就在几个小时前,Xint研究团队披露了他们最新发现的几个nginx远程代码执行漏洞,根据披露信息,他们还在Linux内核中发现了一个单独的漏洞,该漏洞可以与任何nginx漏洞串联,以获得主机上的根权限(一个没有任何账号密码的普通网站访客,可以一路拿到服务器主机的 root 权限) 。
Nginx是世界上部署最广泛的网络服务器之一,且保持全球市场份额第一,驱动超过4亿个站点。
根据披露信息,多个漏洞中影响最大的是CVE-2026-123007,允许未经身份验证的攻击者在启用HTTP/2的受影响nginx服务器上执行命令。
▍ 1. 受影响的版本
五个 nginx 漏洞中的每一个都是独立的攻击路径,不需要串联在一起,它们在受影响的配置上各有不同。
|
CVE
|
受影响的配置
|
该路径首个受影响版本
|
是否可通过禁用 HTTP/2 阻断
|
|---|---|---|---|
|
CVE-2026-123007
|
启用 HTTP/2
|
1.9.5
|
是
|
|
CVE-2026-123634
|
resolver、由请求派生的
proxy_pass 目标,以及 mirror_request_body off |
1.13.4
|
否
|
|
CVE-2026-123633
|
启用 HTTP/2,请求转发到上游(后端)服务器
|
1.19.7
|
是
|
|
CVE-2026-121810
|
启用 HTTP/3,请求转发到上游(后端)服务器
|
1.25.0
|
否
|
|
CVE-2026-113425
|
邮件代理开启
proxy on 并使用 auth_http |
0.5.15
|
否
|
对于 CVE-2026-123634,上表列出的是我们测试所用的设置,其中使用了 mirror 指令。其他会创建子请求的 nginx 功能(例如 SSI)也可能抵达同样的错误,因此单独关闭 mirror 并不能让服务器安全。
CVE-2026-123007 自 nginx 于 2015 年引入 HTTP/2 起便已存在,至今超过十年。从 1.9.5 到 1.31.8 的每一个官方版本都包含易受攻击的代码,包括 2026 年 11 月 10 日的 master 分支。因此,即便是运行最新版本的服务器,也需要与老旧安装相同的补丁状态和 HTTP/2 暴露面检查。
做什么
补丁可用时更新到 1.31.9。在此之前,在受影响的监听端口上禁用 HTTP/2 可以阻断 CVE-2026-123007 和 CVE-2026-123633,但无法阻断另外三个 nginx 漏洞。请对照上表检查自身配置,并应用第 3.3 节中相应的缓解措施。
如何找到它们的
在准备 ZeroDay Cloud 2026 期间,一位 Xint 研究人员发现了 CVE-2026-123007。几天之后,一次全自动扫描又发现了其余四个漏洞,过程中没有人工指导。
nginx2root 一览
|
项目
|
细节
|
|---|---|
|
CVE
|
CVE-2026-123007、CVE-2026-123634、CVE-2026-123633、CVE-2026-121810、CVE-2026-113425
|
|
严重性
|
严重(Critical)
|
|
修复版本
|
1.31.9
|
|
影响
|
未经身份验证的远程攻击者可以以 nginx worker 进程权限执行任意命令
|
|
受影响版本(CVE-2026-123007)
|
nginx 1.9.5 至 1.31.8 的所有官方版本;截至 2026 年 11 月 10 日,master 分支中同样存在易受攻击的代码
|
|
代码历史(CVE-2026-123007)
|
随首个 HTTP/2 版本 nginx 1.9.5 引入,并一直保留到当前受影响的版本
|
|
临时缓解(CVE-2026-123007)
|
在受影响的监听端口上禁用 HTTP/2
|
|
完全修复
|
更新到 1.31.9
|
|
报告者
|
Xint 研究人员(@imssm99、@cdor1、@tjbecker、@yves)
|
▍ 2. 受影响的版本以及如何检查暴露面
本节重点介绍 CVE-2026-123007,它影响了绝大多数服务器,且只需要启用 HTTP/2 即可触发。至于其余四个 nginx 漏洞,请先对照第 1 节中的配置表进行检查。
2.1 受影响的版本
CVE-2026-123007 影响了从 1.9.5 到 1.31.8 的每一个官方 nginx 版本。截至 2026 年 11 月 10 日,易受攻击的代码仍存在于开发分支(master)。
2.1.1 受影响的 Linux 发行版
仅看版本号可能无法判断服务器是否已修复。
三大主流 Linux 发行版提供的默认软件包版本最为常见:Ubuntu 24.04 附带 1.24.0,Ubuntu 22.04 提供 1.18.0,Debian 12 提供 1.22.1。这些发行版往往会将安全修复向后移植(backport)到既有版本,而不是直接替换为新的 nginx 版本。
向后移植可以在不改变 nginx -v 所报告版本号的前提下修复漏洞,只有发行版的完整软件包版本号会发生变化。例如,Ubuntu 22.04 最初发布的是 1.18.0-6ubuntu14 ;到 2026 年 10 月 26 日,USN-8955-1 将该软件包提升到 1.18.0-6ubuntu14.22 ,而 nginx 版本仍然是 1.18.0。
要确定某个修复是否已包含在内,需将完整的已安装软件包版本与发行版的安全公告进行比对。
2.2 互联网暴露面
截至 2026 年 11 月 10 日,Shodan 针对 product:nginx 返回了 5670 万台主机。其中 1194 万台(21.1%)报告了可识别的版本。在已确定版本的主机中,98.9% 落在受 CVE-2026-123007 影响的版本区间内(1.9.5 至 1.31.8)。
这些数字基于主机报告的版本字符串,并不能确认服务器是否真的可利用。要利用 CVE-2026-123007 还需要启用 HTTP/2,而报告的版本也可能已经包含向后移植的修复。
2.3 检查暴露面的命令
如果服务器运行未修补的版本、编译时包含 HTTP/2 模块,且配置中启用了 HTTP/2,就会受到 CVE-2026-123007 的影响。下面前三项检查分别验证这三个条件,第四项检查 HTTP/2 是否可从互联网访问。本节末尾的表格说明如何解读合并后的结果。
2.3.1 检查版本
首先,打印 nginx 版本。
nginx -v 2>&1
该命令会输出类似 nginx version: nginx/1.31.8 的版本字符串。
-
1.9.5 至 1.31.8 :官方版本包含易受攻击的代码,继续执行下一项检查。
-
1.9.4 或更早 :发布于 HTTP/2 支持之前,不受影响。
-
1.31.9 或更高 :可能已修复,但请确认构建中包含了 nginx 1.31.9 发布说明中列出的变更。
-
发行版或设备定制版本 :不要仅依赖版本字符串,需确认修复是否已被向后移植。
2.3.2 检查 HTTP/2 模块
检查该二进制文件是否在编译时包含 HTTP/2 模块。
nginx -V 2>&1 | grep -q -- '--with-http_v2_module' \
&& echo 'HTTP2_MODULE=present' \
|| echo 'HTTP2_MODULE=absent'
-
HTTP2_MODULE=present:二进制包含 HTTP/2 代码,若未打补丁则存在漏洞,继续执行下一项检查。 -
HTTP2_MODULE=absent:二进制不含 HTTP/2 代码,不受此漏洞影响。
2.3.3 检查配置中是否启用了 HTTP/2
在配置中搜索启用 HTTP/2 的指令。
sudo nginx -T 2>&1 \
| sed 's/#.*//' \
| grep -nE 'listen[[:space:]].*http2|^[[:space:]]*http2[[:space:]]+on[[:space:]]*;'
若输出 listen 443 ssl http2; 或 http2 on; ,说明 HTTP/2 已启用;无输出则说明未启用。请注意 nginx -T 读取的是磁盘上的配置,如果你修改后尚未重新加载 nginx,实际运行配置可能与磁盘内容不一致。
2.3.4 检查 HTTP/2 是否可从互联网访问
从网络外部的另一台机器运行以下命令。它会在 TLS 握手期间要求服务器协商 HTTP/2。请把两个 {HOST} 占位符替换为你的域名;若未使用 443 端口,同时调整端口。
openssl s_client -connect {HOST}:443 -servername {HOST} -alpn h2 &1 \
| grep -E 'ALPN protocol:|No ALPN negotiated|Connection refused|connect:errno|handshake failure'
-
若看到
ALPN protocol: h2,说明服务器接受来自互联网的 HTTP/2。 -
No ALPN negotiated表示服务器不接受 HTTP/2。 -
其他任何输出都表示连接失败,请先确认服务器可达后重试。
若 nginx 前方有 CDN 或反向代理,该测试只会到达代理层,因此还需直接针对 nginx 服务器本身再执行一次。
按下表解读综合结果。
|
结果
|
评估
|
|---|---|
|
未修补的 1.9.5–1.31.8 +
HTTP2_MODULE=present + 实际 nginx 端口返回 ALPN protocol: h2 |
存在漏洞且对外暴露,需立即处置
|
|
未修补的 1.9.5–1.31.8 +
HTTP2_MODULE=present + HTTP/2 已禁用 |
易受攻击的代码存在,但当前攻击路径已被关闭
|
|
1.9.4 或更早,或
HTTP2_MODULE=absent |
不受此漏洞影响
|
|
已安装 1.31.9,或已确认旧版本中包含向后移植的修复
|
已修补,不再易受攻击
|
|
连接失败、TLS 握手失败或补丁状态不确定
|
无法判定,需进一步审查
|
▍ 3. 响应与建议行动
3.1 立即行动
修复版本可用后,将 nginx 更新到 1.31.9,并确认所安装的版本包含全部五个漏洞的修复。若无法立即修补,请按第 3.3 节为你的配置应用对应缓解措施。请注意,禁用 HTTP/2 只能覆盖五个 nginx 漏洞中的两个。
安装更新后,需重启 nginx 或完成受支持的在线二进制热升级。仅重新加载配置并不会替换正在运行的可执行文件。
3.2 排查可能的攻击痕迹
利用 CVE-2026-123007 的攻击可能在 nginx 访问日志中留下极少痕迹:用于触发漏洞的 WINDOW_UPDATE 与 RST_STREAM 控制帧不会被记录为请求,且在传输过程中由 TLS 加密。以下小节介绍其余四个可排查的位置:连接统计(3.2.1)、按连接统计请求(3.2.2)、worker 启动的进程(3.2.3)以及 worker 崩溃(3.2.4)。第 3.2.5 节说明如何综合权衡这些证据。
3.2.1 检查连接统计
在目标服务器上,检查 443 端口的 TCP 统计信息。
sudo ss -tinp state established '( sport = :443 )'
连续执行两次命令,间隔很短,比较 bytes_received 与 bytes_sent 的变化。重点关注以下特征的连接:
-
来自同一外部 IP 的连接持续保持打开数分钟;
-
bytes_received持续快速增长; -
服务器发出的
bytes_sent远小于接收量; -
同一外部 IP 同时建立大量短命的 TLS 连接。
这些模式与我们测试中的攻击相符:它通过一条长连接发送大量 WINDOW_UPDATE 帧,因此 bytes_received 不断攀升而 nginx 几乎不发送数据;同时它还会从同一 IP 建立许多短命 TLS 连接。如果同时看到这两种现象并持续数分钟,且没有合理解释(例如大规模上传),应阻断来源并展开调查。
3.2.2 按连接审计请求
默认访问日志不显示每个请求属于哪条连接。下面的日志格式增加了连接 ID( conn )、该连接上的请求数量以及每个请求的大小。将其加入 nginx 的 http 块,不需要调试版本。
log_format h2_hunt '$time_iso8601 src=$remote_addr conn=$connection '
'requests=$connection_requests proto=$server_protocol '
'status=$status request_length=$request_length '
'bytes_sent=$bytes_sent request_time=$request_time';
access_log /var/log/nginx/h2-hunt.log h2_hunt;
校验并重新加载配置,然后只筛选 HTTP/2 请求。
sudo nginx -t && sudo nginx -s reload
sudo grep 'proto=HTTP/2.0' /var/log/nginx/h2-hunt.log | tail -n 200
从 3.2.1 中挑出一个可疑 IP,按 conn 汇总其日志条目的 request_length ,再与 ss 显示的同一 IP 的 bytes_received 对比。如果 bytes_received 持续快速增长,而记录到的请求长度始终很小,说明客户端发送了大量从未以请求形式出现的数据——这与 HTTP/2 控制帧洪水相符,也正是攻击中的表现。同一时段内异常偏大的 request_time 是另一个信号。
3.2.3 监控 worker 的命令执行
我们的利用链通过 execve() 启动 shell 或其他程序。正常的 nginx worker 没有任何理由运行外部程序,因此它启动的任何进程都需要立即调查。首先确定 worker 账号的 UID。
ps -eo uid,user,pid,ppid,args | grep '[n]ginx: worker process'
在使用 Linux 审计子系统 auditd 的系统上,将 NGINX_UID 替换为上面输出中的数字 UID,并添加如下规则。
sudo auditctl -a always,exit -F arch=b64 -S execve,execveat \
-F euid=NGINX_UID -k nginx_worker_exec
该规则只记录安装之后的执行事件,空结果不能排除此前已发生的入侵。它也会匹配使用同一 UID 的其他进程,因此需检查进程 ID 与父进程 ID,判断事件是否确实源自 nginx。
通过以下方式查看记录:
sudo ausearch -k nginx_worker_exec -ts recent -i
重点关注 /bin/sh 、 /bin/bash 以及任何由 nginx worker 启动的程序。如果同一账号下还运行着其他应用,请对照你的服务配置逐个检查事件的父进程,判断哪些来自 nginx。
3.2.4 检查 worker 异常退出
失败的利用尝试可能导致 nginx worker 崩溃,用以下命令查找异常退出与核心转储。
sudo grep -Ei 'worker process.*exited|signal 11|segfault' /var/log/nginx/error.log
sudo coredumpctl list nginx
worker 也可能因与攻击无关的原因崩溃。在得出结论前,请将这些记录与其他信号交叉比对。
3.2.5 评估证据
由 nginx worker 启动的进程(3.2.3)是攻击成功最明确的迹象,应立即调查。以下迹象相对较弱,每一个都可能有正常的成因;但如果多个迹象同时出现且你无法解释,应阻断来源并展开调查:
-
持续的高入站流量(3.2.1);
-
来自同一来源的大量连接(3.2.1);
-
实际接收字节与记录的请求长度之间存在巨大差距(3.2.2);
-
worker 反复异常退出(3.2.4)。
3.3 修补前的紧急缓解
在补丁可用之前,禁用受影响的功能即可阻断已知的攻击路径。这些措施都是临时的,修复版本到位后请立即安装。
3.3.1 禁用 HTTP/2(CVE-2026-123007 与 CVE-2026-123633)
这两个漏洞都出现在 nginx 处理 HTTP/2 连接的过程中。在安装补丁前,请在受影响端口上禁用 HTTP/2。支持 HTTP/1.1 的客户端可以继续使用服务,但依赖 HTTP/2 的服务(例如原生 gRPC)会受到影响。
对于 nginx 1.25.1 及更高版本,在每个受影响的 server 块中写入 http2 off; ,并从其 listen 指令中移除任何遗留的 http2 参数。请检查所有共享同一监听地址与端口的 server 块。
listen 443 ssl;
http2 off;
对于 nginx 1.9.5 至 1.25.0,从 listen 443 ssl http2; 中移除 http2 。
listen 443 ssl;
校验并重新加载配置,然后重复 2.3.4 节的 HTTP/2 检查,确认修改生效。
sudo nginx -t
sudo nginx -s reload
openssl s_client -connect HOST:443 -servername HOST -alpn h2 &1 | grep -F 'ALPN protocol: h2'
一旦 HTTP/2 被禁用,最后一条命令将不再输出任何内容。但连接失败时同样没有输出,因此请确认站点仍能通过 HTTPS 正常加载。
3.3.2 移除请求时的 DNS 查询(CVE-2026-123634)
该缓解适用于所有在请求期间选择上游(后端)并使用 mirror 的服务器。当 proxy_pass 中包含变量(例如 proxy_pass http://$host; ),且 nginx 在处理请求时通过 resolver 对该名称进行 DNS 查询时,就会触发该场景。
当主请求与其镜像在等待同一个 DNS 响应时,错误被触发。在安装补丁前,请将 proxy_pass 指向固定的 upstream 组,从而消除请求期间的 DNS 查询,阻断我们测试的这条路径。
将 mirror_request_body on 也能阻止我们的利用,但它并不能修复解析器错误,因此不要只依赖这一设置。
如果你不需要镜像,在受影响 location 中关闭它,并将 proxy_pass 指向固定上游。将 {BACKEND_IP} 替换为后端 IP 地址,必要时调整端口。
upstream backend_hotfix {
server {BACKEND_IP}:8080;
}
location / {
mirror off;
proxy_pass http://backend_hotfix;
}
如果你需要镜像,请为主请求和镜像分别使用固定的 upstream 组。下面的示例将二者发送到不同的后端;若两者使用同一后端,将它们指向同一个固定组即可。
upstream backend_main_hotfix {
server [MAIN_SERVER_IP]:8080;
}
upstream backend_mirror_hotfix {
server [MIRROR_SERVER_IP]:8080;
}
location / {
mirror /mirror;
proxy_pass http://backend_hotfix;
}
location = /mirror {
internal;
proxy_pass http://backend_mirror_hotfix;
}
校验并重新加载配置:
sudo nginx -t
sudo nginx -s reload
3.3.3 禁用 HTTP/3(QUIC)(CVE-2026-121810)
该漏洞位于 nginx 处理 QUIC 连接上 HTTP/3 请求流的方式中,因此在安装补丁前,请从受影响的服务中移除 QUIC 监听器。
在每个受影响的 server 块中,删除包含 quic 的 listen 指令,设置 http3 off ,并将任何通告 HTTP/3 的 Alt-Svc 响应头替换为 Alt-Svc 'clear' 。TCP 上的普通 TLS 监听器保持不变,最终配置大致如下:
listen 443 ssl;
# listen 443 quic reuseport;
# listen [::]:443 quic reuseport;
http3 off;
add_header Alt-Svc 'clear' always;
校验并重新加载配置,然后检查 443 端口是否仍有进程接受 UDP 流量(必要时调整端口):
sudo nginx -t && sudo nginx -s reload
sudo ss -lunp 'sport = :443'
如果输出中仍显示 nginx,说明 QUIC 监听器仍然活跃。为加强防护,还应在防火墙层面阻断该端口的 UDP。
3.3.4 限制对邮件代理的访问(CVE-2026-113425)
该缓解仅在以 nginx 作为 IMAP、POP3 或 SMTP 服务器的前置代理时适用。如果 mail 块在启用 proxy on 的同时使用 auth_http ,你将受到影响。使用 auth_http 时,nginx 会向一个 HTTP 服务询问每次登录是否有效;错误在登录阶段触发,攻击者无需持有有效凭据。在安装补丁前,请让不受信任的客户端远离邮件代理。
如果代理不需要对外访问,可将每个 IMAP、POP3 和 SMTP 监听器绑定到回环地址,这样只有同一台机器上的程序能够连接。远程客户端(例如用户的邮件应用)将无法再访问代理。示例:
listen 127.0.0.1:143;
校验并重新加载配置,然后确认邮件端口不再监听外部地址:
sudo nginx -t && sudo nginx -s reload
sudo ss -ltnp | grep -E ':(25|110|143|465|587|993|995)([[:space:]]|$)'
该命令检查标准邮件端口;若你的端口不同,请自行添加。如果确实需要外部客户端访问代理,请使用防火墙仅放行你信任的 IP。
3.3.5 关闭既有连接
重新加载只会把新配置应用于新建立的连接。已经打开的连接(例如 HTTP/2 或邮件会话)仍会留给旧 worker,继续使用旧配置;这些 worker 会显示为 nginx: worker process is shutting down 。
如果此类 worker 在重新加载后仍然存在,请通过服务管理器重启 nginx(例如 systemctl restart nginx )。重启会强制断开所有客户端连接,中断正在进行的下载、上传和邮件会话,因此预计会有短暂的服务中断。
▍ 4. 发现与披露时间线
对 nginx 而言,一次性地发现五个远程代码执行漏洞并不寻常。在二十余年的安全研究中,nginx 的未认证 RCE 极为罕见,其中一例是 CVE-2013-2028——一个由精心构造的 HTTP 请求触发的栈缓冲区溢出。
今年发现更多 nginx 漏洞的并非只有我们。2025 年,nginx 官方安全公告页面记录了 2 个新漏洞;截至今年 11 月 17 日,该页面已记录 26 个(不含 nginx2root),还有若干内存破坏类错误,例如缓冲区溢出和释放后使用(use-after-free)。AI 辅助的漏洞研究正以前所未有的速度发现问题,即便在 nginx 这类被大量研究的代码中也是如此。借助 nginx2root,Xint 一次性又贡献了五个。
下面的时间线涵盖发现、披露与预定发布节点,所有日期均为协调世界时(UTC+0)。
|
日期
|
事件
|
|---|---|
|
2026-10-11
|
Xint 研究团队发现漏洞
|
|
2026-10-16
|
通过 HackerOne 向 F5 报告
|
|
2026-10-20
|
HackerOne 完成验证
|
|
2026-10-27
|
报告交付 F5 nginx 开发团队
|
|
2026-11-09
|
nginx 团队请求进行补丁验证
|
|
2026-11-10
|
Xint 研究团队完成补丁验证
|
|
2026-11-18
|
计划发布补丁
|
▍ 5. nginx 漏洞技术分析
本节逐一分析五个 nginx 漏洞。CVE-2026-123007 起源于发送窗口算术中的错误,最终导致越界写入;其余四个均为释放后使用漏洞。针对每个漏洞,我们说明相关的 nginx 功能与行为,追踪错误背后的代码,并概述其如何导致远程代码执行。我们会解释如何实现地址泄露与受控的内存破坏,但会有意省略复现完整利用所需的最后步骤。
5.1 CVE-2026-123007
CVE-2026-123007 是 HTTP/2 流控中的整数溢出漏洞。让发送窗口超过其允许的最大值,最终会产生无效的内存拷贝长度,导致堆上的越界读取与越界写入。
5.1.1 nginx 如何管理 HTTP/2 发送窗口
HTTP/2 通过单条连接承载多个请求与响应,每个请求/响应对使用一个流。客户端创建的流获得不同标识符(如 1、3、5),即流 ID。在每个流中,HEADERS 帧承载头部,DATA 帧承载正文。
HTTP/2 使用流控来防止服务器发送超过客户端准备接收的数据。服务器通过发送窗口跟踪可用额度:每个流一个,外加整个连接一个(下文称为 h2c 窗口)。每个窗口记录服务器可能仍可发送的数据量。只有当流窗口与 h2c 窗口都有足够额度时,服务器才能在该流上发送数据。当客户端准备接收更多数据时,会发送 WINDOW_UPDATE 帧,服务器据此为对应窗口增加相应数量。
WINDOW_UPDATE 中的流 ID 决定哪个窗口被增加:流 ID 0 更新 h2c 窗口,非零流 ID 只更新该流的窗口。
nginx 使用的默认窗口为 65,535( 0xffff ),最大值为 0x7fffffff ( (1U << 31) - 1 )。
// https://github.com/nginx/nginx/blob/140aa942711868a8daeb95810bc9a81f272ada72/src/http/v2/ngx_http_v2.h#L50-L51
#define NGX_HTTP_V2_MAX_WINDOW ((1U << 31) - 1)
#define NGX_HTTP_V2_DEFAULT_WINDOW 65535
在通过套接字发送之前,nginx 会把待发出的帧保存在内存输出队列中。当它排队响应数据时, ngx_http_v2_send_chain() 会从连接级发送窗口 h2c->send_window 和流级发送窗口 stream->send_window 中扣除数据长度。
// https://github.com/nginx/nginx/blob/140aa942711868a8daeb95810bc9a81f272ada72/src/http/v2/ngx_http_v2_filter_module.c#L1232-L1244
ngx_http_v2_queue_frame(h2c, frame);
h2c->send_window -= frame_size;
stream->send_window -= frame_size;
stream->queued++;
如果流在数据发出之前被取消, ngx_http_v2_filter_cleanup() 会从队列中移除该流剩余的 DATA 帧,并把已扣除的长度归还给连接级发送窗口。
// https://github.com/nginx/nginx/blob/140aa942711868a8daeb95810bc9a81f272ada72/src/http/v2/ngx_http_v2_filter_module.c#L1719-L1767
h2c->send_window += window;
排队数据时扣除额度、流被取消时归还额度,这两个步骤本身都是正确的。问题在于中间发生了什么:当数据仍处于排队状态时,客户端可以发送 WINDOW_UPDATE 再次抬高窗口。若该流随后被取消,清理逻辑会把归还的额度叠加在已被抬高的窗口之上。清理逻辑从不检查结果是否超过 HTTP/2 最大值,因此 h2c->send_window 最终可能高于其允许的上限。
5.1.2 漏洞细节
从窗口记账错误到命令执行的完整链条概述如下。第(1)(2)小节覆盖步骤 1–2,第(3)小节覆盖步骤 3 及其后的高级步骤。
|
步骤
|
描述
|
|---|---|
|
在队列中保留数据
|
排队响应正文并从发送窗口中扣除其长度,同时阻止数据到达客户端
|
|
抬高窗口,归还排队数据的额度
|
通过
WINDOW_UPDATE 增加发送窗口,然后取消该流,使清理逻辑把为排队数据扣除的额度加回来 |
|
绕过上限检查
|
共享连接窗口一旦超过最大值,剩余容量计算就会失效,后续
WINDOW_UPDATE 帧仍会被接受 |
|
构造异常的拷贝长度
|
代码把同一组比特分别按有符号与无符号解读,将很小的负数偏移转换为极大的拷贝长度
|
|
泄露地址并破坏内存
|
定位拷贝两端,在响应中返回内存指针,并破坏 TLS 分配元数据
|
|
控制清理回调
|
利用泄露的地址与已破坏的内存覆盖清理函数指针,在清理调用时执行任意命令
|
(1)归还排队额度时突破 31 位上限
第一个目标是在 nginx 输出队列中构造出「已消耗窗口额度但尚未发送」的数据。
客户端首先在流 ID 0 上发送 WINDOW_UPDATE ,把连接发送窗口提升到最大值(Wmax)。接着通过 SETTINGS 帧中的 SETTINGS_INITIAL_WINDOW_SIZE 为新流设置初始发送窗口,将其设为 0 可以让 nginx 生成响应头部却无法发送数据,从而使响应正文一直挂起,直到客户端决定释放。
随后,客户端停止读取并突发发送 PING 帧。nginx 会把控制帧响应(包括 PING ACK)排入待发数据之前,这些 ACK 因此填满 TLS 与 TCP 发送缓冲区。然后客户端为每个流发送足以覆盖其整个响应正文的 WINDOW_UPDATE 额度,使 nginx 排队数据并从连接发送窗口中扣除相应长度。由于 TLS 与 TCP 缓冲区已满,这些数据将无限期处于排队状态。
设 Q 为该排队数据总量。客户端现在把 Q 两次加回 h2c 窗口:先在流 ID 0 上发送 WINDOW_UPDATE ,授予 Q 的额度;再发送 RST_STREAM 取消该流,取消触发清理,丢弃未发送数据并归还其额度,再次把 Q 加到 h2c 窗口。
// https://github.com/nginx/nginx/blob/140aa942711868a8daeb95810bc9a81f272ada72/src/http/v2/ngx_http_v2_filter_module.c#L1723-L1767
if (frame->stream == stream && !frame->blocked) {
*fn = frame->next;
window += frame->length;
}
h2c->send_window += window;
上面最后一行所示的第二次加回没有任何上限检查。因此 h2c 窗口依次经历四个值:
-
Wmax :客户端把窗口提升到最大值;
-
Wmax – Q :排队数据扣除 Q;
-
Wmax :流 ID 0 上的
WINDOW_UPDATE归还 Q; -
Wmax + Q :清理逻辑第二次归还 Q,把窗口推到 31 位上限之外。
具体的响应大小与流数量并不重要,关键在于同一个已知量 Q 被加了两次——一次通过 WINDOW_UPDATE ,一次通过清理逻辑。
(2)窗口检查中的无符号下溢
ngx_http_v2_state_window_update() 在应用增量之前会先计算剩余容量。
// https://github.com/nginx/nginx/blob/140aa942711868a8daeb95810bc9a81f272ada72/src/http/v2/ngx_http_v2.c#L2564-L2575
if (window > NGX_HTTP_V2_MAX_WINDOW - h2c->send_window) {
return ngx_http_v2_connection_error(h2c,
NGX_HTTP_V2_FLOW_CTRL_ERROR);
}
h2c->send_window += window;
这项检查只有在共享连接窗口处于或低于 Wmax 时才有效。 h2c->send_window 的类型为无符号 size_t ,上一步已将其变成 Wmax + Q 。于是剩余容量表达式 Wmax - (Wmax + Q) 若按有符号数解读本应为负,但无符号运算会将其回绕成一个非常大的正值。
nginx 据此认为仍有可用容量,并继续接受该连接上的 WINDOW_UPDATE 帧。每一个增量本身仍然符合 HTTP/2 规范,但这项检查已无法察觉当前窗口早已超出有效范围。重复此过程,可以把发送窗口提升到任意 64 位值。
(3)从超大窗口到越界拷贝
h2c->send_window 是无符号 size_t 。在 64 位目标上,把它增加到例如 2^64 - d ,作为无符号数看起来极大,但转换成有符号的 off_t 后就是一个很小的负数 -d 。
ngx_http_v2_send_chain() 会把该值并入 DATA 帧大小。它先比较发送窗口与 limit ,即本次调用最多可能发送的量。
// https://github.com/nginx/nginx/blob/140aa942711868a8daeb95810bc9a81f272ada72/src/http/v2/ngx_http_v2_filter_module.c#L1144-L1146
if (limit == 0 || limit > (off_t) h2c->send_window) {
limit = h2c->send_window;
}
正的 limit 大于 -d ,条件成立, limit 于是变为 -d 。
下一个比较使用 frame_size (当前 DATA 帧大小)与 limit 。
// https://github.com/nginx/nginx/blob/140aa942711868a8daeb95810bc9a81f272ada72/src/http/v2/ngx_http_v2_filter_module.c#L1163-L1166
if ((off_t) frame_size > limit) {
frame_size = (size_t) limit;
}
正的 frame_size 大于 -d ,条件同样成立。把 -d 转换为 size_t 会得到 2^64 - d ,于是正常的数据大小被替换成一个极大的值。
nginx 把该值保存到 rest (用于跟踪尚未附加到缓冲区的长度),然后将它传给 ngx_http_v2_filter_get_shadow() ,由后者设置缓冲区的起止指针。
// Call site: https://github.com/nginx/nginx/blob/140aa942711868a8daeb95810bc9a81f272ada72/src/http/v2/ngx_http_v2_filter_module.c#L1169-L1207
// Implementation: https://github.com/nginx/nginx/blob/140aa942711868a8daeb95810bc9a81f272ada72/src/http/v2/ngx_http_v2_filter_module.c#L1287-L1308
rest = frame_size;
cl = ngx_http_v2_filter_get_shadow(stream, in->buf, offset, rest);
static ngx_chain_t *
ngx_http_v2_filter_get_shadow(ngx_http_v2_stream_t *stream, ngx_buf_t *buf,
off_t offset, off_t size)
{
chunk->last = chunk->pos + size;
}
作为 off_t , size 持有 -d ,因此 chunk->last 指向 chunk->pos 之前 d 字节处。TLS 输出路径随后会把这两个指针之差作为拷贝长度。
// Declaration: https://github.com/nginx/nginx/blob/140aa942711868a8daeb95810bc9a81f272ada72/src/event/ngx_event_openssl.c#L3054-L3057
// Copy path: https://github.com/nginx/nginx/blob/140aa942711868a8daeb95810bc9a81f272ada72/src/event/ngx_event_openssl.c#L3137-L3150
ssize_t size;
size = in->buf->last - in->buf->pos;
ngx_memcpy(buf->last, in->buf->pos, size);
last - pos 等于 -d ,但 memcpy() 的长度参数是 size_t ,最终转换又把它变回 2^64 - d ,于是传入了一个极大的拷贝长度。
接近 2^64 字节的拷贝通常会越过堆末尾并导致 worker 崩溃——但这里没有,原因在于 glibc 处理大块拷贝的方式。我们实验中使用的 x86-64 glibc memcpy() 路径并非从前向后复制:它先加载源的开头和结尾,再在循环中复制中间部分,方向是从目标末尾向前推进。
目标末尾是 dest + size 。当 size = 2^64 - d 时,该和在 64 位地址空间中溢出并回绕到 dest - d ,即位于 dest 之下 d 字节处。由于末尾现在位于起点之下,反向循环只跑一遍即停止,中间的大片区域从未被触及。这种每次迭代搬运四个 32 字节向量的反向拷贝结构,自 2016 年发布的 glibc 2.24 起就存在于 x86-64 实现中。
glibc 2.41 的 AVX2 路径简化后如下:
head = load128(src)
tail = load32(src + size - 32)
end = (dest + size) mod 2^64
cursor = align_down(end - 129, 32)
do {
copy128(dst=cursor, src=src + (cursor - dest))
cursor -= 128
} while (cursor > dest)
store128(dst=dest, data=head)
store32(dst=end - 32, data=tail)
align_down(x, 32) 把 x 向下取整到 32 字节边界。当 end 按 32 字节对齐时(如下例), cursor = align_down(end - 129, 32) 变为 end - 160 。glibc 从该位置复制 128 字节,并单独复制最后 32 字节。
end - 160 end - 32 end
|---------- 128 bytes ----------|------ 32 bytes -----|
循环拷贝 固定拷贝
由于 cursor 已在 dest 之下,循环只执行一次。跳过中间大段区域后,只剩前 128 字节和末尾 160 字节需要拷贝:
src ~ src + 127 -> dest ~ dest + 127
src - d - 160 ~ src - d - 1 -> dest - d - 160 ~ dest - d - 1
dest 是 TLS 明文缓冲区中的下一个写入位置,因此它恰好落在 nginx 已写入内容的末尾之后。在响应正文之前,nginx 会为客户端的控制帧写入确认,而这些确认的数量由客户端控制。在 nginx 源码中,HTTP/2 帧头为 9 字节,PING 数据为 8 字节,SETTINGS ACK 数据为 0 字节。
// https://github.com/nginx/nginx/blob/140aa942711868a8daeb95810bc9a81f272ada72/src/http/v2/ngx_http_v2.h#L27
#define NGX_HTTP_V2_FRAME_HEADER_SIZE 9
// https://github.com/nginx/nginx/blob/140aa942711868a8daeb95810bc9a81f272ada72/src/http/v2/ngx_http_v2.c#L30-L34
#define NGX_HTTP_V2_SETTINGS_ACK_SIZE 0
#define NGX_HTTP_V2_PING_SIZE 8
因此,一个不带 ACK 标志的 PING 会产生 17 字节的 PING ACK,SETTINGS 则产生 9 字节的 SETTINGS ACK。若客户端发送 p 个 PING 帧和 s 个 SETTINGS 帧,nginx 首先会生成 17p + 9s 字节的响应;再加上紧随其后的 9 字节 DATA 帧头,就得到下一个响应正文的起始位置。
P = 17p + 9s + 9
dest = TLS + P
客户端通过 WINDOW_UPDATE 调整发送窗口,使 d = P - 64 。拷贝终止于 dest - d ,于是变成 TLS + 64 。这样一来,那 160 字节区域跨越了 TLS 缓冲区之前的 96 字节与其内部的前 64 字节。
第二个动作把 src - d 之下的 160 字节复制到 TLS 缓冲区边界。攻击者想从中获得两样东西:一个用于覆盖 TLS 缓冲区之前堆元数据的选定值,以及一个落在缓冲区内、会随响应回传的指针。请求内存池中两者兼有:它既包含请求头部,也包含描述这些头部、并指向 nginx 映像与堆的 nginx 结构体。为了让 src 指向那里,攻击者发送 Range 头请求若干字节区间,nginx 便会构造一个 multipart 响应,该响应从请求池中分配的 boundary 字符串开始, src 因此指向该处。
// https://github.com/nginx/nginx/blob/140aa942711868a8daeb95810bc9a81f272ada72/src/http/modules/ngx_http_range_filter_module.c#L484-L505
ctx->boundary_header.data = ngx_pnalloc(r->pool, size);
// https://github.com/nginx/nginx/blob/140aa942711868a8daeb95810bc9a81f272ada72/src/http/modules/ngx_http_range_filter_module.c#L867-L882
b->pos = ctx->boundary_header.data;
这个 b->pos 在流出输出路径时会变成 in->buf->pos ,也就是最终 memcpy() 使用的 src 。
在请求池中确定 src 后,攻击者用 Cookie 字段填充 src - d 之下的 160 字节。当同一请求包含多个 Cookie 字段时,nginx 会在计算总长度时为每个分隔符加 2 字节,随后用 "; " 拼接各值,并把长度与合并后缓冲区的地址存入请求头结构体。
// https://github.com/nginx/nginx/blob/140aa942711868a8daeb95810bc9a81f272ada72/src/http/v2/ngx_http_v2.c#L3725-L3769
len += vals[i].len + 2;
len -= 2;
h->key.data = cookie.data;
h->value.len = len;
h->value.data = buf;
h->key.data 指向 nginx 映像中的静态字符串,而 h->value.data 指向堆上的 Cookie 缓冲区。于是该结构体既包含攻击者控制的长度,也包含指向 nginx 映像和堆的指针。
如果当前请求池块空间充足,nginx 会紧接上一个分配之后放置新的小分配。
// https://github.com/nginx/nginx/blob/140aa942711868a8daeb95810bc9a81f272ada72/src/core/ngx_palloc.c#L157-L166
m = p->d.last;
if ((size_t) (p->d.end - m) >= size) {
p->d.last = m + size;
return m;
}
Cookie 的数量与长度控制数据及其布局,Range 头与 URI 长度则用于定位作为 src 的 multipart 缓冲区。这样一来, src - d 之前的 160 字节可以被布置成如下形态:
源: [96 字节,含用于 size 字段的取值][64 字节的代码与堆指针]
目标: [TLS 缓冲区之前的 96 字节,含堆元数据][TLS 明文缓冲区的前 64 字节]
前 96 字节覆盖了 TLS 明文缓冲区之前堆区域中的 size 字段;剩下 64 字节随 TLS 响应发出,泄露 nginx 映像地址与堆地址。于是一次错误拷贝同时提供了越界写入与地址泄露。这些能力可用于覆盖清理函数指针,并以 nginx worker 权限执行命令。此处省略函数指针覆盖的详细过程。
5.1.3 可利用性验证
仅依靠对外可访问的 TLS/HTTP/2 端口,我们演示了未经认证的远程代码执行:该漏洞破坏了发送窗口、泄露了 nginx 映像与堆地址,并控制了清理函数,从而以 nginx worker 权限执行命令。
验证结果
Xint 研究团队确认,该利用在存在正常并发流量时、以及不同硬件规格的服务器上均有效。在 AWS、GCP 与 Azure 上,我们分别从目标服务器内部、经由独立的发送方与目标主机之间的专用网络、以及通过公网 HTTPS 端点三种方式完成验证。
|
云平台
|
目标服务器内部
|
专网 / VPC / VNet
|
公网 IP
|
|---|---|---|---|
|
AWS
|
成功
|
成功
|
成功
|
|
GCP
|
成功
|
成功
|
成功
|
|
Azure
|
成功
|
成功
|
成功
|
5.2 CVE-2026-123634
CVE-2026-123634 是 nginx DNS 解析器逻辑中的释放后使用。某个请求的处理程序可以释放另一个仍被等待列表循环待处理、尚未访问的解析器上下文,随后继续使用已释放的内存。
5.2.1 nginx 如何在请求时解析上游名称
nginx 可以作为反向代理,把客户端请求转发给后端服务器(上游)处理。 proxy_pass 配置指令指定上游位置。
上游既可以在配置中固定,也可以来自请求。例如 proxy_pass http://$host; 使用 $host 中的请求主机名作为目标,该值通常来自客户端的 Host 头。如果 nginx 需要 DNS 查询来获取服务器 IP,它会向 resolver 指令指定的 DNS 服务器查询。
由于 DNS 解析需要时间,nginx 在等待 DNS 响应期间会继续处理其他请求。每次查询都有一个解析器上下文( ngx_resolver_ctx_t ),其中包含状态、结果以及查询完成后被调用的 handler 。
解析器以节点为单位跟踪每个域名。如果同一名称的查询已在飞行中,nginx 不会发送第二个查询,而是把新上下文插到该节点等待列表的头部。
当答案最终到达,解析器通过把 rn->waiting 置为 NULL 将等待列表从节点上摘下,然后遍历列表并逐个调用上下文的 handler,每次调用前保存下一个上下文。
// https://github.com/nginx/nginx/blob/140aa942711868a8daeb95810bc9a81f272ada72/src/core/ngx_resolver.c#L2131-L2147
next = rn->waiting;
rn->waiting = NULL;
...
while (next) {
ctx = next;
ctx->state = code;
ctx->valid = ngx_time() + (r->valid ? r->valid : 10);
next = ctx->next;
ctx->handler(ctx);
}
因此,若释放了列表中后续上下文, next 就会成为悬垂指针。不过,仅靠单个请求无法造成这一点,因为终止请求只会释放它自己的上下文。所以只有当两个上下文来自同一请求时,才是真正的错误。
在测试中,我们只发现一个配置选项会为同一请求创建两个上下文: mirror 配置指令会以后台子请求的形式把请求复制到第二个位置,常用于向测试系统发送线上流量副本。如果主请求与其镜像使用相同的上游名称,它们的上下文就可能在同一节点上一起等待 DNS 响应。
5.2.2 漏洞细节
(1)终止主请求释放了镜像的上下文
如果 DNS 查询失败,主请求的 ngx_http_upstream_resolve_handler() 会尝试发送 502 响应。若客户端重置了 TCP 连接,写入可能失败,进而由 ngx_http_terminate_request() 终止主请求。
主请求的清理列表包含镜像的上游清理项,因此下面的清理代码也会作用于镜像,即使其 DNS 结果尚未被处理。
// https://github.com/nginx/nginx/blob/140aa942711868a8daeb95810bc9a81f272ada72/src/http/ngx_http_upstream.c#L4802-L4805
if (u->resolved && u->resolved->ctx) {
ngx_resolve_name_done(u->resolved->ctx);
u->resolved->ctx = NULL;
}
随后 ngx_resolve_name_done() 释放了镜像的上下文,而解析器循环仍在 next 中保留着它。
(2)解析器使用已释放的上下文
在循环抵达之前,镜像的上下文仍处于 NGX_AGAIN 状态。在释放处于该状态的上下文之前, ngx_resolve_name_done() 会尝试把它从节点等待列表中摘除。但循环已经摘下了整个列表并把 rn->waiting 设为 NULL,因此搜索不到任何内容,上下文仍会被释放。
// https://github.com/nginx/nginx/blob/140aa942711868a8daeb95810bc9a81f272ada72/src/core/ngx_resolver.c#L554-L595
if (ctx->state == NGX_AGAIN || ctx->state == NGX_RESOLVE_TIMEDOUT) {
rn = ctx->node;
if (rn) {
p = &rn->waiting;
w = rn->waiting;
while (w) {
...
}
ngx_log_error(NGX_LOG_ALERT, r->log, 0,
"could not cancel %V resolving", &ctx->name);
}
}
done:
...
ngx_resolver_free_locked(r, ctx);
随后控制权返回解析器循环,循环进入 next 中保存的、即镜像那个已释放的上下文,通过写入 ctx->state 、 ctx->valid ,读取 ctx->next ,并调用 ctx->handler(ctx) 触发释放后使用。如果其他分配回收了这块已释放上下文的内存, next 与 handler 都将由攻击者控制,攻击者因此可以重定向列表遍历与最终的间接调用,从而控制程序执行。
要执行任意代码,首先需要地址泄露。有意思的是,该漏洞本身即可用于泄露:glibc 的空闲链表指针会覆盖上下文的 next 字段,于是循环认定的下一个「上下文」就是一块已被释放、内容可由我们选择的 DNS 记录数组。接着我们采用一个技巧:把受控的 handler 指向 vsyscall 的 gettimeofday() 地址(在 amd64 系统上该地址固定),伪造一个堆块 size,并把 glibc 与堆指针放进由 nginx 发往我们控制的服务器的一条 DNS 查询中。
完成信息泄露后,我们可以让循环经由该数组链接到挂起请求正文中的一个伪上下文,将其 handler 设为 system() ,从而在主机上执行任意命令。
5.2.3 可利用性验证
|
项目
|
结果
|
|---|---|
|
目标
|
官方 nginx:1.31.8 镜像,
server 块使用请求时 DNS 解析,并在默认配置中加入 mirror |
|
入口
|
8080 端口上的 HTTP,以及攻击者权威区的 DNS 响应
|
|
认证
|
无
|
|
网络要求
|
nginx 的递归解析器必须能到达攻击者的权威 DNS 服务器
|
|
主机内核
|
Ubuntu Linux 6.8(x86-64),
vsyscall=xonly |
|
结果
|
以 nginx worker 权限实现远程代码执行
|
5.3 CVE-2026-123633
CVE-2026-123633 是一个由「仍然符合排水(drain)条件的活动 HTTP/2 连接」引发的释放后使用。当请求打开上游连接时,nginx 可能关闭该请求自身所在的 HTTP/2 连接并释放其内存,而上游代码随后仍在访问它。该漏洞要求 nginx 打开上游连接,这在生产环境中十分常见。
5.3.1 nginx 如何在资源压力下复用连接
每个 nginx worker 拥有固定数量的连接槽位,由 worker_connections 决定,客户端连接与上游连接共享这些槽位。槽位不足时,nginx 会关闭空闲连接以回收再用。为跟踪哪些连接可以回收,nginx 在连接满足某些协议特定条件时(例如空闲的 HTTP/1.1 keep-alive 连接,或没有活动流的 HTTP/2 连接)将其标记为 reusable(可复用),这些连接被记录在专用队列中。
在分配槽位前,如果空闲槽位不足 1/16 且可复用队列非空, ngx_get_connection() 会调用 ngx_drain_connections() ,从最老的条目开始关闭连接,这一过程称为「排水」(drain)。
排水会设置 c->close ,并直接调用选中连接的读事件处理程序。这些调用是同步的,只有当处理程序返回后,槽位分配才会继续。
// https://github.com/nginx/nginx/blob/140aa942711868a8daeb95810bc9a81f272ada72/src/core/ngx_connection.c#L1411-L1442
if (cycle->free_connection_n > cycle->connection_n / 16
|| cycle->reusable_connections_n == 0)
{
return;
}
...
n = ngx_max(ngx_min(32, cycle->reusable_connections_n / 8), 1);
for (i = 0; i < n; i++) {
...
q = ngx_queue_last(&cycle->reusable_connections_queue);
c = ngx_queue_data(q, ngx_connection_t, queue);
...
c->close = 1;
c->read->handler(c->read);
}
5.3.2 漏洞细节
(1)活动的 HTTP/2 连接被留在可复用队列中
当 HTTP/2 连接没有活动流或待发帧时, ngx_http_v2_handle_connection() 会把它排入可复用队列。如果最后一次读取在帧中间中断,则会被设置 h2c->state.incomplete ,但该标志是在连接被放入队列之后才检查的:
// https://github.com/nginx/nginx/blob/140aa942711868a8daeb95810bc9a81f272ada72/src/http/v2/ngx_http_v2.c#L628-L674
if (h2c->last_out || h2c->processing) {
return;
}
...
ngx_reusable_connection(c, 1);
if (h2c->state.incomplete) {
return;
}
正常情况下,空闲连接的读处理程序会被替换为 ngx_http_v2_idle_handler() ,在数据到达时把连接从队列中移出。但当 ngx_http_v2_handle_connection 因帧不完整而提前返回时,连接会保留原有的 ngx_http_v2_read_handler() ,而它从不把连接从可复用队列中移除。
因此,缺陷的触发过程如下:
-
客户端发送 HEADERS 帧的前半部分,使连接进入可复用队列;
-
客户端发送其余部分,从而打开一个流;
-
若该请求打开上游连接并触发排水,排水就可能收回这个承载新流的连接。
(2)上游连接释放了自己的请求
要访问上游,请求需要另一个连接槽位。 ngx_event_connect_peer() 调用 ngx_get_connection() ;若槽位不足,就会执行排水。此时可复用队列中的 HTTP/2 连接便可能被选中关闭。
HTTP/2 读处理程序看到 c->close 后会尝试发送 GOAWAY,但如果客户端已重置 TCP 连接,写入将失败, ngx_http_v2_finalize_connection() 便会关闭该连接及其流。
// https://github.com/nginx/nginx/blob/140aa942711868a8daeb95810bc9a81f272ada72/src/http/v2/ngx_http_v2.c#L356-L382
if (c->close) {
c->close = 0;
...
if (!h2c->goaway) {
h2c->goaway = 1;
if (ngx_http_v2_send_goaway(h2c, NGX_HTTP_V2_NO_ERROR)
== NGX_ERROR)
{
ngx_http_v2_finalize_connection(h2c, 0);
return;
}
if (ngx_http_v2_send_output_queue(h2c) == NGX_ERROR) {
ngx_http_v2_finalize_connection(h2c, 0);
return;
}
}
关闭流会调用 ngx_http_free_request() ,从而销毁包含请求 r 及其上游结构 u 的请求内存池。
// https://github.com/nginx/nginx/blob/140aa942711868a8daeb95810bc9a81f272ada72/src/http/ngx_http_request.c#L4062-L4071
/*
* Setting r->pool to NULL will increase probability to catch double close
* of request since the request object is allocated from its own pool.
*/
pool = r->pool;
r->pool = NULL;
ngx_destroy_pool(pool);
当排水返回后,nginx 会继续执行那段已经释放了请求的上游代码:它连接上游、发送代理请求、处理该连接上的事件,而这一切都通过已释放的 r 进行。
通过一些堆布局整理技术,我们让 glibc 大块(large bin)的头部正好落在 u 之上,并让头部中的 bk_nextsize 字段正好落在 u->peer.sockaddr 上。该字段随后指向我们控制的字节(我们自己服务器的一个 sockaddr_in ),使上游连接实际连向我们的服务器。
为绕过 ASLR,我们只需接受该连接,nginx 便会返回那块已释放的请求缓冲区,其中此时包含各种指针值。随后 worker 崩溃,但其替代进程具有相同的地址布局。
为执行命令,我们使用另一种堆布局技术,用一个伪造请求回收已释放的请求区,并把其上游读处理程序设为 execv() ;当我们拒绝连接时,epoll 报告错误,nginx 便调用该处理程序。
5.3.3 可利用性验证
|
项目
|
结果
|
|---|---|
|
目标
|
官方 nginx:1.31.8 镜像,一个 TLS/HTTP/2 服务器,并在默认 nginx.conf 中加入
proxy_pass |
|
入口
|
一个使用 ALPN h2 的 TLS 端口,另有一个用于占满连接槽位的 HTTP/1 端口
|
|
认证
|
无
|
|
网络要求
|
nginx 能够与攻击者建立 TCP 连接
|
|
结果
|
以 nginx worker 权限实现远程代码执行
|
5.4 CVE-2026-121810
CVE-2026-121810 是在关闭 QUIC 连接、而其上的某个 HTTP/3 请求仍在运行时导致的释放后使用。在流创建过程中,父 QUIC 连接会被错误地标记为符合排水条件,随后该请求的上游连接就可能释放掉自己的请求内存。
该错误与 CVE-2026-123633 类似,但触发机制略有不同,因此下文省略部分已在前文介绍的定义与背景。建议先阅读第 5.3 节。
5.4.1 nginx 如何把 HTTP/3 流当作连接处理
HTTP/3 通过一条 QUIC 连接承载多个请求流,但 nginx 内部为 QUIC 连接分配一个 ngx_connection_t ,并为每个流额外分配一个。它们都来自同一 worker 的连接槽位,因此创建请求流同样需要一个空闲槽位。我们把承载这些流的 QUIC 连接称为父连接。等待头部的 QUIC 连接与 HTTP/3 请求流都可能符合排水条件。
当单个流关闭时,nginx 会检查父连接是否可以被排干。 ngx_quic_can_shutdown() 会遍历父连接的流树,如果所有剩余流都是可取消的,nginx 就把父连接放入可复用队列。
// https://github.com/nginx/nginx/blob/140aa942711868a8daeb95810bc9a81f272ada72/src/event/quic/ngx_event_quic_streams.c#L1168-L1170
if (!pc->reusable && ngx_quic_can_shutdown(pc) == NGX_OK) {
ngx_reusable_connection(pc, 1);
}
5.4.2 漏洞细节
(1)流创建期间重新入队 QUIC 连接
在为新流分配连接槽位之前, ngx_quic_create_stream() 会把父连接从可复用队列中取出,目的是防止 ngx_get_connection() 在槽位分配期间排干父连接。
// https://github.com/nginx/nginx/blob/140aa942711868a8daeb95810bc9a81f272ada72/src/event/quic/ngx_event_quic_streams.c#L734-L743
reusable = c->reusable;
ngx_reusable_connection(c, 0);
sc = ngx_get_connection(c->fd, log);
if (sc == NULL) {
ngx_destroy_pool(pool);
ngx_queue_insert_tail(&qc->streams.free, &qs->queue);
ngx_reusable_connection(c, reusable);
return NULL;
}
然而,新流只有在分配连接槽位之后才会被加入父连接的流树。
// https://github.com/nginx/nginx/blob/140aa942711868a8daeb95810bc9a81f272ada72/src/event/quic/ngx_event_quic_streams.c#L814
ngx_rbtree_insert(&qc->streams.tree, &qs->node);
假设排水关闭了同一父连接上的一个既有空闲流。如果该流的两个方向都已完成,就可能触发「父连接是否可排水」的检查,但这项检查看不到仍在创建中的新流。由于树中已没有其他不可取消的流,nginx 会把父连接放回可复用队列,即便新流创建完成后它仍留在那里。
(2)上游连接释放了请求
当新流的请求连接上游时,它又需要一个槽位,这可能再次触发排水,并选中刚刚入队的父 QUIC 连接。 ngx_quic_close_connection() 调用 ngx_quic_close_streams() 关闭父连接上的流,从而终止上游连接中仍在进行的请求。
ngx_http_free_request() 销毁请求内存池,包括上游结构 u 。随后控制权返回 ngx_event_connect_peer() ,它会继续使用已释放的 u->peer ,导致释放后使用。
此后,绕过 ASLR 与控制流劫持的路径与 5.3.2 节所述相同,为简洁起见此处不再重复。
5.4.3 可利用性验证
|
项目
|
结果
|
|---|---|
|
目标
|
官方 nginx:1.31.8 amd64 镜像,并在默认 nginx.conf 中加入 HTTP/3 代理服务器
|
|
入口
|
UDP 443(HTTP/3)、TCP 443(HTTP/2)、TCP 80
|
|
认证
|
无
|
|
网络要求
|
nginx 能够向攻击者的监听器发起 TCP 连接
|
|
结果
|
以 nginx worker 权限实现远程代码执行
|
5.5 CVE-2026-113425
CVE-2026-113425 是邮件代理 auth_http 认证路径中的释放后使用。关闭客户端连接会释放其会话,但与认证服务的连接仍保持打开,该连接上的后续事件便会使用已释放的会话。
5.5.1 邮件代理如何对客户端进行认证
nginx 可以在客户端与邮件服务器之间代理 IMAP、POP3 和 SMTP。当客户端登录时,nginx 会询问由 auth_http 配置的 HTTP 服务:凭据是否有效,以及应使用哪台后端邮件服务器。
在此查询过程中,nginx 维护两条连接:一条通往客户端,另一条通往 HTTP 认证服务(下称认证连接)。
ngx_mail_auth_http_init() 用自己的内存池创建查询上下文。然而,认证连接的 data 与 pool 字段指向客户端的会话和客户端连接的内存池。认证连接使用该会话期间,这个内存池必须保持已分配状态。
// https://github.com/nginx/nginx/blob/140aa942711868a8daeb95810bc9a81f272ada72/src/mail/ngx_mail_auth_http_module.c#L216-L221
ctx->peer.connection->data = s;
ctx->peer.connection->pool = s->connection->pool;
s->connection->read->handler = ngx_mail_auth_http_block_read;
ctx->peer.connection->read->handler = ngx_mail_auth_http_read_handler;
ctx->peer.connection->write->handler = ngx_mail_auth_http_write_handler;
5.5.2 漏洞细节
查询开始时,客户端的读处理程序被替换为 ngx_mail_auth_http_block_read() 。如果重新挂载读事件失败,该处理函数会关闭认证连接并释放查询内存池。然而客户端的写处理程序仍是 ngx_mail_send() ,而它的错误路径并不清理认证连接。缺陷在于:当认证连接仍指向该会话时,这个写处理程序可以关闭客户端连接。
(1)查询期间释放客户端会话
该路径要求客户端写事件事先已注册。例如客户端停止读取回复、填满套接字发送缓冲区,发送就会返回 EAGAIN , ngx_mail_send() 随之注册写事件以便重试。
如果登录命令与 TCP 重置在同一次事件循环迭代中被处理,nginx 会先运行活动的读处理程序、再运行写处理程序来处理 epoll 报告的套接字错误。读处理程序解析登录命令并启动认证查询,此时回复仍排在 s->out 中。
随后 ngx_mail_send() 尝试发送排队的回复。在已重置的套接字上写入失败,于是它关闭客户端连接并销毁其内存池。
// https://github.com/nginx/nginx/blob/140aa942711868a8daeb95810bc9a81f272ada72/src/mail/ngx_mail_handler.c#L812-L815
if (n == NGX_ERROR) {
ngx_mail_close_connection(c);
return;
}
// https://github.com/nginx/nginx/blob/140aa942711868a8daeb95810bc9a81f272ada72/src/mail/ngx_mail_handler.c#L966-L972
c->destroyed = 1;
pool = c->pool;
ngx_close_connection(c);
ngx_destroy_pool(pool);
会话及其模块上下文数组都从这块现已被释放的内存池中分配。关键在于,认证连接仍保持打开,其 data 字段依旧指向 s 。
(2)认证连接使用已释放的会话
下一个事件(例如连接完成、响应到达或超时)会在认证连接上运行某个处理程序。读、写处理程序都会从连接的 data 字段取出会话指针,并借此获取查询上下文,从而访问已释放会话中的 s->ctx 。如果攻击者控制的数据回收了这块内存, s->ctx 就可以指向一个伪上下文。认证响应路径随后调用 ctx->handler ,为攻击者提供控制流劫持的机会。
为绕过 ASLR,我们利用了认证连接的过期超时:通过一些堆布局,超时释放掉包含另一条连接部分接收的 IMAP 命令的内存;随后的分配用堆指针回收这块内存,nginx 在回复该 IMAP 命令时把这些指针回显给我们。
为执行命令,我们在新的 worker 上再次运行触发器:会话释放后紧接着用一个带受控密码的 IMAP LOGIN 回收该内存,其 s->ctx 指向一个伪查询上下文,其 handler 为 system() ;当认证服务返回响应时, ngx_mail_auth_http_read_handler() 会沿悬垂会话并调用 system(s) 。
5.5.3 可利用性验证
|
项目
|
结果
|
|---|---|
|
目标
|
官方 nginx:1.31.8 镜像,默认配置加上包含 IMAP、POP3 和 SMTP 的
mail 块 |
|
入口
|
IMAP 143、POP3 110,以及由同一 worker 提供服务的 HTTP 80
|
|
认证
|
无。认证服务拒绝所有登录
|
|
结果
|
以 nginx worker 权限实现远程代码执行
|
▍ 6. Linux 内核 LPE 漏洞分析
nginx 漏洞让攻击者获得 worker 权限下的代码执行。worker 通常以受限权限运行,因此要完全控制主机,还需要一个提权漏洞。我们在 Linux 内核的 SCTP 子系统中发现了一个零日漏洞,将它与其他某个 nginx 漏洞串联后,即可在主机上取得 root 权限。当 nginx 运行于 Docker 容器中时,这一链条同样有效。
本节介绍该 SCTP 漏洞的成因与我们的验证结果。在内核补丁可用之前,我们保留复现或利用它所需的大部分细节。
6.1 SCTP 关联如何工作
SCTP(流控制传输协议)是一种传输层协议,与 TCP、UDP 同级。
与 TCP 一样,SCTP 是面向连接的,它把连接称为「关联」(association)。关联可以在每个端点上使用多个 IP 地址,当某条路径失败时允许连接经由另一条路径继续。
6.2 漏洞细节
错误位于 SCTP 的发送路径中。当一个发送操作处于等待状态时,其关联可能被转移到另一个套接字,随后这个等待中的操作又释放了已被转移的关联。视另一个套接字的行为,这会分别导致释放后使用或双重释放。
在使用 KASAN(内核内存错误检测器)构建的内核上,双重释放的输出如下:
BUG: KASAN: double-free in sctp_[...]
Free of addr ffff8880021b0880 by task t306/838
Call Trace:
kfree+0x170/0x490
sctp_[...]
sctp_[...]
sctp_[...]
Freed by task 836:
kfree+0x23c/0x490
sctp_[...]
sctp_[...]
sctp_[...]
sctp_[...]
该错误于 2018 年在 Linux v4.15 中引入,并在内核中存在了八年多。
6.3 可利用性验证
释放后使用提供了两类原语:击败内核地址空间布局随机化(KASLR)的内核内存泄露,以及内核中的任意函数调用。二者结合即可控制内核执行并完成提权。在我们的测试中,已经以 nginx worker 身份获得代码执行权限的攻击者可以稳定取得 root。
我们还在 nginx 运行于 Docker 容器的环境中取得了主机的 root shell。在许多 Linux 发行版上,SCTP 模块默认安装,当程序首次打开 SCTP 套接字时内核会自动加载它。某台主机上的 SCTP 是否可达,仍取决于内核、可用模块以及容器限制。在可达的情况下,攻击者即可接管主机内核。由于主机上的所有容器共享同一内核,这意味着攻击者可以控制主机及其上的每一个容器。
在内核补丁可用之前,不使用 SCTP 的主机可以通过在 /etc/modprobe.d/ 下的 .conf 文件中写入 install sctp /bin/false 来阻止模块加载。这只能阻止经由 modprobe 的加载,既不会卸载已加载的模块,也无法禁用编译进内核的 SCTP。
本研究报告自 https://xint.io/blog/nginx2root-remote-code-execution
其他推荐阅读
点一下 推荐吧 ,喜欢的转发一下
📰 相关阅读
— 阅读原文请访问微信公众号「表哥带我」 · 原文链接 —














暂无评论内容