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

SpringBoot 实现 RAS+AES 自动接口解密

作者：酷酷是懒虫 | 2024-07-29 10:04:26

赞

踩

对称加密和非对称加密的区别是什么

一、讲个事故

接口安全老生常谈了

过年之前做了过一款飞机大战的H5小游戏，里面无限模式-需要保存用户的积分，因为使用的Body传参，参数是可见的。

为了接口安全我，我和前端约定了传递参数是：用户无限模式的积分+“我们约定的一个数字”+用户id的和，在用Base64加密，请求到服务器我再解密，出用户无限模式的积分；如下：

  1. {
  2.     "integral": "MTExMTM0NzY5NQ==",
  3. }

可是过年的时候，运营突然找我说无限模式积分排行榜分数不对：

197c9e60d7e64af8acefb374bb66468d.png b02ef23d0ccb968bc90d3a4fbac00c46.png

这就很诡异了，第二名才一万多分，第一名就40多万分！！！！

一开始我以为是我解密有问题，反复看了好几变，可就两三行代码不可能有问题的！！！

没办法我去翻了好久的日志，才发现这个用户把我接口参数给改了。。。。

他把Base64接口参数改了

378f1e55058b42fe33ad085168182c18.png 0581c12da4b92fcbcadd0d7398721254.png

事已至此，我也不能怪用户，谁让我把人家想得太简单，接口安全也没到位

所以年后上班第一件是就是把接口加密的工作搞起来

目前常用的加密方式就对称性加密和非对称性加密，加密解密的操作的肯定是大家知道的，最重要的使用什么加密解密方式，制定什么样的加密策略；考虑到我技术水平和接口的速度，采用的是RAS非对称加密和AES对称加密一起用！！！！

二、RSA和AES基础知识

1、非对称加密和对称加密

非对称加密

非对称加密算法是一种密钥的保密方法。非对称加密算法需要两个密钥：公开密钥（publickey:简称公钥）和私有密钥（privatekey:简称私钥）。

公钥与私钥是一对，如果用公钥对数据进行加密，只有用对应的私钥才能解密。因为加密和解密使用的是两个不同的密钥，所以这种算法叫作非对称加密算法。

对称加密

加密秘钥和解密秘钥是一样，当你的密钥被别人知道后，就没有秘密可言了

AES 是对称加密算法，优点：加密速度快；缺点：如果秘钥丢失，就容易解密密文，安全性相对比较差

RSA 是非对称加密算法 ， 优点：安全 ；缺点：加密速度慢

2、RSA基础知识

RSA——非对称加密，会产生公钥和私钥，公钥在客户端，私钥在服务端。公钥用于加密，私钥用于解密。

大概的流程：

客户端向服务器发送消息：客户端用公钥加密信息，发送给服务端，服务端再用私钥机密

服务器向客户端发送消息：服务端用私钥加密信息，发送给客户端，客户端再用公钥机密

当然中间要保障密钥的安全，还有很多为了保障数据安全的操作，比如数字签名，证书签名等等，在这我们就先不说了；

RSA加密解密算法支持三种填充模式，

分别是ENCRYPTION_OAEP、ENCRYPTION_PKCS1、ENCRYPTION_NONE，RSA填充是为了和公钥等长。

  • ENCRYPTION_OAEP：最优非对称加密填充，是RSA加密和RSA解密最新最安全的推荐填充模式。

  • ENCRYPTION_PKCS1：随机填充数据模式，每次加密的结果都不一样，是RSA加密和RSA解密使用最为广泛的填充模式。

  • ENCRYPTION_NONE：不填充模式，是RSA加密和RSA解密使用较少的填充模式。

RSA 常用的加密填充模式

  • RSA/None/PKCS1Padding

  • RSA/ECB/PKCS1Padding

知识点：

Java 默认的 RSA 实现是 RSA/None/PKCS1Padding

在创建RSA秘钥对时，长度最好选择 2048的整数倍，长度为1024在已经不很安全了

一般由服务器创建秘钥对，私钥保存在服务器，公钥下发至客户端

DER是RSA密钥的二进制格式，PEM是DER转码为Base64的字符格式，由于DER是二进制格式，不便于阅读和理解。一般而言，密钥都是通过PEM的格式进行存储的

  1. /**
  2.  * 生成密钥对
  3.  * @param keyLength  密钥长度
  4.  * @return KeyPair
  5.  */
  6. public static KeyPair getKeyPair(int keyLength) {
  7.     try {
  8.         KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");   //默认:RSA/None/PKCS1Padding
  9.         keyPairGenerator.initialize(keyLength);
  10.         return keyPairGenerator.generateKeyPair();
  11.     } catch (NoSuchAlgorithmException e) {
  12.         throw new RuntimeException("生成密钥对时遇到异常" +  e.getMessage());
  13.     }
  14. }
  15.  
  16. /**
  17.  * 获取公钥
  18.  */
  19. public static byte[] getPublicKey(KeyPair keyPair) {
  20.     RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
  21.     return rsaPublicKey.getEncoded();
  22. }
  23.  
  24. /**
  25.  * 获取私钥
  26.  */
  27. public static byte[] getPrivateKey(KeyPair keyPair) {
  28.     RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();
  29.     return rsaPrivateKey.getEncoded();
  30. }
3、AES基础知识

AES 简介

AES加密解密算法是一种可逆的对称加密算法，这类算法在加密和AES解密时使用相同的密钥，或是使用两个可以简单地相互推算的密钥，一般用于服务端对服务端之间对数据进行加密解密。它是一种为了替代原先DES、3DES而建立的高级加密标准（Advanced Encryption Standard）。

作为可逆且对称的块加密，AES加密算法的速度比公钥加密等加密算法快很多，在很多场合都需要AES对称加密，但是要求加密端和解密端双方都使用相同的密钥是AES算法的主要缺点之一。

AES加密解密

AES加密需要：明文 + 密钥+ 偏移量（IV）+密码模式(算法/模式/填充) AES解密需要：密文 + 密钥+ 偏移量（IV）+密码模式(算法/模式/填充)

AES的算法模式一般为 AES/CBC/PKCS5Padding 或 AES/CBC/PKCS7Padding

AES常见的工作模式：

  • 电码本模式(ECB)

  • 密码分组链接模式(CBC)

  • 计算器模式(CTR)

  • 密码反馈模式(CFB)

  • 输出反馈模式(OFB)

除了ECB无须设置初始化向量IV而不安全之外，其它AES工作模式都必须设置向量IV，其中GCM工作模式较为特殊。

AES填充模式

块密码只能对确定长度的数据块进行处理，而消息的长度通常是可变的，因此需要选择填充模式。

  • 填充区别：在ECB、CBC工作模式下最后一块要在加密前进行填充，其它不用选择填充模式；

  • 填充模式：AES支持的填充模式为PKCS7和NONE不填充。其中PKCS7标准是主流加密算法都遵循的数据填充算法。AES标准规定的区块长度为固定值128Bit，对应的字节长度为16位，这明显和PKCS5标准规定使用的固定值8位不符，虽然有些框架特殊处理后可以通用PKCS5，但是从长远和兼容性考虑，推荐PKCS7。

AES密钥KEY和初始化向量IV

初始化向量IV可以有效提升安全性，但是在实际的使用场景中，它不能像密钥KEY那样直接保存在配置文件或固定写死在代码中，一般正确的处理方式为：在加密端将IV设置为一个16位的随机值，然后和加密文本一起返给解密端即可。

  • 密钥KEY：AES标准规定区块长度只有一个值，固定为128Bit，对应的字节为16位。AES算法规定密钥长度只有三个值，128Bit、192Bit、256Bit，对应的字节为16位、24位和32位，其中密钥KEY不能公开传输，用于加密解密数据；

  • 初始化向量IV：该字段可以公开，用于将加密随机化。同样的明文被多次加密也会产生不同的密文，避免了较慢的重新产生密钥的过程，初始化向量与密钥相比有不同的安全性需求，因此IV通常无须保密。然而在大多数情况中，不应当在使用同一密钥的情况下两次使用同一个IV，一般推荐初始化向量IV为16位的随机值。

三、加密策略

RAS、AES加密解密的操作都是一样，如果有效的结合到一起才能达到更好的加密效果很重要；

上面说到：

AES 是对称加密算法，优点：加密速度快；缺点：如果秘钥丢失，就容易解密密文，安全性相对比较差

RSA 是非对称加密算法， 优点：安全 ；缺点：加密速度慢

1、主要思路：

那么我们就结合2个加密算法的优点来操作：

  • 因为接口传递的参数有多有少，当接口传递的参数过多时，使用RSA加密会导致加密速度慢，所以我们使用AES加密加密接口参数

  • 因为AES的密钥key和偏移量VI都是固定的所以可以使用RSA加密

  • 客户端将AES加密后的密文和RSA加密后的密文，传递给服务器即可。

2、涉及工具类：

util包下：

  • ActivityRSAUtil

  • AES256Util

  • RequestDecryptionUtil

3、加密策略
b6c18e4de278f42dc2db9beeec919e26.png
4、交互方式

前端：

1、客户端随机生成2个16为的AES密钥和AES偏移量

2、使用AES加密算法加密真实传递参数，得到参数密文“asy”

3、将AES密钥、AES偏移量和当前时间戳，格式如下：

  • key：密钥

  • keyVI：偏移量

  • time：请求时间，用户判断是否重复请求

  1. {
  2.   "key":"0t7FtCDKofbEVpSZS",
  3.   "keyVI":"0t7WESMofbEVpSZS",
  4.   "time":211213232323323
  5. }
  6. //转成JSON字符串

4、AES信息密钥信息，再使用RSA公钥加密，得到AES密钥的密文“sym”

5、将“sym”和“asy”作为body参数，调用接口

5d439ac4f5e2b297e74929b9d3be27f9.png

后端：

1、在接口接收参数中，多增加2个字段接收加密后的“sym”和“asy” （名字可以自己定，能接收到就行）

2、使用RequestDecryptionUtil.getRequestDecryption()方法解密，返回解密后的真实传递参数

四、服务器自动解密

因为不是每个接口都需求加密解密，我们可以自定义一个注解，将需要解密的接口上加一个这个注解，

1、自定义解密注解：@RequestRSA
  1. import java.lang.annotation.Documented;
  2. import java.lang.annotation.ElementType;
  3. import java.lang.annotation.Retention;
  4. import java.lang.annotation.RetentionPolicy;
  5. import java.lang.annotation.Target;
  6.  
  7.  
  8. @Target({ElementType.TYPE, ElementType.METHOD})
  9. @Retention(RetentionPolicy.RUNTIME)
  10. @Documented
  11. public @interface RequestRSA {
  12. }
2、创建一个aop切片

  1. AOP判断controller接收到请求是否带有@RequestRSA注解

  2. 如果带有注解，通过ProceedingJoinPoint类getArgs()方法获取请求的body参数，

  3. 将body参数，传为JSONObject类，获取到"asy"和"sym"属性，再调用RequestDecryptionUtil解密获取接口传递的真实参数

  4. 获取接口入参的类

  5. 将获取解密后的真实参数，封装到接口入参的类中

  1. import com.alibaba.fastjson.JSONObject;
  2. import app.activity.common.interceptor.RequestRSA;
  3. import app.activity.util.RequestDecryptionUtil;
  4. import lombok.extern.slf4j.Slf4j;
  5. import org.aspectj.lang.ProceedingJoinPoint;
  6. import org.aspectj.lang.annotation.Around;
  7. import org.aspectj.lang.annotation.Aspect;
  8. import org.aspectj.lang.annotation.Pointcut;
  9. import org.aspectj.lang.reflect.MethodSignature;
  10. import org.springframework.core.annotation.Order;
  11. import org.springframework.stereotype.Component;
  12. import org.springframework.web.bind.annotation.RequestBody;
  13.  
  14. import java.lang.reflect.Method;
  15. import java.lang.reflect.Parameter;
  16. import java.util.ArrayList;
  17. import java.util.List;
  18. import java.util.Objects;
  19.  
  20. /**
  21.  * @module
  22.  * @author: qingxu.liu
  23.  * @date: 2023-02-08 16:41
  24.  * @copyright  请求验证RSA & AES  统一验证切面
  25.  **/
  26. @Aspect
  27. @Component
  28. @Order(2)
  29. @Slf4j
  30. public class RequestRSAAspect {
  31.  
  32.     /**
  33.      * 1> 获取请求参数
  34.      * 2> 获取被请求接口的入参类型
  35.      * 3> 判断是否为get请求 是则跳过AES解密判断
  36.      * 4> 请求参数解密->封装到接口的入参
  37.      */
  38.  
  39.     @Pointcut("execution(public * app.activity.controller.*.*(..))")
  40.     public void requestRAS() {
  41.     }
  42.  
  43.     @Around("requestRAS()")
  44.     public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
  45.         //=======AOP解密切面通知=======
  46.         MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
  47.         Method methods = methodSignature.getMethod();
  48.         RequestRSA annotation = methods.getAnnotation(RequestRSA.class);
  49.         if (Objects.nonNull(annotation)){
  50.             //获取请求的body参数
  51.             Object data = getParameter(methods, joinPoint.getArgs());
  52.             String body = JSONObject.toJSONString(data);
  53.             //获取asy和sym的值
  54.             JSONObject jsonObject = JSONObject.parseObject(body);
  55.             String asy = jsonObject.get("asy").toString();
  56.             String sym = jsonObject.get("sym").toString();
  57.             //调用RequestDecryptionUtil方法解密，获取解密后的真实参数
  58.             JSONObject decryption = RequestDecryptionUtil.getRequestDecryption(sym, asy);
  59.             //获取接口入参的类
  60.             String typeName = joinPoint.getArgs()[0].getClass().getTypeName();
  61.             System.out.println("参数值类型："+ typeName);
  62.             Class<?> aClass = joinPoint.getArgs()[0].getClass();
  63.             //将获取解密后的真实参数，封装到接口入参的类中
  64.             Object o = JSONObject.parseObject(decryption.toJSONString(), aClass);
  65.             Object[] as = {o};
  66.             return joinPoint.proceed(as);
  67.         }
  68.         return joinPoint.proceed();
  69.     }
  70.  
  71.     /**
  72.      * 根据方法和传入的参数获取请求参数 获取的是接口的入参
  73.      */
  74.     private Object getParameter(Method method, Object[] args) {
  75.         List<Object> argList = new ArrayList<>();
  76.         Parameter[] parameters = method.getParameters();
  77.         for (int i = 0; i < parameters.length; i++) {
  78.             //将RequestBody注解修饰的参数作为请求参数
  79.             RequestBody requestBody = parameters[i].getAnnotation(RequestBody.class);
  80.             if (requestBody != null) {
  81.                 argList.add(args[i]);
  82.             }
  83.         }
  84.         if (argList.size() == 0) {
  85.             return null;
  86.         } else if (argList.size() == 1) {
  87.             return argList.get(0);
  88.         } else {
  89.             return argList;
  90.         }
  91.     }
  92. }
3、RequestDecryptionUtil 解密类

1、使用privateKey私钥对”sym“解密获取到客户端加密的AES密钥，偏移量、时间等信息

  1. {
  2.   "key":"0t7FtSMofbEVpSZS",
  3.   "keyVI":"0t7FtSMofbEVpSZS",
  4.   "time":211213232323323
  5. }

2、获取当前时间戳，与time比较是否超过一分钟（6000毫秒），超过就抛出“Request timed out, please try again”异常

3、没有超时，将获取的到AES密钥和偏移量，再对“asy”解密获取接口传递的真实参数

  1. import com.alibaba.fastjson.JSONObject;
  2. import app.activity.common.rsa.RSADecodeData;
  3. import app.common.exception.ServiceException;
  4.  
  5. import java.security.interfaces.RSAPrivateKey;
  6. import java.util.Objects;
  7.  
  8. /**
  9.  * @module
  10.  * @author: qingxu.liu
  11.  * @date: 2023-02-09 17:43
  12.  * @copyright
  13.  **/
  14. public class RequestDecryptionUtil {
  15.  
  16.     private final static String publicKey = "RSA生成的公钥";
  17.     private final static String privateKey = "RSA生成的私钥";
  18.     private final static Integer timeout = 60000;
  19.  
  20.     /**
  21.      *
  22.      * @param sym RSA 密文
  23.      * @param asy AES 密文
  24.      * @param clazz 接口入参类
  25.      * @return Object
  26.      */
  27.     public static <T> Object getRequestDecryption(String sym, String asy, Class<T> clazz){
  28.         //验证密钥
  29.         try {
  30.             //解密RSA
  31.             RSAPrivateKey rsaPrivateKey = ActivityRSAUtil.getRSAPrivateKeyByString(privateKey);
  32.             String RSAJson = ActivityRSAUtil.privateDecrypt(sym, rsaPrivateKey);
  33.             RSADecodeData rsaDecodeData = JSONObject.parseObject(RSAJson, RSADecodeData.class);
  34.             boolean isTimeout = Objects.nonNull(rsaDecodeData)  && Objects.nonNull(rsaDecodeData.getTime()) && System.currentTimeMillis() -  rsaDecodeData.getTime() < timeout;
  35.             if (!isTimeout){
  36.                 throw new ServiceException("Request timed out, please try again."); //请求超时
  37.             }
  38.             //解密AES
  39.             String AESJson = AES256Util.decode(rsaDecodeData.getKey(),asy,rsaDecodeData.getKeyVI());
  40.             System.out.println("AESJson: "+AESJson);
  41.             return JSONObject.parseObject(AESJson,clazz);
  42.         } catch (Exception e) {
  43.             throw new RuntimeException("RSA decryption Exception:  " +e.getMessage());
  44.         }
  45.     }
  46.  
  47.     public static JSONObject getRequestDecryption(String sym, String asy){
  48.         //验证密钥
  49.         try {
  50.             //解密RSA
  51.             RSAPrivateKey rsaPrivateKey = ActivityRSAUtil.getRSAPrivateKeyByString(privateKey);
  52.             String RSAJson = ActivityRSAUtil.privateDecrypt(sym, rsaPrivateKey);
  53.             RSADecodeData rsaDecodeData = JSONObject.parseObject(RSAJson, RSADecodeData.class);
  54.             boolean isTimeout = Objects.nonNull(rsaDecodeData)  && Objects.nonNull(rsaDecodeData.getTime()) && System.currentTimeMillis() -  rsaDecodeData.getTime() < timeout;
  55.             if (!isTimeout){
  56.                 throw new ServiceException("Request timed out, please try again."); //请求超时
  57.             }
  58.             //解密AES
  59.             String AESJson = AES256Util.decode(rsaDecodeData.getKey(),asy,rsaDecodeData.getKeyVI());
  60.             System.out.println("AESJson: "+AESJson);
  61.             return JSONObject.parseObject(AESJson);
  62.         } catch (Exception e) {
  63.             throw new RuntimeException("RSA decryption Exception:  " +e.getMessage());
  64.         }
  65.     }
  66. }

4、ActivityRSAUtil 工具类

  1. import org.apache.commons.io.IOUtils;
  2. import javax.crypto.Cipher;
  3. import java.io.ByteArrayOutputStream;
  4. import java.security.*;
  5. import java.security.interfaces.RSAPrivateKey;
  6. import java.security.interfaces.RSAPublicKey;
  7. import java.security.spec.PKCS8EncodedKeySpec;
  8. import java.security.spec.X509EncodedKeySpec;
  9. import java.util.Base64;
  10.  
  11. /**
  12.  * @module
  13.  * @author: qingxu.liu
  14.  * @date: 2023-02-07 16:54
  15.  * @copyright
  16.  **/
  17. public class ActivityRSAUtil {
  18.  
  19.     /**
  20.      * 字符集
  21.      */
  22.     public static String CHARSET = "UTF-8";
  23.  
  24.     /**
  25.      * 生成密钥对
  26.      * @param keyLength  密钥长度
  27.      * @return KeyPair
  28.      */
  29.     public static KeyPair getKeyPair(int keyLength) {
  30.         try {
  31.             KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");   //默认:RSA/None/PKCS1Padding
  32.             keyPairGenerator.initialize(keyLength);
  33.             return keyPairGenerator.generateKeyPair();
  34.         } catch (NoSuchAlgorithmException e) {
  35.             throw new RuntimeException("生成密钥对时遇到异常" +  e.getMessage());
  36.         }
  37.     }
  38.  
  39.     /**
  40.      * 获取公钥
  41.      */
  42.     public static byte[] getPublicKey(KeyPair keyPair) {
  43.         RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
  44.         return rsaPublicKey.getEncoded();
  45.     }
  46.  
  47.     /**
  48.      * 获取私钥
  49.      */
  50.     public static byte[] getPrivateKey(KeyPair keyPair) {
  51.         RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();
  52.         return rsaPrivateKey.getEncoded();
  53.     }
  54.  
  55.     /**
  56.      * 公钥字符串转PublicKey实例
  57.      * @param publicKey 公钥字符串
  58.      * @return          PublicKey
  59.      * @throws Exception e
  60.      */
  61.     public static PublicKey getPublicKey(String publicKey) throws Exception {
  62.         byte[] publicKeyBytes = Base64.getDecoder().decode(publicKey.getBytes());
  63.         X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKeyBytes);
  64.         KeyFactory keyFactory = KeyFactory.getInstance("RSA");
  65.         return keyFactory.generatePublic(keySpec);
  66.     }
  67.  
  68.     /**
  69.      * 私钥字符串转PrivateKey实例
  70.      * @param privateKey  私钥字符串
  71.      * @return PrivateKey
  72.      * @throws Exception e
  73.      */
  74.     public static PrivateKey getPrivateKey(String privateKey) throws Exception {
  75.         byte[] privateKeyBytes = Base64.getDecoder().decode(privateKey.getBytes());
  76.         PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKeyBytes);
  77.         KeyFactory keyFactory = KeyFactory.getInstance("RSA");
  78.         return keyFactory.generatePrivate(keySpec);
  79.     }
  80.  
  81.     /**
  82.      * 获取公钥字符串
  83.      * @param keyPair KeyPair
  84.      * @return  公钥字符串
  85.      */
  86.     public static String getPublicKeyString(KeyPair keyPair){
  87.         RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();  // 得到公钥
  88.         return new String(org.apache.commons.codec.binary.Base64.encodeBase64(publicKey.getEncoded()));
  89.     }
  90.  
  91.     /**
  92.      * 获取私钥字符串
  93.      * @param keyPair  KeyPair
  94.      * @return 私钥字符串
  95.      */
  96.     public static String getPrivateKeyString(KeyPair keyPair){
  97.         RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();   // 得到私钥
  98.         return new String(org.apache.commons.codec.binary.Base64.encodeBase64((privateKey.getEncoded())));
  99.     }
  100.  
  101.  
  102.     /**
  103.      * 公钥加密
  104.      * @param data        明文
  105.      * @param publicKey   公钥
  106.      * @return            密文
  107.      */
  108.     public static String publicEncrypt(String data, RSAPublicKey publicKey) {
  109.         try {
  110.             Cipher cipher = Cipher.getInstance("RSA");
  111.             cipher.init(Cipher.ENCRYPT_MODE, publicKey);
  112.             byte[] bytes = rsaSplitCodec(cipher, Cipher.ENCRYPT_MODE, data.getBytes(CHARSET), publicKey.getModulus().bitLength());
  113.             return new String(org.apache.commons.codec.binary.Base64.encodeBase64(bytes));
  114.         } catch (Exception e) {
  115.             throw new RuntimeException("加密字符串[" + data + "]时遇到异常"+  e.getMessage());
  116.         }
  117.     }
  118.  
  119.     /**
  120.      * 私钥解密
  121.      * @param data        密文
  122.      * @param privateKey  私钥
  123.      * @return            明文
  124.      */
  125.     public static String privateDecrypt(String data, RSAPrivateKey privateKey) {
  126.         try {
  127.             Cipher cipher = Cipher.getInstance("RSA");
  128.             cipher.init(Cipher.DECRYPT_MODE, privateKey);
  129.             return new String(rsaSplitCodec(cipher, Cipher.DECRYPT_MODE, Base64.getDecoder().decode(data), privateKey.getModulus().bitLength()), CHARSET);
  130.         } catch (Exception e) {
  131.             throw new RuntimeException("privateKey解密字符串[" + data + "]时遇到异常"+  e.getMessage());
  132.         }
  133.     }
  134.  
  135.  
  136.     /**
  137.      * 私钥加密
  138.      * @param content 明文
  139.      * @param privateKey 私钥
  140.      * @return 密文
  141.      */
  142.     public static String encryptByPrivateKey(String content, RSAPrivateKey privateKey){
  143.  
  144.         try {
  145.             Cipher cipher = Cipher.getInstance("RSA");
  146.             cipher.init(Cipher.ENCRYPT_MODE, privateKey);
  147.             byte[] bytes = rsaSplitCodec(cipher, Cipher.ENCRYPT_MODE,content.getBytes(CHARSET), privateKey.getModulus().bitLength());
  148.             return new String(org.apache.commons.codec.binary.Base64.encodeBase64(bytes));
  149.         } catch (Exception e) {
  150.             throw new RuntimeException("privateKey加密字符串[" + content + "]时遇到异常" +  e.getMessage());
  151.         }
  152.     }
  153.  
  154.     /**
  155.      * 公钥解密
  156.      * @param content  密文
  157.      * @param publicKey 私钥
  158.      * @return  明文
  159.      */
  160.     public static String decryByPublicKey(String content, RSAPublicKey publicKey){
  161.         try {
  162.             Cipher cipher = Cipher.getInstance("RSA");
  163.             cipher.init(Cipher.DECRYPT_MODE, publicKey);
  164.             return new String(rsaSplitCodec(cipher, Cipher.DECRYPT_MODE, Base64.getDecoder().decode(content), publicKey.getModulus().bitLength()), CHARSET);
  165.         } catch (Exception e) {
  166.             throw new RuntimeException("publicKey解密字符串[" + content + "]时遇到异常" +e.getMessage());
  167.         }
  168.     }
  169.  
  170.     public static RSAPublicKey getRSAPublicKeyByString(String publicKey){
  171.         try {
  172.             X509EncodedKeySpec keySpec = new X509EncodedKeySpec(Base64.getDecoder().decode(publicKey));
  173.             KeyFactory keyFactory = KeyFactory.getInstance("RSA");
  174.             return (RSAPublicKey)keyFactory.generatePublic(keySpec);
  175.         } catch (Exception e) {
  176.             throw new RuntimeException("String转PublicKey出错" + e.getMessage());
  177.         }
  178.     }
  179.  
  180.  
  181.     public static RSAPrivateKey getRSAPrivateKeyByString(String privateKey){
  182.         try {
  183.             PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(Base64.getDecoder().decode(privateKey));
  184.             KeyFactory keyFactory = KeyFactory.getInstance("RSA");
  185.             return (RSAPrivateKey)keyFactory.generatePrivate(pkcs8EncodedKeySpec);
  186.         } catch (Exception e) {
  187.             throw new RuntimeException("String转PrivateKey出错" + e.getMessage());
  188.         }
  189.     }
  190.  
  191.  
  192.     //rsa切割解码  , ENCRYPT_MODE,加密数据   ,DECRYPT_MODE,解密数据
  193.     private static byte[] rsaSplitCodec(Cipher cipher, int opmode, byte[] datas, int keySize) {
  194.         int maxBlock = 0;  //最大块
  195.         if (opmode == Cipher.DECRYPT_MODE) {
  196.             maxBlock = keySize / 8;
  197.         } else {
  198.             maxBlock = keySize / 8 - 11;
  199.         }
  200.         ByteArrayOutputStream out = new ByteArrayOutputStream();
  201.         int offSet = 0;
  202.         byte[] buff;
  203.         int i = 0;
  204.         try {
  205.             while (datas.length > offSet) {
  206.                 if (datas.length - offSet > maxBlock) {
  207.                     //可以调用以下的doFinal（）方法完成加密或解密数据：
  208.                     buff = cipher.doFinal(datas, offSet, maxBlock);
  209.                 } else {
  210.                     buff = cipher.doFinal(datas, offSet, datas.length - offSet);
  211.                 }
  212.                 out.write(buff, 0, buff.length);
  213.                 i++;
  214.                 offSet = i * maxBlock;
  215.             }
  216.         } catch (Exception e) {
  217.             throw new RuntimeException("加解密阀值为[" + maxBlock + "]的数据时发生异常: " + e.getMessage());
  218.         }
  219.         byte[] resultDatas = out.toByteArray();
  220.         IOUtils.closeQuietly(out);
  221.         return resultDatas;
  222.     }
  223. }

5、AES256Util 工具类

  1. import org.bouncycastle.jce.provider.BouncyCastleProvider;
  2. import javax.crypto.Cipher;
  3. import javax.crypto.spec.SecretKeySpec;
  4. import java.nio.charset.StandardCharsets;
  5. import java.security.Security;
  6. import java.util.Base64;
  7.  
  8. /**
  9.  * @module
  10.  * @author: qingxu.liu
  11.  * @date: 2023-02-07 16:14
  12.  * @copyright
  13.  **/
  14.  
  15. public class AES256Util {
  16.  
  17.     private static final String AES = "AES";
  18.     /**
  19.      * 初始向量IV, 初始向量IV的长度规定为128位16个字节, 初始向量的来源为随机生成.
  20.      */
  21.     /**
  22.      * 加密解密算法/加密模式/填充方式
  23.      */
  24.     private static final String CIPHER_ALGORITHM = "AES/CBC/PKCS7Padding";
  25.  
  26.     private static final Base64.Encoder base64Encoder = java.util.Base64.getEncoder();
  27.     private static final Base64.Decoder base64Decoder = java.util.Base64.getDecoder();
  28.  
  29.     //通过在运行环境中设置以下属性启用AES-256支持
  30.     static {
  31.         Security.setProperty("crypto.policy", "unlimited");
  32.     }
  33.     /*
  34.      * 解决java不支持AES/CBC/PKCS7Padding模式解密
  35.      */
  36.     static {
  37.         Security.addProvider(new BouncyCastleProvider());
  38.     }
  39.     /**
  40.      * AES加密
  41.      */
  42.     public static String encode(String key, String content,String keyVI) {
  43.         try {
  44.             javax.crypto.SecretKey secretKey = new javax.crypto.spec.SecretKeySpec(key.getBytes(), AES);
  45.             javax.crypto.Cipher cipher = javax.crypto.Cipher.getInstance(CIPHER_ALGORITHM);
  46.             cipher.init(javax.crypto.Cipher.ENCRYPT_MODE, secretKey, new javax.crypto.spec.IvParameterSpec(keyVI.getBytes()));
  47.             // 获取加密内容的字节数组(这里要设置为utf-8)不然内容中如果有中文和英文混合中文就会解密为乱码
  48.             byte[] byteEncode = content.getBytes(java.nio.charset.StandardCharsets.UTF_8);
  49.             // 根据密码器的初始化方式加密
  50.             byte[] byteAES = cipher.doFinal(byteEncode);
  51.             // 将加密后的数据转换为字符串
  52.             return base64Encoder.encodeToString(byteAES);
  53.         } catch (Exception e) {
  54.             e.printStackTrace();
  55.         }
  56.         return null;
  57.     }
  58.  
  59.     /**
  60.      * AES解密
  61.      */
  62.     public static String decode(String key, String content,String keyVI) {
  63.         try {
  64.             javax.crypto.SecretKey secretKey = new javax.crypto.spec.SecretKeySpec(key.getBytes(), AES);
  65.             javax.crypto.Cipher cipher = javax.crypto.Cipher.getInstance(CIPHER_ALGORITHM);
  66.             cipher.init(javax.crypto.Cipher.DECRYPT_MODE, secretKey, new javax.crypto.spec.IvParameterSpec(keyVI.getBytes()));
  67.             // 将加密并编码后的内容解码成字节数组
  68.             byte[] byteContent = base64Decoder.decode(content);
  69.             // 解密
  70.             byte[] byteDecode = cipher.doFinal(byteContent);
  71.             return new String(byteDecode, java.nio.charset.StandardCharsets.UTF_8);
  72.         } catch (Exception e) {
  73.             e.printStackTrace();
  74.         }
  75.         return null;
  76.     }
  77.  
  78.     /**
  79.      * AES加密ECB模式PKCS7Padding填充方式
  80.      * @param str 字符串
  81.      * @param key 密钥
  82.      * @return 加密字符串
  83.      * @throws Exception 异常信息
  84.      */
  85.     public static String aes256ECBPkcs7PaddingEncrypt(String str, String key) throws Exception {
  86.         Cipher cipher = Cipher.getInstance("AES/ECB/PKCS7Padding");
  87.         byte[] keyBytes = key.getBytes(StandardCharsets.UTF_8);
  88.         cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(keyBytes, AES));
  89.         byte[] doFinal = cipher.doFinal(str.getBytes(StandardCharsets.UTF_8));
  90.         return new String(Base64.getEncoder().encode(doFinal));
  91.     }
  92.  
  93.     /**
  94.      * AES解密ECB模式PKCS7Padding填充方式
  95.      * @param str 字符串
  96.      * @param key 密钥
  97.      * @return 解密字符串
  98.      * @throws Exception 异常信息
  99.      */
  100.     public static String aes256ECBPkcs7PaddingDecrypt(String str, String key) throws Exception {
  101.         Cipher cipher = Cipher.getInstance("AES/ECB/PKCS7Padding");
  102.         byte[] keyBytes = key.getBytes(StandardCharsets.UTF_8);
  103.         cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(keyBytes, AES));
  104.         byte[] doFinal = cipher.doFinal(Base64.getDecoder().decode(str));
  105.         return new String(doFinal);
  106.     }
  107. }

亲测100%可用~~~

转载自：juejin.cn/post/7203931072260915259

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

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

  

闽ICP备14008679号