SpringBoot前后端加密讓數據傳輸更優雅
作者：一安
通過使用對稱加密(AES) 和 非對稱加密(RSA) 的方式來實現對數據的加密；即通過對稱加密進行業務數據體的加密，通過非對稱加密進行對稱加密密鑰的加密； 它結合了對稱加密的高效性 和 非對稱加密的安全性。
在Web應用中，確保前后端之間的數據傳輸安全是非常重要的。這通常涉及到使用HTTPS協議、數據加密、令牌驗證等安全措施。本文通過將前后端之間的傳輸數據進行加密，用于在Spring Boot應用中實現前后端傳輸加密設計。
一、數據加密方案
即使使用了HTTPS，也可能需要在應用層對數據進行額外的加密。這可以通過以下方式實現：
對稱加密： 加密解密是同一個密鑰，速度快，數據接收方需要公布其私鑰給數據傳輸方進行數據加密，安全性完全依賴于該密鑰。適合做大量數據或數據文件的加解密。
- 使用AES、DES等對稱加密算法對敏感數據進行加密和解密。
- 前后端需要共享一個密鑰（key）用于加密和解密。
- 密鑰的管理和傳輸需要特別注意安全性。
非對稱加密： 加密用公鑰，解密用私鑰。公鑰和私鑰是成對的(可借助工具生成，如openssl等)，即用公鑰加密的數據，一定能用其對應的私鑰解密，能用私鑰解密的數據，一定是其對應的公鑰加密。對大量數據或數據文件加解密時，效率較低。數據接收方需公布其公鑰給數據傳輸方，私鑰自己保留，安全性更高。
- 使用RSA、ECC等非對稱加密算法。
- 私鑰用于加密數據，公鑰用于解密數據。
- 公鑰可以公開，而私鑰需要安全存儲。
混合加密：
- 結合使用對稱加密和非對稱加密。
- 使用非對稱加密算法交換對稱加密的密鑰（會話密鑰），然后使用會話密鑰進行實際的數據加密和解密。
這里就贅述介紹每種加密的實現方式和原理。
1.1 數據加密實現方式
- 如果數據傳輸較大，密鑰不需要進行網絡傳輸，數據不需要很高的安全級別，則采用對稱加密，只要能保證密鑰沒有人為外泄即可；
- 如果數據傳輸小，而且對安全級別要求高，或者密鑰需要通過internet交換，則采用非對稱加密；
本文采用了兩者結合的方式(混合加密模式)，這樣是大多數場景下采用的加密方式。加密時序圖如下所示：
圖片
通過使用對稱加密(AES) 和 非對稱加密(RSA) 的方式來實現對數據的加密；即通過對稱加密進行業務數據體的加密，通過非對稱加密進行對稱加密密鑰的加密； 它結合了對稱加密的高效性 和 非對稱加密的安全性。
注意事項：
- 確保RSA公鑰在傳輸過程中是安全的，因為任何擁有這個公鑰的人都可以用它來加密AES密鑰，但只有擁有私鑰的人才能解密它。
- 確保在加密和解密過程中使用安全的加密庫和最新的加密算法標準。
- 定期更換密鑰對和對稱密鑰，以降低密鑰泄露的風險。
這種混合加密模式提供了安全性和效率之間的平衡。對稱加密（如AES）用于加密大量數據，因為它通常比非對稱加密更快。而非對稱加密（如RSA）用于加密密鑰，因為它提供了更強的安全性，特別是當密鑰需要在不安全的通道上傳輸時。
1.2 AES加密工具類創建
封裝AESUtil工具類時 pom.xml 中運用到的依賴：
<!-- hutool-all工具類依賴 -->
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
<version>5.8.18</version>
</dependency>AES加解密工具類 AESUtil 代碼：
package com.example.api_security_demo.utils;
import cn.hutool.core.codec.Base64;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.spec.SecretKeySpec;
import java.io.UnsupportedEncodingException;
import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Random;
/**
* @ClassName : AESUtil
* @Description : AES加密工具類
* @Author : AD
*/
public class AESUtil {
public static final String CHAR_ENCODING = "UTF-8";
/**
* [常見算法]AES、DES、RSA、Blowfish、RC4 等等
* [常見的模式] ECB (電子密碼本模式)、CBC (密碼分組鏈接模式)、CTR (計數模式) 等等
* [常見的填充] NoPadding、PKCS5Padding、PKCS7Padding 等等
*
* [AES算法]可以有以下幾種常見的值：
* AES：標準的AES算法。
* AES/CBC/PKCS5Padding：使用CBC模式和PKCS5填充的AES算法。
* AES/ECB/PKCS5Padding：使用ECB模式和PKCS5填充的AES算法。
* AES/GCM/NoPadding：使用GCM模式的AES算法，不需要填充。
* AES/CCM/NoPadding：使用CCM模式的AES算法，不需要填充。
* AES/CFB/NoPadding：使用CFB模式的AES算法，不需要填充。
* */
public static final String AES_ALGORITHM = "AES";
public static char[] HEXCHAR = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
/**
* Description: 隨機生成 AESKey密鑰
*
* @param length 隨機生成密鑰長度
* @return java.lang.String
*/
public static String getAESKey(int length) throws Exception
{
/*
* Random類用于生成偽隨機數。
* */
Random random = new Random();
StringBuilder ret = new StringBuilder();
for(int i = 0; i < length; i++)
{
// 選擇生成數字還是字符
boolean isChar = (random.nextInt(2) % 2 == 0);
/* 0隨機生成一個字符*/
if (isChar)
{
// 選擇生成大寫字母 / 小寫字母
int choice = (random.nextInt(2) % 2 == 0) ? 65 : 97;
ret.append((char) (choice+random.nextInt(26)));
/* 1隨機生成一個數字 */
}else
{
ret.append( random.nextInt(10));
}
}
return ret.toString();
}
/**
* Description: 加密
*
* @param data 待加密數據內容
* @param aesKey 加密密鑰
* @return byte[]
*/
public static byte[] encrypt(byte[] data,byte[] aesKey)
{
if (aesKey.length != 16)
{
throw new RuntimeException("Invalid AES key length (must be 16 bytes) !");
}
try{
/*
* 創建一個SecretKeySpec對象來包裝AES密鑰。
* 它使用了aesKey字節數組作為密鑰，并指定算法為"AES"。
* 這個對象用來提供對稱加密算法的密鑰。
* */
SecretKeySpec secretKey = new SecretKeySpec(aesKey, "AES");
/*
* 獲取SecretKeySpec對象中的編碼形式，將其存儲在encodedFormat字節數組中。
* 這個編碼形式可以被用來重新構造密鑰。
* */
byte[] encodedFormat = secretKey.getEncoded();
/*
* 使用encodedFormat字節數組創建了另一個SecretKeySpec對象secKey。
* 這個對象也用來提供對稱加密算法的密鑰。
* */
SecretKeySpec secKey = new SecretKeySpec(encodedFormat, "AES");
/*
* 使用Cipher類的getInstance()方法獲取了一個Cipher對象(創建密碼器)。
* 這個對象用來完成加密或解密的工作。
* */
Cipher cipher = Cipher.getInstance(AES_ALGORITHM);
/*
* 碼調用init()方法來初始化Cipher對象(初始化)。
* 它要求傳入操作模式和提供密鑰的對象，這里使用Cipher.ENCRYPT_MODE代表加密模式，以及之前創建的secKey對象作為密鑰。
* */
cipher.init(Cipher.ENCRYPT_MODE,secKey);
/*
* 用Cipher對象對data進行加密操作，得到加密后的結果存儲在result字節數組中。
* */
byte[] result = cipher.doFinal(data);
return result;
}catch (Exception e){
throw new RuntimeException(" encrypt fail! ",e);
}
}
/**
* Description: 解密
*
* @param data 解密數據
* @param aesKey 解密密鑰
* @return byte[]
*/
public static byte[] decrypt(byte[] data,byte[] aesKey)
{
if (aesKey.length != 16)
{
throw new RuntimeException(" Invalid AES Key length ( must be 16 bytes)");
}
try {
SecretKeySpec secretKeySpec = new SecretKeySpec(aesKey, "AES");
byte[] encodedFormat = secretKeySpec.getEncoded();
SecretKeySpec secKey = new SecretKeySpec(encodedFormat, "AES");
/* 創建密碼器 */
Cipher cipher = Cipher.getInstance(AES_ALGORITHM);
/* 初始化密碼器 */
cipher.init(Cipher.DECRYPT_MODE,secKey);
byte[] result = cipher.doFinal(data);
return result;
}catch (Exception e){
throw new RuntimeException(" Decrypt Fail !",e);
}
}
/**
* Description:加密數據，并轉換為Base64編碼格式！
*
* @param data 待加密數據
* @param aeskey 加密密鑰
* @return java.lang.String
*/
public static String encryptToBase64(String data,String aeskey)
{
try {
byte[] valueByte = encrypt(data.getBytes(CHAR_ENCODING), aeskey.getBytes(CHAR_ENCODING));
/* 加密數據轉 Byte[]--> 換為Base64 --> String */
return Base64.encode(valueByte);
}catch (UnsupportedEncodingException e){
throw new RuntimeException(" Encrypt Fail !",e);
}
}
/**
* Description: 解密數據，將Basse64格式的加密數據進行解密操作
*
* @param data
* @param aeskey
* @return java.lang.String
*/
public static String decryptFromBase64(String data,String aeskey)
{
try {
byte[] originalData = Base64.decode(data.getBytes());
byte[] valueByte = decrypt(originalData,aeskey.getBytes(CHAR_ENCODING));
return new String(valueByte,CHAR_ENCODING);
}catch (UnsupportedEncodingException e){
throw new RuntimeException("Decrypt Fail !",e);
}
}
/**
* Description:加密數據，aesKey為Base64格式時，并將加密后的數據轉換為Base64編碼格式
*
* @param data
* @param aesKey
* @return java.lang.String
*/
public static String encryptWithKeyBase64(String data,String aesKey)
{
try{
byte[] valueByte = encrypt(data.getBytes(CHAR_ENCODING), Base64.decode(aesKey.getBytes()));
return Base64.encode(valueByte);
}catch (UnsupportedEncodingException e){
throw new RuntimeException("Encrypt Fail!",e);
}
}
/**
* Description: 解密數據，數據源為Base64格式，且 aesKey為Base64編碼格式
*
* @param data
* @param aesKey
* @return java.lang.String
*/
public static String decryptWithKeyBase64(String data,String aesKey)
{
try {
byte[] originalDate = Base64.decode(data.getBytes());
byte[] valueByte = decrypt(originalDate,Base64.decode(aesKey.getBytes()));
return new String(valueByte,CHAR_ENCODING);
}catch (UnsupportedEncodingException e){
throw new RuntimeException("Decrypt Fail !",e);
}
}
/**
* Description:通過密鑰生成器生成一個隨機的 AES 密鑰，并將其以字節數組的形式返回。
* 主要功能是生成并返回一組隨機的密鑰字節數組，這些字節數組可用于加密和解密數據。
*
* @param
* @return byte[]
*/
public static byte[] generateRandomAesKey()
{
KeyGenerator keyGenerator = null;
try{
/*
* KeyGenerator是Java Cryptography Architecture（JCA）提供的主要密鑰生成器類之一，用于生成對稱加密算法的密鑰。
* 獲取一個用于生成AES算法密鑰的KeyGenerator實例，以便在加密和解密操作中使用該密鑰。
* */
keyGenerator = KeyGenerator.getInstance(AES_ALGORITHM);
}catch (NoSuchAlgorithmException e){
throw new RuntimeException("GenerateRandomKey Fail ！",e);
}
/*
* SecureRandom 類提供了一種用于生成加密強隨機數的實現。
* */
SecureRandom secureRandom = new SecureRandom();
/*
* 初始化密鑰生成器 keyGenerator。
* 初始化密鑰生成器時使用了 SecureRandom 實例，以確保生成的密鑰具有足夠的隨機性。
* */
keyGenerator.init(secureRandom);
/*
* 調用 generateKey() 方法，使用初始化后的 keyGenerator 生成密鑰對象 key。
* */
Key key = keyGenerator.generateKey();
//返回生成的密鑰的字節數組表示。
return key.getEncoded();
}
/**
* Description: 通過密鑰生成器生成一個隨機的 AES 密鑰，并轉化為Base64格式
*
* @param
* @return java.lang.String
*/
public static String generateRandomAesKeyWithBase64()
{
return Base64.encode(generateRandomAesKey());
}
/* ！！當GET請求進行加密時，地址上的加密參數就以16進制字符串的方式進行傳輸，否則特殊符號路徑無法解析[ +、/、=]等Base64編碼格式 */
/**
* Description: 從Byte[] 數組轉 16進制字符串
*
* @param b
* @return java.lang.String
*/
public static String toHexString(byte[] b)
{
/*
* 每個字節都可以用兩個十六進制字符來表示，因此初始化的容量是字節數組長度的兩倍。
* */
StringBuilder sb = new StringBuilder(b.length * 2);
for (int i = 0; i<b.length ;i++)
{
/*
* 首先取字節的高四位，然后查找對應的十六進制字符，并將其追加到StringBuilder中
* */
sb.append(HEXCHAR[(b[i] & 0xf0) >>> 4]);
/*
* 取字節的低四位，找到對應的十六進制字符，并追加到StringBuilder中。
* */
sb.append(HEXCHAR[b[i] & 0x0f]);
}
return sb.toString();
}
/**
* Description: 從16進制字符串轉 byte[] 數組
*
* @param s
* @return byte[]
*/
public static final byte[] toBytes(String s)
{
byte[] bytes;
bytes = new byte[s.length() / 2];
for (int i = 0; i < bytes.length ; i++)
{
bytes[i] = (byte) Integer.parseInt(s.substring(2*i,2*i+2),16);
}
return bytes;
}
}AES加解密工具類方法代碼解析（為了方便自己理解和使用，有必要簡單分類記錄一下工具類中的方法接口）：
AESUtil工具類中的方法封裝的比較雜亂，通過梳理之后更加能理清每個方法的具體用法和功能！
生成AES密鑰的方法:
該工具類中總共封裝了兩種 生成 AES密鑰的方法 String getAESKey(int length) 和 String generateRandomAesKeyWithBase64()
- getAESKey 方法生成的密鑰是 由數字(0-9)、小寫字母、大寫字母隨機組成的普通字符串;
- generateRandomAesKeyWithBase64() 方法生成的密鑰是 通過javax.crypto.KeyGenerator 密鑰生成器生成Byte[] 類型的數據 在將該 byte[] 轉換為 Base64編碼格式。
AES加密數據方法:
1.AES工具類封裝的加密數據方法有以下幾種byte[] encrypt(byte[] data,byte[] aesKey)、 String encryptToBase64(String data,String aeskey) 和 String encryptWithKeyBase64(String data,String aesKey) 共三種加密方式：
注：其實其余加密方法都是基于該方法進行封裝的。也可以根據自己需求來調整，注意區別在于傳入的數據格式有所區別??！
2.String encryptToBase64(String data,String aeskey) 該AES加密方法是通過傳入加密數據的字符串，同時傳入字符格式的AES密鑰Key(通過getAESKey生成的密鑰)；方法內部會將傳入進來的 待加密數據 data 和 aesKey密鑰轉換為 byte[] 格式，然后在調用第一種加密方法；最后生成的加密數據byte[] 也會在內部自動轉換為Base64編碼格式 然后返回。
3.String encryptWithKeyBase64(String data,String aesKey) 該AES加密方法，需要傳入 字符串形式的加密數據，以及Base64編碼格式的AES密鑰 (該密鑰主要是通過generateRandomAesKeyWithBase64() 方法生成的密鑰數據 為Base64編碼格式)。加密方法內部在接收到 待加密數據后會自動轉換為byte[]格式；在接收到Base64編碼格式的AES密鑰后，通過Base64.decode() 將其解碼為 byte[]。然后在調用原始的加密方法對待加密數據進行加密操作。最終加密后的數據byte[] 通過 new String(valueByte,“UTF-8”) 的方式轉換為字符串返回。
AES解密數據方法：
AES工具類中封裝的解密方法，對應于加密方法：byte[] decrypt(byte[] data,byte[] aesKey)、 String decryptFromBase64(String data,String aeskey) 和 String decryptFromBase64(String data,String aeskey) 三種方式。
該三種方式分別與上面三種加密方式是對應的。需要注意傳入的數據封裝格式就行。
- 第一種解密方法就需要傳入 加密后數據格式 byte[]，密鑰格式 byte[]
- 第二種解密方法對應于上面的第二種加密方法。需要傳入的加密數據為Base64編碼格式( 通過加密方法生成byte[] 后 在轉換為 Base64格式 )，需要傳入AES密鑰格式就為普通字符串格式(通過 String getAESKey(int length) 方法生成的密鑰)。
- 第三種解密方法，需要傳入的待解密數據 為Base64編碼格式，需要傳入的AES密鑰也為Base64編碼格式
String toHexString(byte[] b) 方法
該方法是將byte[] 字節數據轉換為16進制的字符串數據，后續會利用到。比如在Get請求種傳輸加密數據，如果前端加密后的數據需要放入地址中進行傳輸到后端；若采用Base64編碼格式數加密數據進行傳輸時，加密內容會包含 +、\、= 三個符號，無法在地址中進行傳輸了。
所以這里封裝了該方法，通過調用該方法，將加密后的byte[] 字節數據數據轉換為 HexString 16進制字符串格式(只包含了 0~9、a、b、c、d、e、f)。這樣Get請求中的加密數據就可以通過地址進行傳輸了
byte[] toBytes(String s) 方法
該方法于 toHexString 方法相對應，將轉換為HexString十六進制的字符串 還原為字節數據Byte[]。
1.3 RSA加密工具類創建
RSA加密工具類，同樣引用了 hutool-all 依賴工具類。
package com.example.api_security_demo.utils;
import cn.hutool.core.codec.Base64Encoder;
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.*;
/**
* @ClassName : RSAUtil
* @Description : RSA加密工具類
* @Author : AD
*/
public class RSAUtil {
/**
* "SHA256withRSA" 是一種使用 SHA-256 哈希算法和 RSA 加密算法結合的數字簽名算法。
* 在這種算法中，數據首先會通過 SHA-256 進行哈希處理，得到一個固定長度的摘要，然后使用 RSA 私鑰對這個摘要進行加密，從而生成數字簽名。
* */
public static final String ALGORITHM_SHA256WITHRSA = "SHA256withRSA";
public static final String KEY_ALGORITHM ="RSA";
//RSA最大加密明文大小
public static final int MAX_ENCRYPT_BLOCK = 117;
//RSA最大解密密文大小
public static final int MAX_DECRYPT_BLOCK = 128;
private static char[] HEXCHAR = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
/**
* Description: 公鑰分段加密
*
* @param data 待加密源數據
* @param publicKey 公鑰（BASE64編碼）
* @param length 段長 1024長度的公鑰最大取117
* @return byte[]
*/
public static byte[] encryptByPublicKey(byte[] data,String publicKey,int length) throws Exception
{
/*
* 將BASE64編碼格式 publicKey進行解碼
* */
byte[] publicKeyByte = decryptBASE64(publicKey);
/*
* 使用X509EncodedKeySpec類創建了一個X.509編碼的KeySpec對象，并將publicKeyByte作為參數傳入。
* 將公鑰 [字符串] 解碼成 [公鑰對象] ，以便用于加密數據。
* */
X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(publicKeyByte);
/*
* 通過KeyFactory獲取了RSA的實例
* */
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
/*
* 調用generatePublic方法使用之前創建的X509EncodedKeySpec對象來生成公鑰。
* */
Key generatePublicKey = keyFactory.generatePublic(x509EncodedKeySpec);
/*
* 創建一個Cipher實例，它是用于加密或解密數據的對象。Cipher類提供了加密和解密功能，并支持許多不同的加密算法。
* 在這里，getInstance 方法中傳入了keyFactory.getAlgorithm()[獲取與指定密鑰工廠相關聯的算法名稱。]，它用于獲取與指定算法關聯的 Cipher 實例。
* */
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
/*
* 初始化 Cipher 對象。
* 在初始化過程中，指定加密模式為 ENCRYPT_MODE，并傳入了之前生成的公鑰 generatePublicKey。
* */
cipher.init(Cipher.ENCRYPT_MODE,generatePublicKey);
int inputLen = data.length;
ByteArrayOutputStream out = new ByteArrayOutputStream();
//段落起始位置
int offSet = 0;
byte[] cache;
int i = 0;
//對數據進行分段加密
while (inputLen - offSet > 0)
{
if (inputLen - offSet > length) {
cache = cipher.doFinal(data,offSet,length);
} else {
cache = cipher.doFinal(data,offSet,inputLen-offSet);
}
out.write(cache,0,cache.length);
i++;
offSet = i * length;
}
byte[] encryptDate = out.toByteArray();
out.close();
return encryptDate;
}
/**
* Description:
*
* @param data 待解密數據
* @param privateKey 私密（BUSE64編碼）
* @param length 分段解密長度 128
* @return byte[]
*/
public static byte[] decryptByPrivateKey(byte[] data,String privateKey,int length) throws Exception
{
byte[] privateKeyByte = decryptBASE64(privateKey);
PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(privateKeyByte);
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
Key generatePrivateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.DECRYPT_MODE,generatePrivateKey);
int inputLen = data.length;
ByteArrayOutputStream out = new ByteArrayOutputStream();
int offSet = 0;
byte[] cache;
int i = 0;
//對數據進行分段解密
while (inputLen - offSet > 0)
{
if (inputLen - offSet > length)
{
cache = cipher.doFinal(data,offSet,length);
} else {
cache = cipher.doFinal(data,offSet,inputLen - offSet);
}
out.write(cache,0,cache.length);
i++;
offSet = i * length;
}
byte[] decryptData = out.toByteArray();
out.close();
return decryptData;
}
/**
* Description: BASE64解碼
*
* @param src
* @return byte[]
*/
public static byte[] decryptBASE64(String src)
{
sun.misc.BASE64Decoder decoder = new sun.misc.BASE64Decoder();
try{
return decoder.decodeBuffer(src);
}catch (Exception ex){
return null;
}
}
/**
* Description: BASE64編碼
*
* @param src
* @return java.lang.String
*/
public static String encryptBASE64(byte[] src)
{
sun.misc.BASE64Encoder encoder = new sun.misc.BASE64Encoder();
return encoder.encode(src);
}
/**
* Description: 從Byte[] 數組轉 16進制字符串
*
* @param b
* @return java.lang.String
*/
public static String toHexString(byte[] b)
{
/*
* 每個字節都可以用兩個十六進制字符來表示，因此初始化的容量是字節數組長度的兩倍。
* */
StringBuilder sb = new StringBuilder(b.length * 2);
for (int i = 0; i<b.length ;i++)
{
/*
* 首先取字節的高四位，然后查找對應的十六進制字符，并將其追加到StringBuilder中
* */
sb.append(HEXCHAR[(b[i] & 0xf0) >>> 4]);
/*
* 取字節的低四位，找到對應的十六進制字符，并追加到StringBuilder中。
* */
sb.append(HEXCHAR[b[i] & 0x0f]);
}
return sb.toString();
}
/**
* Description: 從16進制字符串轉 byte[] 數組
*
* @param s
* @return byte[]
*/
public static final byte[] toBytes(String s)
{
byte[] bytes;
bytes = new byte[s.length() / 2];
for (int i = 0; i < bytes.length ; i++)
{
bytes[i] = (byte) Integer.parseInt(s.substring(2*i,2*i+2),16);
}
return bytes;
}
/**
* Description: 判斷對象是否為null
*/
public static boolean isEmpty(Object str) {
return (str == null || "".equals(str));
}
/**
* RSA 公鑰私鑰生成器
* */
public static Map generateRandomToBase64Key() throws Exception{
String KEY_ALGORITHM ="RSA";
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORITHM);
//密鑰位數
keyPairGenerator.initialize(1024);
//創建公鑰/私鑰
KeyPair keyPair = keyPairGenerator.generateKeyPair();
RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
byte[] publicKeyEncoded = publicKey.getEncoded();
byte[] privateKeyEncoded = privateKey.getEncoded();
HashMap<String,String> map = new HashMap<>();
map.put("publicKey", Base64Encoder.encode(publicKeyEncoded));
map.put("privateKey",Base64Encoder.encode(privateKeyEncoded));
return map;
}
/**
* Description: 根據請求參數Map集合，排號順序Sort，組裝生成對應請求中的簽名參數sign
*
* @param map 請求參數Map集合
* @param allowValueNull 是否允許map中的值為null；true允許：若允許為空則會出現a=&b=
* @return java.lang.String
*/
public static String generateSortSign(Map<String,String> map,boolean allowValueNull)
{
List<String> keys = new ArrayList<>(map.size());
for ( String key : map.keySet() )
{
/*
* 排除下列參數數據
* 1.不允許出現空value 且 map中為null 的鍵值對
* 2.參數簽名內容鍵值對
* */
if ( (!allowValueNull && isEmpty(map.get(key))) || "sign".equals(key) || "signValue".equals(key) )
{
continue;
}
keys.add(key);
}
/*
* sort靜態方法用于按自然順序或自定義順序對List進行排序
* */
Collections.sort(keys);
StringBuffer stringBuffer = new StringBuffer();
boolean isFirst = true;
for (String key : keys){
if (isFirst){
stringBuffer.append(key).append("=").append(map.get(key));
isFirst = false;
continue;
}
stringBuffer.append("&").append(key).append("=").append(map.get(key));
}
return stringBuffer.toString();
}
/**
* Description: 用于生成數據的數字簽名，并將簽名數據轉換為十六進制字符串格式返回
*
* @param rawDate 簽名裸數據
* @param privateKey 私鑰
* @param algorithm 簽名驗算算法
* @return java.lang.String
*/
public static String generateSign(byte[] rawDate,String privateKey,String algorithm) throws Exception
{
byte[] privateKeyBytes = decryptBASE64(privateKey);
PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(privateKeyBytes);
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
PrivateKey generatePrivate = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
/*
* 使用指定的簽名算法algorithm，通過Signature實例獲取簽名對象signature。
* */
Signature signature = Signature.getInstance(algorithm);
/*
* 初始化簽名對象，傳入生成的私鑰generatePrivate。
* */
signature.initSign(generatePrivate);
/*
* 將要簽名的裸數據rawData傳入簽名對象。
* */
signature.update(rawDate);
/*
* 生成簽名數據sign
* */
byte[] sign = signature.sign();
return toHexString(sign);
}
/**
* Description: 驗證簽名
*
* @param data 請求數據
* @param publicKey 公鑰
* @param sign 簽名數據
* @param algorithm 簽名驗算算法
* @return boolean
*/
public static boolean verify(byte[] data,String publicKey,String sign,String algorithm) throws Exception
{
byte[] publicKeyBytes = decryptBASE64(publicKey);
X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(publicKeyBytes);
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
PublicKey generatePublicKey = keyFactory.generatePublic(x509EncodedKeySpec);
Signature signature = Signature.getInstance(algorithm);
signature.initVerify(generatePublicKey);
signature.update(data);
return signature.verify( toBytes(sign) );
}
}RSAUtil加解密工具類方法代碼解析（為了方便自己理解和使用，有必要簡單分類記錄一下工具類中的方法接口）：
- 生成密鑰對方法：
Map generateRandomToBase64Key()- byte[] 與 Base64編碼互相轉換的方法：
byte[] decryptBASE64(String src)
String encryptBASE64(byte[] src)- HexString 十六進制字符串 與 byte[] 字節數組 互相轉換的方法：
String toHexString(byte[] b)
byte[] toBytes(String s)- RSA加密/解密方法：
byte[] encryptByPublicKey(byte[] data,String publicKey,int length)RSAUtil工具類中的加密接口就只有一個，最終加密后的數據會以字節數組 byte[] 格式返回。最終用戶想將密文以什么形式傳輸都可以( String() 字符串形式、Base64編碼格式、HexString十六進制字符串形式 )。
byte[] decryptByPrivateKey(byte[] data,String privateKey,int length)在解碼數據時，必須將密文數據根據對應的數據格式轉換為 byte[] 后傳入解碼方法。
- Base64格式編碼解碼方法：
byte[] decryptBASE64(String src)
String encryptBASE64(byte[] src)二、解密傳輸數據實現方案
依托與SpringBoot進行開發，在后臺中需要解密的請求接口，是采用了FIlter來實現解密操作。
圖片
采用 FIlter 來對加密數據進行解密的好處之一是：Filter 獲取到參數后，可以將密文參數解密之后，重新重寫請求參數。這樣在Controller層處理業務邏的接口可以按照正常方式進行開發，@RequestBody、@RequestParam 等注解都能正常使用。
2.1 Request 流只能讀取一次的問題
在接口調用連接中，request的請求流只能調用一次，處理之后，如果之后還需要用到請求流獲取數據，就會發現數據為空。比如使用了filter或者aop在接口處理之前，獲取了request中的數據，對參數進行了校驗，那么之后就不能在獲取request請求流了。
解決辦法：
繼承HttpServletRequestWrapper，將請求中的流copy一份，復寫getInputStream和getReader等方法供外部使用。每次調用后的getInputStream方法都是從復制出來的二進制數組中進行獲取，這個二進制數組在對象存在期間一致存在。通過HttpServletRequestWrapper可以獲取到前端加密的請求參數，同時也可以將解密后的參數設置進去。
- Post請求： 采用Filter來實現 加密傳輸數據的解密功能，在解密對應request請求流中的數據之后。將解密后的數據替換至自定義封裝的requestWrapper對象中 body中。
- Get請求： 地址欄中添加了加密數據，在Filter進行解密之后，會將請求數據存入自定義封裝的 requestWrapper 對象中的 Map集合數據中。在重寫父類的 getParament() 等方法。
這里需要特別注意；對于MultipartRequest請求如果不做處理HttpServletRequestWrapper中是獲取不到參數的；
自定義 RequestWrapper對象：
package com.example.api_security_demo.common.core.wrapper;
import com.alibaba.fastjson2.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.multipart.MultipartRequest;
import javax.servlet.ReadListener;
import javax.servlet.ServletInputStream;
import javax.servlet.ServletRequest;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.io.*;
import java.nio.charset.Charset;
import java.util.*;
/**
* @ClassName : RequestWrapper
* @Description : 自定義Request，解決request請求流中的數據二次或多次使用問題
* 繼承HttpServletRequestWrapper，將請求體中的流copy一份，覆寫getInputStream()和getReader()方法供外部使用。
* 每次調用覆寫后的getInputStream()方法都是從復制出來的二進制數組中進行獲取，這個二進制數組在對象存在期間一直存在，這樣就實現了流的重復讀取。
* @Author : AD
*/
@Slf4j
public class RequestWrapper extends HttpServletRequestWrapper {
/**
* 存儲Body數據
* */
private byte[] body;
//============
/**
* 保存原始Request對象，當請求為 MultipartRequest 文件上傳類的請求操作
*/
private HttpServletRequest request;
/**
* 額外參數可以加到這個里面 重寫getParameter() 方法 ，從而使請求中不存在的參數，通過該Map集合中獲?。?！
*/
private Map<String, String[]> parameterMap = new LinkedHashMap<>();
/**
* Description: requestWrapper 請求包裝類的構造方法
*
* @param request
* @return
*/
public RequestWrapper(HttpServletRequest request)throws IOException
{
super(request);
//[文件上傳相關的操作]
this.request = request;
if(request instanceof MultipartRequest){
// 如果是[文件上傳類]請求
this.parseBody(request);
}else{
//[普通請求類]將Body數據存儲起來
String bodyString = getBodyString(request);
body = bodyString.getBytes(Charset.defaultCharset());
}
}
/* [MultipartRequest 文件上傳]相關操作接口 */
/**
* 如果是 MultipartRequest，需要解析參數信息
*/
private void parseBody(HttpServletRequest request) {
Map<String,Object> parameterMap = new LinkedHashMap<>();
Enumeration<String> parameterNames = request.getParameterNames();
while(parameterNames.hasMoreElements()){
String name = parameterNames.nextElement();
String[] values = request.getParameterValues(name);
parameterMap.put(name, (values !=null && values.length == 1) ? values[0] : values);
}
// 將解析出來的參數，轉換成JSON并設置到body中保存
this.body = JSONObject.toJSONString(parameterMap).getBytes(Charset.defaultCharset());
}
public void setBody(byte[] body)
{
this.body = body;
try {
if(this.request instanceof MultipartRequest){
//[文件上傳請求相關的操作]
//todo 將Json格式body數據轉換為mp
//this.setParameterMap(JsonUtil.json2map(body));
String bodyStr = new String(body, "UTF-8");
com.fasterxml.jackson.databind.ObjectMapper objectMapper = new com.fasterxml.jackson.databind.ObjectMapper();
Map<String, Object> bodyMap = objectMapper.readValue(bodyStr, Map.class);
this.setParameterMap(bodyMap);
}
} catch (Exception e) {
log.error("轉換參數異常，參數：{}，異常：{}",body, e);
}
}
/**
* Description:讀取請全體Body中數據 [從 requestWrapper中讀取]
*
* @param
* @return java.lang.String
*/
public String getBodyString(){
final InputStream inputStream = new ByteArrayInputStream(body);
return inputStreamToString(inputStream);
}
/**
* Description: 讀取請求體Body中數據 [從HttpServletRequest中讀取]
*
* @param request
* @return java.lang.String
*/
public String getBodyString(final ServletRequest request)
{
try {
return inputStreamToString(request.getInputStream());
}catch (IOException e){
log.error("Read Request Body IO_Stream Fail !",e);
throw new RuntimeException(e);
}
}
/**
* Description: 將inputStream流里面的數據讀取出來并轉換為字符串形式
*
* @param inputStream
* @return java.lang.String
*/
private String inputStreamToString(InputStream inputStream){
StringBuilder sb = new StringBuilder();
BufferedReader reader = null;
try {
reader = new BufferedReader(new InputStreamReader(inputStream, Charset.defaultCharset()));
String line;
while ((line = reader.readLine()) != null){
sb.append(line);
}
}catch (IOException e){
log.error("BufferedReader is Fail !",e);
throw new RuntimeException(e);
}finally {
if (reader != null){
try {
reader.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
return sb.toString();
}
@Override
public BufferedReader getReader() throws IOException {
return new BufferedReader(new InputStreamReader(getInputStream()));
}
@Override
public ServletInputStream getInputStream() throws IOException {
final ByteArrayInputStream inputStream = new ByteArrayInputStream(body);
return new ServletInputStream() {
@Override
public boolean isFinished() {
return false;
}
@Override
public boolean isReady() {
return false;
}
@Override
public void setReadListener(ReadListener readListener) {
}
@Override
public int read() throws IOException {
return inputStream.read();
}
};
}
// [Get請求相關操作，封裝Request.getParameter()中的相關參數 ]
/**
* Description: The default behavior of this method is to return getParameter(Stringname) on the wrapped request object.
*
* @param name
* @return java.lang.String
* @date 2024-05-13
*/
@Override
public String getParameter(String name) {
String result = super.getParameter(name);
// 如果參數獲取不到則嘗試從參數(自定義封裝的存貯零時請求數據的集合)Map中獲取，并且只返回第一個
if(result==null && this.parameterMap.containsKey(name)){
result = this.parameterMap.get(name)[0];
}
return result;
}
/**
* The default behavior of this method is to return getParameterMap() on the
* wrapped request object.
*/
@Override
public Map<String, String[]> getParameterMap() {
// 需要將原有的參數加上新參數 返回
Map<String,String[]> map = new HashMap<>(super.getParameterMap());
for(String key: this.parameterMap.keySet()){
map.put(key, this.parameterMap.get(key));
}
return Collections.unmodifiableMap(map);
}
/**
* The default behavior of this method is to return
* getParameterValues(String name) on the wrapped request object.
*
* @param name
*/
@Override
public String[] getParameterValues(String name) {
String[] result = super.getParameterValues(name);
if(result == null && this.parameterMap.containsKey(name)){
result = this.parameterMap.get(name);
}
return result;
}
/**
* The default behavior of this method is to return getParameterNames() on
* the wrapped request object.
*/
@Override
public Enumeration<String> getParameterNames() {
Enumeration<String> parameterNames = super.getParameterNames();
Set<String> names = new LinkedHashSet<>();
if(parameterNames !=null){
while(parameterNames.hasMoreElements()){
names.add(parameterNames.nextElement());
}
}
// 添加后期設置的參數Map
if(!this.parameterMap.isEmpty()){
names.addAll(this.parameterMap.keySet());
}
return Collections.enumeration(names);
}
/**
* 設置參數map
* @param json2map
*/
public void setParameterMap(Map<String, Object> json2map) {
if(json2map != null && !json2map.isEmpty()) {
for (String key : json2map.keySet()){
//獲取map中對應key的value
Object value = json2map.get(key);
if(this.parameterMap.containsKey(key)){
//如果額外參數HashLink中包含該參數，則在賦值加入到String[] 中
String[] originalArray = this.parameterMap.get(key);
int originalLength = originalArray.length;
originalArray = Arrays.copyOf(originalArray,originalLength + 1);
originalArray[originalLength] = String.valueOf(value);
//this.parameterMap.put(key, Collection.add(this.parameterMap.get(key), value));
this.parameterMap.put(key,originalArray);
}else{
this.parameterMap.put(key, new String[]{String.valueOf(value)});
}
}
}
}
}RequestWrapper類方法代碼解析（為了方便自己理解和使用，有必要簡單分類記錄一下工具類中的方法接口）：這里自定義封裝的 RequestWrapper對象，繼承 HttpServletRequestWrapper。
- 通過重寫 getReader() 、getInputStream() 等方法，從而可以實現通過request對象讀取body數據時，能夠直接獲取到該對象中我們自己封裝的用于存放請求體數據的屬性byte[] body。
- void setBody(byte[] body) 方法可以用來給自定義封裝的屬性body進行賦值，在 解密請求數據的 FIlter中，解密了body數據后，通過調用該方法將解密后的body數據存入requestWrapper對象。這樣在后續的業務操作中直接通過request對象獲取到的body數據就是已經解密的數據。實現了業務無感知！
- void setParameterMap(Map<String, Object> json2map) 在解密Filter中，將Get請求中地址上的加密數據進行解密之后，調用該方法就將解密后的Get請求數據封裝到 requestWrapper對象中的Map集合中實現后續調用request.getParameter() 方法時能夠獲取到解密后的參數。
- 重寫父類 getParameter(String name)、Map<String, String[]> getParameterMap()、 String[] getParameterValues(String name)等方法，實習在getRequestParameter()數據時，也能夠在requestWrapper對象中的Map集合中獲取參數數據。
2.2 過濾器Filter解密請求參數
這里封裝的解密參數過濾器Filter中，首先需要通過請求頭中的 aksEncrypt數據判斷該請求是否為加密請求，如果不是則直接放行不做解密操作。如果需要解密的請求，首先判斷請求類型在進行對應的解密處理。
圖片
Filter解密數據過濾器代碼：
package com.example.api_security_demo.filter;
import com.alibaba.fastjson2.JSONObject;
import com.example.api_security_demo.common.core.wrapper.RequestWrapper;
import com.example.api_security_demo.utils.AESUtil;
import com.example.api_security_demo.utils.RSAUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.util.ObjectUtils;
import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import java.io.BufferedReader;
import java.io.IOException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
/**
* @ClassName : DecryptReplaceStreamFilter
* @Description :Filter過濾器 解密請求參數。同時替換請求體，使后續操作無感知加密??！
* @Author : AD
*/
@Slf4j
public class DecryptReplaceStreamFilter implements Filter {
/*
* AKS（Authentication Key Management System），采用無明文密鑰的方式對數據進行加密保護，加解密運算由統一的安全計算中心完成，AKS系統以接口的方式為對各個業務線提供加密解服務。
* 各個系統不再使用明文密鑰，只使用密鑰別名，調用簡單的加解密函數，完成對數據的保護。
* */
//請求頭標簽開關：是否需要加密解密
private static final String AKS_ENABLE = "aksEncrypt";
//GET請求加密數據Key
public static final String AKS_PARAMETER = "encryptData";
private static final String METHOD_GET = "GET";
private static final String METHOD_POST ="POST";
//POST請求加密數據Key
private static final String AKS_BODY ="content";
//AES密鑰Key
private static final String AES_KEY = "aesKey";
/**
* Feign是聲明式Web Service客戶端，它讓微服務之間的調用變得更簡單，類似controller調用service。
* Feign內部調用時，請求頭中標注請求源
* */
public static final String SOURCE_KEY = "api-source";
public static final String SOURCE_VALUE = "inner-api";
@Value("${Rsa.PrivateKey}")
private String privateKey;
@Value("${API.Security.enable}")
private boolean securityEnable;
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
//轉換為自己Wrapper,實現多次讀寫
RequestWrapper requestWrapper = new RequestWrapper((HttpServletRequest) servletRequest);
String contentType = requestWrapper.getContentType(); //請求頭中獲取Content-Type數據
String requestURI = requestWrapper.getRequestURI();
//配置文件配置是否開啟加解密功能
if (!securityEnable)
{
log.info("未開啟接口安全加密傳輸! 無需解密請求參數！");
filterChain.doFilter(requestWrapper,servletResponse);
return;
}
//通過請求頭參數判斷該請求是否需要解密處理
if (!needAks(requestWrapper)){
log.info("請求：{}，非加密請求，無需解密操作！",requestURI);
filterChain.doFilter(requestWrapper,servletResponse);
return;
}
/*
* [該功能暫時不用管，因為在請求頭中不添加 aksEncrypt：true 鍵值對，請求接口時同樣不會去進行解密請求數據的操作]
* */
//Feign服務端調用內部請求，按照不加密的邏輯放行[Feign是聲明式Web Service客戶端，它讓微服務之間的調用變得更簡單，類似controller調用service。]
//前端 --> A --> b --> c
String sourceKey = requestWrapper.getHeader(SOURCE_KEY);
if (!ObjectUtils.isEmpty(sourceKey) && sourceKey.equals(SOURCE_VALUE) ){
log.info("內部請求，無效加密解密接口數據！");
filterChain.doFilter(requestWrapper,servletResponse);
return;
}
/*
* POST請求進行解密工作
* */
if (requestWrapper.getMethod().equalsIgnoreCase(METHOD_POST)){
//讀取JSON請求體數據
StringBuffer bodyInfo = new StringBuffer();
String line = null;
BufferedReader reader = null;
reader = requestWrapper.getReader();
while ( ( line = reader.readLine() ) != null ){
bodyInfo.append(line);
}
//解密請求體數據
JSONObject jsonObject = JSONObject.parseObject(bodyInfo.toString());
log.info("Post請求:{}，待解密請求參數：{}", requestURI, JSONObject.toJSONString(jsonObject));
//獲取通過AES加密之后的密文
String content = jsonObject.getString(AKS_BODY);
//獲取通過RSA加密之后的AES密鑰KEy
String aesKey = jsonObject.getString(AES_KEY);
//RSAUtil解密出AES密鑰Key
try {
aesKey = new String(RSAUtil.decryptByPrivateKey(RSAUtil.toBytes(aesKey),privateKey,RSAUtil.MAX_DECRYPT_BLOCK),"UTF-8");
} catch (Exception e) {
throw new RuntimeException(e);
}
/*
* 方式1.將解密之后的數據+aesKey [放入body中，棄：會影響body結構] ( 滿足在AOP操作中對出參數據進行加密 ) 一并交給下游業務。
*/
//JSONObject requestBody = JSONObject.parseObject(data);
//requestBody.put(AES_KEY,aesKey);
/*
* 方式2.將其放入[請求對象屬性中中]，不影響請求體結構！
*/
//requestWrapper.setAttribute(AES_KEY,aesKey);
/*
* 方式3.將其放入[放入RequestWrapper封裝的額外參數Map中]，不影響請求體結構！
* */
HashMap<String, Object> map = new HashMap<>();
map.put(AES_KEY,aesKey);
requestWrapper.setParameterMap(map);
//AESUtil + aesKey 解密json數據
String decryptData = AESUtil.decryptFromBase64(content, aesKey);
log.info("Get請求:{}，解密之后參數：{}", requestURI, decryptData);
//重置Json請求體，保證下游業務無感知獲取數據
//requestWrapper.setBody(requestBody.toJSONString().getBytes());
requestWrapper.setBody(decryptData.getBytes());
}
/*
* GET請求解密處理：[AES密鑰Key放置在請求頭中]
* */
else if (requestWrapper.getMethod().equalsIgnoreCase(METHOD_GET))
{
//Get請求中 獲取到指定加密的參數 然后進行解密操作
String encryptData = requestWrapper.getParameter(AKS_PARAMETER);
log.info("Get請求:{}，待解密請求參數：{}", requestWrapper.getRequestURI(), encryptData);
// 先解密 存放在請求頭中且經過RSA加密過的AES密鑰
String aesKey = requestWrapper.getHeader(AES_KEY);
if (encryptData != null && !encryptData.isEmpty() && aesKey != null && !aesKey.isEmpty()){
try {
byte[] aesKeyByte = RSAUtil.decryptByPrivateKey(RSAUtil.toBytes(aesKey), privateKey, RSAUtil.MAX_DECRYPT_BLOCK);
aesKey = new String(aesKeyByte,"UTF-8");
System.out.println("aesKey.toString() = " + aesKey.toString());
} catch (Exception e) {
throw new RuntimeException(e);
}
//Get請求中的加密數據是以16進制字符串方式傳輸
byte[] encryptDataByte = AESUtil.toBytes(encryptData);
System.out.println("Arrays.toString(encryptDataByte) = " + Arrays.toString(encryptDataByte));
// 解密數據操作 AKS_PARAMETER
String decryptData = new String(AESUtil.decrypt(encryptDataByte,aesKey.getBytes("UTF-8")),"UTF-8");
log.info("Get請求:{}，解密之后參數：{}", requestURI, decryptData);
//將GET請求中的Parameter參數賦值入RequestWrapper中封裝的其它參數存放集合Map中
com.fasterxml.jackson.databind.ObjectMapper objectMapper = new com.fasterxml.jackson.databind.ObjectMapper();
Map<String, Object> map = objectMapper.readValue(decryptData, Map.class);
//將aseKey數據也存入map額外參數中
map.put("aesKey",aesKey);
requestWrapper.setParameterMap(map);
}
}
filterChain.doFilter(requestWrapper,servletResponse);
}
@Override
public void init(FilterConfig filterConfig) throws ServletException {
Filter.super.init(filterConfig);
}
@Override
public void destroy() {
Filter.super.destroy();
}
/**
* Description: 判斷當前請求是否需要加密解密數據
*
* @param request
* @return boolean
*/
private boolean needAks(HttpServletRequest request){
String enableAKS = request.getHeader(AKS_ENABLE);
return (enableAKS != null && enableAKS.equalsIgnoreCase("true"))? true: false;
}
}代碼解析：
- 代碼中通過三重方式放到是否需要解密請求接口。一個是配置文件中讀取的開關配置、一個是通過請求頭中是否開啟加密傳輸的標識(也就是在發送加密接口時，都需要在請求頭上封裝該開關)、Feign服務端調用內部請求，按照不加密的邏輯放行。
- 解密方式按照文章開頭采用的方案，先用RSA密鑰解密出隨機的AES密鑰，在通過密鑰解密密文。
- 對應Get請求和Post請求的解密方式兩點區別。Post整個請求體都是加密參數即body數據通過Base64方式傳輸進來的；Get請求中的加密參數需要使用：encryptData，由于需要放入路徑中，Base64編碼格式中含有+、\、=等特殊符號無法進行傳輸和解析，所以Get請求中的加密數據是采用HexString格式進行傳輸的，在解密時也需要對應的方法進行轉換為Byte[]后在進行解密操作。
- 關于AES密鑰的存放位置。Post請求中的AES密鑰是存入body中存入過來的，而Get請求中的AES密鑰是存放在請求頭中傳遞過來的，所以在解密對應請求方式的密文時，注意AES密鑰的獲取方式。
- 關鍵解密后的AES密鑰，需要一并交給下游業務。滿足在AOP操作中對出參數據進行加密，所以解密出來的AES密鑰也需要存入requestWrapper對象的Map集合中，方便下游業務獲取。
Filter過濾器注冊配置類：
需要注意解密過濾器Filter 的優先級一點要設置為最高優先級registration.setOrder(1);，首先需要該過濾器對加密數據進行解密后在重新封裝請求，才能使后續的業務數據能直接獲取到解密后的數據，達到無感知的效果。
package com.example.api_security_demo.filter;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.servlet.Filter;
/**
* @ClassName : WebAllHandlerConfig
* @Description : 過濾器、監聽器、攔截器 前置處理配置類
* @Author : AD
*/
@Configuration
public class WebAllHandlerConfig {
/**
* 注冊過濾器
* */
@Bean
public FilterRegistrationBean AllFilterRegistration(){
FilterRegistrationBean<Filter> registration = new FilterRegistrationBean<>();
registration.setFilter(decryptReplaceStreamFilter());
registration.addUrlPatterns("/*");
registration.setName("APISecurityFilter");
registration.setOrder(1);
return registration;
}
@Bean(name = "decryptReplaceStreamFilter")
public Filter decryptReplaceStreamFilter(){
return new DecryptReplaceStreamFilter();
}
}三、響應數據加密實現方案
響應數據加密的實現方式是采用AOP來實現，可以對返回的結果對象進行處理，而Filter只能拿到Request與Response對象，處理不方便；
這里的響應數據加密方案就簡單采用的是AES加密，通過前端傳來的隨機AES進行加密響應數據后在響應給前端！
這里響應加密的開啟方式是通過自定義注解來實現的，創建自定義一個自定義注解，作為響應數據加密的切點，就實現了響應數據是否加密的開啟。
3.1 自定義注解（開啟加密的注解）：
package com.example.api_security_demo.common.core.annotation;
import java.lang.annotation.*;
/**
* @ClassName : ResponseEncrypt
* @Description : 響應數據加密開啟注解
* @Author : AD
*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
//@Documented
public @interface ResponseEncrypt {
}3.2 AOP實現響應數據加密功能：
需要注意，這里的響應加密AOP的優先級也要設置為最高@Order(value = 0)，從而使最先開始的AOP能最后結束，這樣才能保證 加密響應的AOP最終處理的響應數據是所以業務邏輯都處理結束后最終的響應結果，然后進行加密處理后響應給前端。
package com.example.api_security_demo.aop;
import com.example.api_security_demo.common.R;
import com.example.api_security_demo.common.core.annotation.ResponseEncrypt;
import com.example.api_security_demo.utils.AESUtil;
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.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* @ClassName : ResponseEncryptAOP
* @Description : 傳輸加密模塊AOP，對接口的出參進行加密，注意順序不能亂，
* 此AOP必須第一個執行，因為最先執行的最后結束，這樣才能在各個AOP都執行完畢之后完成最后的加密
* @Author : AD
*/
@Order(value = 0)
@Aspect
@Component
public class ResponseEncryptAop {
@Pointcut("@annotation(com.example.api_security_demo.common.core.annotation.ResponseEncrypt)")
public void point(){}
/**
* 環繞增強，加密出參
* */
@Around(value = "point() && @annotation(responseEncrypt)")
public Object aroundEncrypt(ProceedingJoinPoint joinPoint, ResponseEncrypt responseEncrypt) throws Throwable {
//返回的結合
Object returnValue = null;
//從上下文中提取
HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
HttpServletResponse response = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getResponse();
//業務執行返回結果
returnValue = joinPoint.proceed();
System.out.println("returnValue.toString() = " + returnValue.toString());
//獲取到前端傳遞過來的AES密鑰，然后對響應數據進行AES加密操作
String aesKey = request.getParameter("aesKey");
System.out.println("aesKey = " + aesKey);
String encryptToBase64Data = AESUtil.encryptToBase64(returnValue.toString(), aesKey);
returnValue = R.ok(encryptToBase64Data);
return returnValue;
}
}四、測試相關的類
4.1 測試類實體封裝
package com.example.api_security_demo.controller;
import lombok.Data;
import lombok.ToString;
import lombok.experimental.Accessors;
/**
* @ClassName : TbStudenEntity
* @Description : 測試實體類
* @Author : AD
*/
@Data
@Accessors(chain = true)
@ToString
public class TbStudentEntity {
int id;
String name;
String sex;
int age;
}4.2 測試接口Controller層封裝
package com.example.api_security_demo.controller;
import com.example.api_security_demo.common.R;
import com.example.api_security_demo.common.core.annotation.ResponseEncrypt;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
/**
* @ClassName : TbStudentController
* @Description : 前端控制器Controller測試類
* @Author : AD
*/
@RestController
@RequestMapping("/demo")
@Slf4j
public class TbStudentController {
@PostMapping("/encryptPost")
@ResponseEncrypt
public R postDemo(@RequestBody TbStudentEntity tbStudentEntity,HttpServletRequest request){
System.out.println("request.getParameter(\"aesKey\") = " + request.getParameter("aesKey"));
//System.out.println("request.getAttribute(\"aesKey\") = " + request.getAttribute("aesKey"));
System.out.println("tbStudentEntity = " + tbStudentEntity);
return R.ok(tbStudentEntity.toString());
}
@GetMapping("/encryptGet")
@ResponseEncrypt
public R postDemoGet(HttpServletRequest request,@RequestParam String id,@RequestParam String name,@RequestParam String aesKey ){
System.out.println("id = " + id);
System.out.println("name = " + name);
System.out.println("aesKey = " + aesKey);
System.out.println("request.getParameter(\"age\") = " + request.getParameter("age"));
//System.out.println("request.getAttribute(DecryptReplaceStreamFilter.AKS_PARAMETER) = " + request.getAttribute(DecryptReplaceStreamFilter.AKS_PARAMETER));
return R.ok();
}
}4.3 前端模擬生成加密數據
package com.example.api_security_demo.utils;
import com.alibaba.fastjson2.JSONObject;
import com.fasterxml.jackson.core.JsonProcessingException;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import java.io.UnsupportedEncodingException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
/**
* @ClassName : UtilsTestClass
* @Description : 工具類測試類
* @Author : AD
*/
@Slf4j
public class UtilsTestClass {
/**
* 可以將其放入配置文件中進行讀取
* */
String publicKey = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDI7HE0aW9ILCMkfoAJYmAG+5RBRhU2Itebf04GUtnYMuR6Rl1GJKec7JKuM/8xSindH4jn6Vz3oARTjbCn4CxjbtQPys5i8VeXxgzzqhE34LY0Rt62Qy8UVS113454DTwZZR9BjmPQSxMaftQHMgeDjXVwLUt0a6CmRiZKOjw8WQIDAQAB";
String privateKey = "MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAMjscTRpb0gsIyR+gAliYAb7lEFGFTYi15t/TgZS2dgy5HpGXUYkp5zskq4z/zFKKd0fiOfpXPegBFONsKfgLGNu1A/KzmLxV5fGDPOqETfgtjRG3rZDLxRVLXXfjngNPBllH0GOY9BLExp+1AcyB4ONdXAtS3RroKZGJko6PDxZAgMBAAECgYBRUHdkKcNypwI188gnhBuu18QhQpa1CRbPBI90ObWWLMqQvcdj6tO2y3t1au+9Z/FXXzrN+IC6apU1p2M2HaB4iPdW+2Vm0DaRN7XJPzBdJqVASYVJ2oWWLWCkG05mS2pAgcMlxV3TLen7iBFKTjgZhdLIal8JYgyi6XWdNlAtAQJBAPjCtpmXuAS9luyXo2ExEauKEC2uC06FeZqgM6u1rTqsqUE5kGpmJ1DiERuOcQxn8i+mlnJ1Urmw8ltMxmnJAiECQQDOxVbjUXWolwRF8lsOeZ9XGGc/45pE7J8DubEV0Ii1RVckMyTkXmgNAupE7Xq9cgNMpNBRUQEDNzSHhA8rqGM5AkBuwWrBac6RtcPLpRwl+s3uPTNE01fPZxgkYy1+Rw5QsG1PUAzfgooAthZ92Wa16lXnJ1mWrmvdp03Qnpc8pDVhAkBoqWD6vV/2D0L9eNh4cj2iY1rX7whGfRNcWmD1rtGUF94tF6pD4jl+5Ivaie6H+C8NW5uKnZsKmqX/NmxLZ/eZAkBDXRX7YgMG4PLXcjPT4ot6DEJDjuSVb1LhwucL6QFFYhZloH3/9XQS3T9XB/2F61tdh5Jd3FaCD7WeXJCzW+64";
/**
* Description: 測試獲取密鑰的方法
*/
@Test
public void testGetASK() throws Exception {
// AES密鑰
String aesKey = AESUtil.getAESKey(16);
System.out.println("aesKey = " + aesKey);
// AES Base64類型密鑰
String base64AesKey = AESUtil.generateRandomAesKeyWithBase64();
System.out.println("base64AesKey = " + base64AesKey);
//RSA 私鑰公鑰
Map map = RSAUtil.generateRandomToBase64Key();
System.out.println("map.get(\"privateKey\") = " + map.get("privateKey"));
System.out.println("map.get(\"publicKey\") = " + map.get("publicKey"));
}
/**
* Description: post請求加密傳輸，請求體body封裝測試
*
* @param
* @return void
*/
@Test
public void postRequestBodyEncryptTest() throws Exception {
//自定義方式獲取 aesKey
String aesKey = AESUtil.getAESKey(16);
//內部方式獲取 Base64AesKey
String base64AesKey = AESUtil.generateRandomAesKeyWithBase64();
//創建請求體body數據 content
//模擬業務數據Json,并用AES密鑰Key進行加密
Map<String, Object> dataMap = new HashMap<>();
dataMap.put("id", 15);
dataMap.put("name", "張三");
dataMap.put("sex", "男");
dataMap.put("age", 20);
JSONObject dataJson = new JSONObject(dataMap);
String contentJson = JSONObject.toJSONString(dataJson);
//AES 加密業務數據
String content = AESUtil.encryptToBase64(contentJson, aesKey);
log.info("AES加密數據操作： \nAES加密之前的數據 = {} \nAES加密之后的數據 cnotallow= {}",contentJson,content);
//RSA 加密AES密鑰
byte[] bytes = RSAUtil.encryptByPublicKey(aesKey.getBytes("UTF-8"), publicKey, RSAUtil.MAX_ENCRYPT_BLOCK);
String encryptAesKey = RSAUtil.toHexString(bytes);
log.info("RSA加密AES密鑰操作： \nRSA加密之前的AES密鑰= {} \nRSA加密之后的AES密鑰 aesKey={}",aesKey,encryptAesKey);
/**
* 09:08:42.376 [main] INFO com.example.api_security_demo.utils.UtilsTestClass - AES加密數據操作：
* AES加密之前的數據 = {"sex":"男","name":"張三","id":15,"age":20}
* AES加密之后的數據 cnotallow= u/vRpwktLAo12ATyfa1rb14EHNftHfvhYEfy7r+DOJzO6jzXS4bwUJ0xNY8RJu8f
* 09:08:42.380 [main] INFO com.example.api_security_demo.utils.UtilsTestClass - RSA加密AES密鑰操作：
* RSA加密之前的AES密鑰= 9raG41FIE8uK7l3k
* RSA加密之后的AES密鑰 aesKey=c7eccef1d112075ee64eec65163b8b1dcb1a54ea6c8b51875174f6d34fc4ac7d50d2977b7519d275ee610d717d594228e132b053a70cdad9f925701a728ed794684d12097cfb8bea598c561393cb69de384b2ec83aa8ddb9a98a5adb3ed51ee1b9aaab2cf7bc5b49712a95e40ac4ea17421f5250d34b8e629e58db0b26e54b39
* */
}
/**
* Description: Get請求加密傳輸，請求體RequestParameter數據封裝測試
* 注意: 通過AES加密之后的數據 byte[] 需要轉換為 HexString十六進制字符串后才能在 請求地址中傳輸，不能在用Base64編碼格式的方式進行傳輸！
*/
@Test
public void getRequestBodyEncryptTest() throws Exception {
//自定義方式獲取 aesKey
String aesKey = AESUtil.getAESKey(16);
//內部方式獲取 Base64AesKey
String base64AesKey = AESUtil.generateRandomAesKeyWithBase64();
//創建請求體body數據 content
//模擬業務數據Json,并用AES密鑰Key進行加密
Map<String, Object> dataMap = new HashMap<>();
dataMap.put("id", 15);
dataMap.put("name", "張三");
dataMap.put("sex", "男");
dataMap.put("age", 20);
JSONObject dataJson = new JSONObject(dataMap);
String contentJson = JSONObject.toJSONString(dataJson);
//AES 加密業務數據
byte[] contentByte = AESUtil.encrypt(contentJson.getBytes("UTF-8"), aesKey.getBytes("UTF-8"));
String content = AESUtil.toHexString(contentByte);
log.info("AES加密數據操作： \nAES加密之前的數據 = {} \nAES加密之后的Byte[]數據 = {} \nAES加密后的數據轉換為HexString十六進制字符串數據encryptData={}",contentJson,Arrays.toString(contentByte),content);
//RSA 加密AES密鑰
byte[] bytes = RSAUtil.encryptByPublicKey(aesKey.getBytes("UTF-8"), publicKey, RSAUtil.MAX_ENCRYPT_BLOCK);
String encryptAesKey = RSAUtil.toHexString(bytes);
log.info("RSA加密AES密鑰操作： \nRSA加密之前的AES密鑰= {} \nRSA加密之后的AES密鑰aesKey={}",aesKey,encryptAesKey);
/**
* 09:09:13.172 [main] INFO com.example.api_security_demo.utils.UtilsTestClass - AES加密數據操作：
* AES加密之前的數據 = {"sex":"男","name":"張三","id":15,"age":20}
* AES加密之后的Byte[]數據 = [73, 19, 107, 60, 29, 109, 100, 119, -81, -117, -84, -85, 19, 28, 86, 18, 123, 48, 58, 37, -28, -65, -93, -124, -50, 89, -10, -101, 48, 48, -104, -18, -109, 127, -19, 80, 62, -122, -80, -122, 94, 72, -16, -89, -1, -128, 22, -92]
* AES加密后的數據轉換為HexString十六進制字符串數據encryptData=49136b3c1d6d6477af8bacab131c56127b303a25e4bfa384ce59f69b303098ee937fed503e86b0865e48f0a7ff8016a4
* 09:09:13.177 [main] INFO com.example.api_security_demo.utils.UtilsTestClass - RSA加密AES密鑰操作：
* RSA加密之前的AES密鑰= 868E9FMA727S9W5q
* RSA加密之后的AES密鑰aesKey=2ab5531c7814201b4eaef3802ca883e79ffffd4c4ec32e698403189c0954718fd5cebd0ac5e66e856ec4f95a408442fc76276586a8fdb94c14c8f311f30ad061d6928315078736e6633113cdba255870a78e9077b2f18bdc4b2730804e5d6181df4b0ecf51597f71c8e0ccb89a5e160f1216a7bde5386b42171577db400d5a54
* */
}
@Test
public void testByteBase64String(){
/*
* 創建字節數組的方式
* */
byte[] testBytes = new byte[]{0,1,2,3,4};
/*
* 讀取字節數組的方式：
* */
System.out.println("Arrays.toString(bytes1) = " + Arrays.toString(testBytes));
//模擬業務數據Json,并用AES密鑰Key進行加密
Map<String, String> dataMap = new HashMap<>(2);
dataMap.put("name", "張三");
dataMap.put("age", "20");
JSONObject dataJson = new JSONObject(dataMap);
String jsonStr = JSONObject.toJSONString(dataJson);
com.fasterxml.jackson.databind.ObjectMapper objectMapper = new com.fasterxml.jackson.databind.ObjectMapper();
try {
Map<String, Object> map = objectMapper.readValue(jsonStr, Map.class);
System.out.println("map.toString() = " + map.toString());
System.out.println("map.get(\"name\") = " + map.get("name"));
System.out.println("map.get(\"age\") = " + map.get("age"));
} catch (JsonProcessingException e) {
throw new RuntimeException(e);
}
byte[] jsonByte = dataJson.toString().getBytes();
System.out.println("new String(jsonByte) = " + new String(jsonByte));
//[兩種方式不一樣！]
String hexStr = "0123456789abcdef";
System.out.println("Arrays.toString(hexStr.getBytes()) = " + Arrays.toString(hexStr.getBytes()));
System.out.println("Arrays.toString(RSAUtil.toBytes(hexStr)) = " + Arrays.toString(RSAUtil.toBytes(hexStr)));
}
/**
* Description: 解密操作測試
*/
@Test
public void testAesDecrypt() throws Exception {
String encryptAesKey = "868dbf00b6849a1189f186f18bc98eca65981829e12d3bad21f4a64c139a6fe6953729e488af642cb5bf7104459a4fbf084bb536f251e2d9fa39747037715da6a73caf23e1d68bd5338d51dd207ebe9c4a72749d87d73eb96fc193adac45e6b8b6b7fcc211ee47efd0d54ea97dcfdbc221ac0bd7664d32becbdd654c3d9b2446";
String encryptDate = "8ee240b806a571f0f7ef5568d9cf5e36d999686acabfa4d5425d73ef7e546c8c1e9147c084269a6884cfeebf6759bd60";
//解密之后的AesKey 56X8817GRC2p33w0
byte[] decryptAesKey = RSAUtil.decryptByPrivateKey(RSAUtil.toBytes(encryptAesKey), privateKey, RSAUtil.MAX_DECRYPT_BLOCK);
String decryptAesKeyStr = new String(decryptAesKey, "UTF-8");
System.out.println("decryptAesKeyStr = " + decryptAesKeyStr);
//GET請求數據解密 [加密數據為HexStr十六進制字符串形式]
byte[] encryptDataByte = AESUtil.toBytes(encryptDate);
System.out.println("Arrays.toString(encryptDataByte) 加密數據Byte[]形式 = " + Arrays.toString(encryptDataByte));
String decryptData = new String(AESUtil.decrypt(encryptDataByte,decryptAesKeyStr.getBytes("UTF-8")),"UTF-8");
System.out.println("decryptData解密后的數據 = " + decryptData);
/* //POST請求數據解密 [加密數據為Base64編碼格式]
String decryptData2 = AESUtil.decryptFromBase64(encryptDate, decryptAesKeyStr);
System.out.println("decryptData2 解密后的數據 = " + decryptData2);*/
/**
* AES加密之前的數據 = {"sex":"男","name":"張三","id":15,"age":20}
* AES加密之后的Byte[]數據 = [-114, -30, 64, -72, 6, -91, 113, -16, -9, -17, 85, 104, -39, -49, 94, 54, -39, -103, 104, 106, -54, -65, -92, -43, 66, 93, 115, -17, 126, 84, 108, -116, 30, -111, 71, -64, -124, 38, -102, 104, -124, -49, -18, -65, 103, 89, -67, 96]
* AES加密后的數據轉換為HexString十六進制字符串數據encryptData=8ee240b806a571f0f7ef5568d9cf5e36d999686acabfa4d5425d73ef7e546c8c1e9147c084269a6884cfeebf6759bd60
* 16:48:25.095 [main] INFO com.example.api_security_demo.utils.UtilsTestClass - RSA加密AES密鑰操作：
* RSA加密之前的AES密鑰= 8c0N9032214LJ139
* RSA加密之后的AES密鑰aesKey=868dbf00b6849a1189f186f18bc98eca65981829e12d3bad21f4a64c139a6fe6953729e488af642cb5bf7104459a4fbf084bb536f251e2d9fa39747037715da6a73caf23e1d68bd5338d51dd207ebe9c4a72749d87d73eb96fc193adac45e6b8b6b7fcc211ee47efd0d54ea97dcfdbc221ac0bd7664d32becbdd654c3d9b2446
* */
}
/**
* Description: 響應數據加密后，模擬前端進行解密操作
*/
@Test
public void responseEncryptToDecrypt() throws UnsupportedEncodingException {
String aesKeyPost = "9raG41FIE8uK7l3k";
String aesKeyGet = "0303F71572405EF1";
String encryptData = "cf156ddc9cd9fde2a8287fa3b8eadca258ce063130d29d7d9c1b949a4628c42e497b4e1db76244bdd075cb37b8ef0212";
//解密后的數據
String decryptData = "";
//Base64編碼格式的數據解密
//decryptData = AESUtil.decryptFromBase64(encryptData, aesKeyGet);
//HexString格式的數據轉換后在解密
byte[] decrypt = AESUtil.decrypt(AESUtil.toBytes(encryptData), aesKeyGet.getBytes("UTF-8"));
decryptData = new String(decrypt, "UTF-8");
System.out.println("decryptData = " + decryptData);
}
}4.4 模擬加密請求調用接口
4.4.1 Post請求的封裝
請求頭中封裝數據：
aksEncrypt: true 開啟解密功能
圖片
請求體Body(application/json格式)的封裝：
- content：通過隨機AES密鑰加密后的請求數據
- aesKey: 通過RSA加密后的隨機AES密鑰
圖片
Post請求后響應數據
可以看出 請求數據解密后，通過 RequestWrapper重新封裝后的請求數據，能直接通過@RequestBody 等注解直接獲取到相請求體中的數據。同時也可以通過 request.getParameter()中存放的參數。
圖片
4.4.2 Get請求的封裝
Get請求的封裝
圖片
Get請求響應結果：
圖片
可以看出 請求數據解密后，通過 RequestWrapper重新封裝后的請求數據，能直接通過@RequestParam等注解直接獲取到Get請求中的數據。同時也可以通過 request.getParameter()中存放的參數。
責任編輯：武曉燕
來源：
一安未來
