NGINX2Root: nginx HTTP/2 Flaw CVE-2026-123007 (CVSS 9.2) Allows Unauthenticated RCE in Every Release Since 2015, Public PoC Out and a Kernel Chain to Root — Update to 1.30.7 or 1.31.9

F5 fixed ten nginx flaws on 18 November, including five rated CVSS 9.2 and an HTTP/2 flow-control bug (CVE-2026-123007) that researchers exploited in default setups with ASLR bypassed, and chained with an unpatched Linux SCTP kernel bug to get root.
What Happened
On 18 November 2026, F5 shipped nginx 1.30.7 (stable) and 1.31.9 (mainline). The two releases fix ten vulnerabilities in the open-source web server. Five of them are rated 9.2 under CVSS 4.0 and can lead to remote code execution. The most serious one, CVE-2026-123007, is a memory corruption bug in HTTP/2 flow control. It sits in code that every official release since nginx 1.9.5 (2015) contains, and the researchers say it can be reached in a default HTTP/2 setup with nothing behind nginx but static files.
One of the research teams calls the set "NGINX2Root". At least five groups reported the bugs on their own: an AI security company, a cloud security vendor and three other research teams. The AI company says its automated platform found four of its five reported flaws with no human guidance. It also says it chained the HTTP/2 bug with an unpatched Linux kernel flaw to get root on the host, even from inside a Docker container.
No attacks in the wild had been reported at the time of writing. However, one of the research teams released a proof-of-concept exploit for CVE-2026-123007 on disclosure day. Nginx runs roughly three in ten websites whose server software can be identified, and it is everywhere as a reverse proxy, load balancer and Kubernetes ingress. That makes this the patch to do first this week.
The Two HTTP/2 Bugs
Both HTTP/2 flaws need HTTP/2 to be turned on, and most public nginx servers serving TLS turn it on.
- CVE-2026-123007: HTTP/2 flow-control memory corruption (versions 1.9.5–1.31.8). When a stream is cancelled, nginx gives the stream's unused flow-control allowance back to the connection's send window. It does this without checking HTTP/2's maximum window size. A client that has already raised the window can push the counter past the limit. The bounds check that handles later WINDOW_UPDATE frames then subtracts with unsigned arithmetic. The result wraps around, so further increases pass the check. The oversized window turns into a negative length when nginx builds the outgoing data. In the TLS send path, that becomes an out-of-bounds memory copy. Researchers showed reliable code execution with ASLR defeated on official 64-bit builds serving only static files over HTTP/2 on TLS, with no backend application or third-party module.
- CVE-2026-123633: HTTP/2 connection use-after-free (versions 1.19.7–1.31.8). An idle HTTP/2 connection waiting for the rest of a HEADERS frame goes onto nginx's list of reusable connections. When a request stream starts, the connection is not taken off that list. If nginx runs short of free connection slots, it can close that connection while the request is still being processed. If building the GOAWAY frame then fails, the connection's memory is freed and request handling keeps using it. Researchers say this one is most practical when nginx works as a reverse proxy. ASLR does not stop it, because the bug can also be used to read memory first.
The public proof of concept for CVE-2026-123007 is heavy. According to the researchers, it needs about 128 GB of HTTP/2 traffic over a single connection, and its authors noted that other exploitation methods "may be viable, but none are currently known". That much traffic is a real obstacle, but it is not a defence. A long-lived HTTP/2 connection moving huge amounts of data is exactly the signal defenders should look for.
The Other Critical Flaws
The same releases fix three more bugs rated 9.2 that depend on configuration:
- CVE-2026-121810: use-after-free in HTTP/3 (1.25.0–1.31.8), exploitable when HTTP/3 is used in proxying setups.
- CVE-2026-123634: use-after-free in the DNS resolver while processing responses (0.6.18–1.31.8). It allows code execution when an attacker can control an upstream host name.
- CVE-2026-113425: use-after-free in the mail proxy module (0.5.33–1.31.8), relevant when nginx is a mail proxy using
auth_http.
Lower-rated fixes include an infinite loop when reading a request body over TLS 1.3 (CVE-2026-118899, a denial of service), a NULL pointer crash with PROXY protocol v2 (CVE-2026-120993, only in 1.31.4–1.31.8), a buffer overflow when alias is combined with try_files (CVE-2026-125283), an SNI bypass in stream client-certificate checks (CVE-2026-120967) and weak validation in the stream ssl_preread module (CVE-2026-123640).
The Root Escalation
On its own, code execution through CVE-2026-123007 runs with the rights of an nginx worker process, which are normally limited. The AI research company says it chained this with a bug in the Linux kernel's SCTP (Stream Control Transmission Protocol) code that dates back to Linux 4.15 (2018). In its tests, a compromised worker reliably became root on the host, including from inside a container. The kernel bug has no CVE and no patch yet, and the company is holding back details until a fix exists.
Most web servers never use SCTP. Blocking the module from loading takes the escalation path away until a kernel fix arrives. Note that this does not unload a module that is already loaded, and it does not help if SCTP is built into the kernel.
Who Is Affected
- Any nginx open-source build from 1.9.5 to 1.31.8 with HTTP/2 enabled is exposed to CVE-2026-123007.
- NGINX Plus is affected too. Researchers list R33 and 37.0.0 as first affected. The fixed builds are 37.0.8.1 and 37.3.0.1 for CVE-2026-123007, and 37.0.7.1 and 37.2.0.1 for CVE-2026-123633. Check F5's advisories K000163926 and K000163928 for the exact releases that apply to you.
- Products that bundle nginx also need updates: distribution packages, container base images, Kubernetes ingress controllers, appliances and control panels. Expect fixes from those vendors and distributions over the coming days.
- A CDN or WAF that terminates HTTP/2 in front of nginx may block parts of the attack, depending on how it is built. Don't count on it.
What To Do Now
- Upgrade to nginx 1.30.7 or 1.31.9 (or your distribution's patched package). Then make sure the old worker processes have actually exited.
- Rebuild and redeploy container images that include nginx. A patched host package does nothing for an image built last month.
- If you cannot patch today, turn off HTTP/2 in the affected server blocks (nginx 1.25.1 and later) and remove
http2fromlistenlines. Browsers fall back to HTTP/1.1, but gRPC services will stop working. Turn HTTP/2 back on after upgrading. - Block the SCTP kernel module on hosts that don't need it, to break the known path to root.
- Watch for unexpected nginx worker crashes, shells or other processes started by nginx, and HTTP/2 connections that stay open while sending unusually large amounts of data.
Defensive commands to check versions and apply the stopgaps:
# Show the installed version and whether HTTP/2 is enabled
nginx -v
nginx -T 2>/dev/null | grep -nE 'http2|listen .*ssl'
# Temporary: in each affected server block set
# http2 off;
# then test and reload
nginx -t && systemctl reload nginx
# Block SCTP from loading (does not unload a module already loaded)
echo "install sctp /bin/false" | sudo tee /etc/modprobe.d/disable-sctp.conf
lsmod | grep -i sctp
Why It Matters
This is one of the biggest web-server patch events in years. One bug, ten years old, sits in the default HTTP/2 path of software that serves a large share of the internet. It also shows a pattern we have reported on several times this month: several teams, some of them using AI systems, found the same flaws within weeks of each other. Once researchers and AI tools can find bugs this fast, attackers will be able to as well. With a public proof of concept already out, the safest course is to treat the time to patch as hours, not weeks.
