RSA加密解密，分段加密，分段解密，部分汉字乱码详解

小咪咪 2021-09-25 08:26 750阅读 0赞

在日常的业务逻辑中，难免会遇到需要加密的时候，而常见的MD5加密因为是单向加密并且不可逆，导致应用场景非常的少，而这个时候，RSA对称加密就诞生了。  
RSA加密的逻辑是，生成一个公钥和私钥。  
你可以选择公钥加密，私钥解密，也可以选择 私钥加密，公钥解密。  
一般情况下 都是公钥加密，和私钥解密。

# 一，简单的应用 #

## 1. Java生成密钥 ##

/** * 初始化密钥对 * * @return Map 甲方密钥的Map */
        public static Map<String, Object> initKey() throws Exception { 
            //实例化密钥生成器
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
            //初始化密钥生成器
            //密钥长度，DH算法的默认密钥长度是1024
            //密钥长度必须是64的倍数，在512到65536位之间
            keyPairGenerator.initialize(4096);
            //生成密钥对
            KeyPair keyPair = keyPairGenerator.generateKeyPair();
            //甲方公钥
            RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
            //甲方私钥
            RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
            //将密钥存储在map中
            Map<String, Object> keyMap = new HashMap<String, Object>();
            //公钥
            keyMap.put("RSAPublicKey", publicKey);
            //私钥
            keyMap.put("RSAPrivateKey", privateKey);
            return keyMap;
    
        }

生成密钥对的方式有很多，这里只是简单的说明一下。

## 2. 公钥加密方法 ##

/** * 公钥加密 * * @param data 待加密数据 * @param key 密钥 * @return byte[] 加密数据 */
        public static byte[] encryptByPublicKey(byte[] data, byte[] key) throws Exception { 
    
            //实例化密钥工厂
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            //初始化公钥
            //密钥材料转换
            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);
            //产生公钥
            PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);
    
            //数据加密
            Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
            cipher.init(Cipher.ENCRYPT_MODE, pubKey);
            return cipher.doFinal(data);
        }

## 3. 私钥解密方法 ##

/** * 私钥解密 * * @param data 待解密数据 * @param key 密钥 * @return byte[] 解密数据 */
        public static byte[] decryptByPrivateKey(byte[] data, byte[] key) throws Exception { 
            //取得私钥
            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            //生成私钥
            PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
            //数据解密
            Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
            return cipher.doFinal(data);
        }

## 4. 运行 ##

public static void main(String[] args) throws Exception { 
            //初始化密钥
            //生成密钥对
            Map<String, Object> keyMap = RSACoder.initKey();
            //公钥
            byte[] publicKey = RSACoder.getPublicKey(keyMap);
    
            //私钥
            byte[] privateKey = RSACoder.getPrivateKey(keyMap);
            System.out.println("公钥：/n" + Base64.encodeBase64String(publicKey));
            System.out.println("私钥：/n" + Base64.encodeBase64String(privateKey));
    
            System.out.println("================密钥对构造完毕,开始进行加密数据的传输=============");
            String str = "情人怨遥夜，竟兮起相思。";
            System.out.println("原文："+str);
            //使用公钥对数据进行加密
            byte[] code2 = RSACoder.encryptByPublicKey(str.getBytes(), publicKey);
            System.out.println("===========使用公钥对数据进行加密==============");
            System.out.println("加密后的数据：" + Base64.encodeBase64String(code2));
    
    
            System.out.println("===========使用私钥对数据进行解密==============");
            //甲方使用私钥对数据进行解密
            byte[] decode2 = RSACoder.decryptByPrivateKey(code2, privateKey);
            System.out.println("解密后的数据：" + new String(decode2));
        }

运行结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTY2MjE5_size_16_color_FFFFFF_t_70]  
这个时候 基本的加密解密就完成了。

# 二，问题解答 #

## 1. 数据量太大，加密解密报错。 ##

![在这里插入图片描述][2021043014140954.png]

1.  原因  
    解密有长度限制，长度限制为密钥长度/8；  
    一般来说密钥长度为1024，加密长度为 128 ，加密长度为 117 ，如果字符超过这个数量就会报错。
2.  解决方案  
    采用分段加密解密，计算出来需要加密数据的长度  
    以128分割成多个数组进行加密，  
    以117分割成多个数组进行解密

## 2. 分段加密解密后出现部分中文乱码 ##

1.  原因，加密和解密数据都是要转成byte\[\] 类型的，字符串占字节为3，所以在分割字节的时候，将一个汉字分割成了两个数组的结尾和开头，这样就会出现乱码的情况。

## 3. 加密后密文格式不是是这个格式的 ##

chgHTkMMibvlnbb+50AhHQyCXxrW9Wgjm34p/sCEtAlflU037by5t5dL3w01UIm99VOzfqcZUul7HLdqFanZcCXA5G3ILwZvNZJu19OR5svFS8af6RikS8vkr+26P5yJwD2BfxaY/DDeh3dZGxEkrr/p842vgDw0JalqPRq6C/e5DdHScHKzxyinEq6RZjLEP7m4KwztuSygzRXXgzG/eVphO+kVMiCF5Q7OXbhEIOQLsmTVa530dW3/MQ6BALgIwYx8jMg31rMSRuSgWNVGu5yupi71fA4rDMHK23rnBBDc0bPj+7NdqBXj+AsFSlc+fpWo/+h5Orqhmdk6jm5NCfsXW9Hn+fBLIul/pIQryY9XMoA0nAdNrMarX8HGkQQi40L58r4N8X6RZL369n9b/ytGdctZ6A1MI83hn4r2mhJU43pMw7ce+h9tvye3/ctP4J1uJLcoedThScgR9WaO5GFWk7mgalyAOSlPYiVr+T1SXBnrh+zYH68T++IKyWxt9AfSghntYDt9Oa09wf0Rdj1lUPQsxpo8VVHd9WuCTlLZR3J1Ym12pO9vgSUXbSPpBrrPef94ZwbWvjGMtpYGKQiR7d5FAk3qTOT/qodIxQjWd/mGk+5DSB8hh6yHqdwKHPzG81ibLrSyK/1e7EXYuGB2fXYdlJPlPxhfI5r1Qtc=

1.  原因：密文格式不一样的原因是你的原数据的编码格式的问题，我全部采用的utf-8；

# 附上我的工具类 #

package com.tysu.mall.core.util;
    
    /** * 创建时间:2019/01/10 * 创建人:Administrator * 描述: */
    
    import javax.crypto.Cipher;
    import java.io.ByteArrayOutputStream;
    import java.security.*;
    import java.security.interfaces.RSAPrivateKey;
    import java.security.interfaces.RSAPublicKey;
    import java.security.spec.PKCS8EncodedKeySpec;
    import java.security.spec.X509EncodedKeySpec;
    import java.util.Base64;
    import java.util.HashMap;
    import java.util.Map;
    
    /** * 1、公钥加密，私钥解密用于信息加密 * 2、私钥加密，公钥解密用于数字签名 */
    public class RsaTool{ 
    
        //定义加密方式
        public static final String KEY_RSA = "RSA";
        //定义公钥关键词
        public static final String KEY_RSA_PUBLICKEY = "RSAPublicKey";
        //定义私钥关键词
        public static final String KEY_RSA_PRIVATEKEY = "RSAPrivateKey";
        //定义签名算法
        private final static String KEY_RSA_SIGNATURE = "MD5withRSA";
        /** * ** * RSA最大加密大小 */
        private final static int MAX_ENCRYPT_BLOCK = 117;
    
        /** * ** * RSA最大解密大小 */
        private final static int MAX_DECRYPT_BLOCK = 128;
    
        /** * 生成公私密钥对 */
        public static Map<String, Object> init()
        { 
            Map<String, Object> map = null;
            try
            { 
                KeyPairGenerator generator = KeyPairGenerator.getInstance(KEY_RSA);
                //设置密钥对的bit数，越大越安全，但速度减慢，一般使用512或1024
                generator.initialize(1024);
                KeyPair keyPair = generator.generateKeyPair();
                // 获取公钥
                RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
                // 获取私钥
                RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
                // 将密钥对封装为Map
                map = new HashMap<String, Object>();
                map.put(KEY_RSA_PUBLICKEY, publicKey);
                map.put(KEY_RSA_PRIVATEKEY, privateKey);
            } catch (NoSuchAlgorithmException e)
            { 
                e.printStackTrace();
            }
    
            return map;
        }
    
        /** * 获取Base64编码的公钥字符串 */
        public static String getPublicKey(Map<String, Object> map)
        { 
            String str = "";
            Key key = (Key) map.get(KEY_RSA_PUBLICKEY);
            str = encryptBase64(key.getEncoded());
            return str;
        }
    
        /** * 获取Base64编码的私钥字符串 */
        public static String getPrivateKey(Map<String, Object> map)
        { 
            String str = "";
            Key key = (Key) map.get(KEY_RSA_PRIVATEKEY);
            str = encryptBase64(key.getEncoded());
            return str;
        }
    
        /** * BASE64 解码 * * @param key 需要Base64解码的字符串 * @return 字节数组 */
        public static byte[] decryptBase64(String key)
        { 
            return Base64.getDecoder().decode(key);
        }
    
        /** * BASE64 编码 * * @param key 需要Base64编码的字节数组 * @return 字符串 */
        public static String encryptBase64(byte[] key)
        { 
            return new String(Base64.getEncoder().encode(key));
        }
    
        /** * 公钥加密 * * @param encryptingStr * @param publicKeyStr * @return */
        public static String encryptByPublicKey(String encryptingStr, String publicKeyStr)
        { 
            try
            { 
                // 将公钥由字符串转为UTF-8格式的字节数组
                byte[] publicKeyBytes = decryptBase64(publicKeyStr);
                // 获得公钥
                X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKeyBytes);
                // 取得待加密数据
                byte[] data = encryptingStr.getBytes("UTF-8");
                KeyFactory factory;
                factory = KeyFactory.getInstance(KEY_RSA);
                PublicKey publicKey = factory.generatePublic(keySpec);
                // 对数据加密
                Cipher cipher = Cipher.getInstance(factory.getAlgorithm());
                cipher.init(Cipher.ENCRYPT_MODE, publicKey);
                // 返回加密后由Base64编码的加密信息
                int inputLen = data.length;
                ByteArrayOutputStream out = new ByteArrayOutputStream();
                int offSet = 0;
                byte[] cache;
                int i = 0;
                // 对数据分段解密
                while (inputLen - offSet > 0)
                { 
                    if (inputLen - offSet > MAX_ENCRYPT_BLOCK)
                    { 
                        cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
                    } else
                    { 
                        cache = cipher.doFinal(data, offSet, inputLen - offSet);
                    }
                    out.write(cache, 0, cache.length);
                    i++;
                    offSet = i * MAX_ENCRYPT_BLOCK;
                }
                byte[] decryptedData = out.toByteArray();
                out.close();
                return encryptBase64(decryptedData);
            } catch (Exception e)
            { 
                e.printStackTrace();
            }
    
            return null;
        }
    
        /** * 私钥解密 * * @param encryptedStr * @param privateKeyStr * @return */
        public static String decryptByPrivateKey(String encryptedStr, String privateKeyStr)
        { 
            try
            { 
                // 对私钥解密
                byte[] privateKeyBytes = decryptBase64(privateKeyStr);
                // 获得私钥
                PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKeyBytes);
                // 获得待解密数据
                byte[] data = decryptBase64(encryptedStr);
                KeyFactory factory = KeyFactory.getInstance(KEY_RSA);
                PrivateKey privateKey = factory.generatePrivate(keySpec);
                // 对数据解密
                Cipher cipher = Cipher.getInstance(factory.getAlgorithm());
                cipher.init(Cipher.DECRYPT_MODE, privateKey);
                // 返回UTF-8编码的解密信息
                int inputLen = data.length;
                ByteArrayOutputStream out = new ByteArrayOutputStream();
                int offSet = 0;
                byte[] cache;
                int i = 0;
                // 对数据分段解密
                while (inputLen - offSet > 0)
                { 
                    if (inputLen - offSet > MAX_DECRYPT_BLOCK)
                    { 
                        cache = cipher.doFinal(data, offSet, MAX_DECRYPT_BLOCK);
                    } else
                    { 
                        cache = cipher.doFinal(data, offSet, inputLen - offSet);
                    }
                    out.write(cache, 0, cache.length);
                    i++;
                    offSet = i * MAX_DECRYPT_BLOCK;
                }
                byte[] decryptedData = out.toByteArray();
                out.close();
                return new String(decryptedData, "UTF-8");
            } catch (Exception e)
            { 
                e.printStackTrace();
            }
    
            return null;
        }
    
        /** * 私钥加密 * * @param encryptingStr * @param privateKeyStr * @return */
        public static String encryptByPrivateKey(String encryptingStr, String privateKeyStr)
        { 
            try
            { 
                byte[] privateKeyBytes = decryptBase64(privateKeyStr);
                // 获得私钥
                PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKeyBytes);
                // 取得待加密数据
                byte[] data = encryptingStr.getBytes("UTF-8");
                KeyFactory factory = KeyFactory.getInstance(KEY_RSA);
                PrivateKey privateKey = factory.generatePrivate(keySpec);
                // 对数据加密
                Cipher cipher = Cipher.getInstance(factory.getAlgorithm());
                cipher.init(Cipher.ENCRYPT_MODE, privateKey);
                // 返回加密后由Base64编码的加密信息
                int inputLen = data.length;
                ByteArrayOutputStream out = new ByteArrayOutputStream();
                int offSet = 0;
                byte[] cache;
                int i = 0;
                // 对数据分段解密
                while (inputLen - offSet > 0)
                { 
                    if (inputLen - offSet > MAX_ENCRYPT_BLOCK)
                    { 
                        cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
                    } else
                    { 
                        cache = cipher.doFinal(data, offSet, inputLen - offSet);
                    }
                    out.write(cache, 0, cache.length);
                    i++;
                    offSet = i * MAX_ENCRYPT_BLOCK;
                }
                byte[] decryptedData = out.toByteArray();
                out.close();
                return encryptBase64(decryptedData);
            } catch (Exception e)
            { 
                e.printStackTrace();
            }
    
            return null;
        }
    
        /** * 公钥解密 * * @param encryptedStr * @param publicKeyStr * @return */
        public static String decryptByPublicKey(String encryptedStr, String publicKeyStr)
        { 
            try
            { 
                // 对公钥解密
                byte[] publicKeyBytes = decryptBase64(publicKeyStr);
                // 取得公钥
                X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKeyBytes);
                // 取得待加密数据
                byte[] data = decryptBase64(encryptedStr);
                KeyFactory factory = KeyFactory.getInstance(KEY_RSA);
                PublicKey publicKey = factory.generatePublic(keySpec);
                // 对数据解密
                Cipher cipher = Cipher.getInstance(factory.getAlgorithm());
                cipher.init(Cipher.DECRYPT_MODE, publicKey);
                // 返回UTF-8编码的解密信息
                int inputLen = data.length;
                ByteArrayOutputStream out = new ByteArrayOutputStream();
                int offSet = 0;
                byte[] cache;
                int i = 0;
                // 对数据分段解密
                while (inputLen - offSet > 0)
                { 
                    if (inputLen - offSet > MAX_DECRYPT_BLOCK)
                    { 
                        cache = cipher.doFinal(data, offSet, MAX_DECRYPT_BLOCK);
                    } else
                    { 
                        cache = cipher.doFinal(data, offSet, inputLen - offSet);
                    }
                    out.write(cache, 0, cache.length);
                    i++;
                    offSet = i * MAX_DECRYPT_BLOCK;
                }
                byte[] decryptedData = out.toByteArray();
                out.close();
                return new String(decryptedData, "UTF-8");
            } catch (Exception e)
            { 
                e.printStackTrace();
            }
    
            return null;
        }
    
        /** * 用私钥对加密数据进行签名 * * @param encryptedStr * @param privateKey * @return */
        public static String sign(String encryptedStr, String privateKey)
        { 
            String str = "";
            try
            { 
                //将私钥加密数据字符串转换为字节数组
                byte[] data = encryptedStr.getBytes();
                // 解密由base64编码的私钥
                byte[] bytes = decryptBase64(privateKey);
                // 构造PKCS8EncodedKeySpec对象
                PKCS8EncodedKeySpec pkcs = new PKCS8EncodedKeySpec(bytes);
                // 指定的加密算法
                KeyFactory factory = KeyFactory.getInstance(KEY_RSA);
                // 取私钥对象
                PrivateKey key = factory.generatePrivate(pkcs);
                // 用私钥对信息生成数字签名
                Signature signature = Signature.getInstance(KEY_RSA_SIGNATURE);
                signature.initSign(key);
                signature.update(data);
                str = encryptBase64(signature.sign());
            } catch (Exception e)
            { 
                e.printStackTrace();
            }
            return str;
        }
    
        /** * 校验数字签名 * * @param encryptedStr * @param publicKey * @param sign * @return 校验成功返回true，失败返回false */
        public static boolean verify(String encryptedStr, String publicKey, String sign)
        { 
            boolean flag = false;
            try
            { 
                //将私钥加密数据字符串转换为字节数组
                byte[] data = encryptedStr.getBytes();
                // 解密由base64编码的公钥
                byte[] bytes = decryptBase64(publicKey);
                // 构造X509EncodedKeySpec对象
                X509EncodedKeySpec keySpec = new X509EncodedKeySpec(bytes);
                // 指定的加密算法
                KeyFactory factory = KeyFactory.getInstance(KEY_RSA);
                // 取公钥对象
                PublicKey key = factory.generatePublic(keySpec);
                // 用公钥验证数字签名
                Signature signature = Signature.getInstance(KEY_RSA_SIGNATURE);
                signature.initVerify(key);
                signature.update(data);
                flag = signature.verify(decryptBase64(sign));
            } catch (Exception e)
            { 
                e.printStackTrace();
            }
            return flag;
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTY2MjE5_size_16_color_FFFFFF_t_70]: /images/20210923/28c0dc86bccd4ed5990557e234196ad7.png
[2021043014140954.png]: /images/20210923/b8bd3df960d54e27bd2919370ef3a413.png