【漏洞通知】Nginx中存在新的远程代码执行漏洞,需要立即进行修复

admin 2026-11-21 02:18:31 网络安全文章 来源:ZONE.CI 全球网 0 阅读模式

【漏洞通知】Nginx 中存在新的远程代码执行漏洞,需要立即进行修复

原创

Xint
Xint

像梦又似花

2026年11月19日 10:16
广东

去阅读

引言

Nginx 是全球使用最广泛的 Web 服务器之一。在它中发现一个未经认证的远程代码执行漏洞,长期以来一直都是安全研究人员梦寐以求的目标。Xint 研究团队最近发现了五个这样的漏洞。每个漏洞都会导致远程代码执行,但它们影响的配置各不相同。

Xint 还在 Linux 内核中发现了另一个漏洞,这个漏洞可以与 nginx 系统中的任何漏洞结合使用,从而让攻击者获得系统的 root 权限。我们把这六个漏洞统称为“nginx2root 漏洞”。

如果你正在运行 nginx,那么一旦修复版本发布后,请立即将其更新为 1.31.9 版本。这篇文章阐述了每个 nginx2root 漏洞的根本原因,并总结了我们的攻击评估结果。关于暴露风险的检查,请参见第二部分;而关于补丁程序和临时解决方案,请参见第三部分。

1. 执行摘要

攻击者能够做些什么呢

在这五个漏洞发现中,最严重的一个是 CVE-2026-123007。该漏洞使得未经认证的攻击者可在对启用了 HTTP/2 的受影响的 Nginx 服务器上执行命令。这些命令以处理该请求的 Nginx 工作进程的权限来运行。

我们结合了这一漏洞和 Linux 内核 SCTP 子系统中的另一个缺陷,从而在目标主机上获得了 root 权限。在测试中,这一链式攻击还成功绕过了运行 nginx 的 Docker 容器,并在底层主机上获得了 root 权限。

在下面的视频中,我们使用了 CVE-2026-123007 这一漏洞来在容器中以 nginx 工作进程的身份执行命令,然后利用内核中的漏洞获取系统 root 权限。

nginx2 根目录:demo 视频

我们在 AWS 上进行了这个演示,通过服务器的公共 IP 地址对服务器进行了攻击。关于 AWS、GCP、Azure 以及裸机服务器的演示内容,可以在 nginx2root.com 网站上找到。


受影响的版本

这五个 nginx 漏洞中的每一个都是独立的攻击途径,不需要相互关联。它们所影响的配置各不相同。

CVE 受影响的配置 此路径中首先受到影响的版本 是通过禁用 HTTP/2 来阻止其运行吗?
CVE-2026-123007 支持 HTTP/2 协议 1.9.5 是的
CVE-2026-123634 resolver ,一个由请求派生出的 proxy\_pass 目标,以及带有 mirror\_request\_body off 的 mirror 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 这个漏洞自 2015 年 nginx 引入 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 这个安全漏洞。几天后,通过全自动的 Xint 扫描,在没有人工干预的情况下,又发现了另外四个安全漏洞。

Nginx2 的目录结构概览

物品/东西 详细信息
CVE CVE-2026-123007 CVE-2026-123634 CVE-2026-123633 CVE-2026-121810 CVE-2026-113425
严重程度 关键的
固定版本 1.31.9
影响 未经认证的远程攻击者可以利用 nginx 工作站的权限执行任意命令。
受影响的版本(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 这一漏洞,该漏洞涉及的最多的服务器受到影响。对于其他四个 Nginx 漏洞,需要先查看第一部分中的配置表。

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 版本。这些发行版可能会将安全修复功能整合到现有版本中,而不是通过更新新的 nginx 版本来实现。

回迁操作可以在不更改 nginx -v 所报告的版本号的情况下修复漏洞。只有软件的完整包版本会发生变化。例如,Ubuntu 22.04 最初发布的版本号为 1.18.0-6ubuntu14 。到了 2026 年 10 月 26 日,安全更新使得该包的版本号变为 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 或更高版本:很可能已经修复了漏洞问题。不过,请确认该版本确实包含了在 github.com/nginx/nginx/releases#release-release-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 协议:h2,说明服务器能够接受 HTTP/2 协议的请求;而如果没有看到该协议,则表示服务器无法与客户端建立连接。任何其他情况都意味着连接失败,因此请检查服务器是否可访问,然后再尝试一次。

如果某个内容分发网络或反向代理服务器位于 nginx 服务器的前面,那么测试只会影响到代理服务器。因此,也可以直接对 nginx 服务器进行测试。

请使用以下表格来解读合并后的结果。

结果 评估
在实际运行的 nginx 端口上,未对 1.9.5 到 1.31.8 以及 HTTP2\_MODULE=present + ALPN protocol: h2 版本进行修复。 处于脆弱状态且易受外部威胁影响。必须立即采取行动。
未修复任何漏洞的 1.9.5 到 1.31.8 版本,同时启用了 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)、由工作进程发起的程序(3.2.3),以及工作进程崩溃的情况(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 地址。根据其日志记录的数量来计算该 IP 地址的 request\_length 值。将这个总数与 ss 给出的该 IP 地址的 bytes\_received 值进行比较。如果 bytes\_received 的值持续快速增长,而日志中记录的请求长度却保持较小,那么说明客户端正在发送大量实际上并未被识别为请求的数据。这种情况符合 HTTP/2 控制帧泛滥的情况。如果在同一时期 request\_time 的值很长,那也是另一个迹象,表明可能存在类似的攻击行为。

3.2.3. 监控员工执行的命令

我们的攻击行为使用了 execve() 来启动一个外壳程序或其他程序。普通的 Nginx 工作进程没有理由运行外部程序,因此它启动的任何程序都需要立即被检查。首先,需要确定该工作进程的 UID。

ps -eo uid,user,pid,ppid,args | grep '[n]ginx: worker process'

在使用 Linux 审计子系统的系统上,将 NGINX\_UID 替换为上一步输出中的数字 UID,然后添加以下规则。

sudo auditctl -a always,exit -F arch=b64 -S execve,execveat \

-F euid=NGINX\_UID -k nginx\_worker\_exec

该规则仅在安装后才会记录执行情况。一个空的结果并不能排除之前可能存在的干扰因素。此外,该规则还会匹配使用相同 UID 的其他进程,因此需要检查进程和父进程的身份,以确定事件是否来自 nginx 服务。

请查看相关记录:

sudo ausearch -k nginx\_worker\_exec -ts recent -i

请查找由 nginx 进程启动的 /bin/sh 、 /bin/bash 或其他程序。如果其他应用程序也是使用同一账户运行的,请检查每个事件的父进程,并根据服务配置来判断哪些进程来自 nginx。

3.2.4. 检查工人异常退出情况

如果攻击尝试失败,可能会导致一个 Nginx 工作进程崩溃。因此,请使用以下命令来检测异常退出情况以及核心转储文件中的错误信息。

sudo grep -Ei 'worker process.\*exited|signal 11|segfault' /var/log/nginx/error.log

sudo coredumpctl list nginx

员工可能因为与攻击无关的原因而崩溃。在得出结论之前,需要将这些记录与其他信号进行关联分析。

3.2.5. 评估证据的有效性

由 nginx 工作进程发起的一个程序(参见 3.2.3 节)是攻击成功的最明显迹象。应立即对此进行调查。以下这些迹象则较为轻微,每个迹象都可能由正常原因引起。如果多个迹象同时出现且无法解释其成因,那么请封锁该来源并进行调查:

持续收到大量的访问流量(参见 3.2.1 节)。

许多连接都来自同一个来源(第 3.2.1 节)。

实际接收到的字节数与记录中的请求长度之间存在较大差距(参见第 3.2.2 节)。

频繁出现的异常工作端退出情况(参见 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 及更高版本,请在每个受影响的服务器块中设置 http2 off; 参数,并从其 listen 指令中移除所有过时的 http2 参数。请检查所有共享相同监听地址和端口的服务器块。

listen443 ssl;

http2 off;

对于 Nginx 1.9.5 到 1.25.0 版本,需要将 listen 443 ssl http2; 中的 http2 删除。

listen443 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 指向固定的上游组。这样就能避免在请求过程中进行 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 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 块中,移除包含 listen 指令的 quic ,设置 http3 off 的值,并将所有 Alt-Svc 开头的头文件中的 HTTP/3 广告内容替换为 Alt-Svc 'clear' 。不过,基于 TCP 的常规 TLS 监听器仍然保留不变,因此最终的结果应该如下所示:

listen443 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)

这种缓解措施仅适用于在 IMAP、POP3 或 SMTP 服务器之前使用 nginx 作为邮件代理的情况。当 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 或邮件会话,仍然会使用旧的配置。在 ps 中,这些连接被表示为 nginx: worker process is shutting down 。

如果这些服务器在重新加载后仍然在运行,请通过您的服务管理器重新启动 nginx(例如,使用 systemctl restart nginx )。重新启动会强制断开所有客户的连接,并中断正在进行的下载、上传和邮件会话操作,因此请预计会有一段短暂的服务中断时间。

4. 发现与披露的时间表

在 nginx 中发现五个远程代码执行漏洞的情况并不常见。在二十多年的安全研究过程中,nginx 遇到的未经认证的远程代码执行漏洞其实非常少。其中一个例子就是 CVE-2013-2028,这是一种由恶意的 HTTP 请求引发的堆栈溢出漏洞。

今年,不止我们发现了更多的 Nginx 漏洞。到 2025 年,Nginx 的安全公告列表中出现了两种新的漏洞。而到了今年 11 月 17 日,已经记录了 26 种漏洞,这些漏洞还包括 Nginx2root 相关的漏洞,以及多种内存损坏问题,比如缓冲区溢出和释放变量后使用错误的指针等问题。借助人工智能技术的辅助,发现漏洞的速度比以往任何时候都要快,即使是在像 Nginx 这样被研究得相当透彻的代码中也是如此。再加上 Nginx2root 漏洞,总共有五个漏洞被一次性发现。

以下的时间线记录了相关事件的进展:发现阶段、信息公开情况以及预定的补丁发布时间。所有日期均以协调世界时(UTC+0)为准。

日期 活动/事件
2026 年 10 月 11 日 Xint 研究团队发现了这些漏洞。
2026 年 10 月 16 日 通过 HackerOne 平台向 F5 提交的漏洞信息
2026 年 10 月 20 日 HackerOne 已经完成了验证工作。
2026 年 10 月 27 日 报告已提交给 F5 的 nginx 开发团队。
2026 年 11 月 9 日 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 等。在每个流中,HEADER 帧负责传输头部信息,而 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

defineNGX\_HTTP\_V2\_MAX\_WINDOW      ((1U << 31) - 1)

defineNGX\_HTTP\_V2\_DEFAULT\_WINDOW  65535

Nginx 在通过套接字发送响应之前,会将响应数据保存在内存中的输出队列中。当 Nginx 将响应数据放入队列时,它会从连接级别的发送窗口和流的发送窗口中扣除数据长度。

// 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() 会从队列中移除该数据流剩余的数据帧,并返回被扣除的长度给连接级别的发送窗口。

// https://github.com/nginx/nginx/blob/140aa942711868a8daeb95810bc9a81f272ada72/src/http/v2/ngx\_http\_v2\_filter\_module.c#L1719-L1767

h2c->send\_window += window;

当 nginx 排队处理数据的时候,它会获得一定的信用值。如果在处理数据之前就取消了该流,那么这些信用值也会被返还。这两个步骤都是有效的。但问题是,在这两个步骤之间会发生什么情况呢?当数据仍然被排队的时候,客户端可能会再次发送一个 WINDOW\_UPDATE 信号。如果此时流被取消,清理过程会将返还的信用值加到已经增加的信用值上。不过,清理过程并不会检查最终的信用值是否超出了 HTTP/2 的最大限制,因此 h2c->send\_window 的值可能会超过允许的上限。

5.1.2. 漏洞详情

从窗口会计错误到命令执行的整个过程如下所述。第(1)小节介绍了步骤 1-2,第(2)小节涵盖了步骤 3,而第(3)小节则概述了步骤 4-6 的内容。

步骤/环节 描述
1. 将 DATA 保留在队列中 在队列中处理响应体,并从其长度中减去数据长度,同时防止数据传递给客户端。
1. 延长窗口持续时间,返还排队中的信用值 通过 WINDOW\_UPDATE 增加发送窗口的大小,然后取消当前流的处理,这样在清理过程中就会加上因排队数据而扣除的积分。
1. 绕过上限限制 一旦共享连接窗口超出其最大容量,剩余容量的计算就会失效,但之后仍然可以接受 WINDOW\_UPDATE 帧的数据。
1. 创建一种异常的文件副本长度 这段代码将相同的位解释为有符号和无符号值,并将一个较小的负距离转换为一个非常大的复制长度。
1. 披露地址和被篡改的内存数据 将副本的两端对齐,以返回内存指针,从而破坏 TLS 分配中的元数据。
1. 控制清理回调的调用 利用那些被公开的地址和已被篡改的内存数据,覆盖掉清理函数指针的指向。当清理函数被调用时,就会执行某个任意的指令。

(1) 在返回排队信用时超出了 31 位数的限制

第一个目标是收集存储在 nginx 输出队列中的数据,这些数据已经消耗了窗口资源,但尚未被发送出去。

客户端首先将连接发送窗口提升到最大值( Wmax ),并在流 ID 为 0 的情况下使用 WINDOW\_UPDATE 进行操作。客户端通过 SETTINGS 帧中的 SETTINGS\_INITIAL\_WINDOW\_SIZE 来设置新流的初始发送窗口。如果将此值设置为 0,则 nginx 可以创建响应头部信息,但无法发送数据。这样,响应体内容就会一直等待被客户端释放。

接下来,客户端停止读取数据,并发出一系列 PING 帧。Nginx 将控制帧的响应(包括 PING 确认消息)放在待发送数据的前面,这样这些确认消息就能填充 TLS 和 TCP 的发送缓冲区。然后,客户端向每个流发送与整个响应主体相当数量的字节数,这会导致 Nginx 将数据放入队列中,并从连接发送窗口中扣除相应的数据长度。由于 TLS 和 TCP 缓冲区已经满了,这些数据就会一直被暂存起来,无法被发送出去。

让 Q 表示该队列中待发送的数据总量。客户端现在向 h2c 窗口中两次添加 Q 的数据。首先,它发送了 Stream ID 为 0 的数据,并获得了 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) 。由于 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 框架的 Size 字段中。首先,它会将发送窗口与 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 ,即当前的数据帧大小,以及 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 中,该变量用于跟踪尚未分配缓冲区的长度。之后,Nginx 会将这个值传递给 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 指向 d 字节的位置,而 chunk->pos 则位于其之前。在 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 字节的数据复制过程通常会导致进程在堆内存的末尾处崩溃。不过,由于 glibc 对大尺寸数据复制的处理方式,这种情况并不会发生。在我们的实验中使用的 x86-64 架构下的 glibc 版本不会进行从前端到后端的复制操作。它会先读取源数据的起始点和终点,然后以循环的方式从目标数据的终点开始,向 dest 方向进行复制操作。

该目标文件的结束位置是 dest + size 。使用 size = 2^64 - d 时,这个数值超出了 64 位地址空间的范围,从而会超出到 dest - d ,即 d 字节的位置,而 dest 则位于 d 的下方。由于结束位置已经位于起始位置的下方,因此反向循环会在一次迭代后停止,而庞大的中间区域则永远无法被访问到。这种反向复制结构,每次迭代会移动四个 32 字节的数据块,这种机制自 2016 年发布的 glibc 2.24 版本起就出现在其 x86-64 实现中。

下面展示了 glibc 2.41 AVX2 版本的路径的简化版本。

Introduced in: https://github.com/bminor/glibc/blob/glibc-2.24/sysdeps/x86\_64/multiarch/memmove-vec-unaligned-erms.S#L413-L462

https://github.com/bminor/glibc/blob/glibc-2.41/sysdeps/x86\_64/multiarch/memmove-vec-unaligned-erms.S#L513-L554

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)  rounds x 缩减到了 32 字节的边界。当 end 是 32 字节的整数倍时,如下面的例子所示, cursor = align\_down(end - 129, 32) 就会变成 end - 160 。Glibc 会从这个位置开始复制 128 字节的数据,然后再单独复制最后的 32 字节数据。

end-160end-32end

|---------- 128 bytes ----------|------ 32 bytes -----|

loop copy                    fixed copy

由于 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 确认数据的长度为 0 字节。

// https://github.com/nginx/nginx/blob/140aa942711868a8daeb95810bc9a81f272ada72/src/http/v2/ngx\_http\_v2.h#L27

defineNGX\_HTTP\_V2\_FRAME\_HEADER\_SIZE    9

// https://github.com/nginx/nginx/blob/140aa942711868a8daeb95810bc9a81f272ada72/src/http/v2/ngx\_http\_v2.c#L30-L34

defineNGX\_HTTP\_V2\_SETTINGS\_ACK\_SIZE    0

defineNGX\_HTTP\_V2\_PING\_SIZE            8

如果发送的是不带 ACK 标志的 PING 数据包,那么会生成一个 17 字节的 PING 响应;而如果发送的是 SETTINGS 数据包,则会生成一个 9 字节的 SETTINGS 响应。如果客户端同时发送 PING 和 SETTINGS 数据包,nginx 会首先生成 2 字节的响应数据。再加上后面的 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 会构建一个多部分响应,该响应以在请求池中分配的边界字符串作为起始点,因此 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 ,因此最终会被使用 src 。

在请求池中,有 src 这个参数。攻击者使用 Cookie 字段来填充 160 字节的内容,直到达到 src - d 这个位置。如果同一个请求包含多个 Cookie 字段,nginx 会为每个分隔符增加两个字节来计算总长度,然后将这些值用 \"; \" 连接起来。最终,该请求的长度和合并后的缓冲地址会被存储在请求头部结构中。

// 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 的多部分缓冲区的位置。这样,位于 src - d 之前的 160 字节数据就可以按照如下方式安排:

Source:      [96bytes containing the value for the size field][64bytes of code and heap pointers]

Destination: [96bytes before the TLS buffer, containing heap metadata][first 64bytes of the TLS plaintext buffer]

前 96 个字节覆盖了 TLS 明文缓冲区之前在堆内存中的大小字段。剩余的 64 个字节则包含在 TLS 响应中,其中包含了 nginx 镜像文件的相关信息以及堆内存地址。因此,一个损坏的副本就具备了写入内存数据以及泄露地址的能力。这些信息可以被用来覆盖某个清理函数的指针,从而以 nginx 工作进程的执行权限执行命令。我们省略了关于如何覆盖函数指针的详细过程。

5.1.3. 可利用性验证

我们仅通过一个可外部访问的 TLS/HTTP/2 端口进行实验,成功实现了未经身份验证的远程代码执行。该攻击利用了发送窗口的漏洞,暴露了 nginx 镜像文件及堆内存地址,并控制了某个清理函数,使其能够以 nginx 工作进程的权限执行命令。

验证结果

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 头部信息。如果 nginx 需要查询 DNS 以获取服务器的 IP 地址,它会查询由 resolver 指令指定的 DNS 服务器。

由于 DNS 解析需要时间,在等待 DNS 响应期间,nginx 会继续处理其他请求。每个查询都有一个解析器上下文对象( ngx\_resolver\_ctx\_t ),该对象保存了查询的状态和结果,并且在查询完成时会触发 handler 方法的调用。

这个解析器会跟踪每个域名在节点中的状态。如果某个域名已经进行了查询,那么 nginx 就不会再次发起查询,而是将新的查询上下文推送到该节点的等待队列的头部。

当答案最终到来时,解析器通过设置 rn->waiting 为 NULL 来将待处理列表从节点上分离出来。然后,解析器会遍历这个列表,并调用每个上下文的 handler 。在每次调用之前,解析器会将下一个上下文的信息保存在 next 中。

// 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 中的 free-list 指针会覆盖上下文中的下一个字段,因此循环中的 next “context”实际上是一个已被释放的 DNS 记录数组,我们可以选择其中任意一项作为目标。然后,我们采用一种技巧:将控制处理程序指向 vsyscallgettimeofday() 地址(在 amd64 系统上这个地址是固定的),通过构造一个 DNS 查询来欺骗 nginx 向我们的控制服务器发送数据,从而将 Glibc 的相关指针以及堆内存指针也一同传递到服务器上。

在信息公开之后,我们可以把循环体链接到那个数组中的一个假用户 context ,并将该用户的处理程序设置为 system() ,这样就可以在目标主机上执行任意命令了。

5.2.3. 可利用性验证

物品/东西 结果
目标 官方消息称, nginx:1.31.8 的图片采用了基于请求时间 DNS 解析的服务器块技术,而 mirror 则被添加到库存配置中。
进入点 在 8080 端口上运行 HTTP 服务,并为攻击者的区域提供 DNS 解析服务
认证 没有
网络需求 nginx 的递归解析器必须能够访问攻击者的权威 DNS 服务器。
主机内核 Ubuntu Linux 6.8 (x86-64),适用于 vsyscall=xonly 系统
结果 利用 nginx 工作线程的权限进行远程代码执行

5.3. CVE-2026-123633

CVE-2026-123633 是一种因“使用后资源未释放”而引发的漏洞。当某个请求建立上游连接时,Nginx 可能会关闭该请求的 HTTP/2 连接,从而释放相关资源。然而,在上游代码继续访问这些已释放的资源时,漏洞仍然存在。这种漏洞在 Nginx 的生产环境中很常见,因为它需要在建立上游连接时启用该功能。

5.3.1. 在压力情况下,nginx 如何重用连接资源

每个 Nginx 工作进程都有固定数量的连接槽位,这些槽位的数量由 worker\_connections 定义。客户端连接和上游连接会共享这些槽位。当槽位不足时,Nginx 会关闭空闲连接以释放资源,以便用于其他用途。为了追踪哪些连接可以被释放,Nginx 会将满足某些协议特定条件的连接标记为 reusable ,例如处于空闲状态的 HTTP/1.1 保持连接,或者没有活跃流连接的 HTTP/2 连接。这些 reusable 标记的连接会被记录在专门的队列中。

在分配一个时间段之前, ngx\_get\_connection() 会调用 ngx\_drain\_connections() 。如果最多只有 1/16 的时间段是空闲的,并且可重复使用的队列不为空,那么系统会从最老的条目开始关闭连接,这个过程被称为“排空”操作。

该 Drain 函数会直接调用每个被选中连接的读取处理程序。这些调用是同步进行的,只有在处理程序返回后,才会继续分配资源。

// 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 连接会保留在可重复使用的队列中。

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() 状态,从而无法从可重复使用的队列中移除。

因此,这个缺陷会以以下方式被触发:

一个客户端发送了 HEADSERS 帧的第一部分内容,这会将连接放入可重复使用的队列中。

然后,客户端会发送剩余的数据,这样就开启了一个数据流。

如果该请求开启了某个上游连接,并引发了资源消耗,那么新创建的流所使用的连接可能会被重新利用。

(2) 上游连接释放了自身的请求资源

为了到达上游节点,请求需要另一个连接槽位。 ngx\_event\_connect\_peer() 会调用 ngx\_get\_connection() ,当槽位不足时,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 和 u 实现的。

通过一些内存整理技术,我们可以让 glibc 的大页头部覆盖在 u 之上,而该头部的 bk\_nextsize 字段则指向 u->peer.sockaddr 。这样,它就会指向我们控制的字节段(对于我们的服务器来说,就是 sockaddr\_in ),从而使得上游连接实际上能够连接到我们的服务器上。

为了绕过 ASLR 保护,我们只需接受该连接。此时,nginx 会发送已释放的请求缓冲区,该缓冲区现在包含了各种指针值。然后,工作进程会崩溃,但其替换进程仍然拥有相同的地址布局。

为了执行命令,我们使用了一种不同的处理技术来回收已释放的请求资源。这种技术利用了一个假的请求对象,该对象的上游读取处理程序指向 execv() 。当我们拒绝连接时,epoll 会报告一个错误,然后 nginx 会调用那个处理程序。

5.3.3. 可利用性验证

物品/东西 结果
目标 官方消息称,有 1 台 TLS/HTTP/2 服务器在原有 nginx.conf 的基础上增加了 proxy\_pass 的功能。
进入点 一个使用 ALPN 的 TLS 端口,同时还有一个用于占用连接信道的 HTTP/1 端口
认证 没有
网络需求 nginx 可以打开与攻击者的 TCP 连接。
结果 利用 nginx 工作线程的权限进行远程代码执行

5.4. CVE-2026-121810

CVE-2026-121810 是一种“释放后使用”的安全漏洞,起因是在某个 HTTP/3 请求仍在运行时关闭 QUIC 连接。在流创建过程中,父 QUIC 连接被错误地允许释放资源。随后对该请求的上游连接操作便可以释放相应的请求内存。

该漏洞与 CVE-2026-123633 类似,但其触发机制略有不同。因此,在我们的描述中,我们会省略一些我们已经解释过的定义和背景信息。建议在阅读本节之前先阅读第 5.3 节的内容。

5.4.1. nginx 如何将 HTTP/3 流作为连接来处理

HTTP/3 能够通过一个 QUIC 连接传输多个请求流。不过,nginx 在内部为每个 QUIC 连接分配了一个连接槽,而每个流又对应一个独立的连接槽。所有这些连接槽都来自同一个工作线程的连接槽分配空间,因此创建一个新的请求流也需要一个空闲的连接槽。我们将这些包含请求流的 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() 会将父连接从可复用队列中移除。这样做是为了避免在分配槽位时让父连接被完全释放。

// 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);

returnNULL;

}

不过,新的流只有在连接槽被分配之后才会进入父流的流树中。

// 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) 通过 Upstream Connect 可以释放请求资源

当新流的连接请求成功建立后,它还需要另一个资源来运行。此时,可以再次使用之前排队中的父 QUIC 连接。 ngx\_quic\_close\_connection() 调用 ngx\_quic\_close\_streams() 来关闭父连接的流,从而终止那些仍在进行连接建立过程的请求。

ngx\_http\_free\_request() 破坏了请求池,包括上游结构 u 。此时控制流返回到 ngx\_event\_connect\_peer() , ngx\_event\_connect\_peer() 继续使用已释放的 u->peer 资源,从而导致资源释放后出现的错误。

在这里,关于 ASLR 绕过机制和控制流劫取的方法与第 5.3.2 节中的描述类似,因此为了简洁起见,这里不再赘述。

5.4.3. 可利用性验证

物品/东西 结果
目标 官方版本 nginx:1.31.8 采用了 amd64 架构,同时还增加了 HTTP/3 代理服务器支持,而这一切都是默认配置的 nginx.conf 。
进入点 UDP 443(HTTP/3),TCP 443(HTTP/2)以及 TCP 80
认证 没有
网络需求 nginx 可以打开一个与攻击者的监听端口之间的 TCP 连接。
结果 利用 nginx 工作线程的权限进行远程代码执行

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 字段分别指向了客户端的会话 s 以及客户端连接的内存池。在认证连接使用该会话期间,这个内存池必须保持被占用状态。

// 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 。此时,需要注册写事件,以便能够重新尝试发送数据。

如果登录命令和 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);

会话 s 及其模块上下文数组是从已释放的池中分配到的。重要的是,认证连接仍然保持开放状态,其 data 字段仍然指向 s 。

(2) 身份验证连接使用了已释放的会话资源

下一个事件(例如连接完成、响应或超时等)会触发对认证连接的处理程序。读写处理程序都从连接的 data 字段中获取会话指针,并使用它来获取查找上下文,进而访问 s->ctx 中的上下文信息。如果攻击者能够控制数据的回收过程,那么 s->ctx 就可以指向一个伪造的上下文。认证响应路径随后会调用 ctx->handler ,从而使攻击者能够控制流程。

为了绕过 ASLR 机制,我们利用了旧的认证连接所拥有的超时机制。通过一些内存管理操作,超时机制会释放那些原本被其他连接占用的内存。之后,当内存重新分配时,这些内存会被回收。而当 nginx 响应 IMAP 命令时,它会将这些内存信息反馈给我们。

为了执行这些命令,我们需要在一个新的工作进程中再次触发该触发器。在会话被释放之后,一个使用受控密码的 IMAP 用户会以虚拟会话来接管该会话。这个虚拟会话的 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 和 HTTP 80 服务
认证 没有成功。认证服务拒绝了所有的登录请求。
结果 利用 nginx 工作线程的权限进行远程代码执行

6. 对 Linux 内核 LPE 漏洞的分析

nginx 中的漏洞允许攻击者以工作进程权限执行代码。通常情况下,工作进程的运行权限是受限的,因此要完全控制主机,还需要利用某种权限提升机制。我们调查了 Linux 内核,发现在其 SCTP 子系统存在一个零日漏洞。将该漏洞与 nginx 的漏洞结合使用,就可以获得主机的 root 权限。即使 nginx 运行在 Docker 容器中,这种方法依然有效。

本节描述了 SCTP 漏洞的成因以及我们的验证结果。在相关的内核补丁发布之前,我们不会透露足以复现或利用该漏洞的详细信息。

6.1. SCTP 关联机制的工作原理

SCTP(流控制传输协议)是一种传输层协议,与 TCP 和 UDP 类似。

与 TCP 类似,SCTP 也是面向连接的协议。SCTP 将连接称为“关联”。每个端点可以使用多个 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 工作进程运行代码,他们就足以获得 root 权限。

我们还成功地在某个环境中控制了主机上的根 shell。在这个环境中,Nginx 运行在一个 Docker 容器中。在许多 Linux 发行版中,SCTP 模块是默认安装的,内核会在程序首次打开 SCTP 套接字时自动加载该模块。不过,SCTP 是否能在特定主机上使用,仍然取决于内核、可用的模块以及容器的限制。一旦 SCTP 可以正常使用,攻击者就可以控制主机内核。由于主机上的所有容器都共享同一个内核,因此攻击者可以控制整个主机以及上面的所有容器。

在内核补丁发布之前,不使用 SCTP 的主机可以通过在 /etc/modprobe.d/ 下的 .conf 文件中添加 install sctp /bin/false 来阻止模块加载。不过,这种方法只能阻止通过 modprobe 进行模块加载。它无法卸载已经加载的模块,也无法禁用编译入内核的 SCTP 功能。

结束语

感谢您阅读到这里。总结一下,如果您正在运行 nginx,那么一旦 1.31.9 版本发布,请立即进行更新。如果无法立即更新,请参考第 3.3 节中描述的缓解措施。这些措施可以阻断已知的攻击路径,但它们并不能替代真正的补丁。在内核修复版本发布之前,请按照第 6.3 节的描述,在不需要使用 SCTP 模块的主机上禁用该模块。

在检查服务器是否已经过修补时需要注意。Linux 发行版通常会将修复程序引入到版本中,而不会改变 nginx -v 命令显示的版本信息。因此,应该将完整的软件包版本与您所在发行版的安全公告进行比对。

CVE-2026-123007 这个漏洞在 Nginx 项目中被忽视了超过十年,而 SCTP 漏洞则存在于 Linux 内核中,自 2018 年以来一直未被修复。这两个漏洞几乎在所有的系统中都存在,并且经过多年的安全审查仍未得到解决。不过,直到一个完全自动化的 Xint 扫描工具发现了它们。

    评论:0   参与:  0