给springboot增加XSS跨站脚本攻击防护功能

XSS原理

xss攻击的原理是利用前后端校验不严格，用户将攻击代码植入到数据中提交到了后台，当这些数据在网页上被其他用户查看的时候触发攻击

举例：用户提交表单时把地址写成：山东省济南市<script>for(var i=0;i<9999;i++){alert(i)}</script>

上面的数据如果没有在后台做处理，当数据被展示到网页上的时候，会在网页上弹出N个alert框，当然实际攻击肯定是比这个要复杂的多的

SpringBoot防护

给SpringBoot增加这种防护的原理是用户提交数据之后后台在获取数据内容时做一层过滤。过滤方式有两种

第一种

第一种方式是对特殊字符进行转义操作，例如将 < > /等特殊字符转换成html支持的 < >等，这样显示到页面的时候还是那些内容但是不会当成脚本执行了
这种方式我们用到了SpringFramework自带的HtmlUtils.htmlEscape方法进行替换

```org.springframework.web.util.HtmlUtils.htmlEscape```

第二种

第二种是直接把数据过滤一遍彻底去掉不安全的因素，包括隐藏在标签当中的 onXX=“js代码” 属性。
这一种方式用到了一个jar包 jsoup,Maven的依赖如下：

<dependency>
            <groupId>org.jsoup</groupId>
            <artifactId>jsoup</artifactId>
            <version>1.11.3</version>
        </dependency>           

无论以上那种方式都需要对参数进行过滤处理，具体处理方式如下：

1.添加jsoup包的依赖

2.增加一个Filter类

import com.aliyuncs.utils.StringUtils;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class XssFilter implements Filter {

    private List<String> excludes = new ArrayList<>();

    private boolean enabled = false;

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        String strExcludes = filterConfig.getInitParameter("excludes");
        String strEnabled = filterConfig.getInitParameter("enabled");
        //将不需要xss过滤的接口添加到列表中
        if(StringUtils.isNotEmpty(strExcludes)){
            String[] urls = strExcludes.split(",");
            for(String url:urls){
                excludes.add(url);
            }
        }
        if(StringUtils.isNotEmpty(strEnabled)){
            enabled = Boolean.valueOf(strEnabled);
        }
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) servletRequest;

        //如果该访问接口在排除列表里面则不拦截
        if(isExcludeUrl(request.getServletPath())){
            filterChain.doFilter(servletRequest,servletResponse);
            return;
        }
        //拦截该url并进行xss过滤
        XssHttpServletRequestWrapper xssHttpServletRequestWrapper = new XssHttpServletRequestWrapper(request);
        filterChain.doFilter(xssHttpServletRequestWrapper,servletResponse);

    }

    @Override
    public void destroy() {

    }

    private boolean isExcludeUrl(String urlPath){
        if(!enabled){
            //如果xss开关关闭了，则所有url都不拦截
            return true;
        }
        if(excludes==null||excludes.isEmpty()){
            return false;
        }

        String url = urlPath;
        for(String pattern:excludes){
            Pattern p = Pattern.compile("^"+pattern);
            Matcher m = p.matcher(url);
            if(m.find()){
                return true;
            }
        }
        return false;
    }
}

3.增加一个xssHttpServletRequestWrapper类,这个类重写了获取参数的方法，在获取参数时做了xss替换处理

import org.apache.commons.lang.StringUtils;
import org.jsoup.Jsoup;
import org.jsoup.safety.Whitelist;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;

/**
 * xss过滤包装类
 */
public class XssHttpServletRequestWrapper extends HttpServletRequestWrapper {
    private static final Logger logger = LoggerFactory.getLogger(XssHttpServletRequestWrapper.class);
    /**
     * Constructs a request object wrapping the given request.
     *
     * @param request The request to wrap
     * @throws IllegalArgumentException if the request is null
     */
    public XssHttpServletRequestWrapper(HttpServletRequest request) {
        super(request);
    }

    @Override
    public String getHeader(String name) {
        String strHeader = super.getHeader(name);
        if(StringUtils.isEmpty(strHeader)){
            return strHeader;

        }
        return Jsoup.clean(super.getHeader(name),Whitelist.relaxed());
    }

    @Override
    public String getParameter(String name) {
        String strParameter = super.getParameter(name);
        if(StringUtils.isEmpty(strParameter)){
            return strParameter;
        }
        return Jsoup.clean(super.getParameter(name),Whitelist.relaxed());
    }


    @Override
    public String[] getParameterValues(String name) {
        String[] values = super.getParameterValues(name);
        if(values==null){
            return values;
        }
        int length = values.length;
        String[] escapseValues = new String[length];
        for(int i = 0;i<length;i++){
            //过滤一切可能的xss攻击字符串
            escapseValues[i] = Jsoup.clean(values[i], Whitelist.relaxed()).trim();
            if(!StringUtils.equals(escapseValues[i],values[i])){
                logger.debug("xss字符串过滤前："+values[i]+"
"+"过滤后："+escapseValues[i]);
            }
        }
        return escapseValues;
    }
}

4.SpringBoot里面增加一个configuration配置，把Filter类配置上去

import cn.gov.zibo.scsupport.xss.XssFilter;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.servlet.DispatcherType;
import java.util.HashMap;
import java.util.Map;

/**
 * 设置跨站脚本过滤
 */
@Configuration
public class FilterConfig {
    @Value("${xss.enabled}")
    private String enabled;

    @Value("${xss.excludes}")
    private String excludes;

    @Value("${xss.urlPatterns}")
    private String urlPatterns;

    @Bean
    public FilterRegistrationBean xssFilterRegistration(){
        FilterRegistrationBean registrationBean = new FilterRegistrationBean();
        registrationBean.setDispatcherTypes(DispatcherType.REQUEST);
        registrationBean.setFilter(new XssFilter());
        registrationBean.addUrlPatterns(StringUtils.split(urlPatterns,","));
        registrationBean.setName("XssFilter");
        registrationBean.setOrder(9999);
        Map<String,String> initParameters = new HashMap<>();
        initParameters.put("excludes",excludes);
        initParameters.put("enabled",enabled);
        registrationBean.setInitParameters(initParameters);
        return registrationBean;
    }
}

5.最后在application.properties或者application.yml里面增加一些开关配置，可以忽略某些接口提交的数据或者关闭xss过滤

#xss攻击拦截
xss.enabled=true
xss.excludes=
xss.urlPatterns=/*

6.上面使用的是第二种处理方式，如果想使用第一种处理方式 只需要把XssHttpServletRequestWrapper类里面的Jsoup.clean方法替换成HtmlUtils.htmlEscape(xxx,"UTF-8")即可