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 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

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

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_pass target 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.