首页 > 其他分享 >SpringBoot 接口数据加解密解说,你的系统真的安全吗?

SpringBoot 接口数据加解密解说,你的系统真的安全吗?

时间:2024-01-25 21:00:53浏览次数:26  
标签:code 加密 String data 加解密 解说 序列化 type SpringBoot

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  
 */  
@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框架自身是怎么序列化的,照着配置应该就行嘛,好像有点道理。

跟着执行链路,找到具体的响应序列化,重点就是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部分的请求加密,以及后面加解密惨遭跨域问题,后面有空再和大家聊聊。

最后说一句(求关注!别白嫖!)

如果这篇文章对您有所帮助,或者有所启发的话,求一键三连:点赞、转发、在看。

关注公众号:woniuxgg,在公众号中回复:笔记  就可以获得蜗牛为你精心准备的java实战语雀笔记,回复面试、开发手册、有超赞的粉丝福利!


标签:code,加密,String,data,加解密,解说,序列化,type,SpringBoot
From: https://blog.51cto.com/u_16502039/9419280

相关文章

  • SpringBoot 依赖管理机制
     依赖管理机制思考:1、为什么导入starter-web所有相关依赖都导入进来?开发什么场景,导入什么场景启动器。maven依赖传递原则。     A依赖B B依赖C:   导入A就拥有B和C导入场景启动器。场景启动器自动把这个场景的所有核心依赖全部导入进来2、为什么版......
  • SpringBoot:Springboot整合Mqtt并处理问题
    搭建mqtt服务Docker搭建MQTT服务:https://www.cnblogs.com/nhdlb/p/17960641项目结构这是我的项目结构,主要有两个模块base-modules(业务模块)、base-utils(工具模块)组成,其中base-mqtt服务为工具模块,用于提供给其他业务模块引用依赖的。base-mqtt模块pom.xml这里我的Sprin......
  • springBoot自定义参数注解
    springBoot自定义参数注解前置条件:新建一个springboot项目1.新建一个标记注解@Authimportjava.lang.annotation.ElementType;importjava.lang.annotation.Retention;importjava.lang.annotation.RetentionPolicy;importjava.lang.annotation.Target;/***@authorwa......
  • 解决跨域问题的8种方法,含网关、Nginx和SpringBoot~
    跨域问题是浏览器为了保护用户的信息安全,实施了同源策略(Same-OriginPolicy),即只允许页面请求同源(相同协议、域名和端口)的资源,当JavaScript发起的请求跨越了同源策略,即请求的目标与当前页面的域名、端口、协议不一致时,浏览器会阻止请求的发送或接收。解决跨域问题方案跨域问题......
  • Springboot整合logback
    Springboot整合logback1、引入maven依赖<!--slf4j日志门面--><dependency><groupId>org.slf4j</groupId><artifactId>slf4j-api</artifactId><version>1.7.26</version>&......
  • SpringBoot开启动态定时任务并手动、自动关闭
    场景需求:在执行某个方法的两小时之后进行某个操作涉及:定时任务、哈希表需要注意:业务逻辑层是单一实例的,所以在定时任务类内操作业务逻辑层的某个属性和在业务逻辑层内操作的都是同一个。疑问:ThreadPoolTaskScheduler线程池需不需要规定线程数量?定时任务类@Componentpublicc......
  • Java21 + SpringBoot3整合Redis,使用Lettuce连接池,推荐连接池参数配置,封装Redis操作
    目录前言相关技术简介Redis实现步骤引入maven依赖修改配置文件定义Redis配置类定义Redis服务类,封装Redis常用操作使用Redis服务类总结前言近日心血来潮想做一个开源项目,目标是做一款可以适配多端、功能完备的模板工程,包含后台管理系统和前台系统,开发者基于此项目进行裁剪和扩展......
  • 搞起来,使用 SpringBoot 框架徒手撸一个安全、可靠的本地缓存工具
    在实现本地缓存的时候,我们经常使用线程安全的ConcurrentHashMap来暂存数据,然后加上SpringBoot自带的@Scheduled定时刷新缓存。虽然这样可以实现本地缓存,但既不优雅也不安全。那看一下我的思路,首先看一张图!1.每个处理器都有缓存名字、描述信息、缓存初始化顺序等信息,所以应该定义一......
  • 策略模式【结合springboot实现】
    Hello!~大家好啊,很高兴我们又见面了,今天我们一起学习设计模式–【策略模式】初次对此模式不懂的,或者想偷懒的,我强烈建议大家跟着我的一起把概念和代码一起敲一遍!~为啥子??因为我就是这样学会的,哈哈哈!1.首先我们看下此模式的整体UML图selector:选择器又叫做上下文conte......
  • 如何查找SpringBoot应用中的请求路径(不使用idea)
    背景昨天有个同事向我咨询某个接口的物理表是哪个,由于公司业务较多、这块业务的确不是我负责的,也没有使用idea不能全局搜索(eclipse搜不到jar内的字符串),也就回复了不清楚。除了自己写代码输出servlet的路径和类外,发现了一个我之前没用过的方法:SpringBootActuator,分享给大家。......