Web15- Java Web安全：防止XSS与CSRF攻击

Java Web安全：防止XSS与CSRF攻击

在当今数字化时代，Web应用已成为企业业务运营的核心载体。然而，随之而来的网络安全威胁也日益严峻。OWASP（开放Web应用安全项目）发布的《2021年Web应用安全风险Top 10》显示，注入攻击（包括XSS）和跨站请求伪造（CSRF）分别位列第三和第八位，每年导致数以亿计的经济损失。对于Java Web开发者而言，掌握XSS和CSRF攻击的防御技术已不再是可选技能，而是保障应用安全的基本要求。

本文将系统讲解XSS和CSRF攻击的原理、攻击方式及防御策略，提供30+可直接复用的Java代码示例，涵盖从基础防护到高级防御的全流程解决方案，帮助开发者构建真正安全的Java Web应用。

一、Web安全基础与威胁模型

在深入探讨具体攻击防御之前，我们需要先建立Web安全的基本认知框架，理解常见的威胁模型和安全原则。

1. Web应用安全的核心原则

保障Web应用安全需遵循三大核心原则，通常称为"安全三要素"：

• 保密性（Confidentiality）：确保信息仅被授权用户访问，防止未授权泄露。例如，用户的密码、银行卡信息等敏感数据必须加密存储和传输。
• 完整性（Integrity）：保证数据在传输和存储过程中不被未授权篡改。例如，电子商务订单金额不能被恶意修改。
• 可用性（Availability）：确保授权用户在需要时能够访问应用和数据。例如，防止DDoS攻击导致网站无法访问。

XSS攻击主要破坏保密性和完整性，攻击者可通过注入脚本窃取用户敏感信息或篡改页面内容；CSRF攻击则主要破坏完整性，攻击者可利用用户的身份执行非预期操作。

2. 常见Web安全威胁分类

除了XSS和CSRF，Java Web应用还面临多种安全威胁，了解这些威胁有助于建立全面的安全防御体系：

威胁类型	描述	典型案例
注入攻击	攻击者将恶意代码注入到应用中执行	SQL注入、NoSQL注入、XSS
身份认证失效	攻击者利用身份认证机制的缺陷冒充合法用户	会话固定、密码明文传输
敏感数据暴露	敏感数据未加密或加密强度不足	密码明文存储、HTTPS配置不当
权限提升	攻击者获取超出其权限范围的操作能力	水平越权（访问其他用户数据）、垂直越权（获取管理员权限）
安全配置错误	因不当配置导致的安全漏洞	默认密码未修改、错误的CORS配置
第三方组件漏洞	使用存在已知漏洞的第三方库	Log4j2远程代码执行漏洞

3. Java Web安全防护体系

构建Java Web安全防护体系需要多层次防御，形成"纵深防御"策略：

1. 网络层：使用HTTPS加密传输、配置Web应用防火墙（WAF）、DDoS防护。
2. 应用层：输入验证、输出编码、CSRF防护、会话管理、权限控制。
3. 数据层：敏感数据加密存储、参数化查询防止注入、数据脱敏。
4. 运维层：定期安全审计、依赖库漏洞扫描、安全配置检查。

本文将重点关注应用层中与XSS和CSRF相关的防护措施，这是开发者最能直接控制的安全环节。

二、XSS攻击：原理、类型与危害

跨站脚本攻击（Cross-Site Scripting，XSS）是一种注入式攻击，攻击者通过在Web页面中注入恶意JavaScript代码，当用户访问该页面时，脚本会在用户浏览器中执行，从而达到窃取信息、劫持会话等目的。

1. XSS攻击的工作原理

XSS攻击的核心原理是Web应用未对用户输入进行有效验证和编码，导致恶意脚本被浏览器执行。其攻击流程通常如下：

1. 攻击者向Web应用输入包含恶意JavaScript的内容（如评论、用户名等）。
2. 应用未对输入进行处理，直接将恶意内容存储到数据库或在页面中输出。
3. 其他用户访问包含恶意内容的页面时，恶意脚本被浏览器解析并执行。
4. 恶意脚本执行后，可窃取用户Cookie、会话令牌、敏感信息，或执行非预期操作。

示例场景：一个未做防护的博客评论系统，攻击者提交评论 <script>alert(document.cookie)</script>，当其他用户查看该评论时，浏览器会执行这段脚本，弹出包含用户Cookie的对话框。

2. XSS攻击的主要类型

根据攻击向量和触发方式，XSS可分为三大类：

（1）存储型XSS（Persistent XSS）

存储型XSS是最危险的XSS类型，恶意脚本被永久存储在目标服务器的数据库或文件中。每当用户访问包含该恶意脚本的页面时，脚本都会被执行。

攻击流程：

1. 攻击者在留言板、评论区等功能中提交包含恶意脚本的内容。
2. 恶意内容被存储到服务器数据库。
3. 其他用户访问相关页面时，服务器从数据库读取恶意内容并返回给浏览器。
4. 浏览器执行恶意脚本，导致攻击发生。

典型案例：某社交平台的个人资料页面允许用户输入个人简介，攻击者在简介中插入窃取Cookie的脚本。当其他用户查看该攻击者的资料时，脚本会执行并将自己的Cookie发送给攻击者，攻击者可利用Cookie冒充该用户登录。

（2）反射型XSS（Reflected XSS）

反射型XSS的恶意脚本不会被存储，而是通过URL参数、表单提交等方式传递给服务器，服务器将其"反射"回页面中执行。

攻击流程：

1. 攻击者构造包含恶意脚本的URL（如 http://example.com/search?query=<script>...</script>）。
2. 诱导受害者点击该URL（通常通过邮件、聊天工具等）。
3. 服务器接收到请求后，将URL中的恶意脚本作为响应的一部分返回给浏览器。
4. 浏览器执行恶意脚本，完成攻击。

典型案例：某网站的搜索功能将用户输入的搜索词直接显示在结果页面。攻击者构造包含恶意脚本的搜索URL，当用户点击后，脚本会执行并窃取用户的会话信息。

（3）DOM型XSS（DOM-based XSS）

DOM型XSS与前两种类型的区别在于，恶意脚本的执行完全发生在客户端的JavaScript中，无需与服务器交互。服务器返回的页面本身是安全的，但页面中的JavaScript代码在处理用户输入时存在漏洞。

攻击流程：

1. 攻击者构造包含恶意脚本的URL参数。
2. 受害者访问该URL，服务器返回正常页面。
3. 页面中的JavaScript代码读取URL参数并将其插入到DOM中，未进行安全处理。
4. 恶意脚本在DOM中被执行，导致攻击。

典型案例：页面中的JavaScript代码有如下逻辑：

// 从URL获取参数并插入到页面
var username = decodeURIComponent(location.search.split('username=')[1]);
document.getElementById('user').innerHTML = '欢迎您，' + username;

攻击者构造URL：http://example.com/welcome?username=<script>stealCookie()</script>，当用户访问时，脚本会被插入到页面并执行。

3. XSS攻击的危害

XSS攻击的危害范围广泛，从窃取用户信息到完全控制Web应用：

• 会话劫持：窃取用户Cookie中的会话ID，冒充用户身份登录系统。
• 敏感信息窃取：通过键盘记录等手段获取用户输入的用户名、密码、信用卡信息等。
• 页面篡改：修改网页内容，欺骗用户输入敏感信息或执行其他操作。
• 钓鱼攻击：在页面中插入伪造的登录表单，骗取用户 credentials。
• 恶意软件分发：诱导用户下载安装恶意软件。
• 内网探测与攻击：利用XSS漏洞在用户浏览器中执行脚本，探测用户所在内网环境。

真实案例：2018年，某大型社交媒体平台爆发存储型XSS漏洞，攻击者利用该漏洞在平台上传播恶意脚本，窃取了数万用户的会话信息，造成严重的数据泄露。

三、XSS防御：从输入到输出的全链路防护

防御XSS攻击需要采用"多层防御"策略，从输入验证、输出编码到安全配置，形成完整的防护体系。没有单一的防御措施能完全防止XSS，但组合使用多种措施可将风险降至最低。

1. 输入验证：过滤恶意输入

输入验证是防御XSS的第一道防线，通过对用户输入进行严格校验，拒绝或净化包含恶意内容的输入。

（1）白名单验证

输入验证应采用"白名单"策略：只允许符合预期格式的输入，拒绝所有不符合格式的输入。

Java代码示例：使用正则表达式验证输入

import java.util.regex.Pattern;public class InputValidator {// 用户名验证：只允许字母、数字、下划线，长度3-20private static final Pattern USERNAME_PATTERN = Pattern.compile("^[a-zA-Z0-9_]{3,20}$");// 邮箱验证：简单的邮箱格式验证private static final Pattern EMAIL_PATTERN = Pattern.compile("^[A-Za-z0-9+_.-]+@[A-Za-z0-9.-]+$");// 评论内容验证：允许常见字符，但禁止<script>等标签private static final Pattern COMMENT_PATTERN = Pattern.compile("^[^<>&\"']{1,500}$");/*** 验证用户名*/public static boolean isValidUsername(String username) {if (username == null) {return false;}return USERNAME_PATTERN.matcher(username).matches();}/*** 验证邮箱*/public static boolean isValidEmail(String email) {if (email == null) {return false;}return EMAIL_PATTERN.matcher(email).matches();}/*** 验证评论内容*/public static boolean isValidComment(String comment) {if (comment == null) {return false;}return COMMENT_PATTERN.matcher(comment).matches();}
}// 使用示例
public class CommentController {@PostMapping("/comments")public String addComment(@RequestParam String content) {// 验证输入if (!InputValidator.isValidComment(content)) {return "redirect:/error?message=评论内容包含不允许的字符";}// 处理合法评论commentService.saveComment(content);return "redirect:/comments";}
}

（2）使用框架进行输入验证

Spring框架提供了强大的输入验证功能，通过注解即可实现复杂的验证逻辑：

import javax.validation.constraints.NotBlank;
import javax.validation.constraints.Pattern;
import javax.validation.constraints.Size;// 评论DTO，包含验证注解
public class CommentDTO {@NotBlank(message = "评论内容不能为空")@Size(max = 500, message = "评论内容不能超过500个字符")// 禁止包含HTML标签和特殊字符@Pattern(regexp = "^[^<>&\"']*$", message = "评论内容包含不允许的字符")private String content;// getter和setterpublic String getContent() {return content;}public void setContent(String content) {this.content = content;}
}// 控制器中使用验证
@RestController
@RequestMapping("/api/comments")
public class CommentApiController {@Autowiredprivate CommentService commentService;@PostMappingpublic ResponseEntity<?> createComment(@Valid @RequestBody CommentDTO commentDTO, BindingResult bindingResult) {// 检查验证结果if (bindingResult.hasErrors()) {List<String> errorMessages = bindingResult.getFieldErrors().stream().map(FieldError::getDefaultMessage).collect(Collectors.toList());return ResponseEntity.badRequest().body(errorMessages);}// 保存评论Comment saved = commentService.save(commentDTO);return ResponseEntity.ok(saved);}
}

（3）特殊场景的输入处理

对于允许包含有限HTML的场景（如富文本编辑器），不能简单禁止所有HTML标签，而应使用专门的库进行安全过滤：

使用OWASP Java HTML Sanitizer库过滤HTML

<!-- 添加Maven依赖 -->
<dependency><groupId>com.googlecode.owasp-java-html-sanitizer</groupId><artifactId>owasp-java-html-sanitizer</artifactId><version>20211018.1</version>
</dependency>

import org.owasp.html.PolicyFactory;
import org.owasp.html.Sanitizers;public class HtmlSanitizer {// 定义允许的HTML标签和属性private static final PolicyFactory POLICY = Sanitizers.FORMATTING  // 允许<b>, <i>, <u>等格式化标签.and(Sanitizers.LINKS)  // 允许<a>标签.and(Sanitizers.STYLES)  // 允许有限的样式.and(Sanitizers.IMAGES);  // 允许<img>标签/*** 净化HTML内容，只保留允许的标签和属性*/public static String sanitizeHtml(String html) {if (html == null) {return "";}return POLICY.sanitize(html);}
}// 使用示例
public class ArticleService {public Article saveArticle(ArticleDTO dto) {// 对富文本内容进行安全过滤String safeContent = HtmlSanitizer.sanitizeHtml(dto.getContent());Article article = new Article();article.setTitle(dto.getTitle());article.setContent(safeContent);  // 存储净化后的内容return articleRepository.save(article);}
}

该库会自动移除所有危险的标签和属性（如<script>, onclick），只保留安全的HTML内容。

2. 输出编码：安全展示用户内容

即使进行了严格的输入验证，也不能完全依赖它来防御XSS。输出编码是防御XSS的关键措施，确保用户输入的内容在输出到页面时被正确编码，使其无法被浏览器解析为恶意脚本。

输出编码的核心原则是：根据输出上下文选择合适的编码方式。不同的输出位置（HTML标签内、HTML属性、JavaScript、CSS、URL等）需要不同的编码规则。

（1）HTML标签内文本编码

当用户输入被插入到HTML标签之间时（如<div>用户输入</div>），需要进行HTML实体编码。

Java代码示例：HTML实体编码工具类

public class HtmlEncoder {/*** HTML实体编码* 将特殊字符转换为对应的实体，如& -> &amp;，< -> &lt;*/public static String encode(String input) {if (input == null) {return "";}StringBuilder sb = new StringBuilder(input.length() * 2);for (char c : input.toCharArray()) {switch (c) {case '&':sb.append("&amp;");break;case '<':sb.append("&lt;");break;case '>':sb.append("&gt;");break;case '"':sb.append("&quot;");break;case '\'':sb.append("&#39;");break;default:// 对非ASCII字符进行编码if (c > 127) {sb.append("&#").append((int) c).append(";");} else {sb.append(c);}}}return sb.toString();}
}

在JSP中使用编码：

<!-- 错误示例：未编码直接输出 -->
<div class="comment">${comment.content}</div><!-- 正确示例：使用JSTL的fn:escapeXml函数编码 -->
<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>
<div class="comment">${fn:escapeXml(comment.content)}</div>

在Thymeleaf中使用编码：

Thymeleaf默认会对变量进行HTML编码，无需手动处理：

<!-- Thymeleaf会自动编码，安全 -->
<div class="comment" th:text="${comment.content}"></div><!-- 如果需要输出未编码的HTML（谨慎使用） -->
<div class="comment" th:utext="${comment.content}"></div>

（2）HTML属性编码

当用户输入被用作HTML标签的属性值时（如<input name="username" value="用户输入">），需要进行属性编码，除了编码特殊字符外，还需注意引号的处理。

Java代码示例：HTML属性编码

public class HtmlAttributeEncoder {/*** HTML属性编码* 适用于引号包裹的属性值，如<input value="编码内容">*/public static String encode(String input) {if (input == null) {return "";}StringBuilder sb = new StringBuilder(input.length() * 2);for (char c : input.toCharArray()) {// 对所有非字母数字字符进行编码if (c > '~' || c < ' ') {sb.append("&#").append((int) c).append(";");} else if (c == '"' || c == '\'' || c == '<' || c == '>' || c == '&') {sb.append("&#").append((int) c).append(";");} else {sb.append(c);}}return sb.toString();}
}

使用示例：

// 生成安全的HTML属性
public String generateUserInputHtml(String userInput) {String encodedValue = HtmlAttributeEncoder.encode(userInput);return String.format("<input type='text' name='username' value='%s'>", encodedValue);
}

（3）JavaScript编码

当用户输入需要嵌入到JavaScript代码中时（如var username = "用户输入";），需要使用JavaScript编码。

Java代码示例：JavaScript编码

public class JavaScriptEncoder {/*** JavaScript字符串编码* 适用于双引号包裹的JavaScript字符串*/public static String encode(String input) {if (input == null) {return "";}StringBuilder sb = new StringBuilder();for (char c : input.toCharArray()) {if (c >= 0x20 && c <= 0x7E) {// 可打印ASCII字符if (c == '"' || c == '\\' || c == '/') {// 对特殊字符转义sb.append('\\');sb.append(c);} else if (c == '<' || c == '>') {// 编码HTML特殊字符sb.append("\\x").append(String.format("%02X", (int) c));} else {sb.append(c);}} else if (c == '\b') {sb.append("\\b");} else if (c == '\f') {sb.append("\\f");} else if (c == '\n') {sb.append("\\n");} else if (c == '\r') {sb.append("\\r");} else if (c == '\t') {sb.append("\\t");} else {// 其他字符使用Unicode编码sb.append("\\u").append(String.format("%04X", (int) c));}}return sb.toString();}
}

使用示例：

// 在JavaScript中安全使用用户输入
public String generateUserScript(String username) {String encodedUsername = JavaScriptEncoder.encode(username);return String.format("<script>var username = \"%s\"; console.log(username);</script>", encodedUsername);
}

（4）URL参数编码

当用户输入被用作URL参数时（如http://example.com/user?name=用户输入），需要使用URL编码。

Java中使用URLEncoder进行编码：

import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;public class UrlEncoderUtil {/*** 编码URL参数值*/public static String encodeParam(String param) {if (param == null) {return "";}// 使用UTF-8编码，这是标准做法return URLEncoder.encode(param, StandardCharsets.UTF_8);}
}// 使用示例
public String generateUserUrl(String username) {String encodedUsername = UrlEncoderUtil.encodeParam(username);return String.format("http://example.com/user?name=%s", encodedUsername);
}

（5）使用OWASP Encoder库进行编码

手动实现各种编码容易出错，推荐使用OWASP提供的Encoder库，它包含了各种场景下的安全编码实现：

<!-- 添加Maven依赖 -->
<dependency><groupId>org.owasp.encoder</groupId><artifactId>encoder</artifactId><version>1.2.3</version>
</dependency>

import org.owasp.encoder.Encode;public class OwaspEncoderExample {public void encodeExamples(String userInput) {// HTML标签内文本编码String htmlEncoded = Encode.forHtml(userInput);// HTML属性编码String attrEncoded = Encode.forHtmlAttribute(userInput);// JavaScript编码String jsEncoded = Encode.forJavaScript(userInput);// URL参数编码String urlEncoded = Encode.forUriComponent(userInput);// CSS属性编码String cssEncoded = Encode.forCssString(userInput);}
}

3. 内容安全策略（CSP）：限制脚本执行

内容安全策略（Content Security Policy，CSP）是一种层防御机制，通过HTTP头告诉浏览器哪些资源可以加载，哪些脚本可以执行，从而有效防止XSS攻击。

CSP的工作原理是：限制脚本只能从信任的源加载和执行，禁止内联脚本和eval()等危险函数，即使攻击者成功注入了恶意脚本，浏览器也会拒绝执行。

（1）CSP策略基本语法

CSP策略通过Content-Security-Policy HTTP头指定，基本语法：

Content-Security-Policy: 指令1 源1 源2; 指令2 源3; ...

常用指令：

• default-src：所有未指定指令的默认策略
• script-src：限制JavaScript的源
• style-src：限制CSS的源
• img-src：限制图片的源
• connect-src：限制AJAX、WebSocket等连接的源
• frame-src：限制iframe的源
• object-src：限制插件（如Flash）的源

常用源值：

• 'self'：允许当前域名
• 'none'：不允许任何源
• https://example.com：允许指定域名
• https:：允许所有HTTPS源
• 'unsafe-inline'：允许内联脚本（不推荐，会降低安全性）
• 'unsafe-eval'：允许eval()等函数（不推荐）

（2）在Java Web应用中配置CSP

使用Filter配置CSP头：

import javax.servlet.*;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;// 配置CSP的Filter
public class CspFilter implements Filter {@Overridepublic void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)throws IOException, ServletException {HttpServletResponse httpResponse = (HttpServletResponse) response;// 设置CSP策略// 只允许从当前域名和trusted-cdn.com加载脚本和样式// 禁止内联脚本和eval()String cspPolicy = "default-src 'self'; " +"script-src 'self' https://trusted-cdn.com; " +"style-src 'self' https://trusted-cdn.com; " +"img-src 'self' data: https://trusted-cdn.com; " +"connect-src 'self'; " +"frame-src 'none'; " +"object-src 'none'; " +"base-uri 'self'; " +"form-action 'self'";httpResponse.setHeader("Content-Security-Policy", cspPolicy);// 对于不支持CSP的旧浏览器，可设置X-Content-Security-PolicyhttpResponse.setHeader("X-Content-Security-Policy", cspPolicy);chain.doFilter(request, response);}// init和destroy方法@Overridepublic void init(FilterConfig filterConfig) throws ServletException {}@Overridepublic void destroy() {}
}// 注册Filter（web.xml）
<filter><filter-name>cspFilter</filter-name><filter-class>com.example.security.CspFilter</filter-class>
</filter>
<filter-mapping><filter-name>cspFilter</filter-name><url-pattern>/*</url-pattern>
</filter-mapping>

在Spring Boot中配置CSP：

import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;@Configuration
public class WebSecurityConfig {@Beanpublic FilterRegistrationBean<CspFilter> cspFilter() {FilterRegistrationBean<CspFilter> registrationBean = new FilterRegistrationBean<>();registrationBean.setFilter(new CspFilter());registrationBean.addUrlPatterns("/*");registrationBean.setOrder(1); // 确保在其他过滤器之前执行return registrationBean;}
}

（3）处理内联脚本和样式

严格的CSP策略会禁止内联脚本（<script>...</script>）和内联样式（<style>...</style>），这可能会影响现有应用。有两种解决方案：

1. 将内联脚本/样式移到外部文件（推荐）：
   将所有JavaScript和CSS代码移到外部文件，通过<script src="...">和<link rel="stylesheet" href="...">引用。

2. 使用哈希或nonce允许特定内联脚本：

   • 哈希：计算脚本内容的哈希值，在CSP中指定
   • nonce：为每个请求生成随机nonce值，在脚本标签和CSP中同时指定

使用nonce的示例：

// 生成nonce的Filter
public class CspNonceFilter implements Filter {private static final SecureRandom RANDOM = new SecureRandom();@Overridepublic void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)throws IOException, ServletException {HttpServletRequest httpRequest = (HttpServletRequest) request;HttpServletResponse httpResponse = (HttpServletResponse) response;// 生成16字节的随机nonce，转换为Base64byte[] nonceBytes = new byte[16];RANDOM.nextBytes(nonceBytes);String nonce = Base64.getEncoder().encodeToString(nonceBytes);// 将nonce存储在请求属性中，供视图使用httpRequest.setAttribute("cspNonce", nonce);// 设置包含nonce的CSP策略String cspPolicy = "default-src 'self'; " +"script-src 'self' 'nonce-" + nonce + "'; " + // 允许带有该nonce的内联脚本"style-src 'self' 'nonce-" + nonce + "'";    // 允许带有该nonce的内联样式httpResponse.setHeader("Content-Security-Policy", cspPolicy);chain.doFilter(request, response);}// init和destroy方法省略
}// 在JSP中使用nonce
<script nonce="${cspNonce}">// 内联脚本，因为包含正确的nonce而被允许执行function init() {// ...}
</script>

4. 其他XSS防御措施

除了上述核心防御措施，还有一些辅助手段可以增强XSS防御能力：

（1）设置HttpOnly和Secure属性保护Cookie

XSS攻击的主要目标之一是窃取用户Cookie，特别是包含会话ID的Cookie。通过设置Cookie的HttpOnly和Secure属性，可以有效防止Cookie被窃取：

• HttpOnly：禁止JavaScript访问Cookie，防止通过document.cookie窃取。
• Secure：仅在HTTPS连接中传输Cookie，防止中间人攻击。

Java中设置Cookie属性：

// 在Servlet中设置安全的Cookie
public void setSecureCookie(HttpServletResponse response, String name, String value, int maxAge) {Cookie cookie = new Cookie(name, value);cookie.setHttpOnly(true);  // 禁止JavaScript访问cookie.setSecure(true);    // 仅HTTPS传输cookie.setPath("/");       // 全站有效cookie.setMaxAge(maxAge);  // 有效期（秒）response.addCookie(cookie);
}// 在Spring中设置会话Cookie属性
@Configuration
public class SessionConfig extends AbstractHttpSessionApplicationInitializer {@Beanpublic ServletContextInitializer servletContextInitializer() {return servletContext -> {// 设置会话Cookie的属性servletContext.setSessionCookieConfig(new SessionCookieConfig() {@Overridepublic boolean isHttpOnly() {return true;}@Overridepublic boolean isSecure() {return true;  // 生产环境应设为true}// 其他方法实现省略@Override public String getName() { return "JSESSIONID"; }@Override public String getDomain() { return null; }@Override public String getPath() { return "/"; }@Override public int getMaxAge() { return -1; }@Override public void setName(String name) {}@Override public void setDomain(String domain) {}@Override public void setPath(String path) {}@Override public void setMaxAge(int maxAge) {}@Override public void setHttpOnly(boolean httpOnly) {}@Override public void setSecure(boolean secure) {}@Override public String getComment() { return null; }@Override public void setComment(String comment) {}});};}
}

（2）使用X-XSS-Protection头

虽然现代浏览器对XSS的防护已很完善，但仍可设置X-XSS-Protection头增强防护：

// 在Filter中添加X-XSS-Protection头
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)throws IOException, ServletException {HttpServletResponse httpResponse = (HttpServletResponse) response;// 启用XSS过滤，检测到攻击时阻止页面加载httpResponse.setHeader("X-XSS-Protection", "1; mode=block");chain.doFilter(request, response);
}

（3）避免使用危险的JavaScript API

许多JavaScript API容易被XSS攻击利用，应尽量避免使用：

• eval()：执行字符串作为代码，风险极高
• document.write()：直接写入文档，可能插入恶意脚本
• innerHTML：插入HTML内容，未编码的用户输入会导致XSS
• setTimeout()/setInterval()：第一个参数为字符串时类似eval()

安全替代方案：

// 不安全：使用eval()
var data = 'userInput';
eval('process(' + data + ')');// 安全：使用函数
var data = 'userInput';
process(data);// 不安全：使用innerHTML
document.getElementById('content').innerHTML = userInput;// 安全：使用textContent
document.getElementById('content').textContent = userInput;// 必须使用innerHTML时，先进行编码
document.getElementById('content').innerHTML = encodeHtml(userInput);

四、CSRF攻击：原理、场景与防御

跨站请求伪造（Cross-Site Request Forgery，CSRF）是一种利用用户已认证的身份，在用户不知情的情况下执行非预期操作的攻击方式。与XSS不同，CSRF攻击不需要注入恶意代码，而是利用浏览器的Cookie自动携带机制。

1. CSRF攻击的工作原理

CSRF攻击的核心在于利用用户的身份凭证（通常是Cookie） 执行未授权操作。其攻击流程如下：

1. 用户登录信任的网站A（如网上银行），成功认证后，网站A在用户浏览器中设置认证Cookie。
2. 用户在未退出网站A的情况下，访问恶意网站B。
3. 恶意网站B的页面中包含指向网站A的恶意请求（如转账请求）。
4. 当用户访问恶意网站B时，浏览器会自动携带网站A的Cookie，向网站A发送请求。
5. 网站A收到请求后，由于请求包含有效的认证Cookie，会认为是用户本人发起的请求，从而执行相应操作。

关键条件：CSRF攻击成功需要满足两个条件：

• 用户必须已登录目标网站，且会话尚未过期。
• 攻击者必须诱导用户在登录状态下访问包含恶意请求的页面。

2. CSRF攻击的常见场景

CSRF攻击可针对任何需要认证的操作，常见场景包括：

（1）表单提交攻击

攻击者伪造一个表单，当用户访问恶意页面时自动提交，执行如转账、修改密码等操作。

攻击示例：某银行网站的转账功能通过POST请求实现：

<!-- 银行网站正常转账表单 -->
<form action="https://bank.example.com/transfer" method="POST"><input type="text" name="toAccount" value="123456"><input type="text" name="amount" value="1000"><button type="submit">转账</button>
</form>

攻击者可构造如下恶意页面：

<!-- 恶意网站的CSRF攻击页面 -->
<html>
<body><!-- 隐藏的自动提交表单 --><form id="csrfForm" action="https://bank.example.com/transfer" method="POST"><input type="hidden" name="toAccount" value="attackerAccount"><input type="hidden" name="amount" value="10000"></form><script>// 页面加载后自动提交表单document.getElementById('csrfForm').submit();</script>
</body>
</html>

当已登录银行网站的用户访问该恶意页面时，浏览器会自动向银行网站发送转账请求，由于携带了用户的认证Cookie，银行会执行转账操作。

（2）链接点击攻击

攻击者通过邮件、聊天工具等发送包含恶意请求的链接，诱导用户点击。

攻击示例：某社交网站的关注功能通过GET请求实现：

https://social.example.com/follow?userId=123

攻击者可构造如下链接，诱导用户点击：

https://social.example.com/follow?userId=attackerId

当已登录社交网站的用户点击该链接时，会自动关注攻击者的账号。

（3）AJAX请求攻击

现代Web应用广泛使用AJAX发送请求，攻击者可通过JavaScript构造跨域AJAX请求。

攻击示例：某电商网站的添加购物车功能通过AJAX实现：

// 正常的添加购物车请求
fetch('https://shop.example.com/cart/add', {method: 'POST',credentials: 'include', // 发送Cookieheaders: {'Content-Type': 'application/json'},body: JSON.stringify({productId: 456, quantity: 1})
});

攻击者可构造如下恶意JavaScript：

// 恶意AJAX请求
fetch('https://shop.example.com/cart/add', {method: 'POST',credentials: 'include', // 自动携带目标网站Cookieheaders: {'Content-Type': 'application/json'},body: JSON.stringify({productId: attackerProductId, quantity: 10})
});

由于浏览器的同源策略限制，默认情况下跨域AJAX请求不会成功。但攻击者可通过其他方式绕过（如利用CORS配置错误），或通过表单提交等方式发起请求。

3. CSRF攻击的危害

CSRF攻击的危害取决于被攻击功能的权限，可能包括：

• 执行未授权操作：如转账、购物、修改个人信息、发布内容等。
• 权限提升：如果被攻击用户具有管理员权限，攻击者可能执行更危险的操作，如创建管理员账号、删除数据等。
• 隐私泄露：诱导用户执行敏感操作，泄露个人隐私信息。
• 名誉损害：以用户名义发布不当内容，损害用户名誉。

真实案例：2008年，某知名社交网络平台存在CSRF漏洞，攻击者利用该漏洞诱导用户关注特定账号、发送消息，影响了数百万用户。

五、CSRF防御：验证请求的真实性

防御CSRF攻击的核心是验证请求的真实性，确保请求确实是用户本人发起的，而非第三方伪造。主要防御手段包括使用CSRF Token、验证Referer/Origin头、使用SameSite Cookie属性等。

1. CSRF Token：最有效的防御手段

CSRF Token（跨站请求伪造令牌）是一种随机生成的独特值，由服务器生成并发送给客户端，客户端在发起请求时必须携带该Token，服务器验证Token的有效性后才处理请求。

由于攻击者无法获取到该Token（同源策略限制），因此无法构造有效的恶意请求。

（1）CSRF Token的工作流程

1. 服务器在用户会话中生成一个随机的CSRF Token，并将其存储。
2. 服务器在返回给客户端的页面中（通常是表单页面）嵌入该Token（如隐藏字段、JavaScript变量等）。
3. 客户端在发起请求时（如提交表单），必须将Token作为请求的一部分发送给服务器。
4. 服务器收到请求后，验证请求中的Token与会话中存储的Token是否一致。
5. 若一致，则认为请求有效，继续处理；若不一致或缺失，则拒绝请求。

（2）在Java Web应用中实现CSRF Token

步骤1：生成和存储CSRF Token

import java.security.SecureRandom;
import java.util.Base64;public class CsrfTokenGenerator {// 使用安全的随机数生成器private static final SecureRandom RANDOM = new SecureRandom();/*** 生成32字节的随机CSRF Token，编码为Base64字符串*/public static String generateToken() {byte[] tokenBytes = new byte[32];RANDOM.nextBytes(tokenBytes);return Base64.getUrlEncoder().withoutPadding().encodeToString(tokenBytes);}
}// 存储Token到用户会话
public class CsrfTokenManager {// 会话中存储Token的属性名public static final String CSRF_TOKEN_ATTR = "csrfToken";/*** 为当前会话生成并存储CSRF Token*/public static String getOrCreateToken(HttpSession session) {String token = (String) session.getAttribute(CSRF_TOKEN_ATTR);if (token == null) {token = CsrfTokenGenerator.generateToken();session.setAttribute(CSRF_TOKEN_ATTR, token);}return token;}/*** 验证请求中的Token与会话中的Token是否一致*/public static boolean validateToken(HttpSession session, String requestToken) {if (requestToken == null || requestToken.isEmpty()) {return false;}String sessionToken = (String) session.getAttribute(CSRF_TOKEN_ATTR);if (sessionToken == null) {return false;}// 比较两个Token（使用常量时间比较，防止时序攻击）return constantTimeEquals(sessionToken, requestToken);}/*** 常量时间比较，防止时序攻击*/private static boolean constantTimeEquals(String a, String b) {if (a.length() != b.length()) {return false;}int result = 0;for (int i = 0; i < a.length(); i++) {result |= a.charAt(i) ^ b.charAt(i);}return result == 0;}
}

步骤2：在表单中嵌入CSRF Token

<!-- 在JSP表单中添加CSRF Token隐藏字段 -->
<form action="/user/update" method="POST"><!-- CSRF Token隐藏字段 --><input type="hidden" name="${_csrf.parameterName}" value="${_csrf.token}"><!-- 其他表单字段 --><input type="text" name="username" value="${user.username}"><input type="email" name="email" value="${user.email}"><button type="submit">更新</button>
</form>

步骤3：在AJAX请求中携带CSRF Token

<!-- 在页面中嵌入CSRF Token供JavaScript使用 -->
<meta name="_csrf" content="${_csrf.token}">
<meta name="_csrf_header" content="${_csrf.headerName}"><script>// 获取CSRF Token和头信息var csrfToken = document.querySelector('meta[name="_csrf"]').content;var csrfHeader = document.querySelector('meta[name="_csrf_header"]').content;// 发送AJAX请求fetch('/api/orders', {method: 'POST',headers: {'Content-Type': 'application/json',[csrfHeader]: csrfToken  // 在请求头中携带CSRF Token},body: JSON.stringify({productId: 123,quantity: 2})}).then(response => response.json()).then(data => console.log(data));
</script>

步骤4：验证CSRF Token的Filter

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;public class CsrfFilter implements Filter {// 需要验证CSRF Token的HTTP方法private static final String[] METHODS_TO_CHECK = {"POST", "PUT", "DELETE", "PATCH"};@Overridepublic void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)throws IOException, ServletException {HttpServletRequest httpRequest = (HttpServletRequest) request;HttpServletResponse httpResponse = (HttpServletResponse) response;// 检查请求方法是否需要验证if (shouldCheckCsrf(httpRequest.getMethod())) {HttpSession session = httpRequest.getSession(false);// 没有会话则拒绝请求if (session == null) {httpResponse.sendError(HttpServletResponse.SC_FORBIDDEN, "CSRF Token验证失败");return;}// 从请求中获取Token（优先从请求头获取，其次从参数获取）String requestToken = httpRequest.getHeader("X-CSRF-TOKEN");if (requestToken == null) {requestToken = httpRequest.getParameter("_csrf");}// 验证Tokenif (!CsrfTokenManager.validateToken(session, requestToken)) {httpResponse.sendError(HttpServletResponse.SC_FORBIDDEN, "CSRF Token验证失败");return;}}chain.doFilter(request, response);}/*** 判断是否需要检查CSRF Token*/private boolean shouldCheckCsrf(String method) {for (String m : METHODS_TO_CHECK) {if (m.equalsIgnoreCase(method)) {return true;}}return false;}// init和destroy方法省略@Overridepublic void init(FilterConfig filterConfig) throws ServletException {}@Overridepublic void destroy() {}
}

（3）使用Spring Security的CSRF保护

Spring Security内置了CSRF保护功能，只需简单配置即可启用：

import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {@Overrideprotected void configure(HttpSecurity http) throws Exception {http// 启用CSRF保护（默认已启用）.csrf().and()// 其他安全配置.authorizeRequests().antMatchers("/public/**").permitAll().anyRequest().authenticated().and().formLogin();}
}

Spring Security会自动生成和验证CSRF Token，并在模型中添加_csrf属性供视图使用，使用方式与前面手动实现的示例相同。

对于不需要CSRF保护的端点（如API接口使用Token认证），可以禁用CSRF：

@Override
protected void configure(HttpSecurity http) throws Exception {http// 对API路径禁用CSRF.csrf().ignoringAntMatchers("/api/**").and()// 其他配置...
}

2. 验证Referer和Origin头

HTTP请求中的Referer头和Origin头可以标识请求的来源。通过验证这两个头，可以判断请求是否来自合法的源，从而防御CSRF攻击。

• Referer：包含完整的请求来源URL（如https://example.com/form）。
• Origin：只包含请求来源的协议、域名和端口（如https://example.com），在跨域请求中更常用。

（1）验证Referer/Origin的Filter实现

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;public class RefererOriginFilter implements Filter {// 允许的源（域名）private static final String[] ALLOWED_ORIGINS = {"example.com", "app.example.com"};@Overridepublic void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)throws IOException, ServletException {HttpServletRequest httpRequest = (HttpServletRequest) request;HttpServletResponse httpResponse = (HttpServletResponse) response;// 获取请求方法String method = httpRequest.getMethod();// 只对修改数据的方法验证Referer/Originif ("POST".equals(method) || "PUT".equals(method) || "DELETE".equals(method)) {// 验证Referer或Originif (!isValidReferer(httpRequest) && !isValidOrigin(httpRequest)) {httpResponse.sendError(HttpServletResponse.SC_FORBIDDEN, "请求来源验证失败");return;}}chain.doFilter(request, response);}/*** 验证Referer头*/private boolean isValidReferer(HttpServletRequest request) {String referer = request.getHeader("Referer");if (referer == null || referer.isEmpty()) {return false;}try {URL refererUrl = new URL(referer);String host = refererUrl.getHost();// 检查是否为允许的源for (String allowed : ALLOWED_ORIGINS) {if (host.equals(allowed) || host.endsWith("." + allowed)) {return true;}}return false;} catch (MalformedURLException e) {return false;}}/*** 验证Origin头*/private boolean isValidOrigin(HttpServletRequest request) {String origin = request.getHeader("Origin");if (origin == null || origin.isEmpty()) {return false;}try {URL originUrl = new URL(origin);String host = originUrl.getHost();// 检查是否为允许的源for (String allowed : ALLOWED_ORIGINS) {if (host.equals(allowed) || host.endsWith("." + allowed)) {return true;}}return false;} catch (MalformedURLException e) {return false;}}// init和destroy方法省略@Overridepublic void init(FilterConfig filterConfig) throws ServletException {}@Overridepublic void destroy() {}
}

（2）Referer/Origin验证的局限性

虽然Referer/Origin验证可以作为CSRF防御的补充手段，但存在以下局限性：

• Referer头可能被浏览器出于隐私保护而省略（如从HTTPS页面跳转到HTTP页面）。
• 攻击者可能通过某些手段篡改Referer头（虽然现代浏览器对此限制严格）。
• 对于同源的请求，Origin头可能不存在，需要依赖Referer头。

因此，Referer/Origin验证不应作为唯一的CSRF防御措施，而应与CSRF Token结合使用，形成多层防御。

3. SameSite Cookie属性

SameSite是Cookie的一个属性，用于限制Cookie在跨站请求中的发送，从而有效防御CSRF攻击。该属性已被主流浏览器支持（Chrome 51+、Firefox 60+、Edge 79+）。

SameSite有三个可能的值：

• SameSite=Strict：仅在同源请求中发送Cookie，完全禁止跨站请求携带Cookie。
• SameSite=Lax：允许在GET方法的跨站导航中发送Cookie（如链接跳转），但禁止在POST表单、AJAX等跨站请求中发送。这是大多数浏览器的默认值。
• SameSite=None：允许跨站请求携带Cookie，但必须同时设置Secure属性（仅在HTTPS中传输）。

（1）在Java中设置SameSite属性

设置会话Cookie的SameSite属性：

@Configuration
public class WebConfig implements WebMvcConfigurer {@Beanpublic ServletContextInitializer servletContextInitializer() {return servletContext -> {// 配置会话CookieServletContextHandler handler = new ServletContextHandler();SessionCookieConfig sessionCookieConfig = servletContext.getSessionCookieConfig();// 设置SameSite属性为LaxsessionCookieConfig.setAttribute("SameSite", "Lax");// 其他安全属性sessionCookieConfig.setHttpOnly(true);sessionCookieConfig.setSecure(true); // 生产环境启用};}
}

设置自定义Cookie的SameSite属性：

public void setCustomCookie(HttpServletResponse response) {// 创建CookieCookie cookie = new Cookie("customCookie", "value");cookie.setPath("/");cookie.setHttpOnly(true);cookie.setSecure(true);// 设置SameSite属性（通过响应头直接设置，因为Cookie类不支持）String cookieValue = "customCookie=value; Path=/; HttpOnly; Secure; SameSite=Lax";response.addHeader("Set-Cookie", cookieValue);
}

（2）SameSite属性的使用建议

• 对于大多数Web应用，SameSite=Lax是平衡安全性和可用性的最佳选择。
• 对于安全性要求极高的应用（如银行、支付），可使用SameSite=Strict，但可能影响某些跨站功能（如从邮件点击链接登录）。
• 若应用需要支持跨站请求（如第三方登录），可使用SameSite=None; Secure，但需确保使用HTTPS。

SameSite属性是防御CSRF的有效手段，但由于部分旧浏览器不支持，仍需与CSRF Token结合使用，确保全面防护。

4. 其他CSRF防御措施

除了上述主要防御措施，还有一些辅助手段可以增强CSRF防御：

（1）使用自定义请求头

浏览器的同源策略限制了跨域请求设置自定义头，攻击者难以在跨站请求中添加自定义头。因此，验证请求中是否包含特定的自定义头可以防御CSRF：

// 验证自定义请求头的Filter
public class CustomHeaderFilter implements Filter {private static final String CUSTOM_HEADER = "X-Requested-With";private static final String EXPECTED_VALUE = "XMLHttpRequest";@Overridepublic void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)throws IOException, ServletException {HttpServletRequest httpRequest = (HttpServletRequest) request;HttpServletResponse httpResponse = (HttpServletResponse) response;String method = httpRequest.getMethod();if ("POST".equals(method) || "PUT".equals(method) || "DELETE".equals(method)) {// 验证自定义头String headerValue = httpRequest.getHeader(CUSTOM_HEADER);if (headerValue == null || !headerValue.equals(EXPECTED_VALUE)) {httpResponse.sendError(HttpServletResponse.SC_FORBIDDEN, "缺少有效请求头");return;}}chain.doFilter(request, response);}// 其他方法省略
}

许多JavaScript框架（如jQuery）会自动添加X-Requested-With: XMLHttpRequest头，可利用这一特性进行验证。

（2）要求重新验证身份

对于敏感操作（如转账、修改密码），即使验证了CSRF Token，也应要求用户重新输入密码或进行其他身份验证：

@Service
public class PaymentService {@Autowiredprivate UserRepository userRepository;/*** 转账操作，要求验证密码*/@Transactionalpublic void transfer(Long userId, String targetAccount, BigDecimal amount, String password) {// 1. 验证用户密码User user = userRepository.findById(userId).orElseThrow();if (!BCrypt.checkpw(password, user.getPasswordHash())) {throw new SecurityException("密码验证失败");}// 2. 执行转账逻辑// ...}
}

（3）限制会话时长

缩短用户会话的有效期可以减少CSRF攻击的窗口时间。当用户长时间未操作时，自动登出：

// 在web.xml中配置会话超时
<session-config><!-- 会话超时时间，单位分钟 --><session-timeout>30</session-timeout>
</session-config>// 在Spring Boot中配置
server.servlet.session.timeout=30m

六、综合防御策略与最佳实践

防御XSS和CSRF攻击不是孤立的技术点，而是需要结合多种措施，形成完整的安全防御体系。本节将介绍综合防御策略和最佳实践，帮助开发者在实际项目中有效应用安全措施。

1. 多层防御策略

单一的防御措施难以应对所有攻击场景，采用"多层防御"策略可以大幅提高安全系数：

• XSS防御多层策略：

  1. 输入验证：过滤和净化所有用户输入。
  2. 输出编码：根据上下文对输出内容进行适当编码。
  3. 内容安全策略（CSP）：限制脚本执行和资源加载。
  4. 安全Cookie属性：设置HttpOnly、Secure、SameSite属性。
  5. 定期安全审计：检测潜在的XSS漏洞。

• CSRF防御多层策略：

  1. CSRF Token：为所有状态修改请求添加并验证Token。
  2. SameSite Cookie：设置SameSite属性限制跨站Cookie发送。
  3. Referer/Origin验证：作为辅助验证手段。
  4. 敏感操作二次验证：要求用户重新验证身份。
  5. 限制会话时长：减少攻击窗口。

案例：某电商平台的评论功能采用多层XSS防御：

1. 使用OWASP HTML Sanitizer过滤评论内容。
2. 在页面展示时进行HTML编码。
3. 设置严格的CSP策略，禁止未授权脚本。
4. 对包含用户内容的页面定期进行自动化扫描。

2. 框架安全配置最佳实践

现代Java Web框架（如Spring Boot）提供了丰富的安全特性，正确配置这些特性可以有效防御XSS和CSRF攻击。

（1）Spring Boot安全配置最佳实践

import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.web.filter.CharacterEncodingFilter;@Configuration
@EnableWebSecurity
public class SecurityBestPracticesConfig extends WebSecurityConfigurerAdapter {// 密码加密器@Beanpublic PasswordEncoder passwordEncoder() {return new BCryptPasswordEncoder();}// 配置字符编码过滤器，防止中文乱码和潜在的编码相关漏洞@Beanpublic FilterRegistrationBean<CharacterEncodingFilter> characterEncodingFilter() {FilterRegistrationBean<CharacterEncodingFilter> registrationBean = new FilterRegistrationBean<>();CharacterEncodingFilter filter = new CharacterEncodingFilter();filter.setEncoding("UTF-8");filter.setForceEncoding(true);registrationBean.setFilter(filter);registrationBean.addUrlPatterns("/*");registrationBean.setOrder(0);return registrationBean;}// 配置CSP、X-XSS-Protection等安全头@Beanpublic FilterRegistrationBean<SecurityHeadersFilter> securityHeadersFilter() {FilterRegistrationBean<SecurityHeadersFilter> registrationBean = new FilterRegistrationBean<>();registrationBean.setFilter(new SecurityHeadersFilter());registrationBean.addUrlPatterns("/*");registrationBean.setOrder(1);return registrationBean;}@Overrideprotected void configure(HttpSecurity http) throws Exception {http// 启用CSRF保护.csrf().csrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse()).and()// 配置会话管理.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.IF_REQUIRED).invalidSessionUrl("/login?invalid").maximumSessions(1).expiredUrl("/login?expired").and().and()// 配置安全头.headers().contentSecurityPolicy("default-src 'self'; script-src 'self' 'nonce-${nonce}'; style-src 'self'").and().frameOptions().deny().xssProtection().block(true).and().contentTypeOptions().and()// 授权配置.authorizeRequests().antMatchers("/public/**", "/login").permitAll().antMatchers("/admin/**").hasRole("ADMIN").anyRequest().authenticated().and().formLogin().loginPage("/login").defaultSuccessUrl("/dashboard").and().logout().logoutSuccessUrl("/login?logout").deleteCookies("JSESSIONID");}
}// 安全头过滤器
class SecurityHeadersFilter implements Filter {@Overridepublic void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)throws IOException, ServletException {HttpServletResponse httpResponse = (HttpServletResponse) response;// 防止点击劫持httpResponse.setHeader("X-Frame-Options", "DENY");// 防止MIME类型嗅探httpResponse.setHeader("X-Content-Type-Options", "nosniff");// 防XSS（旧浏览器）httpResponse.setHeader("X-XSS-Protection", "1; mode=block");// 防止Referrer泄露httpResponse.setHeader("Referrer-Policy", "strict-origin-when-cross-origin");// 限制第三方资源使用httpResponse.setHeader("Permissions-Policy", "camera=(), microphone=(), geolocation=()");chain.doFilter(request, response);}// 其他方法省略
}

（2）前端框架安全配置

前端框架（如Vue、React）也提供了XSS防护机制，需正确配置：

Vue.js安全配置：

// Vue默认会对模板中的文本进行HTML编码，防止XSS
new Vue({el: '#app',data: {userInput: '<script>alert("xss")</script>'}
});// 模板中使用v-text（默认编码）
<div v-text="userInput"></div>// 必须使用v-html时（谨慎使用），确保内容已净化
<div v-html="sanitizedHtml"></div>// 在Vue中使用CSRF Token
axios.interceptors.request.use(config => {// 从meta标签获取CSRF Tokenconst csrfToken = document.querySelector('meta[name="csrf-token"]').content;config.headers['X-CSRF-TOKEN'] = csrfToken;return config;
});

3. 安全开发流程与工具

将安全实践融入开发流程，使用自动化工具检测漏洞，可以有效降低安全风险：

（1）安全开发流程

1. 需求阶段：进行安全需求分析，识别潜在风险点。
2. 设计阶段：采用安全的架构设计，如分层防御、最小权限原则。
3. 编码阶段：遵循安全编码规范，使用本文介绍的防御措施。
4. 测试阶段：进行安全测试，包括静态代码分析、动态扫描、渗透测试。
5. 部署阶段：配置安全的服务器环境，启用必要的安全措施。
6. 运维阶段：监控安全事件，定期更新补丁，响应漏洞报告。

（2）安全工具推荐

• 静态代码分析：

  • SonarQube：检测代码中的安全漏洞和不良实践。
  • FindSecBugs：专门用于检测Java代码中的安全漏洞。

• 动态应用安全测试：

  • OWASP ZAP：开源Web应用安全扫描器。
  • Burp Suite：Web应用安全测试工具。

• 依赖库漏洞检测：

  • OWASP Dependency-Check：检测项目依赖中的已知漏洞。
  • Snyk：持续监控依赖库安全。

• XSS和CSRF专项测试：

  • XSSer：XSS攻击测试工具。
  • CSRF Tester：CSRF漏洞检测工具。

在Maven中集成依赖检查：

<plugin><groupId>org.owasp</groupId><artifactId>dependency-check-maven</artifactId><version>7.1.1</version><executions><execution><goals><goal>check</goal></goals></execution></executions>
</plugin>

运行命令检测依赖漏洞：

mvn org.owasp:dependency-check-maven:check

4. 安全意识与持续改进

技术措施固然重要，但开发者的安全意识和持续改进的态度同样关键：

• 安全培训：定期对开发团队进行安全培训，讲解最新的攻击手段和防御技术。
• 代码审查：将安全审查作为代码审查的必要环节，重点检查XSS和CSRF防护措施。
• 漏洞响应：建立漏洞报告和响应机制，及时处理发现的安全问题。
• 安全更新：关注安全社区发布的漏洞信息，及时更新依赖库和框架。
• 威胁情报：跟踪最新的安全威胁，提前采取防御措施。

案例：某互联网公司建立了"安全 champions"计划，每个开发团队推选一名成员负责安全事务，定期参加安全培训，在团队内部推广安全实践，显著降低了生产环境的安全漏洞数量。

七、总结：构建牢不可破的Java Web安全防线

XSS和CSRF作为Web应用中最常见的安全威胁，其防御需要开发者从原理出发，理解攻击方式，采取有针对性的防御措施。本文详细介绍了这两种攻击的原理、场景及防御策略，提供了丰富的Java代码示例，涵盖从基础防护到高级配置的全流程解决方案。