F5 has patched 5 critical NGINX vulnerabilities that security firm Xint has branded nginx2root, including an HTTP/2 flaw that can let an unauthenticated attacker run code on a server in its most common configuration. The worst bug, CVE-2026-123007, has been in NGINX since HTTP/2 support arrived in version 1.9.5 in 2015, and a working proof-of-concept exploit is already public.
The fixes shipped on November 18, 2026 in NGINX Open Source 1.31.9 (mainline) and 1.30.7 (stable), and in NGINX Plus 37.3.0.1 and 37.0.8.1. All 5 nginx2root CVEs carry a CVSS 4.0 score of 9.2 (Critical) and a CVSS 3.1 score of 8.1 in the official records. No exploitation in the wild has been confirmed so far.
What nginx2root covers
Xint’s technical write-up describes 5 separate bugs, each of which it says leads to remote code execution on its own under a different configuration. They do not need to be chained together:
CVE-2026-123007: memory corruption in HTTP/2 flow control. It only needs HTTP/2 to be enabled. The nginx.org advisory list marks versions1.9.5through1.31.8as vulnerable.CVE-2026-123633: a use-after-free in HTTP/2 when NGINX proxies requests to a backend and the worker is running low onworker_connections. Vulnerable from1.19.7.CVE-2026-123634: a use-after-free in the DNS resolver. It requires aproxy_passtarget built from variables, plus amirroror SSI subrequest that resolves the same name.CVE-2026-121810: a use-after-free in HTTP/3 (QUIC) when requests are forwarded to a backend. Vulnerable from1.25.0.CVE-2026-113425: a use-after-free in the mail proxy module when it usesauth_http. Xint says the attacker does not need valid credentials.
The same release also fixed 5 lower-rated NGINX issues, including an infinite loop over TLS 1.3 (CVE-2026-118899) and a buffer overflow when alias is used with try_files (CVE-2026-125283).
Xint says a human researcher found CVE-2026-123007 while preparing for its ZeroDay Cloud event, and its automated platform found the other 4 a few days later with no human guidance. According to Xint’s timeline, it reported the bugs to F5 through HackerOne on October 16 and validated F5’s patch on November 10.
Several teams found the same bugs
Xint was not alone. Wiz Research says it, Ikotas Labs, Metnir, Rapid7 and Xint independently found and reported the 2 HTTP/2 flaws. The official CVE records credit Rapid7, Wiz, Xint and Ikotas Labs for CVE-2026-123007, and Metnir, Wiz and Xint for CVE-2026-123633. Xint is the only credited finder of the other 3.
Wiz says it reported the use-after-free on October 21 and was told another team had already reported it. It reported the flow-control bug on November 16, and F5 confirmed the next day that it matched a fix already planned for November 18. Rapid7 says it first contacted F5 on November 11. Wiz links the overlap to AI-assisted bug hunting and compares it to the PHP2Shell flaws and Java4Shell, the OpenJDK bug disclosed a day earlier.
How the HTTP/2 bug works
HTTP/2 lets a client tell the server how much response data it is ready to receive, using a counter called the send window. NGINX subtracts queued data from that counter before sending it. If a stream is cancelled while its data is still queued, NGINX adds the unsent amount back. Wiz and Xint say that refund does not check HTTP/2’s maximum allowed window.
If the client has already raised the window, the refund pushes the counter past the limit. A later bounds check then wraps around, and an invalid length reaches the TLS send path, where it turns into an out-of-bounds memory copy. Xint says it used this to leak memory addresses and overwrite a cleanup function that runs when a connection closes, which let it run commands with the NGINX worker’s privileges and read the output over the same connection.
Wiz says it confirmed code execution, with an ASLR bypass, on official 1.31.7 and 1.31.8 builds serving ordinary static files over HTTPS on 64-bit systems, with no backend application or third-party module. Xint says its exploit worked on AWS, Google Cloud and Azure servers, including over a public HTTPS endpoint.
From NGINX worker to root
NGINX workers usually run as a low-privilege user, so code execution alone does not hand over the whole machine. Xint says it closed that gap with a separate zero-day in the Linux kernel’s SCTP networking code, a use-after-free in the send path that it says has been in the kernel since 2018. Chained with CVE-2026-123007, it gave Xint root on the host, including from inside a Docker container running NGINX.
Xint is withholding most details of the kernel bug until a fix is available. On many distributions the SCTP module loads automatically the first time a program opens an SCTP socket. Until a kernel patch ships, Xint suggests that hosts that do not use SCTP block the module by adding install sctp /bin/false to a file in /etc/modprobe.d/. That does not unload a module that is already loaded. BreachNews has covered other recent Linux root bugs, including the kernel TCP flaw CVE-2026-98432.
Public exploit, with real limits
Rapid7 researcher Stephen Fewer has published proof-of-concept code that shows unauthenticated code execution against a linux/amd64 Docker image running NGINX 1.31.8 with HTTP/2 and TLS enabled. Rapid7 is also clear about the limits:
- The exploit needs about 128 GB of HTTP/2 data. Rapid7 puts that at about 2 minutes on a 10 Gbit/s link and 17 minutes on 1 Gbit/s. Below roughly 300 Mbit/s it runs into NGINX’s default 1 hour connection limit and fails.
- It depends on a specific x86-64 glibc memory-copy routine that is chosen on CPUs with AVX-512 (
avx512fandavx512vl). Rapid7 says other strategies may be viable, but none are currently known. - If the HTTP/2 connection passes through a proxy, the attacker’s exact frames will likely not reach NGINX in a usable form.
- The public PoC is built for a freshly started container and will likely fail against busy servers with a “messy” heap.
F5’s CVE descriptions add that code execution requires ASLR to be disabled or bypassed. Wiz and Xint both say they bypassed ASLR by leaking memory first. Xint’s own write-up leaves out the final steps of its exploits.
How many servers are exposed
Xint says Shodan returned 56.7 million NGINX hosts on November 10. About 11.94 million of them showed a version number, and 98.9% of those fell in the range affected by CVE-2026-123007. Xint notes that this does not confirm they are vulnerable, since the attack also needs HTTP/2 enabled and a server may already have a backported fix.
How to check if you’re affected
Start with the version on each server:
nginx -v 2>&1
Official releases from 1.9.5 through 1.31.8 contain the vulnerable HTTP/2 code. Distribution packages can be patched without the version changing, though. Xint points out that Ubuntu 22.04 still reports 1.18.0 after many security updates. Check the full package version with dpkg -l nginx or rpm -q nginx and compare it with your distribution’s advisory.
Next, check whether the binary includes HTTP/2 and whether your configuration turns it on:
nginx -V 2>&1 | grep -o -- '--with-http_v2_module'
sudo nginx -T 2>&1 | sed 's/#.*//' | grep -nE 'listen[[:space:]].*http2|http2[[:space:]]+on'
Any match such as listen 443 ssl http2; or http2 on; means HTTP/2 is enabled. Then test from a machine outside your network whether the server actually offers HTTP/2:
openssl s_client -connect example.com:443 -servername example.com -alpn h2 </dev/null 2>&1 | grep -E 'ALPN protocol|No ALPN'
ALPN protocol: h2 means HTTP/2 is reachable. If a CDN or load balancer sits in front, this only tests that front layer, so run it against the NGINX origin directly as well. For the other 4 CVEs, check your configuration for proxied HTTP/3, variable proxy_pass targets with mirror or SSI, and mail blocks that use auth_http.
Patch, then restart
Upgrade to 1.31.9 or 1.30.7, NGINX Plus 37.3.0.1 or 37.0.8.1, or your distribution’s fixed package once it is out. Rapid7’s table lists no fix for older NGINX Plus releases R34 through R36. Then do a full restart, such as sudo systemctl restart nginx. Xint warns that nginx -s reload only reloads the configuration and does not load the new binary, so the old, vulnerable code keeps running.
Distribution fixes were still catching up at publication time. Ubuntu’s tracker listed every supported release from 16.04 through 26.10 as vulnerable, and BreachNews found no Debian or Red Hat advisory for the CVEs yet. Xint says it coordinated with AWS, Azure and Google Cloud before disclosure, but none of the 3 had posted a public bulletin that BreachNews could find.
If you cannot patch right away, turn HTTP/2 off on exposed listeners. On NGINX 1.25.1 and later, set http2 off; in each affected server block and remove http2 from listen lines. On older versions, change listen 443 ssl http2; to listen 443 ssl;. Run nginx -t, apply the change and confirm that workers marked “shutting down” have exited, since existing connections keep the old settings. Then rerun the openssl check, which should no longer show h2. This blocks only CVE-2026-123007 and CVE-2026-123633. Xint’s write-up has separate stopgaps for the other 3, such as removing QUIC listeners and binding the mail proxy to localhost.
To look for signs of attack, Xint suggests watching for single connections that receive huge amounts of data while NGINX sends little back, NGINX workers that start programs such as /bin/sh, and repeated worker crashes in the error log. The control frames used in the attack are not logged as requests, so access logs may show very little.












