软件设计——工厂方法模式之加密算法

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

1、类图

2、源代码

2.1  结构目录

2.2  所需jar包

这里分享几个下载 jar 包的网址：

---

http://www.mvnrepository.com/

http://mvnrepository.com/

http://findjar.com

http://sourceforge.net/

---

注：将 jar 包放入 lib 文件夹后要进行构建路径

2.3  MethodFactory.java  （抽象接口）

package test3;
/**
 * 抽象工厂类
 * @author dell
 *
 */
public interface MethodFactory {
	public Method produceMethod();
}

2.4  DESFactory.java

package test3;
/**
 * 具体工厂类DES
 * @author dell
 *
 */
public class DESFactory implements MethodFactory {
    public DES produceMethod() {
        System.out.println("使用DES算法");
        return new DES();
    }
}

2.5  IDEAFactory.java

package test3;
/**
 * 具体工厂类IDEA
 * @author dell
 *
 */
public class IDEAFactory implements MethodFactory {
    public IDEA produceMethod() {
        System.out.println("使用IDEA算法");
        return new IDEA();
    }
}

2.6  Method.java（抽象接口）

package test3;
/**
 * 抽象方法类
 * @author dell
 *
 */
public interface Method {
	 public void work(String str, String password);
}

2.7  DES.java

package test3;

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

2.8  IDEA.java

package test3;

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

    /**
     * 转换密钥
     * 
     * @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 = "人生苦短及时行乐"; // 要加密的明文
        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());
        }
    }

}

2.9  Client.java

package test3;

import java.lang.reflect.AccessibleObject;
import java.util.Scanner;

import sun.misc.Unsafe;

public class Client {
	/*
	 * 去除因JDK版本造成的非法反射警告
	 */
	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());
        }
    }
}

2.10  遇到的问题

2.10.1  调用IDEA算法时出现警告

WARNING: An illegal reflective access operation has occurred
WARNING: Illegal reflective access by org.bouncycastle.jcajce.provider.drbg.DRBG (file:/D:/java/eclipse-workplace/test3/lib/bcprov-jdk15on-1.60.jar) to constructor sun.security.provider.Sun()
WARNING: Please consider reporting this to the maintainers of org.bouncycastle.jcajce.provider.drbg.DRBG
WARNING: Use --illegal-access=warn to enable warnings of further illegal reflective access operations
WARNING: All illegal access operations will be denied in a future release

通过网上查询得知是jdk版本过高的原因，建议使用1.8及以下版本

eclipse 中修改 jdk配置 ：

window ------>  preference ------->Java ------->compiler

window ------>  preference ------->Java ------->Installed JREs

修改过后仍然出现警告，最后找到的解决办法是在 Client . java 中加入一个方法 disableWarning()，警告消失

	/*
     * 去除因JDK版本造成的非法反射警告
     * 
	*/
		
	  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) { } }

2.10.2  输入明文出现死循环

我试图在 DES . java 和 IDEA . java 中，令用户输入明文，进行相对应的加密解密过程。

但是在运行 Client . java 时陷入死循环，尚未解决

有解决的朋友可以联络我一下

3、运行截图

文章来源：https://www.cnblogs.com/zyt-bg/p/9857820.html