On November 18, 2026, F5 shipped a coordinated nginx security release that fixed 10 issues at once. The headline is CVE-2026-123007, an unauthenticated remote code execution bug in nginx's HTTP/2 flow control: a connection send window is credited twice, pushed past its maximum, and then an unsigned subtraction underflows into a huge value that becomes a negative length in a memory copy. The security firm Xint bundled this with four other nginx use-after-frees and a Linux SCTP kernel bug into a chain they call nginx2root, because in their lab it went from an HTTP/2 visitor to root on the host, escaping the Docker container nginx ran in. Affected: nginx Open Source 1.9.5 through 1.31.8 (the RCE), fixed in 1.31.9 (mainline) and 1.30.7 (stable). F5 and other vendors score it CVSS 4.0 9.2; nginx's own advisory calls it Major. The day after the release I stood up 1.31.8 with HTTP/2 and TLS in Docker, confirmed it is in the affected range and negotiates HTTP/2, then confirmed that turning HTTP/2 off and upgrading to 1.31.9 both remove the exposure. I did not run the weaponized exploit, and I explain below why reproducing the actual RCE needs roughly 119 GiB of HTTP/2 traffic and a specific CPU, and why you should not run the anonymous "PoC" repos already appearing on GitHub.
What is nginx2root and why does it matter?
nginx sits in front of a very large share of the web. Wiz puts it at "more than 225 million websites." It is the default reverse proxy for most Kubernetes ingress setups, it terminates TLS for countless APIs, and it is embedded in appliances and managed platforms that most people never think of as "running nginx." So when a bug lets an unauthenticated attacker run code inside the nginx worker process, the blast radius is the internet-facing edge of a huge number of systems.
That is what landed on November 18, 2026. F5, which owns nginx, published a single coordinated release that fixed 10 separate security issues. The two that matter most both live in the HTTP/2 code:
- CVE-2026-123007 - memory corruption in HTTP/2 flow control, leading to remote code execution. This is the one with a public proof of concept.
- CVE-2026-123633 - a use-after-free in HTTP/2 connection handling, mainly in the reverse-proxy path.
The name nginx2root comes from Xint, the security research firm that reported five of the ten CVEs. Their writeup chains an nginx bug with a separate Linux kernel vulnerability to go from "I can speak HTTP/2 to your server" all the way to "I am root on the host machine, outside the container." The "2root" is literal.
This post walks the whole thing from the ground up: how HTTP/2 flow control works, exactly how the counter breaks, what the other four Xint CVEs are, how the kernel chain gets to root, what it actually takes to exploit (which is more than the headlines suggest), and the detection and patch steps. Then I show the Docker reproduction I ran to check the affected-versus-patched behavior for myself.
HTTP/2 flow control in one section
To see the bug you need one HTTP/2 concept: flow control.
HTTP/1.1 sends one request and one response per connection at a time. HTTP/2 multiplexes many requests, called streams, over a single TCP connection at once. If a fast server could blast data for all of them with no limit, a slow client would be overwhelmed and buffers would explode. So HTTP/2 adds a credit system, called flow control, in RFC 9113.
It works like a prepaid balance:
- Each stream and the connection as a whole has a send window: how many bytes of DATA the sender is still allowed to send before it must wait.
- Every time the sender sends DATA, the window goes down by that many bytes.
- The receiver sends a WINDOW_UPDATE frame to add credit back, letting the sender continue.
- A SETTINGS frame can change the initial window size for streams.
- The window is a signed 31-bit value. Its maximum is
2^31 - 1, which nginx callsNGX_HTTP_V2_MAX_WINDOW. RFC 9113 says if a WINDOW_UPDATE would push a window above that maximum, that is aFLOW_CONTROL_ERRORand the connection (or stream) must be torn down.
So the window is a counter that must stay between 0 and 2^31 - 1. Everything about CVE-2026-123007 is about getting that connection-level counter to leave those bounds without nginx noticing.
How does CVE-2026-123007 actually work?
nginx tracks the connection-level credit in a single unsigned counter, h2c->send_window. The official advisory describes the bug as "Memory corruption in HTTP/2 flow control." Rapid7, which also found it, classifies it as CWE-191, integer underflow. Both are right, because the bug is a sequence: first the counter is pushed above its maximum (an overflow of the allowed range), then a later check does unsigned subtraction that wraps (the underflow). Here is the chain, using the function names from Wiz's and Rapid7's analyses.
Step 1: credit is refunded without a bound check. When a request finishes and its queued response data is cancelled, nginx returns the unused window credit to the connection counter. The cleanup path does, in effect:
/* ngx_http_v2_filter_cleanup(): returns queued DATA credit to the connection */
h2c->send_window += window; /* no check against NGX_HTTP_V2_MAX_WINDOW */
Nothing here verifies that the result stays at or below 2^31 - 1. Rapid7 frames this as the first of three flaws: queued DATA credit is restored to the connection counter without checking the maximum, so the counter can cross 2^31 - 1.
Step 2: crossing the maximum does not kill the connection. When a SETTINGS frame pushes a stream's credit above the maximum, nginx resets that one stream but keeps the connection open. RFC 9113 says this situation should be a connection-level FLOW_CONTROL_ERROR. Because nginx only resets the stream, the connection survives with a counter that is now in an illegal state.
Step 3: the guard check underflows. The next connection-level WINDOW_UPDATE is supposed to be caught by this guard:
/* ngx_http_v2_state_window_update(): the bounds check */
if (window > NGX_HTTP_V2_MAX_WINDOW - h2c->send_window) {
/* reject: would exceed the maximum */
}
This looks correct, but every value here is unsigned. If h2c->send_window is already greater than NGX_HTTP_V2_MAX_WINDOW, then NGX_HTTP_V2_MAX_WINDOW - h2c->send_window does not go negative - it wraps around to a gigantic positive number. The comparison then passes for almost any window, so nginx happily adds even more credit. Repeated, this pushes the counter past 2^63.
Step 4: a huge unsigned value becomes a negative length. That poisoned counter eventually reaches the output path. In ngx_http_v2_send_chain() the value is converted toward a signed off_t, where a value above the signed maximum reads as negative. That negative length flows into ngx_ssl_send_chain(), which performs a memory copy sized by it. A copy told to move a negative-turned-huge number of bytes reads and writes far outside the intended buffer. That out-of-bounds copy on the heap is the memory corruption, and it is what a careful attacker turns into code execution.
The bug needs HTTP/2 to be enabled, and it affects nginx whether it is serving files directly or proxying. Wiz demonstrated code execution with an ASLR bypass on official nginx 1.31.7 and 1.31.8 builds that were simply serving ordinary static files over HTTPS on a 64-bit system.
What about CVE-2026-123633, the HTTP/2 use-after-free?
The second HTTP/2 bug is different in flavor: a use-after-free that shows up mostly when nginx is a reverse proxy and connection slots run low. nginx's own advisory rates it Medium; F5 and several third parties score it 9.2 like the first. The mechanism, per Wiz:
ngx_http_v2_handle_connection()marks an HTTP/2 connection reusable while it waits for the rest of a partial HEADERS frame. "Reusable" means nginx considers it safe to close if it needs the slot.ngx_http_v2_create_stream()incrementsh2c->processing(a request is now live) but does not remove the connection from the reusable list. So a request is running on a connection nginx still thinks is idle and disposable.- When free connection slots run low,
ngx_drain_connections()looks for reusable connections to close and can pick that one. If building the GOAWAY frame fails (for example, because an internal frame limit is hit), the error path frees the connection's memory while the request is still using it.
That freed-then-used memory is the classic recipe for a use-after-free that can crash the worker or, with enough control over the heap, be steered further.
The other three Xint CVEs, and the "2root" part
Xint's nginx2root writeup counts five nginx CVEs. Beyond the two HTTP/2 bugs, the automated scan they ran turned up three more use-after-frees in other subsystems. Official affected ranges are from nginx's advisory.
| CVE | Component | Type | nginx advisory severity | Affected (Open Source) | Disabling HTTP/2 helps? |
|---|---|---|---|---|---|
| CVE-2026-123007 | HTTP/2 flow control | Memory corruption (integer underflow) -> RCE | Major | 1.9.5 - 1.31.8 | Yes |
| CVE-2026-123633 | HTTP/2 connection handling | Use-after-free | Medium | 1.19.7 - 1.31.8 | Yes |
| CVE-2026-123634 | DNS resolver with mirror | Use-after-free | Medium | 0.6.18 - 1.31.8 | No |
| CVE-2026-121810 | HTTP/3 (QUIC) with upstream proxying | Use-after-free | Medium | 1.25.0 - 1.31.8 | No |
| CVE-2026-113425 | Mail proxy auth_http | Use-after-free | Major | 0.5.33 - 1.31.8 | No |
The full 1.31.9 and 1.30.7 release fixed 10 issues in total; the five above are the ones Xint branded as nginx2root, and the two HTTP/2 bugs are the headline because one of them is an RCE with a working proof of concept.
Now the scary part. Xint did not stop at the nginx worker. They also found a separate vulnerability in the Linux kernel's SCTP subsystem - a use-after-free or double free in the SCTP send path that they say has been present since Linux v4.15 in 2018. In their words, it "can be chained with any of the nginx vulnerabilities to gain root privileges on the host." In their tests it gave a KASLR bypass and an arbitrary kernel function call, and the full chain "escaped a Docker container running nginx and obtained root on the underlying host." That is the path the name describes: HTTP/2 request, then nginx worker, then kernel, then host root, straight through the container boundary.
This is also exactly why I would not naively run an unknown exploit for this bug inside a container and assume the container protects me. More on that below.
Who found it, and the disclosure timeline
Two independent parties reported the HTTP/2 flow-control bug, which is unusual and tells you it was findable.
- Xint (researchers credited as @imssm99, @cdor1, @tjbecker and @yves) found CVE-2026-123007 while preparing for ZeroDay Cloud 2026, and then an automated Xint scan found the other four nginx bugs. They reported through HackerOne in October.
- Rapid7's Stephen Fewer, a Senior Principal Security Researcher, independently discovered and reported CVE-2026-123007 in November and wrote the public proof of concept.
F5 coordinated both into the single November 18 release.
How bad is it really? Severity and the exploitation reality
The scores disagree, so it is worth being precise:
- F5 and several vendors (Wiz, Safe Security, Security Boulevard) put CVE-2026-123007 at CVSS 4.0 9.2, Critical. Rapid7 gives the vector
AV:N/AC:H/AT:P/PR:N/UI:N/VC:H/VI:H/VA:H, which reads as network-reachable, no privileges, no user interaction (so unauthenticated), high confidentiality, integrity and availability impact, but high attack complexity and a present attack requirement. - nginx's own advisory labels CVE-2026-123007 "Major" and CVE-2026-123633 only "Medium."
- Downstream trackers list different numbers: Cyber Kendra reports Red Hat at 8.1 (on the older CVSS 3.1 scale, so not directly comparable to F5's 9.2 under CVSS 4.0) and Ubuntu rating it High.
The reason for the "high complexity" is important, and it is the honest counterweight to the panic. Rapid7's proof of concept is a real, unauthenticated RCE: it recovers addresses, forges nginx objects in memory, and redirects a request-pool cleanup callback to run an attacker-chosen command. But it runs with the nginx worker's permissions, not root (execution as the master process or root "has not been established" without the kernel chain), and it has real preconditions:
- It needs a large volume of HTTP/2 data to drive the counter: Rapid7 estimates around 128 GB, and used about 119.02 GiB of plaintext in their reproduction. At 10 Gbit/s that is roughly two minutes; at 1 Gbit/s about seventeen. nginx's default one-hour connection lifetime means a link slower than roughly 300 Mbit/s cannot finish in time, and proxied connections are unlikely to work.
- The RCE strategy depends on a specific x86-64 glibc memcpy routine, selected by the CPU's
avx512fandavx512vlfeatures. Rapid7 notes other strategies "may be viable, but none are currently known."
Wiz, which built its own exploit, said it will not release it "at this time." So the headline is accurate - unauthenticated RCE, no login required - but a smash-and-grab against every nginx box on the internet this is not. It is a targeted attack that needs bandwidth, time and the right target CPU. That gap between "critical score" and "operational difficulty" is exactly the window you want to use to patch.
The 300 Mbit/s bar is the floor: below it the connection times out at one hour before the attack completes.
How I checked it in Docker
I wanted to confirm the affected-versus-patched behavior myself rather than take the version table on faith. On November 19, the day after the release, I ran a small reproduction in Docker (OrbStack's engine). The goal was defensive: prove which version is affected, prove the attack surface is present, and prove that the two remediations actually remove it. I did not run any memory-corruption exploit, for reasons in the next section.
The setup is a self-signed cert and a minimal server block with HTTP/2 and TLS turned on - the configuration that exposes CVE-2026-123007 and CVE-2026-123633:
server {
listen 443 ssl;
http2 on;
server_name localhost;
ssl_certificate /etc/nginx/certs/cert.pem;
ssl_certificate_key /etc/nginx/certs/key.pem;
location / { return 200 "ok\n"; }
}
Affected. Run that on the last vulnerable mainline release, 1.31.8, and confirm both that the version is in range and that HTTP/2 genuinely negotiates:
docker run -d --name nginx-vuln \
-v "$PWD/vuln.conf:/etc/nginx/conf.d/default.conf:ro" \
-v "$PWD/certs:/etc/nginx/certs:ro" \
-p 8443:443 nginx:1.31.8
docker exec nginx-vuln nginx -v
# nginx version: nginx/1.31.8 -> in the affected range 1.9.5 - 1.31.8
curl -sk --http2 -o /dev/null -w "protocol: %{http_version} status: %{http_code}\n" https://localhost:8443/
# protocol: 2 status: 200
echo | openssl s_client -connect localhost:8443 -alpn h2 2>/dev/null | grep -i "ALPN protocol"
# ALPN protocol: h2
The server is a vulnerable version and it speaks HTTP/2. That is the "you are affected" state.
Mitigated. Same 1.31.8 image, the only change is http2 off;. The client still asks for HTTP/2, but the server must refuse and fall back:
curl -sk --http2 -o /dev/null -w "protocol: %{http_version} status: %{http_code}\n" https://localhost:8444/
# protocol: 1.1 status: 200
# ALPN: no h2 offered -> CVE-2026-123007 / 123633 attack surface removed
Patched. The fixed mainline release 1.31.9, with HTTP/2 left on, so you keep the feature and lose the bug:
docker exec nginx-fixed nginx -v
# nginx version: nginx/1.31.9 -> NOT in the affected range (this is a fixed build)
curl -sk --http2 -o /dev/null -w "protocol: %{http_version} status: %{http_code}\n" https://localhost:8445/
# protocol: 2 status: 200 -> HTTP/2 still works, on a patched server
Both fixed images, nginx:1.31.9 (mainline) and nginx:1.30.7 (stable), were already on Docker Hub the day after release, which is faster than these images sometimes land. Here is the whole check in one view:
What this proves, and what it does not: it proves the version boundary and that both remediations work, so you can trust the "upgrade or disable HTTP/2" advice end to end. It does not reproduce code execution. That is deliberate.
Why I did not run the public "exploit" repos
Within a day of disclosure, GitHub had proof-of-concept and "exploit" repositories for these CVEs. Rapid7's own PoC is real and was tested against a linux/amd64 Docker image of nginx 1.31.8. But a reader pointed me at an anonymous third-party repo, created on the disclosure date, with a single star and a two-line description naming the two CVEs. I did not run it, and you should not either. Three reasons:
- Provenance. A brand-new, unreviewed repo from an anonymous account, posted the day a popular CVE drops, is one of the most reliable malware-delivery patterns there is. The thing that calls itself an nginx exploit is frequently a credential stealer or a miner. I wrote about one version of that pattern in the LiteLLM 1.107.0 supply chain attack.
- A container is not a safe blast radius here. The whole point of nginx2root is that the chain escapes Docker to host root through a kernel bug that has existed since 2018. Running unknown "exploit" code for this specific family inside a container and trusting the container to hold is precisely the assumption the attack breaks.
- Reproducing the real RCE is impractical anyway. As above, it needs about 119 GiB of HTTP/2 traffic, a one-hour window, and a target with specific AVX-512 glibc behavior. A one-file repo that promises instant root is not doing that.
The defensive reproduction above - version detection plus confirming the mitigations - gives you everything you need to act, with none of the risk of executing attacker-controlled code.
Am I affected, and how do I fix it?
Step 1: find out if you are affected
You are exposed to the two HTTP/2 RCE-class bugs if you run nginx in the affected range and have HTTP/2 enabled.
# Version (watch for distro backports, see the warning below)
nginx -v
# Is HTTP/2 configured anywhere?
grep -RnE 'http2|listen .*http2' /etc/nginx/ 2>/dev/null
# From a client, does a site negotiate HTTP/2?
curl -skI --http2 https://YOUR_HOST/ -o /dev/null -w '%{http_version}\n'
# "2" means HTTP/2 is on
For containers and Kubernetes ingress, check the actual image tag or digest you are running, not a floating latest. nginx ingress controllers bundle nginx and need a fix from their own vendor.
Step 2: patch (the real fix)
Upgrade nginx Open Source to 1.31.9 (mainline) or 1.30.7 (stable). NGINX Plus has its own fixed builds (37.3.0.1 and 37.0.8.1). Two warnings that bite people:
- A reload is not enough. A configuration reload does not replace the running executable. After upgrading the package you must restart nginx or do a live binary upgrade, and then confirm the old worker processes have actually exited.
- The version string can lie. Distributions backport security fixes without bumping the upstream version number, so
nginx -valone may not tell you whether you are patched. Compare the full package version against your distribution's advisory.
Step 3: if you cannot patch immediately, mitigate
- HTTP/2 bugs (CVE-2026-123007, CVE-2026-123633): disable HTTP/2. On nginx 1.25.1 or later set
http2 off;in the affected server blocks, or remove thehttp2parameter fromlistendirectives. Reload, confirm old workers exited, and re-enable after upgrading. This does not cover the other three CVEs. (My Docker check above confirms the server then refuses HTTP/2 and falls back to HTTP/1.1.) - Resolver UAF (CVE-2026-123634): use fixed upstreams or remove request-time DNS resolution. Note that
mirror_request_body ondoes not fix the resolver bug. - HTTP/3 UAF (CVE-2026-121810): remove QUIC listeners.
- Mail proxy UAF (CVE-2026-113425): bind mail listeners to loopback or otherwise restrict access.
- The SCTP kernel bug (the "2root" escalation): until a kernel fix lands, on hosts that do not need SCTP you can blacklist the module, for example
install sctp /bin/falsein a file under/etc/modprobe.d/. This does not unload an already-loaded module or disable SCTP compiled into the kernel.
Step 4: hunt for exploitation
Wiz calls these "general warning signs, not confirmed indicators," which is the right caveat - treat them as leads, not proof:
- Unexpected nginx worker crashes, or commands launched by nginx that you did not configure.
- Long-lived HTTP/2 connections that transfer very large amounts of data and send a large number of WINDOW_UPDATE frames. Given the ~119 GiB, roughly-hour-long profile of the known RCE path, that traffic shape is a reasonable thing to alert on.
- CDNs and WAFs that terminate HTTP/2 themselves may absorb parts of the attack, depending on implementation - but do not rely on that as your fix.
FAQ
What is CVE-2026-123007?
It is an unauthenticated remote code execution vulnerability in nginx's HTTP/2 flow control, fixed on November 18, 2026. A connection send window is credited twice and pushed past its maximum, then an unsigned bounds check underflows, letting the counter grow into a value that becomes a negative length in a memory copy and corrupts the heap. It affects nginx Open Source 1.9.5 through 1.31.8 when HTTP/2 is enabled.
What is nginx2root?
nginx2root is the name Xint gave to a chain of five nginx CVEs plus a separate Linux SCTP kernel vulnerability. The nginx HTTP/2 bug gives code execution as the nginx worker, and the kernel bug escalates that to root on the host, escaping the Docker container nginx runs in. Hence "nginx to root."
Which nginx versions are affected and which are fixed?
The HTTP/2 RCE (CVE-2026-123007) affects nginx Open Source 1.9.5 through 1.31.8. The fixes are 1.31.9 on the mainline branch and 1.30.7 on the stable branch; NGINX Plus has 37.3.0.1 and 37.0.8.1. The other four nginx2root CVEs have slightly different lower bounds but are all fixed in the same release.
How do I protect nginx right now?
Upgrade to 1.31.9 or 1.30.7 and restart nginx (a config reload does not replace the running binary). If you cannot upgrade immediately, set http2 off; to remove the two HTTP/2 bugs' attack surface, and apply the per-component mitigations for the resolver, HTTP/3 and mail proxy issues. Verify by checking the package version against your distribution's advisory, not just nginx -v.
Is there a public exploit, and should I run it?
Rapid7 published a working proof of concept, and anonymous "exploit" repos appeared within a day. Do not run unvetted ones: a brand-new anonymous repo posted on disclosure day is a classic malware vector, and this chain is specifically designed to escape containers to host root, so a container will not protect you. Reproducing the real RCE also needs about 119 GiB of HTTP/2 traffic and a specific CPU, so a one-file "instant root" tool is not doing what it claims.
If you run nginx with HTTP/2, treat this as patch-now: upgrade to 1.31.9 or 1.30.7 and restart the service, because a reload does not replace the running binary and a backported fix may not change the version string. Cannot patch this minute? Set http2 off; to close the two HTTP/2 RCE bugs, and apply the separate mitigations for the resolver, HTTP/3 and mail CVEs. The CVSS 9.2 is real but the known RCE needs roughly 119 GiB of HTTP/2 traffic and a specific CPU, so you have a real window - use it. And do not run anonymous "exploit" repos to test yourself: version detection plus confirming HTTP/2 is off, which you can do safely in Docker, tells you everything you need.
References
- nginx security advisories - the official affected and fixed version ranges and severities
- F5 advisory K000163926 - the vendor advisory for the release
- CVE-2026-123007: Critical NGINX HTTP/2 Integer Underflow Leads to RCE - Rapid7 - root cause, CVSS vector, PoC details and the exploitation cost figures
- Unauthenticated Remote Code Execution in NGINX: CVE-2026-123633 and CVE-2026-123007 - Wiz - function-level analysis of both HTTP/2 bugs and detection guidance
- nginx2root: Remote Code Execution - Xint - the five-CVE set, the SCTP kernel chain, and the disclosure timeline
- CVE-2026-123007 and CVE-2026-123633: NGINX HTTP/2 RCE - Safe Security
- nginx2root: NGINX HTTP/2 RCE (CVE-2026-123007) Patched - Cyber Kendra - the Red Hat 8.1 and Ubuntu severity divergence
- RFC 9113: HTTP/2 - the flow-control and FLOW_CONTROL_ERROR rules
- Related: LiteLLM 1.107.0 supply chain attack and the eMudhra CA key compromise

