On 18 November 2026, F5 and the nginx project released nginx 1.31.9 and 1.30.7, fixing ten CVEs. Five of them are memory corruption bugs that Xint reports as unauthenticated remote code execution. Xint calls them NGINX2Root, together with a sixth bug: a Linux kernel flaw that takes the attacker from the nginx worker to root on the host. F5 scores all five nginx bugs 9.2 on CVSS v4.0. The nginx project’s own advisory page rates two of them major and three medium. The kernel bug has no patch.

What matters:

If you are a Pentera customer, you’re already covered and can validate NGINX2Root exposures in your environment.

  • The five nginx bugs are independent. Each one is reported as code execution by itself, and each needs a different nginx feature to be switched on.
  • CVE-2026-123007 is the one that reaches most servers. It needs HTTP/2 on a listener the attacker can connect to, and nothing else. The code has been there since nginx 1.9.5 in 2015.
  • A working exploit for it is public: Rapid7 released one on disclosure day. It needs about 128 GB of traffic on one connection, and it depends on how glibc copies memory on x86-64.
  • ASLR is not a defence here. Rapid7, Wiz and Xint each report recovering the addresses they need through the bug itself.
  • Code runs as the nginx worker. The “2Root” part is a separate use-after-free in the Linux kernel’s SCTP code, which Xint says also gets out of a Docker container. As of 19 November it has no fix and no CVE.
  • No exploitation in the wild has been reported, and none of the five CVEs is in CISA’s KEV catalogue, as of 19 November.

Security teams: upgrade to nginx 1.31.9 or 1.30.7 (NGINX Plus 37.3.0.1 or 37.0.8.1), or your distribution’s fixed package, and restart nginx. A reload keeps the old binary running. If you cannot patch today, turn HTTP/2 off, which blocks two of the five, then check your configuration against the other three. On hosts that do not use SCTP, block the kernel module.

Credit returned twice

CVE-2026-123007 is a bookkeeping error in HTTP/2 flow control. This section leans on Xint’s write-up and Rapid7’s analysis. They found the bug independently and agree on the root cause.

HTTP/2 lets a client limit how much response data the server may send. The server keeps a credit counter for each stream and one for the whole connection. Sending DATA spends credit from both, and the client tops them up with WINDOW_UPDATE frames. RFC 9113 caps every window at 2^31-1 bytes, about 2 GB.

nginx keeps the connection counter, h2c->send_window, in a size_t. On a 64-bit build that type holds values far above the cap, so the cap exists only where the code checks for it.

nginx spends the credit when it queues a DATA frame, before any byte leaves:

h2c->send_window -= frame_size;
stream->send_window -= frame_size;

If the stream is cancelled while the frame is still queued, cleanup hands the credit back:

h2c->send_window += window;

Both steps are correct. The problem is what a client can do between them. While the DATA sits in the queue, a WINDOW_UPDATE on stream 0 tops the connection window back up. Then the client cancels the stream, and cleanup returns the same credit a second time. With Q bytes queued:

start, window raised to the maximum     2^31-1
nginx queues Q bytes of DATA            2^31-1 - Q
client sends WINDOW_UPDATE of Q         2^31-1
client cancels, cleanup refunds Q       2^31-1 + Q

The refund does not check the result against the maximum. The counter is now above a limit the rest of the HTTP/2 code assumes it can never cross.

Two practical details. To keep DATA queued, the client stops reading and floods nginx with PING frames, whose replies go out ahead of DATA and fill the TLS and TCP send buffers. To cancel, Xint sends RST_STREAM. Rapid7 uses a SETTINGS frame that pushes the streams’ own windows past the limit. The RFC says that must end the connection. nginx resets the streams and keeps the connection open.

The next WINDOW_UPDATE meets this check:

if (window > NGX_HTTP_V2_MAX_WINDOW - h2c->send_window) {
    return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_FLOW_CTRL_ERROR);
}
h2c->send_window += window;

The subtraction works out how much room is left. With the counter at the maximum plus Q, the answer should be minus Q. In unsigned arithmetic it is 2^64 – Q, so nginx sees almost unlimited room and accepts the frame. It accepts the next one too. Each frame is valid by the RFC, and together they can raise the counter to any 64-bit value.

Xint calls the bug an integer overflow. F5’s CVE record calls it an integer underflow, CWE-191. Both are right, about different lines: the refund overshoots and the check wraps.

From a counter to a copy

The wrong counter turns into memory corruption when nginx sizes the next DATA frame, because that code works in off_t, which is signed. A counter of 2^64 – d, read as a signed number, is minus d.

if (limit == 0 || limit > (off_t) h2c->send_window) {
    limit = h2c->send_window;
}
/* ... */
if ((off_t) frame_size > limit) {
    frame_size = (size_t) limit;
}

Both comparisons exist to shrink a length that is too large. Neither rejects one that is negative. The frame size becomes minus d, and the buffer nginx builds for the frame ends d bytes before it starts. The TLS output path measures that buffer as end minus start, gets minus d, and passes it to memcpy(), which takes an unsigned length. The request is to copy 2^64 – d bytes.

That should crash the worker immediately. It does not, because of how glibc copies large blocks on x86-64. The optimised routine saves the first and last bytes of the source, then copies the middle backward, 128 bytes at a time, from the end of the destination. The end is destination plus size. With a size of 2^64 – d, that sum wraps around and lands d bytes below the destination. The loop runs once, sees it is already past the start, and stops.

So a copy of nearly 2^64 bytes moves a few hundred, and returns. By Xint’s account that is 128 bytes at the destination and 160 bytes just below it, at a distance of d. The attacker sets d through the window arithmetic above.

Xint aims those 160 bytes at the front edge of the TLS plaintext buffer. The first 96 land on the heap metadata in front of the buffer. The other 64 land inside it and go out to the client in the response, carrying pointers into the nginx image and the heap. One copy gives a write and an address leak. The source bytes are arranged in advance with Cookie and Range headers.

From there both teams overwrite a cleanup callback and wait for nginx to call it. Rapid7’s public exploit first reads glibc’s loaded image back over HTTP/2 to find system(). Xint and Wiz have withheld their final steps.

What the exploit depends on

  • A 64-bit build. The conversions above are described for 64-bit targets.
  • glibc on x86-64. Rapid7 says its exploit relies on the copy routine glibc selects on CPUs with AVX-512. Xint walks through the same backward-copy structure in the AVX2 path and dates it to glibc 2.24, released in 2016.
  • A direct connection. Rapid7 expects that an HTTP/2 connection passing through a proxy will not deliver the exact frames. Wiz says the same of CDNs and WAFs that terminate HTTP/2, and adds that it depends on the implementation.

Neither write-up covers musl, which Alpine-based images use, or ARM64. The window bug is in nginx whatever sits underneath. What is specific to glibc is surviving the copy, so on another libc I would expect a crashed worker. That is my inference, not a test result. Rapid7 says other routes to code execution may be viable and none is known.

Where 128 GB comes from

Rapid7 puts its exploit at about 128 GB of HTTP/2 traffic on one connection. The number comes straight from the counter. Credit costs nothing to grant, but the frame that grants it is 13 bytes and can add no more than 2^31-1:

one connection WINDOW_UPDATE        13 bytes, adds at most 2^31-1
to reach 2^63                       about 2^32 frames     52 GiB
to reach just under 2^64            about 2^33 frames    104 GiB
request headers sent alongside      to stay within nginx’s
                                    control-frame limits  15 GiB
total before TLS                                         119 GiB

Rapid7 gives the time as about two minutes on a 10 Gbit/s link and seventeen on 1 Gbit/s. Below roughly 300 Mbit/s the attempt runs into nginx’s default one-hour connection lifetime and fails. Rapid7 also says the figures describe its own route and should not be read as a minimum.

Xint publishes no traffic figure. It reports success against AWS, GCP, Azure and bare metal over a public address, with normal traffic running. Wiz reports code execution against the official 1.31.7 and 1.31.8 builds serving static files, with no backend and no third-party module.

The other four

The remaining four are use-after-free bugs. Each needs a particular configuration. nginx rates three of them medium and one major, against F5’s 9.2 for all four. Ranges and ratings below are from nginx.org. The conditions are from Xint, which tested each one against the official nginx:1.31.8 image with the feature added to the stock configuration.

CVE Where Needs Vulnerable nginx rating
CVE-2026-123633 HTTP/2 HTTP/2 to clients, requests proxied to an upstream, a worker short of free connections 1.19.7 to 1.31.8 medium
CVE-2026-121810 HTTP/3 HTTP/3 (QUIC) to clients, requests proxied to an upstream 1.25.0 to 1.31.8 medium
CVE-2026-123634 Resolver resolver, a proxy_pass destination taken from the request, and a subrequest such as mirror 0.6.18 to 1.31.8 medium
CVE-2026-113425 Mail proxy A mail block with proxy on and auth_http 0.5.33 to 1.31.8 major

Xint lists later starting versions for two of these, 1.13.4 for the resolver path and 0.5.15 for the mail proxy. Those are the first releases where its tested path works. I have used nginx’s ranges.

The two proxy bugs are the same mistake in two protocols. A worker has a fixed number of connection slots, shared between clients and upstreams. When no more than one in sixteen is free, nginx closes idle connections to make room, which it calls draining, and it does so inside the call that asks for a slot.

In HTTP/2, a connection that has received half a HEADERS frame is put on the idle list. When the other half arrives and a request starts, it stays there. The request then asks for a slot to reach its upstream. That triggers a drain, which can pick the connection the request is running on, close it and free the request. Control returns to upstream code that is still holding the freed memory.

HTTP/3 gets there through a gap during stream creation, in which the parent QUIC connection can be put back on the idle list. The ending is the same.

Xint’s exploit shapes the heap so the freed request points at an address of its choosing, and nginx connects out to the attacker’s server and sends it a buffer full of pointers. The worker then crashes, and its replacement has the same memory layout. A second pass plants a fake request whose handler is execv(). Both need nginx to be able to open a TCP connection to the attacker. Wiz found the HTTP/2 one independently and reports code execution with a different trigger for the close.

The resolver bug is in the loop that runs when a DNS answer arrives. nginx walks the list of lookups waiting on that name and calls each one’s handler, having saved a pointer to the next. If a handler frees a later entry, the loop walks into freed memory. That takes two lookups from the same request, which is what mirror provides: the request and its mirror resolve the same name. The attacker needs to answer DNS for a name nginx will look up, for instance with proxy_pass http://$host; and a Host header pointing at their own zone. Xint notes that other features that create subrequests, such as SSI, may reach the same code.

The mail bug is in the login path. With auth_http, nginx asks an HTTP service whether each login is valid, and the connection to that service holds a pointer to the client’s session. If the client resets its connection while nginx still has a reply queued for it, the session is freed and the auth connection lives on. The next event on it uses the freed session. No valid credentials are needed. In Xint’s test the auth service rejected every login.

Xint says one of its researchers found CVE-2026-123007 while preparing for a competition, and that an automated scan found these four a few days later without human guidance.

The half without a patch

Everything above ends with code running as the nginx worker, which is normally an unprivileged account. The “2Root” in the name comes from a sixth bug, and it is not in nginx.

Xint describes a flaw in the send path of SCTP, a transport protocol the Linux kernel supports alongside TCP and UDP. While a send is waiting, the association it belongs to can be moved to another socket. The waiting send can then free an association it no longer owns. Depending on what the other socket does, that is a use-after-free or a double free. Xint dates the bug to Linux 4.15, from 2018.

Xint reports two results from it: a kernel memory leak that defeats KASLR, and an arbitrary function call in the kernel. Together they took an nginx worker to root reliably in its tests. The same chain started inside a Docker container and ended as root on the host, which follows from containers sharing the host’s kernel.

Three things to keep straight.

  • This is Xint’s claim, shown on video, with the details held back until the kernel is fixed. I have not seen an independent reproduction.
  • There is no fix and no CVE as of 19 November. A fully patched kernel is still affected.
  • Nothing about it is specific to nginx. It is a local privilege escalation, and the nginx bugs are one way of becoming local.

Whether a given host is reachable depends on SCTP being available to the process. Xint notes that many distributions install the module by default and load it the first time a program opens an SCTP socket, and that the kernel build and the container’s restrictions can change the answer.

On hosts that do not use SCTP, Xint’s interim measure is one line in a .conf file under /etc/modprobe.d/:

install sctp /bin/false

This stops the module from being loaded on demand. It does not unload a module that is already loaded, so check lsmod. It does nothing where SCTP is compiled into the kernel.

What to do, and what not to trust

Patch. It is the only complete fix, and it only covers the nginx half.

Where your nginx comes from Fixed in
nginx.org mainline 1.31.9
nginx.org stable 1.30.7
NGINX Plus 37.x 37.3.0.1 and 37.0.8.1
NGINX Plus R36 and older No fixed build listed; upgrade to 37.x
Ubuntu 26.10 nginx 1.30.4-7ubuntu1.2
Ubuntu 26.04 LTS nginx 1.28.3-2ubuntu1.13
Ubuntu 24.04 LTS nginx 1.24.0-2ubuntu7.20
Ubuntu 22.04 LTS nginx 1.18.0-6ubuntu14.23
Ubuntu 20.04 LTS and older Fixed for Ubuntu Pro subscribers only
RHEL, Debian, Alpine Check the vendor’s advisory, CVE by CVE
Kubernetes ingress-nginx controller Retired in March 2026; no further releases

The Ubuntu versions are from USN-9159-1, published on 19 November. The ingress-nginx line is from the Kubernetes project’s retirement notice, which rules out further releases and security fixes.

Three traps.

  1. Restart, do not just reload. nginx -s reload re-reads the configuration and keeps the binary that is already in memory. Restart the service, or do a proper binary upgrade, and confirm what is running.
  2. Check the fix per CVE, not per package. Ten CVEs were fixed upstream at once, and a distribution update does not have to carry all of them. Ubuntu’s notice lists eight.
  3. nginx hides in the same places PHP and httpd did: container base images, ingress controllers, appliances, and products that bundle it without saying so.

If you cannot patch yet, each bug has its own interim measure. None of them covers the others.

CVE Interim measure
CVE-2026-123007, CVE-2026-123633 Turn HTTP/2 off. On 1.25.1 and later, http2 off; in every server block that shares the listening address and port, and no http2 on listen. On older versions, remove http2 from listen.
CVE-2026-121810 Remove the quic listeners, set http3 off;, and stop advertising HTTP/3 in Alt-Svc.
CVE-2026-123634 Point proxy_pass at a fixed upstream group, so nginx does no DNS lookup while handling a request.
CVE-2026-113425 Bind the mail listeners to loopback, or firewall them to clients you trust.
Kernel SCTP bug Block the sctp module on hosts that do not use it.

Turning HTTP/2 off breaks anything that requires it, native gRPC included. For the resolver bug, Xint says mirror_request_body on stopped its exploit and is not a fix, and that turning mirror off alone is not enough. A configuration change applies to new connections only. Connections that were already open stay with the old workers, so restart here too.

Then confirm from outside, against nginx itself and not the CDN in front of it:

openssl s_client -connect HOST:443 -servername HOST -alpn h2 </dev/null 2>&1 | grep ‘ALPN protocol’

For detection, Xint’s guidance comes down to four places to look.

  • A process started by a worker. An nginx worker has no reason to run a shell, and Xint calls this the clearest sign of a successful attack. An audit rule on execve for the worker’s UID will record it.
  • One client holding a connection open for minutes, with bytes received climbing fast and very little sent back.
  • A connection that has received gigabytes while its logged request lengths add up to almost nothing.
  • Worker segfaults in the error log. A failed attempt can kill a worker, but workers also crash for other reasons, so read these alongside the other three.

What not to trust:

  • nginx -v on a distribution package. Ubuntu 24.04 reports 1.24.0 before the fix and after it. Compare the full package version with the advisory.
  • “We turned HTTP/2 off.” That is two bugs out of five.
  • The access log. The frames that drive CVE-2026-123007 are WINDOW_UPDATE, PING and RST_STREAM. None is a request, and none is logged as one.
  • ASLR. Every published exploit path starts by leaking the addresses it needs.
  • The 128 GB figure as a control. It is the cost of one public exploit, and its author says so.
  • A kernel update, for now. There is no fixed kernel to update to.

What is still open

Four things had no answer as of 19 November.

  • The kernel bug has no patch, no CVE and no date for either. Until that changes, treat worker-level code execution on a host with SCTP available as root.
  • Nobody has published a result for CVE-2026-123007 on musl or ARM64, or a route to code execution that avoids the glibc copy.
  • Rapid7’s exploit is public. Xint and Wiz are holding theirs back, and Xint says its own works over a public address with normal traffic running.
  • The other four bugs need particular configurations, and nobody has published how common those are.

For now, three numbers. Eleven years in every release since HTTP/2 arrived. Five teams, by Wiz’s count, finding the HTTP/2 bugs independently: Xint, Wiz, Rapid7, Ikotas Labs and Metnir. Thirty-six CVEs on nginx’s advisory page for 2026, by my count, against two for 2025.

Patch, restart, and block a kernel module you have probably never used.

References

Attack Surface Monitoring Cyber Pulse Cybersecurity Research