BlogVulnerability Research

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.

10 min readBy TigerGate Research, Security Research TeamPublished Updated

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-1 as 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:

  1. 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.
  2. 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.

CVEClassAffected rangeRequires
CVE-2026-123007HTTP/2 flow-control overflow + heap UAF1.9.5 – 1.31.8HTTP/2 on listener
CVE-2026-123634DNS resolver UAF1.13.4 – 1.31.8resolver + variable proxy_pass + mirror
CVE-2026-123633HTTP/2 connection-drain UAF1.19.7 – 1.31.8HTTP/2 + upstream proxying
CVE-2026-121810HTTP/3 stream UAF1.25.0 – 1.31.8listen ... quic; HTTP/3 enabled
CVE-2026-113425Mail proxy auth UAF0.5.15 – 1.31.8Mail 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:

CVEMitigation (temporary)
CVE-2026-123007Remove http2 from listen directives or set http2 off; in server blocks
CVE-2026-123633Same as above — disable HTTP/2 on the listener
CVE-2026-123634Replace variable proxy_pass expressions with fixed upstream groups; disable mirror blocks that go through resolver
CVE-2026-121810Comment out listen ... quic; directives and set http3 off;
CVE-2026-113425Bind 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

DateEvent
11 Oct 2026Discovery of the HTTP/2 chain by an independent research team.
16 Oct 2026Coordinated disclosure to F5 via HackerOne.
20 Oct 2026F5 validation completed; four related CVEs identified in review.
9 Nov 2026Vendor patch set shared for validation.
10 Nov 2026Researchers confirm fixes; kernel SCTP double-free also acknowledged upstream.
18 Nov 2026nginx 1.31.9 released; distribution advisories begin landing.

72-hour response

  1. 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.
  2. Prioritise HTTP/2-enabled, internet-reachable listeners. Externally reachable TCP 443 with h2 ALPN is the primary attack surface. Use openssl s_client -connect host:443 -alpn h2 or your ASM inventory to triage.
  3. 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.
  4. 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.
  5. Hunt the last six weeks on previously-exposed nginx hosts: unexpected child processes spawned by nginx worker processes, writes to /tmp or /dev/shm followed by execution, unexpected outbound connections from nginx worker processes, worker segfaults in error.log, kernel panics or soft lockups in dmesg correlated with inbound HTTP/2 traffic.
  6. 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.
  7. 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_STREAM frame mixes. Edge WAFs with HTTP/2 frame visibility can baseline and alert.
  • Process behaviour: child processes spawned by nginx workers that are not part of your deployment (anything that is not nginx itself or a documented sub-process). This is the single cleanest runtime signal.
  • Error-log anomalies: abnormal worker exits, segfaults, and coredumpctl entries 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 /tmp or /dev/shm followed 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

nginx2root is the nickname researchers gave to a chain of five critical nginx vulnerabilities plus one Linux kernel SCTP double-free that together take an unauthenticated network-adjacent attacker from a TLS handshake to root on the underlying host — including Docker container escape. The primary CVE is CVE-2026-123007 in HTTP/2 flow control. All five nginx CVEs are fixed in nginx 1.31.9, released 18 November 2026.
CVE-2026-123007 (the primary) affects nginx 1.9.5 through 1.31.8 — every version since HTTP/2 shipped in 2015. The other four CVEs have narrower ranges that depend on when the affected code path was introduced. Confirm the full package version against your distribution's advisory rather than reading nginx -v alone, since downstreams backport fixes to older-looking version strings (Ubuntu's USN-8955-1, for example, backports to 1.18.0).
The primary CVE (CVE-2026-123007) requires HTTP/2 on a listener. Most nginx installations in 2026 do have it on — it is the default on the common packaged distributions and in most production configs. The other CVEs each have their own prerequisites: HTTP/3 (QUIC) listeners, mail proxy with proxy on + auth_http, DNS resolver with variable proxy_pass + mirror, HTTP/2 with upstream proxying. See the "Config-based mitigations" table below.
Not on its own. CVE-2026-123007 gives RCE as the nginx worker, which typically runs as the nginx or www-data user. The 'to root' step is a separate Linux kernel SCTP double-free that has been present in mainline since v4.15 (2018). Chained, the two produce root on the host. On containerised deployments the same chain produces Docker container escape when the SCTP module is loadable from inside the container.
Run nginx -v for the version, nginx -V | grep http_v2 to confirm HTTP/2 is compiled in, and nginx -T | grep -E 'http2|listen.*http2|listen.*quic' to confirm whether HTTP/2 or HTTP/3 is enabled in your running config. Externally, openssl s_client -connect host:443 -alpn h2 tells you whether the server negotiates HTTP/2. Combine with container-image and host-package inventory across every environment.
SOC 2 CC7.1 (vulnerability lifecycle), ISO 27001 A.8.8, PCI DSS 6.3.3 (critical patch within 30 days), BOD 22-01 if the CVE lands on CISA KEV, and the operational-technology-safety sections of IEC 62443 where nginx fronts industrial systems.

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.