CVE-2026-123007 NGINX2Root: Unauthenticated RCE in NGINX HTTP/2 — Analysis & Mitigation

On November 18, 2026, F5 and the NGINX project released emergency fixes for a set of memory corruption flaws in NGINX, the web server and reverse proxy that sits in front of more than a third of the world's websites. The most dangerous of them, CVE-2026-123007, lets an attacker who has never logged in run code on the server — all it needs is HTTP/2 switched on. The researchers who found the flaws named the set NGINX2Root, because the headline bug can be chained with a separate Linux kernel flaw to reach full root access on the host, including escaping a Docker container. This analysis explains what the flaw is, how it works in general terms, who is exposed, how to check your own servers, and what to patch first.

The short version: if you run NGINX Open Source between versions 1.9.5 and 1.31.8 with HTTP/2 enabled, you are affected. Upgrade to NGINX 1.30.7 (stable) or 1.31.9 (mainline), or install your Linux distribution's backported fix, and restart the service. A configuration reload alone does not replace the running binary, so the restart step matters. If you cannot patch immediately, disabling HTTP/2 blocks this flaw and one other — but not the rest of the set.

What Is NGINX2Root?

NGINX2Root is the name given by the research firm Xint, the research unit of Theori, to five critical vulnerabilities in NGINX that were disclosed together on November 18, 2026. F5 assigned every one of the five a CVSS v4.0 score of 9.2 (Critical) and a CVSS v3.1 score of 8.1 (High). Each flaw is independent: each one on its own can lead to remote code execution, but each needs a different NGINX feature to be in use. The five are:

CVE What it is Needs this setup Affected NGINX Open Source
CVE-2026-123007 Integer underflow in HTTP/2 flow control, leading to heap buffer overflow HTTP/2 enabled 1.9.5 to 1.31.8
CVE-2026-123633 Use-after-free in HTTP/2 connections HTTP/2 enabled and proxying to a backend 1.19.7 to 1.31.8
CVE-2026-123634 Use-after-free in the DNS resolver Proxying to a server name with variables, with an SSI or mirror subrequest resolving the same name 1.13.4 to 1.31.8
CVE-2026-121810 Use-after-free in HTTP/3 HTTP/3 (QUIC) enabled and proxying 1.25.0 to 1.31.8
CVE-2026-113425 Use-after-free in the mail proxy Mail proxy with proxy on and auth_http 0.5.33 to 1.31.8

The name NGINX2Root comes from the demonstrated attack chain. Xint showed that CVE-2026-123007, chained with a separate use-after-free flaw in the Linux kernel's SCTP subsystem, can escalate from code running as the NGINX worker process all the way to root on the host — and it demonstrated the full chain over the public internet against servers running on AWS, GCP and Azure, including escaping a Docker container to reach the underlying host. The kernel flaw had no CVE identifier and no public patch at the time of disclosure. On its own, CVE-2026-123007 gives an attacker code execution as the NGINX worker, which is normally an unprivileged account; the "root" in the name depends on that second, separate kernel bug.

Xint found the flaws on October 11, 2026, while preparing for the ZeroDay Cloud 2026 event, and reported all five to F5 through HackerOne on October 16, 2026. Several research teams found the same bugs independently — Wiz Research, Rapid7, Ikotas Labs and Metnir are all credited — which is a sign of how visible the flawed code was once someone looked at it closely. In total, the November 18 releases fixed ten vulnerabilities in NGINX; the five above are the critical set.

How CVE-2026-123007 Works

To understand the flaw, it helps to know what HTTP/2 flow control is for. HTTP/2 lets a client and a server exchange many streams of data over a single connection. Flow control is the bookkeeping that stops one side from flooding the other: each side keeps a "window" that says how much data it is willing to receive, and the window grows when the receiving side sends a WINDOW_UPDATE frame saying it has room for more. NGINX tracks this window with a counter in its HTTP/2 code.

CVE-2026-123007 is an integer underflow in that bookkeeping. The sequence, as described in the public write-ups, works like this. When response data enters NGINX's output queue, the server reserves part of the connection's send window for it. A WINDOW_UPDATE frame from the client can then replenish that credit while the data is still sitting in the queue. If the client then cancels the stream, the unsent data is removed from the queue and its reserved credit is returned — and that refund pushes the window counter past its permitted maximum. The next time NGINX checks the window, it computes the remaining capacity from a value that is already over the limit. Because the code interprets that value inconsistently as signed and unsigned, it ends up using a wrong, oversized length when copying data in the TLS output path. The result is an out-of-bounds read and write on the heap: memory is read and overwritten beyond the buffer that was allocated for it.

At best, that corrupts the heap enough to crash the NGINX worker process, which is a denial of service. At worst, an attacker who controls the data can overwrite a function pointer stored on the heap — specifically, the cleanup function pointer for the connection — so that when the connection closes, the attacker's code runs instead. That is how a bookkeeping error becomes remote code execution, running with the privileges of the NGINX worker process.

Two things make this flaw unusually serious. First, the vulnerable code has been in NGINX since HTTP/2 support arrived in version 1.9.5, released in 2015 — more than a decade of releases carry it, which is why the affected range starts at 1.9.5 and runs through 1.31.8. Second, the only precondition is that HTTP/2 is enabled on a port an attacker can reach. Wiz Research confirmed code execution on a server doing nothing but serving static files, with no application logic and no extra modules. No login, no user interaction and no application vulnerability is needed.

The fix, in the public NGINX commit, adds a counter for queued frames and counts those frames when validating a client's WINDOW_UPDATE, so the window can no longer be pushed past its maximum by the refund sequence described above. That is a small, targeted correction to the accounting — which is exactly what you would expect for a bug that lived in plain sight for eleven years.

Impact and Exposure

The exposure is enormous because NGINX is everywhere. It is one of the most widely deployed web servers and reverse proxies in the world, sitting in front of websites, APIs, load balancers, content delivery networks and Kubernetes ingress controllers. Censys, which tracks internet-facing services, reported about 8.8 million NGINX services running a potentially affected version with HTTP/2 enabled as of November 19, 2026, out of more than 331 million NGINX web properties it tracks. Xint's own check of Shodan data from November 10 found 56.7 million hosts matching NGINX; of the 11.94 million that revealed a version number, 98.9 percent fell inside the affected range for CVE-2026-123007. Those counts are estimates, not confirmed vulnerable installations — a version string does not prove a server is unpatched, because Linux distributions backport fixes without changing the version number, and many servers hide their version entirely. But they show the scale of the population that had to be checked in a single week.

The good news, as of November 20 to 21, 2026, is that no exploitation in the wild had been reported, and none of the five CVEs had been added to CISA's Known Exploited Vulnerabilities catalog. That is not a reason to relax. A public proof of concept already exists: Rapid7 published a working exploit for CVE-2026-123007 on the day of disclosure, and Censys reproduced code execution with it in a lab, running as the NGINX worker rather than root. Wiz Research confirmed remote code execution with an address-space-layout-randomization bypass against official NGINX 1.31.7 and 1.31.8 builds, but has not released its exploit. The Rapid7 exploit is not plug-and-play — it needs roughly 128 gigabytes of HTTP/2 traffic over a single connection and was built against one specific test setup, including a particular memory-copy routine — but a public exploit lowers the bar for every attacker who follows, and fake exploits are already circulating. The window between a patch release and a reliable public exploit is rarely long.

There is also a second-order impact that defenders should not miss. Even without code execution, the flaw is a reliable crash primitive: the heap corruption typically ends in a worker segmentation fault. An attacker who cannot get code execution can still take a worker down repeatedly, and a flood of such crashes is a denial of service against the sites behind that NGINX instance. Patching removes both the code execution path and the crash path at once.

Who Is Affected

For CVE-2026-123007, the answer is simple: any deployment running NGINX Open Source from 1.9.5 through 1.31.8 with HTTP/2 enabled on a reachable listener. That includes the stable 1.30 branch up to 1.30.6 and the mainline 1.31 branch up to 1.31.8. NGINX Plus is affected in releases 37.0.0 to 37.0.7.1 and 37.1.0 to 37.2.0.1, and in the R34 to R36 branches, for which there is no patch — those must be upgraded to a fixed 37.x release. Products and Kubernetes ingress controllers that embed NGINX are affected through the NGINX version they bundle, and the retired ingress-nginx controller will not receive a fix at all, so deployments using it need a migration plan rather than a patch.

The other four flaws narrow the population, but each still covers a common setup. CVE-2026-123633 needs HTTP/2 plus proxying to a backend, which describes most reverse-proxy deployments. CVE-2026-121810 needs HTTP/3, which is less common but growing. CVE-2026-123634 needs a specific resolver and subrequest configuration, and CVE-2026-113425 needs the mail proxy. Because the five flaws are independent, a server can be exposed to several of them at once — and disabling HTTP/2 blocks only CVE-2026-123007 and CVE-2026-123633, not the other three.

One trap deserves a warning. Version numbers lie after a backport. Ubuntu 24.04 ships NGINX 1.24.0, and its fixed package is versioned 1.24.0-2ubuntu7.20, while the command nginx -v still prints 1.24.0. Checking the version string alone can therefore report a patched server as vulnerable, or, worse, a server that looks old but is actually fixed can be left alone while a genuinely vulnerable one is missed. Always check the package version your distribution reports, not just the number NGINX prints, and confirm against your distribution's security advisory. Ubuntu, Debian 12 and 13, RHEL 10, AlmaLinux 10, Amazon Linux, Alpine and openSUSE Tumbleweed had fixed packages within days of disclosure; RHEL 8 and 9 and SLES were still pending as of November 20, 2026, so their users should watch their vendor advisories and use the HTTP/2 workaround in the meantime.

How to Detect It

Detection is harder than usual for this flaw, and defenders should know why before they start hunting. The attack traffic consists of HTTP/2 WINDOW_UPDATE and RST_STREAM control frames. NGINX does not log those as requests, and they travel inside an encrypted TLS connection, so normal access logs show almost nothing about an attempt. A hunt that only looks at access logs will miss it. The public investigation guidance from Xint and others points to four places instead: connections, worker stability, processes and network traffic.

Start with worker stability, because a memory corruption attempt usually leaves crashes behind before anything else. Look in the NGINX error log for worker process crashes, segmentation faults and unexpected worker restarts, and correlate them with inbound traffic. Repeated worker crashes on an HTTP/2 server, especially alongside spikes in connections, should be investigated rather than dismissed as routine instability. For the resolver flaw, CVE-2026-123634, the vulnerable code path writes an alert to the error log reading "could not cancel" followed by a name being resolved; a hit naming an unfamiliar domain deserves a closer look.

Next, look at connections. A single client connection held open for minutes, with bytes received climbing fast while little is sent back, is the shape of this attack: the exploit needs a very large volume of HTTP/2 traffic over one connection, so a long-lived connection pushing far more data in than out stands out. The guidance suggests listing established connections on port 443 twice and comparing them, watching for one connection whose received byte count jumps sharply between the two samples while its sent count barely moves.

Then check processes. A worker that spawns a shell, or any unexpected child process running under the NGINX worker user, is the loudest single signal of a successful compromise. Look for new or modified files under the NGINX configuration directory or the web root outside a change window, and for outbound connections from the web server to unfamiliar hosts after a burst of requests. Privilege transitions are the final alarm: the NGINX worker account reaching root-owned resources or a shell means the kernel chain has already succeeded.

Be honest about the limits of hunting here. None of these signals is a confirmed exploit artifact, and a crash on its own proves only that a worker died, not that it was attacked. But on an unpatched, internet-facing NGINX server, a cluster of these signs together — crashes, one heavy long-lived HTTP/2 connection, and a new child process — is enough to treat the host as compromised until proven otherwise, isolate it, and rebuild from a known-good image rather than trying to clean it in place.

How to Fix It

The fix is an upgrade, and it should be treated as urgent. For NGINX Open Source, move to 1.30.7 on the stable branch or 1.31.9 on the mainline branch, or install your distribution's backported package — Ubuntu's is USN-9159-1, and Debian, RHEL 10, AlmaLinux 10, Amazon Linux and Alpine all shipped fixed packages within days. For NGINX Plus, upgrade to 37.0.8.1 or 37.3.0.1. The official NGINX Docker images on Docker Hub carry the fixed releases, so pull the images again rather than assuming a cached copy is current. And restart the service after upgrading: a configuration reload alone does not replace the running executable, so a reload without a restart leaves the vulnerable code in memory.

If you cannot patch today, reduce the exposure in this order. First, disable HTTP/2 on the affected listeners. On NGINX 1.25.1 and later, set http2 off in the affected server blocks and remove the http2 parameter from any listen directive; on older versions, remove http2 from listen. That blocks CVE-2026-123007 and CVE-2026-123633, the two HTTP/2 flaws, which are the most broadly dangerous of the five. It does not block the HTTP/3, resolver or mail proxy flaws, so also disable HTTP/3 where it is on, avoid resolving upstream addresses dynamically during the request phase, and stop exposing the mail proxy publicly or restrict access to it. Second, reduce the path to root: where the SCTP kernel module is not needed, block it from loading until a kernel fix ships, since the demonstrated root escalation depends on that subsystem. Third, if your origin sits behind a proxy that terminates HTTP/2 itself, confirm the origin cannot be reached directly — Cloudflare, for example, has said its own edge is not affected and that sites using its HTTP proxy are protected from the HTTP/2 and HTTP/3 flaws as long as the origin server is not directly reachable.

After patching, verify rather than assume. Confirm the running binary reports a fixed version, confirm the package manager agrees, and confirm the service actually restarted with the new binary. Then inventory everything again, because NGINX hides in places people forget: containers, sidecars, ingress controllers, appliances, and products that embed it. Treat any internet-facing NGINX instance as in scope until you can prove its build is patched.

Lessons for Defenders

The first lesson is about age. This flaw sat in NGINX's HTTP/2 code for more than eleven years, in one of the most reviewed codebases in the world, and it was found by several independent teams in the same period. Old code is not safe code, and a protocol implementation that has worked flawlessly for a decade can still carry a counting error that nobody noticed. Long-lived, boring infrastructure deserves the same review attention as new features — arguably more, because its blast radius is larger.

The second lesson is about defaults. HTTP/2 is enabled on the overwhelming majority of HTTPS sites, which is why a flaw that needs nothing more than HTTP/2 became the most dangerous of the five. A feature that is on by default on millions of servers turns a single bug into a global incident. Inventory your enabled features as carefully as your versions, and know which of your listeners have HTTP/2 or HTTP/3 switched on before an advisory forces you to find out.

The third lesson is about detection. An attack that lives in encrypted control frames, invisible to access logs, is a reminder that logging requests is not the same as observing a server. Connection telemetry, process ancestry and crash data caught what the access log could not. If your monitoring cannot see a worker crash, a shell spawned by a web server user, or a single connection moving gigabytes, then your next incident will be discovered by someone else.

The fourth lesson is about chaining. CVE-2026-123007 on its own gives code execution as an unprivileged worker. The root escalation came from a completely separate bug in a different component — the Linux kernel's SCTP subsystem — that had nothing to do with NGINX. Defence in depth is not an abstract idea here: the kernel module that made the chain possible was loaded on servers that had no use for SCTP at all. Removing what you do not need is a real control, and it costs nothing.

Finally, the disclosure itself is a model worth noting. The researchers reported through HackerOne, the vendor shipped fixes on the same day as disclosure, distributions followed within days, and multiple teams published detection guidance instead of keeping it private. The window for defenders is still short — a public exploit exists — but it is a window, and it is open now. Use it.

Frequently Asked Questions

What is CVE-2026-123007?
An integer underflow in NGINX's HTTP/2 flow control that leads to a heap buffer overflow. An unauthenticated remote attacker can crash the NGINX worker or, where memory protections are disabled or can be bypassed, run code as the worker process. It is the most serious of the five NGINX2Root flaws because it needs only HTTP/2 enabled.

Which NGINX versions are affected?
NGINX Open Source 1.9.5 through 1.31.8 with HTTP/2 enabled. Fixed in 1.30.7 (stable) and 1.31.9 (mainline). NGINX Plus is fixed in 37.0.8.1 and 37.3.0.1.

Is there a public exploit?
Yes. Rapid7 published a working proof of concept on the day of disclosure, November 18, 2026, and Censys reproduced code execution with it in a lab. It is not plug-and-play — it needs a very large volume of HTTP/2 traffic and was built for one specific setup — and fake exploits are also circulating.

Has it been exploited in the wild?
No exploitation in the wild had been reported as of November 20 to 21, 2026, and none of the five CVEs was in CISA's Known Exploited Vulnerabilities catalog at that time.

Does disabling HTTP/2 fix it?
Disabling HTTP/2 blocks CVE-2026-123007 and CVE-2026-123633, but not the other three NGINX2Root flaws. It is a valid emergency mitigation, not a substitute for patching.

Do I need to restart NGINX after patching?
Yes. A configuration reload alone does not replace the running executable, so the vulnerable code stays in memory until the service restarts.

What does "NGINX2Root" mean?
It is the name the researchers gave the set of five NGINX flaws plus a Linux kernel flaw. Chained together, the flaws were demonstrated to escalate from code execution as the NGINX worker to root on the host, including escaping a Docker container.

Related posts:

Report by Faizan Akhtar — The Cyber Security Researcher