SpringBoot如何使用过滤器进行XSS防御

<!--jsr-303/jsr-380用于验证的注解 -->
<dependency>
    <groupid>org.springframework.boot</groupid>
    <artifactid>spring-boot-starter-validation</artifactid>
    <version>2.6.7</version>
</dependency>

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

xss:
  enabled: true
  excludeurllist:
    - /xss/local/test

package com.morris.spring.boot.module.xss;

import lombok.data;

import java.util.list;

@data
public class xssfilterproperties {
    /**
     * 是否启用xss过滤。
     */
    private boolean enabled = true;

    /**
     * 需要排除的url模式，这些url不会进行xss过滤。
     */
    private list<string> excludeurllist;
}

package com.morris.spring.boot.module.xss;

import lombok.data;
import org.springframework.boot.autoconfigure.http.httpmessageconverters;
import org.springframework.boot.context.properties.configurationproperties;
import org.springframework.boot.web.servlet.filterregistrationbean;
import org.springframework.context.annotation.bean;
import org.springframework.context.annotation.configuration;
import org.springframework.http.converter.httpmessageconverter;

import javax.servlet.dispatchertype;

@data
@configuration
public class xssfilterconfig {

    @configurationproperties(prefix = "xss")
    @bean
    public xssfilterproperties xssfilterproperties() {
        return new xssfilterproperties();
    }

    /**
     * 注册xss过滤器。
     *
     * @return filterregistrationbean 用于注册过滤器的bean。
     */
    @bean
    public filterregistrationbean<xssfilter> xssfilterregistration(xssfilterproperties xssfilterproperties) {
        filterregistrationbean<xssfilter> registrationbean = new filterregistrationbean<>();
        // 设置过滤器的分发类型为请求类型
        registrationbean.setdispatchertypes(dispatchertype.request);
        // 创建xssfilter的实例
        registrationbean.setfilter(new xssfilter(xssfilterproperties));
        // 添加过滤器需要拦截的url模式，这里拦截所有请求
        registrationbean.addurlpatterns("/*");
        // 设置过滤器的名称
        registrationbean.setname("xssfilter");
        // 设置过滤器的执行顺序，数值越小，优先级越高
        registrationbean.setorder(9999);
        return registrationbean;
    }

    @bean
    public httpmessageconverters xsshttpmessageconverters() {
        xssmappingjackson2httpmessageconverter xssmappingjackson2httpmessageconverter = new xssmappingjackson2httpmessageconverter();
        httpmessageconverter converter = xssmappingjackson2httpmessageconverter;
        return new httpmessageconverters(converter);
    }

}

package com.morris.spring.boot.module.xss;

import lombok.extern.slf4j.slf4j;
import org.springframework.util.collectionutils;

import javax.servlet.*;
import javax.servlet.http.httpservletrequest;
import javax.servlet.http.httpservletresponse;
import java.io.ioexception;
import java.util.regex.matcher;
import java.util.regex.pattern;

@slf4j
public class xssfilter implements filter {

    private final xssfilterproperties xssfilterproperties;

    public xssfilter(xssfilterproperties xssfilterproperties) {
        this.xssfilterproperties = xssfilterproperties;
    }

    /**
     * 执行过滤逻辑，如果当前请求不在排除列表中，则通过xss过滤器包装请求。
     *
     * @param request  http请求对象。
     * @param response http响应对象。
     * @param chain    过滤器链对象，用于继续或中断请求处理。
     * @throws ioexception      如果处理过程中出现i/o错误。
     * @throws servletexception 如果处理过程中出现servlet相关错误。
     */
    @override
    public void dofilter(servletrequest request, servletresponse response, filterchain chain) throws ioexception, servletexception {
        httpservletrequest req = (httpservletrequest) request;
        httpservletresponse resp = (httpservletresponse) response;
        //如果该访问接口在排除列表里面则不拦截
        if (isexcludeurl(req.getservletpath())) {
            chain.dofilter(request, response);
            return;
        }

        log.info("uri:{}", req.getrequesturi());
        // xss 过滤
        chain.dofilter(new xsswrapper(req), resp);
    }

    /**
     * 判断当前请求的url是否应该被排除在xss过滤之外。
     *
     * @param urlpath 请求的url路径。
     * @return 如果请求应该被排除，则返回true；否则返回false。
     */
    private boolean isexcludeurl(string urlpath) {
        if (!xssfilterproperties.isenabled()) {
            //如果xss开关关闭了，则所有url都不拦截
            return true;
        }

        if(collectionutils.isempty(xssfilterproperties.getexcludeurllist())) {
            return false;
        }

        for (string pattern : xssfilterproperties.getexcludeurllist()) {
            pattern p = pattern.compile("^" + pattern);
            matcher m = p.matcher(urlpath);
            if (m.find()) {
                return true;
            }
        }
        return false;
    }
}

package com.morris.spring.boot.module.xss;

import lombok.extern.slf4j.slf4j;
import org.apache.commons.lang3.stringutils;

import javax.servlet.http.httpservletrequest;
import javax.servlet.http.httpservletrequestwrapper;

@slf4j
public class xsswrapper extends httpservletrequestwrapper {

    public xsswrapper(httpservletrequest request) {
        super(request);
    }

    /**
     * 对数组参数进行特殊字符过滤
     */
    @override
    public string[] getparametervalues(string name) {
        string[] values = super.getparametervalues(name);
        if (values == null) {
            return null;
        }
        int count = values.length;
        string[] encodedvalues = new string[count];
        for (int i = 0; i < count; i++) {
            encodedvalues[i] = xssutil.clean(values[i]);
        }
        return encodedvalues;
    }

    /**
     * 对参数中特殊字符进行过滤
     */
    @override
    public string getparameter(string name) {
        string value = super.getparameter(name);
        if (stringutils.isblank(value)) {
            return value;
        }
        return xssutil.clean(value);
    }

    /**
     * 获取attribute,特殊字符过滤
     */
    @override
    public object getattribute(string name) {
        object value = super.getattribute(name);
        if (value instanceof string && stringutils.isnotblank((string) value)) {
            return xssutil.clean((string) value);
        }
        return value;
    }

    /**
     * 对请求头部进行特殊字符过滤
     */
    @override
    public string getheader(string name) {
        string value = super.getheader(name);
        if (stringutils.isblank(value)) {
            return value;
        }
        return xssutil.clean(value);
    }
}

package com.morris.spring.boot.module.xss;

import com.fasterxml.jackson.databind.javatype;
import org.springframework.http.httpinputmessage;
import org.springframework.http.httpoutputmessage;
import org.springframework.http.converter.httpmessagenotreadableexception;
import org.springframework.http.converter.httpmessagenotwritableexception;
import org.springframework.http.converter.json.mappingjackson2httpmessageconverter;

import java.io.ioexception;
import java.lang.reflect.type;

/**
 * 在读取和写入json数据时特殊字符避免xss攻击的消息解析器
 *
 */
public class xssmappingjackson2httpmessageconverter extends mappingjackson2httpmessageconverter {

    /**
     * 从http输入消息中读取对象，同时应用xss防护。
     * 
     * @param type        类型令牌，表示要读取的对象类型。
     * @param contextclass    上下文类，提供类型解析的上下文信息。
     * @param inputmessage http输入消息，包含要读取的json数据。
     * @return 从输入消息中解析出的对象，经过xss防护处理。
     * @throws ioexception 如果发生i/o错误。
     * @throws httpmessagenotreadableexception 如果消息无法读取。
     */
    @override
    public object read(type type, class contextclass,
                       httpinputmessage inputmessage) throws ioexception,
            httpmessagenotreadableexception {
        javatype javatype = getjavatype(type, contextclass);
        object obj = readjavatype(javatype, inputmessage);
        //得到请求json
        string json = super.getobjectmapper().writevalueasstring(obj);
        //过滤特殊字符
        string result = xssutil.clean(json);
        object resultobj = super.getobjectmapper().readvalue(result, javatype);
        return resultobj;
    }

    /**
     * 从http输入消息中读取指定java类型的对象，内部使用。
     * 
     * @param javatype    要读取的对象的java类型。
     * @param inputmessage http输入消息，包含要读取的json数据。
     * @return 从输入消息中解析出的对象。
     * @throws ioexception 如果发生i/o错误。
     * @throws httpmessagenotreadableexception 如果消息无法读取。
     */
    private object readjavatype(javatype javatype, httpinputmessage inputmessage) {
        try {
            return super.getobjectmapper().readvalue(inputmessage.getbody(), javatype);
        } catch (ioexception ex) {
            throw new httpmessagenotreadableexception("could not read json: " + ex.getmessage(), ex);
        }
    }

    /**
     * 将对象写入http输出消息，同时应用xss防护。
     * 
     * @param object 要写入的对象。
     * @param outputmessage http输出消息，对象将被序列化为json并写入此消息。
     * @throws ioexception 如果发生i/o错误。
     * @throws httpmessagenotwritableexception 如果消息无法写入。
     */
    @override
    protected void writeinternal(object object, httpoutputmessage outputmessage)
            throws ioexception, httpmessagenotwritableexception {
        //得到要输出的json
        string json = super.getobjectmapper().writevalueasstring(object);
        //过滤特殊字符
        string result = xssutil.clean(json);
        // 输出
        outputmessage.getbody().write(result.getbytes());
    }
}

package com.morris.spring.boot.module.xss;

import org.jsoup.jsoup;
import org.jsoup.nodes.document;
import org.jsoup.safety.whitelist;

/**
 * xss过滤工具类，使用jsoup库对输入的字符串进行xss攻击防护
 */
public class xssutil {

    /**
     * 使用jsoup自带的relaxed白名单
     */
    private static final whitelist white_list = whitelist.relaxed();
    /**
     * 定义输出设置，关闭prettyprint（prettyprint=false），目的是避免在清理过程中对代码进行格式化
     * 从而保持输入和输出内容的一致性。
     */
    private static final document.outputsettings output_settings = new document.outputsettings().prettyprint(false);

    /*
      初始化白名单策略，允许所有标签拥有style属性。
      这是因为在富文本编辑中，样式通常通过style属性来定义，需要确保这些样式能够被保留。
     */
    static {
        // 富文本编辑时一些样式是使用 style 来进行实现的
        // 比如红色字体 style="color:red;"
        // 所以需要给所有标签添加 style 属性
        white_list.addattributes(":all", "style");
    }

    /**
     * 清理输入的字符串，移除潜在的xss攻击代码。
     *
     * @param content 待清理的字符串，通常是用户输入的html内容。
     * @return 清理后的字符串，保证不包含xss攻击代码。
     */
    public static string clean(string content) {
        // 使用定义好的白名单策略和输出设置清理输入的字符串
        return jsoup.clean(content, "", white_list, output_settings);
    }
}

package com.morris.spring.boot.module.xss;

import org.springframework.validation.annotation.validated;
import org.springframework.web.bind.annotation.getmapping;
import org.springframework.web.bind.annotation.requestmapping;
import org.springframework.web.bind.annotation.restcontroller;


/**
 * xss2防御get请求
 */
@restcontroller
@requestmapping("/xss/global")
@validated
public class xssglobalgetcontroller {

    /**
     * 使用注解拦截get请求中的xss，在方法参数前面加上@xss，注意类上面要加上@validated注解
     *
     * @param useraccount 请求参数
     * @return 请求参数
     */
    @getmapping("/test")
    public string test(string useraccount) {
        return useraccount;
    }

}

package com.morris.spring.boot.module.xss;

import org.springframework.web.bind.annotation.postmapping;
import org.springframework.web.bind.annotation.requestbody;
import org.springframework.web.bind.annotation.requestmapping;
import org.springframework.web.bind.annotation.restcontroller;

/**
 * xss全局防御post请求
 */
@restcontroller
@requestmapping("/xss/global")
public class xssglobalpostcontroller {

    /**
     * 使用注解拦截post请求中的xss，在实体类需要拦截xss的属性上面加上@xss或者@validated注解
     *
     * @param usergloballoginpojo 实体类
     * @return 实体类
     */
    @postmapping("/test")
    public usergloballoginpojo test(@requestbody usergloballoginpojo usergloballoginpojo) {
        return usergloballoginpojo;
    }

}