• SpringBoot 接口数据加解密技巧

    对接口整体进行加密处理

    需求解析：

    • 服务端、客户端和H5统一拦截加解密，网上有成熟方案，也可以按其他服务中实现的加解密流程来搞；

    • 使用AES放松加密，考虑到H5端存储密钥安全性相对来说会低一些，故分针对H5和安卓、IOS分配两套密钥；

    • 本次涉及客户端和服务端的整体改造，经讨论，新接口统一加 /secret/ 前缀来区分

    按本次需求来简单还原问题，定义两个对象，后面用得着，

    用户类：

    1. @Data
    2. public class User {
    3.     private Integer id;
    4.     private String name;
    5.     private UserType userType = UserType.COMMON;
    6.     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    7.     private LocalDateTime registerTime;
    8. }
    9.

    用户类型枚举类：

    1. @Getter
    2. @JsonFormat(shape = JsonFormat.Shape.OBJECT)
    3. public enum UserType {
    4.     VIP("VIP用户"),
    5.     COMMON("普通用户");
    6.     private String code;
    7.     private String type;
    8.  
    9.     UserType(String type) {
    10.         this.code = name();
    11.         this.type = type;
    12.     }
    13. }
    14.

    构造一个简单的用户列表查询示例：

    1. @RestController
    2. @RequestMapping(value = {"/user", "/secret/user"})
    3. public class UserController {
    4.     @RequestMapping("/list")
    5.     ResponseEntity<List<User>> listUser() {
    6.         List<User> users = new ArrayList<>();
    7.         User u = new User();
    8.         u.setId(1);
    9.         u.setName("boyka");
    10.         u.setRegisterTime(LocalDateTime.now());
    11.         u.setUserType(UserType.COMMON);
    12.         users.add(u);
    13.         ResponseEntity<List<User>> response = new ResponseEntity<>();
    14.         response.setCode(200);
    15.         response.setData(users);
    16.         response.setMsg("用户列表查询成功");
    17.         return response;
    18.     }
    19. }
    20.

    调用：localhost:8080/user/list

    查询结果如下，没毛病：

    1. {
    2.  "code": 200,
    3.  "data": [{
    4.   "id": 1,
    5.   "name": "boyka",
    6.   "userType": {
    7.    "code": "COMMON",
    8.    "type": "普通用户"
    9.   },
    10.   "registerTime": "2022-03-24 23:58:39"
    11.  }],
    12.  "msg": "用户列表查询成功"
    13. }
    14.

    目前主要是利用ControllerAdvice来对请求和响应体进行拦截，主要定义SecretRequestAdvice对请求进行加密和SecretResponseAdvice对响应进行加密(实际情况会稍微复杂一点，项目中又GET类型请求，自定义了一个Filter进行不同的请求解密处理)。

    网上的ControllerAdvice使用示例非常多，我这把两个核心方法给大家展示看看，代码：

    SecretRequestAdvice请求解密：

    1. /**
    2.  * @description:
    3.  * @author: boykaff
    4.  */
    5. @ControllerAdvice
    6. @Order(Ordered.HIGHEST_PRECEDENCE)
    7. @Slf4j
    8. public class SecretRequestAdvice extends RequestBodyAdviceAdapter {
    9.     @Override
    10.     public boolean supports(MethodParameter methodParameter, Type type, Class<? extends HttpMessageConverter<?>> aClass) {
    11.         return true;
    12.     }
    13.  
    14.     @Override
    15.     public HttpInputMessage beforeBodyRead(HttpInputMessage inputMessage, MethodParameter parameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) throws IOException {
    16.         //如果支持加密消息，进行消息解密。
    17.         String httpBody;
    18.         if (Boolean.TRUE.equals(SecretFilter.secretThreadLocal.get())) {
    19.             httpBody = decryptBody(inputMessage);
    20.         } else {
    21.             httpBody = StreamUtils.copyToString(inputMessage.getBody(), Charset.defaultCharset());
    22.         }
    23.         //返回处理后的消息体给messageConvert
    24.         return new SecretHttpMessage(new ByteArrayInputStream(httpBody.getBytes()), inputMessage.getHeaders());
    25.     }
    26.  
    27.     /**
    28.      * 解密消息体
    29.      *
    30.      * @param inputMessage 消息体
    31.      * @return 明文
    32.      */
    33.     private String decryptBody(HttpInputMessage inputMessage) throws IOException {
    34.         InputStream encryptStream = inputMessage.getBody();
    35.         String requestBody = StreamUtils.copyToString(encryptStream, Charset.defaultCharset());
    36.         // 验签过程
    37.         HttpHeaders headers = inputMessage.getHeaders();
    38.         if (CollectionUtils.isEmpty(headers.get("clientType"))
    39.                 || CollectionUtils.isEmpty(headers.get("timestamp"))
    40.                 || CollectionUtils.isEmpty(headers.get("salt"))
    41.                 || CollectionUtils.isEmpty(headers.get("signature"))) {
    42.             throw new ResultException(SECRET_API_ERROR, "请求解密参数错误，clientType、timestamp、salt、signature等参数传递是否正确传递");
    43.         }
    44.  
    45.         String timestamp = String.valueOf(Objects.requireNonNull(headers.get("timestamp")).get(0));
    46.         String salt = String.valueOf(Objects.requireNonNull(headers.get("salt")).get(0));
    47.         String signature = String.valueOf(Objects.requireNonNull(headers.get("signature")).get(0));
    48.         String privateKey = SecretFilter.clientPrivateKeyThreadLocal.get();
    49.         ReqSecret reqSecret = JSON.parseObject(requestBody, ReqSecret.class);
    50.         String data = reqSecret.getData();
    51.         String newSignature = "";
    52.         if (!StringUtils.isEmpty(privateKey)) {
    53.             newSignature = Md5Utils.genSignature(timestamp + salt + data + privateKey);
    54.         }
    55.         if (!newSignature.equals(signature)) {
    56.             // 验签失败
    57.             throw new ResultException(SECRET_API_ERROR, "验签失败，请确认加密方式是否正确");
    58.         }
    59.  
    60.         try {
    61.             String decrypt = EncryptUtils.aesDecrypt(data, privateKey);
    62.             if (StringUtils.isEmpty(decrypt)) {
    63.                 decrypt = "{}";
    64.             }
    65.             return decrypt;
    66.         } catch (Exception e) {
    67.             log.error("error: ", e);
    68.         }
    69.         throw new ResultException(SECRET_API_ERROR, "解密失败");
    70.     }
    71. }
    72.

    SecretResponseAdvice响应加密：

    1. @ControllerAdvice
    2. public class SecretResponseAdvice implements ResponseBodyAdvice {
    3.     private Logger logger = LoggerFactory.getLogger(SecretResponseAdvice.class);
    4.  
    5.     @Override
    6.     public boolean supports(MethodParameter methodParameter, Class aClass) {
    7.         return true;
    8.     }
    9.  
    10.     @Override
    11.     public Object beforeBodyWrite(Object o, MethodParameter methodParameter, MediaType mediaType, Class aClass, ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse) {
    12.         // 判断是否需要加密
    13.         Boolean respSecret = SecretFilter.secretThreadLocal.get();
    14.         String secretKey = SecretFilter.clientPrivateKeyThreadLocal.get();
    15.         // 清理本地缓存
    16.         SecretFilter.secretThreadLocal.remove();
    17.         SecretFilter.clientPrivateKeyThreadLocal.remove();
    18.         if (null != respSecret && respSecret) {
    19.             if (o instanceof ResponseBasic) {
    20.                 // 外层加密级异常
    21.                 if (SECRET_API_ERROR == ((ResponseBasic) o).getCode()) {
    22.                     return SecretResponseBasic.fail(((ResponseBasic) o).getCode(), ((ResponseBasic) o).getData(), ((ResponseBasic) o).getMsg());
    23.                 }
    24.                 // 业务逻辑
    25.                 try {
    26.                     String data = EncryptUtils.aesEncrypt(JSON.toJSONString(o), secretKey);
    27.                     // 增加签名
    28.                     long timestamp = System.currentTimeMillis() / 1000;
    29.                     int salt = EncryptUtils.genSalt();
    30.                     String dataNew = timestamp + "" + salt + "" + data + secretKey;
    31.                     String newSignature = Md5Utils.genSignature(dataNew);
    32.                     return SecretResponseBasic.success(data, timestamp, salt, newSignature);
    33.                 } catch (Exception e) {
    34.                     logger.error("beforeBodyWrite error:", e);
    35.                     return SecretResponseBasic.fail(SECRET_API_ERROR, "", "服务端处理结果数据异常");
    36.                 }
    37.             }
    38.         }
    39.         return o;
    40.     }
    41. }
    42.

    OK，代码Demo撸好了，试运行一波：

    请求方法：

    1. localhost:8080/secret/user/list
    2.  
    3. header:
    4. Content-Type:application/json
    5. signature:55efb04a83ca083dd1e6003cde127c45
    6. timestamp:1648308048
    7. salt:123456
    8. clientType:ANDORID
    9.

    body体:

    1. // 原始请求体
    2. {
    3.  "page": 1,
    4.  "size": 10
    5. }
    6. // 加密后的请求体
    7. {
    8.  "data": "1ZBecdnDuMocxAiW9UtBrJzlvVbueP9K0MsIxQccmU3OPG92oRinVm0GxBwdlXXJ"
    9. }
    10.  
    11. // 加密响应体：
    12. {
    13.     "data": "fxHYvnIE54eAXDbErdrDryEsIYNvsOOkyEKYB1iBcre/QU1wMowHE2BNX/je6OP3NlsCtAeDqcp7J1N332el8q2FokixLvdxAPyW5Un9JiT0LQ3MB8p+nN23pTSIvh9VS92lCA8KULWg2nViSFL5X1VwKrF0K/dcVVZnpw5h227UywP6ezSHjHdA+Q0eKZFGTEv3IzNXWqq/otx5fl1gKQ==",
    14.     "code": 200,
    15.     "signature": "aa61f19da0eb5d99f13c145a40a7746b",
    16.     "msg": "",
    17.     "timestamp": 1648480034,
    18.     "salt": 632648
    19. }
    20.  
    21. // 解密后的响应体：
    22. {
    23.  "code": 200,
    24.  "data": [{
    25.   "id": 1,
    26.   "name": "boyka",
    27.   "registerTime": "2022-03-27T00:19:43.699",
    28.   "userType": "COMMON"
    29.  }],
    30.  "msg": "用户列表查询成功",
    31.  "salt": 0
    32. }
    33.

    OK，客户端请求加密->发起请求->服务端解密->业务处理->服务端响应加密->客户端解密展示，看起来没啥问题，但是解密后的数据格式和之前不一样，这个userType和registerTime是不对劲，开始思考：应该是响应体的JSON.toJSONString的问题：

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

    Debug断点调试，果然，是JSON.toJSONString(o)这一步骤转换出了问题，那JSON转换时是不是有高级属性可以配置生成想要的序列化格式呢？

    FastJson在序列化时提供重载方法，找到其中一个"SerializerFeature"参数可以琢磨一下，这个参数是可以对序列化进行配置的，它提供了很多配置类型，其中感觉这几个比较沾边：

    1. WriteEnumUsingToString,
    2. WriteEnumUsingName,
    3. UseISO8601DateFormat
    4.

    对枚举类型来说，默认是使用的WriteEnumUsingName(枚举的Name)， 另一种WriteEnumUsingToString是重新toString方法，理论上可以转换成想要的样子，即这个样子：

    1. @Getter
    2. @JsonFormat(shape = JsonFormat.Shape.OBJECT)
    3. public enum UserType {
    4.     VIP("VIP用户"),
    5.     COMMON("普通用户");
    6.     private String code;
    7.     private String type;
    8.  
    9.     UserType(String type) {
    10.         this.code = name();
    11.         this.type = type;
    12.     }
    13.  
    14.     @Override
    15.     public String toString() {
    16.         return "{" +
    17.                 "\"code\":\"" + name() + '\"' +
    18.                 ", \"type\":\"" + type + '\"' +
    19.                 '}';
    20.     }
    21. }
    22.

    结果转换出来的数据是字符串类型"{"code":"COMMON", "type":"普通用户"}"，这个方法好像行不通，还有什么好办法呢？

    思前想后，开始定义的User和UserType类，标记数据序列化格式@JsonFormat，再突然想起之前看到过的一些文章，SpringMVC底层默认是使用Jackson进行序列化的，那好了，就用Jacksong实施呗，将SecretResponseAdvice中的序列化方法替换一下：

    1. String data = EncryptUtils.aesEncrypt(JSON.toJSONString(o), secretKey);
    2.

    换为：

    1. String data =EncryptUtils.aesEncrypt(new ObjectMapper().writeValueAsString(o), secretKey);
    2.

    重新运行一波，走起：

    1. {
    2.  "code": 200,
    3.  "data": [{
    4.   "id": 1,
    5.   "name": "boyka",
    6.   "userType": {
    7.    "code": "COMMON",
    8.    "type": "普通用户"
    9.   },
    10.   "registerTime": {
    11.    "month": "MARCH",
    12.    "year": 2022,
    13.    "dayOfMonth": 29,
    14.    "dayOfWeek": "TUESDAY",
    15.    "dayOfYear": 88,
    16.    "monthValue": 3,
    17.    "hour": 22,
    18.    "minute": 30,
    19.    "nano": 453000000,
    20.    "second": 36,
    21.    "chronology": {
    22.     "id": "ISO",
    23.     "calendarType": "iso8601"
    24.    }
    25.   }
    26.  }],
    27.  "msg": "用户列表查询成功"
    28. }
    29.

    解密后的userType枚举类型和非加密版本一样了，舒服了，== 好像还不对，registerTime怎么变成这个样子了？原本是"2022-03-24 23:58:39"这种格式的，Jackson之LocalDateTime转换，无需改实体类这篇文章讲到了这个问题，并提出了一种解决方案。

    遂去Jackson官网上查找一下相关文档，当然Jackson也提供了ObjectMapper的序列化配置，重新再初始化配置ObjectMpper对象：

    1. String DATE_TIME_FORMATTER = "yyyy-MM-dd HH:mm:ss";
    2. ObjectMapper objectMapper = new Jackson2ObjectMapperBuilder()
    3.        .findModulesViaServiceLoader(true)
    4.        .serializerByType(LocalDateTime.class, new LocalDateTimeSerializer(
    5.                DateTimeFormatter.ofPattern(DATE_TIME_FORMATTER)))
    6.        .deserializerByType(LocalDateTime.class, new LocalDateTimeDeserializer(
    7.                DateTimeFormatter.ofPattern(DATE_TIME_FORMATTER)))
    8.        .build();
    9.

    转换结果：

    1. {
    2.  "code": 200,
    3.  "data": [{
    4.   "id": 1,
    5.   "name": "boyka",
    6.   "userType": {
    7.    "code": "COMMON",
    8.    "type": "普通用户"
    9.   },
    10.   "registerTime": "2022-03-29 22:57:33"
    11.  }],
    12.  "msg": "用户列表查询成功"
    13. }
    14.

    OK，和非加密版的终于一致了，完了吗？感觉还是可能存在些什么问题，首先业务代码的时间序列化需求不一样，有"yyyy-MM-dd hh:mm:ss"的，也有"yyyy-MM-dd"的，还可能其他配置思考不到位的，导致和之前非加密版返回数据不一致的问题，到时候联调测出来了也麻烦，有没有一劳永逸的办法呢？

    看一下spring框架自身是怎么序列化的，照着配置应该就行，跟着执行链路，找到具体的响应序列化，重点就是RequestResponseBodyMethodProcessor，

    1. protected <T> void writeWithMessageConverters(@Nullable T value, MethodParameter returnType, ServletServerHttpRequest inputMessage, ServletServerHttpResponse outputMessage) throws IOException, HttpMediaTypeNotAcceptableException, HttpMessageNotWritableException {
    2.         // 获取响应的拦截器链并执行beforeBodyWrite方法，也就是执行了我们自定义的SecretResponseAdvice中的beforeBodyWrite啦
    3.   body = this.getAdvice().beforeBodyWrite(body, returnType, selectedMediaType, converter.getClass(), inputMessage, outputMessage);
    4.   if (body != null) {
    5.       // 执行响应体序列化工作
    6.    if (genericConverter != null) {
    7.     genericConverter.write(body, (Type)targetType, selectedMediaType, outputMessage);
    8.    } else {
    9.     converter.write(body, selectedMediaType, outputMessage);
    10.    }
    11.     }
    12.

    进而通过实例化的AbstractJackson2HttpMessageConverter对象找到执行序列化的核心方法

    1. -> AbstractGenericHttpMessageConverter:
    2.  
    3.  public final void write(T t, @Nullable Type type, @Nullable MediaType contentType, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException {
    4.         ...
    5.   this.writeInternal(t, type, outputMessage);
    6.   outputMessage.getBody().flush();
    7.      
    8.     }
    9.  -> 找到Jackson序列化 AbstractJackson2HttpMessageConverter:
    10.  // 从spring容器中获取并设置的ObjectMapper实例
    11.  protected ObjectMapper objectMapper;
    12.  
    13.  protected void writeInternal(Object object, @Nullable Type type, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException {
    14.         MediaType contentType = outputMessage.getHeaders().getContentType();
    15.         JsonEncoding encoding = this.getJsonEncoding(contentType);
    16.         JsonGenerator generator = this.objectMapper.getFactory().createGenerator(outputMessage.getBody(), encoding);
    17.  
    18.   this.writePrefix(generator, object);
    19.   Object value = object;
    20.   Class<?> serializationView = null;
    21.   FilterProvider filters = null;
    22.   JavaType javaType = null;
    23.   if (object instanceof MappingJacksonValue) {
    24.    MappingJacksonValue container = (MappingJacksonValue)object;
    25.    value = container.getValue();
    26.    serializationView = container.getSerializationView();
    27.    filters = container.getFilters();
    28.   }
    29.  
    30.   if (type != null && TypeUtils.isAssignable(type, value.getClass())) {
    31.    javaType = this.getJavaType(type, (Class)null);
    32.   }
    33.  
    34.   ObjectWriter objectWriter = serializationView != null ? this.objectMapper.writerWithView(serializationView) : this.objectMapper.writer();
    35.   if (filters != null) {
    36.    objectWriter = objectWriter.with(filters);
    37.   }
    38.  
    39.   if (javaType != null && javaType.isContainerType()) {
    40.    objectWriter = objectWriter.forType(javaType);
    41.   }
    42.  
    43.   SerializationConfig config = objectWriter.getConfig();
    44.   if (contentType != null && contentType.isCompatibleWith(MediaType.TEXT_EVENT_STREAM) && config.isEnabled(SerializationFeature.INDENT_OUTPUT)) {
    45.    objectWriter = objectWriter.with(this.ssePrettyPrinter);
    46.   }
    47.         // 重点进行序列化
    48.   objectWriter.writeValue(generator, value);
    49.   this.writeSuffix(generator, object);
    50.   generator.flush();
    51.     }
    52.

    那么，可以看出SpringMVC在进行响应序列化的时候是从容器中获取的ObjectMapper实例对象，并会根据不同的默认配置条件进行序列化，那处理方法就简单了，我也可以从Spring容器拿数据进行序列化啊。SecretResponseAdvice进行如下进一步改造：

    1. @ControllerAdvice
    2. public class SecretResponseAdvice implements ResponseBodyAdvice {
    3.  
    4.     @Autowired
    5.     private ObjectMapper objectMapper;
    6.      
    7.       @Override
    8.     public Object beforeBodyWrite(....) {
    9.         .....
    10.         String dataStr =objectMapper.writeValueAsString(o);
    11.         String data = EncryptUtils.aesEncrypt(dataStr, secretKey);
    12.         .....
    13.     }
    14.  }
    15.

    经测试，响应数据和非加密版万全一致啦，还有GET部分的请求加密，以及后面加解密惨遭跨域问题，

  • 相关阅读:
    react-demo项目：支持使用scss(不使用create-react-app脚手架)
    golang 工厂模式
    运放 + MOS管构成的恒流电路分析及实用环境器件参数选择
    软件外包公司真的去不得吗？
    Iptables匹配条件 - 示例1
    08-Linux特殊权限
    多功能气象传感器解析
    Paste v4.1.2(Mac剪切板)
    Python通过pyecharts对爬虫房地产数据进行数据可视化分析（一）
    华为机试真题 Java 实现【无向图染色】【2022.11 Q4新题】
  • 原文地址：https://blog.csdn.net/yuechuzhixing/article/details/127665469