CTI Academy
Log in Create account

NGINX2Root CVE-2026-123007: nginx HTTP/2 RCE, Fix and Hunt

By CTI Academy Team

CVE-2026-123007 and four more nginx RCE flaws: affected versions, honest exploitability, exposure traps, hunting signals and the patch that covers all of them.

Every nginx release from 1.9.5 (September 2015) through 1.31.8 carries the same bookkeeping mistake. When Xint pulled a Shodan snapshot on November 10, 98.9 percent of the nginx hosts that exposed a version number fell inside the vulnerable range for CVE-2026-123007. That is 11.8 million of the 11.94 million version-identifiable hosts, out of 56.7 million nginx hosts in total; a version string alone does not prove a host is vulnerable, as Xint itself notes. Eight days later, F5 shipped the fix.

CVE-2026-123007 is the headline bug in a set of five nginx remote code execution flaws that Xint named NGINX2Root. This piece is for the people who have to answer "are we exposed?" before lunch: what the bugs are, how hard they really are to exploit, where scoping goes wrong, what to hunt for, and how to patch without fooling yourself.

Last updated: November 19, 2026. KEV status checked against the November 18 catalog; distribution package status checked November 19.

What to do now

What NGINX2Root is

NGINX2Root is the name Xint gave to five memory-corruption vulnerabilities in nginx (CVE-2026-123007, CVE-2026-123633, CVE-2026-123634, CVE-2026-121810 and CVE-2026-113425) plus an unpatched Linux kernel SCTP flaw that turns nginx worker access into root. F5 fixed the five nginx bugs in a security release on November 18, 2026: nginx Open Source 1.30.7 (stable) and 1.31.9 (mainline), and NGINX Plus 37.0.8.1 and 37.3.0.1. On NGINX Plus, the CVE-2026-123633 fix had already shipped in 37.0.7.1 and 37.2.0.1.

The most dangerous of the five, CVE-2026-123007, is an integer underflow in HTTP/2 flow control. An unauthenticated client who can reach an HTTP/2-over-TLS listener can corrupt worker memory, and in the right conditions run code with the privileges of the nginx worker process. No login, no special module, no unusual configuration. A server that only serves static files is enough.

The five CVEs at a glance

All five are rated 9.2 under CVSS v4.0 by F5 (8.1 under CVSS v3.1). What matters more than the score is the feature each one needs, because a bug is only reachable when its feature is switched on.

CVE Component Reachable when HTTP/2 off helps?
CVE-2026-123007 HTTP/2 flow control HTTP/2 over TLS Yes
CVE-2026-123633 HTTP/2 connection reuse HTTP/2 + proxying + low free connections Yes
CVE-2026-123634 Resolver Variable proxy_pass + mirror or SSI subrequest No
CVE-2026-121810 HTTP/3 (QUIC) HTTP/3 + proxying No
CVE-2026-113425 Mail proxy Mail proxy with auth_http No

The most common advice circulating ("just turn off HTTP/2") only covers two of the five. If you run HTTP/3, a mail proxy, or dynamic upstreams with mirroring, disabling HTTP/2 leaves you exposed.

The same release also fixed five more nginx CVEs that are not part of NGINX2Root, including CVE-2026-118899, an infinite loop while reading a client request body over TLS 1.3 that Tenable lists at CVSS v4.0 8.7. The patch is the only thing that covers all ten (one of them, CVE-2026-120993, affects and is fixed only on mainline).

How CVE-2026-123007 works, at the level a defender needs

HTTP/2 flow control is credit accounting. Each stream and the connection as a whole has a send window; nginx subtracts from it as it sends response data and adds to it when the client grants more credit with WINDOW_UPDATE frames.

The bug sits in the refund path. When a client cancels a stream that still has response data queued, nginx gives the unsent credit back to the connection window, and according to Wiz's root-cause analysis it never checks that refund against the HTTP/2 maximum. The connection counter can be pushed above the protocol limit. A later window-update check does unsigned arithmetic on that impossible value and wrongly passes; the oversized counter is then read as a negative length that reaches the TLS send path as an out-of-bounds memory copy.

That is the entire story for detection purposes: a client opening streams, cancelling them, and feeding the connection an abnormal volume of flow-control frames over a single long-lived TLS session. We are deliberately not going further than that. You do not need the exploitation details to defend against it, and the researchers who have them are withholding the final steps for good reason.

CVE-2026-123633, the second HTTP/2 bug, is a different shape: a use-after-free when nginx, acting as a reverse proxy and running short of connection slots, drains a connection that is still in the middle of a request. It needs proxying and resource pressure, which makes it more situational, but it is still unauthenticated.

How hard is CVE-2026-123007 to exploit?

The public proof of concept, published by Rapid7 alongside its technical analysis, is heavily constrained:

Bar chart: minutes to send 128 GB at 10 Gbit/s, 1 Gbit/s, 300 Mbit/s and 100 Mbit/s against nginx's 60-minute limit

Figure 1: The public PoC needs about 128 GB on one HTTP/2 connection. At line rate that takes under two minutes on 10 Gbit/s and 57 minutes on 300 Mbit/s; slower links hit nginx's default one-hour keepalive_time first. Traffic figure from Rapid7; times computed by CTI Academy.

Read that list and it is tempting to file this under "theoretical." Do not.

Those are constraints of one public exploit. The bug itself is less fussy. Xint says its own exploit worked against test servers on AWS, GCP and Azure, including over public IPs, using an information leak to defeat ASLR. Wiz says it achieved code execution with an ASLR bypass on official nginx 1.31.7 and 1.31.8 builds. Neither team has published its exploit. Cloud instances also often have the bandwidth and the AVX-512-capable CPUs the public PoC wants.

There is also a fresh precedent. In May, nginx's CVE-2026-42945 ("NGINX Rift") went from public PoC on May 13 to observed exploitation attempts on May 16, per VulnCheck. Three days. That bug also came with "needs ASLR off" caveats for code execution; attackers started probing anyway.

As of November 18, 2026, no source reported in-the-wild exploitation of any NGINX2Root CVE, and none was on CISA's Known Exploited Vulnerabilities catalog. That status can change this week.

The severity labels disagree, and that matters for triage

F5's CVE records score all five NGINX2Root bugs at 9.2 (CVSS v4.0). The nginx.org advisory list, from the same vendor, labels CVE-2026-123007 and CVE-2026-113425 "major" and CVE-2026-123633, CVE-2026-123634 and CVE-2026-121810 "medium."

Our reading: the nginx labels appear to weigh how common the required configuration is, while the CVSS score reflects worst-case impact when the bug is reachable.

nginx.org security advisories list showing CVE-2026-123007 as major and three other NGINX2Root CVEs as medium

Figure 2: The top of the nginx.org advisory list on November 19, 2026. The HTTP/2 flow-control bug is "major"; the resolver, HTTP/3 and HTTP/2 use-after-free bugs, all CVSS v4.0 9.2 in F5's records, are "medium". The "CVE-CVE-2026-121810" typo is on the live page. Source: nginx.org, captured 07:33 UTC.

But if your vulnerability management tool ingests one source and your SOC reads the other, the same bug can land as "critical, patch in 72 hours" in one queue and "medium, next cycle" in another.

This is a textbook case for exposure-driven prioritization over raw scores, which we cover in depth in how threat intelligence changes vulnerability prioritization. The questions that actually rank this bug for you are: is the vulnerable feature on, is the listener reachable from the internet, and is there working exploit code. For CVE-2026-123007 on an internet-facing HTTP/2 server, the answers are yes, yes, and "publicly constrained, privately working."

From nginx worker to root: the SCTP piece

nginx's master process runs as root, but the workers that handle requests normally drop to an unprivileged user such as nginx or www-data. Code execution in a worker is serious (it can read whatever the worker can, including TLS keys loaded in memory and upstream traffic) but it is not root.

Xint closed that gap with a separate bug: a use-after-free in the Linux kernel's SCTP send path, present since Linux 4.15 (2018). Chained with the nginx flaws, it gave the researchers root on the host, including from nginx running inside a Docker container.

As of November 18 the kernel bug had no CVE and no patch. Patching nginx removes the remote entry point; it does not remove this local path to root for anything else that gets code execution on the box.

The interim control is to stop the SCTP module from loading where you do not use it (very few web servers do). On most distributions that means a file in /etc/modprobe.d/ containing:

install sctp /bin/false

Know its limits: this only blocks future modprobe loads. It does nothing if SCTP is already loaded (check with lsmod | grep sctp) or compiled into the kernel. If it is loaded and unused, unload it with modprobe -r sctp or reboot after adding the rule; grep SCTP /boot/config-$(uname -r) shows =y when it is built in. Containers share the host kernel, so this is a host-level control, not something you fix inside the image.

Scoping your exposure: five traps

Asset owners will tell you "we're on a patched version" faster than they can prove it. These are the places where scoping goes wrong.

1. nginx -v lies on distribution packages. Debian and Ubuntu backport security fixes without changing the upstream version string. Xint's example: an Ubuntu 22.04 package moved from 1.18.0-6ubuntu14 to 1.18.0-6ubuntu14.22 while nginx -v still printed 1.18.0. A new-looking version string does not prove the fix is in, either. Check the full package version against your distribution's tracker (Ubuntu, Debian), and expect the status to move daily. On November 18 both listed nginx as vulnerable; by November 19 Ubuntu had shipped fixes for every supported release (for example 1.18.0-6ubuntu14.23 on 22.04 and 1.24.0-2ubuntu7.20 on 24.04, both still printing their old upstream version), while Debian had fixed only unstable (1.30.6-4) and still marked bookworm and trixie as vulnerable. If you install from the official nginx.org repository, the upstream version number is the one that counts.

2. Your CDN terminates HTTP/2, but your origin might not be hiding. A CDN or load balancer that terminates the client's HTTP/2 connection and speaks to nginx separately breaks the public PoC, because the attacker's frames never reach nginx intact. That only protects you if the origin's own TLS listener is not reachable directly. If your origin IP answers on 443 to the whole internet (historical DNS, certificate transparency logs and Censys make origin IPs easy to find), the CDN only slows an attacker down. Test the origin directly, from outside.

3. Reload is not restart. nginx -s reload re-reads configuration but keeps the old binary in memory, and old workers can linger on long-lived connections. After upgrading the package, restart nginx (or do a live binary upgrade) and confirm the running master process started after the patch. A quick check: ls -l /proc/$(cat /run/nginx.pid)/exe showing (deleted) means the old binary is still the one running.

Terminal: nginx -v reports 1.30.7 while the server header still says 1.30.6 and /proc/1/exe is marked deleted until restart

Figure 3: Our lab run with the official nginx 1.30.6 image after swapping in the 1.30.7 binary the way a package upgrade does. nginx -v reads the new file on disk, but the running server keeps answering as 1.30.6, /proc/1/exe points at a deleted binary, and a reload changes nothing. Only the restart brings 1.30.7 into memory.

4. Containers and ingress controllers keep the old build. The official Docker mainline tags now point to 1.31.9, but a running container does not change until it is rebuilt and redeployed. On Kubernetes, F5's NGINX Ingress Controller 5.8.0 and NGINX Gateway Fabric 2.9.0 move to nginx Open Source 1.31.9; confirm NGINX Plus-based images against F5's advisory. The community ingress-nginx project was archived in March 2026 and will ship no further security fixes, so clusters still running it need a migration plan rather than a patch.

5. The NGINX Plus R-series has no fix. F5's advisory lists R34 to R36 and the CVE record says R33 and later; either way, customers have to move to a fixed 37.x build (37.0.8.1 or 37.3.0.1).

nginx is also embedded in a long tail of products: appliances, control panels, API gateways, bundled web UIs. Those inherit the bug and wait on their vendor's release cycle. They belong on the asset list too; the attack surface management guide covers how to build an inventory that finds them.

Patch and mitigate

The fix: nginx Open Source 1.30.7 or 1.31.9, NGINX Plus 37.0.8.1 or 37.3.0.1, or a distribution package your vendor confirms contains the patches. Then restart.

If you cannot patch today, apply the mitigation that matches each feature you actually use. These are temporary and partial.

To confirm HTTP/2 is really off on a listener, ask for it and see what the server agrees to:

openssl s_client -connect ORIGIN_IP:443 -servername your-host -alpn h2 </dev/null 2>/dev/null | grep ALPN

If the output shows ALPN protocol: h2, HTTP/2 is still being negotiated. No ALPN negotiated is the result you want. Keep -servername: HTTP/2 can be set per server block, and without SNI you only test the default server. Run it against the origin IP as well as the public hostname.

Terminal: openssl ALPN check returns ALPN protocol h2 with http2 on and No ALPN negotiated with http2 off

Figure 4: The same check against two lab listeners on one nginx 1.30.7 build, one with http2 on, one with http2 off. The second line of output is all you need to read.

Hunting for exploitation attempts

There are no IOCs worth publishing for this one yet, and for a protocol-level bug there may never be useful ones. Behavior is the durable signal. Four places to look:

Abnormal HTTP/2 connections. The public exploit path needs a huge volume of data on a single connection over minutes, driven by flow-control frames. Look for long-lived connections to 443 where inbound volume is very large (tens of GB) but the access log shows few requests for that connection. On the host, ss -tinp state established '( sport = :443 )' shows per-connection byte counters. At the network layer, flow records or NDR sessions with extreme duration and volume on a single TLS session are worth a look. It is the same behavior-first logic that works against living-off-the-land attacks, where there is no malware hash to match either.

Logs will not show the frames. WINDOW_UPDATE and RST_STREAM frames are not requests, so they never appear in the access log. You can make the connection-level picture visible by adding $connection, $connection_requests and $request_length to your log_format, which lets you spot one connection carrying an unusual pattern of requests.

Worker crashes. Failed exploitation tends to crash workers. Grep the error log for worker process exited, signal 11 or segfault, and check coredumpctl list nginx. A cluster of worker crashes on an internet-facing HTTP/2 server this week deserves an incident ticket.

Workers spawning shells. An nginx worker has no business executing /bin/sh or /bin/bash. An auditd rule on execve and execveat filtered to the worker's effective UID, or the equivalent EDR rule on the process tree (parent nginx, child any shell or interpreter), is a high-fidelity detection that also covers future nginx bugs. Note that auditd only records events after the rule is in place, so deploy it now. Unexpected outbound connections or DNS lookups from nginx workers are worth the same alert.

If you find a crash cluster or an unexpected child process on a host that was unpatched and internet-reachable, assume the worker's secrets are exposed: rotate the TLS private keys and any upstream credentials the worker could read, and check for the SCTP module having been loaded.

The bigger signal: AI is finding nginx bugs faster

According to Xint's write-up, one of its researchers found CVE-2026-123007 while preparing for ZeroDay Cloud 2026, and a fully automated Xint scan found the other four NGINX2Root bugs a few days later without human guidance. Wiz and Rapid7 each reported CVE-2026-123007 to F5 independently in November. Three teams independently landing on a ten-year-old bug within weeks shows how much attention nginx is now getting. The four bugs found by Xint's automated scan, and NGINX Rift in May (found by depthfirst's AI-driven analysis platform), show where that attention is coming from.

Timeline of NGINX2Root disclosure: Xint, Wiz and Rapid7 independently reported CVE-2026-123007 before the Nov 18 release

Figure 5: Three research teams reached CVE-2026-123007 independently between October 11 and November 16, 2026; F5 shipped nginx 1.30.7 and 1.31.9 on November 18. Dates from the Xint, Wiz and Rapid7 disclosure timelines.

The nginx advisory list had already recorded 26 CVEs in 2026 before this batch; with it, the year stands at 36, against two in all of 2025 and seven in 2024.

Bar chart of nginx CVEs listed on nginx.org by CVE year, 2009 to 2026, with 2026 at 36

Figure 6: nginx CVEs on the nginx.org advisory list, counted by CVE year. 2026 has 36, ten of them published on November 18; no earlier year had more than seven. Source: nginx.org security advisories, counted November 19, 2026.

Expect that rate to hold, for nginx and for every other piece of mature C infrastructure sitting on the internet edge.

For defenders, that changes the planning assumption. "The edge web server is boring and stable" is no longer a safe default. An unauthenticated bug on an internet-facing server is also the kind of access initial access brokers trade in, which is why edge flaws belong at the top of any intelligence-led patch queue. Knowing where your nginx instances are, which features are switched on, and which origins are reachable around the CDN is what turns the next one into a routine afternoon. If you are newer to treating a CVE as an intelligence problem rather than just a patching ticket, our guide to what cyber threat intelligence actually is sets out that framing.

Building the judgment behind triage

Reading an advisory tells you what changed. Deciding in an hour whether a bug matters to your estate (which source to trust when the severity labels disagree, which "theoretical" caveat is real, which asset owner's "we're patched" to verify) is a skill that comes from practice.

That is what our Vulnerability Intelligence learning path is built around: working real advisories with KEV, EPSS and exposure data, scoping what is actually reachable, and writing the call your team will act on. If NGINX2Root was a scramble this week, use it to make the next one routine.

Frequently Asked Questions

What is CVE-2026-123007?

CVE-2026-123007 is an integer underflow in nginx's HTTP/2 flow-control handling. An unauthenticated client that can reach an HTTP/2-over-TLS listener can corrupt worker memory and, under the right conditions, run code as the nginx worker process. It affects nginx Open Source 1.9.5 through 1.30.6 and 1.31.0 through 1.31.8, and is fixed in 1.30.7 and 1.31.9.

What is NGINX2Root?

NGINX2Root is the name the research firm Xint gave to five nginx remote code execution vulnerabilities (CVE-2026-123007, CVE-2026-123633, CVE-2026-123634, CVE-2026-121810 and CVE-2026-113425) and a separate, unpatched Linux kernel SCTP flaw that escalates nginx worker access to root. F5 and nginx.org do not use the name.

Which nginx versions are vulnerable to NGINX2Root?

nginx Open Source releases before 1.30.7 (stable) and 1.31.9 (mainline) are affected, with the earliest affected version depending on the CVE. NGINX Plus is affected before 37.0.8.1 and 37.3.0.1, and the R-series (R34 to R36 per F5, R33 and later per the CVE record) has no fix. Distribution packages may carry backported fixes, so check the full package version against your distribution's tracker.

How do I fix CVE-2026-123007?

Upgrade to nginx Open Source 1.30.7 (stable) or 1.31.9 (mainline), or NGINX Plus 37.0.8.1 or 37.3.0.1, or install a distribution package your vendor confirms contains the fix. Then fully restart nginx, because a reload keeps the old binary running. Rebuild and redeploy containers that bundle nginx.

Does disabling HTTP/2 protect nginx from CVE-2026-123007?

Yes, disabling HTTP/2 blocks CVE-2026-123007 and CVE-2026-123633 as a temporary measure. It does not protect against CVE-2026-123634, CVE-2026-121810 or CVE-2026-113425, and it can break gRPC and other HTTP/2-dependent services. Upgrading to a fixed release is the only complete fix.

Is CVE-2026-123007 being exploited in the wild?

As of November 18, 2026, no public source reported in-the-wild exploitation, and the CVE was not in CISA's Known Exploited Vulnerabilities catalog. A constrained public proof of concept exists, and researchers at Xint and Wiz report working exploits they have not released, so this status can change quickly.

Am I safe if my nginx server sits behind Cloudflare or another CDN?

Partly. A CDN or load balancer that terminates HTTP/2 and connects to nginx separately breaks the public exploit, because the attacker's frames do not reach nginx intact. You are still exposed if the origin's TLS listener is reachable directly from the internet, so test the origin IP itself and patch regardless.

Is reloading nginx enough after installing the patch?

No. A reload re-reads configuration but keeps the old executable running, and old workers can stay alive on long-lived connections. Restart nginx fully or perform a live binary upgrade, then confirm the running master process started after the update.

Does running nginx in Docker protect against NGINX2Root?

No. Xint reports the kernel SCTP flaw let it reach root on the host even from nginx running inside a Docker container, because containers share the host kernel. Rebuild and redeploy images on a fixed nginx version and block the SCTP module on the host where it is not needed.

Sources

Continue with the Vulnerability Intelligence Learning Path

Start Learning Path

Related Articles

Read more at CTI Academy Blog