critical

CVE

CVE-2026-123007, CVE-2026-123633, CVE-2026-123634, CVE-2026-121810, CVE-2026-113425

CWE

CWE-191, CWE-787, CWE-416

Affected Surface

  • nginx open source 1.9.5 through 1.31.8 with HTTP/2 enabled (CVE-2026-123007); fixed in 1.30.7 (stable) and 1.31.9 (mainline)
  • nginx 1.19.7 through 1.31.8 proxying HTTP/2 requests upstream (CVE-2026-123633) and 1.25.0 through 1.31.8 proxying HTTP/3 requests (CVE-2026-121810)
  • nginx 0.6.18 through 1.31.8 using `resolver` with a variable `proxy_pass` and subrequests such as `mirror` or SSI (CVE-2026-123634), and 0.5.33 through 1.31.8 running the mail proxy with `auth_http` (CVE-2026-113425)
  • NGINX Plus R33 and 37.x before 37.0.8.1 and 37.3.0.1; R34 to R36 have no fix and need an upgrade to 37.x
  • Distribution packages until patched: Debian bookworm (1.22.1), trixie (1.26.3) and sid (1.30.6) were all listed as vulnerable on 18 November; Ubuntu 22.04 and 24.04 ship 1.18.0 and 1.24.0
  • Kubernetes ingress-nginx (all versions; project retired in March 2026, no fix coming), plus OpenResty, gateways, appliances and container images that bundle their own nginx

TL;DR

On 18 November 2026 F5 released nginx 1.31.9 (mainline) and 1.30.7 (stable). Five of the fixes are what Xint named nginx2root: memory-safety bugs that each give an unauthenticated attacker code execution as the nginx worker, under different configurations.

The one that matters to almost everyone is CVE-2026-123007. It is a flow-control accounting error in the HTTP/2 module, present since HTTP/2 support landed in nginx 1.9.5 in 2015. You only need HTTP/2 enabled on a reachable listener. Xint, Wiz and Rapid7 each built a working exploit with an ASLR bypass, and Wiz showed it against nginx serving plain static files with no backend. Rapid7 published its exploit on GitHub on the day of disclosure.

The other four are use-after-frees:

  • CVE-2026-123633: HTTP/2 connections that proxy to an upstream (1.19.7 onward).
  • CVE-2026-121810: the same pattern over HTTP/3 (QUIC) (1.25.0 onward).
  • CVE-2026-123634: the DNS resolver, when proxy_pass uses a variable and a subrequest such as mirror resolves the same name (0.6.18 onward).
  • CVE-2026-113425: the mail proxy’s auth_http login path (0.5.33 onward).

Xint also found an unpatched Linux kernel SCTP use-after-free and chained it with the nginx bugs to get root on the host, including from inside a Docker container. That kernel bug has no CVE or fix yet.

There are no reports of exploitation in the wild, none of the CVEs is in CISA KEV, and EPSS had no scores for them on 18 November. A public exploit for an internet-scale web server changes that math quickly, though.

What to do now:

  1. Upgrade to nginx 1.31.9 or 1.30.7, or to a distribution package that carries the fixes, then restart nginx. A reload keeps the old binary running.
  2. Until then, turn HTTP/2 off (http2 off; on 1.25.1+, or drop http2 from listen). That blocks CVE-2026-123007 and CVE-2026-123633 only.
  3. Check the other three paths separately: QUIC listeners, proxy_pass http://$var with resolver, and any public mail block using auth_http.
  4. If you still run Kubernetes ingress-nginx, disable HTTP/2 on it now and plan the migration. The project was retired in March 2026 and will not ship a fix.
  5. On hosts that don’t use SCTP, add install sctp /bin/false to a file under /etc/modprobe.d/ to close off the root escalation Xint demonstrated.

Affected packages and projects

Version ranges below are from nginx.org’s advisory page. Xint’s write-up gives earlier first-affected versions for two of the bugs (1.13.4 for CVE-2026-123634 and 0.5.15 for CVE-2026-113425) based on its own code-path analysis. Either way, every supported release before the fix is affected.

EcosystemPackageAffected versionsFixed or safe version
nginx OSSnginx: CVE-2026-123007 (HTTP/2 flow control, nginx.org severity major)1.9.5 to 1.31.81.31.9, 1.30.7
nginx OSSnginx: CVE-2026-123633 (HTTP/2 use-after-free)1.19.7 to 1.31.81.31.9, 1.30.7
nginx OSSnginx: CVE-2026-121810 (HTTP/3 use-after-free)1.25.0 to 1.31.81.31.9, 1.30.7
nginx OSSnginx: CVE-2026-123634 (resolver use-after-free)0.6.18 to 1.31.81.31.9, 1.30.7
nginx OSSnginx: CVE-2026-113425 (mail proxy use-after-free, severity major)0.5.33 to 1.31.81.31.9, 1.30.7
F5NGINX Plus (CVE-2026-123007)R33, 37.0.0 and later before the fix37.0.8.1, 37.3.0.1
F5NGINX Plus (CVE-2026-123633)R33, 37.0.0 and later before the fix37.0.7.1, 37.2.0.1
F5NGINX Plus R34 to R36affectedno fix, upgrade to 37.x
Docker Hubnginx official imagetags built before 18 November1.31.9, 1.30.7, mainline, stable and their variants, rebuilt 18 November 17:18 to 17:21 UTC
Debiannginxbookworm 1.22.1-9+deb12u10, trixie 1.26.3-3+deb13u10, sid 1.30.6-3unfixed in all suites on 18 November
Kuberneteskubernetes/ingress-nginxall versionsnone. Repository archived March 2026

F5 scores all five at CVSS 4.0 9.2 and CVSS 3.1 8.1, with CWE-191 and CWE-787 for CVE-2026-123007 and CWE-416 for the rest.

The same releases fix several smaller bugs: an endless loop reading request bodies over TLS 1.3 (CVE-2026-118899, severity major), a try_files plus alias buffer overflow (CVE-2026-125283), a stream-module SNI client-certificate bypass (CVE-2026-120967), a ssl_preread parsing differential (CVE-2026-123640) and a PROXY protocol v2 crash in 1.31.4 to 1.31.8 (CVE-2026-120993). Upgrading to 1.31.9 or 1.30.7 handles all of them.

Distribution packages often backport fixes without changing what nginx -v prints. Xint points out that Ubuntu 22.04 still reports 1.18.0 at package revision 1.18.0-6ubuntu14.22. Compare the full package version against your distribution’s advisory, not the upstream version string.

Technical analysis

All five fixes were committed to nginx/nginx on 11 November 2026 and tagged into the 1.31.9 and 1.30.7 releases on 18 November.

CVE-2026-123007: refunded send window pushes the counter past the HTTP/2 maximum

HTTP/2 flow control limits how much response data the server may send before the client grants more. nginx tracks the connection-level allowance in h2c->send_window, a size_t. When it queues a DATA frame it subtracts the frame size up front. If the stream is cancelled before the frame goes out, ngx_http_v2_filter_cleanup() gives that allowance back.

The bug is in how those two paths interact with the client’s WINDOW_UPDATE check. The fix (e27f5fa, backported to 1.30.7 as b89c410) adds a counter for bytes that are queued but not sent:

--- a/src/http/v2/ngx_http_v2.c
+++ b/src/http/v2/ngx_http_v2.c
@@ -2561,13 +2561,13 @@ ngx_http_v2_state_window_update(ngx_http_v2_connection_t *h2c, u_char *pos,
-    if (window > NGX_HTTP_V2_MAX_WINDOW - h2c->send_window) {
+    if (window > NGX_HTTP_V2_MAX_WINDOW - h2c->send_window - h2c->send_queued) {
         ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0,
                       "client violated connection flow control: "
 ...
--- a/src/http/v2/ngx_http_v2_filter_module.c
+++ b/src/http/v2/ngx_http_v2_filter_module.c
@@ -1242,6 +1242,7 @@ ngx_http_v2_send_chain(ngx_connection_t *fc, ngx_chain_t *in, off_t limit)
             h2c->send_window -= frame_size;
+            h2c->send_queued += frame_size;
@@ -1634,6 +1635,7 @@ ngx_http_v2_data_frame_handler(ngx_http_v2_connection_t *h2c,
     h2c->payload_bytes += frame->length;
+    h2c->send_queued -= frame->length;
@@ -1770,6 +1772,7 @@ ngx_http_v2_filter_cleanup(void *data)
     h2c->send_window += window;
+    h2c->send_queued -= window;

Here is how the old code fails, following the commit message and the Wiz and Rapid7 write-ups:

  1. A response is queued. send_window drops by the frame size.
  2. The client sends a connection WINDOW_UPDATE that raises send_window back up to the maximum, 2^31-1 (NGX_HTTP_V2_MAX_WINDOW). The check passes because, at that moment, the counter looks low.
  3. The client cancels the stream. ngx_http_v2_filter_cleanup() runs h2c->send_window += window with no bound, so the counter now sits above the maximum.
  4. On the next WINDOW_UPDATE, NGX_HTTP_V2_MAX_WINDOW - h2c->send_window is computed on unsigned values. It underflows to a huge number, so the “would this exceed the limit?” check always passes. Repeated updates drive the counter into the upper half of the 64-bit range.
  5. In ngx_http_v2_send_chain() that value is converted to the signed off_t and becomes negative. It ends up as a buffer length with its end pointer before its start pointer, and the TLS send path in ngx_ssl_send_chain() turns it into an out-of-bounds copy on the heap.

The fix treats queued-but-unsent bytes as still belonging to the client’s window, which is how the client sees them. The refund in step 3 can no longer push the effective window past the limit, because the check in step 4 subtracts send_queued too.

Rapid7 found a second way to reach the over-credit state. When a SETTINGS frame raises SETTINGS_INITIAL_WINDOW_SIZE enough to push an active stream past the maximum, RFC 9113 says to kill the whole connection with FLOW_CONTROL_ERROR. nginx instead resets only the affected stream and keeps the connection open, which triggers the same cleanup refund.

The out-of-bounds copy gives both a read and a write. Xint and Rapid7 both describe the copy sending heap bytes that sit before the response body back to the client over TLS, which leaks heap, nginx and glibc addresses and defeats ASLR. Rapid7’s chain then forges request and buffer objects to read glibc’s ELF metadata, resolves system() and points a request-pool cleanup callback at it. Xint’s overwrites a cleanup function pointer in the same way but leaves out the final steps.

The practical constraint is traffic volume. Each WINDOW_UPDATE is 13 bytes, and the counter has to climb roughly 2^33 increments. Rapid7’s exploit sends about 128 GB of HTTP/2 data. That takes around 2 minutes at 10 Gbit/s and 17 minutes at 1 Gbit/s. Below about 300 Mbit/s it runs into nginx’s default one-hour connection lifetime. Rapid7’s chain also depends on the AVX-512 memcpy variant glibc picks on CPUs with avx512f and avx512vl. Xint says its own exploit worked under concurrent normal traffic and over public IPs on AWS, GCP and Azure, so neither of those limits should be read as a mitigation.

CVE-2026-123633: an HTTP/2 connection with live streams stays on the reusable list

When worker connections run low, nginx closes “reusable” idle connections to make room. An HTTP/2 connection with no streams and a partially read frame is marked reusable, a change originally made to resist slow-read DoS (commit 76672e650). If the client sends one byte of a HEADERS frame and then the rest, a stream gets created but the connection stays on the reusable list.

When that request then opens an upstream connection, ngx_get_connection() drains reusable connections and can pick the request’s own HTTP/2 connection. It tries to send GOAWAY. If that fails, for example because the per-connection frame limit is exhausted, the error path frees the connection pool while the upstream code up the stack is still using it.

The fix (2df48a5) is one line, in ngx_http_v2_create_stream():

     h2c->processing++;
 
+    ngx_reusable_connection(h2c->connection, 0);
+
     if (h2c->connection->read->timer_set) {

nginx’s changelog credits this one to Albert of Vexera AI. Wiz, Ikotas Labs, Metnir, Rapid7 and Xint each reported one or both HTTP/2 bugs independently, and F5 told Wiz on 21 October that someone had already reported it. It needs nginx to proxy upstream and to be short on worker_connections, which an attacker can push it toward by opening connections.

CVE-2026-121810: the same pattern on QUIC streams

ngx_quic_create_stream() cleared the parent QUIC connection’s reusable flag, then called ngx_get_connection() before inserting the new stream into the stream tree. If that call drained an idle stream on the same QUIC connection, the close path found no remaining streams and marked the parent reusable again. A later upstream connect could then free it mid-request. The fix (b5252da) inserts the stream into the tree first:

+    ngx_rbtree_insert(&qc->streams.tree, &qs->node);
+
     reusable = c->reusable;
     ngx_reusable_connection(c, 0);
 
     sc = ngx_get_connection(c->fd, log);
     if (sc == NULL) {
         ngx_destroy_pool(pool);
+        ngx_rbtree_delete(&qc->streams.tree, &qs->node);

CVE-2026-123634: resolver frees a context it is still iterating

When several lookups wait on the same name, the resolver walks the waiting list and calls each handler. If one handler terminates its request and calls ngx_resolve_name_done() on a different context for the same name, one the loop hasn’t reached yet, that context was freed while still queued. Xint triggered this with proxy_pass http://$host;, a resolver, and a mirror subrequest with mirror_request_body off, so the main request and its mirror wait for the same DNS answer. Sophos and Xint note SSI subrequests may reach it too.

The fix (e39708e) stops freeing a context that is still pending and installs a finalizer instead:

-            ngx_log_error(NGX_LOG_ALERT, r->log, 0,
-                          "could not cancel %V resolving", &ctx->name);
+            ngx_log_debug1(NGX_LOG_DEBUG_CORE, r->log, 0,
+                           "could not cancel %V resolving", &ctx->name);
         }
+
+        ctx->handler = ngx_resolver_free_handler;
     }
 ...
-    ngx_resolver_free_locked(r, ctx);
+    if (ctx->handler != ngx_resolver_free_handler) {
+        ngx_resolver_free_locked(r, ctx);
+    }

One side effect for defenders: before the fix, some of these races logged could not cancel ... resolving at alert level. Those lines in old error logs are worth a look if you run that configuration.

Xint’s exploit uses the bug for its own address leak. Freed DNS record memory gets treated as a resolver context, and a forged handler pointing at the fixed vsyscall page leaks glibc and heap pointers in a DNS query sent to an attacker-controlled server.

CVE-2026-113425: mail proxy session freed during auth_http

With proxy on and auth_http, nginx asks an HTTP service whether a login is valid. The POP3, IMAP and SMTP handlers left a default reply sitting in s->out. If the client sent a login command and a TCP reset in the same event-loop pass, the write handler tried to send that stale reply, failed and destroyed the session while the auth_http connection still pointed at it. No valid credentials are needed. The fix (754fe68) discards the queued reply when the auth request starts:

     ctx->peer.connection->data = s;
     ctx->peer.connection->pool = s->connection->pool;
 
+    s->out.len = 0;
+
     s->connection->read->handler = ngx_mail_auth_http_block_read;

Three companion commits block client writes while the mail proxy waits on auth_http, the upstream connect and SMTP client resolution.

The kernel half: SCTP use-after-free to host root

Code execution as an nginx worker is not root. Xint got the rest of the way with a separate Linux kernel bug in the SCTP send path, introduced in 4.15 (2018). While a send waits, its association can be moved to another socket, and the waiting send then frees it, which gives a use-after-free or double free. Many distributions auto-load the sctp module the first time a process opens an SCTP socket, so an unprivileged worker can reach it. Xint demonstrated a KASLR bypass and a container-to-host escape, and is withholding details until a kernel patch exists. CIRCL and Equixly both confirm no CVE had been assigned on 18 November.

This is not CVE-2026-64564 (“SCTPhantom”), a different SCTP ASCONF bug fixed in August.

Exploitation status

  • Public exploit: Rapid7’s Stephen Fewer published sfewer-r7/CVE-2026-123007 (repository created 18 November 11:16 UTC) with a minimal trigger script and a full RCE exploit against a fresh linux/amd64 Docker container running 1.31.8. The README says it will likely fail against busy servers, messy heaps, slow links or proxies that re-frame HTTP/2. Several copycat and checker repositories followed the same afternoon. We did not run any of them.
  • Withheld exploits: Xint and Wiz both hold back their full chains. Wiz confirmed RCE on official 1.31.7 and 1.31.8 builds.
  • In the wild: none reported by Xint, Wiz, Rapid7, Sophos or CIRCL as of 18 November. Not in CISA KEV.

IOCs

These are vulnerabilities, not a malware campaign, so there are no domains, IPs or hashes. The signs Xint and CIRCL suggest correlating:

  • A long-lived HTTP/2 connection on 443 where bytes_received climbs fast (tens of GB) while bytes_sent stays small, often alongside many short TLS connections from the same source. WINDOW_UPDATE and RST_STREAM frames don’t show up as access-log requests.
  • nginx workers spawning /bin/sh, /bin/bash or any other program.
  • Worker crashes: worker process ... exited on signal 11 in error.log, or nginx core dumps.
  • For CVE-2026-123634 configurations, could not cancel ... resolving alerts in older error logs.

Detection and remediation

# 1. Version and HTTP/2 module
nginx -v 2>&1                     # 1.31.9+ or 1.30.7+ is fixed upstream
nginx -V 2>&1 | grep -o -- '--with-http_v2_module\|--with-http_v3_module\|--with-mail'

# 2. Which nginx2root paths does your config expose?
sudo nginx -T 2>/dev/null | sed 's/#.*//' | grep -nE \
  'listen[[:space:]].*(http2|quic)|^[[:space:]]*(http2|http3)[[:space:]]+on|^[[:space:]]*(resolver|mirror|ssi|auth_http)[[:space:]]|proxy_pass[[:space:]]+[a-z]+://[^;]*\$'

# 3. Is HTTP/2 actually negotiated? Run from outside, and against the origin if a CDN sits in front
openssl s_client -connect example.com:443 -servername example.com -alpn h2 </dev/null 2>&1 \
  | grep -E 'ALPN protocol|No ALPN'

# 4. Distribution packages (compare against your distro's advisory, not the upstream number)
dpkg-query -W -f='${Package} ${Version}\n' 'nginx*' 2>/dev/null
rpm -q nginx 2>/dev/null
apk info -v nginx 2>/dev/null

# 5. Container images and Dockerfiles
grep -rnE '^FROM[[:space:]]+(docker\.io/)?(library/)?nginx(:|@|$)' --include='Dockerfile*' .
docker run --rm --entrypoint nginx <image> -v

# 6. Retired ingress-nginx still running in Kubernetes?
kubectl get pods -A -o jsonpath='{range .items[*]}{.metadata.namespace}{"\t"}{.spec.containers[*].image}{"\n"}{end}' \
  | grep -i 'ingress-nginx/controller'

# 7. Worker crashes and spawned processes
sudo grep -Ei 'worker process.*exited|signal 11|segfault|could not cancel' /var/log/nginx/error.log
sudo coredumpctl list nginx

Temporary mitigations, one per path. They don’t replace the upgrade:

# CVE-2026-123007 and CVE-2026-123633: disable HTTP/2 in every server block on the listener
listen 443 ssl;        # 1.9.5 to 1.25.0: just remove "http2" from listen
http2 off;             # 1.25.1 and later

# CVE-2026-121810: drop QUIC
# listen 443 quic reuseport;
http3 off;
add_header Alt-Svc 'clear' always;

# CVE-2026-123634: replace request-time DNS with a fixed upstream
upstream backend_fixed { server 10.0.0.10:8080; }
location / { proxy_pass http://backend_fixed; }

# CVE-2026-113425: keep the mail proxy off untrusted networks
mail { server { listen 127.0.0.1:143; } }

Disabling HTTP/2 breaks native gRPC through that listener, so check before flipping it on gRPC front ends. After any change, run nginx -t, then restart rather than reload if old workers (nginx: worker process is shutting down) hang around holding HTTP/2 connections.

For the kernel escalation, on hosts that don’t need SCTP:

echo 'install sctp /bin/false' | sudo tee /etc/modprobe.d/disable-sctp.conf
lsmod | grep '^sctp'      # already loaded? It stays loaded until reboot
grep '^CONFIG_IP_SCTP=' "/boot/config-$(uname -r)"   # =y means built in, the modprobe block won't help

If you find signs of exploitation, assume the attacker had everything the worker could read. Rotate TLS private keys served by that nginx, credentials in proxy_set_header or auth_basic_user_file, upstream client certificates and any secrets in included config files. On hosts with sctp loadable, treat the whole host and its containers as exposed.

Patch order: internet-facing nginx with HTTP/2 first, especially shared ingress and edge hosts in front of many services, then QUIC listeners, dynamic proxy_pass setups and mail proxies.

Timeline

  • 2015-09-22: nginx 1.9.5 ships HTTP/2 support with the flow-control code behind CVE-2026-123007.
  • 2026-10-11: Xint’s disclosure timeline marks this as the discovery date. A researcher found CVE-2026-123007 while preparing for ZeroDay Cloud 2026, and an automated Xint scan found the other four a few days later.
  • 2026-10-16: Xint reports to F5 through HackerOne. HackerOne completes validation on 20 October.
  • 2026-10-21: Wiz reports the HTTP/2 use-after-free (CVE-2026-123633). F5 replies that another team already reported it.
  • 2026-11-09 to 11-10: The nginx team asks Xint to validate the patches, and Xint confirms them. F5 sends Wiz the CVE-2026-123633 patch for review.
  • 2026-11-11: All five fixes are committed to nginx/nginx (12:13 to 12:18 UTC). Rapid7 contacts F5 and discloses CVE-2026-123007 the next day.
  • 2026-11-16: Wiz reports CVE-2026-123007. F5 confirms the CVE and the 18 November date to Rapid7.
  • 2026-11-18: Rapid7 creates its PoC repository (11:16 UTC). nginx 1.31.9 and 1.30.7 releases are published on GitHub (15:54 and 15:56 UTC). Xint, Wiz, Rapid7, CIRCL, Sophos and Aikido publish. Docker Hub’s official nginx images are rebuilt by 17:21 UTC. Debian lists every suite as vulnerable, the SCTP kernel bug has no fix, and none of the CVEs is in KEV.

From research to remediation

Check whether this pattern exists in your codebase

Turn this research into a remediation workflow. Scan dependencies and package manifests for similar supply-chain risk, then prioritize fixes with reachability context.

References