Five unauthenticated nginx RCE flaws, led by CVE-2026-123007 in HTTP/2. Affected versions, what logs and WAFs miss, and how to patch or mitigate.

TL;DR
TL;DR
- What is affected: nginx 1.9.5 through 1.30.6 and 1.31.0 through 1.31.8 with HTTP/2 on is the highest risk. HTTP/3, the resolver with mirror pattern and the mail proxy each carry their own CVE. The five are CVE-2026-123007, CVE-2026-123633, CVE-2026-121810, CVE-2026-123634 and CVE-2026-113425.
- Why it is hard to see: the main bug is triggered by HTTP/2 control frames, which are not requests, so it may leave little in access logs and gives a WAF or a DAST scan nothing to match on.
- What we see at Harness: 2,372 discovered APIs report a vulnerable nginx version. That is version exposure, not confirmed exploitability.
- What to do: after upgrading, restart nginx, because a reload does not swap the binary. If you cannot patch today, turn off HTTP/2 and HTTP/3 on exposed listeners, and watch for long-lived connections with heavy control-frame traffic.
On November 18, 2026, Xint researchers disclosed nginx2root, a set of five unauthenticated remote code execution (RCE) vulnerabilities in nginx, plus an unpatched Linux kernel bug that turns a compromised nginx worker into full root on the host.
The worst one, CVE-2026-123007, has been in nginx's HTTP/2 code since 2015. It needs no credentials, no plugins and no special setup. HTTP/2 just has to be on, so check whether your nginx enables it.
nginx sits in front of a huge share of the web, so this is not a one-service problem. Chain in the kernel bug and the attacker owns the host.
Fix: upgrade to nginx 1.3.0.7 (stable) or 1.31.9 (mainline), both released November 18.
Which nginx versions and setups are affected?
Anyone running nginx with HTTP/2 enabled on an unpatched version. A few details change the urgency:
- Highest risk: nginx 1.9.5 through 1.30.6 and 1.31.0 through 1.31.8 with HTTP/2 on and a TLS port reachable from the internet.
- Also in scope: HTTP/3 (CVE-2026-121810), the resolver with mirror pattern (CVE-2026-123634) and the mail proxy (CVE-2026-113425). Each has its own fix.
- Version numbers can mislead. Ubuntu 22.04 still reports nginx 1.18.0 after security updates, and only the full package version (1.18.0-6ubuntu14.22 in Xint's example) shows which fixes it has. Check your distribution's advisory, not nginx -v.
- A CDN or load balancer in front of nginx only tells you about the edge. Check the origin too.
The table below lists, for each of the five CVEs, what must be true of your server, the first affected nginx version and whether disabling HTTP/2 fixes it .

Why nginx2root is severe
Three things make nginx2root worse than the average vulnerability.
- No login required. The attack needs only a reachable TLS port with HTTP/2 enabled. Xint demonstrated it against a plain static-file server, with no backend application and no third-party module.
- It works in the real world. Xint's exploit worked under concurrent normal traffic and across servers with different hardware, on AWS, GCP and Azure, including over public IP addresses.
- It may leave little evidence in request logs. The control frames that trigger the bug are not logged as requests, and a WAF that inspects parsed requests has nothing to match on. The attack is loud elsewhere: Wiz notes that it takes a large number of WINDOW_UPDATE frames over a long-lived connection, which the network checks below are built to catch.
Can a WAF or DAST detect nginx2root?
Short answer: for the exploit itself, mostly no. Security teams are asking whether a WAF or a DAST scan can catch nginx2root, and the reason it mostly cannot shapes what you can do instead.
HTTP/2 splits traffic into small labeled frames. Some frames carry requests (HEADERS and DATA), and those are what your access log, WAF and scanner see. Others are the connection managing itself: SETTINGS, PING, WINDOW_UPDATE and RST_STREAM. CVE-2026-123007 is triggered by a sequence of those control frames. They are not requests, they do not appear in the access log as individual requests, and a WAF that inspects parsed requests has nothing to match on. Xint puts it more carefully: an attack may leave little evidence in nginx access logs.

The left lane is what your tools were built for. The right lane is where this bug lives.
One of the other four, CVE-2026-123633, is also an HTTP/2 bug. The remaining three sit further from HTTP/2. One depends on attacker-controlled DNS answers, one runs over HTTP/3 on UDP, and one is in the mail proxy.
What testing can do is find exposure. A scanner can check whether a target negotiates h2 during the TLS handshake (ALPN), whether it advertises HTTP/3 through an Alt-Svc header, and which nginx version it reports. That tells you which endpoints are in scope for patching.
It does not prove a server is vulnerable, because distributions backport fixes without changing the version string. And it should never mean running the exploit against production, since the bug corrupts memory and can crash workers.
How much nginx is in the affected version range?
nginx sits at the front of a huge share of the internet - as a web server, a reverse proxy and a load balancer. Xint counted 56.7 million hosts on Shodan reporting nginx as of November 10. About 11.9 million of them reveal a version, and 98.9% of those fall inside the range affected by CVE-2026-123007 (1.9.5 through 1.31.8).
Those numbers come from version banners, so they overstate real exposure. The attack also needs HTTP/2 enabled, and distributions that backport fixes keep reporting older version strings. Even so, one flaw in the server itself hits unrelated sites, apps and APIs at once. You do not have to write insecure code to be exposed. You only have to run nginx.
How many nginx APIs are exposed: Harness API discovery data
We checked our own view of customer traffic. Harness profiles the Server header of the APIs it discovers, so we counted which ones advertise a vulnerable nginx version. The count uses one sample per API across our production clusters.
2,372 APIs, across at least 11 customers, report a vulnerable nginx OSS version. None report NGINX Plus. HTTP/2 was not confirmed on any of those versioned APIs, so this is version exposure, not a confirmed exploitable setup.
Three things stand out:
- Old versions dominate. The most common builds are 1.24.0 (460 APIs), 1.26.3 (380) and 1.26.2 (310). Almost all of the 186 older APIs run nginx 1.18.0, the version Ubuntu 22.04 keeps reporting after security updates, so some may carry backported fixes once distributions ship them. The header cannot tell us.
- The exposure is concentrated. One tenant accounts for 1,482 of the 2,186 APIs in range for both bugs, and at least 11 tenants run a version affected by both.
- The unknown group is large. A further 1,884 APIs return a bare nginx header with the version hidden. They are not in the 2,372, and some of them are likely vulnerable too.
The limits matter. A Server header can be hidden, spoofed or stale, and it describes the edge, not necessarily the origin. HTTP/2 is negotiated inside TLS, so a profiled sample cannot easily show whether it is on. Treat these numbers as a prioritized list for patching, not a list of exploitable systems.
nginx2root disclosure timeline
The researchers found CVE-2026-123007 on October 11 while preparing for a security competition. A few days later, an automated scan found the other four with no human guidance. The reports went to F5, which owns nginx, on October 16, and the nginx team asked for patch validation on November 10. The findings went public on November 18. The fixed releases, nginx 1.30.7 and 1.31.9, shipped the same day.

They were not alone. Several other teams independently found CVE-2026-123633 and CVE-2026-123007, which means more than one group was looking at the same code. The pace is telling too. nginx's advisory list recorded two new vulnerabilities in 2025 and 26 by mid-November this year, before nginx2root, and the researchers point to AI-assisted research as part of the reason.
How CVE-2026-123007 works: an HTTP/2 flow-control bug
You do not need to read C to understand the shape of it.
HTTP/2 uses a credit system to stop a fast sender from overwhelming a slow receiver. The server may only send as much data as its balance allows, and the client tops the balance up with a WINDOW_UPDATE frame. nginx keeps one balance per request and one for the whole connection. It spends credit when it queues data, and it refunds that credit if the request is cancelled before the data goes out.
Both steps are correct on their own. The problem is the gap between them. While data is still queued, the client can top up the balance and then cancel the request. nginx refunds credit that was already restored, and it never checks the total against the protocol's maximum.

Spending and refunding are each correct on their own. The refund lands after the top-up, so the same credit is counted twice.
The balance ends up above the limit and nginx's own safety check stops working. The oversized number later becomes a nonsense length in a memory copy. From there, an attacker can learn nginx's memory layout and take over control flow, then run commands as the nginx worker.
Everything the attacker sends is a valid HTTP/2 frame. None of it looks like a request.
CVE-2026-123007 root cause in nginx's HTTP/2 code
For readers who want the mechanism, here is the path through nginx's HTTP/2 module. The names come from the nginx source.

- Spend. When nginx queues response data, ngx_http_v2_send_chain() subtracts the frame size from both the connection window and the stream window.
h2c->send_window -= frame_size;
stream->send_window -= frame_size;- Refund. If the stream is cancelled before that data is sent, ngx_http_v2_filter_cleanup() removes the queued frames and adds their length back to the connection window. Nothing here checks the result against the maximum, which is 0x7fffffff.
h2c->send_window += window;- Check. ngx_http_v2_state_window_update() rejects any increment that would push the window past the maximum.
if (window > NGX_HTTP_V2_MAX_WINDOW - h2c->send_window) {
return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_FLOW_CTRL_ERROR);
}h2c->send_window is an unsigned size_t. Once the refund has pushed it above the maximum, the subtraction in that check wraps around to a huge positive number. The check now passes every time. Each later WINDOW_UPDATE is individually legal, and repeating them can raise the window to an arbitrary 64-bit value.
- Sign confusion.
ngx_http_v2_send_chain()compares the window with the send limit as a signedoff_t. Asize_tjust below 2^64 becomes a small negative number when cast, so the frame size is derived from a negative length and then converted back to an unsigned value near 2^64. That length ends up as the size of a memory copy, and the invalid copy corrupts adjacent heap memory.
The lesson is a general one. A limit enforced at one entry point is not a limit if another code path can add to the same counter. Here the window was checked when the client increased it, but not when nginx refunded it.
The five nginx CVEs compared: conditions and affected versions
Each of the five nginx bugs gives code execution on its own. They differ in what has to be true of your server.
CVE-2026-123007 is the window accounting error described above. The other four are use-after-free bugs: nginx frees a piece of memory and keeps using it, and an attacker who can fill that spot with their own data can redirect what nginx does next.
Disabling HTTP/2 closes two of the five and leaves three open, so check your configuration against the table. For CVE-2026-123634, the table shows the tested setup using mirror. Other features that create subrequests, such as SSI, may reach the same bug, so turning off mirror alone does not make a server safe.
Linux kernel SCTP bug: from nginx worker to host root
nginx workers run with restricted permissions, so code execution there is serious but contained. Xint also found a use-after-free in the Linux kernel's SCTP code, introduced in Linux 4.15 in 2018, that closes that gap.
SCTP is a little-used network protocol, but on many distributions the kernel loads its module automatically the first time a program opens an SCTP socket. In Xint's tests, an attacker already running as an nginx worker reliably became root, including when nginx ran inside a Docker container. Containers share the host kernel, so owning the kernel means owning the host and every container on it.

nginx gives the attacker a foothold. The kernel bug turns it into control of the whole host.
As of November 18, the kernel bug has no CVE identifier, and Xint is withholding most details until a patch exists.
How to detect nginx2root exploitation attempts
Because nothing useful shows up in access logs, detection moves to the network and the host. Xint's guidance, in short:
- Connection statistics. Run ss -tinp state established '( sport = :443 )' twice, a few seconds apart. Look for a long-lived connection from one IP whose bytes received keep climbing while bytes sent stay small, alongside many short TLS connections from the same address.
- Requests per connection. Add a log format with $connection, $connection_requests and $request_length, then compare the logged request lengths with the bytes received that ss shows. A large gap fits a flood of control frames.
- Workers starting programs. A normal nginx worker never runs a shell. Add an auditd rule on execve for the worker's UID and alert on /bin/sh or /bin/bash. This is the clearest sign of a successful attack.
- Worker crashes. Repeated signal 11 or segfault entries in error.log, and core dumps, can point to failed attempts. This one is weak on its own.
Two snippets from Xint's guidance make the second and third checks concrete. First, a log format that records the connection and its request count, to add to the http block:
log_format h2_hunt '$time_iso8601 src=$remote_addr conn=$connection '
'requests=$connection_requests proto=$server_protocol '
'status=$status request_length=$request_length '
'bytes_sent=$bytes_sent request_time=$request_time';
access_log /var/log/nginx/h2-hunt.log h2_hunt;Second, an auditd rule that records every program the nginx worker starts. Replace NGINX_UID with the numeric UID from ps -eo uid,user,pid,ppid,args | grep '[n]ginx: worker process':
sudo auditctl -a always,exit -F arch=b64 -S execve,execveat \
-F euid=NGINX_UID -k nginx_worker_exec
sudo ausearch -k nginx_worker_exec -ts recent -iThe rule matches anything running under the same UID, so check each event's parent process before deciding it came from nginx.
No single signal is proof. Several together, with no innocent explanation, mean block the source and investigate. An empty audit result cannot rule out an earlier compromise, because the rule only records events after you install it.
How to patch nginx and mitigate CVE-2026-123007 now
Patch. It is the only complete fix for the nginx bugs; there is no kernel patch yet. Update to the fixed release, confirm the build includes the fixes for all five bugs against F5's advisory (K000164058), then restart nginx. A configuration reload does not replace the running binary.
The disclosures name 1.31.9 for mainline, and one of them also lists 1.30.7 for the stable branch. Verify both against F5's advisory before you roll out. If you cannot patch this hour, these steps buy time but do not replace the patch:
- HTTP/2 (CVE-2026-123007 and CVE-2026-123633). Turn it off on each affected listener. On nginx 1.25.1 and later, set http2 off; and remove any legacy http2 parameter from listen. On older versions, remove http2 from listen. Then confirm from outside that openssl s_client -alpn h2 no longer negotiates h2. Services that need HTTP/2, such as native gRPC, will be affected.
- HTTP/3 (CVE-2026-121810). Remove the quic listeners, set http3 off;, replace any HTTP/3 Alt-Svc header with Alt-Svc 'clear', and block UDP on that port.
- Resolver with mirror (CVE-2026-123634). Point proxy_pass at a fixed upstream group so nginx does not look up DNS during the request. Turning off mirror alone is not enough.
- Mail proxy (CVE-2026-113425). Bind IMAP, POP3 and SMTP listeners to a loopback address, or use your firewall to allow only trusted IPs.
- Kernel. On hosts that do not use SCTP, put install sctp /bin/false in a file under /etc/modprobe.d/. This only blocks loading through modprobe. It does not unload a module that is already loaded, and it does not disable SCTP compiled into the kernel.
After changing configuration, restart nginx if workers still show worker process is shutting down, since old workers keep serving existing connections under the old settings.
Treat every one of these as a bridge. Then start the inventory now. The hard part of a flaw in something this common is finding every instance, including the ones inside container images and appliances, before an attacker does.
How Harness can help
Harness protects against NGINX2Root by pairing Supply Chain Security (SCS) for pre-deployment control with Dynamic Application Security Testing (DAST) for live endpoint validation. Together, they stop vulnerable NGINX builds from shipping while verifying that running services cannot be exploited.
Harness Supply Chain Security (Pre-Deployment Control)
- Zero Day Intelligence. Tracks emerging threats ahead of CVE publication and automatically matches them to the packages in your SBOMs, so you know your exposure the day a zero day breaks.
- SBOM Discovery. Automatically scans container registries and repositories to pinpoint every service or base image running vulnerable NGINX versions (1.9.5 - 1.31.8).
- CI/CD Policy Gates. Uses Open Policy Agent (OPA) rules to automatically block builds or deployments until images upgrade to patched releases (NGINX 1.30.7+ or 1.31.9+).
- Immediate Version Blocking. Tracks exact package versions inside SBOMs so you can block exposure right away without waiting for external CVE databases to update.
Harness DAST (Runtime Validation)
- Exploitability Testing. Sends safe payloads to live staging and production endpoints to verify whether vulnerable HTTP/2 paths are actually reachable.
- Mitigation Verification. Confirms that temporary workarounds; like disabling HTTP/2 (http2 off;), actually block attacks when immediate image rebuilds aren't possible.
- Edge & Ingress Coverage. Scans external ingress controllers and load balancers to catch exposed proxies and detect configuration drift over time.

