nginx2root: Six CVEs, One Chain from HTTP Request to Root

Six CVEs in nginx, one of them in the codebase since 2015. Chain it with a Linux kernel zero-day and you go from unauthenticated HTTP request to root on the host, container escape included. That's nginx2root.
Xint's research team dropped this on November 18. Five independent RCE paths in nginx, plus a separate privilege escalation bug in the Linux kernel's SCTP subsystem. Any of the nginx bugs gets you code execution as the nginx worker. The SCTP bug then takes you to root, breaking out of Docker in the process.
If you run nginx, update to 1.31.9 when it ships. That's the short version.
The main bug: CVE-2026-123007
This one has the widest blast radius. It requires HTTP/2 enabled, and nothing else. No authentication, no special configuration, just a listening HTTP/2 port.
The root cause is an integer overflow in nginx's HTTP/2 flow control accounting. HTTP/2 uses send windows to prevent the server from flooding a client that isn't ready. The server tracks how much data it's allowed to send through two counters: one per-stream and one for the whole connection (h2c->send_window).
When response data gets queued, nginx subtracts the size from both windows. If a stream gets canceled before the data is sent, cleanup returns that credit back to the connection window. The problem: cleanup doesn't check whether the returned credit pushes the window past the HTTP/2 maximum (0x7fffffff).
An attacker can exploit this sequence deliberately:
- Raise the connection window to its maximum with WINDOW_UPDATE on stream ID 0
- Set
SETTINGS_INITIAL_WINDOW_SIZEto 0 so nginx queues response bodies but can't send them - Flood nginx with PING frames to fill the TLS/TCP send buffers
- Grant each stream enough window to queue its full response body
- Send another WINDOW_UPDATE to grant Q more bytes, then RST_STREAM to cancel the streams
Cancellation returns Q back through cleanup. That same Q was already added by the WINDOW_UPDATE. The window ends up at Wmax + Q, past the 31-bit limit, with no check catching it.
From there, the remaining-capacity check in ngx_http_v2_state_window_update() does unsigned arithmetic on a value that's already past its valid range. The subtraction underflows to a huge positive number, so nginx keeps accepting WINDOW_UPDATE frames indefinitely.
Eventually the window wraps to a value that, when cast to a signed off_t, becomes a small negative number -d. That -d flows into the DATA frame size calculation, then into a buffer pointer setup where chunk->last = chunk->pos + (-d), putting the end pointer before the start. The TLS output path computes size = last - pos, gets -d as a signed value, casts it to size_t, and passes 2^64 - d to memcpy() as the copy length.
A copy of almost 2^64 bytes sounds like an instant crash. It isn't, because of how glibc's x86-64 memcpy works. Since glibc 2.24, the AVX2 path copies back-to-front for large sizes. The destination end pointer overflows the 64-bit address space and wraps below the start, so the backward loop exits after one pass. What actually gets written is a ~160-byte region: 96 bytes before the TLS buffer (overwriting heap metadata) and 64 bytes inside it (read back in the TLS response as a leak).
That's both address disclosure and heap corruption in one shot. Xint used this to disclose nginx image and heap addresses, overwrite a cleanup function pointer, and execute arbitrary commands as the nginx worker, working over public HTTPS against AWS, GCP, and Azure.
The code has been in nginx since HTTP/2 was introduced in version 1.9.5 in 2015. More than ten years.
Worker to root: the SCTP kernel LPE
Getting RCE as the nginx worker is useful but limited. Workers normally run as a low-privilege user. What Xint also found is a zero-day in the Linux kernel's SCTP subsystem.
The bug is in the SCTP send path. A send operation waits while its association gets transferred to another socket, then frees the transferred association, causing a use-after-free or double free depending on what the other socket does. It was introduced in Linux v4.15 in 2018 and has been there for over eight years.
Xint extracted two primitives from it: a kernel memory disclosure that defeats KASLR, and an arbitrary function call in the kernel. Combined, they give root.
They tested the full chain (nginx2root worker RCE + SCTP LPE) on AWS, GCP, Azure, and bare metal. It works. Including inside Docker, because all containers on a host share the same kernel, so root on the kernel means root on everything.
SCTP is loaded on demand on many Linux distros when any program opens an SCTP socket. If you don't use SCTP, you can block it:
echo "install sctp /bin/false" > /etc/modprobe.d/disable-sctp.conf
Note this only blocks loading via modprobe. It does nothing if the module is already loaded or compiled into the kernel directly.
Xint is withholding the full SCTP exploit details until a kernel patch is available. Fair call.
The other four nginx CVEs
The other bugs are use-after-frees with narrower configuration requirements.
CVE-2026-123634: Use-after-free in nginx's DNS resolver. Requires resolver + proxy_pass with a variable (like proxy_pass http://$host;) + mirror with mirror_request_body off. When the main request and its mirror wait for the same DNS answer, cleanup can free the mirror's resolver context while the loop still holds a pointer to it. The fix for this one is to use a fixed upstream block instead of a variable in proxy_pass and disable mirror if you don't need it.
CVE-2026-123633: Use-after-free in HTTP/2 with an upstream connection. An HTTP/2 connection can stay in nginx's "reusable" queue (eligible for draining) even when it has an active stream, due to an ordering issue in ngx_http_v2_handle_connection(). When the active request tries to open an upstream connection and nginx needs a free slot, it drains connections from that queue, potentially closing the very connection the request is running on, freeing the request pool while the upstream code is still running.
CVE-2026-121810: Same class of bug but in HTTP/3/QUIC. During QUIC stream creation, a timing issue can put the parent QUIC connection back into the reusable queue. A subsequent upstream connect can then drain it, freeing the request.
CVE-2026-113425: Use-after-free in the mail proxy's auth_http path. During a login lookup, if the client's TCP connection resets and both a read event (parsing the login command) and a write event (sending a queued reply) are processed in the same event loop iteration, the write handler can close and free the client session while the auth connection still holds a pointer to it. The next event on the auth connection uses the freed session. Only affects nginx mail proxy deployments.
Each of these is an independent path to RCE. They don't need each other.
What to do
Patch. nginx 1.31.9 fixes all five nginx CVEs. No fixed build is out yet as of this writing, but it's scheduled for November 18. After installing it, restart nginx or do a live binary upgrade. A config reload does not replace the running executable.
Watch out for version string confusion. Ubuntu and Debian backport fixes without bumping the nginx version that nginx -v shows. The package version changes, but nginx version: nginx/1.24.0 stays the same. Check the full package version against your distribution's security advisory, not the nginx version string.
Temporary mitigations (while you wait):
Disabling HTTP/2 blocks CVE-2026-123007 and CVE-2026-123633. For nginx 1.25.1 and later:
listen 443 ssl;
http2 off;
For older versions, remove http2 from the listen directive:
listen 443 ssl;
This does not cover CVE-2026-123634, CVE-2026-121810, or CVE-2026-113425.
For CVE-2026-123634: replace proxy_pass variables with fixed upstream blocks and turn off mirror if you don't need it.
For CVE-2026-121810: remove QUIC listeners.
For CVE-2026-113425: restrict access to mail proxy ports via firewall if external access isn't needed.
Check exposure:
# Check nginx version
nginx -v
# Check whether HTTP/2 module is compiled in
nginx -V 2>&1 | grep -q -- '--with-http_v2_module' && echo "HTTP2_MODULE=present"
# Check whether HTTP/2 is enabled
sudo nginx -T 2>&1 | sed 's/#.*//' | grep -nE 'listen[[:space:]].*http2|^[[:space:]]*http2[[:space:]]+on[[:space:]]*;'
Check SCTP:
# Block SCTP module loading (if not needed)
echo "install sctp /bin/false" > /etc/modprobe.d/disable-sctp.conf
# Check if already loaded
lsmod | grep sctp
The pattern here
Shodan showed 56.7 million nginx hosts on November 10. Of the ones reporting a version, 98.9% fell in the affected range. That's the population that just became a target.
CVE-2026-123007 sat in nginx for more than ten years. The SCTP bug has been in the Linux kernel since 2018. Both projects have had years of security review. These bugs survived because they're in the interaction between subsystems: HTTP/2 flow control accounting plus memory management, SCTP send paths plus socket transfer semantics. The kind of thing a manual code review per-file tends to miss.
Xint says CVE-2026-123007 was found by a researcher preparing for a conference. The other four were found by a fully automated scan, without human guidance, shortly after.
The advisory also notes that nginx had two new CVEs in all of 2025. By November 17 this year, it had 26, not counting nginx2root. Something has changed in the speed at which these bugs are being found.
Patch nginx when 1.31.9 lands. Disable HTTP/2 in the meantime if the exposure matters. And check whether SCTP is loaded on your servers.