接口安全防线加解密：springboot 全局-指定接口解密（同时支持参数在body和 ...

接口安全防线加解密：springboot 全局/指定接口解密（同时支持参数在body和param）

---

上风：通过注解形式，不必要改变原接口请求参数，在拦截器里面把加密数据解密为原接口请求参数。同时支持application/x-www-form-

urlencoded和application/json 的解密
1.原理

1.1.过滤器，过滤所有请求，使用HttpServletRequestWrapper解决request中流读取一次的处理，方便后续修改请求内容

1.2.自界说注解，通过自界说注解可以标识，指定哪些接口在拦截器中处理数据

1.3.拦截器，拦截带有指定注解的请求，把数据进行加密解密后返回处理

---

2.支持范围

2.1.实际可以自己改造适合多种环境处理，已支持以下

1.application/json 加密参数在body
2.application/x-www-form-urlencoded 支持参数在body大概在param
2.2.为什么不用RequestBodyAdvice

1.因为RequestBodyAdvice只支持body内容的数据加解密处理，具有局限性。

---

3.详细实现代码

3.1. 过滤器(目的读取request，为后续自界说数据做铺垫)

1. /**
2. * @Author: bright chen
3. */
4. @WebFilter(value = "/*", filterName = "uriFormatFilter")
5. public class UriFormatFilter extends OncePerRequestFilter {
6.     @Override
7.     protected void doFilterInternal(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, FilterChain filterChain) throws ServletException, IOException {
9.         String uri = httpServletRequest.getRequestURI();
10.         String newUri = uri.replace("//","/");
11.         httpServletRequest = new HttpServletRequestWrapper(httpServletRequest){
12.             @Override
13.             public String getRequestURI() {
14.                 return newUri;
15.             }
16.         };
17.         ServletRequest requestWrapper=new RequestWrapper(httpServletRequest);
18.         if(requestWrapper!=null){
19.             filterChain.doFilter(requestWrapper,httpServletResponse);
20.         }else{
21.             filterChain.doFilter(httpServletRequest, httpServletResponse);
22.         }
23.     }
24. }

复制代码

3.2.自界说HttpServletRequestWrapper（重点1，param赋值，body赋值，param pojo读取时赋值）

1. /**
2. * @Author: bright chen
3. */
4. public class RequestWrapper extends HttpServletRequestWrapper {
5.     private String body;
6.     private Map<String, String[]> params = new HashMap<String, String[]>();
8.     public RequestWrapper(HttpServletRequest request) {
9.         super(request);
10.         StringBuilder stringBuilder = new StringBuilder();
11.         BufferedReader bufferedReader = null;
12.         InputStream inputStream = null;
13.         try {
14.             inputStream = request.getInputStream();
15.             if (inputStream != null) {
16.                 bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
17.                 char[] charBuffer = new char[128];
18.                 int bytesRead = -1;
19.                 while ((bytesRead = bufferedReader.read(charBuffer)) > 0) {
20.                     stringBuilder.append(charBuffer, 0, bytesRead);
21.                 }
22.             } else {
23.                 stringBuilder.append("");
24.             }
25.         } catch (IOException ex) {
27.         } finally {
28.             if (inputStream != null) {
29.                 try {
30.                     inputStream.close();
31.                 } catch (IOException e) {
32.                     e.printStackTrace();
33.                 }
34.             }
35.             if (bufferedReader != null) {
36.                 try {
37.                     bufferedReader.close();
38.                 } catch (IOException e) {
39.                     e.printStackTrace();
40.                 }
41.             }
42.         }
43.         body = stringBuilder.toString();
44.         this.params.putAll(request.getParameterMap());
45.     }
48.     @Override
49.     public Map<String, String[]> getParameterMap() {
50.         return params;
51.     }
54.     @Override
55.     public ServletInputStream getInputStream() throws IOException {
56.         final ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(body.getBytes());
57.         ServletInputStream servletInputStream = new ServletInputStream() {
58.             @Override
59.             public boolean isFinished() {
60.                 return false;
61.             }
63.             @Override
64.             public boolean isReady() {
65.                 return false;
66.             }
68.             @Override
69.             public void setReadListener(ReadListener readListener) {
70.             }
72.             @Override
73.             public int read() throws IOException {
74.                 return byteArrayInputStream.read();
75.             }
76.         };
77.         return servletInputStream;
78.     }
81.     // 重载一个构造方法
82.     public RequestWrapper(HttpServletRequest request, Map<String, Object> extendParams, String body) {
83.         this(request);
84.         if (body != null && body.length() > 0) {
85.             setBody(body);
86.         }
87.         if (extendParams.size() > 0) {
88.             addAllParameters(extendParams);// 这里将扩展参数写入参数表
89.         }
90.     }
93.     @Override
94.     public BufferedReader getReader() throws IOException {
95.         return new BufferedReader(new InputStreamReader(this.getInputStream()));
96.     }
98.     public String getBody() {
99.         return this.body;
100.     }
102.     // 赋值给body字段
103.     public void setBody(String body) {
104.         this.body = body;
105.     }
108.     @Override
109.     public String getParameter(String name) {// 重写getParameter，代表参数从当前类中的map获取
110.         String[] values = params.get(name);
111.         if (values == null || values.length == 0) {
112.             return null;
113.         }
114.         return values[0];
115.     }
117.     public String[] getParameterValues(String name) {// 同上
118.         return params.get(name);
119.     }
122.     /**
123.      * 参数为pojo类型时，会通过此方法获取所有的请求参数并进行遍历，对pojo属性赋值
124.      *
125.      * @return
126.      */
127.     @Override
128.     public Enumeration<String> getParameterNames() {// 同上
129.         ArrayList<String> list = list = new ArrayList<>();
130.         for (Map.Entry<String, String[]> entry : params.entrySet()) {
131.             list.add(entry.getKey());
132.         }
133.         return Collections.enumeration(list);
134.     }
136.     public void addAllParameters(Map<String, Object> otherParams) {// 增加多个参数
137.         for (Map.Entry<String, Object> entry : otherParams.entrySet()) {
138.             addParameter(entry.getKey(), entry.getValue());
139.         }
140.     }
143.     public void addParameter(String name, Object value) {// 增加参数
144.         if (value != null) {
145.             if (value instanceof String[]) {
146.                 params.put(name, (String[]) value);
147.             } else if (value instanceof String) {
148.                 params.put(name, new String[]{(String) value});
149.             } else {
150.                 params.put(name, new String[]{String.valueOf(value)});
151.             }
152.         }
153.     }
154. }

复制代码

3.3.自界说注解 @DecryptApi，后期在controller层带上这个注解则该controller层接口会被过滤器及拦截器进行解密处理。

1. /**
2. * 支持params和body的解密
3. * 支持
4. * @Author: bright chen
5. */
6. @Retention(RetentionPolicy.RUNTIME)
7. @Target({ElementType.METHOD,ElementType.PARAMETER})
8. public @interface DecryptApi {
9. }

复制代码

3.4. （核心代码） 拦截器 DecryptInterceptor，对带有@DecryptApi注解的接口数据进行解密处理后重新赋值，注意配置

拦截所有请求

1. /**
2. * @Author: bright chen
3. * api 解密拦截器
4. */
5. public class DecryptInterceptor extends HandlerInterceptorAdapter {
6.     private static Logger logger = LogManager.getLogger(DecryptInterceptor.class);
7.     @Autowired
8.     private EncryptProperties encryptProperties;
10.     /**
11.      * Controller之前执行
12.      * preHandle：拦截于请求刚进入时，进行判断，需要boolean返回值，如果返回true将继续执行，如果返回false，将不进行执行。一般用于登录校验
13.      * 1.当preHandle方法返回false时，从当前拦截器往回执行所有拦截器的afterCompletion方法，再退出拦截器链。也就是说，请求不继续往下传了，直接沿着来的链往回跑。
14.      * 2.当preHandle方法全为true时，执行下一个拦截器,直到所有拦截器执行完。再运行被拦截的Controller。然后进入拦截器链，运行所有拦截器的postHandle方法,
15.      * 完后从最后一个拦截器往回执行所有拦截器的afterCompletion方法.
16.      */
17.     @Override
18.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
19.         try {
22.             if (handler instanceof HandlerMethod) {
23.                 HandlerMethod method = (HandlerMethod) handler;
24.                 // RequireLogin annotation = method.getMethodAnnotation(RequireLogin.class);
25.                 if (method.hasMethodAnnotation(DecryptApi.class)) {
26.                     // 需要对数据进行加密解密
27.                     // 1.对application/json类型
28.                     String contentType = request.getContentType();
29.                     if (contentType == null && !"GET".equals(request.getMethod())) {
30.                         // 请求不通过，返回错误信息给客户端
31.                         responseResult(response, response.getWriter(), TResponse.FAIL("Decrypt failed"));
32.                         return false;
33.                     }
34.                     String requestBody = null;
35.                     boolean shouldEncrypt = false;
37.                     if ((contentType != null && StringUtils.substringMatch(contentType, 0,
38.                             MediaType.APPLICATION_FORM_URLENCODED_VALUE)) || "GET".equals(request.getMethod())) {
39.                         // 1.application/x-www-form-urlencoded 支持参数在body或者在param
40.                         shouldEncrypt = true;
41.                         requestBody = convertFormToString(request);
42.                         if (requestBody == null || "{}".equals(requestBody)) {
43.                             requestBody = URLDecoder.decode(convertInputStreamToString(request.getInputStream()),
44.                                     "UTF-8");
45.                             List<String> uriToList =
46.                                     Stream.of(requestBody.split("&")).map(elem -> new String(elem)).collect(Collectors.toList());
48.                             Map<String, String> uriToListToMap = new HashMap<>();
51.                             for (String individualElement : uriToList) {
52.                                 if (individualElement.split("=")[0] != null && !"".equals(individualElement.split("=")[0])) {
53.                                     uriToListToMap.put(individualElement.split("=")[0],
54.                                             individualElement.substring(individualElement.split("=")[0].length() + 1));
55.                                 }
57.                             }
58.                             requestBody = JSONObject.toJSONString(uriToListToMap);
59.                         }
61.                     } else if (StringUtils.substringMatch(contentType, 0, MediaType.APPLICATION_JSON_VALUE)) {
62.                         // application/json 支持加密参数在body
63.                         shouldEncrypt = true;
64.                         requestBody = convertInputStreamToString(request.getInputStream());
66.                     }
68.                     if (requestBody == null || "{}".equals(requestBody)||!shouldEncrypt) {
69.                         return true;
70.                     } else {
72.                         String result = decodeApi(JSON.parseObject(requestBody, StdRequestApi.class),
73.                                 encryptProperties.getPrivateKey());
74.                         if (result == null) {
75.                             // 请求不通过，返回错误信息给客户端
76.                             responseResult(response, response.getWriter(), TResponse.FAIL("Decrypt failed"));
77.                             return false;
78.                         }
79.                         JSONObject jasonObject = JSONObject.parseObject(result);
80.                         Map map = (Map) jasonObject;
81.                         if (request instanceof RequestWrapper) {
82.                             RequestWrapper requestWrapper = (RequestWrapper) request;
83.                             requestWrapper.setBody(result);
84.                             requestWrapper.addAllParameters(map);
85.                             // requestWrapper = new RequestWrapper(request, map, result);
86.                             return true;
87.                         }
88.                     }
89.                 } else {
90.                     String contentType = request.getContentType();
91.                     if (contentType != null && contentType.length() > 0 && StringUtils.substringMatch(contentType, 0,
92.                             MediaType.APPLICATION_FORM_URLENCODED_VALUE)) {
93.                         // 1.application/x-www-form-urlencoded 支持参数在body或者在param
94.                         String requestBody = convertFormToString(request);
95.                         if (requestBody == null || "{}".equals(requestBody)) {
96.                             // 把流数据放进param中,不解密
97.                             requestBody = URLDecoder.decode(convertInputStreamToString(request.getInputStream()),
98.                                     "UTF-8");
99.                             List<String> uriToList =
100.                                     Stream.of(requestBody.split("&")).map(elem -> new String(elem)).collect(Collectors.toList());
102.                             Map<String, Object> uriToListToMap = new HashMap<>();
104.                             for (String individualElement : uriToList) {
105.                                 if (individualElement.split("=")[0] != null && !"".equals(individualElement.split("=")[0])) {
106.                                     uriToListToMap.put(individualElement.split("=")[0],
107.                                             individualElement.substring(individualElement.split("=")[0].length() + 1));
108.                                 }
109.                             }
110.                             if (request instanceof RequestWrapper) {
111.                                 RequestWrapper requestWrapper = (RequestWrapper) request;
112.                                 requestWrapper.setBody(requestBody);
113.                                 requestWrapper.addAllParameters(uriToListToMap);
114.                                 return true;
115.                             }
116.                         }
117.                     }
118.                 }
120.                 return true;
121.             }
122.             return true;
124.         } catch (Exception e) {
125.             e.printStackTrace();
126.             logger.error(e.getMessage() + "异常地址：" + request.getServletPath());
127.             responseResult(response, response.getWriter(), TResponse.FAIL("Decrypt failed"));
128.             return false;
129.         }
130.     }
133.     /**
134.      * 返回信息给客户端
135.      *
136.      * @param response
137.      * @param tResponse
138.      */
139.     private void responseResult(HttpServletResponse response, TResponse tResponse) throws IOException {
140.         response.setContentType(HttpConstant.CONTENT_TYPE_JSON);
141.         String json = JSONObject.toJSONString(tResponse);
142.         PrintWriter out = response.getWriter();
143.         out.print(json);
144.         out.flush();
145.         out.close();
146.     }
148.     private String convertFormToString(HttpServletRequest request) {
149.         Map<String, String> result = new HashMap<>(8);
150.         Enumeration<String> parameterNames = request.getParameterNames();
151.         while (parameterNames.hasMoreElements()) {
152.             String name = parameterNames.nextElement();
153.             result.put(name, request.getParameter(name));
154.         }
155.         try {
156.             return JSON.toJSONString(result);
157.         } catch (Exception e) {
158.             throw new IllegalArgumentException(e);
159.         }
160.     }
162.     private String convertInputStreamToString(InputStream inputStream) throws IOException {
163.         return StreamUtils.copyToString(inputStream, Charset.forName("UTF-8"));
164.     }
167.     public String decodeApi(StdRequestApi stdRequestApi, String apiPrivateKey) {
168.         try {
169.             // 1.rsa解密
170.             // 2.AES验签
171.             // 3.AES解密
172.             return deData;
173.         } catch (Exception e) {
174.             e.printStackTrace();
175.             return null;
176.         }
177.     }
179.     /**
180.      * 返回信息给客户端
181.      *
182.      * @param response
183.      * @param out
184.      * @param tResponse
185.      */
186.     private void responseResult(HttpServletResponse response, PrintWriter out, TResponse tResponse) {
187.         response.setContentType(HttpConstant.CONTENT_TYPE_JSON);
188.         String json = JSONObject.toJSONString(tResponse);
189.         out.print(json);
190.         out.flush();
191.         out.close();
192.     }
195. }

复制代码

3.5.公钥私钥配置读取

1. /**
2. * @Author: bright chen
3. */
4. @Component
5. @ConfigurationProperties(prefix = "api")
6. public class EncryptProperties {
7.     private String privateKey;
8.     private String publicKey;
10.     public String getPrivateKey() {
11.         return privateKey;
12.     }
14.     public void setPrivateKey(String privateKey) {
15.         this.privateKey = privateKey;
16.     }
18.     public String getPublicKey() {
19.         return publicKey;
20.     }
22.     public void setPublicKey(String publicKey) {
23.         this.publicKey = publicKey;
24.     }
25. }

复制代码

---

PS：本文编写于公司产物被黑客入侵后的处理方案之一，详细加密解密逻辑不在本文中报告
下一篇：接口安全防线注解加解密(二）：加密请求异常后请求/error处理
末了

从时代发展的角度看，网络安全的知识是学不完的，而且以后要学的会更多，同砚们要摆正心态，既然选择入门网络安全，就不能仅仅只是入门水平而已，能力越强时机才越多。
因为入门学习阶段知识点比较杂，所以我讲得比较笼统，各人如果有不懂的地方可以找我咨询，我保证知无不言言无不尽，必要相干资料也可以找我要，我的网盘里一大堆资料都在吃灰呢。
干货主要有：
①1000+CTF历届题库（主流和经典的应该都有了）
②CTF技术文档（最全中文版）
③项目源码（四五十个有趣且经典的练手项目及源码）
④ CTF大赛、web安全、渗出测试方面的视频（适合小白学习）
⑤ 网络安全学习路线图（告别不入流的学习）
⑥ CTF/渗出测试工具镜像文件大全
⑦ 2023密码学/隐身术/PWN技术手册大全
如果你对网络安全入门感爱好，那么你必要的话可以点击这里