springboot实现参请求参数和返回参数的加密解密(RequestBodyAdvice、ResponseBodyAdvice、HandlerMethodArgumentResolver)

我不是女神ヾ 2022-11-27 07:08 226阅读 0赞

#### 前言 ####

> 在前后端分离系统的基础架构中，安全框架、令牌鉴权基本已经能保证数据的安全，  
> 但某些场景，仅有鉴权是不够的，一些比较重要的数据，还需要一个针对请求报文加密解密的工具，前端送加密报文，后端直接解密。

#### 实现细节 ####

**参考链接**  
码云上别人写的例子，具有参考意义。  
https://gitee.com/licoy/encrypt-body-spring-boot-starter?\_from=gitee\_search

##### 第一步 #####

添加一个参数解析解析器，通过WebMvcConfigurer来添加一个参数解析器，自定义参数解析器需要实现HandlerMethodArgumentResolver接口，springboot添加参数解析器，可以通过

WebMvcConfigurer的addArgumentResolvers方法来实现，WebMvcConfigurer是一个接口，自定义一个类实现该接口并重写addArgumentResolvers方法。  
ApiCryptoConfiguration 类需要添加@Configuration注解，使其标记为一个配置类，其他都是一些辅助属性，关键是要让WebMvcConfigurer生效就可以。  
这个生效了之后，每次进入controller的方法之前都会进这里进行参数解析，也是就是把前端的请求参数转换成我们一般说的对象，这里也只是简单的测试了一下，具体使用还得根据自己的业务来实现。

@Configuration
    @RequiredArgsConstructor
    @EnableConfigurationProperties(ApiCryptoProperties.class)
    public class ApiCryptoConfiguration implements WebMvcConfigurer { 
       private final ApiCryptoProperties apiCryptoProperties;
     
       @Override
       public void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) { 
          argumentResolvers.add(new ApiDecryptParamResolver(apiCryptoProperties));
       }
     
    }

ApiDecryptParamResolver这个类是自定义的参数解析器，自定义的参数解析器需要实现HandlerMethodArgumentResolver接口，主要实现supportsParameter和resolveArgument方法，  
supportsParameter方法返回为true的时候会执行下面的解析参数方法(resolveArgument),resolveArgument方法就是把参数解密之后然后转换成方法的参数对象，到这里基本上就完成了加密参数解析，且转换成方法参数对象的功能。

@RequiredArgsConstructor
    public class ApiDecryptParamResolver implements HandlerMethodArgumentResolver { 
       private final ApiCryptoProperties properties;
     
       @Override
       public boolean supportsParameter(MethodParameter parameter) { 
       //参数是否需要加密，是根据自己的业务来定的。
       //一般是通过自定义注解来实现。
          return AnnotatedElementUtils.hasAnnotation(parameter.getParameter(), ApiDecrypt.class);
       }
     
       @Nullable
       @Override
       public Object resolveArgument(MethodParameter methodParameter, ModelAndViewContainer mavContainer,
                              NativeWebRequest webRequest, WebDataBinderFactory binderFactory) { 
          Parameter parameter = methodParameter.getParameter();
          ApiDecrypt apiDecrypt = AnnotatedElementUtils.getMergedAnnotation(parameter, ApiDecrypt.class);
          String text = webRequest.getParameter(properties.getParamName());
          if (StringUtil.isBlank(text)) { 
             return null;
          }
          //前端请求的参数怎么解密，根据业务自己定。
          CryptoInfoBean infoBean = new CryptoInfoBean(apiDecrypt.value(), apiDecrypt.secretKey());
          byte[] textBytes = text.getBytes(Charsets.UTF_8);
          byte[] decryptData = ApiCryptoUtil.decryptData(properties, textBytes, infoBean);
          return JsonUtil.readValue(decryptData, parameter.getType());
       }
    }

上面这种方法是通过固定K的形式传输的，因为代码里面的String text = webRequest.getParameter(properties.getParamName());获取参数的获取一个固定的K的值，然后再解析来完成的。

这种通过使用param方式传参，如果传多个参数都是加密的，那么解析起来就不方便了，比如前段传两个加密的参数，那这就需要获取两次，然后合并再转换成调用方法里面的参数，当然如果约定好规范就固定一个K来传也是可以的。

另外一种方式提供了 body提交方式。将 @ApiDecrypt 注解从参数处移至方法处, 并加上 @RequestBody 注解。

这种实现方式的原理是这样的，因为使用@RequestBody注解来注入参数，要想对@RequestBody注解标识的参数前后做解析操作，需要使用**RequestBodyAdvice**和**ResponseBodyAdvice**接口。

##### 请求的解析实现。 #####

RequestBodyAdvice接口主要实现两个方法，supports方法用来判断是否需要对body进行操作，beforeBodyRead方法用来解析请求参数。

@Slf4j
    @Order(1)
    @Configuration
    @ControllerAdvice
    @RequiredArgsConstructor
    public class ApiDecryptRequestBodyAdvice implements RequestBodyAdvice { 
       private final ApiCryptoProperties properties;
     
       @Override
       public boolean supports(MethodParameter methodParameter, @NonNull Type targetType, @NonNull Class<? extends HttpMessageConverter<?>> converterType) { 
       //这个一样，判断是否需要解密。
          return ClassUtil.isAnnotated(methodParameter.getMethod(), ApiDecrypt.class);
       }
     
       @Override
       public Object handleEmptyBody(Object body, @NonNull HttpInputMessage inputMessage, @NonNull MethodParameter parameter,
                              @NonNull Type targetType, @NonNull Class<? extends HttpMessageConverter<?>> converterType) { 
          return body;
       }
     
       @NonNull
       @Override
       public HttpInputMessage beforeBodyRead(HttpInputMessage inputMessage, @NonNull MethodParameter parameter,
                                     @NonNull Type targetType, @NonNull Class<? extends HttpMessageConverter<?>> converterType) throws IOException { 
          // 判断 body 是否为空
          InputStream messageBody = inputMessage.getBody();
          if (messageBody.available() <= 0) { 
             return inputMessage;
          }
          byte[] decryptedBody = null;
          CryptoInfoBean cryptoInfoBean = ApiCryptoUtil.getDecryptInfo(parameter);
          if (cryptoInfoBean != null) { 
             // base64 byte array
             byte[] bodyByteArray = StreamUtils.copyToByteArray(messageBody);
             decryptedBody = ApiCryptoUtil.decryptData(properties, bodyByteArray, cryptoInfoBean);
          }
          if (decryptedBody == null) { 
             throw new Exception("Decryption error");
          }
          InputStream inputStream = new ByteArrayInputStream(decryptedBody);
          //@使用RequestBody注解，在获取到流里面的信息之后，解密，最后还是返回inputStream对象。
          return new DecryptHttpInputMessage(inputStream, inputMessage.getHeaders());
       }
     
       @NonNull
       @Override
       public Object afterBodyRead(@NonNull Object body, @NonNull HttpInputMessage inputMessage, @NonNull MethodParameter parameter, @NonNull Type targetType, @NonNull Class<? extends HttpMessageConverter<?>> converterType) { 
          return body;
       }

##### 返回的处理实现(返回的加密，不管使用哪种方式，返回要加密，都要对ResponseBodyAdvice进行处理) #####

ResponseBodyAdvice接口主要实现两个方法，supports方法用来判断是否需要对body进行操作，beforeBodyRead方法用来解析请求参数。

@Slf4j
    @Order(1)
    @Configuration
    @ControllerAdvice
    @RequiredArgsConstructor
    public class ApiEncryptResponseBodyAdvice implements ResponseBodyAdvice<Object> { 
       private final ApiCryptoProperties properties;
     
       @Override
       public boolean supports(MethodParameter returnType, @NonNull Class converterType) { 
          return ClassUtil.isAnnotated(returnType.getMethod(), ApiEncrypt.class);
       }
     
       @Nullable
       @Override
       public Object beforeBodyWrite(Object body, @NonNull MethodParameter returnType, @NonNull MediaType selectedContentType,
                              @NonNull Class selectedConverterType, @NonNull ServerHttpRequest request, @NonNull ServerHttpResponse response) { 
          if (body == null) { 
             return null;
          }
          response.getHeaders().setContentType(MediaType.TEXT_PLAIN);
          CryptoInfoBean cryptoInfoBean = ApiCryptoUtil.getEncryptInfo(returnType);
          if (cryptoInfoBean != null) { 
             byte[] bodyJsonBytes = JsonUtil.toJsonAsBytes(body);
             return ApiCryptoUtil.encryptData(properties, bodyJsonBytes, cryptoInfoBean);
          }
          throw new EncryptBodyFailException();
       }
     
    }

#### 总结 ####

要想对请求和返回的数据进行加密，主要是自定义自己的参数解析器，然后再数据绑定之前和数据返回之后进行相关加密和解密操作就可以。