# NGINX2Root: How to Check and Fix the 5 nginx Vulnerabilities on Any Server (2026)

> NGINX2Root explained: five nginx CVEs, one fixed in nginx 1.30.7 and 1.31.9. Check your version, update and restart, turn off HTTP/2 if you can't patch yet.

**NGINX2Root is a set of five nginx vulnerabilities, and the worst one lets an attacker run commands on your server without logging in.** It was disclosed on **18 November 2026** by Xint, the research team at Theori. nginx sits in front of roughly a third of the web, including many WordPress sites, so this one matters even if you have never touched an nginx config.

**The official fix is out:** **nginx 1.31.9** (mainline) and **nginx 1.30.7** (stable), released the same day. In their demo, the researchers chained the worst nginx bug with a separate **Linux kernel** bug and reached **root on the host**, even from inside a Docker container. That kernel bug does not have a fix yet.

We covered a similar emergency for PHP in our [**PHP2Shell guide for any host**](/php2shell-wordpress/). **xCloud customers:** our team is already working on this for xCloud servers that run nginx. We'll update this post with every step we take and when.

This guide does the same for nginx for everyone else: what NGINX2Root is, how to tell if your server is exposed, how to patch it on any setup, what to do if you can't patch today, and how to check nobody got in.

![NGINX2Root emergency checklist for any nginx server](/_landing/blog/nginx2root-cover.jpg)

## **TL;DR**

- **What:** five nginx CVEs (CVE-2026-123007, CVE-2026-123633, CVE-2026-121810, CVE-2026-123634, CVE-2026-113425). The worst, **CVE-2026-123007**, is memory corruption in **HTTP/2** flow control that can lead to remote code execution.
- **Who:** any server running nginx **1.9.5 to 1.31.8** with HTTP/2 turned on, which is the common setup for HTTPS sites.
- **Fix:** update to **nginx 1.31.9 or 1.30.7**, or your distribution's patched package, then **restart** nginx. A reload is not enough.
- **Can't patch yet?** Turn off HTTP/2 on every public listener, then check from outside that it's off.
- **Kernel bug:** the step from nginx to root uses a separate Linux kernel bug. Its fix is due "in the coming weeks", so install it when your distribution ships it.

## **NGINX2Root at a Glance**

| | |
|---|---|
| **Name** | NGINX2Root |
| **Found by** | Xint (Theori). One bug was also found independently by other researchers |
| **Disclosed** | 18 November 2026 |
| **CVEs** | CVE-2026-123007, CVE-2026-123633, CVE-2026-121810, CVE-2026-123634, CVE-2026-113425, plus a Linux kernel bug with no public CVE yet |
| **Worst impact** | Unauthenticated remote code execution as the nginx worker; root on the host when chained with the kernel bug |
| **Affected** | nginx 1.9.5 to 1.31.8 for the HTTP/2 bug; older ranges for some others |
| **Official fix** | nginx 1.31.9 (mainline) and 1.30.7 (stable), 18 November 2026 |
| **Exploit status** | Xint has not published its exploit, but third-party proof-of-concept code appeared on GitHub within hours. No confirmed attacks as of 18 November |

The researchers counted **11.8 million of 11.94 million** nginx servers with a visible version number (**98.9%**) running a release in the affected range, in a Shodan snapshot from 10 November 2026. That counts versions, not servers that can actually be attacked: a server is only exposed if the vulnerable feature is turned on and reachable.

## **The Five nginx Bugs, in Plain Words**

Each bug is separate and needs a different setup to be reachable. Here is what each one is and when your server is in scope, from the [**nginx security advisories**](https://nginx.org/en/security_advisories.html):

| CVE | What it is | Your server is in scope if… | Vulnerable versions |
|---|---|---|---|
| **CVE-2026-123007** | Memory corruption in HTTP/2 flow control (nginx rates it **major**) | HTTP/2 is turned on | 1.9.5 to 1.31.8 |
| **CVE-2026-123633** | Use-after-free in HTTP/2 | HTTP/2 is on and nginx proxies to an upstream (for example `grpc_pass`) | 1.19.7 to 1.31.8 |
| **CVE-2026-121810** | Use-after-free in HTTP/3 | HTTP/3 (QUIC) is on and nginx proxies to an upstream | 1.25.0 to 1.31.8 |
| **CVE-2026-123634** | Use-after-free in the resolver | nginx uses the `resolver` directive together with subrequests | 0.6.18 to 1.31.8 |
| **CVE-2026-113425** | Use-after-free in the mail proxy (rated **major**) | nginx runs as a mail proxy with `auth_http` | 0.5.33 to 1.31.8 |

The same nginx release fixes five more lower-risk issues, including an endless loop when reading request bodies over TLS 1.3 (CVE-2026-118899) and a buffer overflow with `alias` and `try_files` (CVE-2026-125283). Updating takes care of all of them at once.

**Why HTTP/2 matters most:** the bug behind CVE-2026-123007 has been in nginx since **HTTP/2 support arrived in 2015**. An attacker only needs to reach your HTTPS port and speak HTTP/2, which every modern browser does. According to the researchers, nginx's **default configuration with HTTP/2 enabled is vulnerable**.

## **Step 1: Find Out Whether Your Server Is Exposed**

Run these three checks over SSH:

```bash
# 1. Which nginx is running? (look for 1.9.5 to 1.31.8)
nginx -v

# 2. Is HTTP/2 built in and switched on?
nginx -V 2>&1 | grep -o with-http_v2_module
sudo nginx -T 2>/dev/null | grep -E "listen .*http2|http2 on|quic|http3|resolver|auth_http"

# 3. Which package is installed? (compare with your vendor's advisory)
dpkg -l | grep nginx        # Ubuntu, Debian
rpm -qa | grep nginx        # RHEL, Rocky, Alma
```

Then check from outside whether the server still offers HTTP/2. Replace `example.com` with your domain:

```bash
openssl s_client -connect example.com:443 -servername example.com -alpn h2 </dev/null 2>&1 | grep "ALPN protocol"
```

If you see `ALPN protocol: h2`, HTTP/2 is on and reachable.

**Don't trust the version number alone.** Ubuntu, Debian and Red Hat often put a security fix into an older version, so `nginx -v` can show 1.24 on a fully patched server. Compare the full package version with your distribution's security notice for these CVEs.

| What you see | What it means |
|---|---|
| 1.31.9 or newer, or 1.30.7 or newer, from nginx.org | Patched. Make sure it was restarted (Step 2) |
| 1.9.5 to 1.31.8 and `h2` offered | Exposed to the HTTP/2 bugs. Patch now, or turn off HTTP/2 (Step 3) |
| Distribution package with an older number | Check your distribution's notice for the CVEs above |
| No nginx at all (OpenLiteSpeed, LiteSpeed, Apache, Caddy) | Not affected by these five bugs. Check for nginx in a proxy or container in front |

## **Step 2: Install the Fixed nginx, Whatever Your Setup**

| Your setup | Who installs the fix | What you do |
|---|---|---|
| **Shared or managed hosting** | Your host | Ask whether they run nginx and when the fix is live |
| **Your own VPS with nginx.org packages** | You | Update to 1.31.9 or 1.30.7 and restart |
| **Your own VPS with Ubuntu or Debian packages** | Your distribution, then you | Install the security update when it ships; turn off HTTP/2 until then |
| **Docker** | You | Pull the rebuilt image and recreate every container |
| **Kubernetes ingress, appliances, panels** | The vendor | Follow the vendor's advisory for its bundled nginx |

### **On Your Own VPS (nginx.org Packages)**

nginx.org already has **1.30.7 and 1.31.9 packages for Ubuntu 22.04, 24.04 and 26.04**. Update and restart:

```bash
sudo apt update
sudo apt install --only-upgrade nginx
nginx -v                         # should say 1.30.7 or 1.31.9
sudo nginx -t && sudo systemctl restart nginx
ps -o pid,lstart,cmd -C nginx    # every process should be new
```

**Restart, don't reload.** `nginx -s reload` and `systemctl reload nginx` only load the new configuration; the old, vulnerable binary keeps running. If you can't afford a restart, nginx's [**binary upgrade procedure**](https://nginx.org/en/docs/control.html#upgrade) swaps the binary without dropping connections.

### **On Ubuntu or Debian's Own nginx Package**

If `dpkg -l` shows a version like `1.24.0-2ubuntu7.x` rather than one from nginx.org, your fix comes from your distribution. Watch the [**Ubuntu security notices**](https://ubuntu.com/security/notices) or Debian's tracker for these CVEs, install the update as soon as it appears, and restart nginx. **Until it's out, do Step 3.**

### **On Docker: Rebuild, Don't Just Restart**

The official `nginx` images on Docker Hub were rebuilt on **18 November 2026**. Restarting a container keeps the old image, so pull and recreate:

```bash
docker pull nginx:stable          # or the tag you use
docker compose up -d --force-recreate
docker exec <container> nginx -v
```

If you pin a tag such as `nginx:1.27-alpine`, check whether that tag was rebuilt by comparing the image digest before and after `docker pull`. Also update the **host's kernel** when the fix lands, because the researchers escaped a container with the kernel bug.

## **Step 3: Turn Off HTTP/2 Until You Can Patch**

If the patch isn't available for your setup yet, turning off HTTP/2 stops the two HTTP/2 bugs, including the worst one. Browsers fall back to HTTP/1.1, so your site keeps working, just a little slower on pages with many files.

**nginx 1.25.1 and newer:** add this to every `server` block that listens on 443, or once in the `http` block:

```nginx
http2 off;
```

**nginx 1.25.0 and older:** remove `http2` from each `listen` line:

```nginx
# before
listen 443 ssl http2;
# after
listen 443 ssl;
```

Then test, reload, and check from outside again:

```bash
sudo nginx -t && sudo nginx -s reload
openssl s_client -connect example.com:443 -servername example.com -alpn h2 </dev/null 2>&1 | grep "ALPN protocol"
```

No `h2` in the result means HTTP/2 is off, but only if the TLS connection itself worked. Existing HTTP/2 connections stay open until they close, so a restart is the cleaner way to be sure.

**Two warnings:**

- **gRPC needs HTTP/2.** If nginx serves gRPC, turning off HTTP/2 breaks it. Patch those servers first.
- **The other three bugs need their own checks.** If you use HTTP/3 (`quic` on a `listen` line), the `resolver` directive with subrequests, or the mail proxy, turn those off where you can, or patch.

### **Does Cloudflare or a CDN Protect You?**

Only if three things are true: the CDN ends the HTTP/2 connection, it talks to your server over **HTTP/1.1**, and nobody can reach your server directly. Attackers who find your server's IP skip the CDN entirely. Lock your firewall to the CDN's IP ranges, or patch. A web application firewall can't inspect HTTP/2 control frames, so **it is not a substitute for the update**.

## **Step 4: Check Whether Anyone Got In**

The researchers saw no attacks before disclosure, but some of these bugs are over ten years old, and third-party proof-of-concept code is now public. After patching, look for:

```bash
# Worker crashes (signal 11 = segmentation fault)
sudo grep -E "worker process .* exited on signal" /var/log/nginx/error.log*

# Anything the nginx user is running besides nginx itself
ps -u www-data -o pid,ppid,lstart,cmd | grep -v nginx

# New or unexpected cron jobs and SSH keys
sudo ls -la /etc/cron.* /var/spool/cron/crontabs 2>/dev/null
sudo find / -name authorized_keys -newer /etc/hostname 2>/dev/null
```

Your access log won't show this attack, because it uses HTTP/2 control frames that nginx doesn't log as requests. Repeated worker crashes or strange processes don't prove a break-in, but treat them seriously.

If anything looks wrong, take the server off the network, keep a copy for investigation, and **rebuild from a clean image**. Patching doesn't remove what an attacker already changed. Rotate every password, API key and database credential the server could reach.

## **Your NGINX2Root Checklist**

| Done | Task |
|---|---|
| ☐ | List every server, container and appliance that runs nginx |
| ☐ | Check the version and whether HTTP/2 is on (Step 1) |
| ☐ | Update to nginx 1.31.9 / 1.30.7 or your vendor's patched package |
| ☐ | **Restart** nginx and confirm no old processes remain |
| ☐ | Can't patch? Turn off HTTP/2 and confirm from outside |
| ☐ | Check HTTP/3, `resolver` and mail proxy settings separately |
| ☐ | Look for worker crashes and unexpected processes |
| ☐ | Install the Linux kernel update when your distribution ships it |

## **Running WordPress? What This Means for You**

NGINX2Root is not a WordPress or plugin bug, so **no WordPress update, security plugin or firewall plugin can fix it**. The attack hits nginx before WordPress even loads, just like [**PHP2Shell hit PHP**](/php2shell-wordpress/). Your site is exposed if nginx serves it, which is the case on many managed WordPress hosts and most self-built VPS setups.

If your site runs on **OpenLiteSpeed or LiteSpeed**, these five bugs don't apply, though the kernel bug still does once it's published. Not sure which web server you have? Ask your host, or see our [**NGINX vs OpenLiteSpeed comparison**](/nginx-vs-openlitespeed-which-web-server-is-faster/) for how to tell them apart.

## **Stay Ahead of the Next nginx Emergency with xCloud**

NGINX2Root is the second serious web stack vulnerability in a month after PHP2Shell, and the fix for both was the same: update the server software fast and restart it properly. On your own server, that job is yours every time.

- **Security updates on a schedule.** Turn on **Managed Service Updates** and **Automatic Reboot**, and routine package and kernel security updates install on schedule. See [**how automated security updates work**](/docs/how-automated-security-updates-and-auto-reboot-work-in-xcloud/).
- **Firewall in a few clicks.** Allow only the ports and IPs you need from [**Firewall Management**](/docs/how-to-configure-firewall-management-in-xcloud/), so nobody can bypass your CDN.
- **Edge protection.** Add [**Cloudflare WAF rules**](/docs/how-to-enable-cloudflare-waf-rules-in-xcloud/) from the dashboard.
- **We're on it for xCloud servers.** Our team is checking every xCloud server that runs nginx and preparing the fixed nginx, so you don't have to patch it yourself. We'll update this post with what we've done and when.
- **A public response record.** Every vulnerability we've responded to, with dates, is on our [**zero-day security record**](/zero-day-security/). NGINX2Root will be added there too.

**Want a server where patches like this are handled for you?** [**Start free on xCloud**](https://app.xcloud.host/register) and bring your own server, or let us host it.

## **Patch nginx Today, Then Plan for the Kernel Fix**

NGINX2Root is serious because it needs no login, works on the default HTTPS setup and was demonstrated all the way to root. The good news is that the nginx fix is already out. **Update to nginx 1.31.9 or 1.30.7 today, restart it, and turn off HTTP/2 anywhere you can't update yet.**

Then put the Linux kernel update on your calendar. The researchers say it will arrive in the coming weeks, and it closes the step from the nginx worker to root.

If you have found this blog helpful, feel free to [**subscribe to our blogs**](https://xcloud.host/blog/) for valuable tutorials, guides, knowledge, and tips on web hosting and server management. You can also join our [**Facebook community**](https://www.facebook.com/groups/xcloud.community) to share insights and engage in discussions.

## **Frequently Asked Questions**

### **What is NGINX2Root?**

NGINX2Root is the name Xint, Theori's research team, gave to five nginx vulnerabilities disclosed on 18 November 2026: CVE-2026-123007, CVE-2026-123633, CVE-2026-121810, CVE-2026-123634 and CVE-2026-113425. The most severe lets an unauthenticated attacker run commands on a server through HTTP/2. Chained with a separate Linux kernel bug, the researchers reached root on the host.

### **Which nginx versions fix NGINX2Root?**

nginx 1.31.9 (mainline) and nginx 1.30.7 (stable), released on 18 November 2026. Every official release from 1.9.5 to 1.31.8 contains the HTTP/2 bug. Distribution packages can carry the fix under an older version number, so check your vendor's advisory too.

### **Is reloading nginx enough after the update?**

No. nginx -s reload only reloads the configuration and keeps the old binary running. Restart nginx, or use its binary upgrade procedure, and make sure no old worker processes are left.

### **How do I protect nginx if I can't update yet?**

Turn off HTTP/2 on every public listener: remove http2 from the listen line on nginx 1.25.0 and older, or set http2 off on 1.25.1 and newer. Then reload and confirm from outside that the server no longer offers h2. This stops the two HTTP/2 bugs, not the HTTP/3, resolver or mail proxy ones.

### **Does Cloudflare or a CDN protect my server from NGINX2Root?**

Only partly. A CDN that ends the HTTP/2 connection, talks to your server over HTTP/1.1 and blocks direct access to your server's IP blocks the HTTP/2 attack path. If attackers can reach your server directly, or the CDN talks HTTP/2 to it, you are still exposed. Patching is the real fix.

### **Is NGINX2Root being exploited?**

The researchers said on 18 November 2026 that they had no evidence of exploitation, and they have not published their own exploit. Within hours, though, third-party proof-of-concept code for the HTTP/2 bugs appeared on GitHub, so treat attacks as likely and patch now.

### **Does NGINX2Root affect WordPress sites?**

Yes, if the site is served by nginx, which many WordPress hosts and VPS setups use. Updating WordPress or a plugin does not help, because the bugs are in nginx itself. Sites on OpenLiteSpeed, LiteSpeed or Apache without nginx in front are not affected by these five bugs.

### **What is xCloud doing about NGINX2Root?**

Our team is working on it now. We are checking every xCloud server that runs nginx and preparing the fixed nginx for them, so customers are protected without having to do it themselves. We will update this post with the steps we have taken and the dates.
