NGINX2Root is a set of five nginx vulnerabilities, disclosed on November 18, 2026, that let an unauthenticated attacker run commands on a web server. The most severe one, CVE-2026-123007, sits in HTTP/2 flow control and affects every upstream nginx release from 1.9.5 until the fixed versions, 1.30.7 on stable and 1.31.9 on mainline. An attacker who chains it with a separate Linux kernel bug gets root on the host.
Patching a fleet takes time. Until your rollout finishes, a proxy in front of the origin blocks three of the five CVEs and leaves the other two open.
What is NGINX2Root?
Xint, the research team at Theori, found five distinct memory-safety bugs in nginx and one in the Linux kernel’s SCTP subsystem. Xint built a working exploit for each nginx bug, and each one runs code as the nginx worker process. The kernel bug lets that worker become root, even from inside a Docker container.
The five nginx findings affect different features:
- CVE-2026-123007: integer overflow in HTTP/2 send-window accounting.
- CVE-2026-123633: use-after-free in HTTP/2 connection handling when nginx proxies to an upstream.
- CVE-2026-121810: use-after-free in HTTP/3 (QUIC) connection handling when nginx proxies to an upstream.
- CVE-2026-123634: use-after-free in the DNS resolver, reachable when a
proxy_passtarget built from variables meets an SSI ormirrorsubrequest that resolves the same name. - CVE-2026-113425: use-after-free in the mail proxy
auth_httppath.
Xint reported the bugs to F5 on October 16 and F5 shipped the fix 33 days later. Xint says it has no evidence of exploitation so far, and it is withholding its exploits.
Why NGINX2Root matters for so many servers
The HTTP/2 bug dates to nginx 1.9.5, the 2015 release that introduced HTTP/2. In a Shodan snapshot Xint took on November 10, 11.8 million of 11.94 million version-identifiable nginx hosts ran a release in the affected range. Xint notes that this measures version prevalence, not exploitable endpoints.
A default nginx configuration with HTTP/2 enabled on a public listener is vulnerable. The attacker needs no credentials and no unusual directive.
Two details make the response harder:
- Version strings mislead. Distributions backport fixes without changing the upstream version, so
nginx -valone does not tell you whether a package is patched. - Access logs show nothing. The attack uses HTTP/2 control frames, and nginx does not log those as requests.
How the HTTP/2 attack works
HTTP/2 uses flow control to stop one side from overwhelming the other. Each connection has a send window, and the peer raises it with WINDOW_UPDATE frames.
According to Xint’s writeup, nginx reserves send credit when response data enters its output queue, and a specific sequence of frames pushes the window past its limit. From there the exploit follows four steps:
- Corrupt the connection’s send window with crafted
WINDOW_UPDATEandRST_STREAMframes. - Use the invalid window to read heap memory and leak addresses.
- Overwrite a connection cleanup function pointer with controlled data.
- Close the connection, so nginx calls the pointer and runs the attacker’s commands.
All four steps need the attacker to speak HTTP/2 to the vulnerable nginx process itself. A proxy in front of the origin removes that condition.
WAF rules vs protocol termination
A web application firewall inspects requests: URLs, headers, bodies. The HTTP/2 bugs are one layer below, in frame processing, so a rule has no malicious URL or payload to match.
According to Xint’s FAQ, rules that inspect URLs or request bodies “cannot eliminate vulnerabilities in HTTP/2 frame processing code.”
The same FAQ names the control that does work. A frontend that terminates HTTP/2, forwards requests to nginx over HTTP/1.1, and blocks direct access to the nginx server “can block this attack path.” TLS passthrough, or HTTP/2 between the frontend and nginx, leaves the server exposed.
You get the protection from where the client’s connection ends, with no signature to write or maintain.
How protocol termination blocks the HTTP/2 and HTTP/3 paths
The Azion Platform runs on a distributed architecture that sits between clients and the origin. When an application runs behind it, clients connect to Azion, and Azion connects to the origin. Two separate connections carry each request.
Client to Azion. A workload terminates TLS on Azion’s distributed infrastructure and accepts HTTP/1.1, HTTP/2, and HTTP/3. Client frames, including any crafted WINDOW_UPDATE, stop there.
Azion to origin. A connector opens a new connection to the origin. The Connectors settings reference lists http1_1 as the only accepted value for http_version_policy, and the API refuses http2.
The origin’s nginx receives only HTTP/1.1 requests that the connector builds. The attacker cannot deliver HTTP/2 frames or QUIC packets to it, which removes the entry point for CVE-2026-123007, CVE-2026-123633, and CVE-2026-121810.
This holds only if the origin refuses every connection that does not come through Azion. An origin that still answers on its public IP is as exposed as before.
The impact of Azion on each NGINX2Root CVE
The table assumes the application runs behind Azion and the origin accepts connections only from Azion addresses.
| Vulnerability | Attack path | Behind Azion |
|---|---|---|
| CVE-2026-123007 | HTTP/2 flow control | Blocked. Attacker frames never reach the origin. |
| CVE-2026-123633 | HTTP/2 with an upstream | Blocked for the same reason. |
| CVE-2026-121810 | HTTP/3 (QUIC) with an upstream | Blocked when the origin’s QUIC listener is not reachable from the internet. |
| CVE-2026-123634 | resolver, proxy_pass with variables, and SSI or mirror | Not covered. Ordinary HTTP requests trigger it. Fix the configuration or patch. |
| CVE-2026-113425 | Mail proxy with auth_http | Out of scope. This is IMAP, POP3, and SMTP traffic. |
| Linux kernel SCTP bug | Local privilege escalation | Out of scope. It needs a host-level fix. |
Azion removes the entry point for three of the five nginx CVEs, including the one with the widest exposure. The other two and the kernel bug stay open, so you still need the patch.
Three scenarios and what each one leaves open
The same nginx build has a different exposure depending on how traffic reaches it.
- Origin behind Azion, firewall enforcing the Origin Shield list. The three protocol-level CVEs have no entry point. The resolver bug remains if you use that configuration.
- Origin behind Azion, public IP still answering. An attacker who finds the address reaches nginx as before.
- nginx reached through TLS passthrough, or on an internal network only. The client’s HTTP/2 connection ends at nginx itself, so all five CVEs apply to whoever can reach it.
Only the first scenario reduces risk.
How to close direct access to the origin
Protocol termination protects the origin only when the origin’s firewall blocks direct connections. Origin Shield provides the allowlist for that firewall.
Its Origin IP ACL publishes the address prefixes Azion uses to reach origins in a network list named Azion Origin Shield. Your origin’s firewall allows those prefixes and refuses every other source.
Four points matter when you set it up:
- Turn it on per connector. Origin Shield applies to connectors of type
http, and Origin IP ACL has its own switch. - Allow IPv6 as well as IPv4. A rule that covers one family leaves the other open.
- Cover UDP 443. With Azion in front, no legitimate client needs QUIC on the origin. Remove the listener or block the port.
- Keep the list current. Azion publishes changes, and new servers go into production 7 days later.
An allowlisted address proves a connection came from Azion’s infrastructure, though not from your connector. The HTTP/2 and HTTP/3 bugs stay closed either way, because connectors speak only HTTP/1.1 to origins.
Then test from outside Azion’s addresses. The connection should fail:
What you still need to patch
Update nginx
Install 1.31.9, 1.30.7, or your vendor’s security update. Then restart the service. A configuration reload does not replace the running binary, so old worker processes keep the vulnerable code until they exit.
If the update has to wait, disable HTTP/2 on public listeners. On nginx 1.25.1 and later:
On 1.9.5 through 1.25.0, remove http2 from the listen directive. Native gRPC clients require HTTP/2 and will stop working, so test first.
Fix the configurations Azion does not cover
- CVE-2026-123634: Replace
proxy_passtargets built from variables with fixed upstream groups, or turn off SSI andmirrorin those locations. Xint notes thatmirror_request_body onstopped its exploit without fixing the bug. - CVE-2026-113425: Bind mail listeners to loopback, or restrict them with a firewall allowlist.
Close the kernel path
Xint published before a kernel patch existed. On hosts that do not use SCTP, Xint suggests preventing the module from loading:
This blocks loading through modprobe only. It does not unload a running module, and it does nothing when the kernel has SCTP built in.
Include internal servers
A private network limits who can reach nginx and leaves the vulnerable code in place. An attacker with a foothold can use an unpatched internal nginx to reach other hosts.
How to check for signs of compromise
Because access logs miss the control frames, look at process and connection behavior. Xint’s guidance ranks the signals:
- Commands started by an nginx worker. This is the clearest sign. An
auditdrule onexecvefiltered by the worker UID records it, but only from the moment you install the rule. - Unexpected worker crashes. Search the error log for
signal 11orworker process exited. Crashes also have benign causes. - Odd connection profiles. Investigate any address that holds a long-lived connection and receives far more bytes than it sends.
If you confirm a compromise, isolate the host and preserve evidence before you rebuild. Treat credentials the worker could read as exposed.
Frequently asked questions
NGINX2Root questions
Next steps for NGINX2Root
Start your NGINX2Root response with the patch. Update nginx, restart it, fix the resolver and mail proxy configurations, and track your kernel vendor’s advisory for the SCTP bug.
Until that work is done, your exposure depends on what sits in front of the origin. Terminating HTTP/2 and HTTP/3 before the origin, forwarding over HTTP/1.1, and refusing direct connections removes the entry point for the three protocol-level CVEs.
If your origins already run behind Azion, check two things today: Origin Shield is on for each connector, and the origin firewall enforces the list for IPv4, IPv6, and UDP. The documentation below covers both.
