nginx2root: Critical NGINX Flaw Lets Attackers Run Code With No Login — Patch Now

If your website runs on NGINX, there is a good chance it is vulnerable right now. On November 18, 2026, researchers at Xint disclosed nginx2root, a set of five critical vulnerabilities in the world’s most popular web server software — and the worst of them lets an attacker run code on your server without logging in, without a password, and without you ever noticing until it is too late.

NGINX powers more than a third of all public websites, including servers run by tech giants, global brands, governments and most foundational software platforms. The flaw has been hiding in NGINX’s HTTP/2 code since the protocol was introduced in 2015 — more than a decade of exposure, in software that has been audited by some of the best security researchers in the world. The fix is out, the patch takes minutes, and every hour you wait is an hour attackers can use to build on the public details.

What Is nginx2root?

nginx2root is the name Xint gave to a collection of five distinct vulnerabilities, each with its own CVE number: CVE-2026-123007, CVE-2026-123634, CVE-2026-123633, CVE-2026-121810 and CVE-2026-113425. Each one has a proven exploit. Together, they affect NGINX Open Source versions from 1.9.5 through 1.31.8, the stable 1.30.x line, and several NGINX Plus releases.

The most severe is CVE-2026-123007, an integer overflow in NGINX’s HTTP/2 flow control that causes a heap buffer overflow. F5, which maintains NGINX, rates it Critical with a CVSS score of 9.2. The second headline flaw, CVE-2026-123633, is a use-after-free bug that triggers when NGINX drains an HTTP/2 connection while connecting to an upstream server. The other three flaws affect TLS 1.3, reverse-proxy setups and NGINX’s mail proxy, and several of them need specific configurations to be exploitable — but all five can lead to unauthenticated code execution with the privileges of the NGINX worker process.

As of November 10, 2026, Xint found that 98.9 percent of hosts running an identifiable version of NGINX were affected. That is not a rounding error. That is nearly every NGINX server on the public internet.

How the Attack Works

A stylized diagram-like illustration of data packets flowing through a glowing network tunnel toward a web server

You do not need to understand memory corruption to understand the danger, but the short version is this: HTTP/2 lets a browser and a server agree on how much data can be in flight at once, using a mechanism called flow control. NGINX failed to count queued response bytes when validating HTTP/2 WINDOW_UPDATE frames, so an attacker could push the connection window past the protocol’s limit and corrupt the server’s memory.

From there, an unauthenticated remote attacker can disclose memory addresses, reuse freed memory, and replace a cleanup function that runs when a connection closes — which is enough to execute commands with worker privileges and receive the output over the same connection. Xint’s team demonstrated the full chain: from NGINX remote code execution all the way to root on the server, remotely and unauthenticated.

The only precondition is an externally reachable TLS or HTTP/2 port. No login, no credentials, no user interaction. And because NGINX is trivially easy to fingerprint with broadly available tools, exposed servers can be found at scale in minutes.

For the full technical details, see Xint’s technical writeup.

How Bad Is It, Really?

Serious — but with an important qualification. At the time of disclosure, no attacks exploiting these flaws had been reported in the wild, and CVE-2026-123007 was not listed in CISA’s Known Exploited Vulnerabilities catalog. That is genuinely good news, and it reflects the unusual care taken around disclosure: Xint limited who knew about the discovery, gave customers only 24 hours’ notice without naming the target, and held back details until the patch was publicly available.

CERT-EU’s security advisory also tracks the disclosure and the available patches.

The bad news is that the window is closing fast. Public exploit code is already circulating, and researchers have confirmed working unauthenticated remote code execution against affected builds. As Xint’s public advisory puts it, AI-enabled attackers can now reverse engineer exploits from even the smallest clues — which is exactly why the disclosure was handled so carefully, and exactly why patching quickly matters more than ever. This is the same pattern AI agents turning patches into exploits that Google warned about earlier this month.

It is also worth remembering that this is the second major HTTP/2 remote code execution flaw in a matter of weeks. Just days earlier, a critical Apache HTTP/2 flaw forced a similar emergency patch. Two different web servers, the same protocol, the same class of bug — HTTP/2’s complexity is proving to be fertile ground for memory-safety flaws.

How to Check If You Are Affected

First, find out whether you run NGINX at all. If you use a managed host, a CDN or a cloud load balancer, your provider may handle it — but check anyway, because the fix only helps if it is actually deployed. If you manage your own server, run nginx -v to see the version, then check whether HTTP/2 is enabled on any listening port with sudo nginx -T | grep http2.

You are at risk if you run an affected version with HTTP/2 enabled. Note that distribution packages complicate the version check: Ubuntu and Debian were still listing vulnerable packages on patch day, and fixes may be backported without the version string changing — so compare your full installed package version against your distribution’s security advisory, not just the NGINX version number. And if you use the retired ingress-nginx controller in Kubernetes, there is no fix coming at all: you need to plan a move to another ingress controller.

How to Patch in Minutes

The fix is straightforward, and for most servers it takes about ten minutes.

1. Update NGINX to a fixed version: open-source 1.30.7 or 1.31.9 (or later), or NGINX Plus 37.3.0.1 or 37.0.8.1. On Debian or Ubuntu, run sudo apt update and then sudo apt install –only-upgrade nginx nginx-common; on RHEL-based systems, use sudo dnf update nginx. In Docker, pull the new image and recreate the container.

2. Test the configuration with sudo nginx -t.

3. Restart NGINX — not reload. A reload can leave old worker processes handling existing connections, so the vulnerable code keeps running. A full restart with sudo systemctl restart nginx makes sure the new code is what actually serves traffic.

4. Confirm the fix by checking the installed package version and the service start time, and verify the running binary is the new one.

That is the whole job for most servers. The urgency is real: Microsoft’s November Patch Tuesday fixed more than a thousand flaws in the same week, including an Outlook zero-day already under attack — and the lesson from both is the same. Patch fast, patch completely, and do not assume a version number tells the whole story.

What If You Cannot Patch Right Now?

If an update is not immediately possible, there is a workaround: disable HTTP/2 on exposed listeners. On NGINX 1.25.1 and later, add http2 off; to each affected server block and remove any legacy http2 parameter from your listen directives. On older versions, remove http2 from the listen line itself. That removes the attack path for the two headline flaws, though it does nothing for the other three — so treat it as a stopgap, not a fix.

Also worth doing while you are in there: make sure ASLR and other memory protections are enabled and that NGINX workers run as a non-root user. That does not fix the bug, but it makes the worst outcome — full code execution — substantially less likely, reducing it to a worker crash instead.

The AI Angle: Found by Machines, Exploited by Machines

There is a twist to this story that says a lot about where security is heading. Four of the five vulnerabilities were found by Xint’s autonomous platform with no human steering. A researcher pointed the system at a 50,000-line slice of NGINX; ninety minutes later it flagged high-severity issues with reproduction steps specific enough to become a working exploit in under ten minutes. The fifth flaw was found by a human on the same team.

Six months ago, Xint made headlines for finding CopyFail, the most severe Linux vulnerability in years — but that discovery needed human guidance. This time the AI did it alone, using mostly the same models that have been generally available since May. As Xint CEO Brian Pak put it, models are setting the floor for performance in cyber, but harness development is setting the ceiling.

That cuts both ways. The same AI capabilities that found this flaw in ninety minutes can rebuild an exploit from a patch diff in hours — which is why disclosure windows are shrinking. Google Project Zero’s shorter disclosure deadlines are a direct response to the same shift. Defenders now have to patch at machine speed, because attackers already exploit at machine speed.

The Bottom Line

nginx2root is a reminder that the most dangerous vulnerabilities are not always in the newest technology. This one sat in HTTP/2 code written in 2015, in one of the most scrutinised codebases on the internet, and it took an AI-assisted platform ninety minutes to find what two decades of human auditing had missed.

If you run NGINX, the action is simple: update to 1.30.7 or 1.31.9, restart the service, and verify the fix. If you cannot update yet, turn off HTTP/2. Then check the rest of your stack — because the cybersecurity threats to watch in 2026 are increasingly the ones hiding in plain sight, in the infrastructure you stopped thinking about years ago.

Leave a Comment

Your email address will not be published. Required fields are marked *

Scroll to Top