request请求的body中的参数（json对象）只能取出一次，参数丢失问题的解决方式（防sql注入过滤器的应用）

雨点打透心脏的1/2处 2023-01-08 06:24 163阅读 0赞

在项目即将上线的渗透测试报告中检测出了sql注入的问题，关于这个问题的解决方案，最初的思路是写一个全局的过滤器，对所有请求的参数进行过滤拦截，如果存在和sql注入相关的特殊字符则拦截掉，具体细节展开以下讨论！

（当然要提供一个白名单，白名单里的请求不给予过滤）

###### 首先提供以下白名单code.properties ######

# 鉴权码
    # IDAM鉴权（多个以逗号分隔）
    authcode=32j42i3
    # 防sql注入请求白名单
    sqlverify=/ryjh/mappingGroup/updateInfo,\
      /author/Logon/loginConfigCheck,\
      /author/Logon/login,\
      /author/SAuUser/resetPwd,\
      /author/SAuUser/addUser,\
      /swagger-resources/configuration/ui,\
      /swagger-resources,\
      /doc.html

###### 第一版的过滤器如下 ######

/** * @author FanJiangFeng * @version 1.0.0 * @ClassName SqlFilter.java * @Description 防止Sql注入过滤器，校验参数 * @createTime 2021年01月05日 17:08:00 */
    @Component
    @WebFilter(value = "/")
    public class SqlFilter implements Filter { 
    
        //Sql注入配置文件白名单绝对路径
        @Value("${auth.authCodeUrl}")
        private String url;
    
    
        private boolean verify(String uri) throws IOException { 
            Properties properties=new Properties();
            InputStream inputStream=new FileInputStream(new File(url));
            properties.load(inputStream);
            Map<String,String> codeMap=(Map)properties;
            String whiteDoc=codeMap.get("sqlverify");
            String[] strings = whiteDoc.split(",");
            boolean over=false;
            for(String s:strings){ 
                if(s.equals(uri)){ 
                    over=true;
                    break;
                }
            }
            return over;
        }
    
        @Override
        public void init(FilterConfig filterConfig) throws ServletException { 
    
        }
    
        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException { 
            HttpServletRequest request=(HttpServletRequest)servletRequest;
            String contentType = request.getContentType();
            String requestURI = request.getRequestURI();
            boolean verify = verify(requestURI);
            if(verify){ 
                filterChain.doFilter(servletRequest,servletResponse);
                return;
            }   
                //application/x-www-form-urlencoded
                Map<String, String[]> parameterMap = request.getParameterMap();
                for(Map.Entry<String,String[]> entry:parameterMap.entrySet()){ 
    // String strings = entry.getKey();
                    //校验参数名是否合法
    // boolean isTrue = verifySql(strings);
    // if(!isTrue){ 
    // return;
    // }
                    //校验参数值是否合法
                    String[] value = entry.getValue();
                    for(String s:value){ 
                        //校验参数值是否合法
                        boolean b = verifySql(s);
                        if(!b){ 
                            return;
                        }
                    }
            }
            
                filterChain.doFilter(servletRequest,servletResponse);
            	return;
        }
    
        @Override
        public void destroy() { 
    
        }
    
        /** * 校验参数非法字符 */
        public boolean verifySql(String parameter){ 
            if(parameter.contains("'")){  //' 单引号
                return false;
            }else if(parameter.contains("\"")){  //" 双引号
                return false;
            }else if(parameter.contains("\\'")){ //' 反斜杠单引号
                return false;
            }else if(parameter.contains("\\\"")){ //" 反斜杠双引号
                return false;
            }else if(parameter.contains("(")||parameter.contains(")")||parameter.contains(";")){ //括号和分号
                return false;
            }else if(parameter.contains("--")||parameter.contains("+")){ //双减号 加号
                return false;
            }else if(parameter.toLowerCase().contains("select")||parameter.toLowerCase().contains("update")
            ||parameter.toLowerCase().contains("delete")||parameter.toLowerCase().contains("drop")
            ||parameter.toLowerCase().contains("updatexml")||parameter.toLowerCase().contains("concat")){ 
                return false;
            }
            return true;
    
        }
    }

第一个版本的不足：

它只能解析content-type为application/x-www-form-urlencoded的请求携带的参数

由Map<String, String\[\]> parameterMap = request.getParameterMap()的方式进行获取

但是它解析不了content-type类型为application/json格式的参数 ，上面那种方式已经获取不到了，所以要重新改版。

###### 我是如何跳坑的？ ######

刚开始我新加了一个方法，传入request对象，然后从request对象中拿到json字符串格式的参数，通过对字符串进行转换校验等处理，然后达到目的效果，但是我发现，处理之后，虽然过滤器放开了这个请求，当请求来到controller时，参数消失了？

这是因为，request请求中的body参数只可以拿出来一次，拿出来就没有了！

###### 解决方案 ######

> 需要一个类继承HttpServletRequestWrapper，该类继承了ServletRequestWrapper并实现了HttpServletRequest，
> 
> 因此它可作为request在FilterChain中传递。
> 
> 该类需要重写getReader和getInputStream两个方法，并在返回时将读出的body数据重新写入。

参考文章：https://my.oschina.net/u/4335633/blog/4252883

###### 新建BodyReaderRequestWrapper类 ######

public class BodyReaderRequestWrapper extends HttpServletRequestWrapper { 
        private final String body;
    
        public String getBody() { 
            return body;
        }
    
        /** * 取出请求体body中的参数（创建对象时执行） * @param request */
        public BodyReaderRequestWrapper(HttpServletRequest request) throws IOException { 
            super(request);
            StringBuilder sb = new StringBuilder();
            InputStream ins = request.getInputStream();
            BufferedReader isr = null;
            try{ 
                if(ins != null){ 
                    isr = new BufferedReader(new InputStreamReader(ins));
                    char[] charBuffer = new char[128];
                    int readCount = 0;
                    while((readCount = isr.read(charBuffer)) != -1){ 
                        sb.append(charBuffer,0,readCount);
                    }
                }else{ 
                    sb.append("");
                }
            }catch (IOException e){ 
                throw e;
            }finally { 
                if(isr != null) { 
                    isr.close();
                }
            }
    
            sb.toString();
            body = sb.toString();
        }
    
        @Override
        public BufferedReader getReader() throws IOException { 
            return new BufferedReader(new InputStreamReader(this.getInputStream()));
        }
    
        @Override
        public ServletInputStream getInputStream() throws IOException { 
            final ByteArrayInputStream byteArrayIns = new ByteArrayInputStream(body.getBytes());
            ServletInputStream servletIns = new ServletInputStream() { 
                @Override
                public boolean isFinished() { 
                    return false;
                }
                @Override
                public boolean isReady() { 
                    return false;
                }
                @Override
                public void setReadListener(ReadListener readListener) { 
    
                }
                @Override
                public int read() throws IOException { 
                    return byteArrayIns.read();
                }
            };
            return  servletIns;
        }
    }

###### filter过滤器更改 ######

在dofilter方法中创建BodyReaderRequestWrapper对象，并继续传递。

BodyReaderRequestWrapper wrapper=null;
            if("application/json".equals(contentType)){ 
                wrapper=new BodyReaderRequestWrapper(request);
                ......
                    
            if(wrapper==null){ 
                filterChain.doFilter(servletRequest,servletResponse);
            }else{ 
                filterChain.doFilter(wrapper,servletResponse);
            }

既然可以获取到json对象的字符串信息了，那么开始写对json的校验过程

###### 对json格式参数递归解析 ######

讨论：json格式的参数种类很多，比如

{ 
    "id":"test",
    "name":"test"
    }

[
        { 
            "id":"test",
            "name":"test"
    	}
        { 
            "id":"test",
            "name":"test"
    	}
    ]

{ 
    "id":"test",
    "name":[
                { 
                    "id":"test",
                    "name":"test"
                }
                { 
                    "id":"test",
                    "name":"test"
                }
    		]
    }

以及更多，所以这里采用递归解析的方式

###### 过滤器的最终版本 ######

@Component
    @WebFilter(value = "/")
    public class SqlFilter implements Filter { 
    
        //Sql注入配置文件白名单绝对路径
        @Value("${auth.authCodeUrl}")
        private String url;
    
    
        private boolean verify(String uri) throws IOException { 
            Properties properties=new Properties();
            InputStream inputStream=new FileInputStream(new File(url));
            properties.load(inputStream);
            Map<String,String> codeMap=(Map)properties;
            String whiteDoc=codeMap.get("sqlverify");
            String[] strings = whiteDoc.split(",");
            boolean over=false;
            for(String s:strings){ 
                if(s.equals(uri)){ 
                    over=true;
                    break;
                }
            }
            return over;
        }
    
        @Override
        public void init(FilterConfig filterConfig) throws ServletException { 
    
        }
    
        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException { 
            HttpServletRequest request=(HttpServletRequest)servletRequest;
            String contentType = request.getContentType();
            String requestURI = request.getRequestURI();
            boolean verify = verify(requestURI);
            if(verify){ 
                filterChain.doFilter(servletRequest,servletResponse);
                return;
            }
            BodyReaderRequestWrapper wrapper=null;
            if("application/json".equals(contentType)){ 
                wrapper=new BodyReaderRequestWrapper(request);
                String requestPostStr = wrapper.getBody();
                if (requestPostStr.startsWith("{")) { 
                    //解析json对象
                    boolean b = resolveJSONObjectObj(requestPostStr);
                    if(!b)return;
    
                }else if (requestPostStr.startsWith("[")) { 
                    //把数据转换成json数组
                    JSONArray jsonArray = JSONArray.parseArray(requestPostStr);
                    jsonArray.forEach(json -> { 
                        //解析json对象
                        boolean b = resolveJSONObjectObj(json.toString());
                        if(!b)return;
                    });
                }
    
            }else{ 
                //application/x-www-form-urlencoded
                Map<String, String[]> parameterMap = request.getParameterMap();
                for(Map.Entry<String,String[]> entry:parameterMap.entrySet()){ 
    // String strings = entry.getKey();
                    //校验参数名是否合法
    // boolean isTrue = verifySql(strings);
    // if(!isTrue){ 
    // return;
    // }
                    //校验参数值是否合法
                    String[] value = entry.getValue();
                    for(String s:value){ 
                        //校验参数值是否合法
                        boolean b = verifySql(s);
                        if(!b){ 
                            return;
                        }
                    }
                }
            }
            if(wrapper==null){ 
                filterChain.doFilter(servletRequest,servletResponse);
            }else{ 
                filterChain.doFilter(wrapper,servletResponse);
    
            }
            return;
        }
    
        /** * 对JSONObject对象进行递归参数解析 * * @param requestPostStr * @return */
        private boolean resolveJSONObjectObj(String requestPostStr) { 
            boolean isover=true;
            // 创建需要处理的json对象
            JSONObject jsonObject = JSONObject.parseObject(requestPostStr);
            // 获取所有的参数key
            Set<String> keys = jsonObject.keySet();
            if (keys.size() > 0) { 
                for (String key : keys) { 
                    //获取参数名称
                    String value = null;
                    if (jsonObject.get(key) != null) { 
                        value = String.valueOf(jsonObject.get(key));
                        //当value为数组时
                        if(value.startsWith("[")){ 
                            //把数据转换成json数组
                            JSONArray jsonArray = JSONArray.parseArray(value);
                            for(int i=0;i<jsonArray.size();i++){ 
                                //解析json对象
                                boolean b = resolveJSONObjectObj(jsonArray.get(i).toString());
                                if(!b){ 
                                    isover=false;
                                    break;
                                }
                            }
                        }else if(value.startsWith("{")){ 
                            boolean b = resolveJSONObjectObj(value);
                            if(!b){ 
                                isover=false;
                                break;
                            }
                        }else{ 
                            //校验参数值是否合法
                            boolean b = verifySql(value);
                            if(!b){ 
                                isover=false;
                                break;
                            }
                        }
                    }
                }
            }
            return isover;
        }
    
    
        @Override
        public void destroy() { 
    
        }
    
        /** * 校验参数非法字符 */
        public boolean verifySql(String parameter){ 
            if(parameter.contains("'")){  //' 单引号
                return false;
            }else if(parameter.contains("\"")){  //" 双引号
                return false;
            }else if(parameter.contains("\\'")){ //' 反斜杠单引号
                return false;
            }else if(parameter.contains("\\\"")){ //" 反斜杠双引号
                return false;
            }else if(parameter.contains("(")||parameter.contains(")")||parameter.contains(";")){ //括号和分号
                return false;
            }else if(parameter.contains("--")||parameter.contains("+")){ //双减号 加号
                return false;
            }else if(parameter.toLowerCase().contains("select")||parameter.toLowerCase().contains("update")
            ||parameter.toLowerCase().contains("delete")||parameter.toLowerCase().contains("drop")
            ||parameter.toLowerCase().contains("updatexml")||parameter.toLowerCase().contains("concat")){ 
                return false;
            }
            return true;
    
        }
    }

这样，什么格式的json参数都会解析到！如果有任何问题可以联系本人，可以共同探讨！