<think>我们正在讨论的是在Java Web应用中如何对
JSON数据进行
XSS过滤。根据引用
内容，有两种主要方法：
1. 通过修改
SpringMVC的
json序列化器（如Jackson）来在序列化过程中
过滤XSS（引用[1]提到）。
2. 通过
过滤器（Filter）在请求进入时对参数进行
过滤（引用[3]提到）。
但是，对于
JSON数据，由于通常是通过请求体（@RequestBody）传递的，在
过滤器中直接读取请求体会导致Controller无法再次读取（因为输入流只能读一次）。因此，我们需要结合之前解决请求体重复读取的方法（使用请求包装器）和
XSS过滤。
具体步骤：
1. 创建一个可缓存请求体的HttpServletRequestWrapper（如前所述）。
2. 在
过滤器中，使用这个包装器，然后从缓存的请求体中获取
JSON字符串。
3. 对
JSON字符串进行
XSS过滤（可以使用像org.apache.commons.text.StringEscapeUtils这样的库，或者自定义
过滤规则）。
4. 将
过滤后的字符串重新设置到请求包装器中（或者创建一个新的包装器，包含
过滤后的字节数组）。
5. 将包装后的请求传递给后续处理。
然而，需要注意的是，直接修改
JSON字符串可能会破坏
JSON结构（例如，转义了引号等）。因此，更推荐的方式是解析
JSON树，然后对字符串类型的节点进行
过滤。
另一种方法（如引用[1]所述）是在Jackson的序列化/反序列化过程中进行
过滤，这通常更安全，因为它是在解析为对象树后进行的，不会破坏结构。
下面我将分别介绍这两种方法。
方法一：使用
过滤器（结合请求包装器和
JSON解析）
步骤：
1. 创建可缓存请求体的请求包装器（CachedBodyHttpServletRequest，如前所述）。
2. 在
过滤器中，读取缓存的请求体（
JSON字符串），然后解析为
JSON树（如使用Jackson的ObjectMapper）。
3. 遍历
JSON树，对所有字符串值进行
XSS过滤（例如，转义HTML特殊字符）。
4. 将
过滤后的
JSON树写回为字符串，并更新请求包装器
中的缓存体。
5. 将包装后的请求传递下去。
方法二：使用Jackson的
JsonDeserializer（在反序列化时
过滤）
1. 自定义一个
JsonDeserializer，用于在反序列化字符串时进行
XSS过滤。
2. 将这个反序列化器注册到ObjectMapper中，可以全局注册或者通过注解在特定字段上使用。
考虑到方法一在
过滤器中处理所有请求，可能会影响性能（因为要解析和重构整个
JSON），而且如果请求体不是
JSON，则不需要处理。方法二则更精确，只在反序列化时处理字符串字段。
下面分别给出两种方法的实现示例。
方法一：
过滤器方式（适用于所有请求，但注意性能）
首先，我们扩展之前的CachedBodyHttpServletRequest，使其可以重新设置缓存体（用于
过滤后更新）。
修改CachedBodyHttpServletRequest：
增加一个setCachedBody方法，用于更新缓存体。
然后，在
过滤器中：
1. 包装请求。
2. 检查请求的Content-Type是否为application/
json（避免处理非
JSON请求）。
3. 读取缓存体，解析为
JSON（使用Jackson的
JsonNode）。
4. 遍历
JsonNode，对所有文本节点进行
过滤。
5. 将
过滤后的
JsonNode写回字符串，并设置回请求包装器。
6. 传递包装后的请求。
方法二：使用Jackson反序列化器（推荐，因为更轻量且精确）
步骤：
1. 自定义一个
XSS过滤的反序列化器。
2. 注册这个反序列化器到ObjectMapper（可以全局注册，也可以针对特定字段使用注解）。
下面分别给出两种方法的代码示例。
方法一：
过滤器方式
注意：这种方法需要处理整个请求体，可能会对性能有影响，特别是大
JSON。
步骤1：修改CachedBodyHttpServletRequest，增加setCachedBody方法（可选，也可以重新创建字节数组）
实际上，我们可以通过重新设置cachedBody并重新生成输入流和reader。我们在之前的类中增加一个setCachedBody方法：
```java
public void setCachedBody(byte[] body) {
this.cachedBody = body;
}
```
步骤2：编写
XSS过滤工具类（简单示例，使用StringEscapeUtils）
添加依赖（如果使用Apache Commons Text）：
```xml
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-text</artifactId>
<version>1.9</version>
</dependency>
```
步骤3：编写
过滤器，对
JSON请求体进行
过滤
```java
import com.fasterxml.jackson.databind.
JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.commons.text.StringEscapeUtils;
import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
public class
XssJsonFilter implements Filter {
private ObjectMapper objectMapper = new ObjectMapper();
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
HttpServletRequest httpRequest = (HttpServletRequest) request;
// 检查是否为
JSON请求
if (is
JsonRequest(httpRequest)) {
// 使用我们之前定义的包装器
CachedBodyHttpServletRequest wrappedRequest = new CachedBodyHttpServletRequest(httpRequest);
// 读取缓存体
byte[] bodyBytes = wrappedRequest.getCachedBody();
String bodyStr = new String(bodyBytes, httpRequest.getCharacterEncoding());
// 解析
JSON
JsonNode rootNode = objectMapper.readTree(bodyStr);
// 遍历
JSON树并
过滤字符串值
filter
JsonNode(rootNode);
// 将
过滤后的
JSON转回字符串
String filteredBody = objectMapper.writeValueAsString(rootNode);
// 重新设置缓存体
wrappedRequest.setCachedBody(filteredBody.getBytes(httpRequest.getCharacterEncoding()));
// 继续传递包装后的请求
chain.doFilter(wrappedRequest, response);
} else {
chain.doFilter(request, response);
}
}
private boolean is
JsonRequest(HttpServletRequest request) {
String contentType = request.getContentType();
return contentType != null && contentType.contains("application/
json");
}
// 递归遍历
JsonNode，对字符串值进行
过滤
private void filter
JsonNode(
JsonNode node) {
if (node.isObject()) {
node.fields().forEachRemaining(entry -> {
JsonNode value = entry.getValue();
if (value.isTextual()) {
// 对字符串进行
XSS过滤
String filtered = StringEscapeUtils.escapeHtml4(value.asText());
((ObjectNode) node).put(entry.getKey(), filtered);
} else {
filter
JsonNode(value); // 递归处理
}
});
} else if (node.isArray()) {
for (
JsonNode item : node) {
filter
JsonNode(item);
}
}
// 其他类型无需处理
}
}
```
注意：上面的递归
过滤中，我们只处理了对象和数组。对于基本类型，只处理字符串。
方法二：使用Jackson反序列化器（推荐）
步骤1：创建自定义反序列化器
```java
import com.fasterxml.jackson.core.
JsonParser;
import com.fasterxml.jackson.core.
JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.
JsonDeserializer;
import org.apache.commons.text.StringEscapeUtils;
import java.io.IOException;
public class
XssString
JsonDeserializer extends
JsonDeserializer<String> {
@Override
public String deserialize(
JsonParser p, DeserializationContext ctxt) throws IOException,
JsonProcessingException {
String value = p.getValueAsString();
if (value == null) {
return null;
}
// 进行
XSS过滤
return StringEscapeUtils.escapeHtml4(value);
}
}
```
步骤2：注册这个反序列化器
有两种方式：
方式一：全局注册（所有String类型字段都应用）
```java
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.module.SimpleModule;
import org.
springframework.context.annotation.Bean;
import org.
springframework.context.annotation.Configuration;
import org.
springframework.http.converter.
json.Jackson2ObjectMapperBuilder;
@Configuration
public class JacksonConfig {
@Bean
public ObjectMapper objectMapper(Jackson2ObjectMapperBuilder builder) {
ObjectMapper objectMapper = builder.createXmlMapper(false).build();
SimpleModule module = new SimpleModule();
module.addDeserializer(String.class, new
XssString
JsonDeserializer());
objectMapper.registerModule(module);
return objectMapper;
}
}
```
方式二：在特定字段上使用注解
```java
public class User {
@
JsonDeserialize(using =
XssString
JsonDeserializer.class)
private String name;
// 其他字段...
}
```
方法二的好处：
- 只在反序列化时处理，不影响其他请求。
- 只针对字符串字段，不会误处理数字等。
- 更符合单一职责原则。
但是，方法二需要确保所有需要
过滤的字段都应用了该反序列化器（如果是全局注册则所有字符串字段都会被
过滤，可能有些字段不需要
过滤，比如密码字段通常不需要转义HTML，但需要
防止存储型
XSS，这取决于上下文）。
因此，建议使用方法二，并考虑在不需要
过滤的字段上使用其他注解（如@
JsonRawValue）或通过自定义注解来排除。
总结：
- 如果希望集中处理所有请求的
JSON数据，可以使用
过滤器方法（方法一），但要注意性能。
- 如果使用
Spring Boot，推荐使用方法二（自定义Jackson反序列化器），因为它更精确，且不会破坏
JSON结构，同时只在需要的地方
过滤。
根据引用[1]中提到的，他们使用了修改
json序列化的方式（即类似方法二），所以方法二也是被验证可行的。
注意：
XSS过滤的规则可以根据需要调整，比如使用更严格的策略（如白名单）或使用专门的库（如OWASP Java Encoder）。
使用OWASP Java Encoder的例子：
```java
import org.owasp.encoder.Encode;
// 在反序列化器中
return Encode.forHtmlContent(value); // 根据上下文选择编码方法
```
相关问题：
1. 如何选择
XSS过滤的编码方式（HTML
内容、HTML属性、JavaScript等）？
2. 在
Spring Boot中如何排除某些字段不进行
XSS过滤？
3. 如何
防止GET请求
中的XSS攻击（URL参数）？</think>### Java Web应用中
JSON数据的
XSS过滤方法
在Java Web应用中
防止JSON数据的
XSS攻击，主要有两种核心方案：**
过滤器层
过滤**和**
JSON序列化层
过滤**。以下是具体实现方法：
---
#### 方案1：
过滤器层
过滤（推荐）
在请求到达Controller前进行
XSS过滤，兼容性强且不依赖特定框架。
##### 实现步骤：
1. **创建
XSS过滤工具类**：
```java
import org.apache.commons.text.StringEscapeUtils;
public class
XssUtils {
// 使用ESAPI或Apache Commons Text进行
XSS过滤
public static String clean
Xss(String value) {
if (value == null) return null;
return StringEscapeUtils.escapeHtml4(value); // 转义HTML特殊字符
// 或使用：ESAPI.encoder().encodeForHTML(value) // 需ESAPI依赖
}
}
```
2. **创建可缓存请求的包装器**（解决请求体多次读取问题）：
```java
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import java.nio.charset.StandardCharsets;
public class
XssRequestWrapper extends HttpServletRequestWrapper {
private byte[] cachedBody;
public
XssRequestWrapper(HttpServletRequest request) throws IOException {
super(request);
// 读取并缓存请求体
ByteArrayOutputStream baos = new ByteArrayOutputStream();
InputStream is = request.getInputStream();
byte[] buffer = new byte[1024];
int len;
while ((len = is.read(buffer)) > -1) {
baos.write(buffer, 0, len);
}
cachedBody = baos.toByteArray();
}
@Override
public ServletInputStream getInputStream() {
return new CachedServletInputStream(cachedBody);
}
// 获取
过滤后的
JSON字符串
public String getFiltered
Json() {
String
json = new String(cachedBody, StandardCharsets.UTF_8);
return
XssUtils.clean
Xss(
json); // 应用
XSS过滤
}
}
```
3. **创建
XSS过滤器**：
```java
import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
public class
XssFilter implements Filter {
@Override
public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)
throws IOException, ServletException {
HttpServletRequest httpReq = (HttpServletRequest) req;
// 只处理
JSON请求
if ("application/
json".equalsIgnoreCase(httpReq.getContentType())) {
XssRequestWrapper wrappedRequest = new
XssRequestWrapper(httpReq);
// 获取
过滤后的
JSON
String filtered
Json = wrappedRequest.getFiltered
Json();
// 将
过滤后的
JSON重新放入请求属性（Controller层可获取）
wrappedRequest.setAttribute("filteredBody", filtered
Json);
chain.doFilter(wrappedRequest, res);
} else {
chain.doFilter(req, res); // 非
JSON请求直接放行
}
}
}
```
4. **在Controller中获取
过滤后的数据**：
```java
@PostMapping("/submit")
public ResponseEntity<?> handle
Json(@RequestBody String raw
Json,
HttpServletRequest request) {
// 从请求属性获取已
过滤的
JSON
String safe
Json = (String) request.getAttribute("filteredBody");
// 使用safe
Json继续处理...
return ResponseEntity.ok("Processed safely");
}
```
5. **配置
过滤器**（web.xml）：
```xml
<filter>
<filter-name>
XssFilter</filter-name>
<filter-class>com.example.
XssFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>
XssFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
```
---
#### 方案2：
JSON序列化层
过滤（
Spring Boot专用）
通过自定义Jackson反序列化器在
JSON解析时
过滤XSS，更精准但依赖
Spring框架。
##### 实现步骤：
1. **创建
XSS反序列化器**：
```java
import com.fasterxml.jackson.core.
JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.
JsonDeserializer;
import org.apache.commons.text.StringEscapeUtils;
import java.io.IOException;
public class
XssStringDeserializer extends
JsonDeserializer<String> {
@Override
public String deserialize(
JsonParser p, DeserializationContext ctx)
throws IOException {
String value = p.getValueAsString();
return value != null ? StringEscapeUtils.escapeHtml4(value) : null;
}
}
```
2. **注册全局反序列化器**：
```java
import com.fasterxml.jackson.databind.Module;
import com.fasterxml.jackson.databind.module.SimpleModule;
import org.
springframework.context.annotation.Bean;
import org.
springframework.context.annotation.Configuration;
@Configuration
public class JacksonConfig {
@Bean
public Module
xssModule() {
SimpleModule module = new SimpleModule();
// 所有String类型字段都应用
XSS过滤
module.addDeserializer(String.class, new
XssStringDeserializer());
return module;
}
}
```
3. **选择性
过滤**（使用注解）：
```java
public class UserDto {
@
JsonDeserialize(using =
XssStringDeserializer.class) // 仅
过滤特定字段
private String bio;
private Integer age; // 非字符串字段不受影响
}
```
---
### 两种方案对比
| **方案** | **优势** | **适用场景** |
|---------------------|----------------------------------|------------------------------|
|
过滤器层
过滤 | 框架无关、支持非
JSON请求 | 多框架项目、需要统一安全管控 |
|
JSON序列化层
过滤 | 精准到字段、无需处理请求流问题 |
Spring Boot项目、精确控制 |
---
### 关键注意事项
1. **性能优化**：
- 对于大
JSON，使用流式解析（如Jackson的`
JsonParser`）
- 添加缓存大小限制：`if(cachedBody.length > 10_000_000) throw new PayloadTooLargeException()`
2. **上下文感知
过滤**：
```java
// 根据
内容位置选择不同编码方式
String sanitized = switch(context) {
case HTML -> Encode.forHtml(input);
case JS -> Encode.forJavaScript(input);
default -> input;
};
```
3. **依赖库推荐**：
```xml
<!-- Apache Commons Text -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-text</artifactId>
<version>1.10.0</version>
</dependency>
<!-- OWASP Java Encoder（更专业） -->
<dependency>
<groupId>org.owasp.encoder</groupId>
<artifactId>encoder</artifactId>
<version>1.2.3</version>
</dependency>
```
4. **测试用例**：
```java
@Test
void test
XssFilter() {
String malicious = "<script>alert(1)</script>";
String safe =
XssUtils.clean
Xss(malicious);
assertEquals("<script>alert(1)</script>", safe);
}
```
> 实际项目中建议结合两种方案：
> - 用
过滤器处理所有请求的通用
XSS防护
> - 用
JSON反序列化器对敏感字段额外加固[^1][^3]
---
### 总结
在Java Web应用中防护
JSON数据的
XSS攻击，**
过滤器方案**提供基础防护并解决请求流复用问题，**
JSON序列化方案**实现精准字段级
过滤。关键点是：
1. 通过`HttpServletRequestWrapper`缓存请求体
2. 使用`StringEscapeUtils`或OWASP Encoder转义危险字符
3. 在
过滤器或Jackson反序列化器中植入清洗逻辑
4. 对HTML/JS/URL上下文采用差异化编码策略[^2]
对于新项目推荐使用
JSON序列化层方案，遗留系统建议采用
过滤器方案逐步迁移[^1][^3]。
本文介绍如何在Spring MVC中使用自定义的XSSMappingJackson2HttpMessageConverter来处理JSON的XSS攻击，通过重写read()和writeInternal()方法，确保了请求和响应的数据安全。
扫一扫
2461
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
