F5 and nginx.org disclosed ten nginx vulnerabilities on November 18, 2026. Five of them, attributed to the Xint research team and published as nginx2root, are memory corruption flaws that an unauthenticated attacker can use to crash a worker process or, according to Xint, execute commands on the server. Xint additionally identified a Linux kernel bug that elevates that foothold to root on the host, including from a Docker container. Two HTTP/2 bugs were also found independently by other teams: F5 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.

How Cloudflare's edge is positioned

The proxy serving customer traffic at Cloudflare's edge now runs largely on FL2, written in Rust. Cloudflare reviewed the parts still built on its modified nginx fork against all five bugs before disclosure, and an update closing the related code paths finished rolling out globally before publication. Those same releases address five additional nginx CVEs, among them CVE-2026-118899, an infinite loop triggered while reading a request body over TLS 1.3.

The nginx2root flaw set

nginx2root consists of five independent bugs, each exploitable on its own and each requiring a different configuration. F5 rates them High (CVSS 3.1: 8.1) and Critical (CVSS 4.0: 9.2), and notes that code execution requires disabling or bypassing ASLR. For CVE-2026-123007, Xint's write-up demonstrates leaking memory addresses to achieve exactly that.

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 proxy_pass to a backend, worker low on worker_connections

1.19.7

CVE-2026-121810

Use-after-free

HTTP/3 (QUIC) with proxy_pass to a backend

1.25.0

CVE-2026-123634

Use-after-free

resolver + proxy_pass with variables + a subrequest (mirror or SSI)

0.6.18

CVE-2026-113425

Use-after-free

Mail proxy with proxy on and auth_http

0.5.33

CVE-2026-123007 matters most: it requires only HTTP/2, commonly enabled on TLS deployments, and has existed 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. A Shodan search on November 10, before disclosure, matched 56.7 million hosts on product:nginx; of the 11.94 million reporting a version, 98.9% fell in the affected range. By November 19, Censys's nginx2root exposure tracker counted roughly 8.8 million services running a potentially affected version with HTTP/2 enabled. Version strings don't prove vulnerability, since distributions backport fixes, but the exposed population is large.

The five other bugs in the same releases include CVE-2026-118899, the most serious of that group: an infinite loop while reading a request body over TLS 1.3, present in nginx 1.13.0 and later, that lets an unauthenticated attacker stall a worker.

The kernel piece completes 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 then frees it. An attacker already executing code as the nginx worker can use this to gain root on the host — Xint did so from nginx running inside a Docker container. Many distributions autoload the SCTP module 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 existed, and Xint withheld details until one ships.

As of November 19, none of the five nginx2root CVEs appears in CISA's Known Exploited Vulnerabilities catalog, and no exploitation in the wild has been reported. Xint and Wiz Research have not released exploits. Rapid7 published a proof of concept it describes as suitable only for demonstrating the attack against a freshly started local container, and fake "exploits" are circulating on GitHub.

Why proxied origins are shielded

The most dangerous nginx2root bugs live in HTTP/2 and HTTP/3 connection parsing and management. Triggering them requires sending a carefully ordered stream of protocol frames straight to the nginx process: billions of WINDOW_UPDATE frames, a SETTINGS frame that holds response data back, PING frames filling send buffers, partial HEADERS frames, RST_STREAM at precisely the right moment.

With a proxied DNS record, that connection terminates at Cloudflare's edge.

image1.png

The edge reads the client's HTTP request, applies security and caching rules, then opens its own connection to the origin. Flow-control frames, pings, settings and stream resets from the attacker are consumed at the edge and not forwarded; your nginx sees only the requests Cloudflare chooses to send, framed as Cloudflare frames them. This holds even when Cloudflare speaks HTTP/2 to the origin: it runs its own flow control on that connection and emits WINDOW_UPDATE and RST_STREAM frames only as its own traffic requires, so a client cannot force relay of the billions of WINDOW_UPDATE frames the attack depends on. Rapid7 reaches the same conclusion for CVE-2026-123007, noting that proxied HTTP/2 frames "will likely not be retransmitted" in an exploitable way.

CVE

What the attacker needs

Behind Cloudflare's HTTP proxy

CVE-2026-123007

Direct control over HTTP/2 WINDOW_UPDATE, SETTINGS, PING and RST_STREAM on one connection to nginx

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 proxy_pass. Patch.

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.

Keeping the origin unreachable

The protection presumes attackers cannot reach your origin directly. If they can find its IP and connect over TCP 443 or 80 (HTTP/2), UDP 443 (HTTP/3) or the mail ports, Cloudflare is out of the path. Three approaches keep origin access confined to Cloudflare's proxies:

  • Cloudflare Tunnel: the origin makes an outbound-only connection and exposes no inbound ports.
  • Firewall to Cloudflare IP ranges: accept inbound HTTP/HTTPS only from Cloudflare's published ranges, enforced by an IP firewall rather than nginx configuration.
  • Authenticated Origin Pulls (mTLS): the origin rejects TLS connections that don't present Cloudflare's client certificate.

Xint's exposure check makes the same point, advising that when a CDN or reverse proxy fronts nginx, the test only reaches the proxy, so it should also be run directly against the nginx server.

Gaps in the proxied shield

  • Spectrum TCP/UDP applications: Internet traffic passes unmodified to the origin. Patch or disable the affected features on any nginx origin.
  • 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): exploitation depends on how configuration builds the proxy_pass target from the request, combined with a timed HTTP request cancellation. Proxying makes it harder but is not full protection; update regardless.
  • DNS-only, internal or otherwise non-proxied nginx: any instance reachable without going through Cloudflare, including internal services reachable from a compromised host, needs patching.

WAF rules play no part here. These are protocol-level bugs, and because the proxy parses HTTP messages itself and constructs new ones toward origin servers, proxied origins are shielded from the HTTP/2 and HTTP/3 flaws without a rule. No managed rule was released; the protection comes from connection termination, not pattern matching.

Remediation steps

  1. Inventory every nginx server, including nginx Plus, distribution packages, container images and appliances. On each, run nginx -V and nginx -T and note HTTP/2 and HTTP/3/QUIC listeners, proxy_pass with variables plus SSI or mirror, and any mail block.
  2. Patch. Move 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 through 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.
  3. Verify backports. Distributions often patch without changing the version nginx -v reports; compare the full package version against the distribution advisory.
  4. Confine origin access to Cloudflare via Tunnel, IP allowlisting or Authenticated Origin Pulls.
  5. If patching must wait, disable what you don't need. http2 off; (nginx 1.25.1 and later; on older versions, remove http2 from the listen directive) blocks CVE-2026-123007 and CVE-2026-123633. Removing QUIC listeners and setting http3 off; blocks CVE-2026-121810. Point proxy_pass at fixed upstream groups for CVE-2026-123634. Don't rely on mirror_request_body alone: Xint's tested setup set it to off, and the default on stopped 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.
  6. Block SCTP if unused. Add install sctp /bin/false to a file in /etc/modprobe.d/ to prevent the module from loading. This neither unloads an already-loaded module nor disables SCTP built into the kernel. Install and reboot into your distribution's kernel update for the SCTP bug when it ships; the module block is a stopgap.

The Cloudflare Radar Zero Wire entry for nginx2root carries the full checklist, an agent prompt for a read-only fleet assessment, and links to every vendor advisory.

Inside the code: five fixes, one broken invariant

The analysis below compares nginx 1.31.8 (commit 140aa94), the last release before the fixes, with 1.31.9, whose changes also shipped in 1.30.7 on the stable branch. Four of the five bugs were reproduced: the public 1.31.8 and 1.31.9 trees were built with AddressSanitizer and exercised for flow control, HTTP/2 use-after-free, resolver and mail proxy cases. Each faults on 1.31.8 and runs clean on 1.31.9. The HTTP/3 bug was not reproduced; that part rests on the fix commit and published analysis.

Four use-after-frees with a common shape

Manual memory management is the backdrop: one part of nginx frees an object another part still references. Because nginx is event driven, a handler can call into code that tears down the very connection or request the handler is operating on. Three bugs take that form; in the fourth, a second connection keeps a pointer to a freed object.

  • CVE-2026-123633 and CVE-2026-121810. A request needs a connection slot to reach its upstream, nginx is short on slots, and the idle connection it closes to free one belongs to that same request.
  • CVE-2026-123634. A resolver callback ends a request; the request's cleanup frees a second resolver context the resolver is about to invoke.
  • CVE-2026-113425. A failed write to a mail client closes the client connection while the connection to the authentication service still points at its session.

F5 rates all four as potential code execution when ASLR is disabled or bypassed; Xint reports code execution with the worker's privileges in its tests. The fifth bug, CVE-2026-123007, is an accounting error that turns into a length error.

CVE-2026-123007: a refund that breaks a check

HTTP/2 flow control gives nginx a send window per stream and one per connection, h2c->send_window. Clients enlarge windows with WINDOW_UPDATE frames, and the protocol caps every window at 2^31 − 1. nginx enforces that cap when the frame arrives in 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);
}

That check is sound by itself. But the connection window also grows elsewhere: queuing DATA frames for a stream subtracts their length, and if the stream is canceled before they are sent, ngx_http_v2_filter_cleanup() dequeues them and returns the credit.

h2c->send_window += window;

Nothing caps this refund. Per the fix commit, a client that enlarges the connection window after the frames are queued but before the stream terminates pushes the window past 2^31 − 1. The first check then fails open: h2c->send_window is an unsigned size_t, so NGX_HTTP_V2_MAX_WINDOW - h2c->send_window wraps to a huge value and every later WINDOW_UPDATE is accepted. The frame-sizing code in ngx_http_v2_send_chain() treats the same window as signed:

if (limit == 0 || limit > (off_t) h2c->send_window) {
   limit = h2c->send_window;
}
...
if ((off_t) frame_size > limit) {
   frame_size = (size_t) limit;
}

Once the window passes 2^63 it is negative as an off_t. The frame size becomes the window itself, a value between 2^63 and 2^64, and nginx builds a buffer whose last pointer precedes its pos pointer. Under TLS that buffer reaches a memcpy() in ngx_ssl_send_chain() carrying that length, where the AddressSanitizer test stops. Xint's write-up describes how a window driven near 2^64 yields a controlled out-of-bounds write and an address leak; Xint, Rapid7 and Wiz each report code execution. Over cleartext HTTP/2 the invalid buffer follows a different output path, and the cleartext test also faults on 1.31.8 and passes on 1.31.9; the public write-ups cover the TLS case only.

Traffic cost and why the bug hid so long

A WINDOW_UPDATE frame is 13 bytes and moves a window by at most 2^31 − 1, so reaching 2^63 from a 64-bit value takes about 2^32 frames. Rapid7's proof of concept cites 52 GiB of WINDOW_UPDATE traffic; it also notes that nginx limits control-frame traffic relative to other traffic, so its run adds roughly 15 GiB of request traffic for a total near 128 GB. That is about 112 GB (104 GiB) of frames alone, or about two minutes on a 10 Gbit/s link and seventeen minutes at 1 Gbit/s. These numbers describe Rapid7's route, not a proven minimum. For defenders the volume is the useful part: tens of gigabytes arriving from one client over a single long-lived connection, with little sent back and far more than the requests in the access log explain.

The refund line has been in nginx since HTTP/2 support landed in 1.9.5 in 2015. Each half looks right on its own — the cap check is correct, the refund is correct — and the check simply relies on an assumption the refund does not preserve. Crash-driven testing is also a poor fit at this scale, since triggering a fault needs tens of gigabytes of input. The bad state is far cheaper: Censys published a cleartext test that reaches what it calls the corrupted flow-control state with a 5.69 MB capture. An assertion that the send window never exceeds its protocol maximum after each frame would catch it immediately; waiting for memory corruption would not.

The 6-line fix

The patch adds a counter, h2c->send_queued, tracking DATA that is queued but unsent, and folds those bytes into the WINDOW_UPDATE check:

if (window > NGX_HTTP_V2_MAX_WINDOW - h2c->send_window - h2c->send_queued) {

Queued frames now count toward the window as the client sees it, so credit nginx is about to refund cannot be replenished. A fixed version answers the attempt with a flow-control error.

CVE-2026-123633: when draining picks the wrong connection

Each worker has a fixed pool of worker_connections slots shared by client and upstream connections. Since 1.19.2, once free slots fall to 1/16 of the pool or fewer, ngx_get_connection() calls ngx_drain_connections(), which closes connections marked reusable — those with nothing in progress, such as idle keep-alives.

The safety argument holds only if "reusable" is accurate. For HTTP/2 it was not always. Two commits landed the same day in February 2021 and shipped in 1.19.7:

  • "HTTP/2: fixed reusing connections with active requests" addressed a cleartext HTTP/2 connection that stayed reusable while holding a request.
  • "HTTP/2: reuse of connections with incomplete frames" marked a connection reusable while it waited for the rest of a partly received frame, preventing a client from hoarding slots with partial frames.

The second is the relevant one. According to the fix commit, if that remainder is a HEADERS frame a stream is created — but the reusable flag is not cleared until the connection next goes idle, so a connection with a request stays in the reusable queue. Once the request is proxied, nginx asks for a slot for the upstream connection; under pressure the drain runs inside that call and can pick this same connection. The drain tells it to close and nginx tries to send GOAWAY; if that send fails, nginx frees the connection and all its streams, and control returns to the upstream code, which keeps using the request it was called for. F5 credits Albert Ebb of Metnir, Nir Ohfeld at Wiz Research, Xint.io and memN0ps of Palo Alto Networks Unit 42; the nginx.org changelog credits Albert of Vexera AI.

The fix is two lines: ngx_http_v2_create_stream() now calls ngx_reusable_connection(h2c->connection, 0), so a connection holding a stream is never reusable whatever state it was in.

CVE-2026-121810: the same outcome through QUIC

Per the fix commit and Xint's analysis, HTTP/3 arrives at the same result differently. A QUIC connection occupies one slot and each stream another. A QUIC connection may be drained only if every stream left in its tree can be cancelled, which nginx decides by walking that tree. ngx_quic_create_stream() removed the connection from the reusable queue and then requested a slot for the new stream, adding the stream to the tree only afterwards. If that request triggered a drain that closed another idle stream of the same QUIC connection, the handler for the closed stream walked the tree, missed the stream under construction, judged the connection idle and made it reusable again. A later drain — for instance when the new request connects to its upstream — could then close the QUIC connection mid-request. F5 notes that exploitation "also depends on conditions beyond the attacker's control", and Xint writes that it "is triggered by a slightly different mechanism" than the HTTP/2 bug. The fix adds four lines: the stream enters the tree before the slot request and is removed again on the error paths.

CVE-2026-123634: freeing the next entry mid-walk

When proxy_pass contains a variable, nginx resolves the host name during the request. If a lookup for the same name is already running, the new request waits on the same resolver node. When the answer arrives, nginx detaches the list of waiting contexts and invokes each in turn:

next = rn->waiting;
rn->waiting = NULL;

while (next) {
   ctx = next;
   ...
   next = ctx->next;

   ctx->handler(ctx);
}

The loop saves next before the handler call, so a handler may free its own context. The problem is a handler freeing a different context in the same list — the case when two contexts belong to one request, as with a request and its mirror subrequest resolving the same name (Xint's test; F5 also lists SSI subrequests). If the first handler ends the request, cleanup calls ngx_resolve_name_done() for the second context; that function searches the node's waiting list, fails to find it because the list is detached, and frees it anyway. The loop then advances to freed memory. Vulnerable versions usually write this to the error log at alert level when the search fails:

could not cancel <name> resolving

It is worth searching for, but not conclusive either way: the fix commit notes one variant, while following a CNAME, produced no alert.

The fix (31 lines) stops freeing a context cancelled while sitting in a detached list; its handler is swapped for one that frees it when the loop reaches it. The message is also demoted to debug, so it appears at alert level only on unpatched builds.

CVE-2026-113425: closing one side of a mail session

With auth_http, the mail proxy asks an HTTP service to verify each login and holds two connections for one session while waiting: the client connection and the one to the authentication service. The latter points at the session and uses the client connection's memory pool. Before the fix, the reply the protocol handler had prepared for the client stayed queued during authentication, and the client's write handler was still ngx_mail_send(). If that handler ran and the write failed because the client reset the connection, it closed the client connection and destroyed the session — leaving the authentication connection pointing at freed memory, which the next event on it would use. Xint lists two preconditions: the client's write event already registered (say, because the client stopped reading replies), and the login command and reset handled in the same event-loop pass. Valid credentials are not needed; this happens before the login is checked.

Two lines discard the queued reply when authentication begins. The same release adds three commits blocking 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 patches have in common

Every fix is small — between 2 and 31 added lines, plus three companion commits for the mail proxy — and none changes the design. Each restores an invariant the surrounding code already trusted:

  • a send window never rises above the protocol maximum;
  • a connection with a request in progress is never reusable;
  • an object another part of the code is about to use is not freed underneath it.

In each case one path stopped honouring a rule the rest of nginx relied on, and the patch makes it honour the rule again. As code evolves, such rules break easily.

Log lines to watch

Exploit attempts tend to leave characteristic entries behind. Three of them — two at info and one at warn — sit below nginx's default error_log level of error and appear only when a lower level is configured; 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 client violated connection flow control: received WINDOW_UPDATE frame with window increment ... not allowed for window ... (level info; older versions have the same message for ordinary violations). http2 flood detected (level info) on such a connection can be a failed attempt, but nginx also logs that message for several other limits.

CVE-2026-123633, CVE-2026-121810

worker process <pid> exited on signal 11 (level alert) on servers that accept HTTP/2 or HTTP/3 and proxy to an upstream, along with worker_connections are not enough, reusing connections (level warn). A use-after-free does not always crash.

CVE-2026-123634

could not cancel <name> resolving (level alert, unpatched versions only). The absence of this message does not rule the bug out.

CVE-2026-113425

Worker crashes in a mail proxy using auth_http, with client connections reset during login.

All five

Unexpected programs launched by an nginx worker process, for example from an auditd rule on execve for the worker's user. Xint recommends this check, and it is the strongest sign of a successful attack.

Disclosure timeline and where the bugs came from

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

The age of some of these flaws stands out. CVE-2026-123007 had been present in nginx for more than ten years, and the SCTP issue has existed in the Linux kernel since 2018. According to Xint, a researcher there found CVE-2026-123007 manually, while an automated Xint scan surfaced the remaining four nginx vulnerabilities. The two HTTP/2 bugs were also independently discovered by several other teams.

Discovery volume is climbing sharply. nginx's advisory list held two entries in 2025 and already has 36 this year. AI-assisted research is locating defects in heavily reviewed code at a faster rate than before, which points to more disclosures of this kind.

Why an edge in front of the origin matters

This is the practical case for placing Cloudflare ahead of your origin server. When an attacker cannot speak a vulnerable protocol to your web server directly, a protocol-level bug becomes far less dangerous. Cloudflare's edge is not affected, and HTTP/2 and HTTP/3 attacks aimed at your nginx terminate at its network.

Patching remains necessary regardless. The other steps are to restrict the origin so that Cloudflare is the only path in, and to audit your fleet using the Radar Zero Wire page.

Sources