SpringBoot关于抵御XSS攻击的解决方案_springboot 拦截器解决xss攻击

一、XSS攻击的危害

XSS攻击通常指的是通过利用网页开发时留下的漏洞，通过巧妙的方法注入恶意指令代码到网页，使用户加载并执行攻击者恶意制造的网页程序。这些恶意网页程序通常是JavaScript，但实际上也可以包括Java、 VBScript、ActiveX、 Flash 或者甚至是普通的HTML。攻击成功后，攻击者可能得到包括但不限于更高的权限（如执行一些操作）、私密网页内容、会话和cookie等各种内容。

例如用户在发帖或者注册的时候，在文本框中输入<script>alert('xss')</script>，这段代码如果不经过转义处理，而直接保存到数据库。将来视图层渲染HTML的时候，把这段代码输出到页面上，那么<script>标签的内容就会被执行。

通常情况下，我们登陆到某个网站。如果网站使用HttpSession保存登陆凭证，那么SessionId会以Cookie的形式保存在浏览器上。如果黑客在这个网页发帖的时候，填写的JavaScript代码是用来获取Cookie内容的，并且把Cookie内容通过Ajax发送给黑客自己的电脑。于是只要有人在这个网站上浏览黑客发的帖子，那么视图层渲染HTML页面，就会执行注入的XSS脚本，于是你的Cookie信息就泄露了。黑客在自己的电脑上构建出Cookie，就可以冒充已经登陆的用户。

即便很多网站使用了JWT，登陆凭证（Token令牌）是存储在浏览器上面的。所以用XSS脚本可以轻松的从Storage中提取出Token，黑客依然可以轻松的冒充已经登陆的用户。

所以避免XSS攻击最有效的办法就是对用户输入的数据进行转义，然后存储到数据库里面。等到视图层渲染HTML页面的时候。转义后的文字是不会被当做JavaScript执行的，这就可以抵御XSS攻击。

二、导入依赖库

因为Hutool工具包带有XSS转义的工具类，所以我们要导入Hutool，然后利用Servlet规范提供的请求包装类，定义数据转义功能。

<!--Hutool工具包 带有XSS转义的工具类 用于抵御XSS-->
<dependency>
	<groupId>cn.hutool</groupId>
	<artifactId>hutool-all</artifactId>
	<version>5.4.0</version>
</dependency>
1
2
3
4
5
6

三、定义请求包装类

我们平时写Web项目遇到的HttpServletRequest，它其实是个接口。如果我们想要重新定义请求类，扩展这个接口是最不应该的。因为HttpServletRequest接口中抽象方法太多了，我们逐一实现起来太耗费时间。所以我们应该挑选一个简单一点的自定义请求类的方式。那就是继承HttpServletRequestWrapper父类。

JavaEE只是一个标准，具体的实现由各家应用服务器厂商来完成。比如说Tomcat在实现Servlet规范的时候，就自定义了HttpServletRequest接口的实现类。同时JavaEE规范还定义了HttpServletRequestWrapper，这个类是请求类的包装类，用上了装饰器模式。不得不说这里用到的设计模式真的非常棒，无论各家应用服务器厂商怎么去实现HttpServletRequest接口，用户想要自定义请求，只需要继承HttpServletRequestWrapper，对应覆盖某个方法即可，然后把请求传入请求包装类，装饰器模式就会替代请求对象中对应的某个方法。用户的代码和服务器厂商的代码完全解耦，我们不用关心HttpServletRequest接口是怎么实现的，借助于包装类我们可以随意修改请求中的方法。同学们，如此优雅的代码设计，有时间你真该认真学习设计模式。

以下为增强Http请求方法

import cn.hutool.core.util.StrUtil;
import cn.hutool.http.HtmlUtil;
import cn.hutool.json.JSONUtil;

import javax.servlet.ReadListener;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.io.*;
import java.nio.charset.Charset;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Objects;

public class XssHttpServletRequestWrapper  extends HttpServletRequestWrapper {
    public XssHttpServletRequestWrapper(HttpServletRequest request) {
        super(request);
    }

    @Override
    public String getParameter(String name) {
        String value =  super.getParameter(name);
        if(!StrUtil.hasEmpty(value)){
            //进行转译
            value=HtmlUtil.filter(value);
        }
        return value;
    }

    @Override
    public String[] getParameterValues(String name) {
        String[]values =  super.getParameterValues(name);
        if(values!=null){
            //遍历数组
            for (int i = 0; i < values.length; i++) {
                String value = values[i];
                //判断是否有效
                if(!StrUtil.hasEmpty(value)){
                    //进行转译
                    value=HtmlUtil.filter(value);
                }
                //重新赋值
                values[i] = value;
            }
        }
        return values;
    }

    @Override
    public Map<String, String[]> getParameterMap() {
        Map<String, String[]>parameters = super.getParameterMap();
        //重新定义一个map
        LinkedHashMap<String, String[]> map = new LinkedHashMap<>();
        if(parameters!=null){
            //遍历map
            for (String key:parameters.keySet()) {
                String[]values = parameters.get(key);
                //遍历数组
                for (int i = 0; i < values.length; i++) {
                    String value = values[i];
                    //判断是否有效
                    if(!StrUtil.hasEmpty(value)){
                        //进行转译
                        value = HtmlUtil.filter(value);
                    }
                    //重新赋值
                    values[i] = value;
                }
                map.put(key,values);
            }
        }
        return map;
    }

    @Override
    public String getHeader(String name) {
        String value =  super.getHeader(name);
        if(!StrUtil.hasEmpty(value)){
            //进行转译
            value = HtmlUtil.filter(value);
        }
        return value;
    }

    @Override
    public ServletInputStream getInputStream() throws IOException {
        //读入数据
        InputStream in =  super.getInputStream();
        InputStreamReader reader = new InputStreamReader(in, Charset.forName("UTF-8"));
        //缓冲流
        BufferedReader buffer = new BufferedReader(reader);
        StringBuffer body = new StringBuffer();
        //读取缓冲流第一行数据
        String line = buffer.readLine();
        //读取每一行
        while(line!=null){
            body.append(line);
            line = buffer.readLine();
        }
        //关闭缓冲流
        buffer.close();
        reader.close();
        in.close();


        //将json转换为字符串
        Map<String, Object>map = JSONUtil.parseObj(body.toString());
        //对map对象进行转移转译
        Map<String,Object>result = new LinkedHashMap<>();
        for(String key:map.keySet()){
            Object val = map.get(key);
            //判断是否是字符串格式数据
            if (val instanceof String){
                //如果是 强制转换为字符串
                //判断是否是空字符串
                if (!StrUtil.hasEmpty(val.toString())){
                    result.put(key,HtmlUtil.filter(val.toString()));
                }
            }else {
                //如果不是 直接放如
                result.put(key,val);
            }
        }
        //转换回json字符串
        String json = JSONUtil.toJsonStr(result);
        ByteArrayInputStream bain = new ByteArrayInputStream(json.getBytes());
        return new ServletInputStream() {
            @Override
            public int read() throws IOException {
                return bain.read();
            }

            @Override
            public boolean isFinished() {
                return false;
            }

            @Override
            public boolean isReady() {
                return false;
            }

            @Override
            public void setReadListener(ReadListener readListener) {

            }
        };
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

四、创建过滤器，把所有请求对象传入包装类

为了让刚刚定义的包装类生效，我们还要在com.example.demo.config.xss中创建XssFilter过滤器。过滤器拦截所有请求，然后把请求传入包装类，这样包装类就能覆盖所有请求的参数方法，用户从请求中获得数据，全都经过转义。

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

//过滤器
@WebFilter(urlPatterns = "/*")
public class XssFilter implements Filter {
    @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;
        XssHttpServletRequestWrapper wrapper = new XssHttpServletRequestWrapper(request);
        filterChain.doFilter(wrapper,servletResponse);
    }

    @Override
    public void destroy() {
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

五、给主类添加注解

给SpringBoot主类添加@ServletComponentScan注解。

@SpringBootApplication
@ServletComponentScan
public class DemoApplication {

   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }

}
1
2
3
4
5
6
7
8
9

六、测试拦截XSS脚本

1. 编写测试controller

   @Data
   public class TestForm {
       public String name;
   }
   1
   2
   3
   4

   @PostMapping("/test")
   public R testPost(@Valid @RequestBody TestForm form){
       return R.ok().put(form.getName());
   }
   1
   2
   3
   4

2. 在Swagger中，执行testPost()方法，向name属性传入<script>HelloWorld</script>，然后观察返回的结果