RSA加密算法的工具类

  • A+
所属分类:java 软件工具

流程分析:

甲方构建密钥对,将公钥公布给乙方,将私钥保留。
甲方使用私钥加密数据,然后用私钥对加密后的数据签名,发送给乙方签名以及加密后的数据;乙方使用公钥、签名来验证待解密数据是否有效,如果有效使用公钥对数据解密。
乙方使用公钥加密数据,向甲方发送经过加密后的数据;甲方获得加密数据,通过私钥解密。

 

  1. import org.apache.commons.codec.binary.Base64;
  2. import javax.crypto.Cipher;
  3. import java.security.*;
  4. import java.security.spec.PKCS8EncodedKeySpec;
  5. import java.security.spec.X509EncodedKeySpec;
  6. import java.util.HashMap;
  7. import java.util.Map;
  8. /**
  9.  * RSA加密和解密工具
  10.  *
  11.  * @Author: syj
  12.  * @CreateDate: 2018/7/20 16:52
  13.  */
  14. public class RSAUtil {
  15.     /**
  16.      * 数字签名,密钥算法
  17.      */
  18.     private static final String RSA_KEY_ALGORITHM = "RSA";
  19.     /**
  20.      * 数字签名签名/验证算法
  21.      */
  22.     private static final String SIGNATURE_ALGORITHM = "MD5withRSA";
  23.     /**
  24.      * RSA密钥长度,RSA算法的默认密钥长度是1024密钥长度必须是64的倍数,在512到65536位之间
  25.      */
  26.     private static final int KEY_SIZE = 1024;
  27.     /**
  28.      * 生成密钥对
  29.      */
  30.     private static Map<String, String> initKey() throws Exception {
  31.         KeyPairGenerator keygen = KeyPairGenerator.getInstance(RSA_KEY_ALGORITHM);
  32.         SecureRandom secrand = new SecureRandom();
  33.         /**
  34.          * 初始化随机产生器
  35.          */
  36.         secrand.setSeed("initSeed".getBytes());
  37.         /**
  38.          * 初始化密钥生成器
  39.          */
  40.         keygen.initialize(KEY_SIZE, secrand);
  41.         KeyPair keys = keygen.genKeyPair();
  42.         byte[] pub_key = keys.getPublic().getEncoded();
  43.         String publicKeyString = Base64.encodeBase64String(pub_key);
  44.         byte[] pri_key = keys.getPrivate().getEncoded();
  45.         String privateKeyString = Base64.encodeBase64String(pri_key);
  46.         Map<String, String> keyPairMap = new HashMap<>();
  47.         keyPairMap.put("publicKeyString", publicKeyString);
  48.         keyPairMap.put("privateKeyString", privateKeyString);
  49.         return keyPairMap;
  50.     }
  51.     /**
  52.      * 密钥转成字符串
  53.      *
  54.      * @param key
  55.      * @return
  56.      */
  57.     public static String encodeBase64String(byte[] key) {
  58.         return Base64.encodeBase64String(key);
  59.     }
  60.     /**
  61.      * 密钥转成byte[]
  62.      *
  63.      * @param key
  64.      * @return
  65.      */
  66.     public static byte[] decodeBase64(String key) {
  67.         return Base64.decodeBase64(key);
  68.     }
  69.     /**
  70.      * 公钥加密
  71.      *
  72.      * @param data      加密前的字符串
  73.      * @param publicKey 公钥
  74.      * @return 加密后的字符串
  75.      * @throws Exception
  76.      */
  77.     public static String encryptByPubKey(String data, String publicKey) throws Exception {
  78.         byte[] pubKey = RSAUtil.decodeBase64(publicKey);
  79.         byte[] enSign = encryptByPubKey(data.getBytes(), pubKey);
  80.         return Base64.encodeBase64String(enSign);
  81.     }
  82.     /**
  83.      * 公钥加密
  84.      *
  85.      * @param data   待加密数据
  86.      * @param pubKey 公钥
  87.      * @return
  88.      * @throws Exception
  89.      */
  90.     public static byte[] encryptByPubKey(byte[] data, byte[] pubKey) throws Exception {
  91.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(pubKey);
  92.         KeyFactory keyFactory = KeyFactory.getInstance(RSA_KEY_ALGORITHM);
  93.         PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);
  94.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
  95.         cipher.init(Cipher.ENCRYPT_MODE, publicKey);
  96.         return cipher.doFinal(data);
  97.     }
  98.     /**
  99.      * 私钥加密
  100.      *
  101.      * @param data       加密前的字符串
  102.      * @param privateKey 私钥
  103.      * @return 加密后的字符串
  104.      * @throws Exception
  105.      */
  106.     public static String encryptByPriKey(String data, String privateKey) throws Exception {
  107.         byte[] priKey = RSAUtil.decodeBase64(privateKey);
  108.         byte[] enSign = encryptByPriKey(data.getBytes(), priKey);
  109.         return Base64.encodeBase64String(enSign);
  110.     }
  111.     /**
  112.      * 私钥加密
  113.      *
  114.      * @param data   待加密的数据
  115.      * @param priKey 私钥
  116.      * @return 加密后的数据
  117.      * @throws Exception
  118.      */
  119.     public static byte[] encryptByPriKey(byte[] data, byte[] priKey) throws Exception {
  120.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(priKey);
  121.         KeyFactory keyFactory = KeyFactory.getInstance(RSA_KEY_ALGORITHM);
  122.         PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
  123.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
  124.         cipher.init(Cipher.ENCRYPT_MODE, privateKey);
  125.         return cipher.doFinal(data);
  126.     }
  127.     /**
  128.      * 公钥解密
  129.      *
  130.      * @param data   待解密的数据
  131.      * @param pubKey 公钥
  132.      * @return 解密后的数据
  133.      * @throws Exception
  134.      */
  135.     public static byte[] decryptByPubKey(byte[] data, byte[] pubKey) throws Exception {
  136.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(pubKey);
  137.         KeyFactory keyFactory = KeyFactory.getInstance(RSA_KEY_ALGORITHM);
  138.         PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);
  139.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
  140.         cipher.init(Cipher.DECRYPT_MODE, publicKey);
  141.         return cipher.doFinal(data);
  142.     }
  143.     /**
  144.      * 公钥解密
  145.      *
  146.      * @param data      解密前的字符串
  147.      * @param publicKey 公钥
  148.      * @return 解密后的字符串
  149.      * @throws Exception
  150.      */
  151.     public static String decryptByPubKey(String data, String publicKey) throws Exception {
  152.         byte[] pubKey = RSAUtil.decodeBase64(publicKey);
  153.         byte[] design = decryptByPubKey(Base64.decodeBase64(data), pubKey);
  154.         return new String(design);
  155.     }
  156.     /**
  157.      * 私钥解密
  158.      *
  159.      * @param data   待解密的数据
  160.      * @param priKey 私钥
  161.      * @return
  162.      * @throws Exception
  163.      */
  164.     public static byte[] decryptByPriKey(byte[] data, byte[] priKey) throws Exception {
  165.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(priKey);
  166.         KeyFactory keyFactory = KeyFactory.getInstance(RSA_KEY_ALGORITHM);
  167.         PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
  168.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
  169.         cipher.init(Cipher.DECRYPT_MODE, privateKey);
  170.         return cipher.doFinal(data);
  171.     }
  172.     /**
  173.      * 私钥解密
  174.      *
  175.      * @param data       解密前的字符串
  176.      * @param privateKey 私钥
  177.      * @return 解密后的字符串
  178.      * @throws Exception
  179.      */
  180.     public static String decryptByPriKey(String data, String privateKey) throws Exception {
  181.         byte[] priKey = RSAUtil.decodeBase64(privateKey);
  182.         byte[] design = decryptByPriKey(Base64.decodeBase64(data), priKey);
  183.         return new String(design);
  184.     }
  185.     /**
  186.      * RSA签名
  187.      *
  188.      * @param data   待签名数据
  189.      * @param priKey 私钥
  190.      * @return 签名
  191.      * @throws Exception
  192.      */
  193.     public static String sign(byte[] data, byte[] priKey) throws Exception {
  194.         // 取得私钥
  195.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(priKey);
  196.         KeyFactory keyFactory = KeyFactory.getInstance(RSA_KEY_ALGORITHM);
  197.         // 生成私钥
  198.         PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
  199.         // 实例化Signature
  200.         Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
  201.         // 初始化Signature
  202.         signature.initSign(privateKey);
  203.         // 更新
  204.         signature.update(data);
  205.         return Base64.encodeBase64String(signature.sign());
  206.     }
  207.     /**
  208.      * RSA校验数字签名
  209.      *
  210.      * @param data   待校验数据
  211.      * @param sign   数字签名
  212.      * @param pubKey 公钥
  213.      * @return boolean 校验成功返回true,失败返回false
  214.      */
  215.     public boolean verify(byte[] data, byte[] sign, byte[] pubKey) throws Exception {
  216.         // 实例化密钥工厂
  217.         KeyFactory keyFactory = KeyFactory.getInstance(RSA_KEY_ALGORITHM);
  218.         // 初始化公钥
  219.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(pubKey);
  220.         // 产生公钥
  221.         PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);
  222.         // 实例化Signature
  223.         Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
  224.         // 初始化Signature
  225.         signature.initVerify(publicKey);
  226.         // 更新
  227.         signature.update(data);
  228.         // 验证
  229.         return signature.verify(sign);
  230.     }
  231.     public static void main(String[] args) {
  232.         try {
  233.             Map<String, String> keyMap = initKey();
  234.             String publicKeyString = keyMap.get("publicKeyString");
  235.             String privateKeyString = keyMap.get("privateKeyString");
  236.             System.out.println("公钥:" + publicKeyString);
  237.             System.out.println("私钥:" + privateKeyString);
  238.             // 待加密数据
  239.             String data = "admin123";
  240.             // 公钥加密
  241.             String encrypt = RSAUtil.encryptByPubKey(data, publicKeyString);
  242.             // 私钥解密
  243.             String decrypt = RSAUtil.decryptByPriKey(encrypt, privateKeyString);
  244.             System.out.println("加密前:" + data);
  245.             System.out.println("加密后:" + encrypt);
  246.             System.out.println("解密后:" + decrypt);
  247.         } catch (Exception e) {
  248.             e.printStackTrace();
  249.         }
  250.     }
  251. }
avatar

发表评论

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: