devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

RSA加密实现之JAVA方式_java rsa加密

作者：我家自动化 | 2024-05-21 05:51:51

赞

踩

java rsa加密
  1. package com.xxxx.tax.util;
  2. import com.xxxxx.tax.util.ExceptionUtil;
  3.  
  4. import lombok.extern.log4j.Log4j;
  5.  
  6. import java.io.ByteArrayOutputStream;
  7. import java.security.Key;
  8. import java.security.KeyFactory;
  9. import java.security.KeyPair;
  10. import java.security.KeyPairGenerator;
  11. import java.security.PrivateKey;
  12. import java.security.PublicKey;
  13. import java.security.Signature;
  14. import java.security.interfaces.RSAPrivateKey;
  15. import java.security.interfaces.RSAPublicKey;
  16. import java.security.spec.PKCS8EncodedKeySpec;
  17. import java.security.spec.X509EncodedKeySpec;
  18. import java.util.HashMap;
  19. import java.util.Map;
  20. import org.apache.commons.codec.binary.Base64;
  21. import javax.crypto.Cipher;
  22.  
  23.  
  24. @Log4j
  25. public class RSAUtils {
  26.  
  27.     /** *//**
  28.      * 加密算法RSA
  29.      */
  30.     public static final String KEY_ALGORITHM = "RSA";
  31.     
  32.     /** *//**
  33.      * 签名算法
  34.      */
  35.     public static final String SIGNATURE_ALGORITHM = "MD5withRSA";
  36.  
  37.     /** *//**
  38.      * 获取公钥的key
  39.      */
  40.     private static final String PUBLIC_KEY = "RSAPublicKey";
  41.     
  42.     /** *//**
  43.      * 获取私钥的key
  44.      */
  45.     private static final String PRIVATE_KEY = "RSAPrivateKey";
  46.     
  47.     /** *//**
  48.      * RSA最大加密明文大小
  49.      */
  50.     private static final int MAX_ENCRYPT_BLOCK = 117;
  51.     
  52.     /** *//**
  53.      * RSA最大解密密文大小
  54.      */
  55.     private static final int MAX_DECRYPT_BLOCK = 128;
  56.  
  57.     /** *//**
  58.      * <p>
  59.      * 生成密钥对(公钥和私钥)
  60.      * </p>
  61.      * 
  62.      * @return
  63.      * @throws Exception
  64.      */
  65.     public static Map<String, Object> genKeyPair() throws Exception {
  66.         KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
  67.         keyPairGen.initialize(1024);
  68.         KeyPair keyPair = keyPairGen.generateKeyPair();
  69.         RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
  70.         RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
  71.         Map<String, Object> keyMap = new HashMap<String, Object>(2);
  72.         
  73. 		String publicKeyString = new String(Base64Util.encode(publicKey.getEncoded()));  
  74. 		// 得到私钥字符串  
  75. 		String privateKeyString = new String(Base64Util.encode((privateKey.getEncoded())));  
  76. 		
  77.         System.out.println(publicKeyString);
  78.         System.out.println(privateKeyString);
  79.         keyMap.put(PUBLIC_KEY, publicKey);
  80.         keyMap.put(PRIVATE_KEY, privateKey);
  81.         return keyMap;
  82.     }
  83.     
  84.     /** *//**
  85.      * <p>
  86.      * 用私钥对信息生成数字签名
  87.      * </p>
  88.      * 
  89.      * @param data 已加密数据
  90.      * @param privateKey 私钥(BASE64编码)
  91.      * 
  92.      * @return
  93.      * @throws Exception
  94.      */
  95.     public static String sign(byte[] data, String privateKey) throws Exception {
  96.         byte[] keyBytes = Base64Util.decode(privateKey);
  97.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
  98.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  99.         PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
  100.         Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
  101.         signature.initSign(privateK);
  102.         signature.update(data);
  103.         return Base64Util.encode(signature.sign());
  104.     }
  105.  
  106.     /** *//**
  107.      * <p>
  108.      * 校验数字签名
  109.      * </p>
  110.      * 
  111.      * @param data 已加密数据
  112.      * @param publicKey 公钥(BASE64编码)
  113.      * @param sign 数字签名
  114.      * 
  115.      * @return
  116.      * @throws Exception
  117.      * 
  118.      */
  119.     public static boolean verify(byte[] data, String publicKey, String sign)
  120.             throws Exception {
  121.         byte[] keyBytes = Base64Util.decode(publicKey);
  122.         X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
  123.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  124.         PublicKey publicK = keyFactory.generatePublic(keySpec);
  125.         Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
  126.         signature.initVerify(publicK);
  127.         signature.update(data);
  128.         return signature.verify(Base64Util.decode(sign));
  129.     }
  130.  
  131.     /** *//**
  132.      * <P>
  133.      * 私钥解密
  134.      * </p>
  135.      * 
  136.      * @param encryptedData 已加密数据
  137.      * @param privateKey 私钥(BASE64编码)
  138.      * @return
  139.      * @throws Exception
  140.      */
  141.     public static String decryptByPrivateKey(byte[] encryptedData, String privateKey)
  142.             throws Exception {
  143.         byte[] keyBytes = Base64Util.decode(privateKey);
  144.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
  145.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  146.         Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
  147.         Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
  148.         cipher.init(Cipher.DECRYPT_MODE, privateK);
  149.         int inputLen = encryptedData.length;
  150.         ByteArrayOutputStream out = new ByteArrayOutputStream();
  151.         int offSet = 0;
  152.         byte[] cache;
  153.         int i = 0;
  154.         // 对数据分段解密
  155.         while (inputLen - offSet > 0) {
  156.             if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
  157.                 cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
  158.             } else {
  159.                 cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
  160.             }
  161.             out.write(cache, 0, cache.length);
  162.             i++;
  163.             offSet = i * MAX_DECRYPT_BLOCK;
  164.         }
  165.         byte[] decryptedData = out.toByteArray();
  166.         out.close();
  167.         return Base64Util.encode(decryptedData);
  168.     }
  169.     
  170.     /**
  171.      * 公钥解密
  172.      *
  173.      * @param publicKeyText
  174.      * @param text
  175.      * @return
  176.      * @throws Exception
  177.      */
  178.     public static String decryptByPublicKey(String publicKeyText, String text) throws Exception {
  179.         X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(Base64.decodeBase64(publicKeyText));
  180.         KeyFactory keyFactory = KeyFactory.getInstance("RSA");
  181.         PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
  182.         Cipher cipher = Cipher.getInstance("RSA");
  183.         cipher.init(Cipher.DECRYPT_MODE, publicKey);
  184.         byte[] result = cipher.doFinal(Base64.decodeBase64(text));
  185.         return new String(result);
  186.     }
  187.  
  188.     /** *//**
  189.      * <p>
  190.      * 公钥解密
  191.      * </p>
  192.      * 
  193.      * @param encryptedData 已加密数据
  194.      * @param publicKey 公钥(BASE64编码)
  195.      * @return
  196.      * @throws Exception
  197.      */
  198.     public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey)
  199.             throws Exception {
  200.         byte[] keyBytes = Base64Util.decode(publicKey);
  201.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
  202.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  203.         Key publicK = keyFactory.generatePublic(x509KeySpec);
  204.         Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
  205.         cipher.init(Cipher.DECRYPT_MODE, publicK);
  206.         int inputLen = encryptedData.length;
  207.         ByteArrayOutputStream out = new ByteArrayOutputStream();
  208.         int offSet = 0;
  209.         byte[] cache;
  210.         int i = 0;
  211.         // 对数据分段解密
  212.         while (inputLen - offSet > 0) {
  213.             if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
  214.                 cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
  215.             } else {
  216.                 cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
  217.             }
  218.             out.write(cache, 0, cache.length);
  219.             i++;
  220.             offSet = i * MAX_DECRYPT_BLOCK;
  221.         }
  222.         byte[] decryptedData = out.toByteArray();
  223.         out.close();
  224.         return decryptedData;
  225.     }
  226.  
  227.     /** *//**
  228.      * <p>
  229.      * 公钥加密
  230.      * </p>
  231.      * 
  232.      * @param data 源数据
  233.      * @param publicKey 公钥(BASE64编码)
  234.      * @return
  235.      * @throws Exception
  236.      */
  237.     public static String encryptByPublicKey(byte[] data, String publicKey)
  238.             throws Exception {
  239.         byte[] keyBytes = Base64Util.decode(publicKey);
  240.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
  241.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  242.         Key publicK = keyFactory.generatePublic(x509KeySpec);
  243.         // 对数据加密
  244.         Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
  245.         cipher.init(Cipher.ENCRYPT_MODE, publicK);
  246.         int inputLen = data.length;
  247.         ByteArrayOutputStream out = new ByteArrayOutputStream();
  248.         int offSet = 0;
  249.         byte[] cache;
  250.         int i = 0;
  251.         // 对数据分段加密
  252.         while (inputLen - offSet > 0) {
  253.             if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
  254.                 cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
  255.             } else {
  256.                 cache = cipher.doFinal(data, offSet, inputLen - offSet);
  257.             }
  258.             out.write(cache, 0, cache.length);
  259.             i++;
  260.             offSet = i * MAX_ENCRYPT_BLOCK;
  261.         }
  262.         byte[] encryptedData = out.toByteArray();
  263.         out.close();
  264.         //return Base64Util.encode(encryptedData);
  265.         return bytesToHexString(encryptedData);
  266.     }
  267.     
  268.     /** *//**
  269.      * <p>
  270.      * 公钥加密
  271.      * </p>
  272.      * 
  273.      * @param data 源数据
  274.      * @param publicKey 公钥(BASE64编码)
  275.      * @return
  276.      * @throws Exception
  277.      */
  278.     public static String encryptByPublicKeyByBase(byte[] data, String publicKey)
  279.             throws Exception {
  280.         byte[] keyBytes = Base64Util.decode(publicKey);
  281.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
  282.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  283.         Key publicK = keyFactory.generatePublic(x509KeySpec);
  284.         // 对数据加密
  285.         Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
  286.         cipher.init(Cipher.ENCRYPT_MODE, publicK);
  287.         int inputLen = data.length;
  288.         ByteArrayOutputStream out = new ByteArrayOutputStream();
  289.         int offSet = 0;
  290.         byte[] cache;
  291.         int i = 0;
  292.         // 对数据分段加密
  293.         while (inputLen - offSet > 0) {
  294.             if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
  295.                 cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
  296.             } else {
  297.                 cache = cipher.doFinal(data, offSet, inputLen - offSet);
  298.             }
  299.             out.write(cache, 0, cache.length);
  300.             i++;
  301.             offSet = i * MAX_ENCRYPT_BLOCK;
  302.         }
  303.         byte[] encryptedData = out.toByteArray();
  304.         out.close();
  305.         return Base64Util.encode(encryptedData);
  306.        // return bytesToHexString(encryptedData);
  307.     }
  308.     
  309.     /**
  310.      * 将字节数组转换成16进制字符串
  311.      * @param bytes  即将转换的数据
  312.      * @return 16进制字符串
  313.      */
  314.     public static String bytesToHexString(byte[] bytes) {
  315.         StringBuffer sb = new StringBuffer(bytes.length);
  316.         String temp = null;
  317.         for (int i = 0; i < bytes.length; i++) {
  318.             temp = Integer.toHexString(0xFF & bytes[i]);
  319.             if (temp.length() < 2) {
  320.                 sb.append(0);
  321.             }
  322.             sb.append(temp);
  323.         }
  324.         return sb.toString();
  325.     }
  326.  
  327.     /** *//**
  328.      * <p>
  329.      * 私钥加密
  330.      * </p>
  331.      * 
  332.      * @param data 源数据
  333.      * @param privateKey 私钥(BASE64编码)
  334.      * @return
  335.      * @throws Exception
  336.      */
  337.     public static byte[] encryptByPrivateKey(byte[] data, String privateKey)
  338.             throws Exception {
  339.         byte[] keyBytes = Base64Util.decode(privateKey);
  340.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
  341.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  342.         Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
  343.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
  344.         cipher.init(Cipher.ENCRYPT_MODE, privateK);
  345.         int inputLen = data.length;
  346.         ByteArrayOutputStream out = new ByteArrayOutputStream();
  347.         int offSet = 0;
  348.         byte[] cache;
  349.         int i = 0;
  350.         // 对数据分段加密
  351.         while (inputLen - offSet > 0) {
  352.             if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
  353.                 cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
  354.             } else {
  355.                 cache = cipher.doFinal(data, offSet, inputLen - offSet);
  356.             }
  357.             out.write(cache, 0, cache.length);
  358.             i++;
  359.             offSet = i * MAX_ENCRYPT_BLOCK;
  360.         }
  361.         byte[] encryptedData = out.toByteArray();
  362.         out.close();
  363.         return encryptedData;
  364.     }
  365.  
  366.     /** *//**
  367.      * <p>
  368.      * 获取私钥
  369.      * </p>
  370.      * 
  371.      * @param keyMap 密钥对
  372.      * @return
  373.      * @throws Exception
  374.      */
  375.     public static String getPrivateKey(Map<String, Object> keyMap)
  376.             throws Exception {
  377.         Key key = (Key) keyMap.get(PRIVATE_KEY);
  378.         return Base64Util.encode(key.getEncoded());
  379.     }
  380.  
  381.     /** *//**
  382.      * <p>
  383.      * 获取公钥
  384.      * </p>
  385.      * 
  386.      * @param keyMap 密钥对
  387.      * @return
  388.      * @throws Exception
  389.      */
  390.     public static String getPublicKey(Map<String, Object> keyMap)
  391.             throws Exception {
  392.         Key key = (Key) keyMap.get(PUBLIC_KEY);
  393.         return Base64Util.encode(key.getEncoded());
  394.     }
  395.     
  396.     public static void main(String[] args){
  397.     	try {
  398. 			//RSAUtils.genKeyPair();
  399.     		
  400.     		String IMAGE_PRIVATEKEY = "MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBALwNwRLuWJo7gzOIJDQSa2tnsu52bEESmI1yC+/pPEQ4tqXiuyhAqctwFXY97qLakUBdoGs/4CcjU9yTVjFMBE5kyaQncF83TwIoDyZlS5VoYL8gcNXt9RTemlURVYXpu1WxoOD60X6T24uUrko4AiEpu5E2HtmNypELxlJUPWqrAgMBAAECgYA3Mv5adTXyx8dCSBMAaeu4Ei9WidJK44997V0NpfO3vsH2PXBcZ2avvY2/MHystuVt9E2TTaOZOWhzVZg2Ti7w5j/L3P9WpgSB4M4Rpy2WaI31cLLu9cmRgfuQCNHJKwevlp9h144F65XJpHJjkCyP/rW5QvPRtoA/d0ujA4C10QJBAPY+HW5wl139ALfRVJx/GHdxMNLsJskJPwLAT/+vJu5eVerF3d/nQgpuDyEmNN0GvNhrZ/liP1i9IWBsy26TlJMCQQDDgV75r2TEt8wp4mqKP9ufm4tkmidsPlAAsx8G8/ETffekROv9ksWjSdTxvcQ5Z7AFfVq4NFKiXMOG86pwqniJAkAgvMda7HsjUsSqq5jtKXSORK0yDZVmeuU2r2yzWIz7ee1ARkgmQW+lRVabmKHElOW8fCMZo7c6TALI+A3fyJ0jAkEArgw2aUJkC101PPR8tKc09lqbNeymvA6dWoIcVSxGqnuyQ2O4U/6eREgucyfl0NUmNzzpzqOGDVVYHIRAcBzTQQJACt5qNapy/2id4m4KigEcEuNAVmjRL82fXeRdoNbCfch7xWDnszPR1vSXxR1uE2lXD0E2SBbRXOJSwuZpVhDPKw==";
  401.     		String IMAGE_PUBLICKEY = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC8DcES7liaO4MziCQ0EmtrZ7LudmxBEpiNcgvv6TxEOLal4rsoQKnLcBV2Pe6i2pFAXaBrP+AnI1Pck1YxTAROZMmkJ3BfN08CKA8mZUuVaGC/IHDV7fUU3ppVEVWF6btVsaDg+tF+k9uLlK5KOAIhKbuRNh7ZjcqRC8ZSVD1qqwIDAQAB";
  402.  
  403.     		String str = "IfdCNJNKQzzG0bspKMPPmFPQ6lC82HeM5+fnBVym+6wJw24T51WgPY81RE4JTmFo95LttN0EBZPSPs2awj1pKYtC4o51vXSOI/mtt0RbUKwcvOXDZBzcHFv/kmYgGK/NakU0k0GCGwagbUnMf7oubiX0STNBOwZ+FNbOsTfxbK4eGGJ5O5447Q38GKvw+YZswwjCwb7h0BgGjwwHy2fRfllbd6c8fP1zV3ENIVBwIK03jjlodNdK7uaSBEo90YSuYVN7t5hmmHEx9XTU1vC7de3oHYXlGS8ospkgo+DPzaNGpmGz940I3jVXzOkhlTJ6c3v4FTH3byl/Novc9EU1409JcKS0sq/eYRSgGtvS8C/baxXknjl3eyoGBK5TfZ+Y32FJqkvof5j+NR98oA4zHClOLRuvqtuVET6kP++kut+JvnRObUJUTuTVn716Jpr50QRAcAbnLEvzyBy5ln20fxNn2dTUokJbyB4oZZFP+oYw61ysrV8pXk+tclT2r/Sns41oXt9oniKsGqIgxDmCQCOg6rghDPKVoYJGVIbCS8O1iB+KQ73B0TCfSlfLpZXbnsK91rAA9t3bOvBc8QQ0HXkFY9bDzOgntf8ftWvl6Eq9wA4Z+o63dCuJXI3fVWv5nrTllK//PQ6wI2od0cVsJ96vXZC1nXlKZZWfQaaceOKf4Wcm6qWIUzG0qy35bZyR1CxWwzMUve1e2dgzeuT23XOsJvCyPMf4JTpkm+Xhr7gpqoRBRsVLi8mU1ObIYCtWbGs87L6FdFrhRljXw9BPOXJXczqXupQFFujlb4vnte8/3JT0v56qh/JKv6R0Fj4MsDieIqE9RKZrLt85ulVwoWTWuhTF1VdtBx0062tcI7/HG539S2X30YGTKpPLWAL/zsmSYoFR6uZm0nM+gwHA8kR+EYK+XAVvPNcb/ULKkhUq0ZaaT3Rbsz04UMmXiVFanOtmDIAsAsnq8fAuuInpzn/vhqEXofGADtrgg5SlMAg5Czw3koycIR1YxuQBxnNjGRpJA9pJR3BMy3/Fyus8GD4mGIwnIwfHKvyuWuYTx2LzvKQRQa/qf3u2w0Wl3mC6is9hubvPg/njv/PiB7mJbz/Ec3+r1nfPXBwAvFM7gj59KEhvJuFo04HwjEaSl7XZGMh3YKlsTZnmRrArBNZzhBGxt3mRUZ0sZ93Yev2QUaw=";
  404.     		String res = new String(Base64Util.decode(RSAUtils.decryptByPrivateKey(Base64Util.decode(str), IMAGE_PRIVATEKEY)));
  405.     		System.out.println(res);
  406.     		
  407.     		String ss = RSAUtils.encryptByPublicKey("abcdef".getBytes(), IMAGE_PUBLICKEY);
  408.     		System.out.println(ss);
  409. 		} catch (Exception e) {
  410. 			log.error(ExceptionUtil.getMessage(e));
  411. 		}
  412.     }
  413.  
  414. }

如有问题，请私信。

xObP8s/gudi/zrPMoaJKU7K5u7e+s7/Os8yhokpBVkHP4LnYv86zzMjn0OjSqtKyv8nS1MGqz7VRUaGjDQoNCtf31d8gUVEgNDA0NTQwMjI5

题，请私信

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/601135
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号