SpringBoot如何實作RAS+AES自動介面解密
一、講個事故
介面安全老生常談了
過年之前做了一款飛機大戰的H5小遊戲，裡面無限模式-需要保存用戶的積分，因為使用的Body傳參，參數是可見的，為了接口安全我，我和前端約定了傳遞參數是：用戶無限模式的積分“我們約定的一個數字」 用戶id的和，在用Base64加密，請求到伺服器我再解密，出用戶無限模式的積分；如下：
{
"integral": "MTExMTM0NzY5NQ==",
}可是過年的時候，營運突然找我說無限模式積分排行榜分數不對：
這就很詭異了，第二名才一萬多分，第一名就40多萬分！ ！ ！ ！
一開始我以為是我解密有問題，反覆看了好幾變，可就兩三行程式碼不可能有問題的！ ！ ！
沒辦法我去翻了好久的日誌，才發現這個使用者把我介面參數給改了。 。 。 。
他把Base64介面參數改了
事已至此，我也不能怪用戶，誰讓我把人家想得太簡單，介面安全也沒到位
所以年後上班第一件是就是把介面加密的工作搞起來
目前常用的加密方式就對稱性加密和非對稱性加密，加密解密的操作的肯定是大家知道的，最重要的使用什麼加密解密方式，制定什麼樣的加密策略；考慮到我技術水平和接口的速度，採用的是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的格式進行儲存的
/**
* 生成密钥对
* @param keyLength 密钥长度
* @return KeyPair
*/
public static KeyPair getKeyPair(int keyLength) {
try {
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA"); //默认:RSA/None/PKCS1Padding
keyPairGenerator.initialize(keyLength);
return keyPairGenerator.generateKeyPair();
} catch (NoSuchAlgorithmException e) {
throw new RuntimeException("生成密钥对时遇到异常" + e.getMessage());
}
}
/**
* 获取公钥
*/
public static byte[] getPublicKey(KeyPair keyPair) {
RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
return rsaPublicKey.getEncoded();
}
/**
* 获取私钥
*/
public static byte[] getPrivateKey(KeyPair keyPair) {
RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();
return rsaPrivateKey.getEncoded();
}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个加密算法的优点来操作：
1、因为接口传递的参数有多有少，当接口传递的参数过多时，使用RSA加密会导致加密速度慢，所以我们使用AES加密加密接口参数
2、因为AES的密钥key和偏移量VI都是固定的所以可以使用RSA加密
3、客户端将AES加密后的密文和RSA加密后的密文，传递给服务器即可。
2、涉及工具类：
util包下：
ActivityRSAUtilAES256UtilRequestDecryptionUtil
3、加密策略
4、交互方式
前端：
1、客户端随机生成2个16为的AES密钥和AES偏移量
2、使用AES加密算法加密真实传递参数，得到参数密文“asy”
3、将AES密钥、AES偏移量和当前时间戳，格式如下：
key：密钥
keyVI：偏移量
time：请求时间，用户判断是否重复请求
{
"key":"0t7FtCDKofbEVpSZS",
"keyVI":"0t7WESMofbEVpSZS",
"time":211213232323323
}
//转成JSON字符串4、AES信息密钥信息，再使用RSA公钥加密，得到AES密钥的密文“sym”
5、将“sym”和“asy”作为body参数，调用接口
后端：
1、在接口接收参数中，多增加2个字段接收加密后的“sym”和“asy” （名字可以自己定，能接收到就行）
2、使用RequestDecryptionUtil.getRequestDecryption（）方法解密，返回解密后的真实传递参数
四、服务器自动解密
因为不是每个接口都需求加密解密，我们可以自定义一个注解，将需要解密的接口上加一个这个注解，
1、自定义解密注解：@RequestRSA
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RequestRSA {
}2、创建一个aop切片
1、AOP判断controller接收到请求是否带有@RequestRSA注解
2、如果带有注解，通过ProceedingJoinPoint类getArgs()方法获取请求的body参数，
3、将body参数，传为JSONObject类，获取到"asy"和"sym"属性，再调用RequestDecryptionUtil解密获取接口传递的真实参数
4、获取接口入参的类
5、将获取解密后的真实参数，封装到接口入参的类中
import com.alibaba.fastjson.JSONObject;
import app.activity.common.interceptor.RequestRSA;
import app.activity.util.RequestDecryptionUtil;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.RequestBody;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
/**
* @module
* @author: qingxu.liu
* @date: 2023-02-08 16:41
* @copyright 请求验证RSA & AES 统一验证切面
**/
@Aspect
@Component
@Order(2)
@Slf4j
public class RequestRSAAspect {
/**
* 1> 获取请求参数
* 2> 获取被请求接口的入参类型
* 3> 判断是否为get请求 是则跳过AES解密判断
* 4> 请求参数解密->封装到接口的入参
*/
@Pointcut("execution(public * app.activity.controller.*.*(..))")
public void requestRAS() {
}
@Around("requestRAS()")
public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
//=======AOP解密切面通知=======
MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
Method methods = methodSignature.getMethod();
RequestRSA annotation = methods.getAnnotation(RequestRSA.class);
if (Objects.nonNull(annotation)){
//获取请求的body参数
Object data = getParameter(methods, joinPoint.getArgs());
String body = JSONObject.toJSONString(data);
//获取asy和sym的值
JSONObject jsonObject = JSONObject.parseObject(body);
String asy = jsonObject.get("asy").toString();
String sym = jsonObject.get("sym").toString();
//调用RequestDecryptionUtil方法解密，获取解密后的真实参数
JSONObject decryption = RequestDecryptionUtil.getRequestDecryption(sym, asy);
//获取接口入参的类
String typeName = joinPoint.getArgs()[0].getClass().getTypeName();
System.out.println("参数值类型："+ typeName);
Class<?> aClass = joinPoint.getArgs()[0].getClass();
//将获取解密后的真实参数，封装到接口入参的类中
Object o = JSONObject.parseObject(decryption.toJSONString(), aClass);
Object[] as = {o};
return joinPoint.proceed(as);
}
return joinPoint.proceed();
}
/**
* 根据方法和传入的参数获取请求参数 获取的是接口的入参
*/
private Object getParameter(Method method, Object[] args) {
List<Object> argList = new ArrayList<>();
Parameter[] parameters = method.getParameters();
for (int i = 0; i < parameters.length; i++) {
//将RequestBody注解修饰的参数作为请求参数
RequestBody requestBody = parameters[i].getAnnotation(RequestBody.class);
if (requestBody != null) {
argList.add(args[i]);
}
}
if (argList.size() == 0) {
return null;
} else if (argList.size() == 1) {
return argList.get(0);
} else {
return argList;
}
}
}3、RequestDecryptionUtil 解密类
1、使用privateKey私钥对”sym“解密获取到客户端加密的AES密钥，偏移量、时间等信息
{
"key":"0t7FtSMofbEVpSZS",
"keyVI":"0t7FtSMofbEVpSZS",
"time":211213232323323
}2、获取当前时间戳，与time比较是否超过一分钟（6000毫秒），超过就抛出“Request timed out, please try again”异常
3、没有超时，将获取的到AES密钥和偏移量，再对“asy”解密获取接口传递的真实参数
import com.alibaba.fastjson.JSONObject;
import app.activity.common.rsa.RSADecodeData;
import app.common.exception.ServiceException;
import java.security.interfaces.RSAPrivateKey;
import java.util.Objects;
/**
* @module
* @author: qingxu.liu
* @date: 2023-02-09 17:43
* @copyright
**/
public class RequestDecryptionUtil {
private final static String publicKey = "RSA生成的公钥";
private final static String privateKey = "RSA生成的私钥";
private final static Integer timeout = 60000;
/**
*
* @param sym RSA 密文
* @param asy AES 密文
* @param clazz 接口入参类
* @return Object
*/
public static <T> Object getRequestDecryption(String sym, String asy, Class<T> clazz){
//验证密钥
try {
//解密RSA
RSAPrivateKey rsaPrivateKey = ActivityRSAUtil.getRSAPrivateKeyByString(privateKey);
String RSAJson = ActivityRSAUtil.privateDecrypt(sym, rsaPrivateKey);
RSADecodeData rsaDecodeData = JSONObject.parseObject(RSAJson, RSADecodeData.class);
boolean isTimeout = Objects.nonNull(rsaDecodeData) && Objects.nonNull(rsaDecodeData.getTime()) && System.currentTimeMillis() - rsaDecodeData.getTime() < timeout;
if (!isTimeout){
throw new ServiceException("Request timed out, please try again."); //请求超时
}
//解密AES
String AESJson = AES256Util.decode(rsaDecodeData.getKey(),asy,rsaDecodeData.getKeyVI());
System.out.println("AESJson: "+AESJson);
return JSONObject.parseObject(AESJson,clazz);
} catch (Exception e) {
throw new RuntimeException("RSA decryption Exception: " +e.getMessage());
}
}
public static JSONObject getRequestDecryption(String sym, String asy){
//验证密钥
try {
//解密RSA
RSAPrivateKey rsaPrivateKey = ActivityRSAUtil.getRSAPrivateKeyByString(privateKey);
String RSAJson = ActivityRSAUtil.privateDecrypt(sym, rsaPrivateKey);
RSADecodeData rsaDecodeData = JSONObject.parseObject(RSAJson, RSADecodeData.class);
boolean isTimeout = Objects.nonNull(rsaDecodeData) && Objects.nonNull(rsaDecodeData.getTime()) && System.currentTimeMillis() - rsaDecodeData.getTime() < timeout;
if (!isTimeout){
throw new ServiceException("Request timed out, please try again."); //请求超时
}
//解密AES
String AESJson = AES256Util.decode(rsaDecodeData.getKey(),asy,rsaDecodeData.getKeyVI());
System.out.println("AESJson: "+AESJson);
return JSONObject.parseObject(AESJson);
} catch (Exception e) {
throw new RuntimeException("RSA decryption Exception: " +e.getMessage());
}
}
}4、ActivityRSAUtil 工具类
import org.apache.commons.io.IOUtils;
import javax.crypto.Cipher;
import java.io.ByteArrayOutputStream;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;
/**
* @module
* @author: qingxu.liu
* @date: 2023-02-07 16:54
* @copyright
**/
public class ActivityRSAUtil {
/**
* 字符集
*/
public static String CHARSET = "UTF-8";
/**
* 生成密钥对
* @param keyLength 密钥长度
* @return KeyPair
*/
public static KeyPair getKeyPair(int keyLength) {
try {
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA"); //默认:RSA/None/PKCS1Padding
keyPairGenerator.initialize(keyLength);
return keyPairGenerator.generateKeyPair();
} catch (NoSuchAlgorithmException e) {
throw new RuntimeException("生成密钥对时遇到异常" + e.getMessage());
}
}
/**
* 获取公钥
*/
public static byte[] getPublicKey(KeyPair keyPair) {
RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
return rsaPublicKey.getEncoded();
}
/**
* 获取私钥
*/
public static byte[] getPrivateKey(KeyPair keyPair) {
RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();
return rsaPrivateKey.getEncoded();
}
/**
* 公钥字符串转PublicKey实例
* @param publicKey 公钥字符串
* @return PublicKey
* @throws Exception e
*/
public static PublicKey getPublicKey(String publicKey) throws Exception {
byte[] publicKeyBytes = Base64.getDecoder().decode(publicKey.getBytes());
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKeyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
return keyFactory.generatePublic(keySpec);
}
/**
* 私钥字符串转PrivateKey实例
* @param privateKey 私钥字符串
* @return PrivateKey
* @throws Exception e
*/
public static PrivateKey getPrivateKey(String privateKey) throws Exception {
byte[] privateKeyBytes = Base64.getDecoder().decode(privateKey.getBytes());
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKeyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
return keyFactory.generatePrivate(keySpec);
}
/**
* 获取公钥字符串
* @param keyPair KeyPair
* @return 公钥字符串
*/
public static String getPublicKeyString(KeyPair keyPair){
RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic(); // 得到公钥
return new String(org.apache.commons.codec.binary.Base64.encodeBase64(publicKey.getEncoded()));
}
/**
* 获取私钥字符串
* @param keyPair KeyPair
* @return 私钥字符串
*/
public static String getPrivateKeyString(KeyPair keyPair){
RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate(); // 得到私钥
return new String(org.apache.commons.codec.binary.Base64.encodeBase64((privateKey.getEncoded())));
}
/**
* 公钥加密
* @param data 明文
* @param publicKey 公钥
* @return 密文
*/
public static String publicEncrypt(String data, RSAPublicKey publicKey) {
try {
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
byte[] bytes = rsaSplitCodec(cipher, Cipher.ENCRYPT_MODE, data.getBytes(CHARSET), publicKey.getModulus().bitLength());
return new String(org.apache.commons.codec.binary.Base64.encodeBase64(bytes));
} catch (Exception e) {
throw new RuntimeException("加密字符串[" + data + "]时遇到异常"+ e.getMessage());
}
}
/**
* 私钥解密
* @param data 密文
* @param privateKey 私钥
* @return 明文
*/
public static String privateDecrypt(String data, RSAPrivateKey privateKey) {
try {
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.DECRYPT_MODE, privateKey);
return new String(rsaSplitCodec(cipher, Cipher.DECRYPT_MODE, Base64.getDecoder().decode(data), privateKey.getModulus().bitLength()), CHARSET);
} catch (Exception e) {
throw new RuntimeException("privateKey解密字符串[" + data + "]时遇到异常"+ e.getMessage());
}
}
/**
* 私钥加密
* @param content 明文
* @param privateKey 私钥
* @return 密文
*/
public static String encryptByPrivateKey(String content, RSAPrivateKey privateKey){
try {
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.ENCRYPT_MODE, privateKey);
byte[] bytes = rsaSplitCodec(cipher, Cipher.ENCRYPT_MODE,content.getBytes(CHARSET), privateKey.getModulus().bitLength());
return new String(org.apache.commons.codec.binary.Base64.encodeBase64(bytes));
} catch (Exception e) {
throw new RuntimeException("privateKey加密字符串[" + content + "]时遇到异常" + e.getMessage());
}
}
/**
* 公钥解密
* @param content 密文
* @param publicKey 私钥
* @return 明文
*/
public static String decryByPublicKey(String content, RSAPublicKey publicKey){
try {
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.DECRYPT_MODE, publicKey);
return new String(rsaSplitCodec(cipher, Cipher.DECRYPT_MODE, Base64.getDecoder().decode(content), publicKey.getModulus().bitLength()), CHARSET);
} catch (Exception e) {
throw new RuntimeException("publicKey解密字符串[" + content + "]时遇到异常" +e.getMessage());
}
}
public static RSAPublicKey getRSAPublicKeyByString(String publicKey){
try {
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(Base64.getDecoder().decode(publicKey));
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
return (RSAPublicKey)keyFactory.generatePublic(keySpec);
} catch (Exception e) {
throw new RuntimeException("String转PublicKey出错" + e.getMessage());
}
}
public static RSAPrivateKey getRSAPrivateKeyByString(String privateKey){
try {
PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(Base64.getDecoder().decode(privateKey));
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
return (RSAPrivateKey)keyFactory.generatePrivate(pkcs8EncodedKeySpec);
} catch (Exception e) {
throw new RuntimeException("String转PrivateKey出错" + e.getMessage());
}
}
//rsa切割解码 , ENCRYPT_MODE,加密数据 ,DECRYPT_MODE,解密数据
private static byte[] rsaSplitCodec(Cipher cipher, int opmode, byte[] datas, int keySize) {
int maxBlock = 0; //最大块
if (opmode == Cipher.DECRYPT_MODE) {
maxBlock = keySize / 8;
} else {
maxBlock = keySize / 8 - 11;
}
ByteArrayOutputStream out = new ByteArrayOutputStream();
int offSet = 0;
byte[] buff;
int i = 0;
try {
while (datas.length > offSet) {
if (datas.length - offSet > maxBlock) {
//可以调用以下的doFinal（）方法完成加密或解密数据：
buff = cipher.doFinal(datas, offSet, maxBlock);
} else {
buff = cipher.doFinal(datas, offSet, datas.length - offSet);
}
out.write(buff, 0, buff.length);
i++;
offSet = i * maxBlock;
}
} catch (Exception e) {
throw new RuntimeException("加解密阀值为[" + maxBlock + "]的数据时发生异常: " + e.getMessage());
}
byte[] resultDatas = out.toByteArray();
IOUtils.closeQuietly(out);
return resultDatas;
}
}5、AES256Util 工具类
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.Security;
import java.util.Base64;
/**
* @module
* @author: qingxu.liu
* @date: 2023-02-07 16:14
* @copyright
**/
public class AES256Util {
private static final String AES = "AES";
/**
* 初始向量IV, 初始向量IV的长度规定为128位16个字节, 初始向量的来源为随机生成.
*/
/**
* 加密解密算法/加密模式/填充方式
*/
private static final String CIPHER_ALGORITHM = "AES/CBC/PKCS7Padding";
private static final Base64.Encoder base64Encoder = java.util.Base64.getEncoder();
private static final Base64.Decoder base64Decoder = java.util.Base64.getDecoder();
//通过在运行环境中设置以下属性启用AES-256支持
static {
Security.setProperty("crypto.policy", "unlimited");
}
/*
* 解决java不支持AES/CBC/PKCS7Padding模式解密
*/
static {
Security.addProvider(new BouncyCastleProvider());
}
/**
* AES加密
*/
public static String encode(String key, String content,String keyVI) {
try {
javax.crypto.SecretKey secretKey = new javax.crypto.spec.SecretKeySpec(key.getBytes(), AES);
javax.crypto.Cipher cipher = javax.crypto.Cipher.getInstance(CIPHER_ALGORITHM);
cipher.init(javax.crypto.Cipher.ENCRYPT_MODE, secretKey, new javax.crypto.spec.IvParameterSpec(keyVI.getBytes()));
// 获取加密内容的字节数组(这里要设置为utf-8)不然内容中如果有中文和英文混合中文就会解密为乱码
byte[] byteEncode = content.getBytes(java.nio.charset.StandardCharsets.UTF_8);
// 根据密码器的初始化方式加密
byte[] byteAES = cipher.doFinal(byteEncode);
// 将加密后的数据转换为字符串
return base64Encoder.encodeToString(byteAES);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* AES解密
*/
public static String decode(String key, String content,String keyVI) {
try {
javax.crypto.SecretKey secretKey = new javax.crypto.spec.SecretKeySpec(key.getBytes(), AES);
javax.crypto.Cipher cipher = javax.crypto.Cipher.getInstance(CIPHER_ALGORITHM);
cipher.init(javax.crypto.Cipher.DECRYPT_MODE, secretKey, new javax.crypto.spec.IvParameterSpec(keyVI.getBytes()));
// 将加密并编码后的内容解码成字节数组
byte[] byteContent = base64Decoder.decode(content);
// 解密
byte[] byteDecode = cipher.doFinal(byteContent);
return new String(byteDecode, java.nio.charset.StandardCharsets.UTF_8);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* AES加密ECB模式PKCS7Padding填充方式
* @param str 字符串
* @param key 密钥
* @return 加密字符串
* @throws Exception 异常信息
*/
public static String aes256ECBPkcs7PaddingEncrypt(String str, String key) throws Exception {
Cipher cipher = Cipher.getInstance("AES/ECB/PKCS7Padding");
byte[] keyBytes = key.getBytes(StandardCharsets.UTF_8);
cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(keyBytes, AES));
byte[] doFinal = cipher.doFinal(str.getBytes(StandardCharsets.UTF_8));
return new String(Base64.getEncoder().encode(doFinal));
}
/**
* AES解密ECB模式PKCS7Padding填充方式
* @param str 字符串
* @param key 密钥
* @return 解密字符串
* @throws Exception 异常信息
*/
public static String aes256ECBPkcs7PaddingDecrypt(String str, String key) throws Exception {
Cipher cipher = Cipher.getInstance("AES/ECB/PKCS7Padding");
byte[] keyBytes = key.getBytes(StandardCharsets.UTF_8);
cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(keyBytes, AES));
byte[] doFinal = cipher.doFinal(Base64.getDecoder().decode(str));
return new String(doFinal);
}
}以上是SpringBoot如何實作RAS+AES自動介面解密的詳細內容。更多資訊請關注PHP中文網其他相關文章！
熱AI工具
Undresser.AI Undress
人工智慧驅動的應用程序，用於創建逼真的裸體照片
AI Clothes Remover
用於從照片中去除衣服的線上人工智慧工具。
Undress AI Tool
免費脫衣圖片
Clothoff.io
AI脫衣器
Video Face Swap
使用我們完全免費的人工智慧換臉工具，輕鬆在任何影片中換臉！
熱門文章
熱工具
記事本++7.3.1
好用且免費的程式碼編輯器
SublimeText3漢化版
中文版，非常好用
禪工作室 13.0.1
強大的PHP整合開發環境
Dreamweaver CS6
視覺化網頁開發工具
SublimeText3 Mac版
神級程式碼編輯軟體(SublimeText3)
Springboot怎麼整合Jasypt實現設定檔加密
Jun 01, 2023 am 08:55 AM
Jasypt介紹Jasypt是一個java庫，它允許開發員以最少的努力為他/她的專案添加基本的加密功能，並且不需要對加密工作原理有深入的了解用於單向和雙向加密的高安全性、基於標準的加密技術。加密密碼，文本，數字，二進位檔案...適合整合到基於Spring的應用程式中，開放API，用於任何JCE提供者...添加如下依賴：com.github.ulisesbocchiojasypt-spring-boot-starter2. 1.1Jasypt好處保護我們的系統安全，即使程式碼洩露，也可以保證資料來源的
SpringBoot怎麼整合Redisson實現延遲隊列
May 30, 2023 pm 02:40 PM
使用場景1、下單成功，30分鐘未支付。支付超時，自動取消訂單2、訂單簽收，簽收後7天未進行評估。訂單超時未評價，系統預設好評3、下單成功，商家5分鐘未接單，訂單取消4、配送超時，推播簡訊提醒…對於延時比較長的場景、即時性不高的場景，我們可以採用任務調度的方式定時輪詢處理。如：xxl-job今天我們採
怎麼在SpringBoot中使用Redis實現分散式鎖
Jun 03, 2023 am 08:16 AM
一、Redis實現分散式鎖原理為什麼需要分散式鎖在聊分散式鎖之前，有必要先解釋一下，為什麼需要分散式鎖。與分散式鎖相對就的是單機鎖，我們在寫多執行緒程式時，避免同時操作一個共享變數產生資料問題，通常會使用一把鎖來互斥以保證共享變數的正確性，其使用範圍是在同一個進程中。如果換做是多個進程，需要同時操作一個共享資源，如何互斥？現在的業務應用通常是微服務架構，這也意味著一個應用會部署多個進程，多個進程如果需要修改MySQL中的同一行記錄，為了避免操作亂序導致髒數據，此時就需要引入分佈式鎖了。想要實現分
springboot讀取檔案打成jar包後存取不到怎麼解決
Jun 03, 2023 pm 04:38 PM
springboot讀取文件，打成jar包後訪問不到最新開發出現一種情況，springboot打成jar包後讀取不到文件，原因是打包之後，文件的虛擬路徑是無效的，只能通過流去讀取。文件在resources下publicvoidtest(){Listnames=newArrayList();InputStreamReaderread=null;try{ClassPathResourceresource=newClassPathResource("name.txt");Input
Springboot+Mybatis-plus不使用SQL語句進行多表新增怎麼實現
Jun 02, 2023 am 11:07 AM
在Springboot+Mybatis-plus不使用SQL語句進行多表添加操作我所遇到的問題準備工作在測試環境下模擬思維分解一下:創建出一個帶有參數的BrandDTO對像模擬對後台傳遞參數我所遇到的問題我們都知道,在我們使用Mybatis-plus中進行多表操作是極其困難的,如果你不使用Mybatis-plus-join這一類的工具,你只能去配置對應的Mapper.xml文件,配置又臭又長的ResultMap,然後再寫對應的sql語句,這種方法雖然看上去很麻煩,但具有很高的靈活性,可以讓我們
SpringBoot怎麼自訂Redis實作快取序列化
Jun 03, 2023 am 11:32 AM
1.自訂RedisTemplate1.1、RedisAPI預設序列化機制基於API的Redis快取實作是使用RedisTemplate範本進行資料快取操作的，這裡開啟RedisTemplate類，查看該類別的源碼資訊publicclassRedisTemplateextendsRedisAccessorimplementsRedisOperations,BeanClassLoaderAware{//聲明了value的各種序列化方式，初始值為空@NullableprivateRedisSe
SpringBoot與SpringMVC的比較及差別分析
Dec 29, 2023 am 11:02 AM
SpringBoot和SpringMVC都是Java開發中常用的框架，但它們之間有一些明顯的差異。本文將探究這兩個框架的特點和用途，並對它們的差異進行比較。首先，我們來了解一下SpringBoot。 SpringBoot是由Pivotal團隊開發的，它旨在簡化基於Spring框架的應用程式的建立和部署。它提供了一種快速、輕量級的方式來建立獨立的、可執行
springboot怎麼取得application.yml裡值
Jun 03, 2023 pm 06:43 PM
在專案中，很多時候需要用到一些配置信息，這些信息在測試環境和生產環境下可能會有不同的配置，後面根據實際業務情況有可能還需要再做修改。我們不能將這些設定在程式碼中寫死，最好是寫到設定檔中，例如可以把這些資訊寫到application.yml檔案中。那麼，怎麼在程式碼裡取得或使用這個位址呢？有2個方法。方法一：我們可以透過@Value註解的${key}即可取得設定檔（application.yml）中和key對應的value值，這個方法適用於微服務比較少的情形方法二：在實際專案中，遇到業務繁瑣，邏
