Java--RSA非对称加密的实现（使用java.security.KeyPair）

前言

• 非对称加密是指使用不同的两个密钥进行加密和解密的一种加密算法，调用方用使用服务方提供的公钥进行加密，服务方使用自己的私钥进行解密。RSA算法是目前使用最广泛的公钥密码算法。
• Java提供了KeyPairGenerator类要生成公钥和私钥密钥对（KeyPair），本文将提供两个接口，模拟公钥加密字符串和私钥解密字符串的过程。

实现步骤

1. 创建RsaService,该类提供以下方法：

   genKeyPair(): 初始化密钥对，并将生成的密钥对存入Redis
   getPublicKey()/getPrivateKey(): 提供获取公钥和私钥的方法
   encrypt(String password)/decrypt(String password): 提供加密和解密的方法，供其他类调用

   @Service
   public class RsaService { 
       @Autowired
       private RedisOperation redisOperation;
       /**
       * 初始化随机生成密钥对
       */
       @PostConstruct
       public void genKeyPair() throws NoSuchAlgorithmException {
           // KeyPairGenerator类用于生成公钥和私钥对，基于RSA算法生成对象
           KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
           // 初始化密钥对生成器，密钥大小为96-1024位
           // 这里的常量为：public static final int INT_FOUR_KB = 4096;
           keyPairGen.initialize(MagicNum.INT_FOUR_KB, new SecureRandom());
           // 生成一个密钥对，保存在keyPair中
           KeyPair keyPair = keyPairGen.generateKeyPair();
           //私钥
           RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();
           //公钥
           RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
   
           /**
            * 公钥与私钥
            */
           String publicKey = new String(Base64.encodeBase64(rsaPublicKey.getEncoded()));
           String privateKey = new String(Base64.encodeBase64((rsaPrivateKey.getEncoded())));
           /**
            * 存入Redis
            */
           redisOperation.set(RedisKeyConstant.SYSTEM_RAS_PUBLIC,publicKey);
           redisOperation.set(RedisKeyConstant.SYSTEM_RAS_PRIVATE,privateKey);
       }
   
       /**
        * 解密方法
        *
        * @param password -
        * @return ProcessException 自定义异常类
        */
       public String decrypt(String password) {
           try {
               return RsaUtil.decrypt(password, getPrivateKey());
           } catch (Exception e) {
               e.printStackTrace();
               throw new ProcessException(CommonConstants.ENUM_PROCESSING_EXCEPTION,"RSA解密异常");
           }
       }
   
       /**
        * 加密方法
        *
        * @param password -
        * @return -
        * @exception ProcessException 自定义异常类
        */
       public String encrypt(String password) {
           try {
               return RsaUtil.encrypt(password, getPublicKey());
           } catch (Exception e) {
               throw new ProcessException(CommonConstants.ENUM_PROCESSING_EXCEPTION,"RSA加密异常");
           }
       }
   
       /**
        * 获取公钥
        */
       public String getPublicKey() {
           return redisOperation.get(RedisKeyConstant.SYSTEM_RAS_PUBLIC);
       }
   
       /**
        * 获取私钥
        */
       public String getPrivateKey() {
           return redisOperation.get(RedisKeyConstant.SYSTEM_RAS_PRIVATE);
       }
   }
   

2. RsaUtil工具类，提供Base编码和解码

   public final class RsaUtil {
   
       private static final String RSA = "RSA";
   
       /**
        * RSA公钥加密
        *
        * @param publicKey publicKey
        * @param str       加密字符串
        * @return 密文
        * @throws Exception 加密过程中的异常信息
        */
       public static String encrypt(String str, String publicKey) throws Exception {
           //base64编码的公钥
           byte[] decoded = Base64.decodeBase64(publicKey);
           X509EncodedKeySpec keySpec = new X509EncodedKeySpec(decoded);
           KeyFactory keyFactory = KeyFactory.getInstance(RSA);
           PublicKey pubKey = keyFactory.generatePublic(keySpec);
           //RSA加密
           Cipher cipher = Cipher.getInstance(RSA);
           cipher.init(Cipher.ENCRYPT_MODE, pubKey);
           return Base64.encodeBase64String(cipher.doFinal(str.getBytes(StandardCharsets.UTF_8)));
       }
   
       /**
        * RSA私钥解密
        *
        * @param privateKey privateKey
        * @param str        加密字符串
        * @return 明文
        */
       public static String decrypt(String str, String privateKey) throws Exception {
           //64位解码加密后的字符串
           byte[] inputByte = Base64.decodeBase64(str.getBytes(StandardCharsets.UTF_8));
           //base64编码的私钥
           byte[] decoded = Base64.decodeBase64(privateKey);
           RSAPrivateKey priKey =
                   (RSAPrivateKey) KeyFactory.getInstance(RSA).generatePrivate(new PKCS8EncodedKeySpec(decoded));
           //RSA解密
           Cipher cipher = Cipher.getInstance(RSA);
           cipher.init(Cipher.DECRYPT_MODE, priKey);
           return new String(cipher.doFinal(inputByte));
       }
   }
   

3. 在Controller层编写接口以便做后面的测试

   @RestController
   @RequestMapping("/part/util")
   public class UtilController {
        @Autowired
        private RsaService rsaService;
       /**
         * 获取公钥
         *
         * @return -
         */
        @ApiOperation("获取公钥")
        @GetMapping("getPublicKey")
        public Result getPublicKey() {
            return Result.ok().data(rsaService.getPublicKey());
        }
   
        /**
         * 获取加密字符串
         *
         * @param key -
         * @return -
         */
        @ApiOperation("获取加密字符串")
        @GetMapping("encrypt/key")
        public Result getText(@RequestParam(value = "key") String key) {
            String encryptKey = rsaService.encrypt(key);
            return Result.ok().data(encryptKey);
        }
   
        /**
         * 获取解密字符串
         *
         * @param encryptKey -
         * @return -
         */
        @ApiOperation("获取解密字符串")
        @GetMapping("decrypt/key")
        public Result getText2(@RequestParam(value = "encryptKey") String encryptKey) {
            String decryptKey = rsaService.decrypt(encryptKey);
            return Result.ok().data(decryptKey);
        }
   }
   

测试结果

• 获取公钥接口

  

• 加密接口，输入参数key将与公钥加密，接口返回得到加密后的字符串。

  

• 解密接口，输入参数为公钥加密后的字符串，接口将返回私钥解密后的结果。