关于XSS过滤

XSS攻击绕过过滤方法大全（约100种）

XSS攻击绕过过滤方法大全（约100种） - 付杰博客

解决办法：

1.增加前端过滤

可参考：https://www.cnblogs.com/caizhenbo/p/6836390.html  【前端安全】JavaScript防XSS攻击

xss前端过滤工具：https://cdn.bootcdn.net/ajax/libs/js-xss/0.3.3/xss.min.js

使用方法：前端防止xss攻击- xss.js使用 - 凡凡0410 - 博客园

2.在后台新增过滤器，对用户请求进行过滤

SpringMVC中发起的Controller层Request请求对象一般为以下几种类型：

1.基本数据类型，2.POJO类型，3.数组类型，4.集合类型

参考网址：SpringMvc的参数请求类型_没有故事的胡南北的博客-CSDN博客

而代码层请求的类型，一个是不带注解的，再就是@RequestBody类型，因此需要对以下两种请求类型进行过滤

1.application/x-www-form-urlencoded（普通的数据类型请，POJO类型，简单数组或集合类型）

2.application/json （RequestBody类型）

3.其他类型如：mutipart/form-data application/xml

非RequestBody过滤器：

可参考：XSS过滤JAVA过滤器filter 防止常见SQL注入 - 现世安稳。 - 博客园

XSS过滤JAVA过滤器filter 防止常见SQL注入

RequestBody过滤器：

可参考：https://blog.csdn.net/Answer0902/article/details/118546226

SpringBoot+Xss过滤（@RequestBody参数过滤Xss）

基于以上情况，可以将两者结合起来，代码如下：

public class RequestStringProcessor extends HttpServletRequestWrapper {
    
    private static final Log log=LogFactory.getLog(RequestStringProcessor.class);
    
    private byte[] requestBody;
    private Charset charSet;
    
    private static final String REQUEST_BODY_TYPE = "application/json";
    /**
     * 前台请求类型分三种
     * 1.application/x-www-form-urlencoded; charset=UTF-8 String类型
     * 2.application/json;charset=UTF-8 RequestBody类型
     * 3.其他如：mutipart/form-data，application/json,application/xml
     * mutipart/form-data 类型 RequestBody无法处理，只能处理application/json,application/xml
     * @param request
     */
    public RequestStringProcessor(HttpServletRequest request) {
        super(request);
        //缓存请求body
        getRequestBody(request);
    }

    /**
     * 过滤RequestBody内容
     * @param request
     */
    private void getRequestBody(HttpServletRequest request) {
        String contentType=request.getContentType();
        if(contentType==null||contentType.indexOf(REQUEST_BODY_TYPE)<0) {
            //请求的contentType为空或不是json格式
            return;
        }
        String charSetName = request.getCharacterEncoding();
        if (charSetName == null) {
            charSetName = "UTF-8";
        }
        charSet = Charset.forName(charSetName);
        try {
            //获取前台传输的RequestBody字符串内容
            String bodyContent = StreamUtils.copyToString(request.getInputStream(), charSet);
            bodyContent=StringUtil.getFilterString(bodyContent);
            boolean isJson=cn.hutool.json.JSONUtil.isJson(bodyContent);
            if(isJson) {
                if(JSONUtil.isJsonArray(bodyContent)) {
                    JSONArray resultJson=JSONObject.parseArray(bodyContent);
                    requestBody = resultJson.toString().getBytes(charSet);
                }else {
                    JSONObject resultJson = JSONObject.parseObject(bodyContent);
                    requestBody = resultJson.toString().getBytes(charSet);
                }
            }else {
                requestBody = new byte[0];
            }
        } catch (Exception e) {
            log.error("RequestBody请求获取失败...",e);
        }
    }
 
    @Override
    public String getParameter(String name) {
        // 返回值之前 先进行过滤
        return StringUtil.getFilterString(super.getParameter(name));
    }
 
    @Override
    public String[] getParameterValues(String name) {
        // 返回值之前 先进行过滤
        String[] values = super.getParameterValues(name);
        if(values==null){
            return null;
        }
        for (int i = 0; i < values.length; i++) {
            values[i] = StringUtil.getFilterString(values[i]);
        }
        return values;
    }
 
    @Override
    public Map<String, String[]> getParameterMap() {
        Map<String, String[]> paramMap = super.getParameterMap();
        Set<Entry<String, String[]>> set = paramMap.entrySet();
        Iterator<Entry<String, String[]>> iters = set.iterator();
        while (iters.hasNext()) {
            Entry<String, String[]> key = iters.next();
            String[] value = paramMap.get(key.getKey());
            paramMap.put(key.getKey(), StringUtil.getFilterString(value));
        }
        return paramMap;
    }

    /**
     * 获取前台输入的请求参数文件流
     * RequestBody以Stream方式进行传输
     */
    public ServletInputStream getInputStream() {
        if (requestBody == null) {
            requestBody = new byte[0];
        }

        final ByteArrayInputStream requestStream = new ByteArrayInputStream(requestBody);

        return new ServletInputStream() {
            @Override
            public boolean isFinished() {
                return false;
            }
            @Override
            public boolean isReady() {
                return false;
            }
            @Override
            public void setReadListener(ReadListener readListener) {
            }
            @Override
            public int read() {
                return requestStream.read();
            }
        };
    }

}

Filter代码

@WebFilter(filterName="requestStringFilter",urlPatterns="/*")
public class RequestStringFilter extends OncePerRequestFilter  {

    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) 
            throws ServletException, IOException {
        chain.doFilter(new RequestStringProcessor((HttpServletRequest)request), response);
    }
}

还有其他的类似解决办法可参考：

【Springboot】@RequestBody参数过滤Xss_for_bf的博客-CSDN博客