2023/10/31星期二总结

软件设计                  石家庄铁道大学信息学院

 

实验3：工厂方法模式

本次实验属于模仿型实验，通过本次实验学生将掌握以下内容：

1、理解工厂方法模式的动机，掌握该模式的结构；

2、能够利用工厂方法模式解决实际问题。

 

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

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

实验要求：

1.画出对应的类图；

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

3.注意编程规范。

1：类图：

 

2：源代码：

Client.java

package moshi;

import java.lang.reflect.AccessibleObject;

import java.util.Scanner;

  

  

  

public class Client {

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) des).work("1787878787878787", "0E329232EA6D0D73");

                    break;

                }

                case 2: {

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

                    break;

                }

                }

            }

        }catch (Exception e) {

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

        }

    }

}

 

DES.java

package moshi;

 

import javax.crypto.Cipher;

import javax.crypto.KeyGenerator;

import javax.crypto.SecretKey;

  

/**

 * 具体方法类DES

 * @author dell

 *

 */

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());

        }

    }

}

 

DESFctory.java

package moshi;

 

public class DESFactory implements MethodFactory {

 

    public DES produceMethod() {

 

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

 

        return new DES();

 

}

 

}

 

IDEA.java

package moshi;

 

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 {

        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

package moshi;

 

public class IDEAFactory implements MethodFactory {

    public IDEA produceMethod() {

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

        return new IDEA();

    }

}

 

 

Method.java

package moshi;

public interface Method {

 public void work(String str, String password);

}

 

 

MethodFactory.java

package moshi;

public interface MethodFactory {

public DES produceMethod();

}