Web15- Java Web安全：防止XSS与CSRF攻击_ssrf漏洞 java程序进行防止

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

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

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

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

（1）HTML标签内文本编码

当用户输入被插入到HTML标签之间时（如

），需要进行HTML实体编码。

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

public class HtmlEncoder { /** * HTML实体编码 * 将特殊字符转换为对应的实体，如& -> &， < */ 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(\"&\");  break; case \'<\':  sb.append(\"<\");  break; case \'>\':  sb.append(\">\");  break; case \'\"\':  sb.append(\""\");  break; case \'\\\'\':  sb.append(\"'\");  break; default:  // 对非ASCII字符进行编码  if (c > 127) { sb.append(\"&#\").append((int) c).append(\";\");  } else { sb.append(c);  } } } return sb.toString(); }}

在JSP中使用编码：

${comment.content}
${fn:escapeXml(comment.content)}

在Thymeleaf中使用编码：

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

<div class=\"comment\" th:text=\"${comment.content}\"></div><div class=\"comment\" th:utext=\"${comment.content}\"></div>

（2）HTML属性编码

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

Java代码示例：HTML属性编码

public class HtmlAttributeEncoder { /** * HTML属性编码 * 适用于引号包裹的属性值，如 */ 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(\"\", 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(\"var username = \\\"%s\\\"; console.log(username);\", 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库，它包含了各种场景下的安全编码实现：

<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的Filterpublic class CspFilter implements Filter { @Override public 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-Policy httpResponse.setHeader(\"X-Content-Security-Policy\", cspPolicy); chain.doFilter(request, response); } // init和destroy方法 @Override public void init(FilterConfig filterConfig) throws ServletException {} @Override public 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>/*

在Spring Boot中配置CSP：

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

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

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

1. 将内联脚本/样式移到外部文件（推荐）：
   将所有JavaScript和CSS代码移到外部文件，通过和引用。

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

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

使用nonce的示例：

// 生成nonce的Filterpublic class CspNonceFilter implements Filter { private static final SecureRandom RANDOM = new SecureRandom(); @Override public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { HttpServletRequest httpRequest = (HttpServletRequest) request; HttpServletResponse httpResponse = (HttpServletResponse) response; // 生成16字节的随机nonce，转换为Base64 byte[] 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中设置安全的Cookiepublic 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属性@Configurationpublic class SessionConfig extends AbstractHttpSessionApplicationInitializer { @Bean public ServletContextInitializer servletContextInitializer() { return servletContext -> { // 设置会话Cookie的属性 servletContext.setSessionCookieConfig(new SessionCookieConfig() { @Override public boolean isHttpOnly() {  return true; } @Override public 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头@Overridepublic 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);// 不安全：使用innerHTMLdocument.getElementById(\'content\').innerHTML = userInput;// 安全：使用textContentdocument.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>

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

<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\', // 发送Cookie headers: { \'Content-Type\': \'application/json\' }, body: JSON.stringify({productId: 456, quantity: 1})});

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

// 恶意AJAX请求fetch(\'https://shop.example.com/cart/add\', { method: \'POST\', credentials: \'include\', // 自动携带目标网站Cookie headers: { \'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

      更新

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

 // 获取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));

步骤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\"}; @Override public 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\"); } // 验证Token if (!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方法省略 @Override public void init(FilterConfig filterConfig) throws ServletException {} @Override public 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@EnableWebSecuritypublic class SecurityConfig extends WebSecurityConfigurerAdapter { @Override protected 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：

@Overrideprotected 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\"}; @Override public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { HttpServletRequest httpRequest = (HttpServletRequest) request; HttpServletResponse httpResponse = (HttpServletResponse) response; // 获取请求方法 String method = httpRequest.getMethod(); // 只对修改数据的方法验证Referer/Origin if (\"POST\".equals(method) || \"PUT\".equals(method) || \"DELETE\".equals(method)) { // 验证Referer或Origin if (!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方法省略 @Override public void init(FilterConfig filterConfig) throws ServletException {} @Override public 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属性：

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

设置自定义Cookie的SameSite属性：

public void setCustomCookie(HttpServletResponse response) { // 创建Cookie Cookie 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：

// 验证自定义请求头的Filterpublic class CustomHeaderFilter implements Filter { private static final String CUSTOM_HEADER = \"X-Requested-With\"; private static final String EXPECTED_VALUE = \"XMLHttpRequest\"; @Override public 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，也应要求用户重新输入密码或进行其他身份验证：

@Servicepublic class PaymentService { @Autowired private UserRepository userRepository; /** * 转账操作，要求验证密码 */ @Transactional public 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@EnableWebSecuritypublic class SecurityBestPracticesConfig extends WebSecurityConfigurerAdapter { // 密码加密器 @Bean public PasswordEncoder passwordEncoder() { return new BCryptPasswordEncoder(); } // 配置字符编码过滤器，防止中文乱码和潜在的编码相关漏洞 @Bean public 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等安全头 @Bean public FilterRegistrationBean<SecurityHeadersFilter> securityHeadersFilter() { FilterRegistrationBean<SecurityHeadersFilter> registrationBean = new FilterRegistrationBean<>(); registrationBean.setFilter(new SecurityHeadersFilter()); registrationBean.addUrlPatterns(\"/*\"); registrationBean.setOrder(1); return registrationBean; } @Override protected 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 { @Override public 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编码，防止XSSnew Vue({ el: \'#app\', data: { userInput: \'alert(\"xss\")\' }});// 模板中使用v-text（默认编码）<div v-text=\"userInput\"></div>// 必须使用v-html时（谨慎使用），确保内容已净化<div v-html=\"sanitizedHtml\"></div>// 在Vue中使用CSRF Tokenaxios.interceptors.request.use(config => { // 从meta标签获取CSRF Token const 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代码示例，涵盖从基础防护到高级配置的全流程解决方案。