【SpringBoot】利用过滤器举行XSS防御

在Spring Boot中，我们可以利用注解的方式来举行XSS防御。注解是一种轻量级的防御本领，它可以在方法或字段级别对输入举行校验，从而防止XSS攻击。
而想对全局的哀求都举行XSS防御可以利用servlet中的过滤器大概spring mvc中的拦截器，这里利用servlet中的过滤器举行演示。
引入干系依靠

maven依靠：

1. <!--JSR-303/JSR-380用于验证的注解 -->
2. <dependency>
3.     <groupId>org.springframework.boot</groupId>
4.     <artifactId>spring-boot-starter-validation</artifactId>
5.     <version>2.6.7</version>
6. </dependency>

复制代码

假如是利用grade，引入依靠：

1. implementation 'org.springframework.boot:spring-boot-starter-validation:2.6.7'

复制代码

修改设置文件

1. xss:
2.   enabled: true
3.   excludeUrlList:
4.     - /xss/local/test

复制代码

界说设置文件对应的属性类

1. package com.morris.spring.boot.module.xss;
3. import lombok.Data;
5. import java.util.List;
7. @Data
8. public class XssFilterProperties {
9.     /**
10.      * 是否启用XSS过滤。
11.      */
12.     private boolean enabled = true;
14.     /**
15.      * 需要排除的URL模式，这些URL不会进行XSS过滤。
16.      */
17.     private List<String> excludeUrlList;
18. }

复制代码

注入XSS设置类

1. package com.morris.spring.boot.module.xss;
3. import lombok.Data;
4. import org.springframework.boot.autoconfigure.http.HttpMessageConverters;
5. import org.springframework.boot.context.properties.ConfigurationProperties;
6. import org.springframework.boot.web.servlet.FilterRegistrationBean;
7. import org.springframework.context.annotation.Bean;
8. import org.springframework.context.annotation.Configuration;
9. import org.springframework.http.converter.HttpMessageConverter;
11. import javax.servlet.DispatcherType;
13. @Data
14. @Configuration
15. public class XssFilterConfig {
17.     @ConfigurationProperties(prefix = "xss")
18.     @Bean
19.     public XssFilterProperties xssFilterProperties() {
20.         return new XssFilterProperties();
21.     }
23.     /**
24.      * 注册XSS过滤器。
25.      *
26.      * @return FilterRegistrationBean 用于注册过滤器的bean。
27.      */
28.     @Bean
29.     public FilterRegistrationBean<XssFilter> xssFilterRegistration(XssFilterProperties xssFilterProperties) {
30.         FilterRegistrationBean<XssFilter> registrationBean = new FilterRegistrationBean<>();
31.         // 设置过滤器的分发类型为请求类型
32.         registrationBean.setDispatcherTypes(DispatcherType.REQUEST);
33.         // 创建XssFilter的实例
34.         registrationBean.setFilter(new XssFilter(xssFilterProperties));
35.         // 添加过滤器需要拦截的URL模式，这里拦截所有请求
36.         registrationBean.addUrlPatterns("/*");
37.         // 设置过滤器的名称
38.         registrationBean.setName("XssFilter");
39.         // 设置过滤器的执行顺序，数值越小，优先级越高
40.         registrationBean.setOrder(9999);
41.         return registrationBean;
42.     }
44.     @Bean
45.     public HttpMessageConverters xssHttpMessageConverters() {
46.         XSSMappingJackson2HttpMessageConverter xssMappingJackson2HttpMessageConverter = new XSSMappingJackson2HttpMessageConverter();
47.         HttpMessageConverter converter = xssMappingJackson2HttpMessageConverter;
48.         return new HttpMessageConverters(converter);
49.     }
51. }

复制代码

XssFilter过滤器

XssFilter过滤器会将全部须要举行防御的哀求包装为XssWrapper。

1. package com.morris.spring.boot.module.xss;
3. import lombok.extern.slf4j.Slf4j;
4. import org.springframework.util.CollectionUtils;
6. import javax.servlet.*;
7. import javax.servlet.http.HttpServletRequest;
8. import javax.servlet.http.HttpServletResponse;
9. import java.io.IOException;
10. import java.util.regex.Matcher;
11. import java.util.regex.Pattern;
13. @Slf4j
14. public class XssFilter implements Filter {
16.     private final XssFilterProperties xssFilterProperties;
18.     public XssFilter(XssFilterProperties xssFilterProperties) {
19.         this.xssFilterProperties = xssFilterProperties;
20.     }
22.     /**
23.      * 执行过滤逻辑，如果当前请求不在排除列表中，则通过XSS过滤器包装请求。
24.      *
25.      * @param request  HTTP请求对象。
26.      * @param response HTTP响应对象。
27.      * @param chain    过滤器链对象，用于继续或中断请求处理。
28.      * @throws IOException      如果处理过程中出现I/O错误。
29.      * @throws ServletException 如果处理过程中出现Servlet相关错误。
30.      */
31.     @Override
32.     public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
33.         HttpServletRequest req = (HttpServletRequest) request;
34.         HttpServletResponse resp = (HttpServletResponse) response;
35.         //如果该访问接口在排除列表里面则不拦截
36.         if (isExcludeUrl(req.getServletPath())) {
37.             chain.doFilter(request, response);
38.             return;
39.         }
41.         log.info("uri:{}", req.getRequestURI());
42.         // xss 过滤
43.         chain.doFilter(new XssWrapper(req), resp);
44.     }
46.     /**
47.      * 判断当前请求的URL是否应该被排除在XSS过滤之外。
48.      *
49.      * @param urlPath 请求的URL路径。
50.      * @return 如果请求应该被排除，则返回true；否则返回false。
51.      */
52.     private boolean isExcludeUrl(String urlPath) {
53.         if (!xssFilterProperties.isEnabled()) {
54.             //如果xss开关关闭了，则所有url都不拦截
55.             return true;
56.         }
58.         if(CollectionUtils.isEmpty(xssFilterProperties.getExcludeUrlList())) {
59.             return false;
60.         }
62.         for (String pattern : xssFilterProperties.getExcludeUrlList()) {
63.             Pattern p = Pattern.compile("^" + pattern);
64.             Matcher m = p.matcher(urlPath);
65.             if (m.find()) {
66.                 return true;
67.             }
68.         }
69.         return false;
70.     }
71. }

复制代码

XssWrapper过滤get哀求和哀求头

XssWrapper会过滤get哀求和哀求头中的非法字符。

1. package com.morris.spring.boot.module.xss;
3. import lombok.extern.slf4j.Slf4j;
4. import org.apache.commons.lang3.StringUtils;
6. import javax.servlet.http.HttpServletRequest;
7. import javax.servlet.http.HttpServletRequestWrapper;
9. @Slf4j
10. public class XssWrapper extends HttpServletRequestWrapper {
12.     public XssWrapper(HttpServletRequest request) {
13.         super(request);
14.     }
16.     /**
17.      * 对数组参数进行特殊字符过滤
18.      */
19.     @Override
20.     public String[] getParameterValues(String name) {
21.         String[] values = super.getParameterValues(name);
22.         if (values == null) {
23.             return null;
24.         }
25.         int count = values.length;
26.         String[] encodedValues = new String[count];
27.         for (int i = 0; i < count; i++) {
28.             encodedValues[i] = XssUtil.clean(values[i]);
29.         }
30.         return encodedValues;
31.     }
33.     /**
34.      * 对参数中特殊字符进行过滤
35.      */
36.     @Override
37.     public String getParameter(String name) {
38.         String value = super.getParameter(name);
39.         if (StringUtils.isBlank(value)) {
40.             return value;
41.         }
42.         return XssUtil.clean(value);
43.     }
45.     /**
46.      * 获取attribute,特殊字符过滤
47.      */
48.     @Override
49.     public Object getAttribute(String name) {
50.         Object value = super.getAttribute(name);
51.         if (value instanceof String && StringUtils.isNotBlank((String) value)) {
52.             return XssUtil.clean((String) value);
53.         }
54.         return value;
55.     }
57.     /**
58.      * 对请求头部进行特殊字符过滤
59.      */
60.     @Override
61.     public String getHeader(String name) {
62.         String value = super.getHeader(name);
63.         if (StringUtils.isBlank(value)) {
64.             return value;
65.         }
66.         return XssUtil.clean(value);
67.     }
68. }

复制代码

MessageConverter过滤post哀求

1. package com.morris.spring.boot.module.xss;
3. import com.fasterxml.jackson.databind.JavaType;
4. import org.springframework.http.HttpInputMessage;
5. import org.springframework.http.HttpOutputMessage;
6. import org.springframework.http.converter.HttpMessageNotReadableException;
7. import org.springframework.http.converter.HttpMessageNotWritableException;
8. import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
10. import java.io.IOException;
11. import java.lang.reflect.Type;
13. /**
14. * 在读取和写入JSON数据时特殊字符避免xss攻击的消息解析器
15. *
16. */
17. public class XSSMappingJackson2HttpMessageConverter extends MappingJackson2HttpMessageConverter {
19.     /**
20.      * 从HTTP输入消息中读取对象，同时应用XSS防护。
21.      *
22.      * @param type        类型令牌，表示要读取的对象类型。
23.      * @param contextClass    上下文类，提供类型解析的上下文信息。
24.      * @param inputMessage HTTP输入消息，包含要读取的JSON数据。
25.      * @return 从输入消息中解析出的对象，经过XSS防护处理。
26.      * @throws IOException 如果发生I/O错误。
27.      * @throws HttpMessageNotReadableException 如果消息无法读取。
28.      */
29.     @Override
30.     public Object read(Type type, Class contextClass,
31.                        HttpInputMessage inputMessage) throws IOException,
32.             HttpMessageNotReadableException {
33.         JavaType javaType = getJavaType(type, contextClass);
34.         Object obj = readJavaType(javaType, inputMessage);
35.         //得到请求json
36.         String json = super.getObjectMapper().writeValueAsString(obj);
37.         //过滤特殊字符
38.         String result = XssUtil.clean(json);
39.         Object resultObj = super.getObjectMapper().readValue(result, javaType);
40.         return resultObj;
41.     }
43.     /**
44.      * 从HTTP输入消息中读取指定Java类型的对象，内部使用。
45.      *
46.      * @param javaType    要读取的对象的Java类型。
47.      * @param inputMessage HTTP输入消息，包含要读取的JSON数据。
48.      * @return 从输入消息中解析出的对象。
49.      * @throws IOException 如果发生I/O错误。
50.      * @throws HttpMessageNotReadableException 如果消息无法读取。
51.      */
52.     private Object readJavaType(JavaType javaType, HttpInputMessage inputMessage) {
53.         try {
54.             return super.getObjectMapper().readValue(inputMessage.getBody(), javaType);
55.         } catch (IOException ex) {
56.             throw new HttpMessageNotReadableException("Could not read JSON: " + ex.getMessage(), ex);
57.         }
58.     }
60.     /**
61.      * 将对象写入HTTP输出消息，同时应用XSS防护。
62.      *
63.      * @param object 要写入的对象。
64.      * @param outputMessage HTTP输出消息，对象将被序列化为JSON并写入此消息。
65.      * @throws IOException 如果发生I/O错误。
66.      * @throws HttpMessageNotWritableException 如果消息无法写入。
67.      */
68.     @Override
69.     protected void writeInternal(Object object, HttpOutputMessage outputMessage)
70.             throws IOException, HttpMessageNotWritableException {
71.         //得到要输出的json
72.         String json = super.getObjectMapper().writeValueAsString(object);
73.         //过滤特殊字符
74.         String result = XssUtil.clean(json);
75.         // 输出
76.         outputMessage.getBody().write(result.getBytes());
77.     }
78. }

复制代码

Xss过滤工具类

1. package com.morris.spring.boot.module.xss;
3. import org.jsoup.Jsoup;
4. import org.jsoup.nodes.Document;
5. import org.jsoup.safety.Whitelist;
7. /**
8. * XSS过滤工具类，使用Jsoup库对输入的字符串进行XSS攻击防护
9. */
10. public class XssUtil {
12.     /**
13.      * 使用jsoup自带的relaxed白名单
14.      */
15.     private static final Whitelist WHITE_LIST = Whitelist.relaxed();
16.     /**
17.      * 定义输出设置，关闭prettyPrint（prettyPrint=false），目的是避免在清理过程中对代码进行格式化
18.      * 从而保持输入和输出内容的一致性。
19.      */
20.     private static final Document.OutputSettings OUTPUT_SETTINGS = new Document.OutputSettings().prettyPrint(false);
22.     /*
23.       初始化白名单策略，允许所有标签拥有style属性。
24.       这是因为在富文本编辑中，样式通常通过style属性来定义，需要确保这些样式能够被保留。
25.      */
26.     static {
27.         // 富文本编辑时一些样式是使用 style 来进行实现的
28.         // 比如红色字体 style="color:red;"
29.         // 所以需要给所有标签添加 style 属性
30.         WHITE_LIST.addAttributes(":all", "style");
31.     }
33.     /**
34.      * 清理输入的字符串，移除潜在的XSS攻击代码。
35.      *
36.      * @param content 待清理的字符串，通常是用户输入的HTML内容。
37.      * @return 清理后的字符串，保证不包含XSS攻击代码。
38.      */
39.     public static String clean(String content) {
40.         // 使用定义好的白名单策略和输出设置清理输入的字符串
41.         return Jsoup.clean(content, "", WHITE_LIST, OUTPUT_SETTINGS);
42.     }
43. }

复制代码

get哀求测试

1. package com.morris.spring.boot.module.xss;
3. import org.springframework.validation.annotation.Validated;
4. import org.springframework.web.bind.annotation.GetMapping;
5. import org.springframework.web.bind.annotation.RequestMapping;
6. import org.springframework.web.bind.annotation.RestController;
8. /**
9. * Xss2防御get请求
10. */
11. @RestController
12. @RequestMapping("/xss/global")
13. @Validated
14. public class XssGlobalGetController {
16.     /**
17.      * 使用注解拦截get请求中的xss，在方法参数前面加上@Xss，注意类上面要加上@Validated注解
18.      *
19.      * @param userAccount 请求参数
20.      * @return 请求参数
21.      */
22.     @GetMapping("/test")
23.     public String test(String userAccount) {
24.         return userAccount;
25.     }
27. }

复制代码

发送get哀求：http://localhost:8888/xss/global/test?userAccount=demoData
返回结果：demoData
post哀求测试

1. package com.morris.spring.boot.module.xss;
3. import org.springframework.web.bind.annotation.PostMapping;
4. import org.springframework.web.bind.annotation.RequestBody;
5. import org.springframework.web.bind.annotation.RequestMapping;
6. import org.springframework.web.bind.annotation.RestController;
8. /**
9. * Xss全局防御post请求
10. */
11. @RestController
12. @RequestMapping("/xss/global")
13. public class XssGlobalPostController {
15.     /**
16.      * 使用注解拦截POST请求中的xss，在实体类需要拦截xss的属性上面加上@Xss或者@Validated注解
17.      *
18.      * @param userGlobalLoginPojo 实体类
19.      * @return 实体类
20.      */
21.     @PostMapping("/test")
22.     public UserGlobalLoginPojo test(@RequestBody UserGlobalLoginPojo userGlobalLoginPojo) {
23.         return userGlobalLoginPojo;
24.     }
26. }

复制代码

发送post哀求：http://localhost:8888/xss/global/test
哀求体：

1. {
2.     "userAccount": "<iframe οnlοad='alert(0)'>demoData</iframe>"
3. }

复制代码

返回结果：

1. {
2.     "userAccount": "demoData"
3. }

复制代码