RSA加密解密，签名验签简述 + 完美工具类RSAUtils

你的名字 2022-12-31 12:29 662阅读 0赞

原创博文，欢迎转载，转载时请务必附上博文链接，感谢您的尊重。

系列文章目录

RSA+AES数据传输的加密解密【篇】，项目实战（专题汇总）：

  1. AES 加密解密简述 + 完美工具类 AESUtils
  2. RSA 加密解密，签名验签简述 + 完美工具类 RSAUtils
  3. RSA + AES 加密原理，一线大厂主流的加密手段
  4. RSA 与 AES 加密效率对比，用调研事实说明问题，用算法原理解决疑惑
  5. RSA + AES 混合加密策略，真实项目案例，一线大厂的主流HTTP加密交互方式（正在赶稿）

一、RSA简介

RSA是1977年由罗纳德·李维斯特（Ron Rivest）、阿迪·萨莫尔（Adi Shamir）和伦纳德·阿德曼（Leonard Adleman）一起提出的。当时他们三人都在麻省理工学院工作。RSA就是他们三人姓氏开头字母拼在一起组成的。

20201229193613333.jpg

RSA是被研究得最广泛的公钥算法，从提出到现在已近三十年，经历了各种攻击的考验，逐渐为人们接受，普遍认为是目前最优秀的公钥方案之一。该能够抵抗到目前为止已知的绝大多数密码攻击，已被ISO推荐为公钥数据加密标准。

RSA算法属于非对称加密算法，非对称加密算法需要两个密钥：公开密钥（publickey）和私有密钥（privatekey）。公开密钥与私有密钥是一对，如果用公开密钥对数据进行加密，只有用对应的私有密钥才能解密；如果用私有密钥对数据进行加密，那么只有用对应的公开密钥才能解密。因为加密和解密使用的是两个不同的密钥，所以这种算法叫作非对称加密算法。简单的说是“公钥加密，私钥解密；私钥加密，公钥解密”。

二、参数解释

下面几行是生成 RSA 秘钥对的标准核心代码，我们通过它分析下参数对结果的影响。

  1. // keygen类
  2. KeyPairGenerator keygen = KeyPairGenerator.getInstance("RSA");
  4. // 随机种子
  5. keygen.initialize(2048, new SecureRandom());
  7. // 生成一个密钥对，保存在keyPair中
  8. KeyPair keys = keygen.genKeyPair();
  9. PublicKey publicKey = keys.getPublic();
  10. PrivateKey privateKey = keys.getPrivate();

1. 秘钥长度

RSA密钥是（公钥+模值）、（私钥+模值）分组分发的，单独给对方一个公钥或私钥是没有任何用处，所以我们说的“密钥”其实是它们两者中的其中一组。

而“密钥长度”一般只是指模值的位长度，目前主流可选值：1024、2048、3072、4096… 没有上限，多大都可以使用。但出于安全问题的考虑，低于1024bit的密钥不建议使用。

2. 秘钥种子

初始化keygen时：

  • 如果不指定seed（如上范例所示），而是直接 New 一个 SecureRandom 的随机对象，那生成的公私钥也是随机的；

  • 如果指定seed（如下引用所示），那么 secureRandom 结果是一样的，所以生成的公私钥也永远不会变。

    String seed = “$%^*%^()(ED47d784sde78”;
    SecureRandom secureRandom = new SecureRandom();
    secureRandom.setSeed(seed.getBytes());
    keygen.initialize(2048, secureRandom);

种子 seed 干嘛用？答：非常有用，而且生产中建议使用。

做测试每次都随机无所谓，但是在生产中很必要。

设想我们 new SecureRandom() 随机生成一对RSA秘钥，公钥都已经发给调用方了，结果我的私钥弄丢了，怎么办？只能再生成一对，然后逐一通知调用方进行更换，很尴尬吧。但是，如果我们使用种子seed生成，然后安全的保存了种子，以后就再不怕把公钥、私钥弄丢了。

二、RSAUtils

工具类 RSAUtils，包含：

  1. 生成 RSA 密钥对，包含随机、固定的方法;
  2. RSA 加密与解密，普通方法；
  3. RSA 加密与解密，限制明文大小的方法；
  4. SIGN 签名与验签的方法；

代码：RSAUtils.java

  1. import java.nio.charset.StandardCharsets;
  2. import java.security.Key;
  3. import java.security.KeyFactory;
  4. import java.security.KeyPair;
  5. import java.security.KeyPairGenerator;
  6. import java.security.PrivateKey;
  7. import java.security.PublicKey;
  8. import java.security.SecureRandom;
  9. import java.security.Signature;
  10. import java.security.interfaces.RSAPrivateKey;
  11. import java.security.interfaces.RSAPublicKey;
  12. import java.security.spec.PKCS8EncodedKeySpec;
  13. import java.security.spec.X509EncodedKeySpec;
  14. import java.util.HashMap;
  15. import java.util.Map;
  16. import javax.crypto.Cipher;
  17. import com.alibaba.fastjson.JSON;
  18. import org.apache.commons.codec.binary.Base64;
  19. import org.apache.commons.lang3.ArrayUtils;
  20. import org.slf4j.Logger;
  21. import org.slf4j.LoggerFactory;
  23. /**
  24.  * 功能：SHA256withRSA 工具类
  25.  * 说明：
  26.  * @author Mr.tjm
  27.  * @date 2020-5-20 11:25
  28.  */
  29. @SuppressWarnings("all")
  30. public class RSAUtils {
  31.     private static final Logger logger = LoggerFactory.getLogger(RSAUtils.class);
  33.     // MAX_DECRYPT_BLOCK应等于密钥长度/8（1byte=8bit），所以当密钥位数为2048时，最大解密长度应为256.
  34.     // 128 对应 1024，256对应2048
  35.     private static final int KEYSIZE = 2048;
  36.     // RSA最大加密明文大小
  37.     private static final int MAX_ENCRYPT_BLOCK = 117;
  38.     // RSA最大解密密文大小
  39.     private static final int MAX_DECRYPT_BLOCK = 128;
  41.     // 不仅可以使用DSA算法，同样也可以使用RSA算法做数字签名
  42.     private static final String KEY_ALGORITHM = "RSA";
  43.     private static final String SIGNATURE_ALGORITHM = "SHA256withRSA";
  45.     // 默认种子
  46.     public static final String DEFAULT_SEED = "$%^*%^()(ED47d784sde78";
  47.     // 编码格式
  48.     private static final String CODE_FORMATE_UTF8 = "UTF-8";
  50.     // - - - - - - - - - - - - - - - - - - - - RSA 生成秘钥对 - - - - - - - - - - - - - - - - - - - - //
  51.     /**
  52.      * 生成密钥对：Base64 转码的字符串
  53.      * @param key
  54.      * @return
  55.      */
  56.     public static Map<String, String> initKeyBase64Str() throws Exception {
  57.         Map<String, String> map = new HashMap<>(2);
  58.         Map<String, Key> keyMap = initKey();
  59.         PublicKey publicKey = (PublicKey) keyMap.get("PublicKey");
  60.         PrivateKey privateKey = (PrivateKey) keyMap.get("PrivateKey");
  61.         map.put("PublicKey", new String(Base64.encodeBase64(publicKey.getEncoded())));
  62.         map.put("PrivateKey", new String(Base64.encodeBase64(privateKey.getEncoded())));
  63.         logger.info("生成密钥 = " + JSON.toJSONString(map));
  64.         return map;
  65.     }
  67.     /**
  68.      * 生成默认密钥
  69.      *
  70.      * @return 密钥对象
  71.      */
  72.     public static Map<String, Key> initKey() throws Exception {
  73.         return initKey(DEFAULT_SEED);
  74.     }
  76.     /**
  77.      * 生成密钥对：若seed为null，那么结果是随机的；若seed不为null且固定，那么结果也是固定的；
  78.      *
  79.      * @param seed  种子
  80.      * @return      密钥对象
  81.      */
  82.     public static Map<String, Key> initKey(String seed) throws Exception {
  83.         KeyPairGenerator keygen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
  85.         // 如果指定seed，那么secureRandom结果是一样的，所以生成的公私钥也永远不会变
  86.         SecureRandom secureRandom = new SecureRandom();
  87.         secureRandom.setSeed(seed.getBytes());
  88.         // Modulus size must range from 512 to 1024 and be a multiple of 64
  89.         keygen.initialize(KEYSIZE, secureRandom);
  91.         // 生成一个密钥对，保存在keyPair中
  92.         KeyPair keys = keygen.genKeyPair();
  93.         PublicKey publicKey = keys.getPublic();
  94.         PrivateKey privateKey = keys.getPrivate();
  96.         // 将公钥和私钥保存到Map
  97.         Map<String, Key> map = new HashMap<>(2);
  98.         map.put("PublicKey", publicKey);
  99.         map.put("PrivateKey", privateKey);
  100.         logger.info("生成密钥 = " + JSON.toJSONString(map));
  101.         return map;
  102.     }
  104.     // - - - - - - - - - - - - - - - - - - - - RSA 加密、解密 - - - - - - - - - - - - - - - - - - - - //
  105.     /**
  106.      * 获取公钥 PublicKey 信息
  107.      * @param  公钥
  108.      * @return
  109.      */
  110.     public static PublicKey getPublicKey(String pubKeyStr) throws Exception{
  111.         byte[] publicKeys = Base64.decodeBase64(pubKeyStr);
  112.         X509EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(publicKeys);
  113.         KeyFactory mykeyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  114.         PublicKey publicKey = mykeyFactory.generatePublic(publicKeySpec);
  115.         logger.info("传入的公钥为：【" + pubKeyStr + "】，转义后的公钥为：【" + publicKey + "】");
  116.         return publicKey;
  117.     }
  119.     /**
  120.      * 公钥加密，指定 RSA 方式的 PublicKey 对象
  121.      *
  122.      * @param str 加密字符串
  123.      * @param publicKey 公钥
  124.      * @return
  125.      */
  126.     public static String encrypt(String str, String publicKey) throws Exception{
  127.         // base64编码的公钥
  128.         byte[] decoded = Base64.decodeBase64(publicKey);
  129.         RSAPublicKey pubKey = (RSAPublicKey) KeyFactory.getInstance(KEY_ALGORITHM).generatePublic(new X509EncodedKeySpec(decoded));
  130.         // RSA加密
  131.         Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);
  132.         cipher.init(Cipher.ENCRYPT_MODE, pubKey);
  133.         String outStr = Base64.encodeBase64String(cipher.doFinal(str.getBytes(CODE_FORMATE_UTF8)));
  134.         return outStr;
  135.     }
  137.     /**
  138.      * 公钥加密，任意 PublicKey 对象
  139.      *
  140.      * @param publicKey
  141.      * @param encryptData
  142.      * @param encode
  143.      */
  144.     public static String encrypt(PublicKey publicKey, String encryptData, String encode) throws Exception {
  145.         if (publicKey == null) {
  146.             throw new Exception("加密公钥为空，请设置。");
  147.         }
  148.         try {
  149.             final Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);
  150.             cipher.init(Cipher.ENCRYPT_MODE, publicKey);
  151.             byte[] output = cipher.doFinal(encryptData.getBytes(encode));
  152.             return Base64.encodeBase64String(output);
  153.         } catch (Exception e) {
  154.             logger.info("加密异常:"+e.getMessage());
  155.             return null;
  156.         }
  157.     }
  159.     /**
  160.      * 私钥解密，指定 RSA 方式的 PrivateKey 对象
  161.      *
  162.      * @param str 加密字符串
  163.      * @param privateKey 私钥
  164.      * @return
  165.      */
  166.     public static String decrypt(String str, String privateKey) throws Exception{
  167.         // 64位解码加密后的字符串
  168.         byte[] inputByte = Base64.decodeBase64(str.getBytes(CODE_FORMATE_UTF8));
  169.         // base64编码的私钥
  170.         byte[] decoded = Base64.decodeBase64(privateKey);
  171.         RSAPrivateKey priKey = (RSAPrivateKey) KeyFactory.getInstance(KEY_ALGORITHM).generatePrivate(new PKCS8EncodedKeySpec(decoded));
  172.         // RSA解密
  173.         Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);
  174.         cipher.init(Cipher.DECRYPT_MODE, priKey);
  175.         String outStr = new String(cipher.doFinal(inputByte));
  176.         return outStr;
  177.     }
  179.     /**
  180.      * RSA 公钥加密，【限制长度】
  181.      *
  182.      * @param str       加密字符串
  183.      * @param publicKey 公钥
  184.      * @return 密文
  185.      */
  186.     public static String encryptByPublicKey(String str, String publicKey) throws Exception {
  187.         // base64编码的公钥
  188.         byte[] keyBytes = decryptBASE64(publicKey);
  189.         RSAPublicKey pubKey = (RSAPublicKey) KeyFactory.getInstance(KEY_ALGORITHM).generatePublic(new X509EncodedKeySpec(keyBytes));
  190.         // RSA加密
  191.         Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);
  192.         cipher.init(Cipher.ENCRYPT_MODE, pubKey);
  194.         byte[] data = str.getBytes("UTF-8");
  195.         // 加密时超过117字节就报错。为此采用分段加密的办法来加密
  196.         byte[] enBytes = null;
  197.         for (int i = 0; i < data.length; i += MAX_ENCRYPT_BLOCK) {
  198.             // 注意要使用2的倍数，否则会出现加密后的内容再解密时为乱码
  199.             byte[] doFinal = cipher.doFinal(ArrayUtils.subarray(data, i, i + MAX_ENCRYPT_BLOCK));
  200.             enBytes = ArrayUtils.addAll(enBytes, doFinal);
  201.         }
  202.         String outStr = encryptBASE64(enBytes);
  203.         return outStr;
  204.     }
  206.     /**
  207.      * RSA 私钥解密，【限制长度】
  208.      *
  209.      * @param encryStr   加密字符串
  210.      * @param privateKey 私钥
  211.      * @return 明文
  212.      */
  213.     public static String decryptByPrivateKey(String encryStr, String privateKey) throws Exception {
  214.         // base64编码的私钥
  215.         byte[] decoded = decryptBASE64(privateKey);
  216.         RSAPrivateKey priKey = (RSAPrivateKey) KeyFactory.getInstance(KEY_ALGORITHM).generatePrivate(new PKCS8EncodedKeySpec(decoded));
  217.         // RSA解密
  218.         Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);
  219.         cipher.init(Cipher.DECRYPT_MODE, priKey);
  221.         // 64位解码加密后的字符串
  222.         byte[] data = decryptBASE64(encryStr);
  223.         // 解密时超过128字节报错。为此采用分段解密的办法来解密
  224.         StringBuilder sb = new StringBuilder();
  225.         for (int i = 0; i < data.length; i += MAX_DECRYPT_BLOCK) {
  226.             byte[] doFinal = cipher.doFinal(ArrayUtils.subarray(data, i, i + MAX_DECRYPT_BLOCK));
  227.             sb.append(new String(doFinal));
  228.         }
  229.         return sb.toString();
  230.     }
  232.     /**
  233.      * BASE64Encoder 加密
  234.      *
  235.      * @param data 要加密的数据
  236.      * @return 加密后的字符串
  237.      */
  238.     private static String encryptBASE64(byte[] data) {
  239.         return new String(Base64.encodeBase64(data));
  240.     }
  242.     /**
  243.      * BASE64Encoder 解密
  244.      *
  245.      * @param data 要解密的数据
  246.      * @return 解密后的字节
  247.      */
  248.     private static byte[] decryptBASE64(String data) {
  249.         return Base64.decodeBase64(data);
  250.     }
  252.     // - - - - - - - - - - - - - - - - - - - - SIGN 签名，验签 - - - - - - - - - - - - - - - - - - - - //
  253.     /**
  254.      * 加签：生成报文签名
  255.      *
  256.      * @param content       报文内容
  257.      * @param privateKey    私钥
  258.      * @param encode        编码
  259.      * @return
  260.      */
  261.     public static String doSign(String content, String privateKey, String encode) {
  262.         try {
  263.             String unsign = Base64.encodeBase64String(content.getBytes(StandardCharsets.UTF_8));
  264.             byte[] privateKeys = Base64.decodeBase64(privateKey.getBytes());
  265.             PKCS8EncodedKeySpec privateKeySpec = new PKCS8EncodedKeySpec(privateKeys);
  266.             KeyFactory mykeyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  267.             PrivateKey psbcPrivateKey = mykeyFactory.generatePrivate(privateKeySpec);
  268.             Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
  269.             signature.initSign(psbcPrivateKey);
  270.             signature.update(unsign.getBytes(encode));
  271.             byte[] signed = signature.sign();
  272.             return Base64.encodeBase64String(signed);
  273.         } catch (Exception e) {
  274.             logger.error("生成报文签名出现异常");
  275.         }
  276.         return null;
  277.     }
  279.     /**
  280.      * 验证：验证签名信息
  281.      *
  282.      * @param content   签名报文
  283.      * @param signed    签名信息
  284.      * @param publicKey 公钥
  285.      * @param encode    编码格式
  286.      * @return
  287.      */
  288.     public static boolean doCheck(String content, String signed, PublicKey publicKey, String encode) {
  289.         try {
  290.             // 解密之前先把content明文，进行base64转码
  291.             String unsigned = Base64.encodeBase64String(content.getBytes(encode));
  292.             Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
  293.             signature.initVerify(publicKey);
  294.             signature.update(unsigned.getBytes(encode));
  295.             boolean bverify = signature.verify(Base64.decodeBase64(signed));
  296.             return bverify;
  297.         } catch (Exception e) {
  298.             logger.error("报文验证签名出现异常");
  299.         }
  300.         return false;
  301.     }
  302. }

三、秘钥生成网站

如果只是想随机生成一对秘钥用于测试，也可以使用现有网站，笔者推荐一个：https://www.bejson.com/enc/rsa/

《BEJSON —— RSA 公钥私钥，加密解密在线测试》：

2020122920462180.png

我是「IT无知君」，您的点赞、评论和关注，是我创作的动力源泉。
学无止境，气有浩然，让我们一起加油，天涯未远，江湖有缘再见！！

发表评论

表情：
评论列表 （有 0 条评论，662人围观）

还没有评论，来说两句吧...

相关阅读

    相关 加密解密 签名验签

    几个基本概念： 加密:发送方利用接收方的公钥对要发送的明文进行加密。 解密:接受方利用自己的私钥进行解密。 公钥和私钥配对的，用公钥加密的文件，只有对应的私钥才能解密。当

    女爷i女爷i/ 0 赞/ 429 阅读