nginx2root is a one-line patch — what we reproduced, and what we did not
On 2026-11-18 F5 and nginx.org disclosed ten nginx vulnerabilities, fixed in 1.30.7 (stable) and 1.31.9 (mainline). Five of them, the ones Xint reported, are what Xint calls nginx2root. The name is not decoration: Xint demonstrated command execution as the nginx worker over its public IP on AWS, GCP, Azure and bare metal, then chained a separate Linux kernel SCTP use-after-free (present since v4.15) to take root on the host — including out of a Docker container running nginx.
F5 scored all five identically: 9.2 under CVSS 4.0 and 8.1 under 3.1 — one number covering a resolver bug whose vendor range starts at 0.6.18, two HTTP/2 bugs, an HTTP/3 bug and a mail-proxy bug. nginx.org does not even agree with that: it rates CVE-2026-123007 and CVE-2026-113425 major and the other three medium. A single severity number tells you the ceiling of the set and nothing about which issue your configuration is exposed to.
| CVE | component | what has to be configured | blocked by disabling HTTP/2 |
|---|---|---|---|
| CVE-2026-123007 | HTTP/2 flow control | HTTP/2 enabled | yes |
| CVE-2026-123633 | HTTP/2 | HTTP/2 and proxying to an upstream, worker low on worker_connections |
yes |
| CVE-2026-121810 | HTTP/3 | HTTP/3/QUIC and proxying to an upstream | no |
| CVE-2026-123634 | resolver | resolver with a request-derived proxy_pass destination, plus a subrequest (SSI, mirror) resolving the same name |
no |
| CVE-2026-113425 | mail proxy | mail proxy with proxy on and auth_http |
no |
The first-affected release differs by source, and both answers are honest to different questions. The vendor ranges begin at 1.9.5 (HTTP/2 flow control), 1.19.7 (HTTP/2 use-after-free), 1.25.0 (HTTP/3), 0.6.18 (resolver) and 0.5.33 (mail proxy); Xint names 1.13.4 and 0.5.15 as the first releases carrying the resolver and mail-proxy attack paths it actually tested. When did the faulty code appear and when did the tested path exist are different questions — quote one and say which.
The other five issues fixed in the same releases are not nginx2root; the serious one there is CVE-2026-118899, an infinite loop while reading a request body over TLS 1.3 (from 1.13.0, rated major by nginx.org). Patching for nginx2root fixes it at no extra cost, and if you are only on 1.31.9 you get it, since one of the ten is fixed in 1.31.9 only.
The one-line patch
Of the five, the most impactful is CVE-2026-123007 — an overflow in HTTP/2 flow control, driven by WINDOW_UPDATE and RST_STREAM control frames that never appear in the access log as requests, and present since nginx shipped HTTP/2 in 2015. The most interesting is CVE-2026-123633, whose fix is one line in src/http/v2/ngx_http_v2.c, ngx_http_v2_create_stream():
h2c->processing++;
+ ngx_reusable_connection(c, 0);
Reading release-1.31.8 rather than the advisory text, three facts compose into the bug.
A mid-frame connection is a drain candidate. ngx_http_v2_handle_connection() registers the connection reusable and only afterwards looks at the frame parser:
if (!c->read->timer_set) {
ngx_add_timer(c->read, clcf->keepalive_timeout);
}
ngx_reusable_connection(c, 1);
if (h2c->state.incomplete) {
return;
}
A connection halfway through a frame — not idle at all — is queued as reusable.
Creating a stream did not take it back out. Pre-patch, ngx_http_v2_create_stream() set h2c->processing++ and left the registration alone, so a connection that owned a live stream stayed on the queue.
The queue gets drained by someone else's connect. When the connection free list empties, ngx_get_connection() drains reusable connections from the tail. Any connection's upstream connect — or the accept path — can drain another connection in the same worker, because processing is per-worker state. Per the commit message, once the drain recognised that the target owned streams it tried to send GOAWAY, and on send failure it closed the connection and released h2c->pool immediately, while the stack above was still inside create_stream() dereferencing h2c.
That is why this one needs HTTP/2 and a proxied upstream: it is the upstream connection that empties the free list and triggers the drain.
What we reproduced, and what we did not
We built a lab rather than repeat the advisory: Docker, nginx:1.31.8, one worker, worker_connections 64, proxy_pass to a backend that always refuses, so every proxied request has to open an upstream connection. A Python client drives the exact transition — TLS with ALPN h2, then a HEADERS frame header only, held for a second while nginx marks the connection reusable, then the payload, which creates the stream while the connection is still queued.
| mode | what the client did | what nginx did |
|---|---|---|
| baseline | curl -k --http2, free slots |
502 over http/2, upstream refused — harness sane |
| control | whole HEADERS in one write | request stalls, no reusable registration |
| exploit | frame header, 1 s hold, then payload | request stalls; error log: 64 worker_connections are not enough, reusing connections |
The preconditions reproduce and are repeatable: the partial write does put a mid-frame connection on the reusable queue, and with the free list emptied the drain path demonstrably runs — that log line is the drain path.
The worker did not crash, and the source says why. ngx_http_v2_handle_connection() opens with
if (h2c->last_out || h2c->processing) {
return;
}
so a drain that reaches a stream-owning connection through its write handler returns without touching it: processing is already non-zero. The free has to land in a narrower window — still registered reusable, but with processing dropped, which is the interval between request finalisation and ngx_http_v2_close_stream() completing (that close is posted, not synchronous) — combined with a GOAWAY write that fails.
Our harness stops at the door of that window. Xint's exploit goes through it, and its writeup states the extra conditions we did not set up: for CVE-2026-123633 and CVE-2026-121810, nginx has to be able to open a TCP connection back to the attacker, and F5 notes that code execution requires ASLR to be disabled or bypassed — which Xint achieves by leaking addresses. Two lab notes for anyone repeating this: the official images are built without --with-debug, so debug_http2 logging of the queue transitions is unavailable, and the image ships no ps, so worker liveness has to be read out of the error log.
What exposure looks like when you measure it
We measured 1,095 distinct hosts belonging to organisations in Lithuania, Sweden, Denmark, Norway and Finland — one client hello and one GET each, no scanning, redirects recorded but not followed so every verdict belongs to the host that was actually named. Where a host was measured twice, the later measurement wins.
| what the host actually did | hosts |
|---|---|
| nginx answering with HTTP/2 negotiated, build in range | 40 |
| nginx answering with HTTP/2, already at 1.30.7 or later | 4 |
| nginx answering, HTTP/2 not offered | 52 |
| a CDN or managed proxy answers (origin build unknowable from here) | 293 |
| HTTP/2 on a non-nginx edge (Caddy, ALB, Cloudflare) | 240 |
| answered with a redirect before showing any edge | 254 |
| other banner, or no TLS/HTTP answer | 212 |
Xint's headline scale — 56.7 million product:nginx hosts in Shodan, 98.9% of those with a discoverable version inside the CVE-2026-123007 range — is the right global frame. Locally, what struck us is how much of the "nginx" population is not nginx at all: 293 hosts answered as somebody else's edge, and for those the vendor's "disable HTTP/2" advice is a conversation with your CDN provider, not with your sysadmin. If your nginx is reachable only through an HTTP proxy that terminates HTTP/2 and HTTP/3 at its edge, you are covered while you patch — but not through Spectrum-style TCP passthrough or DNS-only records, and not for the mail proxy.
The banner tells you very little. Of the 40 hosts where the exposed code path is demonstrably live, 6 disclose a version; the other 34 answer nginx and nothing else. And a version string is not a patch state: distribution and appliance packages backport fixes without changing nginx -v — Xint's own example is Ubuntu 22.04 going from 1.18.0-6ubuntu14 to 1.18.0-6ubuntu14.22 while still reporting nginx/1.18.0. The banner is a reason to ask a question, not an answer.
Exposure moves within hours. Between our morning pass and an evening re-measurement of the same candidates, two hosts went from an affected build to 1.30.7 (meteo.lt, ownit.se) and four stopped offering HTTP/2 at all (mokivezi.lt, www.mokivezi.lt, svaistunas.lt, druskininkai.lt). During an active disclosure an exposure list has a shelf life measured in hours: a claim about someone else's infrastructure has to carry its measurement timestamp, and a host that already patched is not a lost opportunity but evidence the owner reads advisories.
Telling whether someone has already been in
The control frames that trigger CVE-2026-123007 are not logged as requests, so the access log is not your evidence. Xint's hunt guidance boils down to three signals, and they are worth adopting whether or not you have been hit:
- A program started by an nginx worker. The exploit calls
execve(); a normal worker has no reason to run external programs.auditctl -a always,exit -F arch=b64 -S execve,execveat -F euid=<worker uid> -k nginx_worker_exec, thenausearch -k nginx_worker_exec -ts recent -i. This is the clearest sign of a successful attack, and it only records from the moment you install the rule. - Repeated worker crashes:
grep -Ei 'worker process.*exited|signal 11|segfault' /var/log/nginx/error.log, pluscoredumpctl list nginx. Failed attempts crash workers; so do unrelated bugs. - Byte asymmetry on one long-lived connection:
ss -tinp state established '( sport = :443 )', sampled twice. A frame flood growsbytes_receivedfast whilebytes_sentstays small and the logged request lengths stay small — and the same source IP tends to open many short-lived TLS connections alongside it.
What to do
Upgrade on whichever branch you track: 1.30.7 or later on 1.30, 1.31.9 or later on mainline — and restart or do a proper binary upgrade, because nginx -s reload does not replace the running executable. If nginx comes from a distribution or an appliance, compare the full package version against the distribution advisory rather than trusting the version string. If you cannot patch yet, disable the feature each path needs: http2 off (or no http2 in listen on older versions) covers CVE-2026-123007 and CVE-2026-123633; removing QUIC/HTTP/3 listeners covers CVE-2026-121810; pointing proxy_pass at fixed upstream groups rather than request-derived variables covers the resolver path; restrict mail proxy listeners to trusted networks. Hosts that do not use SCTP can block the kernel module with sctp /bin/false in /etc/modprobe.d/, though that does not unload an already-loaded module. And note that these are protocol and memory-safety flaws: WAF rules do not reliably match them.
We have added the measured version of this question to the free website security check: it now reports whether HTTP/2 actually negotiates on your origin and whether the announced build sits inside the affected range, with the handshake output as the evidence — and it says so plainly when the banner leaves the answer open, which is most of the time.
Want this depth applied to your own systems?
Automated security testing from €100 with a fixed price agreed before testing begins, or see what your own website gives away in a single request.