# nginx2root: How the Critical nginx HTTP/2 RCE Works (CVE-2026-123007), and How I Checked It in Docker

- URL: https://www.dhruvvakharwala.dev/blogs/nginx2root-http2-rce-cve-2026-123007
- Author: Dhruv Vakharwala (https://www.dhruvvakharwala.dev/about)
- Published: November 19, 2026
- Category: Security
- Keywords: nginx2root, cve-2026-123007, cve-2026-123633, nginx http/2 rce, nginx vulnerability, nginx rce, http2 flow control, nginx 1.31.9, nginx 1.30.7, nginx patch

> nginx2root (CVE-2026-123007) is an unauthenticated HTTP/2 RCE in nginx 1.9.5-1.31.8. How the flow-control underflow works, a Docker check, and the patch.

**TL;DR:** On November 18, 2026, F5 shipped a coordinated nginx security release that fixed 10 issues at once. The headline is **CVE-2026-123007**, an unauthenticated remote code execution bug in nginx's **HTTP/2 flow control**: a connection send window is credited twice, pushed past its maximum, and then an unsigned subtraction **underflows** into a huge value that becomes a negative length in a memory copy. The security firm Xint bundled this with four other nginx use-after-frees and a Linux SCTP kernel bug into a chain they call **nginx2root**, because in their lab it went from an HTTP/2 visitor to **root on the host, escaping the Docker container** nginx ran in. Affected: nginx Open Source **1.9.5 through 1.31.8** (the RCE), fixed in **1.31.9 (mainline) and 1.30.7 (stable)**. F5 and other vendors score it CVSS 4.0 **9.2**; nginx's own advisory calls it Major. The day after the release I stood up 1.31.8 with HTTP/2 and TLS in Docker, confirmed it is in the affected range and negotiates HTTP/2, then confirmed that turning HTTP/2 off and upgrading to 1.31.9 both remove the exposure. I did **not** run the weaponized exploit, and I explain below why reproducing the actual RCE needs roughly 119 GiB of HTTP/2 traffic and a specific CPU, and why you should not run the anonymous "PoC" repos already appearing on GitHub.


![Cover card for nginx2root: CVE-2026-123007 unauthenticated HTTP/2 RCE, CVSS 4.0 9.2, affected nginx 1.9.5 to 1.31.8, fixed in 1.31.9 and 1.30.7, part of a five-CVE chain that escapes Docker to host root, verified in Docker on November 19 2026](https://www.dhruvvakharwala.dev/images/blog/nginx2root-http2-rce-cve-2026-123007/cover.png)

## What is nginx2root and why does it matter?

nginx sits in front of a very large share of the web. Wiz puts it at "more than 225 million websites." It is the default reverse proxy for most Kubernetes ingress setups, it terminates TLS for countless APIs, and it is embedded in appliances and managed platforms that most people never think of as "running nginx." So when a bug lets an unauthenticated attacker run code inside the nginx worker process, the blast radius is the internet-facing edge of a huge number of systems.

That is what landed on November 18, 2026. F5, which owns nginx, published a single coordinated release that fixed 10 separate security issues. The two that matter most both live in the HTTP/2 code:

- **CVE-2026-123007** - memory corruption in HTTP/2 flow control, leading to remote code execution. This is the one with a public proof of concept.
- **CVE-2026-123633** - a use-after-free in HTTP/2 connection handling, mainly in the reverse-proxy path.

The name **nginx2root** comes from Xint, the security research firm that reported five of the ten CVEs. Their writeup chains an nginx bug with a separate Linux kernel vulnerability to go from "I can speak HTTP/2 to your server" all the way to "I am root on the host machine, outside the container." The "2root" is literal.

This post walks the whole thing from the ground up: how HTTP/2 flow control works, exactly how the counter breaks, what the other four Xint CVEs are, how the kernel chain gets to root, what it actually takes to exploit (which is more than the headlines suggest), and the detection and patch steps. Then I show the Docker reproduction I ran to check the affected-versus-patched behavior for myself.

```mermaid
flowchart LR
    V["Unauthenticated HTTP/2 client"] --> B1["CVE-2026-123007: flow-control underflow"]
    B1 --> W["Code execution as the nginx worker"]
    W --> K["CVE in Linux SCTP: kernel use-after-free"]
    K --> R["Root on the host, outside the container"]
    style B1 fill:#7a2d2d,stroke:#d05a5a,color:#fff
    style W fill:#7a5a2d,stroke:#c2772e,color:#fff
    style K fill:#7a2d2d,stroke:#d05a5a,color:#fff
    style R fill:#5a2d7a,stroke:#a06cd5,color:#fff

```

---

## HTTP/2 flow control in one section

To see the bug you need one HTTP/2 concept: flow control.

HTTP/1.1 sends one request and one response per connection at a time. HTTP/2 multiplexes many requests, called streams, over a single TCP connection at once. If a fast server could blast data for all of them with no limit, a slow client would be overwhelmed and buffers would explode. So HTTP/2 adds a credit system, called flow control, in RFC 9113.

It works like a prepaid balance:

- Each stream and the connection as a whole has a **send window**: how many bytes of DATA the sender is still allowed to send before it must wait.
- Every time the sender sends DATA, the window goes **down** by that many bytes.
- The receiver sends a **WINDOW_UPDATE** frame to add credit back, letting the sender continue.
- A **SETTINGS** frame can change the initial window size for streams.
- The window is a signed 31-bit value. Its maximum is `2^31 - 1`, which nginx calls `NGX_HTTP_V2_MAX_WINDOW`. RFC 9113 says if a WINDOW_UPDATE would push a window above that maximum, that is a `FLOW_CONTROL_ERROR` and the connection (or stream) must be torn down.

So the window is a counter that must stay between 0 and `2^31 - 1`. Everything about CVE-2026-123007 is about getting that connection-level counter to leave those bounds without nginx noticing.

```mermaid
sequenceDiagram
    participant C as Client
    participant N as nginx (HTTP/2)
    C->>N: Request stream, server queues DATA
    N-->>C: DATA frames (send_window decreases)
    C->>N: WINDOW_UPDATE (send_window increases)
    Note over N: Rule: send_window must stay <= 2^31 - 1
    C->>N: More WINDOW_UPDATE beyond max
    Note over N: RFC 9113: this must be FLOW_CONTROL_ERROR

```

---

## How does CVE-2026-123007 actually work?

nginx tracks the connection-level credit in a single unsigned counter, `h2c->send_window`. The official advisory describes the bug as "Memory corruption in HTTP/2 flow control." Rapid7, which also found it, classifies it as **CWE-191, integer underflow**. Both are right, because the bug is a sequence: first the counter is pushed above its maximum (an overflow of the allowed range), then a later check does unsigned subtraction that wraps (the underflow). Here is the chain, using the function names from Wiz's and Rapid7's analyses.

**Step 1: credit is refunded without a bound check.** When a request finishes and its queued response data is cancelled, nginx returns the unused window credit to the connection counter. The cleanup path does, in effect:

```c
/* ngx_http_v2_filter_cleanup(): returns queued DATA credit to the connection */
h2c->send_window += window;   /* no check against NGX_HTTP_V2_MAX_WINDOW */
```

Nothing here verifies that the result stays at or below `2^31 - 1`. Rapid7 frames this as the first of three flaws: queued DATA credit is restored to the connection counter without checking the maximum, so the counter can cross `2^31 - 1`.

**Step 2: crossing the maximum does not kill the connection.** When a SETTINGS frame pushes a stream's credit above the maximum, nginx resets that one stream but keeps the connection open. RFC 9113 says this situation should be a connection-level `FLOW_CONTROL_ERROR`. Because nginx only resets the stream, the connection survives with a counter that is now in an illegal state.

**Step 3: the guard check underflows.** The next connection-level WINDOW_UPDATE is supposed to be caught by this guard:

```c
/* ngx_http_v2_state_window_update(): the bounds check */
if (window > NGX_HTTP_V2_MAX_WINDOW - h2c->send_window) {
    /* reject: would exceed the maximum */
}
```

This looks correct, but every value here is unsigned. If `h2c->send_window` is already greater than `NGX_HTTP_V2_MAX_WINDOW`, then `NGX_HTTP_V2_MAX_WINDOW - h2c->send_window` does not go negative - it **wraps around** to a gigantic positive number. The comparison then passes for almost any `window`, so nginx happily adds even more credit. Repeated, this pushes the counter past `2^63`.

**Step 4: a huge unsigned value becomes a negative length.** That poisoned counter eventually reaches the output path. In `ngx_http_v2_send_chain()` the value is converted toward a signed `off_t`, where a value above the signed maximum reads as **negative**. That negative length flows into `ngx_ssl_send_chain()`, which performs a memory copy sized by it. A copy told to move a negative-turned-huge number of bytes reads and writes far outside the intended buffer. That out-of-bounds copy on the heap is the memory corruption, and it is what a careful attacker turns into code execution.

```mermaid
flowchart TD
    A["Request closes: ngx_http_v2_filter_cleanup refunds credit"] --> B["send_window += window, no max check"]
    B --> C["SETTINGS pushes a stream above max, only the stream is reset"]
    C --> D["Connection stays open with an illegal counter"]
    D --> E["WINDOW_UPDATE guard: window > MAX - send_window"]
    E --> F["Unsigned subtraction wraps to a giant value, guard passes"]
    F --> G["send_window climbs past 2^63"]
    G --> H["ngx_http_v2_send_chain converts to off_t, value goes negative"]
    H --> I["ngx_ssl_send_chain: out-of-bounds memory copy on the heap"]
    style I fill:#7a2d2d,stroke:#d05a5a,color:#fff

```

The bug needs HTTP/2 to be enabled, and it affects nginx whether it is serving files directly or proxying. Wiz demonstrated code execution with an ASLR bypass on official nginx 1.31.7 and 1.31.8 builds that were simply serving ordinary static files over HTTPS on a 64-bit system.

---

## What about CVE-2026-123633, the HTTP/2 use-after-free?

The second HTTP/2 bug is different in flavor: a use-after-free that shows up mostly when nginx is a reverse proxy and connection slots run low. nginx's own advisory rates it Medium; F5 and several third parties score it 9.2 like the first. The mechanism, per Wiz:

- `ngx_http_v2_handle_connection()` marks an HTTP/2 connection **reusable** while it waits for the rest of a partial HEADERS frame. "Reusable" means nginx considers it safe to close if it needs the slot.
- `ngx_http_v2_create_stream()` increments `h2c->processing` (a request is now live) but does **not** remove the connection from the reusable list. So a request is running on a connection nginx still thinks is idle and disposable.
- When free connection slots run low, `ngx_drain_connections()` looks for reusable connections to close and can pick that one. If building the GOAWAY frame fails (for example, because an internal frame limit is hit), the error path frees the connection's memory while the request is still using it.

That freed-then-used memory is the classic recipe for a use-after-free that can crash the worker or, with enough control over the heap, be steered further.

```mermaid
stateDiagram-v2
    [*] --> Reusable: handle_connection marks conn reusable
    Reusable --> Live: create_stream increments processing
    Live --> StillReusable: conn NOT removed from reusable list
    StillReusable --> Drained: slots low, drain_connections picks it
    Drained --> Freed: GOAWAY build fails, error path frees conn
    Freed --> UAF: request keeps using freed memory
    UAF --> [*]

```

---

## The other three Xint CVEs, and the "2root" part

Xint's nginx2root writeup counts five nginx CVEs. Beyond the two HTTP/2 bugs, the automated scan they ran turned up three more use-after-frees in other subsystems. Official affected ranges are from nginx's advisory.

| CVE | Component | Type | nginx advisory severity | Affected (Open Source) | Disabling HTTP/2 helps? |
|---|---|---|---|---|---|
| CVE-2026-123007 | HTTP/2 flow control | Memory corruption (integer underflow) -> RCE | Major | 1.9.5 - 1.31.8 | Yes |
| CVE-2026-123633 | HTTP/2 connection handling | Use-after-free | Medium | 1.19.7 - 1.31.8 | Yes |
| CVE-2026-123634 | DNS resolver with `mirror` | Use-after-free | Medium | 0.6.18 - 1.31.8 | No |
| CVE-2026-121810 | HTTP/3 (QUIC) with upstream proxying | Use-after-free | Medium | 1.25.0 - 1.31.8 | No |
| CVE-2026-113425 | Mail proxy `auth_http` | Use-after-free | Major | 0.5.33 - 1.31.8 | No |

The full 1.31.9 and 1.30.7 release fixed 10 issues in total; the five above are the ones Xint branded as nginx2root, and the two HTTP/2 bugs are the headline because one of them is an RCE with a working proof of concept.

Now the scary part. Xint did not stop at the nginx worker. They also found a separate vulnerability in the Linux kernel's **SCTP** subsystem - a use-after-free or double free in the SCTP send path that they say has been present since Linux v4.15 in 2018. In their words, it "can be chained with any of the nginx vulnerabilities to gain root privileges on the host." In their tests it gave a KASLR bypass and an arbitrary kernel function call, and the full chain "escaped a Docker container running nginx and obtained root on the underlying host." That is the path the name describes: HTTP/2 request, then nginx worker, then kernel, then host root, straight through the container boundary.

This is also exactly why I would not naively run an unknown exploit for this bug inside a container and assume the container protects me. More on that below.

---

## Who found it, and the disclosure timeline

Two independent parties reported the HTTP/2 flow-control bug, which is unusual and tells you it was findable.

- **Xint** (researchers credited as @imssm99, @cdor1, @tjbecker and @yves) found CVE-2026-123007 while preparing for ZeroDay Cloud 2026, and then an automated Xint scan found the other four nginx bugs. They reported through HackerOne in October.
- **Rapid7's Stephen Fewer**, a Senior Principal Security Researcher, independently discovered and reported CVE-2026-123007 in November and wrote the public proof of concept.

F5 coordinated both into the single November 18 release.

```mermaid
timeline
    title nginx2root disclosure (UTC)
    Oct 11 2026 : Xint discovers the bugs
    Oct 16 2026 : Xint reports to F5 via HackerOne
    Oct 20 2026 : HackerOne validation complete
    Oct 27 2026 : Reports delivered to the nginx dev team
    Nov 10 2026 : Xint completes patch validation
    Nov 11 2026 : Rapid7 (Stephen Fewer) contacts F5
    Nov 16 2026 : F5 confirms CVE assignment and sets the date
    Nov 18 2026 : Coordinated release, 1.31.9 and 1.30.7

```

---

## How bad is it really? Severity and the exploitation reality

The scores disagree, so it is worth being precise:

- **F5 and several vendors** (Wiz, Safe Security, Security Boulevard) put CVE-2026-123007 at **CVSS 4.0 9.2, Critical**. Rapid7 gives the vector `AV:N/AC:H/AT:P/PR:N/UI:N/VC:H/VI:H/VA:H`, which reads as network-reachable, no privileges, no user interaction (so unauthenticated), high confidentiality, integrity and availability impact, but **high attack complexity** and a **present attack requirement**.
- **nginx's own advisory** labels CVE-2026-123007 "Major" and CVE-2026-123633 only "Medium."
- **Downstream trackers list different numbers:** Cyber Kendra reports Red Hat at **8.1** (on the older CVSS 3.1 scale, so not directly comparable to F5's 9.2 under CVSS 4.0) and Ubuntu rating it **High**.

The reason for the "high complexity" is important, and it is the honest counterweight to the panic. Rapid7's proof of concept is a real, unauthenticated RCE: it recovers addresses, forges nginx objects in memory, and redirects a request-pool cleanup callback to run an attacker-chosen command. But it runs with the **nginx worker's** permissions, not root (execution as the master process or root "has not been established" without the kernel chain), and it has real preconditions:

- It needs a **large volume of HTTP/2 data** to drive the counter: Rapid7 estimates around 128 GB, and used about **119.02 GiB** of plaintext in their reproduction. At 10 Gbit/s that is roughly two minutes; at 1 Gbit/s about seventeen. nginx's default one-hour connection lifetime means a link slower than roughly **300 Mbit/s cannot finish in time**, and proxied connections are unlikely to work.
- The RCE strategy depends on a **specific x86-64 glibc memcpy routine**, selected by the CPU's `avx512f` and `avx512vl` features. Rapid7 notes other strategies "may be viable, but none are currently known."

Wiz, which built its own exploit, said it will not release it "at this time." So the headline is accurate - unauthenticated RCE, no login required - but a smash-and-grab against every nginx box on the internet this is not. It is a targeted attack that needs bandwidth, time and the right target CPU. That gap between "critical score" and "operational difficulty" is exactly the window you want to use to patch.

```mermaid
xychart-beta
    title "Time to push ~119 GiB of HTTP/2 data (Rapid7 estimates)"
    x-axis ["10 Gbit/s", "1 Gbit/s", "300 Mbit/s floor"]
    y-axis "minutes" 0 --> 60
    bar [2, 17, 60]

```

The 300 Mbit/s bar is the floor: below it the connection times out at one hour before the attack completes.

---

## How I checked it in Docker

I wanted to confirm the affected-versus-patched behavior myself rather than take the version table on faith. On November 19, the day after the release, I ran a small reproduction in Docker (OrbStack's engine). The goal was defensive: prove which version is affected, prove the attack surface is present, and prove that the two remediations actually remove it. I did **not** run any memory-corruption exploit, for reasons in the next section.

The setup is a self-signed cert and a minimal server block with HTTP/2 and TLS turned on - the configuration that exposes CVE-2026-123007 and CVE-2026-123633:

```nginx
server {
    listen 443 ssl;
    http2 on;
    server_name localhost;
    ssl_certificate     /etc/nginx/certs/cert.pem;
    ssl_certificate_key /etc/nginx/certs/key.pem;
    location / { return 200 "ok\n"; }
}
```

**Affected.** Run that on the last vulnerable mainline release, 1.31.8, and confirm both that the version is in range and that HTTP/2 genuinely negotiates:

```bash
docker run -d --name nginx-vuln \
  -v "$PWD/vuln.conf:/etc/nginx/conf.d/default.conf:ro" \
  -v "$PWD/certs:/etc/nginx/certs:ro" \
  -p 8443:443 nginx:1.31.8

docker exec nginx-vuln nginx -v
# nginx version: nginx/1.31.8   -> in the affected range 1.9.5 - 1.31.8

curl -sk --http2 -o /dev/null -w "protocol: %{http_version}  status: %{http_code}\n" https://localhost:8443/
# protocol: 2  status: 200

echo | openssl s_client -connect localhost:8443 -alpn h2 2>/dev/null | grep -i "ALPN protocol"
# ALPN protocol: h2
```

The server is a vulnerable version and it speaks HTTP/2. That is the "you are affected" state.

**Mitigated.** Same 1.31.8 image, the only change is `http2 off;`. The client still asks for HTTP/2, but the server must refuse and fall back:

```bash
curl -sk --http2 -o /dev/null -w "protocol: %{http_version}  status: %{http_code}\n" https://localhost:8444/
# protocol: 1.1  status: 200
# ALPN: no h2 offered  -> CVE-2026-123007 / 123633 attack surface removed
```

**Patched.** The fixed mainline release 1.31.9, with HTTP/2 left on, so you keep the feature and lose the bug:

```bash
docker exec nginx-fixed nginx -v
# nginx version: nginx/1.31.9   -> NOT in the affected range (this is a fixed build)

curl -sk --http2 -o /dev/null -w "protocol: %{http_version}  status: %{http_code}\n" https://localhost:8445/
# protocol: 2  status: 200   -> HTTP/2 still works, on a patched server
```

Both fixed images, `nginx:1.31.9` (mainline) and `nginx:1.30.7` (stable), were already on Docker Hub the day after release, which is faster than these images sometimes land. Here is the whole check in one view:

![Terminal reproduction on November 19 2026: nginx 1.31.8 with HTTP/2 on negotiates h2 and returns 200 and is marked affected; nginx 1.31.8 with http2 off falls back to HTTP/1.1 with no h2 and is marked mitigated; nginx 1.31.9 with HTTP/2 on negotiates h2 and returns 200 and is marked patched](https://www.dhruvvakharwala.dev/images/blog/nginx2root-http2-rce-cve-2026-123007/repro.png)

What this proves, and what it does not: it proves the version boundary and that both remediations work, so you can trust the "upgrade or disable HTTP/2" advice end to end. It does **not** reproduce code execution. That is deliberate.

---

## Why I did not run the public "exploit" repos

Within a day of disclosure, GitHub had proof-of-concept and "exploit" repositories for these CVEs. Rapid7's own PoC is real and was tested against a linux/amd64 Docker image of nginx 1.31.8. But a reader pointed me at an anonymous third-party repo, created on the disclosure date, with a single star and a two-line description naming the two CVEs. I did not run it, and you should not either. Three reasons:

1. **Provenance.** A brand-new, unreviewed repo from an anonymous account, posted the day a popular CVE drops, is one of the most reliable malware-delivery patterns there is. The thing that calls itself an nginx exploit is frequently a credential stealer or a miner. I wrote about one version of that pattern in the [LiteLLM 1.107.0 supply chain attack](https://www.dhruvvakharwala.dev/blogs/litellm-1-107-0-supply-chain-attack-2026).
2. **A container is not a safe blast radius here.** The whole point of nginx2root is that the chain **escapes Docker to host root** through a kernel bug that has existed since 2018. Running unknown "exploit" code for this specific family inside a container and trusting the container to hold is precisely the assumption the attack breaks.
3. **Reproducing the real RCE is impractical anyway.** As above, it needs about 119 GiB of HTTP/2 traffic, a one-hour window, and a target with specific AVX-512 glibc behavior. A one-file repo that promises instant root is not doing that.

The defensive reproduction above - version detection plus confirming the mitigations - gives you everything you need to act, with none of the risk of executing attacker-controlled code.

---

## Am I affected, and how do I fix it?

### Step 1: find out if you are affected

You are exposed to the two HTTP/2 RCE-class bugs if you run nginx in the affected range **and** have HTTP/2 enabled.

```bash
# Version (watch for distro backports, see the warning below)
nginx -v

# Is HTTP/2 configured anywhere?
grep -RnE 'http2|listen .*http2' /etc/nginx/ 2>/dev/null

# From a client, does a site negotiate HTTP/2?
curl -skI --http2 https://YOUR_HOST/ -o /dev/null -w '%{http_version}\n'
# "2" means HTTP/2 is on
```

For containers and Kubernetes ingress, check the actual image tag or digest you are running, not a floating `latest`. nginx ingress controllers bundle nginx and need a fix from their own vendor.

```mermaid
flowchart TD
    A["nginx version in 1.9.5 - 1.31.8 ?"] -->|No| S["Not affected by the HTTP/2 RCE; still patch the others"]
    A -->|Yes| B["HTTP/2 enabled ?"]
    B -->|No| C["Lower risk for 123007 and 123633; still patch for the resolver, HTTP/3 and mail CVEs"]
    B -->|Yes| D["Exposed: patch now, or disable HTTP/2 as a stopgap"]
    D --> E["Upgrade to 1.31.9 or 1.30.7"]
    D --> F["Or set http2 off; and reload"]
    style D fill:#7a2d2d,stroke:#d05a5a,color:#fff
    style E fill:#2d5a3d,stroke:#3f9c74,color:#fff

```

### Step 2: patch (the real fix)

Upgrade nginx Open Source to **1.31.9** (mainline) or **1.30.7** (stable). NGINX Plus has its own fixed builds (37.3.0.1 and 37.0.8.1). Two warnings that bite people:

- **A reload is not enough.** A configuration reload does not replace the running executable. After upgrading the package you must **restart nginx** or do a live binary upgrade, and then confirm the old worker processes have actually exited.
- **The version string can lie.** Distributions backport security fixes without bumping the upstream version number, so `nginx -v` alone may not tell you whether you are patched. Compare the full **package** version against your distribution's advisory.

### Step 3: if you cannot patch immediately, mitigate

- **HTTP/2 bugs (CVE-2026-123007, CVE-2026-123633):** disable HTTP/2. On nginx 1.25.1 or later set `http2 off;` in the affected server blocks, or remove the `http2` parameter from `listen` directives. Reload, confirm old workers exited, and re-enable after upgrading. This does **not** cover the other three CVEs. (My Docker check above confirms the server then refuses HTTP/2 and falls back to HTTP/1.1.)
- **Resolver UAF (CVE-2026-123634):** use fixed upstreams or remove request-time DNS resolution. Note that `mirror_request_body on` does **not** fix the resolver bug.
- **HTTP/3 UAF (CVE-2026-121810):** remove QUIC listeners.
- **Mail proxy UAF (CVE-2026-113425):** bind mail listeners to loopback or otherwise restrict access.
- **The SCTP kernel bug (the "2root" escalation):** until a kernel fix lands, on hosts that do not need SCTP you can blacklist the module, for example `install sctp /bin/false` in a file under `/etc/modprobe.d/`. This does not unload an already-loaded module or disable SCTP compiled into the kernel.

### Step 4: hunt for exploitation

Wiz calls these "general warning signs, not confirmed indicators," which is the right caveat - treat them as leads, not proof:

- Unexpected **nginx worker crashes**, or commands launched by nginx that you did not configure.
- **Long-lived HTTP/2 connections that transfer very large amounts of data** and send a large number of WINDOW_UPDATE frames. Given the ~119 GiB, roughly-hour-long profile of the known RCE path, that traffic shape is a reasonable thing to alert on.
- CDNs and WAFs that terminate HTTP/2 themselves may absorb parts of the attack, depending on implementation - but do not rely on that as your fix.

---

## FAQ

### What is CVE-2026-123007?

It is an unauthenticated remote code execution vulnerability in nginx's HTTP/2 flow control, fixed on November 18, 2026. A connection send window is credited twice and pushed past its maximum, then an unsigned bounds check underflows, letting the counter grow into a value that becomes a negative length in a memory copy and corrupts the heap. It affects nginx Open Source 1.9.5 through 1.31.8 when HTTP/2 is enabled.

### What is nginx2root?

nginx2root is the name Xint gave to a chain of five nginx CVEs plus a separate Linux SCTP kernel vulnerability. The nginx HTTP/2 bug gives code execution as the nginx worker, and the kernel bug escalates that to root on the host, escaping the Docker container nginx runs in. Hence "nginx to root."

### Which nginx versions are affected and which are fixed?

The HTTP/2 RCE (CVE-2026-123007) affects nginx Open Source 1.9.5 through 1.31.8. The fixes are 1.31.9 on the mainline branch and 1.30.7 on the stable branch; NGINX Plus has 37.3.0.1 and 37.0.8.1. The other four nginx2root CVEs have slightly different lower bounds but are all fixed in the same release.

### How do I protect nginx right now?

Upgrade to 1.31.9 or 1.30.7 and restart nginx (a config reload does not replace the running binary). If you cannot upgrade immediately, set `http2 off;` to remove the two HTTP/2 bugs' attack surface, and apply the per-component mitigations for the resolver, HTTP/3 and mail proxy issues. Verify by checking the package version against your distribution's advisory, not just `nginx -v`.

### Is there a public exploit, and should I run it?

Rapid7 published a working proof of concept, and anonymous "exploit" repos appeared within a day. Do not run unvetted ones: a brand-new anonymous repo posted on disclosure day is a classic malware vector, and this chain is specifically designed to escape containers to host root, so a container will not protect you. Reproducing the real RCE also needs about 119 GiB of HTTP/2 traffic and a specific CPU, so a one-file "instant root" tool is not doing what it claims.

---

**Takeaway:** If you run nginx with HTTP/2, treat this as patch-now: upgrade to **1.31.9** or **1.30.7** and **restart** the service, because a reload does not replace the running binary and a backported fix may not change the version string. Cannot patch this minute? Set `http2 off;` to close the two HTTP/2 RCE bugs, and apply the separate mitigations for the resolver, HTTP/3 and mail CVEs. The CVSS 9.2 is real but the known RCE needs roughly 119 GiB of HTTP/2 traffic and a specific CPU, so you have a real window - use it. And do not run anonymous "exploit" repos to test yourself: version detection plus confirming HTTP/2 is off, which you can do safely in Docker, tells you everything you need.


---

## References

- [nginx security advisories](https://nginx.org/en/security_advisories.html) - the official affected and fixed version ranges and severities
- [F5 advisory K000163926](https://my.f5.com/manage/s/article/K000163926) - the vendor advisory for the release
- [CVE-2026-123007: Critical NGINX HTTP/2 Integer Underflow Leads to RCE - Rapid7](https://www.rapid7.com/blog/post/ve-cve-2026-123007-critical-nginx-http-2-integer-underflow-leads-to-rce-fixed/) - root cause, CVSS vector, PoC details and the exploitation cost figures
- [Unauthenticated Remote Code Execution in NGINX: CVE-2026-123633 and CVE-2026-123007 - Wiz](https://www.wiz.io/blog/nginx-http2-rce-vulnerabilities) - function-level analysis of both HTTP/2 bugs and detection guidance
- [nginx2root: Remote Code Execution - Xint](https://xint.io/blog/nginx2root-remote-code-execution) - the five-CVE set, the SCTP kernel chain, and the disclosure timeline
- [CVE-2026-123007 and CVE-2026-123633: NGINX HTTP/2 RCE - Safe Security](https://safe.security/resources/blog/cve-2026-123007-cve-2026-123633-nginx-http-2-rce-two-critical-flaws-turn-protocol-handling-into-remote-code-execution/)
- [nginx2root: NGINX HTTP/2 RCE (CVE-2026-123007) Patched - Cyber Kendra](https://www.cyberkendra.com/2026/11/nginx2root-nginx-http2-rce-cve-2026-123007.html) - the Red Hat 8.1 and Ubuntu severity divergence
- [RFC 9113: HTTP/2](https://www.rfc-editor.org/rfc/rfc9113.html) - the flow-control and FLOW_CONTROL_ERROR rules
- Related: [LiteLLM 1.107.0 supply chain attack](https://www.dhruvvakharwala.dev/blogs/litellm-1-107-0-supply-chain-attack-2026) and the [eMudhra CA key compromise](https://www.dhruvvakharwala.dev/blogs/emudhra-ca-key-compromise-2026)