SpringBoot 优雅地对接口进行数据加解密

Posted 2022-11-23 ABin-阿斌

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了SpringBoot 优雅地对接口进行数据加解密相关的知识，希望对你有一定的参考价值。

我是 ABin-阿斌：写一生代码，创一世佳话，筑一览芳华。如果小伙伴们觉得不错就一键三连吧~

声明：

原作者：掘金：https://juejin.cn/user/3650034336532824
原文链接：https://juejin.cn/post/7080568585021554718

文章目录

一、前言
二、分析
- 1、主要的需求点如下：
- 2、需求解析：
三、动手
四、技术选型
五、总结

一、前言

这日，刚撸完2两代码，正准备掏出手机摸鱼放松放松，只见老大朝我走过来，并露出一个”善意“的微笑，兴伟呀，xx项目有于安全问题，需要对接口整体进行加密处理，你这方面比较有经验，就给你安排上了哈，看这周内提测行不…，额，摸摸头上飘摇着而稀疏的长发，感觉我爱了。
和产品、前端同学对外需求后，梳理了相关技术方案，

二、分析

1、主要的需求点如下：

尽量少改动，不影响之前的业务逻辑；
考虑到时间紧迫性，可采用对称性加密方式，服务需要对接安卓、ios、H5三端，另外考虑到H5端存储密钥安全性相对来说会低一些，故分针对H5和安卓、IOS分配两套密钥；
要兼容低版本的接口，后面新开发的接口可不用兼容；
接口有GET和POST两种接口，需要都要进行加解密；

2、需求解析：

服务端、客户端和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使用示例非常多，我这把两个核心方法给大家展示看看，相信大佬们一看就晓得了，不需多言。上代码：

1、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, "解密失败");

2、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;

3、结果分析

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)以上是关于SpringBoot 优雅地对接口进行数据加解密的主要内容，如果未能解决你的问题，请参考以下文章 
 SpringBoot Starter自定义注解 - 接口加解密
 SpringBoot 接口数据加解密实战
 SpringBoot：如何优雅地进行参数传递响应数据封装异常处理？
 「SpringBoot」如何优雅地管理SpringBoot项目
 SpringBoot 2.2.5 配置AOP，实现API接口请求体及响应体自动加解密的功能
 SpringBoot：如何优雅地进行响应数据封装异常处理？