devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Springboot中使用过滤器校验PSOT类型请求参数内容_spring在过滤器中添加正则校验参数

作者：我家自动化 | 2024-03-25 15:12:06

赞

踩

spring在过滤器中添加正则校验参数

目录

目的

实现步骤

完整代码

目的

        在Springboot中创建过滤器，用来过滤所有POST类型请求并获取body中的参数进行校验内容是否合法；该方法仅适用于POST类型请求，因为POST和GET请求的参数位置不一样所以处理方式也不一样，如果想要实现拦截获取GET类型请求校验参数，可以参考以下示例：

Springboot中拦截GET请求获取请求参数验证合法性icon-default.png?t=N6B9https://blog.csdn.net/weixin_45151960/article/details/132184917?spm=1001.2014.3001.5501

实现步骤

        1、创建Filter过滤器用来过滤所有请求；

        2、将PSOT类型请求中的body参数内容进行转换；

        3、处理body数据进行校验：

                3.1、当body数据仅为json对象时进行处理校验；

                3.2、当body数据仅为json数组时进行处理校验；

                3.3、当body数据为json对象且包含json数组时进行处理校验；

                3.4、当body数据为json数组且包含json对象时进行处理校验；

                

完整代码

        过滤器

  1. import com.alibaba.fastjson.JSON;
  2. import com.alibaba.fastjson.JSONArray;
  3. import com.alibaba.fastjson.JSONObject;
  4. import com.boc.ljh.utils.Result;
  5. import com.boc.ljh.utils.status.AppErrorCode;
  6. import org.springframework.context.annotation.Configuration;
  7.  
  8. import javax.servlet.*;
  9. import javax.servlet.annotation.WebFilter;
  10. import javax.servlet.http.HttpServletRequest;
  11. import javax.servlet.http.HttpServletResponse;
  12. import java.io.IOException;
  13. import java.util.List;
  14. import java.util.Map;
  15. import java.util.Set;
  16.  
  17.  
  18. /**
  19.  * @Author: ljh
  20.  * @ClassName SqlFilter
  21.  * @Description 过滤请求内容 防止sql注入
  22.  * @date 2023/8/8 16:15
  23.  * @Version 1.0
  24.  */
  25.  
  26. @WebFilter(urlPatterns = "/*", filterName = "sqlFilter")
  27. @Configuration
  28. public class SqlFilter implements Filter {
  29.  
  30.     @Override
  31.     public void init(FilterConfig filterConfig) {
  32.     }
  33.  
  34.     @Override
  35.     public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
  36.         HttpServletResponse response = (HttpServletResponse) servletResponse;
  37.         response.setContentType("application/json;charset=utf-8");
  38.         Result result = new Result();
  39.         result.setStatus(500);
  40.         result.setMessage(AppErrorCode.REQUEST_DATA_FULL.message);
  41.         String data = JSON.toJSONString(result);
  42.         BodyReaderRequestWrapper wrapper = null;
  43.         HttpServletRequest request = (HttpServletRequest) servletRequest;
  44.         if (request.getMethod().equals("POST")) {
  45.             String contentType = request.getContentType();
  46.             if ("application/json".equals(contentType)) {
  47.                 wrapper = new BodyReaderRequestWrapper(request);
  48.                 String requestPostStr = wrapper.getBody();
  49.                 if (requestPostStr.startsWith("{")) {
  50.                     //解析json对象
  51.                     boolean b = resolveJSONObjectObj(requestPostStr);
  52.                     if (!b) {
  53.                         response.getWriter().print(data);
  54.                         return;
  55.                     }
  56.                 } else if (requestPostStr.startsWith("[")) {
  57.                     //把数据转换成json数组
  58.                     JSONArray jsonArray = JSONArray.parseArray(requestPostStr);
  59.                     List<String> list = JSONObject.parseArray(jsonArray.toJSONString(), String.class);
  60.                     for (String str : list) {
  61.                         if (str.startsWith("{")) {
  62.                             //解析json对象
  63.                             boolean b = resolveJSONObjectObj(requestPostStr);
  64.                             if (!b) {
  65.                                 response.getWriter().print(data);
  66.                                 return;
  67.                             }
  68.                         } else {
  69.                             boolean b = verifySql(str);
  70.                             if (b) {
  71.                                 try {
  72.                                     response.getWriter().print(data);
  73.                                     return;
  74.                                 } catch (IOException e) {
  75.                                     e.printStackTrace();
  76.                                 }
  77.                             }
  78.                         }
  79.                     }
  80.                 }
  81.             } else {
  82.                 //application/x-www-form-urlencoded
  83.                 Map<String, String[]> parameterMap = request.getParameterMap();
  84.                 for (Map.Entry<String, String[]> entry : parameterMap.entrySet()) {
  85.                     //校验参数值是否合法
  86.                     String[] value = entry.getValue();
  87.                     for (String s : value) {
  88.                         //校验参数值是否合法
  89.                         boolean b = verifySql(s);
  90.                         if (b) {
  91.                             response.getWriter().print(data);
  92.                             return;
  93.                         }
  94.                     }
  95.                 }
  96.             }
  97.         }
  98.         if (wrapper == null) {
  99.             filterChain.doFilter(servletRequest, servletResponse);
  100.         } else {
  101.             filterChain.doFilter(wrapper, servletResponse);
  102.         }
  103.     }
  104.  
  105.     /**
  106.      * @Author: ljh
  107.      * @Description: 对JSONObject对象进行递归参数解析
  108.      * @DateTime: 14:26 2023/8/9
  109.      * @Params:
  110.      * @Return
  111.      */
  112.     private boolean resolveJSONObjectObj(String requestPostStr) {
  113.         boolean isover = true;
  114.         // 创建需要处理的json对象
  115.         JSONObject jsonObject = JSONObject.parseObject(requestPostStr);
  116.         // 获取所有的参数key
  117.         Set<String> keys = jsonObject.keySet();
  118.         if (keys.size() > 0) {
  119.             for (String key : keys) {
  120.                 //获取参数名称
  121.                 String value;
  122.                 if (jsonObject.get(key) != null) {
  123.                     value = String.valueOf(jsonObject.get(key));
  124.                     //当value为数组时
  125.                     if (value.startsWith("[")) {
  126.                         //把数据转换成json数组
  127.                         JSONArray jsonArray = JSONArray.parseArray(value);
  128.                         for (Object o : jsonArray) {
  129.                             if (o.toString().startsWith("{")) {
  130.                                 //解析json对象
  131.                                 boolean b = resolveJSONObjectObj(o.toString());
  132.                                 if (!b) {
  133.                                     isover = false;
  134.                                     break;
  135.                                 }
  136.                             } else {
  137.                                 boolean b = verifySql(value);
  138.                                 if (b) {
  139.                                     isover = false;
  140.                                     break;
  141.                                 }
  142.                             }
  143.                         }
  144.                     } else if (value.startsWith("{")) {
  145.                         boolean b = resolveJSONObjectObj(value);
  146.                         if (!b) {
  147.                             isover = false;
  148.                             break;
  149.                         }
  150.                     } else {
  151.                         //校验参数值是否合法
  152.                         boolean b = verifySql(value);
  153.                         if (b) {
  154.                             isover = false;
  155.                             break;
  156.                         }
  157.                     }
  158.                 }
  159.             }
  160.         }
  161.         return isover;
  162.     }
  163.  
  164.  
  165.     @Override
  166.     public void destroy() {
  167.     }
  168.  
  169.     /**
  170.      * @Author: ljh
  171.      * @Description: 校验参数非法字符
  172.      * @DateTime: 14:26 2023/8/9
  173.      * @Params:
  174.      * @Return
  175.      */
  176.     public boolean verifySql(String parameter) {
  177.         String s = parameter.toLowerCase();
  178.         // 过滤掉的sql关键字，特殊字符前面需要加\\进行转义
  179.         String badStr =
  180.                 "select|update|and|or|delete|insert|truncate|char|into|substr|ascii|declare|exec|count|master|into|drop|execute|table|" +
  181.                         "char|declare|sitename|xp_cmdshell|like|from|grant|use|group_concat|column_name|" +
  182.                         "information_schema.columns|table_schema|union|where|order|by|" +
  183.                         "'\\*|\\;|\\-|\\--|\\+|\\,|\\//|\\/|\\%|\\#";
  184.  
  185.         //使用正则表达式进行匹配
  186.         boolean matches = s.matches(badStr);
  187.         return matches;
  188.     }
  189.  
  190. }

        解析body数据 工具类

  1. import javax.servlet.ReadListener;
  2. import javax.servlet.ServletInputStream;
  3. import javax.servlet.http.HttpServletRequest;
  4. import javax.servlet.http.HttpServletRequestWrapper;
  5. import java.io.*;
  6.  
  7. /**
  8.  * @Author: ljh
  9.  * @ClassName BodyReaderRequestWrapper
  10.  * @Description 解析body数据
  11.  * @date 2023/8/8 16:14
  12.  * @Version 1.0
  13.  */
  14.  
  15. public class BodyReaderRequestWrapper extends HttpServletRequestWrapper {
  16.  
  17.     private final String body;
  18.  
  19.     public String getBody() {
  20.         return body;
  21.     }
  22.  
  23.     /**
  24.      * 取出请求体body中的参数（创建对象时执行）
  25.      *
  26.      * @param request
  27.      */
  28.     public BodyReaderRequestWrapper(HttpServletRequest request) throws IOException {
  29.         super(request);
  30.         StringBuilder sb = new StringBuilder();
  31.         InputStream ins = request.getInputStream();
  32.         BufferedReader isr = null;
  33.         try {
  34.             if (ins != null) {
  35.                 isr = new BufferedReader(new InputStreamReader(ins));
  36.                 char[] charBuffer = new char[128];
  37.                 int readCount;
  38.                 while ((readCount = isr.read(charBuffer)) != -1) {
  39.                     sb.append(charBuffer, 0, readCount);
  40.                 }
  41.             }
  42.         } finally {
  43.             if (isr != null) {
  44.                 isr.close();
  45.             }
  46.         }
  47.  
  48.         sb.toString();
  49.         body = sb.toString();
  50.     }
  51.  
  52.     @Override
  53.     public BufferedReader getReader() {
  54.         return new BufferedReader(new InputStreamReader(this.getInputStream()));
  55.     }
  56.  
  57.     @Override
  58.     public ServletInputStream getInputStream() {
  59.         final ByteArrayInputStream byteArrayIns = new ByteArrayInputStream(body.getBytes());
  60.         return new ServletInputStream() {
  61.  
  62.             @Override
  63.             public boolean isFinished() {
  64.                 return false;
  65.             }
  66.  
  67.             @Override
  68.             public boolean isReady() {
  69.                 return false;
  70.             }
  71.  
  72.             @Override
  73.             public void setReadListener(ReadListener readListener) {
  74.  
  75.             }
  76.  
  77.             @Override
  78.             public int read() {
  79.                 return byteArrayIns.read();
  80.             }
  81.  
  82.         };
  83.     }
  84. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/310724?site=
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号