首页 > 其他分享 >软件设计3

软件设计3

时间：2023-11-07 16:34:44浏览次数：33  
标签：String 软件设计 System println data public out

[实验任务一]：加密算法

目前常用的加密算法有DES（Data Encryption Standard）和IDEA（International Data Encryption Algorithm）国际数据加密算法等，请用工厂方法实现加密算法系统。

实验要求：

1. 画出对应的类图；

 

 

2. 提交该系统的代码，该系统务必是一个可以能够直接使用的系统，查阅资料完成相应加密算法的实现；

//Client.java

import java.lang.reflect.AccessibleObject;

import java.util.Scanner;

 

import sun.misc.Unsafe;

 

public class Client {

 

    public static void disableWarning() {

        try {

            java.lang.reflect.Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");

            ((AccessibleObject) theUnsafe).setAccessible(true);

            Unsafe u = (Unsafe) theUnsafe.get(null);

            Class<?> cls = Class.forName("jdk.internal.module.IllegalAccessLogger");

            java.lang.reflect.Field logger = cls.getDeclaredField("logger");

            u.putObjectVolatile(cls, u.staticFieldOffset(logger), null);

        } catch (Exception e) {

        }

    }

 

    public static void main(String[] args) {

        disableWarning();

 

        DES des = new DES();

        IDEA idea = new IDEA();

        try {

            int n = 0;

 

            @SuppressWarnings("resource")

            Scanner in = new Scanner(System.in);

            while (n != 3) {

                System.out.println("请选择要使用的加密算法 1.DES加密算法 2.IDEA加密算法 3.退出");

                System.out.println("请选择：");

                if (in.hasNextInt()) {

                    n = in.nextInt();

                } else {

                    System.out.println("输入的不是整数，请重新输入：");

                    continue;

                }

                switch (n) {

                case 1: {

 

                    des.work("1787878787878787", "0E329232EA6D0D73");

                    break;

                }

                case 2: {

                    idea.work("8787878787878787", "0E329232EA6D0D73");

                    break;

                }

                }

            }

        }catch (Exception e) {

            System.out.println(e.getMessage());

        }

    }

}

//DES.java

import javax.crypto.Cipher;

import javax.crypto.KeyGenerator;

import javax.crypto.SecretKey;

 

 

public class DES implements Method{

     public void work(String str, String password) {

            String begincode = "人生苦短及时行乐"; // 要加密的明文

            String endcode = null; // 加密后的密文

            String opencode = null; // 密文解密后得到的明文

            System.out.println("要加密的明文:" + begincode);

            String cipherType = "DESede"; // 加密算法类型，可设置为DES(56)、DESede(112)、AES等字符串(128)

            try {

                // 获取密钥生成器

                KeyGenerator keyGen = KeyGenerator.getInstance(cipherType);

                // 初始化密钥生成器，不同的加密算法其密钥长度可能不同

                keyGen.init(112);

                // 生成密钥

                SecretKey key = keyGen.generateKey();

                // 得到密钥字节码

                byte[] keyByte = key.getEncoded();

                // 输出密钥的字节码

                System.out.println("密钥是：");

                for (int i = 0; i < keyByte.length; i++) {

                    System.out.print(keyByte[i] + ",");

                }

                System.out.println("");

                // 创建密码器

                Cipher cp = Cipher.getInstance(cipherType);

                // 初始化密码器

                cp.init(Cipher.ENCRYPT_MODE, key);

                System.out.println("要加密的字符串是：" + begincode);

                byte[] codeStringByte = begincode.getBytes("UTF8");

                System.out.println("要加密的字符串对应的字节码是：");

                for (int i = 0; i < codeStringByte.length; i++) {

                    System.out.print(codeStringByte[i] + ",");

                }

                System.out.println("");

                // 开始加密

                byte[] codeStringByteEnd = cp.doFinal(codeStringByte);

                System.out.println("加密后的字符串对应的字节码是：");

                for (int i = 0; i < codeStringByteEnd.length; i++) {

                    System.out.print(codeStringByteEnd[i] + ",");

                }

                System.out.println("");

                endcode = new String(codeStringByteEnd);

                System.out.println("加密后的字符串是：" + endcode);

                System.out.println("");

                // 重新初始化密码器

                cp.init(Cipher.DECRYPT_MODE, key);

                // 开始解密

                byte[] decodeStringByteEnd = cp.doFinal(codeStringByteEnd);

                System.out.println("解密后的字符串对应的字节码是：");

                for (int i = 0; i < decodeStringByteEnd.length; i++) {

                    System.out.print(decodeStringByteEnd[i] + ",");

                }

                System.out.println("");

                opencode = new String(decodeStringByteEnd);

                System.out.println("解密后的字符串是：" + opencode);

                System.out.println("");

            } catch (Exception e) {

                e.printStackTrace();

            }

        }

 

        public static void main(String[] args) {

            // TODO Auto-generated method stub

            System.out.println("DES加密算法");

            DES des = new DES();

            try {

                des.work("8787878787878787", "0E329232EA6D0D73");

 

            } catch (Exception e) {

                System.out.println(e.getMessage());

            }

        }

    

}

//DESFactory.java

public class DESFactory implements MethodFactory {

    public DES produceMethod() {

        System.out.println("使用DES算法");

        return new DES();

    }

}

//IDEA.java

import javax.crypto.Cipher;

import javax.crypto.KeyGenerator;

import javax.crypto.SecretKey;

import org.apache.commons.codec.binary.Base64;

import org.bouncycastle.jce.provider.BouncyCastleProvider;

 

 

import javax.crypto.spec.SecretKeySpec;

import java.security.Key;

import java.security.Security;

 

public class IDEA implements Method {

 

    public static final String KEY_ALGORITHM = "IDEA";

 

    public static final String CIPHER_ALGORITHM = "IDEA/ECB/ISO10126Padding";

 

    public static byte[] initkey() throws Exception {

        // 加入bouncyCastle支持

        Security.addProvider(new BouncyCastleProvider());

 

        // 实例化密钥生成器

        KeyGenerator kg = KeyGenerator.getInstance(KEY_ALGORITHM);

        // 初始化密钥生成器，IDEA要求密钥长度为128位

        kg.init(128);

        // 生成密钥

        SecretKey secretKey = kg.generateKey();

        // 获取二进制密钥编码形式

        return secretKey.getEncoded();

    }

 

 

    private static Key toKey(byte[] key) throws Exception {

        // 实例化DES密钥

        // 生成密钥

        SecretKey secretKey = new SecretKeySpec(key, KEY_ALGORITHM);

        return secretKey;

    }

 

 

    private static byte[] encrypt(byte[] data, byte[] key) throws Exception {

        // 加入bouncyCastle支持

        Security.addProvider(new BouncyCastleProvider());

        // 还原密钥

        Key k = toKey(key);

        // 实例化

        Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);

        // 初始化，设置为加密模式

        cipher.init(Cipher.ENCRYPT_MODE, k);

        // 执行操作

        return cipher.doFinal(data);

    }

 

 

    private static byte[] decrypt(byte[] data, byte[] key) throws Exception {

        // 加入bouncyCastle支持

        Security.addProvider(new BouncyCastleProvider());

        // 还原密钥

        Key k = toKey(key);

        Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);

        // 初始化，设置为解密模式

        cipher.init(Cipher.DECRYPT_MODE, k);

        // 执行操作

        return cipher.doFinal(data);

    }

 

    public static String getKey() {

        String result = null;

        try {

            result = Base64.encodeBase64String(initkey());

        } catch (Exception e) {

            e.printStackTrace();

        }

        return result;

    }

 

    public static String ideaEncrypt(String data, String key) {

        String result = null;

        try {

            byte[] data_en = encrypt(data.getBytes(), Base64.decodeBase64(key));

            result = Base64.encodeBase64String(data_en);

        } catch (Exception e) {

            e.printStackTrace();

        }

        return result;

    }

 

    public static String ideaDecrypt(String data, String key) {

        String result = null;

        try {

            byte[] data_de = decrypt(Base64.decodeBase64(data), Base64.decodeBase64(key));

            ;

            result = new String(data_de);

        } catch (Exception e) {

            e.printStackTrace();

        }

        return result;

    }

 

    public void work(String str, String password) {

        String data = "人生苦短及时行乐"; // 要加密的明文

        String key = getKey();

        System.out.println("要加密的原文：" + data);

        System.out.println("密钥：" + key);

        String data_en = ideaEncrypt(data, key);

        System.out.println("密文：" + data_en);

        String data_de = ideaDecrypt(data_en, key);

        System.out.println("原文：" + data_de);

    }

 

    public static void main(String[] args) {

        // TODO Auto-generated method stub

        System.out.println("IDEA加密算法");

        IDEA idea = new IDEA();

        try {

            idea.work("8787878787878787", "0E329232EA6D0D73");

        } catch (Exception e) {

            System.out.println(e.getMessage());

        }

    }

 

}

//IDEAFactory.java

public class IDEAFactory implements MethodFactory {

    public IDEA produceMethod() {

        System.out.println("使用IDEA算法");

        return new IDEA();

    }

}

//Method.java

public interface Method {

    public void work(String str, String password);

 

}

//MethodFactory.java

public interface MethodFactory {

    

    public Method produceMethod();

 

}

3.注意编程规范。

标签：String,软件设计,System,println,data,public,out
From： https://www.cnblogs.com/renliqin/p/17815305.html

相关文章

  • 软件设计2
    [实验任务一]：女娲造人使用简单工厂模式模拟女娲(Nvwa)造人(Person)，如果传入参数M，则返回一个Man对象，如果传入参数W，则返回一个Woman对象，如果传入参数R，则返回一个Robot对象。请用程序设计实现上述场景。实验要求：1. 画出对应的类图；  2. 提交源代码；1 packagenvwa; ......
  • 番外-软件设计（5）
    实现一个双向适配器，使得猫可以学狗叫，狗可以学猫抓老鼠。实验要求：1. 画出对应的类图；2.提交源代码；#include<iostream>usingnamespacestd;classCat{public:    virtualvoidmiao()=0;    virtualvoidcatchs()=0;};classDog{public:    virtualvoid......
  • 番外-软件设计（6）
    用桥接模式实现在路上开车这个问题，其中，车可以是car或bus，路可以是水泥路或沥青路。实验要求：1. 画出对应的类图；2.提交源代码；packagetest9; publicclassBusimplementsTransport{    @Override    publicvoidrun(){        System.out.print("Bus"......
  • 软件设计1
    [实验任务一]：UML复习阅读教材第一章复习UML，回答下述问题：面向对象程序设计中类与类的关系都有哪几种？分别用类图实例说明。1,关联关系  2，依赖关系  3，泛化关系  4，接口与实现关系    [实验任务二]：单一职责原则登录模块在实际项目开发中很常见，请按照教......
  • 番外-软件设计（3）
    用C++完成数学中向量的封装，其中，用指针和动态申请支持向量长度的改变，使用浅克隆和深克隆复制向量类，比较这两种克隆方式的异同。实验要求：1. 画出对应的类图；2.提交源代码（用C++完成）；#include "stdafx.h"using namespace std; class AbstractVector{public: virtual ......
  • 番外-软件设计（4）
    仿照课堂的身份证的例子，实现每个同学仅有一个学号这一问题。实验要求：1. 画出对应的类图；2.提交源代码；1.Clientpackage Singleton_pattern; public class Client{public static void main(String[] args){StudentIDstu1,stu2;stu1=StudentID.getStudentID();......
  • 软件设计实验7：单例模式
    实验7：单例模式本次实验属于模仿型实验，通过本次实验学生将掌握以下内容：1、理解单例模式的动机，掌握该模式的结构；2、能够利用单列模式解决实际问题。 [实验任务一]：学号的单一仿照课堂的身份证的例子，实现每个同学仅有一个学号这一问题。实验要求：1. 画出对应的类图；  2......
  • 软件设计实验6：原型模式
     实验6：原型模式本次实验属于模仿型实验，通过本次实验学生将掌握以下内容：1、理解原型模式的动机，掌握该模式的结构；2、能够利用原型模式解决实际问题。 [实验任务一]：向量的原型用C++完成数学中向量的封装，其中，用指针和动态申请支持向量长度的改变，使用浅克隆和深克隆复制向量......
  • 软件设计实验4：抽象工厂模式
    实验4：抽象工厂模式本次实验属于模仿型实验，通过本次实验学生将掌握以下内容：1、理解抽象工厂模式的动机，掌握该模式的结构；2、能够利用抽象工厂模式解决实际问题。 [实验任务一]：人与肤色使用抽象工厂模式，完成下述产品等级结构： 实验要求：1. 画出对应的类图； 2. 提交源代......
  • 软件设计实验5：建造者模式
    实验5：建造者模式本次实验属于模仿型实验，通过本次实验学生将掌握以下内容：1、理解建造者模式的动机，掌握该模式的结构；2、能够利用建造者模式解决实际问题。 [实验任务一]：计算机组装使用建造者模式，完成下述任务：计算机组装工厂可以将CPU、内存、硬盘、主机等硬件设备组装在一起......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99