SHA256withRSA 完美工具类 RSAUtils

ゞ 浴缸里的玫瑰 2021-12-03 18:29 728阅读 0赞

SHA256withRSA 完美工具类 RSAUtils，包含：

  1. 1、签名
  2. 2、验签
  3. 3、公钥加密》私钥解密
  4. 4、私钥加密》公钥解密

代码：RSAUtils.java

  1. import java.io.File;
  2. import java.io.FileInputStream;
  3. import java.io.FileNotFoundException;
  4. import java.io.IOException;
  5. import java.io.InputStream;
  6. import java.io.UnsupportedEncodingException;
  7. import java.security.InvalidKeyException;
  8. import java.security.Key;
  9. import java.security.KeyFactory;
  10. import java.security.KeyPair;
  11. import java.security.KeyPairGenerator;
  12. import java.security.KeyStore;
  13. import java.security.NoSuchAlgorithmException;
  14. import java.security.PrivateKey;
  15. import java.security.PublicKey;
  16. import java.security.SecureRandom;
  17. import java.security.Signature;
  18. import java.security.cert.CertificateException;
  19. import java.security.cert.CertificateFactory;
  20. import java.security.cert.X509Certificate;
  21. import java.security.interfaces.RSAPrivateKey;
  22. import java.security.interfaces.RSAPublicKey;
  23. import java.security.spec.InvalidKeySpecException;
  24. import java.security.spec.PKCS8EncodedKeySpec;
  25. import java.security.spec.X509EncodedKeySpec;
  26. import java.util.Enumeration;
  27. import java.util.HashMap;
  28. import java.util.Map;
  30. import javax.crypto.BadPaddingException;
  31. import javax.crypto.Cipher;
  32. import javax.crypto.IllegalBlockSizeException;
  33. import javax.crypto.NoSuchPaddingException;
  35. import org.apache.commons.codec.binary.Base64;
  36. import org.apache.commons.lang3.ArrayUtils;
  37. import org.slf4j.Logger;
  38. import org.slf4j.LoggerFactory;
  40. /**
  41.  * SHA256withRSA
  42.  * 
  43.  * @author 单红宇
  44.  * @date 2019年7月18日
  45.  *
  46.  */
  47. public class RSAUtils {
  49.     private static final Logger logger = LoggerFactory.getLogger(RSAUtils.class);
  52.     // MAX_DECRYPT_BLOCK应等于密钥长度/8（1byte=8bit），所以当密钥位数为2048时，最大解密长度应为256.
  53.     // 128 对应 1024，256对应2048
  54.     private static final int KEYSIZE = 2048;
  56.     // RSA最大加密明文大小
  57.     private static final int MAX_ENCRYPT_BLOCK = 117;
  59.     // RSA最大解密密文大小
  60.     private static final int MAX_DECRYPT_BLOCK = 128;
  62.     // 不仅可以使用DSA算法，同样也可以使用RSA算法做数字签名
  63.     private static final String KEY_ALGORITHM = "RSA";
  64.     private static final String SIGNATURE_ALGORITHM = "SHA256withRSA";
  66.     public static final String DEFAULT_SEED = "$%^*%^()(ED47d784sde78"; // 默认种子
  68.     public static final String PUBLIC_KEY = "PublicKey";
  69.     public static final String PRIVATE_KEY = "PrivateKey";
  71.     /**
  72.      * 
  73.      * 生成密钥
  74.      * 
  75.      * @param seed 种子
  76.      * 
  77.      * @return 密钥对象
  78.      * @throws Exception
  79.      * 
  80.      */
  82.     public static Map<String, Key> initKey(String seed) throws Exception {
  83.         logger.info("生成密钥");
  84.         KeyPairGenerator keygen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
  85.         SecureRandom secureRandom = new SecureRandom();
  86.         // 如果指定seed，那么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);
  90.         KeyPair keys = keygen.genKeyPair();
  91.         PrivateKey privateKey = keys.getPrivate();
  92.         PublicKey publicKey = keys.getPublic();
  93.         Map<String, Key> map = new HashMap<>(2);
  94.         map.put(PUBLIC_KEY, publicKey);
  95.         map.put(PRIVATE_KEY, privateKey);
  96.         return map;
  97.     }
  99.     /**
  100.      * 
  101.      * 生成默认密钥
  102.      *
  103.      * 
  104.      * @return 密钥对象
  105.      * @throws Exception
  106.      * 
  107.      */
  109.     public static Map<String, Key> initKey() throws Exception {
  110.         return initKey(DEFAULT_SEED);
  111.     }
  113.     /**
  114.      * 
  115.      * 取得私钥
  116.      * 
  117.      * @param keyMap
  118.      * 
  119.      * @return
  120.      * @throws Exception
  121.      * 
  122.      */
  123.     public static String getPrivateKey(Map<String, Key> keyMap) throws Exception {
  124.         Key key = (Key) keyMap.get(PRIVATE_KEY);
  125.         return encryptBASE64(key.getEncoded()); // base64加密私钥
  126.     }
  128.     /**
  129.      * 
  130.      * 取得公钥
  131.      * 
  132.      * @param keyMap
  133.      * 
  134.      * @return
  135.      * @throws Exception
  136.      * 
  137.      */
  138.     public static String getPublicKey(Map<String, Key> keyMap) throws Exception {
  139.         Key key = (Key) keyMap.get(PUBLIC_KEY);
  140.         return encryptBASE64(key.getEncoded()); // base64加密公钥
  141.     }
  143.     /**
  144.      * 
  145.      * 用私钥对信息进行数字签名
  146.      * 
  147.      * @param data       加密数据
  148.      * 
  149.      * @param privateKey 私钥-base64加密的
  150.      * 
  151.      * @return
  152.      * 
  153.      * @throws Exception
  154.      * 
  155.      */
  156.     public static String signByPrivateKey(byte[] data, String privateKey) throws Exception {
  157.         logger.info("用私钥对信息进行数字签名");
  158.         byte[] keyBytes = decryptBASE64(privateKey);
  159.         PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
  160.         KeyFactory factory = KeyFactory.getInstance(KEY_ALGORITHM);
  161.         PrivateKey priKey = factory.generatePrivate(keySpec);// 生成私钥
  162.         // 用私钥对信息进行数字签名
  163.         Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
  164.         signature.initSign(priKey);
  165.         signature.update(data);
  166.         return encryptBASE64(signature.sign());
  168.     }
  170.     /**
  171.      * 
  172.      * BASE64Encoder 加密
  173.      * 
  174.      * @param data 要加密的数据
  175.      * 
  176.      * @return 加密后的字符串
  177.      * 
  178.      */
  179.     private static String encryptBASE64(byte[] data) {
  180. //        BASE64Encoder encoder = new BASE64Encoder();
  181. //        String encode = encoder.encode(data);
  182. //        return encode;
  183.         return new String(Base64.encodeBase64(data));
  184.     }
  186.     private static byte[] decryptBASE64(String data) {
  187.         // BASE64Decoder 每76个字符换行
  188. //        BASE64Decoder decoder = new BASE64Decoder();
  189. //        byte[] buffer = decoder.decodeBuffer(data);
  190. //        return buffer;
  191.         // codec 的 Base64 不换行
  192.         return Base64.decodeBase64(data);
  193.     }
  195.     public static boolean verifyByPublicKey(byte[] data, String publicKey, String sign) throws Exception {
  196.         byte[] keyBytes = decryptBASE64(publicKey);
  197.         X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
  198.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  199.         PublicKey pubKey = keyFactory.generatePublic(keySpec);
  200.         Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
  201.         signature.initVerify(pubKey);
  202.         signature.update(data);
  203.         return signature.verify(decryptBASE64(sign)); // 验证签名
  204.     }
  206.     /**
  207.      * RSA公钥加密
  208.      * 
  209.      * @param str       加密字符串
  210.      * @param publicKey 公钥
  211.      * @return 密文
  212.      * @throws NoSuchAlgorithmException
  213.      * @throws InvalidKeySpecException
  214.      * @throws NoSuchPaddingException
  215.      * @throws InvalidKeyException
  216.      * @throws UnsupportedEncodingException
  217.      * @throws BadPaddingException
  218.      * @throws IllegalBlockSizeException
  219.      * @throws Exception                    加密过程中的异常信息
  220.      */
  221.     public static String encryptByPublicKey(String str, String publicKey)
  222.             throws InvalidKeySpecException, NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException,
  223.             IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException {
  224.         // base64编码的公钥
  225.         byte[] keyBytes = decryptBASE64(publicKey);
  226.         RSAPublicKey pubKey = (RSAPublicKey) KeyFactory.getInstance(KEY_ALGORITHM)
  227.                 .generatePublic(new X509EncodedKeySpec(keyBytes));
  228.         // RSA加密
  229.         Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);
  230.         cipher.init(Cipher.ENCRYPT_MODE, pubKey);
  232.         byte[] data = str.getBytes("UTF-8");
  233.         // 加密时超过117字节就报错。为此采用分段加密的办法来加密
  234.         byte[] enBytes = null;
  235.         for (int i = 0; i < data.length; i += MAX_ENCRYPT_BLOCK) {
  236.             // 注意要使用2的倍数，否则会出现加密后的内容再解密时为乱码
  237.             byte[] doFinal = cipher.doFinal(ArrayUtils.subarray(data, i, i + MAX_ENCRYPT_BLOCK));
  238.             enBytes = ArrayUtils.addAll(enBytes, doFinal);
  239.         }
  240.         String outStr = encryptBASE64(enBytes);
  241.         return outStr;
  242.     }
  244.     /**
  245.      * RSA私钥加密
  246.      * 
  247.      * @param str       加密字符串
  248.      * @param privateKey 公钥
  249.      * @return 密文
  250.      * @throws NoSuchAlgorithmException
  251.      * @throws InvalidKeySpecException
  252.      * @throws NoSuchPaddingException
  253.      * @throws InvalidKeyException
  254.      * @throws UnsupportedEncodingException
  255.      * @throws BadPaddingException
  256.      * @throws IllegalBlockSizeException
  257.      * @throws Exception                    加密过程中的异常信息
  258.      */
  259.     public static String encryptByPrivateKey(String str, String privateKey)
  260.             throws InvalidKeySpecException, NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException,
  261.             IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException {
  262.         // base64编码的公钥
  263.         byte[] keyBytes = decryptBASE64(privateKey);
  264.         RSAPrivateKey priKey = (RSAPrivateKey) KeyFactory.getInstance(KEY_ALGORITHM)
  265.                 .generatePrivate(new PKCS8EncodedKeySpec(keyBytes));
  266.         // RSA加密
  267.         Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);
  268.         cipher.init(Cipher.ENCRYPT_MODE, priKey);
  270.         byte[] data = str.getBytes("UTF-8");
  271.         // 加密时超过117字节就报错。为此采用分段加密的办法来加密
  272.         byte[] enBytes = null;
  273.         for (int i = 0; i < data.length; i += MAX_ENCRYPT_BLOCK) {
  274.             // 注意要使用2的倍数，否则会出现加密后的内容再解密时为乱码
  275.             byte[] doFinal = cipher.doFinal(ArrayUtils.subarray(data, i, i + MAX_ENCRYPT_BLOCK));
  276.             enBytes = ArrayUtils.addAll(enBytes, doFinal);
  277.         }
  278.         String outStr = encryptBASE64(enBytes);
  279.         return outStr;
  280.     }
  282.     /**
  283.      * 读取公钥
  284.      * 
  285.      * @param publicKeyPath
  286.      * @return
  287.      */
  288.     public static PublicKey readPublic(String publicKeyPath) {
  289.         if (publicKeyPath != null) {
  290.             try (FileInputStream bais = new FileInputStream(publicKeyPath)) {
  291.                 CertificateFactory certificatefactory = CertificateFactory.getInstance("X.509");
  292.                 X509Certificate cert = (X509Certificate) certificatefactory.generateCertificate(bais);
  293.                 return cert.getPublicKey();
  294.             } catch (CertificateException e) {
  295.                 logger.error(e.getMessage(), e);
  296.             } catch (FileNotFoundException e) {
  297.                 logger.error(e.getMessage(), e);
  298.             } catch (IOException e) {
  299.                 logger.error(e.getMessage(), e);
  300.             }
  301.         }
  302.         return null;
  303.     }
  305.     /**
  306.      * 读取私钥
  307.      * 
  308.      * @param path
  309.      * @return
  310.      */
  311.     public static PrivateKey readPrivate(String privateKeyPath, String privateKeyPwd) {
  312.         if (privateKeyPath == null || privateKeyPwd == null) {
  313.             return null;
  314.         }
  315.         try (InputStream stream = new FileInputStream(new File(privateKeyPath));) {
  316.             // 获取JKS 服务器私有证书的私钥，取得标准的JKS的 KeyStore实例
  317.             KeyStore store = KeyStore.getInstance("JKS");// JKS，二进制格式，同时包含证书和私钥，一般有密码保护；PKCS12，二进制格式，同时包含证书和私钥，一般有密码保护。
  318.             // jks文件密码，根据实际情况修改
  319.             store.load(stream, privateKeyPwd.toCharArray());
  320.             // 获取jks证书别名
  321.             Enumeration<String> en = store.aliases();
  322.             String pName = null;
  323.             while (en.hasMoreElements()) {
  324.                 String n = (String) en.nextElement();
  325.                 if (store.isKeyEntry(n)) {
  326.                     pName = n;
  327.                 }
  328.             }
  329.             // 获取证书的私钥
  330.             PrivateKey key = (PrivateKey) store.getKey(pName, privateKeyPwd.toCharArray());
  331.             return key;
  332.         } catch (Exception e) {
  333.             logger.error(e.getMessage(), e);
  334.         }
  335.         return null;
  336.     }
  338.     /**
  339.      * RSA私钥解密
  340.      * 
  341.      * @param encryStr   加密字符串
  342.      * @param privateKey 私钥
  343.      * @return 铭文
  344.      * @throws NoSuchAlgorithmException
  345.      * @throws InvalidKeySpecException
  346.      * @throws NoSuchPaddingException
  347.      * @throws BadPaddingException
  348.      * @throws IllegalBlockSizeException
  349.      * @throws InvalidKeyException
  350.      * @throws Exception                 解密过程中的异常信息
  351.      */
  352.     public static String decryptByPrivateKey(String encryStr, String privateKey)
  353.             throws InvalidKeySpecException, NoSuchAlgorithmException, NoSuchPaddingException, IllegalBlockSizeException,
  354.             BadPaddingException, InvalidKeyException {
  355.         // base64编码的私钥
  356.         byte[] decoded = decryptBASE64(privateKey);
  357.         RSAPrivateKey priKey = (RSAPrivateKey) KeyFactory.getInstance(KEY_ALGORITHM)
  358.                 .generatePrivate(new PKCS8EncodedKeySpec(decoded));
  359.         // RSA解密
  360.         Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);
  361.         cipher.init(Cipher.DECRYPT_MODE, priKey);
  363.         // 64位解码加密后的字符串
  364.         byte[] data = decryptBASE64(encryStr);
  365.         // 解密时超过128字节报错。为此采用分段解密的办法来解密
  366.         StringBuilder sb = new StringBuilder();
  367.         for (int i = 0; i < data.length; i += MAX_DECRYPT_BLOCK) {
  368.             byte[] doFinal = cipher.doFinal(ArrayUtils.subarray(data, i, i + MAX_DECRYPT_BLOCK));
  369.             sb.append(new String(doFinal));
  370.         }
  372.         return sb.toString();
  373.     }
  375.     /**
  376.      * RSA公钥解密
  377.      * 
  378.      * @param encryStr   加密字符串
  379.      * @param privateKey 私钥
  380.      * @return 铭文
  381.      * @throws NoSuchAlgorithmException
  382.      * @throws InvalidKeySpecException
  383.      * @throws NoSuchPaddingException
  384.      * @throws BadPaddingException
  385.      * @throws IllegalBlockSizeException
  386.      * @throws InvalidKeyException
  387.      * @throws Exception                 解密过程中的异常信息
  388.      */
  389.     public static String decryptByPublicKey(String encryStr, String publicKey)
  390.             throws InvalidKeySpecException, NoSuchAlgorithmException, NoSuchPaddingException, IllegalBlockSizeException,
  391.             BadPaddingException, InvalidKeyException {
  392.         // base64编码的私钥
  393.         byte[] decoded = decryptBASE64(publicKey);
  394.         RSAPublicKey priKey = (RSAPublicKey) KeyFactory.getInstance(KEY_ALGORITHM)
  395.                 .generatePublic(new X509EncodedKeySpec(decoded));
  396.         // RSA解密
  397.         Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);
  398.         cipher.init(Cipher.DECRYPT_MODE, priKey);
  400.         // 64位解码加密后的字符串
  401.         byte[] data = decryptBASE64(encryStr);
  402.         // 解密时超过128字节报错。为此采用分段解密的办法来解密
  403.         StringBuilder sb = new StringBuilder();
  404.         for (int i = 0; i < data.length; i += MAX_DECRYPT_BLOCK) {
  405.             byte[] doFinal = cipher.doFinal(ArrayUtils.subarray(data, i, i + MAX_DECRYPT_BLOCK));
  406.             sb.append(new String(doFinal));
  407.         }
  409.         return sb.toString();
  410.     }
  412.     /**
  413.      * main方法测试 第一种用法：公钥加密，私钥解密。---用于加解密 第二种用法：私钥签名，公钥验签。---用于签名
  414.      * 
  415.      * @param args
  416.      * @throws Exception
  417.      */
  418.     public static void main(String[] args) throws Exception {
  419.         String ss = "hello";
  420.         byte[] data = ss.getBytes();
  421.         Map<String, Key> keyMap = initKey();// 构建密钥
  422.         PublicKey publicKey = (PublicKey) keyMap.get(PUBLIC_KEY);
  423.         PrivateKey privateKey = (PrivateKey) keyMap.get(PRIVATE_KEY);
  424.         logger.info("私钥format：{}", privateKey.getFormat());
  425.         logger.info("公钥format：{}", publicKey.getFormat());
  426.         logger.info("私钥string：{}", getPrivateKey(keyMap));
  427.         logger.info("公钥string：{}", getPublicKey(keyMap));
  428.         // 产生签名
  429.         String sign = signByPrivateKey(data, getPrivateKey(keyMap));
  430.         logger.info("签名sign={}", sign);
  431.         // 验证签名
  432.         boolean verify1 = verifyByPublicKey(ss.getBytes(), getPublicKey(keyMap), sign);
  433.         logger.info("经验证数据和签名匹配：{} ", verify1);
  434.         boolean verify = verifyByPublicKey(data, getPublicKey(keyMap), sign);
  435.         logger.error("经验证数据和签名匹配：{} ", verify);
  436.         // logger.info("数字签名为"+sign);
  438.         String s = "单红宇测试，e8986ae53e76e7514ebc7e8a42e81e6cea5b6280fb5d3259d5f0a46f9f6e090c";
  439.         String encryStr = encryptByPublicKey(s, getPublicKey(keyMap));
  440.         logger.info("字符串 {} 的公钥加密结果为：{}", s, encryStr);
  441.         String decryStr = decryptByPrivateKey(encryStr, getPrivateKey(keyMap));
  442.         logger.info("私钥解密结果为：{}", decryStr);
  443.         logger.info("========================================================================================");
  444.         String s2 = "单红宇测试222，e8986ae53e76e7514ebc7e8a42e81e6cea5b6280fb5d3259d5f0a46f9f6e090c";
  445.         String encryStr2 = encryptByPrivateKey(s, getPrivateKey(keyMap));
  446.         logger.info("字符串 {} 的私钥加密结果为：{}", s2, encryStr2);
  447.         String decryStr2 = decryptByPublicKey(encryStr2, getPublicKey(keyMap));
  448.         logger.info("公钥解密结果为：{}", decryStr2);
  450.     }
  452. }

（END）

发表评论

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

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

相关阅读

    相关 SHA256WithRSA

    在[上文][Link 1]中了解到SHA和RSA，工作中恰好用到扩展应用：SHA256WithRSA，本文总结下学习过程，备忘の 再提供另外一种方法，实现Java版pem密

    妖狐艹你老母妖狐艹你老母/ 0 赞/ 199 阅读