Contents
ToggleExecutive Summary
NGINX2Root (CVE-2026-123007) is a memory-corruption flaw in the HTTP/2 code of NGINX. It’s in every open-source release from 1.9.5 through 1.31.8. Version 1.9.5 shipped in September 2015 and was the first NGINX build with HTTP/2. So the bug has been in production code for about ten years.
F5 disclosed it on November 18, 2026, as part of a set of ten NGINX security fixes. Four of the other nine are close siblings of this bug. Together the five are called NGINX2Root. All five are fixed in NGINX 1.31.9 (mainline) and 1.30.7 (stable).
The flaw needs no authentication. It’s reachable before any application login. An attacker who can open an HTTP/2 session with an affected listener can corrupt worker memory. No credentials are needed, and no vulnerable backend application either.
This matters because of reach. NGINX fronts a large share of internet traffic. HTTP/2 is on by default in many deployments, including the retired ingress-nginx controller. Researchers showed code execution on stock 1.31.7 and 1.31.8 builds that served only static files, with ASLR still enabled.
The code runs as the NGINX worker account, not as root. Getting to host root takes a second bug. Researchers chained it with a separate, still-unpatched Linux kernel SCTP flaw and reached root, including from inside a Docker container.
Code execution in the worker gives an attacker a lot on a typical web or proxy tier. They can intercept requests, read TLS private keys and secrets held in memory, and use the host to move further into the network.
As of November 19, 2026 there is no confirmed in-the-wild exploitation. The CVE is not on CISA’s Known Exploited Vulnerabilities catalog. A public proof-of-concept exists. Several research teams have run working exploits against lab builds. One team reports success over public IP addresses under live traffic.

TL;DR for Engineering Teams
| Label | Content |
|---|---|
| What it is | Unauthenticated HTTP/2 memory corruption in NGINX (CVE-2026-123007, CVSS 4.0 9.2, CWE-191 / CWE-787). The lead flaw in a set of five “NGINX2Root” vulnerabilities fixed November 18, 2026. |
| Where it bites | Every NGINX Open Source release 1.9.5 to 1.31.8, and NGINX Plus R33 to R36 / 37.x before the fix. Any internet-facing or internal listener that negotiates HTTP/2. |
| Why it matters | Pre-auth. No backend application required. Exploitable on static-only sites. Public PoC available. Code execution confirmed by three independent research teams. Around 8.8 million services on affected versions still negotiate HTTP/2 (internet scan data, Nov 19). |
| Patch status | Available. Fixed in 1.31.9 and 1.30.7; NGINX Plus 37.0.8.1 and 37.3.0.1. No fix for NGINX Plus R33 to R36. |
| Immediate action | Upgrade to 1.31.9 or 1.30.7. Then fully restart NGINX or run a live binary upgrade. A config reload leaves the vulnerable worker binary running. |
Vulnerability Overview
| Field | Value |
|---|---|
| Vendor | F5 (NGINX) |
| Product | NGINX Open Source, NGINX Plus |
| Vulnerability Type | Unauthenticated remote code execution via HTTP/2 memory corruption |
| CWE | CWE-191 (integer underflow); the CVE record also lists CWE-787 (out-of-bounds write) |
| CVSS Score | 9.2 (CVSS 4.0, F5); 8.1 (CVSS 3.1); nginx.org severity “major” |
| CVE | CVE-2026-123007 |
| Patch Available | Yes (1.31.9 mainline, 1.30.7 stable) |
| Active Exploitation | Not confirmed as of Nov 19, 2026; not listed in CISA KEV |
Technical Anatomy
Root Cause
The flaw sits in NGINX’s HTTP/2 flow-control accounting. When NGINX finishes a filtered response, ngx_http_v2_filter_cleanup() gives flow-control credit back to the connection window. It does this without an upper-bound check.
A crafted sequence of WINDOW_UPDATE and stream frames pushes the available-window value below zero. The counter is unsigned, so the subtraction underflows (CWE-191) and turns into a very large positive window. NGINX later treats that window as a signed off_t length. The oversized length drives a memcpy that writes past the intended buffer (CWE-787).
The result is an out-of-bounds write in the worker that the attacker can influence. Three research teams described this chain independently. The upstream fix commit (b89c410, November 11) adds the missing bound.
Exploit Path
- Entry point. The attacker opens an HTTP/2 connection to any affected NGINX listener. No login, no specific vhost content and no backend application are needed. A plain static file server is enough. Researchers showed this on official 1.31.7 and 1.31.8 builds.
- Trigger. A tuned stream of HTTP/2 control frames forces the flow-control underflow. A bounded copy becomes an out-of-bounds write, and the attacker gets influence over worker memory. The researchers describe in-band address leakage that defeats ASLR, so ASLR doesn’t need to be off. CIRCL’s TR-105 report says this directly.
- Execution impact. The attacker gets code execution as the NGINX worker process. The public PoC reaches a command shell against a local
nginx:1.31.8container. Host root is a separate step. Researchers chained an unpatched Linux kernel SCTP use-after-free to escalate from the worker, including out of a Docker container.

The four siblings
F5 fixed four related memory-corruption flaws in the same release. Each is rated CVSS 4.0 9.2, and each is reachable only in a specific configuration.
- CVE-2026-123633 is a second HTTP/2 flaw. It’s a use-after-free that triggers when NGINX proxies a request to a backend while the worker is low on
worker_connections. - CVE-2026-123634 is a resolver use-after-free. It needs a proxied server name built from variables, plus an SSI or mirror subrequest that resolves the same name.
- CVE-2026-121810 is an HTTP/3 use-after-free. It’s reachable when HTTP/3 is on and requests are proxied upstream.
- CVE-2026-113425 is a mail-proxy use-after-free. It needs
proxy ontogether withauth_http.
Disabling HTTP/2 stops only the first two. A config review has to cover HTTP/3, the resolver pattern and the mail proxy separately.
Affected Versions
| Package | Vulnerable Versions | Fixed Version | Notes |
|---|---|---|---|
| NGINX Open Source (CVE-2026-123007) | 1.9.5 to 1.31.8 | 1.31.9 (mainline), 1.30.7 (stable) | HTTP/2 enabled. 1.31.9 and 1.30.7 fix all five NGINX2Root CVEs. |
| NGINX Plus (CVE-2026-123007) | R33 to R36, 37.0.0 to 37.2.0.1 | 37.0.8.1, 37.3.0.1 | R33 reached End of Technical Support on disclosure day. No R-series fix listed. |
| CVE-2026-123633 (HTTP/2 use-after-free) | 1.19.7 to 1.31.8 | 1.31.9 / 1.30.7 | HTTP/2 + proxy to a backend while the worker is low on worker_connections. |
| CVE-2026-123634 (resolver use-after-free) | 0.6.18 to 1.31.8 | 1.31.9 / 1.30.7 | Variable-built proxied server name + SSI or mirror subrequest to the same name. |
| CVE-2026-121810 (HTTP/3 use-after-free) | 1.25.0 to 1.31.8 | 1.31.9 / 1.30.7 | HTTP/3 enabled with requests proxied upstream. |
| CVE-2026-113425 (mail proxy use-after-free) | 0.5.33 to 1.31.8 | 1.31.9 / 1.30.7 | Mail proxy configured with proxy on and auth_http. |
A distribution package can carry a backported fix without changing the version that nginx -v reports. Match against your distribution’s own advisory, not the upstream number.
NGINX Ingress Controller is fixed in 5.8.0, and NGINX Gateway Fabric in 2.9.0. The community ingress-nginx controller is retired with no fix planned. It ships with HTTP/2 on by default.
Exposure Analysis
| Environment | Risk Level | Reason |
|---|---|---|
| Internet-exposed NGINX with HTTP/2 | Critical | Direct pre-auth reach to the vulnerable listener. Around 8.8 million such services found by internet scans. |
| CI/CD and Kubernetes ingress | High | ingress-nginx has HTTP/2 on by default and no fix planned. Exposes build and application secrets. |
| Cloud workloads and containers | High | Worker RCE plus the unpatched SCTP kernel chain can reach host root from inside a container. |
| Developer and internal services | Medium | Internal HTTP/2 endpoints are reachable from any foothold and often stay unpatched longer. |
Real-World Impact
Internet scan data counts roughly 8.8 million services on an affected version that still negotiate HTTP/2. On the evening of disclosure the number was about 9.48 million. It’s dropping as patching starts.
Treat 8.8 million as an upper bound with blind spots. Scans can’t see origins behind CDNs or distribution backports. Around 100 million NGINX services hide their version entirely and aren’t counted. Netcraft put NGINX behind more than 225 million sites in its September 2026 survey. W3Techs attributes 29.7% of sites with a known web server to NGINX. These counts move every hour, so any single number is a snapshot.
The practical scenarios follow from worker-level RCE on a server that terminates TLS. An attacker can intercept requests and read TLS private keys and secrets in worker memory. A reverse proxy or API gateway becomes a place to collect credentials. In Kubernetes, an exposed ingress-nginx with HTTP/2 on is reachable before authentication. The SCTP chain then turns a container foothold into host root.
Exploitability deserves an honest read. The public PoC is lab-grade. It needs about 128 GB of HTTP/2 traffic and takes around two and a half minutes at 10 Gbit/s. It fails on links slower than about 300 Mbit/s because of NGINX’s one-hour connection limit. It also depends on a glibc memcpy variant chosen on x86-64 CPUs with the avx512f and avx512vl features.
Those are limits of that one PoC, not of the vulnerability. A separate, unreleased exploit ran on AWS, GCP and Azure over public IP addresses, under normal concurrent traffic. That’s the stronger signal. Exposure isn’t limited to a fresh local container.
Detection Guidance
Log indicators
Look for:
- NGINX worker processes starting unexpected executables
- abnormal worker exits or core dumps
- long-lived HTTP/2 connections with heavy inbound traffic but few logged requests
- unusual outbound connections or DNS lookups from the host
A clean access log doesn’t clear a host. HTTP/2 control frames like WINDOW_UPDATE and RST_STREAM aren’t recorded as requests, so their absence proves nothing (CIRCL). A worker that starts a child program is the clearest single sign of a successful attack.
Scanner references
Run SCA and container image scans for the nginx package version across every image and host. Use external attack surface scanning to find internet-facing listeners that negotiate HTTP/2. Phoenix Security correlates these signals, so the same host isn’t reported five times.
An experimental Suricata rule (SID 9007015) fires on the flow-control sequence over cleartext h2c. It needs decrypted traffic to be useful against TLS listeners.
Verification steps for teams
- Inventory NGINX versions from the running binary, not just package metadata. A backported fix keeps the old
nginx -vstring. - Test each listener for HTTP/2 at the origin:
bash
openssl s_client -alpn h2 -connect host:443
# look for: ALPN protocol: h2
Behind a CDN, test the origin directly. A CDN that speaks only HTTP/1.1 to NGINX removes this path. 3. Scan container images and SBOMs for nginx 1.9.5 to 1.31.8 and for NGINX Plus builds before the fix. 4. Flag hosts with HTTP/3, the resolver plus SSI/mirror pattern, or the mail proxy configured. Those expose the sibling CVEs even with HTTP/2 off.
Remediation Guidance

Immediate actions
- Upgrade NGINX Open Source to 1.31.9 (mainline) or 1.30.7 (stable). For NGINX Plus, move to 37.0.8.1 or 37.3.0.1. R33 through R36 have no fix, so migrate to a fixed 37.x build. Versions and advisories are on nginx.org and in F5’s advisory index.
- Restart NGINX fully, or run a supported live binary upgrade (
USR2to the master, then retire the old one). A reload alone leaves existing workers on the vulnerable executable. - Re-pull official Docker images. The 1.31.9, 1.30.7 and Alpine tags were updated on disclosure day. For a short window before that,
lateststill pointed at 1.31.8. - On Ubuntu, apply USN-9159-1, published November 19. Debian bookworm, trixie and forky had no fixed package as of November 19. Track the Debian security tracker.
Temporary mitigations
- Disable HTTP/2 on affected listeners. On 1.25.1 and later, set
http2 off;in each server block and removehttp2fromlistendirectives. On 1.9.5 to 1.25.0, removehttp2from the listen line, solisten 443 ssl http2;becomeslisten 443 ssl;. This blocks CVE-2026-123007 and CVE-2026-123633 only. Re-run the openssl check at the origin to confirm. - Disable HTTP/3 where you don’t need it. This removes CVE-2026-121810.
- For CVE-2026-123634, avoid SSI and mirror directives, and don’t build proxied server names from variables. Pin
proxy_passto a fixed upstream. - For CVE-2026-113425, bind mail-proxy listeners to trusted networks.
- For the host-root chain, block the SCTP kernel module on hosts that don’t use it. Add
install sctp /bin/falseto a file in/etc/modprobe.d/. This doesn’t unload a module that’s already loaded.
Phoenix Security Recommendations
This vulnerability has CVEs, so SCA will flag the package. The hard part is prioritization, and version strings make it harder. A distribution backport keeps the old nginx -v number. Naive CVE matching then over-reports patched hosts and misses exposed ones. Phoenix Security resolves the real running version first, then adds reachability and exposure on top.
Contextual deduplication collapses the same NGINX finding from SCA, container and attack-surface scanners into one prioritized item per asset. You get one row per host, instead of five.
Reachability and exposure analysis separates NGINX instances that actually negotiate HTTP/2 at the origin from those behind HTTP/1.1-only CDNs and from internal-only listeners. Config state decides which of the five CVEs applies. HTTP/2, HTTP/3, the mail proxy and the resolver plus mirror pattern each gate a different flaw. Phoenix uses that state to drop noise and raise the findings that are really reachable.
Attack surface management lists the internet-facing NGINX listeners that negotiate HTTP/2 and maps each one to an owner.
Remediation campaigns turn the result into work. Create a campaign, assign owners by asset, and track the upgrade and the restart, not just the package bump. Then verify that the listener no longer negotiates the vulnerable path.
Phoenix Security ties the NGINX finding to the workloads that actually terminate HTTP/2. It filters out CDN-shielded and version-hidden noise and assigns owned, trackable fixes. A fleet-wide count in the millions becomes a short list of reachable hosts, with names against them.
See how Phoenix Security turns a fleet-wide CVE into an owned remediation list. Book a demo.
External References
- F5 security advisory K000163926: CVE-2026-123007 (NGINX ngx_http_v2_module). Sibling advisories: K000163928 (CVE-2026-123633), K000163925 (CVE-2026-123634), K000163927 (CVE-2026-121810), K000163931 (CVE-2026-113425). Full list in the F5 NGINX advisory index.
- nginx.org security advisories.
- CVE records: CVE-2026-123007, CVE-2026-123633, CVE-2026-123634, CVE-2026-121810, CVE-2026-113425.
- NGINX fix commit b89c410 (HTTP/2 flow-control bound).
- CIRCL TR-105: NGINX2Root, Remote Code Execution in NGINX and Potential Host Compromise.
- Ubuntu Security Notice USN-9159-1 and the Ubuntu CVE-2026-123007 status page.
- Debian security tracker: CVE-2026-123007.
- CISA Known Exploited Vulnerabilities catalog.
















