nginx2root: Five Critical nginx RCEs Chain into a Linux Kernel LPE for Root (and Docker Escape)
On 18 November 2026 nginx shipped 1.31.9, fixing five critical vulnerabilities — all unauthenticated network RCE — in the HTTP/2, HTTP/3, DNS resolver, and mail-proxy code paths. The primary flaw, CVE-2026-123007, is an HTTP/2 window-accounting bug in every nginx release from 1.9.5 (September 2015) through 1.31.8. On its own that gives RCE as the nginx worker. Chained with a long-dormant Linux kernel SCTP double-free that has sat in mainline since 4.15 (2018), it reaches root on the host — and escapes Docker. The chain has been demonstrated against AWS, GCP, and Azure infrastructure. This is as close to a "patch every edge proxy you own" moment as the webserver stack ever gets.
TL;DR
- Primary RCE: CVE-2026-123007 — unauthenticated HTTP/2 flow-control integer-overflow and UAF chain in nginx 1.9.5 → 1.31.8. Fixed in 1.31.9.
- Four more criticals: CVE-2026-123634 (DNS resolver UAF), CVE-2026-123633 (HTTP/2 connection-drain UAF), CVE-2026-121810 (HTTP/3 stream UAF), CVE-2026-113425 (mail-proxy auth UAF). All fixed in 1.31.9.
- Kernel LPE: Linux SCTP double-free in the send path — in mainline since v4.15 (2018). Patches rolling through distribution kernels this week. On its own, a local priv-esc; chained with any nginx worker RCE above, it gives root on the host and Docker container escape.
- Blast radius: anything that fronts with nginx (most of the web, most reverse-proxy ingress, many ingress controllers in Kubernetes, many WAF edges). Confirmed exploitable across AWS, GCP, and Azure.
- Action now: upgrade to nginx 1.31.9 (or your distro's backport — see Ubuntu
USN-8955-1as an example), patch kernels, inventory HTTP/2 and HTTP/3 listeners, and treat any nginx host that was internet-reachable on HTTP/2 since the disclosure as potentially compromised until proven otherwise.
The nginx2root chain, in one page
The researchers framed this as two independent findings that combine into a single realistic attack:
- Unauthenticated nginx worker RCE — any of the five nginx CVEs, depending on your server's enabled modules and directives. The primary path is CVE-2026-123007 over HTTP/2, which requires only TLS reachability on an HTTP/2-enabled listener.
- Linux kernel LPE — a double-free in the SCTP send path. SCTP is not usually in use, but the kernel module is loadable from unprivileged code paths on most enterprise distributions. Once the attacker is executing as the nginx worker, the LPE lifts them to root on the host.
On a containerised deployment, the chain terminates in Docker escape rather than merely "root inside the container," because the kernel is shared with the host and the SCTP double-free fires at kernel level. The researchers demonstrated this across AWS, GCP, and Azure.
Why this one matters more than the usual nginx advisory: CVE-2026-123007 affects every nginx release with HTTP/2 since 2015. Most production nginx has HTTP/2 on by default. Many organisations have no accurate inventory of their nginx fleet — nginx is the kind of software that ends up inside container images, behind load balancers, in appliance firmware, and in long-tail acquired-company estates. The patch cadence is not the hard part. The inventory is.
The primary RCE — CVE-2026-123007 (HTTP/2)
The shape of the bug is straightforward to describe without describing how to exploit it. HTTP/2 per-stream flow control works on a 31-bit credit window — 0x7fffffff bytes maximum. When a stream is cancelled, nginx returns the queued flow-control credits to the connection-level window. The return path did not check the result against the 31-bit maximum, so with the right sequence of WINDOW_UPDATE + RST_STREAM frames, the connection-level window can be driven beyond its upper bound and then wrap under subsequent WINDOW_UPDATE frames.
Once the window is in that state, a signed/unsigned type confusion downstream converts a negative "distance to copy" into a very large unsigned length. A controlled partial copy gives the attacker a heap overwrite — enough to corrupt metadata, leak a pointer, and ultimately redirect a function-pointer-driven cleanup callback. Nginx worker RCE.
Exploitation prerequisites are minimal: unauthenticated network reach, TLS to the server, and HTTP/2 negotiated. There is no interaction with upstream content, no access required to any admin interface, and no particular module stack.
The four supporting nginx CVEs
Each of the next four is also unauthenticated RCE, but with narrower configuration prerequisites. Treat them all as "patch anyway" — but if you cannot patch immediately, the prerequisite table below tells you which paths are reachable in your setup.
| CVE | Class | Affected range | Requires |
|---|---|---|---|
| CVE-2026-123007 | HTTP/2 flow-control overflow + heap UAF | 1.9.5 – 1.31.8 | HTTP/2 on listener |
| CVE-2026-123634 | DNS resolver UAF | 1.13.4 – 1.31.8 | resolver + variable proxy_pass + mirror |
| CVE-2026-123633 | HTTP/2 connection-drain UAF | 1.19.7 – 1.31.8 | HTTP/2 + upstream proxying |
| CVE-2026-121810 | HTTP/3 stream UAF | 1.25.0 – 1.31.8 | listen ... quic; HTTP/3 enabled |
| CVE-2026-113425 | Mail proxy auth UAF | 0.5.15 – 1.31.8 | Mail block with proxy on + auth_http |
The kernel LPE: SCTP double-free
The nginx worker is not running as root on any sane deployment. The "to root" in nginx2root comes from a Linux kernel SCTP double-free in the send path. SCTP is the Stream Control Transmission Protocol — a legitimate transport layer, but one that almost no production workload uses. Its kernel module is, however, auto-loadable on most mainstream distributions when a userspace process opens an SCTP socket, which means a code-execution foothold with the ability to open sockets can trigger it.
The bug has been in mainline since kernel v4.15 (early 2018), which means every long-lived Linux host is eligible. Distribution patches are landing this week; check your vendor advisories.
The Docker escape
Container isolation is a userspace construct on a shared kernel. A kernel LPE inside a container is a kernel LPE on the host. The demonstrated chain goes: HTTP/2 traffic reaches an nginx pod → CVE-2026-123007 gives RCE as the nginx worker inside the container → SCTP module loads from inside the container → the double-free fires at kernel level → attacker has root on the Kubernetes node. From there, all other pods on that node are reachable, cluster credentials on the node's kubelet can be stolen, and lateral movement proceeds. The containment story many teams tell themselves about "nginx is just an ingress pod" ends at step three.
Mitigations that reduce (but do not eliminate) this specific escape: disable kernel-module auto-loading from containers (modprobe.conf, seccomp profiles that block create_module/finit_module), run pods with a non-root user and a read-only root filesystem, and prefer cluster distributions that ship with a hardened kernel profile.
Config-based mitigations if you can't patch immediately
Each nginx CVE above is gated on a specific directive. If you cannot roll out 1.31.9 before internet-exposed nginx is probed, these per-CVE knobs reduce reachable exposure as a stopgap:
| CVE | Mitigation (temporary) |
|---|---|
| CVE-2026-123007 | Remove http2 from listen directives or set http2 off; in server blocks |
| CVE-2026-123633 | Same as above — disable HTTP/2 on the listener |
| CVE-2026-123634 | Replace variable proxy_pass expressions with fixed upstream groups; disable mirror blocks that go through resolver |
| CVE-2026-121810 | Comment out listen ... quic; directives and set http3 off; |
| CVE-2026-113425 | Bind mail-proxy listeners to 127.0.0.1 only; restrict reachability via firewall |
For the kernel SCTP LPE where you cannot immediately patch, blacklist the module on hosts that genuinely do not use SCTP: add install sctp /bin/false to a file in /etc/modprobe.d/ and reboot or rmmod sctp. Caveat: this does not work against SCTP built into the kernel rather than compiled as a module — check cat /proc/kallsyms | grep sctp_ or your distribution's build config.
A quick note on version strings
nginx -v is not sufficient. Distribution packages backport security fixes into older-looking version strings — Ubuntu's USN-8955-1, for instance, applies the fix set to 1.18.0 rather than renaming to 1.31.9. Always check the package build identifier against the vendor advisory. For container images, inventory the full nginx package build — not just the semver.
Timeline
| Date | Event |
|---|---|
| 11 Oct 2026 | Discovery of the HTTP/2 chain by an independent research team. |
| 16 Oct 2026 | Coordinated disclosure to F5 via HackerOne. |
| 20 Oct 2026 | F5 validation completed; four related CVEs identified in review. |
| 9 Nov 2026 | Vendor patch set shared for validation. |
| 10 Nov 2026 | Researchers confirm fixes; kernel SCTP double-free also acknowledged upstream. |
| 18 Nov 2026 | nginx 1.31.9 released; distribution advisories begin landing. |
72-hour response
- Inventory every nginx. Container images (
nginx:*, derivative images, Kubernetes ingress controllers like ingress-nginx and nginx-ingress), Linux hosts, cloud load balancers that front with nginx, appliance firmware (many edge security products embed nginx). Treat every one as in scope until proven otherwise. - Prioritise HTTP/2-enabled, internet-reachable listeners. Externally reachable TCP 443 with
h2ALPN is the primary attack surface. Useopenssl s_client -connect host:443 -alpn h2or your ASM inventory to triage. - Upgrade. Patch to nginx 1.31.9, or your distribution's backported equivalent, across every environment. Rebuild and redeploy container images — pinned digests in your Dockerfiles will not pull the fix. Rolling restart ingress controllers.
- Patch kernels. Apply vendor kernel updates covering the SCTP double-free. For hosts that do not use SCTP, blacklist the module as a defence-in-depth step; the real fix is the kernel update.
- Hunt the last six weeks on previously-exposed nginx hosts: unexpected child processes spawned by nginx worker processes, writes to
/tmpor/dev/shmfollowed by execution, unexpected outbound connections from nginx worker processes, worker segfaults inerror.log, kernel panics or soft lockups indmesgcorrelated with inbound HTTP/2 traffic. - Rotate adjacent secrets on any nginx host that was reachable from the public internet before patching: TLS private keys, upstream basic-auth credentials, Vault tokens mounted into the pod, cloud credentials that the host's instance profile holds, and anything the nginx worker could read from
/etc. - Preserve evidence. If the host was exposed on HTTP/2 to the internet during the window, snapshot the container/host state, access logs, error logs, and auditd. Breach-notification clocks may apply even if you find nothing — regulatory discovery clocks start now, not at a later confirmed incident.
Detection without exploitation
Keep this at observable, non-reproducible signals. Three categories:
- Network shape: sustained high-volume HTTP/2 connections with large asymmetric byte ratios and unusual
WINDOW_UPDATE/RST_STREAMframe mixes. Edge WAFs with HTTP/2 frame visibility can baseline and alert. - Process behaviour: child processes spawned by
nginxworkers that are not part of your deployment (anything that is notnginxitself or a documented sub-process). This is the single cleanest runtime signal. - Error-log anomalies: abnormal worker exits, segfaults, and
coredumpctlentries correlated with HTTP/2 traffic bursts.
Companion advisories — same patch window
- SSHole (CVE-2026-123158) — OpenSSH authentication bypass on musl / Alpine. CISA KEV from 9 Nov.
- GPUStack (CVE-2026-102895) — unauthenticated admin on inference control planes. CISA KEV from 9 Nov.
- PHP2Shell × Fragnesia — a similar-shape PHP RCE + kernel LPE chain against Palo Alto, Cisco, Citrix, F5 and Siemens management interfaces. Instructive on how the "worker RCE + kernel LPE" pattern lands on appliances.
How TigerGate helps
- Container Security flags container images with nginx below 1.31.9 (or your distribution's backported equivalent) across your registries, and surfaces the first running workload per affected image so you rebuild in reachability order — including ingress-nginx and sidecar images.
- KSPM and CNAPP extend the view to Kubernetes ingress controllers and service-mesh sidecars that embed nginx, with reachability analysis for externally-exposed listeners.
- Server Vulnerability Monitoring fingerprints nginx on every Linux host and cloud VM, prioritised by eBPF runtime-reachability — hosts actually serving HTTP/2 rise to the top of the queue.
- eBPF runtime detection catches the exploitation side-effects: anomalous child processes spawned by nginx workers, outbound connections from nginx processes, writes to
/tmpor/dev/shmfollowed by execution, and unexpected SCTP socket activity from containerised workloads. - VAPT AI Engine and continuous VAPT run scheduled fingerprinting sweeps for vulnerable nginx builds across your ASM-discovered surface — first findings in the dashboard inside an hour.
- Compliance evidence maps the patch and rotation activity to SOC 2 CC7.1, ISO 27001 A.8.8, PCI DSS 6.3.3, and the BOD 22-01 clock if the CVEs land on CISA KEV.
FAQ
Sources
- nginx CHANGES — 1.31.9 release notes, 18 November 2026
- F5 K-article — coordinated disclosure summary via HackerOne
- CVE-2026-123007, CVE-2026-123634, CVE-2026-123633, CVE-2026-121810, CVE-2026-113425 at NVD
- Ubuntu security notices — USN-8955-1 backport to nginx 1.18.0
- Linux kernel SCTP double-free — distribution advisories rolling out this week; check your vendor
Find vulnerable nginx across your fleet
14-day trial. TigerGate inventories every nginx container image, ingress controller, Linux host, and cloud load balancer in your estate, flags builds below 1.31.9 (and distribution backports), and prioritises by HTTP/2 / HTTP/3 reachability — one patch window closes the exposure.