9.18

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

实验3：工厂方法模式
本次实验属于模仿型实验，通过本次实验学生将掌握以下内容：
1、理解工厂方法模式的动机，掌握该模式的结构；
2、能够利用工厂方法模式解决实际问题。

[实验任务一]：加密算法
目前常用的加密算法有DES（Data Encryption Standard）和IDEA（International Data Encryption Algorithm）国际数据加密算法等，请用工厂方法实现加密算法系统。
实验要求：

1. 画出对应的类图；

2. 源代码
   MethodFactory.java

　　

package jiami;

public interface MethodFactory {
public Method produceMethod();
}
DESFactory.java

package jiami;

public class DESFactory implements MethodFactory {
public DES produceMethod() {
System.out.println("使用DES算法");
return new DES();
}
}
IDEAFactory.java

package jiami;

public class IDEAFactory implements MethodFactory {
public IDEA produceMethod() {
System.out.println("使用IDEA算法");
return new IDEA();
}
}
Method.java

package jiami;

public interface Method {
public abstract void work(String str, String password);
}
DES.java

package jiami;

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 codeStringBegin = "信1605-320163432 张运涛"; // 要加密的明文
    String codeStringEnd = null; // 加密后的密文
    String decodeString = null; // 密文解密后得到的明文
    System.out.println("要加密的明文:" + codeStringBegin);
    String cipherType = "DESede"; // 加密算法类型，可设置为DES、DESede、AES等字符串
    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("要加密的字符串是：" + codeStringBegin);
        byte[] codeStringByte = codeStringBegin.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("");
        codeStringEnd = new String(codeStringByteEnd);
        System.out.println("加密后的字符串是：" + codeStringEnd);
        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("");
        decodeString = new String(decodeStringByteEnd);
        System.out.println("解密后的字符串是：" + decodeString);
        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());
    }
}

}
IDEA.java

package jiami;

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.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
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();
}

/**
 * 转换密钥
 * 
 * @param key
 *            二进制密钥
 * @return Key 密钥
 */
private static Key toKey(byte[] key) throws Exception {
    // 实例化DES密钥
    // 生成密钥
    SecretKey secretKey = new SecretKeySpec(key, KEY_ALGORITHM);
    return secretKey;
}

/**
 * 加密数据
 * 
 * @param data
 *            待加密数据
 * @param key
 *            密钥
 * @return byte[] 加密后的数据
 */
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);
}

/**
 * 解密数据
 * 
 * @param data
 *            待解密数据
 * @param key
 *            密钥
 * @return byte[] 解密后的数据
 */
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 = "20163432张运涛";
    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());
    }
}

}
zhuhanshu.java

package jiami;

import java.util.Scanner;

public class zhuhanshu {

public static void main(String[] args) {

    DES des = new DES();
    IDEA idea = new IDEA();
    try {
        int n = 0;

        Scanner in = new Scanner(System.in);
        while (n != 3) {
            System.out.println("请选择要使用的加密算法 1.DES加密算法 2.IDEA加密算法");
            System.out.println("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());
    }
}

}