Java 使用Cipher类实现加密

野性酷女 2021-07-24 15:11 469阅读 0赞

## 一、先看一个简单加密，解密实现 ##

~~  
**1.1 加密**

/** * content: 加密内容 * slatKey: 加密的盐，16位字符串 * vectorKey: 加密的向量，16位字符串 */
    public String encrypt(String content, String slatKey, String vectorKey) throws Exception { 
        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        SecretKey secretKey = new SecretKeySpec(slatKey.getBytes(), "AES");
        IvParameterSpec iv = new IvParameterSpec(vectorKey.getBytes());
        cipher.init(Cipher.ENCRYPT_MODE, secretKey, iv);
        byte[] encrypted = cipher.doFinal(content.getBytes());
        return Base64.encodeBase64String(encrypted);
    }

**1.2 解密**

/** * content: 解密内容(base64编码格式) * slatKey: 加密时使用的盐，16位字符串 * vectorKey: 加密时使用的向量，16位字符串 *///加入Java开发交流君样：756584822一起吹水聊天
    public String decrypt(String base64Content, String slatKey, String vectorKey) throws Exception { 
        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        SecretKey secretKey = new SecretKeySpec(slatKey.getBytes(), "AES");
        IvParameterSpec iv = new IvParameterSpec(vectorKey.getBytes());
        cipher.init(Cipher.DECRYPT_MODE, secretKey, iv);
        byte[] content = Base64.decodeBase64(base64Content);
        byte[] encrypted = cipher.doFinal(content);
        return new String(encrypted);
    }

**1.3 代码解释**  
上面简单实现了AES(“AES/CBC/PKCS5Padding”)的加密和解密。可以看到代码中主要的是cipher对象，并有以下调用

（1）新建Cipher对象时需要传入一个参数"AES/CBC/PKCS5Padding"

（2）cipher对象使用之前还需要初始化，共三个参数(“加密模式或者解密模式”,“密匙”,“向量”)

（3）调用数据转换：cipher.doFinal(content)，其中content是一个byte数组

实际上Cipher类实现了多种加密算法，在创建Cipher对象时，传入不同的参数就可以进行不同的加密算法。而这些算法不同的地方只是创建密匙的方法不同而已。

如传入“AES/CBC/NoPadding”可进行AES加密，传入"DESede/CBC/NoPadding"可进行DES3加密。具体的后面会介绍到。

要参考Java自带的加密算法，可以参考JDK文档的附录：https://docs.oracle.com/javase/8/docs/technotes/guides/security/StandardNames.html

## 二、Java的Cipher类 ##

**2.1 Cipher类提供了加密和解密的功能。**  
该项目使用Cipher类完成aes，des，des3和rsa加密.

获取Cipher类的对象：Cipher cipher = Cipher.getInstance(“DES/CBC/PKCS5Padding”); 参数按"算法/模式/填充模式"，有以下的参数

*  AES/CBC/NoPadding (128)
 *  AES/CBC/PKCS5Padding (128)
 *  AES/ECB/NoPadding (128)
 *  AES/ECB/PKCS5Padding (128)
 *  DES/CBC/NoPadding (56)
 *  DES/CBC/PKCS5Padding (56)
 *  DES/ECB/NoPadding (56)
 *  DES/ECB/PKCS5Padding (56)
 *  DESede/CBC/NoPadding (168)
 *  DESede/CBC/PKCS5Padding (168)
 *  DESede/ECB/NoPadding (168)
 *  DESede/ECB/PKCS5Padding (168)
 *  RSA/ECB/PKCS1Padding (1024, 2048)
 *  RSA/ECB/OAEPWithSHA-1AndMGF1Padding (1024, 2048)
 *  RSA/ECB/OAEPWithSHA-256AndMGF1Padding (1024, 2048)  
    (1)加密算法有：AES，DES，DESede(DES3)和RSA 四种  
    (2) 模式有CBC(有向量模式)和ECB(无向量模式)，向量模式可以简单理解为偏移量，使用CBC模式需要定义一个IvParameterSpec对象  
    (3) 填充模式:
 *  NoPadding: 加密内容不足8位用0补足8位, Cipher类不提供补位功能，需自己实现代码给加密内容添加0, 如\{65,65,65,0,0,0,0,0\}
 *  PKCS5Padding: 加密内容不足8位用余位数补足8位, 如\{65,65,65,5,5,5,5,5\}或\{97,97,97,97,97,97,2,2\}; 刚好8位补8位8

**2.2 Cipher对象需要初始化**  
init(int opmode, Key key, AlgorithmParameterSpec params)  
(1)opmode ：Cipher.ENCRYPT\_MODE(加密模式)和 Cipher.DECRYPT\_MODE(解密模式)  
(2)key ：密匙，使用传入的盐构造出一个密匙，可以使用SecretKeySpec、KeyGenerator和KeyPairGenerator创建密匙，其中

*  SecretKeySpec和KeyGenerator支持AES，DES，DESede三种加密算法创建密匙
 *  KeyPairGenerator支持RSA加密算法创建密匙  
    (3)params ：使用CBC模式时必须传入该参数，该项目使用IvParameterSpec创建iv 对象

**2.3 加密或解密**  
byte\[\] b = cipher.doFinal(content);  
返回结果为byte数组，如果直接使用 new String(b) 封装成字符串，则会出现乱码

## 三、创建密匙 ##

创建密匙主要使用SecretKeySpec、KeyGenerator和KeyPairGenerator三个类来创建密匙。

3.1 SecretKeySpec类  
　　SecretKeySpec类支持创建密匙的加密算法(ASE,DES,DES3)  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dqMTMxNDI1MA_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dqMTMxNDI1MA_size_16_color_FFFFFF_t_70 1]  
KeyGenerator类支持创建密匙的加密算法(ASE,DES,DES3)  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dqMTMxNDI1MA_size_16_color_FFFFFF_t_70 2]

/** * 获取加密的密匙，传入的slatKey可以是任意长度的，作为SecureRandom的随机种子， * 而在KeyGenerator初始化时设置密匙的长度128bit(16位byte) */
        private static Key getSlatKey(String slatKey) throws Exception { 
            KeyGenerator kgen = KeyGenerator.getInstance("AES");
            SecureRandom random = SecureRandom.getInstance("SHA1PRNG");
            random.setSeed(slatKey.getBytes());
            kgen.init(128, random);
            Key key = kgen.generateKey();
            return key;
        }//加入Java开发交流君样：756584822一起吹水聊天

KeyGenerator对象在初始化需要传入一个随机源。一般使用的都是SecureRandom类来创建随机源，此时传入的盐只作为SecureRandom类的随机种子，种子相同，产生的随机数也相同；  
盐的长度不再受限制了，但KeyGenerator对象则必须指定长度。

**3.3KeyPairGenerator类**  
RSA加密算法使用的密匙是包含公匙和私匙两种，一般情况下，有使用公匙加密，则用私匙解密；使用私匙加密，则使用公匙解密。可以使用KeyPairGenerator类来创建RSA加密算法的密匙

KeyPairGenerator类支持创建密匙的加密算法(RSA)![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dqMTMxNDI1MA_size_16_color_FFFFFF_t_70 3]

/** * 根据slatKey获取公匙，传入的slatKey作为SecureRandom的随机种子 * 若使用new SecureRandom()创建公匙，则需要记录下私匙，解密时使用 */
        private static byte[] getPublicKey(String slatKey) throws Exception { 
            KeyPairGenerator keyPairGenerator  = KeyPairGenerator.getInstance("RSA");
            SecureRandom random = SecureRandom.getInstance("SHA1PRNG");
            random.setSeed(slatKey.getBytes());
            keyPairGenerator.initialize(1024, random);//or 2048
            KeyPair keyPair = keyPairGenerator.generateKeyPair();
            return keyPair.getPublic().getEncoded();
        }
        
        /** * 根据slatKey获取私匙，传入的slatKey作为SecureRandom的随机种子 */
        private static byte[] getPrivateKey(String slatKey) throws Exception { 
            KeyPairGenerator keyPairGenerator  = KeyPairGenerator.getInstance("RSA");
            SecureRandom random = SecureRandom.getInstance("SHA1PRNG");
            random.setSeed(slatKey.getBytes());
            keyPairGenerator.initialize(1024, random);// or 2048
            KeyPair keyPair = keyPairGenerator.generateKeyPair();
            return keyPair.getPrivate().getEncoded();
        }//加入Java开发交流君样：756584822一起吹水聊天

同上，传入的盐只作为SecureRandom类的随机种子，盐相同，产生的keyPair的公匙和私匙也是同一对。  
也可以不设置SecureRandom类的随机种子，直接使用new SecureRandom()创建一个新对象，此时就必须记录下公匙和私匙，在解密时使用。

## 四、对加密结果进行一层包装 ##

4.1 针对1.3返回结果返回字符串乱码的问题，一般对byte数组进行处理  
有两种处理方式：转换为base64的字符串或转换为16进制的字符串

**4.2 转换为base64**  
使用apache下的Base64类进行封装即可，Base64.encodeBase64String(result); 结果形如 qPba5V+b0Ox3Um…  
jar包下载：https://mvnrepository.com/artifact/commons-codec/commons-codec

**4.3 转换为16进制**  
编码实现，即编码实现将2进制转换为16进制

/** * 16进制工具类 */
    public class HexUtil { 
        private static final char[] HEX_CHARS = {  '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
    
        /** * 十六进制转化为二进制 */
        public static byte[] hexStrToByteArray(String hexString) { 
            if (hexString == null) { 
                return null;
            }
            if (hexString.length() == 0) { 
                return new byte[0];
            }//加入Java开发交流君样：756584822一起吹水聊天
            byte[] byteArray = new byte[hexString.length() / 2];
            for (int i = 0; i < byteArray.length; i++) { 
                String subStr = hexString.substring(2 * i, 2 * i + 2);
                byteArray[i] = ((byte) Integer.parseInt(subStr, 16));
            }
            return byteArray;
        }
    
        /** * 二进制转化为十六进制 */
        public static String byteArrayToHexStr(byte[] byteArray) { 
            if (byteArray == null) { 
                return null;
            }
            char[] hexChars = new char[byteArray.length * 2];
            for (int j = 0; j < byteArray.length; j++) { 
                int v = byteArray[j] & 0xFF;
                hexChars[j * 2] = HEX_CHARS[v >>> 4];
                hexChars[j * 2 + 1] = HEX_CHARS[v & 0x0F];
            }
            return new String(hexChars);
        }//加入Java开发交流君样：756584822一起吹水聊天
    }

结果形如 04A2784A45234B…

![image][]

[**最新2020整理收集的一些高频面试题（都整理成文档），有很多干货，包含mysql，netty，spring，线程，spring cloud、jvm、源码、算法等详细讲解，也有详细的学习规划图，面试题整理等，需要获取这些内容的朋友请加Q君样：756584822**][2020_mysql_netty_spring_spring cloud_jvm_Q_756584822]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dqMTMxNDI1MA_size_16_color_FFFFFF_t_70]: /images/20210724/343388891c774c2cb847326965ee5d05.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dqMTMxNDI1MA_size_16_color_FFFFFF_t_70 1]: /images/20210724/2449f2aa19d64291814e864abd2b4a44.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dqMTMxNDI1MA_size_16_color_FFFFFF_t_70 2]: /images/20210724/a18f3134b2574ade81a26461d57beb7f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dqMTMxNDI1MA_size_16_color_FFFFFF_t_70 3]: /images/20210724/ed8b1a4da495459eae24a440c988bc09.png
[image]: /images/20210724/1331eccbcc264efcba9cfe897516dacf.png
[2020_mysql_netty_spring_spring cloud_jvm_Q_756584822]: https://jq.qq.com/?_wv=1027&k=0IsBuUb0