nginx2root: Five new nginx vulnerabilities, and how Cloudflare protects origins from the worst of them

On November 18, 2026, F5 and nginx.org disclosed ten vulnerabilities in nginx. Five of them, detailed by the Xint research team and published under the name nginx2root, are memory corruption flaws that an unauthenticated attacker can use to crash an nginx worker or, per Xint's research, run commands on the server. Xint also found a Linux kernel bug that turns that foothold into root on the host, including from inside a Docker container. Other teams found the two HTTP/2 bugs independently: F5 also credits Rapid7, Wiz Research and Ikotas Labs for CVE-2026-123007, and Metnir, Wiz Research, and Palo Alto Networks Unit 42 for CVE-2026-123633.
nginx is an HTTP web server that also serves as reverse proxy, content cache, load balancer, TCP/UDP proxy server, and mail proxy server. nginx runs a large share of the world's web servers, so this is a patch-now event. But if your nginx server is reachable only through Cloudflare's proxy, attackers cannot reach the vulnerable code paths for the most serious of these bugs, giving you protection while you update your servers.
Here is where Cloudflare stands, what that protection covers, where it stops, and how the bugs work.
The short version
- Cloudflare's edge is not affected. Much of the proxy that handles customer traffic at our edge now runs on FL2, written in Rust. We reviewed the parts still built on our heavily modified nginx fork against all five bugs before disclosure, and an update closing the related code paths finished rolling out globally before the vulnerabilities were published. The same releases fix five other nginx CVEs, including CVE-2026-118899, an infinite loop while reading a request body over TLS 1.3.
- Origins behind Cloudflare's HTTP proxy are shielded from the HTTP/2 and HTTP/3 attacks. For proxied hostnames, Cloudflare terminates every client HTTP/2 and HTTP/3 connection at our edge and opens a separate connection to your origin. The attacker's frames never reach your nginx.
- The resolver and mail proxy vulnerabilities depend on specific configuration. Many configurations of nginx will not be vulnerable, but the safest way to be sure is to update your install or disable features.
- You should still patch. Update to nginx 1.30.7 or 1.31.9 (or your vendor's fixed build) and restart. Some configurations, covered below, are not protected by the proxy.
What was disclosed
nginx2root is five independent bugs. Each one works on its own and each one needs a different configuration.
CVE | Bug class | Affected configuration | First affected release |
CVE-2026-123007 | Integer overflow leading to out-of-bounds heap read/write | HTTP/2 enabled | 1.9.5 (2015) |
CVE-2026-123633 | Use-after-free | HTTP/2 with | 1.19.7 |
CVE-2026-121810 | Use-after-free | HTTP/3 (QUIC) with | 1.25.0 |
CVE-2026-123634 | Use-after-free |
| 0.6.18 |
CVE-2026-113425 | Use-after-free | Mail proxy with | 0.5.33 |
F5 rates each one High (CVSS 3.1: 8.1) and Critical (CVSS 4.0: 9.2), and notes that code execution requires disabling or bypassing ASLR (Address Space Layout Randomization). For CVE-2026-123007, Xint's write-up shows how it leaked memory addresses to do exactly that.
CVE-2026-123007 is the one to worry about most. It only needs HTTP/2 turned on, which is commonly enabled on TLS deployments, and it has been in every nginx release since HTTP/2 support shipped in 1.9.5. Xint ran the exploit over the public Internet against servers on AWS, GCP and Azure. Xint searched Shodan on November 10, before the disclosure, and found 56.7 million hosts matching product:nginx. Of the 11.94 million that reported a version, 98.9% fell in the affected range. As of November 19, Censys's nginx2root exposure tracker counts about 8.8 million services running a potentially affected version with HTTP/2 enabled. Version strings don't prove a host is vulnerable, since distributions backport fixes, but the exposure is large.
The same nginx releases also fix five other bugs. The most serious, CVE-2026-118899, is an infinite loop when reading a request body over TLS 1.3 that lets an unauthenticated attacker stall a worker, in nginx 1.13.0 and later.
The Linux kernel bug is the sixth part of nginx2root. Xint found a use-after-free in the kernel's SCTP send path, present since Linux 4.15 (2018): while a send operation waits, its SCTP association can be moved to another socket, and the waiting send can then free it. An attacker who already runs code as the nginx worker can use it to gain root on the host, and Xint did this from an nginx running inside a Docker container. Many distributions load the SCTP module automatically the first time a program opens an SCTP socket, so hosts that never use SCTP can still be exposed. As of November 18, no kernel fix was available and Xint was withholding the details until there is one.
As of November 19, none of the five nginx2root CVEs is in CISA's Known Exploited Vulnerabilities catalog, and we have not seen reports of exploitation in the wild. Xint and Wiz Research have not released their exploits. Rapid7 has published a proof of concept, which it describes as suitable only for demonstrating the attack against a freshly started local container. Fake 'exploits' are also circulating on GitHub.
Why Cloudflare's proxy protects your origin
nginx2root's most dangerous bugs live in how nginx parses and manages HTTP/2 and HTTP/3 connections. To trigger them, an attacker has to send a carefully ordered stream of protocol frames directly to the nginx process: billions of WINDOW_UPDATE frames, a SETTINGS frame that holds response data back, PING frames that fill the send buffers, partial HEADERS frames, RST_STREAM at exactly the right moment.
When your DNS record is proxied through Cloudflare, that connection ends at our edge.

Cloudflare reads the client's HTTP request, applies your security and caching rules, and then makes its own request to your origin over a connection Cloudflare controls. The flow-control frames, pings, settings, and stream resets that the attacker sends are consumed by our edge. They are not forwarded. Your nginx only ever sees the requests Cloudflare chooses to send, framed the way Cloudflare frames them. This also holds when Cloudflare connects to your origin over HTTP/2: Cloudflare runs its own flow control on that connection and sends WINDOW_UPDATE and RST_STREAM frames only as its own traffic needs, so a client can't make it relay the billions of WINDOW_UPDATE frames the attack requires.
Rapid7 makes the same point in its analysis of CVE-2026-123007: if the HTTP/2 connection is proxied, the attacker's frames "will likely not be retransmitted" in a way that allows exploitation. This breaks each of the HTTP/2 and HTTP/3 attacks.
CVE | What the attacker needs | Behind Cloudflare's HTTP proxy |
CVE-2026-123007 | Direct control over HTTP/2 | Protected. Control frames terminate at Cloudflare's edge. |
CVE-2026-123633 | The first part of a HEADERS frame on a direct HTTP/2 connection, plus the ability to exhaust nginx connection slots and reset the TCP connection | Protected. The client's HTTP/2 connection terminates at Cloudflare. |
CVE-2026-121810 | A direct QUIC/HTTP/3 connection to nginx | Protected. HTTP/3 terminates at Cloudflare's edge. We do not communicate to origins over HTTP/3 |
CVE-2026-123634 | A request and its mirror or SSI subrequest waiting on the same DNS lookup, and the main request ending while the answer is processed. In Xint's exploit, nginx's resolver had to reach the attacker's DNS server. | Not fully protected. Depends on how your config builds |
CVE-2026-113425 | A direct IMAP/POP3/SMTP connection to the nginx mail proxy | Not protected. Cloudflare's HTTP proxy does not carry mail traffic. |
There is one condition to be protected by Cloudflare here: your origin must not be reachable directly. If an attacker can find your origin's IP and connect to it directly (TCP 443 or 80 for HTTP/2, UDP 443 for HTTP/3, or the mail ports), Cloudflare isn't in the path and the protection doesn't apply. You should ensure that your origin servers can only be accessed through Cloudflare’s proxies, using one of the following approaches:
- Cloudflare Tunnel. Your origin makes an outbound-only connection to Cloudflare and exposes no inbound ports.
- Firewall to Cloudflare IP ranges. Accept inbound HTTP/HTTPS only from Cloudflare's published IP ranges. This must be done using an IP firewall, not based on configuration in your nginx server.
- Authenticated Origin Pulls (mTLS). Your origin rejects any TLS connection that doesn't present Cloudflare's client certificate.
Xint's own exposure check makes the same point: "If a CDN or reverse proxy sits in front of nginx, the test only reaches the proxy, so also run it directly against the nginx server."
Where the protection does not apply
There are several situations in which Cloudflare’s HTTP proxy does not provide protection.
- Spectrum TCP/UDP applications. For these configurations, traffic from the Internet is passed unmodified through to your origin. If your origin is running nginx, patch or disable the affected features.
- nginx mail proxy. Cloudflare's HTTP proxy does not carry IMAP, POP3 or SMTP. Restrict mail listeners to trusted networks until patched.
- CVE-2026-123634 (resolver). This depends on how your configuration builds the
proxy_passtarget from the request, combined with a carefully timed cancellation of an HTTP request. Passing your traffic through Cloudflare’s proxy makes it harder to exploit this, but does not provide full protection. Update regardless. - DNS-only (grey-cloud), internal or non-proxied nginx. Any nginx server an attacker can reach without going through Cloudflare, including internal services behind a compromised host, needs to be patched.
Cloudflare’s WAF rules are not relevant to these vulnerabilities. These are protocol-level bugs. Because Cloudflare’s proxy handles parsing the HTTP protocol messages, and creates new messages to fetch information from origin servers, origins behind Cloudflare's HTTP proxy are protected from the HTTP/2 and HTTP/3 bugs without needing a rule. We have therefore not released a managed rule. The protection comes from connection termination, not from pattern matching.
What to do now
- Find every nginx server. Include nginx Plus, distribution packages, container images and appliances. Run
nginx -Vandnginx -Ton each and note HTTP/2, HTTP/3/QUIC listeners,proxy_passwith variables plus SSI ormirror, and anymailblock. - Patch. Update nginx Open Source to 1.30.7 or 1.31.9, nginx Plus to 37.0.8.1 or 37.3.0.1, or your distribution's fixed package. F5 lists nginx Plus R34 to R36 as affected with no fixed build, so move those to a fixed 37.x release. Then restart nginx or complete a binary upgrade. A config reload does not replace the running binary.
- Check backport versions carefully. Distributions often patch without changing the version
nginx -vreports. Compare the full package version against your distribution's advisory. - Make sure your origin is only reachable through Cloudflare. Use Tunnel, IP allowlisting or Authenticated Origin Pulls.
- If you can't patch yet, disable what you don't need.
http2 off;(nginx 1.25.1 and later; on older versions, removehttp2from thelistendirective) blocks CVE-2026-123007 and CVE-2026-123633. Removing QUIC listeners and settinghttp3 off;blocks CVE-2026-121810. Pointproxy_passat fixed upstream groups for CVE-2026-123634. Don't rely onmirror_request_bodyalone: Xint's tested setup set it tooff, and the defaultonstopped that exploit, but SSI and other subrequests can still reach the bug. Bind mail listeners to trusted networks for CVE-2026-113425. Restart so old connections close. - Block SCTP if you don't use it. Add
install sctp /bin/falseto a file in/etc/modprobe.d/to stop the kernel module from loading. This doesn't unload an already-loaded module or disable SCTP built into the kernel. When your distribution ships a kernel update for the SCTP bug, install it and reboot. Blocking the module is a stopgap until then.
The Cloudflare Radar Zero Wire entry for nginx2root has the full checklist, a prompt you can give an agent to run a read-only assessment of your fleet, and links to every vendor advisory.
Technical deep dive
Let’s dig into the details of the five bugs by looking through the code. We’re looking at nginx 1.31.8 (commit 140aa94) which was the most recent code published before the fixes, and comparing this to the fixes in 1.31.9 (which were also included in release 1.30.7 on the stable branch).
A note on methodology: we based our analysis on the public advisories, and to verify our reading of the code, we built the public 1.31.8 and 1.31.9 releases with AddressSanitizer and ran tests for four of the five bugs (flow control, HTTP/2 use-after-free, resolver and mail proxy). Each one faults on 1.31.8 and runs clean on 1.31.9. We did not reproduce the HTTP/3 bug; that section is based on the fix commit and the published analysis.
One pattern, in four places
Four of the five bugs are use-after-free bugs. This is a common issue with programs that manually manage memory without language support: one part of the code frees an object that another part is still using.
nginx is event driven. A handler runs, calls other code, and that code returns to the handler. Three of the bugs occur when the called code tears down the connection or request the handler is working on. In the fourth, a second connection still holds a pointer to the object.
- CVE-2026-123633 and CVE-2026-121810. A request needs a connection slot to reach its upstream. nginx is low on slots, so it closes an idle connection to free one. The connection it chooses is the one the request belongs to.
- CVE-2026-123634. A resolver callback ends a request. Cleanup of that request frees a second resolver context that the resolver is about to call next.
- CVE-2026-113425. When a write to a mail client fails, the client connection is closed while the connection to the authentication service still points at its session.
F5 rates all four as potential code execution if address space layout randomization (ASLR) is disabled or bypassed, and in its tests Xint reports code execution with the privileges of the nginx worker.
The fifth bug, CVE-2026-123007, is of a different kind: an accounting error that becomes a length error.
CVE-2026-123007: two flow-control pieces that each look correct
HTTP/2 flow control limits the amount of response data a server may send. nginx tracks a send window for each stream and one for the connection, h2c->send_window. The client enlarges a window with a WINDOW_UPDATE frame, and the protocol caps every window at 2^31 − 1.
nginx enforces that cap when a WINDOW_UPDATE arrives (ngx_http_v2_state_window_update()):
if (window > NGX_HTTP_V2_MAX_WINDOW - h2c->send_window) {
/* logs "client violated connection flow control" */
return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_FLOW_CTRL_ERROR);
}On its own, this check is correct. But the connection window also grows in a second place. When nginx queues DATA frames for a stream, it subtracts their length from the window. If the stream is canceled before those frames go out, ngx_http_v2_filter_cleanup() takes them off the queue and returns the credit:
h2c->send_window += window;Nothing caps this line. As the fix commit describes, if the client enlarges the connection window after the frames are queued and before the stream is terminated, the refund pushes the window past 2^31 − 1.
From that point the first check no longer works. h2c->send_window is an unsigned size_t, so NGX_HTTP_V2_MAX_WINDOW - h2c->send_window wraps around to a very large number and every subsequent WINDOW_UPDATE is accepted. The client can then raise the window as far as it wants.
The window is unsigned, but the code that sizes DATA frames compares it as a signed value (ngx_http_v2_send_chain()):
if (limit == 0 || limit > (off_t) h2c->send_window) {
limit = h2c->send_window;
}
...
if ((off_t) frame_size > limit) {
frame_size = (size_t) limit;
}After the window passes 2^63, it is negative as an off_t. The frame size becomes the window value itself, a number between 2^63 and 2^64, and nginx builds a buffer whose last pointer lies before its pos pointer.
Over TLS, that buffer reaches a memcpy() in ngx_ssl_send_chain() with that length. Our TLS test stops at that point under AddressSanitizer. Xint's write-up explains how, with the window pushed close to 2^64, this turns into a controlled out-of-bounds write and an address leak, and Xint, Rapid7, and Wiz each report code execution from it. This post goes no further than the fault.
Over cleartext HTTP/2, the same invalid buffer follows a different output path. Our cleartext test also faults under AddressSanitizer on 1.31.8 and runs clean on 1.31.9. The public write-ups address the TLS case.
How much traffic the known attacks require
The biggest step a WINDOW_UPDATE can take is 2^31 − 1, and a WINDOW_UPDATE frame is 13 bytes. Bringing a 64-bit window near its top therefore requires about 2^33 frames: roughly 8.6 billion frames, or about 112 GB (104 GiB).
Rapid7, which published a proof of concept, gives the same figure and adds that nginx limits control-frame traffic relative to other traffic on the connection, so its run also sends about 15 GiB of other request traffic. Its total comes to approximately 128 GB of HTTP/2 data: about two minutes on a 10 Gbit/s link and about seventeen minutes at 1 Gbit/s. Rapid7 estimates the WINDOW_UPDATE traffic needed to reach 2^63 at about 2^32 frames, or 52 GiB, half of the 104 GiB figure. It also notes that these figures describe its route and are not a proven minimum.
For defenders, this is the useful fact about the bug. At this volume, the known attacks are hard to hide: nginx receives tens of gigabytes from a single client over one long-lived connection and sends little back, much more than the requests in the access log account for.
Why it was difficult to find
The refund line has existed in nginx since HTTP/2 support arrived in 1.9.5 in 2015. Two things made it difficult to notice.
First, each piece looks correct on its own. The check on WINDOW_UPDATE is the right check. The refund is the right refund. The bug is that the check relies on an assumption the refund does not preserve.
Second, testing that waits for a crash is very unlikely to reach it, because a crash requires tens of gigabytes of input. The bad state itself can be reached with very little traffic: Censys published a cleartext test that reaches what it calls the corrupted flow-control state with a 5.69 MB capture. A test that asserts "the send window never exceeds its protocol maximum" after every frame would flag the bad state as soon as a test sequence got there. A test that waits for memory corruption would not.
The fix
The fix (6 lines added) introduces a counter, h2c->send_queued, for DATA that is queued but not yet sent. The WINDOW_UPDATE check now includes those bytes in the window:
if (window > NGX_HTTP_V2_MAX_WINDOW - h2c->send_window - h2c->send_queued) {From the client's perspective, queued frames still count toward the window, so the client can no longer refill credit that nginx is about to refund. On a fixed version the attempt is rejected with a flow-control error.
CVE-2026-123633: where two protections interact
An nginx worker has a fixed number of connection slots (worker_connections), which the client and upstream connections share. Since 1.19.2, when free slots run low (1/16 of the total or fewer), ngx_get_connection() calls ngx_drain_connections(), which closes connections marked "reusable": connections with nothing in progress, such as idle keep-alive connections.
This works only if a reusable connection truly has nothing in progress. For HTTP/2 that was not always the case. Two commits landed on the same day in February 2021 and were released together in 1.19.7:
- "HTTP/2: fixed reusing connections with active requests" fixed a case in which a cleartext HTTP/2 connection could remain reusable while it had a request.
- "HTTP/2: reuse of connections with incomplete frames" registered a connection as reusable while it waits for the remainder of a partly received frame, so that a client cannot hold slots with partial frames.
The second change is the relevant one here. As the fix commit explains, if the remainder of that frame is a HEADERS frame, a stream is created, but the reusable status was not reset until the connection next went idle. The connection then has a request and remains in the reusable queue.
If that request is proxied, nginx requests a slot for the upstream connection. If slots are short, the drain runs inside that call and can choose this same connection. The drain instructs the connection to close and nginx attempts to send GOAWAY. If that send fails, nginx frees the connection and every stream on it. Control then goes back to the upstream code, which continues to use the request it was called for.
Each change made sense on its own. The interaction between them was subtle and stayed unnoticed until this year. F5's advisory credits Albert Ebb of Metnir, Nir Ohfeld at Wiz Research, Xint.io and memN0ps of Palo Alto Networks Unit 42; nginx.org's changelog credits Albert of Vexera AI.
The fix
Two lines added: ngx_http_v2_create_stream() now calls ngx_reusable_connection(h2c->connection, 0). A connection that has a stream is never reusable, regardless of the state it was in before.
CVE-2026-121810: the same idea, in QUIC
According to the fix commit and Xint's analysis, the HTTP/3 bug reaches the same result by a different route.
In nginx's QUIC code, each QUIC connection uses one connection slot and each stream uses another. A QUIC connection may be drained only when every stream remaining in its tree can be cancelled, and nginx determines this by walking the connection's tree of streams.
ngx_quic_create_stream() removes the QUIC connection from the reusable queue and then requests a slot for the new stream. Before the fix, the new stream was added to the tree only after that. If the slot request triggered a drain that closed another, idle stream of the same QUIC connection, the code handling the closed stream walked the tree, did not find the stream being created, concluded the connection was idle, and made it reusable again. A later drain, for example when the new request connects to its upstream, could then close the QUIC connection while that request was running.
F5's advisory states that exploitation "also depends on conditions beyond the attacker's control". Xint writes that the bug "is triggered by a slightly different mechanism" from the HTTP/2 one.
The fix
Four lines added: the stream goes into the tree before the slot is requested, and is taken out again on the error paths.
CVE-2026-123634: freeing the next item of a list during the walk
When proxy_pass contains a variable, nginx resolves the host name while handling the request. If a lookup for the same name is already in progress, the new request waits on the same resolver node. When the answer arrives, nginx detaches the list of waiting contexts and calls each in turn:
next = rn->waiting;
rn->waiting = NULL;
while (next) {
ctx = next;
...
next = ctx->next;
ctx->handler(ctx);
}The loop stores next before the handler call, so a handler may free its own context. The trouble starts when a handler frees a different context in the same list. This happens when two contexts belong to one request, as with a request and its mirror subrequest resolving the same name (the case Xint tested; F5 also lists SSI subrequests). If the first handler ends the request, the request's cleanup calls ngx_resolve_name_done() for the second context. That function searches the node's waiting list for the context, does not find it because the list has been detached, and frees the context regardless. The loop then advances to the freed context.
Usually nginx logs this. On vulnerable versions, when the search fails, it writes
could not cancel <name> resolvingto the error log at alert level. This line is worth searching for. It is not proof either way: the fix commit notes that one variant, while following a CNAME, produced no alert.
The fix
A context cancelled while it sits in a detached list is no longer freed immediately. Its handler is swapped for one that frees it when the loop gets to it (31 lines added). The fix also downgrades the alert to a debug message, so the line above shows up at alert level only on unpatched versions.
CVE-2026-113425: two connections, one session
With auth_http, the mail proxy asks an HTTP service to verify each login. During the wait, it holds two connections for one session: the client connection and the connection to the authentication service. The second points at the session and uses the memory pool of the client connection.
Before the fix, the reply the protocol handler had prepared for the client remained queued while the authentication request was in progress, and the client's write handler was still ngx_mail_send(). If that handler ran and the write failed because the client had reset the connection, it closed the client connection and destroyed the session. The authentication connection still pointed at the session, and the next event on that connection used freed memory.
Xint describes two conditions for this: the client's write event must already be registered (for example, because the client stopped reading replies), and the login command and the reset must be handled in the same pass of the event loop. Valid credentials are not needed, because this happens before the login is checked.
The fix
Two added lines discard the queued reply when the authentication request begins. The same release contains three further commits that block client writes while the proxy waits for the authentication response, while it connects to the upstream and reads its greeting, and while it resolves an SMTP client's address and name.
What the fixes share
The five fixes each involve minor corrections to the code. They add between 2 and 31 lines each, and the mail proxy fix came with three further commits. There is no design change needed. Each fix restores an invariant that the rest of the code already depended on:
- a send window never goes above the protocol maximum
- a connection with a request in progress is never reusable
- an object that other code is about to use is not freed out from under it
In every case, one code path failed to keep a rule that the rest of the code relied on, and the fix makes that path keep it. As code is modified over time, it is very easy for these kinds of rules to become broken.
What to watch for
Attempts to exploit this will typically trigger some characteristic log messages. Three of these messages (the two at info and the one at warn) fall below nginx's default error_log level of error and appear only if a lower level is set. The alert messages are logged by default.
Bug | Log messages or other signals |
CVE-2026-123007 | A single long-lived HTTP/2 connection on which nginx receives tens of gigabytes from a client and sends little back, much more than its logged requests account for. On fixed versions a rejected attempt logs |
CVE-2026-123633, CVE-2026-121810 |
|
CVE-2026-123634 |
|
CVE-2026-113425 | Worker crashes in a mail proxy using |
All five | Unexpected programs launched by an nginx worker process, for example from an |
Timeline
Date (UTC) | Event |
Oct 11, 2026 | Xint discovers the vulnerabilities |
Oct 16, 2026 | Reported to F5 via HackerOne |
Oct 27, 2026 | Reports delivered to the nginx development team |
Nov 10, 2026 | Xint completes patch validation |
Nov 18, 2026 | Public disclosure; nginx 1.30.7 and 1.31.9 released |
Closing
CVE-2026-123007 sat in nginx for more than ten years. The SCTP bug has been in the Linux kernel since 2018. Xint says one of its researchers found CVE-2026-123007 by hand and an automated Xint scan found the other four nginx bugs. Several other teams found the two HTTP/2 bugs independently. Meanwhile, nginx's advisory list has gone from two entries in 2025 to 36 so far this year. AI-assisted research is finding bugs in heavily reviewed code faster than before, and more disclosures like this one are coming.
That's a large part of why it's worth putting Cloudflare in front of your origin. A protocol bug in your web server becomes much less of a risk when the attacker can't speak that protocol to your server directly. Our edge is not affected, and the HTTP/2 and HTTP/3 attacks against your nginx end at our network. Patch anyway, lock down your origin so Cloudflare is the only way in, and use the Radar Zero Wire page to check your fleet.


