NGINX2Root: Five nginx Flaws Led by CVE-2026-123007, and the Kernel Step That Stays Open
- Saeed Abbasi
- 326 reads
Five nginx flaws in NGINX2Root, led by CVE-2026-123007, affect servers with HTTP/2 enabled. Fixed builds exist, but the kernel step has no patch yet.

The part of NGINX2Root that deserves attention isn't the 9.2 score. It's that the lead flaw is unauthenticated, sits in nginx's own HTTP/2 code, and reaches the process that handles live traffic on the internet-facing edge. Patching nginx closes the remote entry point. It does not close the whole chain, because the researchers' route to root runs through a Linux kernel flaw that has no patch yet.

What CVE-2026-123007 actually does
HTTP/2 lets a client tell the server how much data it may send, using flow-control windows. nginx can lose track of that allowance when a client cancels requests at the right moment. The incorrect count leads nginx to copy memory it shouldn't touch. That's an integer underflow feeding a memory-corruption bug, and it's the reason the CVE is listed with an integer underflow detection elsewhere in this write-up.
F5 describes the typical outcome as a crash of the nginx worker, the process serving live connections. It also says code execution is possible where ASLR, the address-space randomization that makes exploitation harder, is disabled or bypassed. The team at Xint, which named NGINX2Root, says it did exactly that. It leaked memory addresses and then ran commands as the nginx worker over a public HTTPS port. Xint's write-up covers the details.
Here's the thing that matters for planning: the worker's account sets the ceiling. Workers normally run as a restricted user. If yours already runs as root in a given environment, the RCE is root, and no second flaw is needed. Where the worker is unprivileged, the researchers chained a separate flaw in the Linux kernel's SCTP code, a transport protocol the kernel supports alongside TCP, to reach root. They report root on the host, including from nginx running inside a Docker container. That kernel flaw has no CVE and no patch at the time of disclosure.
So the practical split is simple. Upgrading nginx removes the remote foothold. It doesn't remove the local escalation path, which needs its own tracking.
What an attacker gets from the worker
Qualys TRU's assessment lists three outcomes that matter to a business, and I'd rank them in this order:
- Exposure of traffic and keys. Code running in the worker sees requests and responses after nginx decrypts them. That includes passwords and session tokens. TLS private keys held in software and readable by the worker may also be exposed.
- A foothold behind the perimeter. Backend systems usually trust the proxy in front of them. An attacker who controls the proxy starts from a trusted position.
- Outages. Even a failed attempt can crash workers and drop connections.
The first outcome is the one application teams tend to underestimate, so it gets its own section below.
The other four flaws, and why they need different checks
NGINX2Root bundles four more nginx flaws. F5 scores all five at 9.2 under CVSS v4.0 and 8.1 under CVSS v3.1, and the same fixed releases address them. The exposure conditions differ, and that's where teams can save time. Turning off HTTP/2 is a partial mitigation at best.
| CVE | Configuration that puts a server in scope | Does turning off HTTP/2 help? |
| CVE-2026-123007 | HTTP/2 enabled | Yes |
| CVE-2026-123633 | HTTP/2 for clients, requests passed to a backend, and a worker running low on connections | Yes |
| CVE-2026-123634 | Proxying where the backend server name contains variables, plus an SSI or mirror subrequest that looks up the same name | No |
| CVE-2026-121810 | HTTP/3 enabled | No |
| CVE-2026-113425 | nginx used as a mail proxy | No |
Two things stand out. First, an HTTP/3-only or mail-proxy deployment can be exposed to one of these flaws even if it has HTTP/2 switched off. Second, the variable-based backend issue in CVE-2026-123634 needs a specific proxy layout, so an inventory check that only looks for HTTP/2 will miss it.
Why this is also an application security problem
NGINX2Root is an infrastructure bug, but its impact lands on the applications behind nginx. Where nginx terminates TLS and proxies requests, every login, API call, and session cookie bound for those applications passes through the worker in cleartext. Code running there sits between users and the systems they trust, and that position leads to four concrete problems:

- Credentials and tokens become reusable. Passwords, session cookies, API keys, and bearer tokens read from the worker can be replayed straight at the applications and APIs behind the proxy. The replayed requests look like ordinary user traffic.
- Trust placed in the proxy becomes the attacker's. Internal APIs and admin interfaces are often reachable only from the proxy. Applications that accept identity or client details from headers the proxy sets, such as X-Forwarded-For or user headers added after single sign-on, will believe whatever a compromised proxy sends.
- Traffic can be altered in transit. Because requests and responses pass through the worker, an attacker can change what users receive and what the backend processes, with no change to application code.
- One proxy, many applications. A shared reverse proxy or Kubernetes ingress controller often fronts dozens of applications owned by different teams. One worker crash takes all of them offline together.
For application security teams, the scoping question isn't only which hosts run a vulnerable build. It's which applications and APIs depend on those hosts, what data they handle, and who owns them. That mapping is slower to build than a version scan, and it's the part that sets priority.
Are you affected?
A system is in scope only when both conditions hold: a vulnerable build, and HTTP/2 reachable on a listener the attacker can connect to.
| Condition | Affected | Not affected |
| nginx build | Unpatched NGINX Open Source 1.9.5 through 1.31.8. Unpatched NGINX Plus: 37.0.0 before 37.0.8.1, 37.1.0 before 37.3.0.1, and R33 and later R-series releases | NGINX Open Source 1.30.7 and 1.31.9. Releases before 1.9.5, which predate HTTP/2 support. Builds compiled without the HTTP/2 module. Any vendor build that contains the fix |
| HTTP/2 | Turned on for at least one listener, with http2 on, or with http2 on a listen line | Not turned on for any listener |
F5 didn't evaluate versions past End of Technical Support. It lists BIG-IP, BIG-IQ, and F5OS as not vulnerable in its advisory.
The researchers' checks run on the nginx host. The first confirms the build includes HTTP/2:
nginx -V 2>&1 | grep -o -- '--with-http_v2_module'The second shows whether the configuration turns HTTP/2 on:
sudo nginx -T 2>&1 | sed 's/#.*//' | grep -nE 'listen[[:space:]].*http2|^[[:space:]]*http2[[:space:]]+on[[:space:]]*;'Run the third from outside your network. An ALPN result of h2 means the server accepts HTTP/2 from the internet:
openssl s_client -connect HOST:443 -servername HOST -alpn h2 </dev/null 2>&1 | grep -E 'ALPN protocol:|No ALPN negotiated'Three cautions apply when you read those results. Don't rely on nginx -v alone, because distributions often backport a fix without changing the version string, so compare the full package version against the distribution's advisory. Check where the HTTP/2 connection terminates, since a CDN or load balancer in front may handle HTTP/2 itself, and an outside test then reaches only that device. Test the nginx port directly. And treat internet exposure as a way to set order, not a way to close findings. An internal nginx with HTTP/2 on is still reachable by anyone already inside the network.
Where else nginx is hiding
nginx ships inside many other products, and the status varies. As of November 18, 2026:
| Where nginx runs | Status |
| F5 NGINX Ingress Controller | Release 5.8.0 builds on NGINX Open Source 1.31.9. For NGINX Plus images, confirm the build against F5's advisory |
| F5 NGINX Gateway Fabric | Release 2.9.0 moves to NGINX Open Source 1.31.9. For NGINX Plus images, confirm the build against F5's advisory |
| Community ingress-nginx for Kubernetes | Archived in March 2026. The project states it will ship no further security fixes |
| Linux distribution packages | Ubuntu and Debian list their nginx packages as vulnerable, with no fixed package yet |
| Docker nginx image | Mainline tags now point to 1.31.9. Running containers stay on the old build until you pull and redeploy |
| Other products that bundle nginx | Potentially affected. Verify the bundled nginx version, vendor backports, and whether the vulnerable feature is enabled |
The community ingress-nginx row is the one I'd flag first. An archived project won't get the fix, so any cluster still running it needs a migration plan rather than a patch.
Exploitation status and what slows it down
As of November 18, 2026, there's no public confirmation of exploitation in the wild. Working exploit code is public, though. The Xint team says its own exploit works over public IP addresses on AWS, GCP, and Azure, and it's holding back the final steps.
The public exploit is awkward to use. It sends a very large number of HTTP/2 control messages over one long-lived connection for several minutes. It has to reach nginx directly, and it depends on a specific memory-copy routine in the standard Linux C library, on 64-bit Intel and AMD processors.
Those constraints slow mass exploitation. They don't protect a particular internet-facing server from a capable attacker, and Qualys TRU expects other techniques may follow. I'd plan around the assumption that the hard parts will get easier, not the reverse.
Fixes and interim mitigations
Updating nginx is the only complete fix. F5 released fixed builds on November 18, 2026.
| Product | Affected | Fixed build |
| NGINX Open Source, mainline | 1.31.0 through 1.31.8 | 1.31.9 |
| NGINX Open Source, stable | 1.30.0 through 1.30.6 | 1.30.7 |
| NGINX Open Source, older branches | 1.9.5 through 1.29.x | None listed. Move to 1.30.7 or 1.31.9, or use a vendor package that contains the fix |
| NGINX Plus 37.1 and later | 37.1.0 before 37.3.0.1 | 37.3.0.1 |
| NGINX Plus 37.0 | 37.0.0 before 37.0.8.1 | 37.0.8.1 |
| NGINX Plus R-series | R34 through R36 in F5's advisory, R33 and later in the CVE record | None listed. Move to a fixed 37.x build |
Two operational points tend to get missed. Reloading nginx applies configuration changes but keeps the old binary running, so the flaw stays in memory until a full restart. And Linux distributions publish on their own schedules. As of November 18, Ubuntu and Debian hadn't shipped fixed packages, so use your vendor's advisory to identify the fixed package and confirm it covers CVE-2026-123007.
If you can't patch today, turn HTTP/2 off on every affected listener. That covers CVE-2026-123007 and CVE-2026-123633 only, and it doesn't replace the patch. nginx's http2 directive documentation covers the exact steps, and CERT-EU's advisory is another reference. Clients fall back to HTTP/1.1. Anything that depends on HTTP/2, such as gRPC, will break, so test before you push the change.
What risk and vulnerability teams should change
Qualys TRU's guidance for teams running this response is practical, and I'd adopt most of it:
- Don't let the score set the deadline. At 8.1 under CVSS v3.1, many remediation rules would file this as High. Public exploit code and an internet-facing server matter more than the number. Treat vulnerable nginx with externally reachable HTTP/2 as urgent.
- Close findings on evidence. A server is done when the fixed build is installed, nginx has been restarted, and the vendor advisory confirms the package covers all five CVEs. Track patched, temporarily mitigated, not exposed by configuration, and unknown as separate states. Don't count unknown as safe.
- Fix the template as well as the server. Container images, Helm charts, machine images, and autoscaling templates all need the new build. Otherwise the next scale-out or failover brings the vulnerable version back.
- Map each nginx instance to the applications behind it. A host inventory shows where a vulnerable build sits. It doesn't show which applications, owners, and data depend on it. Use that mapping to set priority and to notify application owners.
- Put an end date on every workaround. Disabling HTTP/2 covers two of the five flaws, and the next configuration push can quietly undo it. Record who owns each exception and when it expires.
- Decide what to do with nginx that won't get a fix. The archived ingress-nginx project and the older NGINX Plus R-series branches need a migration plan or a signed risk acceptance.
- Treat local privilege escalation as part of this response. Where the worker runs unprivileged, any local escalation flaw reachable from the worker's context can serve as the second step. The SCTP flaw is one. Patch known local escalation flaws on nginx hosts, in the kernel and elsewhere, with the same urgency. A current kernel doesn't mean the SCTP flaw is fixed, because that flaw has no patch yet.
Detection tooling
Qualys says it has added detection coverage for NGINX2Root. Its Cybersecurity Asset Management inventory can list every nginx installation with its version, which tells you which hosts fall in the affected range. The inventory doesn't show whether HTTP/2 is on or whether a distribution has backported the fix, so those checks still happen separately. Container-bundled and appliance-bundled nginx may not appear in a standard inventory either.
Qualys also describes InstaScan, which checks new vendor advisories against software inventory it already holds and creates CVE-2026-123007 findings in its Enterprise TruRisk Management platform, typically within minutes of an advisory. Because it matches on the installed version, it has the same blind spots as any version-based check. Qualys says it has added version-based detections for all five CVEs in its TotalAppSec product, with QIDs 520441 through 520450. Each one reports that the nginx version identified for an application falls in an affected range. A detection marks an application for investigation, not for closure. Whatever tool you use, close the finding only after you've confirmed the build and the configuration on the host.
The next things to watch are the Ubuntu and Debian fixed packages, whether the SCTP kernel flaw gets a CVE and a patch, and whether the public exploit's constraints loosen. Those three will tell you whether the window for the unprivileged-worker case is closing or staying open.