企业官网建设流程全解析

1. 问题现象：特殊字符导致字段截断与清空

最近在使用若依Plus框架开发项目时，遇到了一个奇怪的XSS过滤问题。当我在表单中提交包含特殊字符的数据时，出现了字段内容被异常截断或清空的情况。具体表现为：

• A字段输入内容：’【】、=-·！@#~￥%……&*（）——+{}|”：》？《,./;'\\][=-~!@#$%^&*()_+{}|":>????????????????<`
• B字段输入内容：’【】、=-·！@#~￥%……&*（）——+{}|”：》？《,./;'\\][=-~!@#$%^&*()_+{}|":>????????????????/>`

提交后发现：

1. A字段内容被部分截断
2. B字段内容完全被清空

这个现象在测试包含HTML特殊字符和标点符号的输入时尤为明显。作为开发者，我们期望XSS过滤器应该只过滤真正的HTML标签和脚本，而不应该影响正常的文本内容，特别是当这些内容只是包含特殊字符而非恶意代码时。

注意：在实际开发中，用户输入包含各种特殊字符是完全正常的场景。比如用户可能在内容中输入数学公式（包含<>符号）、外语文字（包含各种标点）或者代码片段。一个好的XSS过滤器应该能够区分真正的恶意代码和正常的特殊字符使用。

2. 问题根源分析：整体JSON过滤的缺陷

经过深入排查，发现问题出在XSS过滤器的实现方式上。原版的XssHttpServletRequestWrapper对PUT和POST请求的处理存在设计缺陷：

2.1 原实现的工作机制

原过滤器的工作流程如下：

1. 检查请求是否为JSON类型（通过Content-Type判断）
2. 如果是JSON请求，读取整个请求体内容
3. 对整个JSON字符串进行HTML标签清理
4. 返回处理后的内容

关键问题代码：

public static String cleanHtmlTag(String content) { return content.replaceAll("(<[^<]*?>)|(<[\\s]*?/[^<]*?>)|(<[^<]*?/[\\s]*?>)", ""); }

2.2 为什么会导致字段截断

问题的本质在于：

1. 原实现将整个JSON字符串作为单一文本处理
2. HTML标签清理的正则表达式可能会错误匹配JSON中的特殊字符组合
3. 特别是当JSON中包含类似HTML标签结构的字符序列时（如/>,<,>等）
4. 这些字符组合被误认为是HTML标签而被删除，导致数据损坏

举例说明：

• 当JSON中包含"key": "value/>"这样的数据时，/>可能被误判为HTML标签结束
• 类似<script>的字符组合即使出现在字符串值中也会被过滤

2.3 更深层的设计问题

这种实现方式违背了几个重要的安全处理原则：

1. 上下文感知不足：没有区分JSON的结构和内容，对所有字符一视同仁
2. 过度过滤：在不需要过滤的地方进行了过滤，导致正常数据被破坏
3. 缺乏精确性：应该只过滤真正的威胁，而不是可能看起来像威胁的内容

3. 解决方案：精细化字段级过滤

针对上述问题，我们重构了XSS过滤器的实现，改为对JSON数据进行字段级的精细化处理。下面是详细的解决方案：

3.1 新实现的核心思路

1. 解析原始JSON为Map结构
2. 只对String类型的值进行HTML标签清理
3. 保持JSON结构和非String类型数据不变
4. 重新序列化为JSON字符串

这种方法确保：

• 只处理真正需要处理的部分（字符串值）
• 保持JSON结构完整
• 不误伤特殊字符组合

3.2 关键代码实现

改进后的getInputStream方法实现：

@Override public ServletInputStream getInputStream() throws IOException { // 非JSON类型，直接返回原始流 if (!isJsonRequest()) { return super.getInputStream(); } // 读取原始JSON String json = StrUtil.str(IoUtil.readBytes(super.getInputStream(), false), StandardCharsets.UTF_8); if (StringUtils.isEmpty(json)) { return super.getInputStream(); } // 使用ObjectMapper解析JSON ObjectMapper mapper = new ObjectMapper(); Map<String, Object> map; try { map = mapper.readValue(json, new TypeReference<Map<String, Object>>() {}); } catch (Exception e) { // JSON解析失败时保守处理，返回原始流 return super.getInputStream(); } // 遍历Map，仅清理String类型的值 for (Map.Entry<String, Object> entry : map.entrySet()) { if (entry.getValue() instanceof String) { entry.setValue(HtmlUtil.cleanHtmlTag((String) entry.getValue()).trim()); } } // 重新序列化为JSON byte[] jsonBytes = mapper.writeValueAsBytes(map); final ByteArrayInputStream bis = new ByteArrayInputStream(jsonBytes); return new ServletInputStream() { @Override public boolean isFinished() { return true; } @Override public boolean isReady() { return true; } @Override public void setReadListener(ReadListener readListener) {} @Override public int available() throws IOException { return jsonBytes.length; } @Override public int read() throws IOException { return bis.read(); } }; }

3.3 方案优势分析

1. 精确过滤：只针对字符串值进行过滤，不破坏JSON结构
2. 安全性保持：仍然有效防范XSS攻击，因为所有字符串值都会被清理
3. 数据完整性：特殊字符在不构成真正威胁时会被保留
4. 健壮性：添加了JSON解析异常处理，避免因过滤导致服务不可用
5. 性能影响小：虽然增加了解析和序列化步骤，但对现代应用性能影响可忽略

4. 实施细节与注意事项

在实际应用这个解决方案时，有几个重要的实施细节需要考虑：

4.1 依赖管理

确保项目中包含必要的依赖：

<!-- Jackson for JSON processing --> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>2.12.3</version> </dependency> <!-- Hutool工具包 --> <dependency> <groupId>cn.hutool</groupId> <artifactId>hutool-all</artifactId> <version>5.7.12</version> </dependency>

4.2 异常处理策略

我们采用了保守的异常处理策略：

1. 如果JSON解析失败，返回原始输入流
2. 这样确保服务在遇到畸形JSON时仍能工作
3. 但同时需要在更高层级做好安全防护

提示：在生产环境中，你可能需要根据安全需求调整这种策略。对于高安全要求的应用，可能需要在JSON解析失败时拒绝请求或记录安全事件。

4.3 递归处理嵌套结构

当前实现只处理了顶层的String字段。如果JSON包含嵌套结构（如对象数组），需要增强实现：

private void cleanMap(Map<String, Object> map) { for (Map.Entry<String, Object> entry : map.entrySet()) { if (entry.getValue() instanceof String) { entry.setValue(HtmlUtil.cleanHtmlTag((String) entry.getValue()).trim()); } else if (entry.getValue() instanceof Map) { cleanMap((Map<String, Object>) entry.getValue()); } else if (entry.getValue() instanceof List) { cleanList((List) entry.getValue()); } } } private void cleanList(List list) { for (int i = 0; i < list.size(); i++) { Object item = list.get(i); if (item instanceof String) { list.set(i, HtmlUtil.cleanHtmlTag((String) item).trim()); } else if (item instanceof Map) { cleanMap((Map<String, Object>) item); } else if (item instanceof List) { cleanList((List) item); } } }

4.4 性能考虑

虽然JSON解析和序列化会带来一定的性能开销，但：

1. 现代JSON库如Jackson非常高效
2. 对于大多数Web应用，这种开销可以忽略
3. 如果确实遇到性能瓶颈，可以考虑：
   • 缓存ObjectMapper实例（线程安全）
   • 对已知安全的请求路径跳过过滤
   • 使用更高效的JSON库如Gson

5. 测试验证与边缘案例

为确保解决方案的可靠性，我们需要设计全面的测试用例：

5.1 测试用例设计

5.2 自动化测试实现

建议使用JUnit编写自动化测试：

public class XssFilterTest { private XssHttpServletRequestWrapper wrapper; @BeforeEach void setUp() throws Exception { MockHttpServletRequest request = new MockHttpServletRequest(); request.setContentType("application/json"); wrapper = new XssHttpServletRequestWrapper(request); } @Test void testNormalText() throws Exception { String json = "{\"name\":\"John\"}"; ServletInputStream result = processJson(json); assertEquals(json, readStream(result)); } @Test void testWithHtml() throws Exception { String json = "{\"html\":\"<script>alert(1)</script>\"}"; ServletInputStream result = processJson(json); assertEquals("{\"html\":\"alert(1)\"}", readStream(result)); } @Test void testSpecialChars() throws Exception { String json = "{\"chars\":\"!@#$%^&*()_+-=[]{};':\\\",./<>?\"}"; ServletInputStream result = processJson(json); assertEquals(json, readStream(result)); } private ServletInputStream processJson(String json) throws Exception { ByteArrayInputStream input = new ByteArrayInputStream(json.getBytes()); wrapper.setInputStream(input); return wrapper.getInputStream(); } private String readStream(ServletInputStream stream) throws Exception { return new String(stream.readAllBytes(), StandardCharsets.UTF_8); } }

5.3 性能测试建议

使用JMH进行微基准测试，确保过滤器的性能可接受：

@BenchmarkMode(Mode.AverageTime) @OutputTimeUnit(TimeUnit.MILLISECONDS) @State(Scope.Benchmark) public class XssFilterBenchmark { private XssHttpServletRequestWrapper wrapper; private String testJson; @Setup public void setup() { MockHttpServletRequest request = new MockHttpServletRequest(); request.setContentType("application/json"); wrapper = new XssHttpServletRequestWrapper(request); testJson = "{\"name\":\"John\",\"age\":30,\"address\":{\"street\":\"123 Main St\",\"city\":\"New York\"}}"; } @Benchmark public void benchmarkFilter() throws Exception { ByteArrayInputStream input = new ByteArrayInputStream(testJson.getBytes()); wrapper.setInputStream(input); wrapper.getInputStream().readAllBytes(); } }

6. 经验总结与最佳实践

在实际实施这个解决方案的过程中，我总结了一些有价值的经验：

6.1 安全过滤的黄金法则

1. 最小权限原则：只过滤真正需要过滤的内容
2. 上下文感知：根据数据所在的位置决定过滤策略
3. 防御深度：不要依赖单一防护层
4. 故障安全：当过滤失败时，应该拒绝而非放行

6.2 Web安全过滤的最佳实践

1. 输入验证：在接收数据时进行格式验证
2. 输出编码：在显示数据时进行适当的编码
3. 内容安全策略(CSP)：使用HTTP头限制可执行内容
4. 分层防御：结合WAF、框架过滤和业务逻辑验证

6.3 针对若依Plus的特别建议

1. 版本兼容性：检查不同版本若依Plus的XSS过滤器实现
2. 扩展性考虑：如果需要支持更多内容类型（如XML），需要相应扩展
3. 日志记录：记录被过滤的内容以便安全审计
4. 配置化：考虑将过滤规则做成可配置的

6.4 常见陷阱与规避方法

1. 过度过滤：

   • 现象：破坏了合法内容
   • 解决：采用更精确的过滤策略，如本文的字段级过滤

2. 过滤不足：

   • 现象：放过了一些恶意内容
   • 解决：结合多种过滤方法，使用OWASP推荐的正则表达式

3. 性能问题：

   • 现象：过滤器成为性能瓶颈
   • 解决：优化实现，考虑缓存安全结果

4. 编码混淆：

   • 现象：攻击者使用编码绕过过滤
   • 解决：在过滤前统一字符编码

7. 延伸思考与未来改进

虽然当前的解决方案已经解决了字段截断的问题，但Web安全是一个持续的过程，还可以考虑以下改进方向：

7.1 支持更多内容类型

当前实现只处理了JSON格式的请求体，可以扩展支持：

• XML格式
• Form-data
• GraphQL查询

7.2 动态过滤策略

根据不同的API端点采用不同的过滤严格度：

1. 对于富文本内容，采用更宽松的策略
2. 对于普通文本，采用严格策略
3. 对于特定字段（如密码），可以跳过过滤

7.3 集成现代安全机制

1. Content Security Policy：添加CSP头提供额外防护
2. Subresource Integrity：确保加载的外部资源未被篡改
3. Trusted Types：限制危险的DOM API使用

7.4 机器学习辅助

对于复杂的过滤场景，可以考虑：

1. 使用机器学习模型识别真正的恶意输入
2. 自动调整过滤严格度
3. 异常检测和警报

在实际项目中实施安全措施时，最重要的是在安全性和可用性之间找到平衡。过度的安全措施可能损害用户体验，而不足的安全措施则会让系统面临风险。本文介绍的精细化XSS过滤方案正是这样一种平衡的体现——它既解决了原始实现中过于粗暴的过滤问题，又保持了系统的安全性。