On November 18, 2026, security teams at F5 and nginx.org jointly disclosed a severe batch of ten vulnerabilities affecting the NGINX web server ecosystem. Among the most alarming discoveries are five memory corruption flaws collectively detailed by the Xint research team under the moniker “nginx2root.” These vulnerabilities can be exploited by unauthenticated attackers to crash NGINX worker processes or, under specific conditions, execute arbitrary commands on the underlying server. Compounding the threat, Xint also uncovered a long-standing Linux kernel bug that can leverage this initial foothold to achieve root privileges on the host system, even when executed from inside a Docker container.
Given that NGINX powers a massive share of the world’s web infrastructure, serving as an HTTP web server, reverse proxy, content cache, load balancer, and mail proxy, this disclosure represents a critical patch-now event. However, network security specialists note that servers shielded behind a reverse proxy like Cloudflare’s edge network enjoy significant mitigation, as attackers are blocked from reaching the vulnerable protocol code paths for the most serious of these flaws. Nonetheless, administrators worldwide are racing to update their systems to eliminate potential attack vectors.
The Short Version and Scope of Disclosure
The vulnerabilities grouped under the nginx2root umbrella consist of five independent bugs, each functioning autonomously and requiring specific configurations to trigger. F5 has rated each of these flaws as High under CVSS 3.1 with scores of 8.1, and Critical under CVSS 4.0 with scores reaching 9.2. Researchers have noted that achieving actual code execution requires bypassing or disabling Address Space Layout Randomization (ASLR). For CVE-2026-123007, Xint demonstrated how memory addresses could be leaked precisely to achieve this bypass.
CVE-2026-123007 has emerged as the primary source of concern among security professionals because it requires only that HTTP/2 be enabled—a standard configuration on modern TLS deployments. This vulnerability has existed in every NGINX release since HTTP/2 support was first introduced in version 1.9.5 back in 2015. Xint successfully tested the exploit over the public internet against live servers hosted on major cloud providers including AWS, GCP, and Azure. Internet-wide scans conducted via Shodan prior to the disclosure revealed tens of millions of matching hosts, with the vast majority running versions falling within the affected range. Censys exposure trackers estimated that millions of internet-facing services were running potentially vulnerable versions with HTTP/2 enabled. While version strings alone do not guarantee vulnerability—as many Linux distributions backport security patches independently—the overall exposure footprint remains massive.
In addition to the headline-grabbing nginx2root flaws, the latest NGINX releases also patch five other distinct issues. The most notable among these is CVE-2026-118899, an unauthenticated vulnerability causing an infinite loop when reading request bodies over TLS 1.3, which allows malicious actors to stall worker processes indefinitely on NGINX versions 1.13.0 and later.
Adding a severe infrastructure dimension to the disclosure, Xint identified a sixth component involving a use-after-free vulnerability in the Linux kernel’s SCTP send path, which has been present since Linux 4.15 was released in 2018. Under this flaw, while a send operation is waiting, its SCTP association can be moved to another socket, allowing the waiting send operation to erroneously free it. An attacker who has already established code execution within an NGINX worker can exploit this kernel weakness to escalate privileges to root on the host machine. Xint successfully demonstrated this escalation from an NGINX instance operating inside a Docker container. Because many Linux distributions automatically load the SCTP kernel module the moment any program opens an SCTP socket, hosts that never actively utilize SCTP remain exposed. At the time of disclosure, a kernel fix was not yet publicly available, prompting Xint to withhold technical details until a patch could be issued.
Why Reverse Proxies Provide Origin Protection
The most dangerous vulnerabilities within the nginx2root advisory reside in the complex ways NGINX parses and manages HTTP/2 and HTTP/3 connections. To trigger these bugs, an attacker must transmit a precisely ordered sequence of protocol frames directly to the NGINX process, involving massive volumes of flow-control frames, customized settings, ping commands, and stream resets.

When a website or application’s DNS records are proxied through a service like Cloudflare, the incoming client connection terminates securely at the network’s edge. The proxy reads the incoming HTTP request, enforces security and caching policies, and subsequently initiates an independent connection to the origin server under controlled parameters. Consequently, the raw flow-control frames, pings, and stream resets sent by a malicious actor are fully consumed and neutralized at the edge rather than forwarded to the origin. The backend NGINX server only ever interacts with sanitized requests framed directly by the proxy. This architectural barrier effectively breaks the attack chains for both HTTP/2 and HTTP/3 vulnerabilities.
Security analysis from organizations like Rapid7 confirms this assessment, noting that when HTTP/2 connections are proxied, malicious frames are generally not retransmitted in a manner that permits downstream exploitation. However, security experts emphasize an absolute prerequisite for this protection: the origin server must not be directly reachable via its raw IP address. If an attacker can bypass the proxy and connect directly to the origin via standard ports for HTTP/2, HTTP/3, or mail services, the protective barrier is bypassed entirely. Administrators are strongly advised to restrict origin access exclusively to authorized proxy networks.
Technical Deep Dive into the Flaws
Analyzing the source code before and after the patches reveals the subtle nature of these memory management errors. Four of the five primary NGINX bugs are classified as use-after-free vulnerabilities, a persistent risk in complex C-based software where memory is managed manually. NGINX operates on an asynchronous, event-driven architecture where handlers execute, invoke sub-routines, and return control. The use-after-free conditions typically materialize when a called subroutine prematurely tears down a connection or request while the primary handler is still actively processing it.
CVE-2026-123007 diverges from the use-after-free pattern, representing instead an accounting error that culminates in a severe length calculation flaw. HTTP/2 flow control relies on send windows to limit outgoing response data. NGINX tracks individual stream windows alongside a global connection send window. While protocol limits cap these windows, an oversight in how window credits are refunded when canceled data frames are removed from the transmission queue allowed windows to wrap past safe cryptographic boundaries. This accounting breakdown ultimately led to integer overflows, invalid buffer pointer allocations, and memory corruption via standard TLS transmission paths.
Similarly, CVE-2026-123633 stems from an interaction between connection recycling logic and HTTP/2 stream initialization. NGINX maintains a fixed pool of worker connections shared by client and upstream traffic. When free connection slots run low, the server aggressively reclaims idle keep-alive connections. Due to a timing oversight, active HTTP/2 connections could be incorrectly flagged as reusable, leading to premature closure and subsequent use-after-free faults when upstream communication resumed. CVE-2026-121810 mirrors this underlying logic within the newer QUIC and HTTP/3 protocol implementations, where tree-walking algorithms failed to account for newly spawned streams during slot exhaustion events.
CVE-2026-123634 involves resolver routines tied to dynamic proxy directives. When multiple requests or subrequests, such as mirror or Server Side Include (SSI) directives, awaited the same DNS resolution, the completion handler could inadvertently free contexts belonging to related requests during list traversal. Finally, CVE-2026-113425 affected mail proxy configurations utilizing HTTP authentication, where client connection resets during pending authentication checks left stale session pointers vulnerable to memory corruption.
The Road Ahead and Industry Response
As of the initial disclosures, none of the five primary CVEs had been incorporated into the Cybersecurity and Infrastructure Security Agency’s Known Exploited Vulnerabilities catalog, and widespread active exploitation in the wild had not been formally reported. While some security vendors published limited proof-of-concept code designed strictly for local testing against isolated containers, various spurious scripts began circulating on public repositories.
Industry observers note that the discovery of these complex vulnerabilities—some of which lingered undetected in heavily reviewed codebases for over a decade—underscores an accelerating trend in software security. With automated scanning tools and AI-assisted research methods identifying deep logic flaws at an unprecedented rate, software maintainers face a rising volume of critical disclosures. Security leaders emphasize that defense-in-depth strategies, including rigorous network edge protection, strict origin firewalling, and prompt patch management, remain essential safeguards against evolving infrastructure threats.