SpringBoot 接口資料加解密技巧，so easy

作者：宮三公子

連結：https://juejin.cn/post/7080568585021554718

這日，剛撸完2兩代碼，正準備掏出手機摸魚放松放松，隻見老大朝我走過來，并露出一個”善意“的微笑，興偉呀，xx項目有于安全問題，需要對接口整體進行加密處理，你這方面比較有經驗，就給你安排上了哈，看這周内提測行不...，額，摸摸頭上飄搖着而稀疏的長發，感覺我愛了。

和産品、前端同學對外需求後，梳理了相關技術方案，主要的需求點如下：

盡量少改動，不影響之前的業務邏輯；
考慮到時間緊迫性，可采用對稱性加密方式，服務需要對接安卓、IOS、H5三端，另外考慮到H5端存儲密鑰安全性相對來說會低一些，故分針對H5和安卓、IOS配置設定兩套密鑰；
要相容低版本的接口，後面新開發的接口可不用相容；
接口有GET和POST兩種接口，需要都要進行加解密；

需求解析：

服務端、用戶端和H5統一攔截加解密，網上有成熟方案，也可以按其他服務中實作的加解密流程來搞；
使用AES放松加密，考慮到H5端存儲密鑰安全性相對來說會低一些，故分針對H5和安卓、IOS配置設定兩套密鑰；
本次涉及用戶端和服務端的整體改造，經讨論，新接口統一加 /secret/ 字首來區分

按本次需求來簡單還原問題，定義兩個對象，後面用得着，

使用者類：

@Data
public class User {
    private Integer id;
    private String name;
    private UserType userType = UserType.COMMON;
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private LocalDateTime registerTime;
}

使用者類型枚舉類：

@Getter
@JsonFormat(shape = JsonFormat.Shape.OBJECT)
public enum UserType {
    VIP("VIP使用者"),
    COMMON("普通使用者");
    private String code;
    private String type;




    UserType(String type) {
        this.code = name();
        this.type = type;
    }
}

構造一個簡單的使用者清單查詢示例：

@RestController
@RequestMapping(value = {"/user", "/secret/user"})
public class UserController {
    @RequestMapping("/list")
    ResponseEntity<List<User>> listUser() {
        List<User> users = new ArrayList<>();
        User u = new User();
        u.setId(1);
        u.setName("boyka");
        u.setRegisterTime(LocalDateTime.now());
        u.setUserType(UserType.COMMON);
        users.add(u);
        ResponseEntity<List<User>> response = new ResponseEntity<>();
        response.setCode(200);
        response.setData(users);
        response.setMsg("使用者清單查詢成功");
        return response;
    }
}

調用：localhost:8080/user/list

查詢結果如下，沒毛病：

{
"code": 200,
"data": [{
"id": 1,
"name": "boyka",
"userType": {
"code": "COMMON",
"type": "普通使用者"
},
"registerTime": "2022-03-24 23:58:39"
}],
"msg": "使用者清單查詢成功"
}

目前主要是利用ControllerAdvice來對請求和響應體進行攔截，主要定義SecretRequestAdvice對請求進行加密和SecretResponseAdvice對響應進行加密(實際情況會稍微複雜一點，項目中又GET類型請求，自定義了一個Filter進行不同的請求解密處理)。

好了，網上的ControllerAdvice使用示例非常多，我這把兩個核心方法給大家展示看看，相信大佬們一看就曉得了，不需多言。上代碼：

SecretRequestAdvice請求解密：

/**
 * @description:
 * @author: boykaff
 * @date: 2022-03-25-0025
 */
@ControllerAdvice
@Order(Ordered.HIGHEST_PRECEDENCE)
@Slf4j
public class SecretRequestAdvice extends RequestBodyAdviceAdapter {
    @Override
    public boolean supports(MethodParameter methodParameter, Type type, Class<? extends HttpMessageConverter<?>> aClass) {
        return true;
    }




    @Override
    public HttpInputMessage beforeBodyRead(HttpInputMessage inputMessage, MethodParameter parameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) throws IOException {
        //如果支援加密消息，進行消息解密。
        String httpBody;
        if (Boolean.TRUE.equals(SecretFilter.secretThreadLocal.get())) {
            httpBody = decryptBody(inputMessage);
        } else {
            httpBody = StreamUtils.copyToString(inputMessage.getBody(), Charset.defaultCharset());
        }
        //傳回處理後的消息體給messageConvert
        return new SecretHttpMessage(new ByteArrayInputStream(httpBody.getBytes()), inputMessage.getHeaders());
    }




    /**
     * 解密消息體
     *
     * @param inputMessage 消息體
     * @return 明文
     */
    private String decryptBody(HttpInputMessage inputMessage) throws IOException {
        InputStream encryptStream = inputMessage.getBody();
        String requestBody = StreamUtils.copyToString(encryptStream, Charset.defaultCharset());
        // 驗簽過程
        HttpHeaders headers = inputMessage.getHeaders();
        if (CollectionUtils.isEmpty(headers.get("clientType"))
                || CollectionUtils.isEmpty(headers.get("timestamp"))
                || CollectionUtils.isEmpty(headers.get("salt"))
                || CollectionUtils.isEmpty(headers.get("signature"))) {
            throw new ResultException(SECRET_API_ERROR, "請求解密參數錯誤，clientType、timestamp、salt、signature等參數傳遞是否正确傳遞");
        }




        String timestamp = String.valueOf(Objects.requireNonNull(headers.get("timestamp")).get(0));
        String salt = String.valueOf(Objects.requireNonNull(headers.get("salt")).get(0));
        String signature = String.valueOf(Objects.requireNonNull(headers.get("signature")).get(0));
        String privateKey = SecretFilter.clientPrivateKeyThreadLocal.get();
        ReqSecret reqSecret = JSON.parseObject(requestBody, ReqSecret.class);
        String data = reqSecret.getData();
        String newSignature = "";
        if (!StringUtils.isEmpty(privateKey)) {
            newSignature = Md5Utils.genSignature(timestamp + salt + data + privateKey);
        }
        if (!newSignature.equals(signature)) {
            // 驗簽失敗
            throw new ResultException(SECRET_API_ERROR, "驗簽失敗，請确認加密方式是否正确");
        }




        try {
            String decrypt = EncryptUtils.aesDecrypt(data, privateKey);
            if (StringUtils.isEmpty(decrypt)) {
                decrypt = "{}";
            }
            return decrypt;
        } catch (Exception e) {
            log.error("error: ", e);
        }
        throw new ResultException(SECRET_API_ERROR, "解密失敗");
    }
}

SecretResponseAdvice響應加密：

@ControllerAdvice
public class SecretResponseAdvice implements ResponseBodyAdvice {
    private Logger logger = LoggerFactory.getLogger(SecretResponseAdvice.class);




    @Override
    public boolean supports(MethodParameter methodParameter, Class aClass) {
        return true;
    }




    @Override
    public Object beforeBodyWrite(Object o, MethodParameter methodParameter, MediaType mediaType, Class aClass, ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse) {
        // 判斷是否需要加密
        Boolean respSecret = SecretFilter.secretThreadLocal.get();
        String secretKey = SecretFilter.clientPrivateKeyThreadLocal.get();
        // 清理本地緩存
        SecretFilter.secretThreadLocal.remove();
        SecretFilter.clientPrivateKeyThreadLocal.remove();
        if (null != respSecret && respSecret) {
            if (o instanceof ResponseBasic) {
                // 外層加密級異常
                if (SECRET_API_ERROR == ((ResponseBasic) o).getCode()) {
                    return SecretResponseBasic.fail(((ResponseBasic) o).getCode(), ((ResponseBasic) o).getData(), ((ResponseBasic) o).getMsg());
                }
                // 業務邏輯
                try {
                    String data = EncryptUtils.aesEncrypt(JSON.toJSONString(o), secretKey);
                    // 增加簽名
                    long timestamp = System.currentTimeMillis() / 1000;
                    int salt = EncryptUtils.genSalt();
                    String dataNew = timestamp + "" + salt + "" + data + secretKey;
                    String newSignature = Md5Utils.genSignature(dataNew);
                    return SecretResponseBasic.success(data, timestamp, salt, newSignature);
                } catch (Exception e) {
                    logger.error("beforeBodyWrite error:", e);
                    return SecretResponseBasic.fail(SECRET_API_ERROR, "", "服務端處理結果資料異常");
                }
            }
        }
        return o;
    }
}

OK，代碼Demo撸好了，試運作一波：

請求方法：

localhost:8080/secret/user/list




header:
Content-Type:application/json
signature:55efb04a83ca083dd1e6003cde127c45
timestamp:1648308048
salt:123456
clientType:ANDORID




body體:
// 原始請求體
{
"page": 1,
"size": 10
}
// 加密後的請求體
{
"data": "1ZBecdnDuMocxAiW9UtBrJzlvVbueP9K0MsIxQccmU3OPG92oRinVm0GxBwdlXXJ"
}




// 加密響應體：
{
    "data": "fxHYvnIE54eAXDbErdrDryEsIYNvsOOkyEKYB1iBcre/QU1wMowHE2BNX/je6OP3NlsCtAeDqcp7J1N332el8q2FokixLvdxAPyW5Un9JiT0LQ3MB8p+nN23pTSIvh9VS92lCA8KULWg2nViSFL5X1VwKrF0K/dcVVZnpw5h227UywP6ezSHjHdA+Q0eKZFGTEv3IzNXWqq/otx5fl1gKQ==",
    "code": 200,
    "signature": "aa61f19da0eb5d99f13c145a40a7746b",
    "msg": "",
    "timestamp": 1648480034,
    "salt": 632648
}




// 解密後的響應體：
{
"code": 200,
"data": [{
"id": 1,
"name": "boyka",
"registerTime": "2022-03-27T00:19:43.699",
"userType": "COMMON"
}],
"msg": "使用者清單查詢成功",
"salt": 0
}

OK，用戶端請求加密-》發起請求-》服務端解密-》業務處理-》服務端響應加密-》用戶端解密展示，看起來沒啥問題，實際是頭天下午花了2小時碰需求，差不多花1小時寫好demo測試，然後對所有接口統一進行了處理，整體一下午趕腳應該行了吧，告訴H5和安卓端同學明兒上午聯調（不小的大家到這個時候發現存在某種問題或陰謀沒有，當時确實疏忽了，翻了大車......）

次日，安卓端回報，你這個加解密有問題，解密後的資料格式和之前不一樣，仔細一看，擦，這個userType和registerTime是不對勁，開始思考：這個能是哪兒的問題呢？1s之後，初步定位，應該是響應體的JSON.toJSONString的問題：

String data = EncryptUtils.aesEncrypt(JSON.toJSONString(o)),

Debug斷點調試，果然，是JSON.toJSONString(o)這一步驟轉換出了問題，那JSON轉換時是不是有進階屬性可以配置生成想要的序列化格式呢？FastJson在序列化時提供重載方法，找到其中一個"SerializerFeature"參數可以琢磨一下，這個參數是可以對序列化進行配置的，它提供了很多配置類型，其中感覺這幾個比較沾邊：

WriteEnumUsingToString,
WriteEnumUsingName,
UseISO8601DateFormat

對枚舉類型來說，預設是使用的WriteEnumUsingName(枚舉的Name)，另一種WriteEnumUsingToString是重新toString方法，理論上可以轉換成想要的樣子，即這個樣子：

@Getter
@JsonFormat(shape = JsonFormat.Shape.OBJECT)
public enum UserType {
    VIP("VIP使用者"),
    COMMON("普通使用者");
    private String code;
    private String type;




    UserType(String type) {
        this.code = name();
        this.type = type;
    }




    @Override
    public String toString() {
        return "{" +
                "\"code\":\"" + name() + '\"' +
                ", \"type\":\"" + type + '\"' +
                '}';
    }
}

結果轉換出來的資料是字元串類型"{"code":"COMMON", "type":"普通使用者"}"，這個方法好像行不通，還有什麼好辦法呢？思前想後，看文章開始定義的User和UserType類，标記資料序列化格式@JsonFormat，再突然想起之前看到過的一些文章，SpringMVC底層預設是使用Jackson進行序列化的，那好了，就用Jacksong實施呗，将SecretResponseAdvice中的序列化方法替換一下：

String data = EncryptUtils.aesEncrypt(JSON.toJSONString(o), secretKey);
 換為：
 String data =EncryptUtils.aesEncrypt(new ObjectMapper().writeValueAsString(o), secretKey);

重新運作一波，走起：

{
"code": 200,
"data": [{
"id": 1,
"name": "boyka",
"userType": {
"code": "COMMON",
"type": "普通使用者"
},
"registerTime": {
"month": "MARCH",
"year": 2022,
"dayOfMonth": 29,
"dayOfWeek": "TUESDAY",
"dayOfYear": 88,
"monthValue": 3,
"hour": 22,
"minute": 30,
"nano": 453000000,
"second": 36,
"chronology": {
"id": "ISO",
"calendarType": "iso8601"
}
}
}],
"msg": "使用者清單查詢成功"
}

解密後的userType枚舉類型和非加密版本一樣了，舒服了，== 好像還不對，registerTime怎麼變成這個樣子了？原本是"2022-03-24 23:58:39"這種格式的，Jackson之LocalDateTime轉換，無需改實體類這篇文章講到了這個問題，并提出了一種解決方案，不過用在我們目前這個需求裡面，就是有損改裝了啊，不太可取，遂去Jackson官網上查找一下相關文檔，當然Jackson也提供了ObjectMapper的序列化配置，重新再初始化配置ObjectMpper對象：

String DATE_TIME_FORMATTER = "yyyy-MM-dd HH:mm:ss";
ObjectMapper objectMapper = new Jackson2ObjectMapperBuilder()
                            .findModulesViaServiceLoader(true)
                            .serializerByType(LocalDateTime.class, new LocalDateTimeSerializer(
                                    DateTimeFormatter.ofPattern(DATE_TIME_FORMATTER)))
                            .deserializerByType(LocalDateTime.class, new LocalDateTimeDeserializer(
                                    DateTimeFormatter.ofPattern(DATE_TIME_FORMATTER)))
                            .build();

轉換結果：

{
"code": 200,
"data": [{
"id": 1,
"name": "boyka",
"userType": {
"code": "COMMON",
"type": "普通使用者"
},
"registerTime": "2022-03-29 22:57:33"
}],
"msg": "使用者清單查詢成功"
}

OK，和非加密版的終于一緻了，完了嗎？感覺還是可能存在些什麼問題，首先業務代碼的時間序列化需求不一樣，有"yyyy-MM-dd hh:mm:ss"的，也有"yyyy-MM-dd"的，還可能其他配置思考不到位的，導緻和之前非加密版傳回資料不一緻的問題，到時候聯調測出來了也麻煩，有沒有一勞永逸的辦法呢？

同僚一句話點亮我，看一下spring架構自身是怎麼序列化的，照着配置應該就行嘛，好像有點道理，不從0開始分析源碼了，敢興趣的朋友可以看看這篇文章源碼分析Spring MVC源碼(三) ----- @RequestBody和@ResponseBody原了解析，感覺寫可以。

跟着執行鍊路，找到具體的響應序列化，重點就是RequestResponseBodyMethodProcessor，

protected <T> void writeWithMessageConverters(@Nullable T value, MethodParameter returnType, ServletServerHttpRequest inputMessage, ServletServerHttpResponse outputMessage) throws IOException, HttpMediaTypeNotAcceptableException, HttpMessageNotWritableException {
        // 擷取響應的攔截器鍊并執行beforeBodyWrite方法，也就是執行了我們自定義的SecretResponseAdvice中的beforeBodyWrite啦
body = this.getAdvice().beforeBodyWrite(body, returnType, selectedMediaType, converter.getClass(), inputMessage, outputMessage);
if (body != null) {
    // 執行響應體序列化工作
if (genericConverter != null) {
genericConverter.write(body, (Type)targetType, selectedMediaType, outputMessage);
} else {
converter.write(body, selectedMediaType, outputMessage);
}
    }

進而通過執行個體化的AbstractJackson2HttpMessageConverter對象找到執行序列化的核心方法

-> AbstractGenericHttpMessageConverter:


public final void write(T t, @Nullable Type type, @Nullable MediaType contentType, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException {
        ...
this.writeInternal(t, type, outputMessage);
outputMessage.getBody().flush();
     
    }
-> 找到Jackson序列化 AbstractJackson2HttpMessageConverter:
// 從spring容器中擷取并設定的ObjectMapper執行個體
protected ObjectMapper objectMapper;


protected void writeInternal(Object object, @Nullable Type type, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException {
        MediaType contentType = outputMessage.getHeaders().getContentType();
        JsonEncoding encoding = this.getJsonEncoding(contentType);
        JsonGenerator generator = this.objectMapper.getFactory().createGenerator(outputMessage.getBody(), encoding);




this.writePrefix(generator, object);
Object value = object;
Class<?> serializationView = null;
FilterProvider filters = null;
JavaType javaType = null;
if (object instanceof MappingJacksonValue) {
MappingJacksonValue container = (MappingJacksonValue)object;
value = container.getValue();
serializationView = container.getSerializationView();
filters = container.getFilters();
}




if (type != null && TypeUtils.isAssignable(type, value.getClass())) {
javaType = this.getJavaType(type, (Class)null);
}




ObjectWriter objectWriter = serializationView != null ? this.objectMapper.writerWithView(serializationView) : this.objectMapper.writer();
if (filters != null) {
objectWriter = objectWriter.with(filters);
}




if (javaType != null && javaType.isContainerType()) {
objectWriter = objectWriter.forType(javaType);
}




SerializationConfig config = objectWriter.getConfig();
if (contentType != null && contentType.isCompatibleWith(MediaType.TEXT_EVENT_STREAM) && config.isEnabled(SerializationFeature.INDENT_OUTPUT)) {
objectWriter = objectWriter.with(this.ssePrettyPrinter);
}
        // 重點進行序列化
objectWriter.writeValue(generator, value);
this.writeSuffix(generator, object);
generator.flush();
    }

那麼，可以看出SpringMVC在進行響應序列化的時候是從容器中擷取的ObjectMapper執行個體對象，并會根據不同的預設配置條件進行序列化，那處理方法就簡單了，我也可以從Spring容器拿資料進行序列化啊。SecretResponseAdvice進行如下進一步改造：

@ControllerAdvice
public class SecretResponseAdvice implements ResponseBodyAdvice {




    @Autowired
    private ObjectMapper objectMapper;
     
      @Override
    public Object beforeBodyWrite(....) {
        .....
        String dataStr =objectMapper.writeValueAsString(o);
        String data = EncryptUtils.aesEncrypt(dataStr, secretKey);
        .....
    }
 }

經測試，響應資料和非加密版萬全一緻啦，還有GET部分的請求加密，以及後面加解密慘遭跨域問題，後面有空再和大家聊聊。

SpringBoot 接口資料加解密技巧，so easy

繼續閱讀

MyBatis-Plus 之AR模式

馴服爛代碼_馴服Tomcat：Tomcat 5的過濾技巧

基于Springboot+VUE+Mysql的大學生校園疫情防控管理系統

Using MessageConverter

馴服爛代碼_C＃中的馴服配置

Spring Cloud整合Sleuth，當請求完成後，Zipkin沒有鍊路資訊

JAVA自學之路——馬士兵

Rabbitmq指令行手動建立隊列

整合 Spring 開發架構及服務端技術

SSM整合02---Spring-SpringMVC層一、添加web架構支援二、web.xml三、spring-mvc.xml

SSM架構（二）------------表現層的SpringMVC

Intellij idea基于Maven 的SSM 架構整合

Spring資料和Redis

SpringMVC的啟動過程源碼分析1 SpringMVC 配置XML的方式啟動2 SpringMVC純注解模式啟動

Java Spring 架構

SpringCloud微服務（四）之ribbon筆記ribbon是什麼？入門案例自定義均衡負載算法