SpringBoot 通过Filter与AOP实现请求加密解密功能

爱被打了一巴掌 2022-09-14 03:07 74阅读 0赞

# SpringBoot 通过Filter与AOP实现请求加密解密功能 #

> 对所有请求信息进行解密，解密之后传入Controller进行处理，Controller 处理完成之后返回结果信息在进行加密返回；  
> 执行流程：  
> 前端请求(加密) -> Filter(解密) -> AOP -> Controller -> AOP(加密) -> Filter -> 前端（解密）

为什么这么设计？这么设计有什么好处？

1.  通过Filter 可以修改请求入参，对于已经开发完成的接口完全不需要修改；
2.  采用AOP 可以对返回的结果对象进行处理，而Filter只能拿到Request与Response对象，处理不方便；
3.  Spring到 AOP层已经做了一些预处理，比如请求参数已经处理好，这时候在做处理显然不太合适；
4.  如果使用AOP 那么像 @RequestBody，@RequestParam 等注解就会失效。

具体代码如下；

## 1. 先通过HttpServletRequestWrapper接口修改请求参数； ##

通过HttpServletRequestWrapper可以获取到前端加密的请求参数，同时也可以将解密后的参数设置进去；  
这里需要特别注意；对于MultipartRequest请求如果不做处理HttpServletRequestWrapper中是获取不到参数的；

自定义RequestWrapper对象

import org.apache.commons.collections4.MapUtils;
    import org.apache.commons.io.IOUtils;
    import org.apache.commons.lang3.ArrayUtils;
    import org.apache.commons.lang3.StringUtils;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.web.multipart.MultipartRequest;
    
    import javax.servlet.ReadListener;
    import javax.servlet.ServletInputStream;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletRequestWrapper;
    import java.io.*;
    import java.util.*;
    /** * AKS加密解密请求封装，注意这个对象每次请求都需要new出来 * 这个类只是负责封装处理的参数 * @author liujunguang1 * @version V1.0 * @date 2021/09/30 10:27 */
    public class RequestWrapper extends HttpServletRequestWrapper { 
        private static final Logger log = LoggerFactory.getLogger(RequestWrapper.class);
    
        /** * 请求体，用于获取参数 */
        private String body;
        /** * 保存原始Request对象 */
        private HttpServletRequest request;
        /** * 额外参数可以加到这个里面 */
        private Map<String, String[]> parameterMap = new LinkedHashMap<>();
    
        public RequestWrapper(HttpServletRequest request) { 
            super(request);
            this.request = request;
            // 如果是文件上传类请求
            if(request instanceof MultipartRequest){ 
                this.parseBody(request);
            }else { 
                // 普通请求将请求体设置到body中去；这样可以多次使用流方式访问请求体
                try (ByteArrayOutputStream baos = new ByteArrayOutputStream()) { 
                    IOUtils.copy(request.getInputStream(), baos);
                    body = baos.toString();
                } catch (IOException e) { 
                    log.error("复制请求体失败，原因：{}", e.getMessage(), e);
                }
            }
        }
    
        /** * 如果是MultipartRequest，需要解析参数信息 */
        private void parseBody(HttpServletRequest request) { 
            Map<String,Object> parameterMap = new LinkedHashMap<>();
            Enumeration<String> parameterNames = request.getParameterNames();
            while(parameterNames.hasMoreElements()){ 
                String name = parameterNames.nextElement();
                String[] values = request.getParameterValues(name);
                parameterMap.put(name, (values !=null && values.length == 1) ? values[0] : values);
            }
            // 将解析出来的参数，转换成JSON并设置到body中保存
            this.body = JsonUtil.toJSONString(parameterMap);
        }
    
        /** * The default behavior of this method is to return getInputStream() on the * wrapped request object. */
        @Override
        public ServletInputStream getInputStream() throws IOException { 
            final ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(body.getBytes());
            return new ServletInputStream() { 
                @Override
                public boolean isFinished() { 
                    return false;
                }
    
                @Override
                public boolean isReady() { 
                    return false;
                }
    
                @Override
                public void setReadListener(ReadListener listener) { 
                }
    
                @Override
                public int read() throws IOException { 
                    return byteArrayInputStream.read();
                }
            };
        }
    
        @Override
        public BufferedReader getReader() throws IOException { 
            return new BufferedReader(new InputStreamReader(this.getInputStream()));
        }
    
        /** * 获取请求体 * @return */
        public String getBody(){ 
            return this.body;
        }
    
    
        /** * 设置请求体，如果是MultipartRequest请求则需要同步保存到参数Map中去 * @param body 请求体 */
        public void setBody(String body){ 
            this.body = body;
            try { 
                if(this.request instanceof MultipartRequest){ 
                    this.setParameterMap(JsonUtil.json2map(body));
                }
            } catch (Exception e) { 
                log.error("转换参数异常，参数：{}，异常：{}",body, e);
            }
        }
    
        /** * The default behavior of this method is to return getParameter(String * name) on the wrapped request object. * * @param name */
        @Override
        public String getParameter(String name) { 
            String result =  super.getParameter(name);
            // 如果参数获取不到则尝试从参数Map中获取，并且只返回第一个
            if(StringUtils.isBlank(result) && this.parameterMap.containsKey(name)){ 
                result = this.parameterMap.get(name)[0];
            }
            return result;
        }
    
        /** * The default behavior of this method is to return getParameterMap() on the * wrapped request object. */
        @Override
        public Map<String, String[]> getParameterMap() { 
            // 需要将原有的参数加上新参数 返回
            Map<String,String[]> map = new HashMap<>(super.getParameterMap());
            for(String key: this.parameterMap.keySet()){ 
                map.put(key, this.parameterMap.get(key));
            }
            return Collections.unmodifiableMap(map);
        }
    
        /** * The default behavior of this method is to return * getParameterValues(String name) on the wrapped request object. * * @param name */
        @Override
        public String[] getParameterValues(String name) { 
            String[] result =  super.getParameterValues(name);
            if(result == null && this.parameterMap.containsKey(name)){ 
                result = this.parameterMap.get(name);
            }
            return result;
        }
    
        /** * The default behavior of this method is to return getParameterNames() on * the wrapped request object. */
        @Override
        public Enumeration<String> getParameterNames() { 
            Enumeration<String> parameterNames = super.getParameterNames();
            Set<String> names = new LinkedHashSet<>();
            if(parameterNames !=null){ 
                while(parameterNames.hasMoreElements()){ 
                    names.add(parameterNames.nextElement());
                }
            }
            // 添加后期设置的参数Map
            if(!this.parameterMap.isEmpty()){ 
                names.addAll(this.parameterMap.keySet());
            }
            return Collections.enumeration(names);
        }
    
        /** * 设置参数map * @param json2map */
        public void setParameterMap(Map<String, Object> json2map) { 
            if(json2map != null && !json2map.isEmpty()) { 
                for (String key : json2map.keySet()){ 
                    String value = MapUtils.getString(json2map, key);
                    if(this.parameterMap.containsKey(key)){ 
                        this.parameterMap.put(key, ArrayUtils.add(this.parameterMap.get(key), value));
                    }else{ 
                        this.parameterMap.put(key, new String[]{ value});
                    }
                }
            }
        }
    }

## 2. 使用Filter解密请求参数 ##

这里需要解密规则是，如果请求头包含指定的头，并且值为指定的值。才进行请求参数的解密；

> 注意：对于Get与Post请求需要分别处理; get 请求的加密参数需要使用：encryptData，Post 整个请求体都是加密参数

代码如下：

import lombok.extern.slf4j.Slf4j;
    import org.apache.commons.lang3.StringUtils;
    import org.springframework.beans.BeansException;
    import org.springframework.context.ApplicationContext;
    import org.springframework.core.annotation.Order;
    import org.springframework.web.context.support.WebApplicationContextUtils;
    import org.springframework.web.multipart.MultipartResolver;
    
    import javax.servlet.*;
    import javax.servlet.annotation.WebFilter;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    import java.util.Objects;
    
    /** * Aks加密解密过滤器 * * @author liujunguang1 * @version V1.0 * @date 2021/09/30 10:55 */
    @Order(12)
    @Slf4j
    // 指定对所有请求都进行拦截，注意需要配合：@ServletComponentScan(basePackages="xx") 一起使用才生效
    @WebFilter(urlPatterns = "/*") 
    public class AksFilter implements Filter { 
        // 需要特殊处理的请求头
        private static final String AKS_HEADER = "aksEncrypt";
        // 加密参数名称
        private static final String AKS_PARAMETER = "encryptData";
        private static final String METHOD_GET = "GET";
        private static final String METHOD_POST = "POST";
        // 是否为文件上传请求
        private static final String MULTIPART_FORM ="multipart/form-data";
    
        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain chain) throws IOException, ServletException { 
            // 获取并转换请求对象
            HttpServletRequest request = this.getHttpServletRequest(servletRequest);
            HttpServletResponse response = (HttpServletResponse) servletResponse;
            String url = request.getRequestURL().toString();
            // 如果不需要处理，直接返回
            if(!needAks(request)){ 
                log.debug("请求：{},非加密请求，不解密！", url);
                chain.doFilter(request, response);
                return;
            }
            // 包装请求对象
            RequestWrapper requestWrapper = new RequestWrapper(request);
            // POST 请求
            if(StringUtils.equalsIgnoreCase(requestWrapper.getMethod(), METHOD_POST)) { 
                // 获取加密之前的请求数据
                String encryptData = requestWrapper.getBody();
                requestWrapper.setAttribute(AKS_PARAMETER, encryptData);// 这行主要是 解密时候 需要传入加密原始参数，所以保存了下
                log.info("Post请求:{}，待解密请求参数：{}", url, encryptData);
                // 解密数据，这里调用Service进行解密
                String decryptoData = this.getAksService(request.getServletContext()).decryptoAksWebData(encryptData);
                log.info("Post请求:{}，解密之后参数：{}", url, decryptoData);
                // 特别声明，Post请求参数应该是JSON格式加密后的数据
                requestWrapper.setBody(decryptoData);
            }
            // Get 请求
            else if(StringUtils.equalsIgnoreCase(requestWrapper.getMethod(), METHOD_GET)){ 
                String encryptData = request.getParameter(AKS_PARAMETER);
                log.info("Get请求:{}，待解密请求参数：{}", url, encryptData);
                if(StringUtils.isNotBlank(encryptData)){ 
                    requestWrapper.setAttribute(AKS_PARAMETER, encryptData);// 这行主要是 解密时候 需要传入加密原始参数，所以保存了下
                    // 解密数据
                    String decryptoData = this.getAksService(request.getServletContext()).decryptoAksWebData(encryptData);
                    log.info("Get请求:{}，解密之后参数：{}", url, decryptoData);
                    requestWrapper.setParameterMap(JsonUtil.json2map(decryptoData));
                }
            }
            chain.doFilter(requestWrapper, response);
        }
    
        /** * 转换为HttpServletRequest 对象 * @param servletRequest 请求对象 * @return HttpServletRequest */
        private HttpServletRequest getHttpServletRequest(ServletRequest servletRequest) { 
            String enctype = servletRequest.getContentType();
            if (StringUtils.isNotBlank(enctype) && enctype.contains(MULTIPART_FORM)) { 
                // 注意：MultipartResolver springboot 已经默认注入了，如果没有的话，需要手动注入
                // 如果不使用MultipartResolver那么request.getParameter(name)，就获取不到参数，这里spring帮我们做了参数解析
                return this.getBean(servletRequest.getServletContext(), MultipartResolver.class).resolveMultipart((HttpServletRequest) servletRequest);
            }
            return (HttpServletRequest) servletRequest;
        }
    
        /** * 获取Aks服务 * @param sc * @return */
        private AksService getAksService(ServletContext sc){ 
            return  this.getBean(sc, AksService.class);
        }
    
        /** * 获取Spring中定义的Bean都对象 * @param sc ServletContext * @param requiredType 需要的类型 * @param <T> 结果 * @return 结果 */
        private <T> T getBean(ServletContext sc, Class<T> requiredType){ 
            ApplicationContext ctx = WebApplicationContextUtils.getWebApplicationContext(sc);
            return  Objects.requireNonNull(ctx).getBean(requiredType);
        }
    
        /** * 判断当前请求是否需要加密解密数据 * 根据请求头中 是否包含：aksEncrypt，并且值为 true * @return true 需要，false 不需要 */
        private boolean needAks(HttpServletRequest request) { 
            return StringUtils.equalsIgnoreCase(request.getHeader(AKS_HEADER), "true");
        }
    }

到此Controller参数已经通过Filter解析完成了，并且@RequestBody @Validated 等注解也是可用的。

接下来controller 执行完成，开始进行对返回值进行加密

## 3. AksSecretAspect Controller执行后的参数加密 ##

如果采用Filter也可以完成，但是需要转换成JSON对象或者对整个字符串进行加密处理；  
这里使用Spring Intercepter（AOP方式）

import com.HttpResponse;
    import lombok.extern.slf4j.Slf4j;
    import org.apache.commons.lang3.StringUtils;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    import org.springframework.web.context.request.RequestContextHolder;
    import org.springframework.web.context.request.ServletRequestAttributes;
    
    import javax.servlet.http.HttpServletRequest;
    import java.util.Objects;
    
    /** * 加密解密切面类 * * @author liujunguang1 * @version V1.0 * @date 2021/09/29 14:11 */
    @Aspect
    @Component
    @Slf4j
    public class AksSecretAspect { 
        private static final String AKS_HEADER = "aksEncrypt";
        private static final String AKS_PARAMETER = "encryptData";
        // 加密解密辅助类
        @Autowired
        private AksService aksService;
    
        /** * 环绕通知 @Around * * @param point 切面 * @throws Throwable */
        @Around("execution(* com.web.controller.*.*(..))")
        public Object around(ProceedingJoinPoint point) throws Throwable { 
            if(!needAks()){ 
                return point.proceed();
            }
            Object result = point.proceed();
            return this.encryptResult(result);
        }
    
        /** * 加密结果信息 * @param result 结果数据 * @return 响应结果 */
        private Object encryptResult(Object result) { 
            String encryptData = getEncryptData();
            if(result == null || StringUtils.isBlank(encryptData)){ 
                log.info("返回值为空，不加密数据！");
                return result;
            }
            // 结果信息，HttpResponse自定义类，有 T data 属性，这个是需要加密的，其他字段不需要加密
            if(result instanceof HttpResponse){ 
                HttpResponse<Object>  baseResponse = (HttpResponse<Object>) result;
                String data = JsonUtil.toJSONString(((HttpResponse<?>) result).getData());
                baseResponse.setData(aksService.encryptoAksWebData(encryptData, data));
                baseResponse.setAksEncrypt(true);
                log.info("Aks加密返回结果Data数据:{}", StringUtils.substring(data, 0,200));
            }
            return result;
        }
    
        /** * 获取加密的字符串 * @return 加密数据信息 */
        private String getEncryptData() { 
            HttpServletRequest request = ((ServletRequestAttributes) Objects.requireNonNull(RequestContextHolder.getRequestAttributes())).getRequest();
            return String.valueOf(request.getAttribute(AKS_PARAMETER));
        }
    
        /** * 判断当前请求是否需要加密解密数据 * 根据请求头中 是否包含：aksEncrypt，并且值为 true * @return true 需要，false 不需要 */
        private boolean needAks() { 
            HttpServletRequest request = ((ServletRequestAttributes) Objects.requireNonNull(RequestContextHolder.getRequestAttributes())).getRequest();
            return StringUtils.equalsIgnoreCase(request.getHeader(AKS_HEADER), "true");
        }
    
    }

到此加密解密就已经写完了，可以愉快的回家了；  
提示：别忘了Main类中@ServletComponentScan注解

另外留个家庭作业：采用上面的方式比较麻烦，又是Filter 又是AOP 其实Spring 提供的更加方便的接口：Intecepter 接口；  
小伙伴们可以通过Intecepter接口来实现前端请求的加密解密；这里就不在累述了；

提示：不管是采用 AOP还是Intecepter 都需要对请求对象进行修改，那么必然少不了HttpServletRequestWrapper接口的使用；

## Filter 踩坑记 ##

问题描述：以上代码在java8 + SpringBoot 2.5.0 + Tomcat9.0.x可以启动（以jar包方式执行）；但是放到服务器上（war tomcat 8.5.42）却启动失败；  
原因：tomcat 9.0.x 支持 servlet 4.0 版本，tomcat 8.5.x 支持servlet 3.1 版本。相应的Filter 变化是4.0使用java default 默认方法从写了init 与destory 方法， 而3.1需要实现这两个方法，这才导致tomcat 8 中启动失败。

问题解决办法：覆盖filter 中的 init 与 destory 方法；