NGINX HTTP/2 Flow-Control Flaw (CVE-2026-123007): Patch NGINX Now

F5 NGINX HTTP/2 security advisory, rated Critical by F5, CVE-2026-123007, not in CISA KEV.

Status: F5 and the nginx project fixed CVE-2026-123007, a memory-corruption flaw in NGINX's HTTP/2 module, on 18 November 2026; the CVE record gives 10:00 EST as its public disclosure time. It affects NGINX Open Source and NGINX Plus only where HTTP/2 is enabled. F5 scores it 9.2 (Critical) under CVSS 4.0 and 8.1 (High) under CVSS 3.1, with high attack complexity and no privileges or user interaction required; nginx.org rates it "major". F5 says the usual result is a crash of an NGINX worker process, and that code execution is possible where Address Space Layout Randomization (ASLR) is disabled or can be bypassed. Rapid7, one of four reporters F5 credits, says its own proof of concept achieved unauthenticated remote code execution against NGINX 1.31.8, and Wiz Research separately reports confirmed code execution on official 1.31.7 and 1.31.8 builds. The fixed releases are NGINX Open Source 1.31.9 and 1.30.7 and NGINX Plus 37.3.0.1 and 37.0.8.1. F5 lists no fix for NGINX Plus R34 to R36 and no mitigation. The flaw is not in CISA's Known Exploited Vulnerabilities (KEV) catalog, and none of the sources we checked reports exploitation in the wild. Proof-of-concept exploit code is public: Rapid7's write-up links to code its researcher published on GitHub, and The Hacker News reports that code is publicly available. We last checked at 14:15 EST on 18 November 2026.

Executive Summary

NGINX can lose track of how much response data an HTTP/2 client has allowed it to send. Rapid7's technical write-up shows how a remote client without credentials can push NGINX's connection-level flow-control counter past the protocol limit, turn it into a negative length, and make NGINX copy memory outside its buffers. F5's advisory K000163926 describes the same flaw as an integer underflow (CWE-191) that can lead to a heap buffer overflow, "typically followed by an NGINX worker segmentation fault". F5 says the flaw is in the data plane only, with no control-plane exposure.

Three things decide whether a given NGINX instance is exposed:

  1. An affected build. NGINX Open Source 1.9.5 through 1.31.8 (HTTP/2 support first shipped in 1.9.5), NGINX Plus 37.x below 37.3.0.1 or 37.0.8.1, or NGINX Plus R34 to R36, for which F5 lists no fix, or older Plus releases past End of Technical Support, which F5 does not evaluate (see the R33 note).
  2. HTTP/2 enabled on a listener. F5 and the CVE record limit the flaw to configurations that use the ngx_http_v2_module. That module is not built by default in source builds, but common packages and container images ship with it. An instance that only speaks HTTP/1.1 is not affected by this CVE.
  3. A client that can open an HTTP/2 connection to NGINX directly. Rapid7 says that if the HTTP/2 connection is proxied, the attacker's precise frames "will likely not be retransmitted" in a way that allows exploitation. That lowers the risk of code execution behind an HTTP/2-terminating load balancer or CDN, but it is Rapid7's assessment, not a vendor statement, and it does not cover origins that can also be reached directly.

How serious is it in practice? The CVSS 3.1 "high attack complexity" rating matches what Rapid7 describes. Its code-execution route needs about 128 GB of HTTP/2 traffic over one connection: roughly two minutes on a 10 Gbit/s network and seventeen minutes on 1 Gbit/s. Because NGINX closes a keep-alive connection after one hour by default, Rapid7 says an attacker on a link slower than about 300 Mbit/s cannot finish. The route also depends on a specific glibc memcpy implementation that x86-64 systems select at run time when the CPU reports avx512f and avx512vl. Rapid7 says other routes "may be viable, but none are currently known", and that code runs with the NGINX worker's permissions; it has not shown execution as the master process or root.

How to read this (Rescana guidance): the conditions make large-scale exploitation over the internet harder, but they do not make the flaw minor. Well-connected attackers, cloud-hosted attack infrastructure and internal networks all clear the bandwidth bar. The ASLR condition in F5's wording is not much of a barrier either, because on systems that meet its conditions, Rapid7's route recovers memory addresses through the same flaw. Treat internet-facing NGINX with HTTP/2 on as patch-now, and treat a worker crash as the realistic minimum impact.

Exploitation status. CISA's KEV catalog (version 2026.11.17, 1,782 entries) does not list CVE-2026-123007. CISA's Vulnrichment entry on the CVE record rates exploitation "none", automatable "no" and technical impact "total"; CISA had not updated it since 11:04 EST when we checked. FIRST's EPSS service had no score for the CVE when we checked, and the NVD record was still at status "Received", carrying only F5's scores. Rapid7 has demonstrated its proof of concept in a video, and its write-up links to proof-of-concept code that its researcher published on GitHub, so proof-of-concept code for this flaw is public. The Hacker News reports that the code's own notes call it suitable only for demonstrating the attack against a freshly started Docker container on the same machine, a narrower setting than an attack over the internet. Public code still lowers the effort for anyone adapting it (Rescana guidance). Wiz Research says it will not release its exploits at this time. None of the sources we checked reports exploitation in the wild, and we have not opened or run the code.

Technical Information

Where the bug is. HTTP/2 lets a client limit how much response data a server may send, using flow-control "credit" granted in WINDOW_UPDATE frames. The protocol caps that credit at 2^31-1 bytes per connection. According to Rapid7's analysis, NGINX holds the connection's credit in an unsigned 64-bit counter and enforces the cap in its own code. Two behaviours combine to break that cap:

  • When a request closes while some of its response data is still queued and unsent, NGINX returns the reserved credit to the connection without checking whether that takes the counter above the cap.
  • When a client raises the initial stream window in a SETTINGS frame so far that an open stream would exceed the cap, RFC 9113 says the server must end the whole connection. Rapid7 says NGINX instead resets only the affected streams and keeps the connection open.

With the counter already above the cap, the next connection-level WINDOW_UPDATE check performs an unsigned subtraction that wraps around. That is the integer underflow F5 classifies as CWE-191. After that, the client can keep adding credit until the counter reaches the top half of its 64-bit range. NGINX later treats that value as a negative response length, builds a buffer whose end pointer sits before its start, and passes a huge byte count to memcpy when it buffers TLS output. That is the out-of-bounds write (CWE-787) on the CVE record.

Why "crash" and "RCE" are both right. A copy that really ran across that range would hit unmapped memory and crash the worker, which is what F5 describes as the typical outcome. Rapid7 found that on AVX-512 capable x86-64 CPUs, where glibc selects a particular copy routine, the copy instead stops after a limited amount of out-of-bounds reading and writing. It says that is enough to leak memory addresses, defeating ASLR, and to corrupt nearby heap data, and calls these "constrained read and write capabilities, not an unconditional arbitrary read or write". Its proof of concept turns them into command execution.

Why the traffic volume matters. Each WINDOW_UPDATE frame grants a bounded amount of credit, so Rapid7's route needs billions of them on a single connection, plus further request traffic, for a reported total of about 119 GiB before TLS and network overhead. Rapid7 notes these figures describe its 64-bit route, not a universal minimum.

What has been shown, and by whom. Rapid7 reports unauthenticated code execution against a linux/amd64 Docker image of NGINX 1.31.8 with http2 on and TLS enabled, in about two and a half minutes. Rapid7's timeline says it contacted F5 on 11 November and gave F5 the details privately on 12 November, and that F5 validated the flaw on 16 November and set the 18 November disclosure date. F5 credits Stephen Fewer of Rapid7, Tomer Schwartz of Wiz Research, Xint.io, and Ikotas Labs. Wiz Research separately reports confirmed remote code execution with an ASLR bypass on official NGINX 1.31.7 and 1.31.8 builds, using HTTP/2 over TLS on 64-bit systems serving ordinary static files with no backend application. Wiz does not say whether its route shares Rapid7's CPU dependency. The nginx.org change log credits Xint.io.

Fixed alongside it. NGINX 1.31.9 and 1.30.7 also fix other security issues listed in the nginx.org security advisories, including two in the same HTTP area. nginx.org rates both medium, but F5 scores each 9.2 (Critical) under CVSS 4.0 and 8.1 (High) under CVSS 3.1, with the same ASLR wording as the main flaw. One is a use-after-free in HTTP/2 when a worker runs short of worker_connections while proxying requests to a backend (CVE-2026-123633, F5 K000163928), and Wiz Research says it confirmed remote code execution. F5 lists NGINX Plus fixes in 37.2.0.1 and 37.0.7.1, so the releases that fix CVE-2026-123007 cover it too. Treat it as a second patch-now HTTP/2 flaw: the same upgrade fixes both, and disabling HTTP/2 takes both out of scope (Rescana guidance). The other is a use-after-free in HTTP/3 (CVE-2026-121810, F5 K000163927), which needs HTTP/3. Other fixes in the release are CVE-2026-118899 and CVE-2026-113425 (both major), CVE-2026-123634 and CVE-2026-120967 (medium), and CVE-2026-125283, CVE-2026-123640 and CVE-2026-120993 (minor). nginx.org lists CVE-2026-120993 as affecting only 1.31.4 to 1.31.8, fixed in 1.31.9. Upgrading for CVE-2026-123007 covers all of them, which is one more reason to upgrade rather than rely on configuration changes.

Affected Product Versions

Product and branch Affected (per F5 K000163926) Fixed in
NGINX Open Source 1.31.x (mainline) 1.31.0 to 1.31.8 1.31.9
NGINX Open Source 1.30.x and older 1.9.5 to 1.30.6 1.30.7
NGINX Plus 37.x 37.1.0 to 37.2.0.1 37.3.0.1
NGINX Plus 37.0.x 37.0.0 to 37.0.7.1 37.0.8.1
NGINX Plus R34 to R36 All None listed

Notes on the table:

  • Plus R33. F5's advisory table lists R34 to R36. The machine-readable CVE record lists NGINX Plus as affected from R33 onwards, with no upper bound; the same record uses an open-ended entry for Open Source from 1.9.5, where F5's table gives 1.9.5 to 1.30.6. F5 says it evaluates only releases that have not reached End of Technical Support. If you still run R33 or earlier, treat it as exposed and unpatchable in place (Rescana guidance).
  • Older Open Source releases. Releases before 1.30 get no separate fix. F5 and Rapid7 both point anyone on 1.9.5 to 1.30.6 to 1.30.7.
  • Other F5 products. F5 lists BIG-IP (all modules), BIG-IQ, F5OS, F5OS-A, F5OS-C, BIG-IP Next for Kubernetes, BIG-IP CNF, F5 AI Gateway and "NGINX (all other products)" as not vulnerable. For F5 Distributed Cloud and NGINX One Console, F5 says it is "still researching" and will update the article.
  • Distribution packages. As of 14:09 EST on 18 November, most major distributors had not shipped a fix. Debian's security tracker listed nginx in bookworm, trixie, forky and sid as vulnerable. Ubuntu listed nginx as vulnerable in every release from 16.04 LTS to 26.10, at High priority. Red Hat rated the flaw Critical and listed nginx in RHEL 8, 9 and 10 and in Red Hat Hardened Images as affected, with no erratum. Alpine's security database listed nginx 1.30.7-r0 as the fix for edge and Alpine 3.24, with no entry for 3.23 or 3.22. Distributors often fix a package by patching an older version, so a fixed package can still report an old version number. Compare against your distributor's advisory for CVE-2026-123007, not the upstream version alone. Until a fixed package ships, either move to nginx.org's own 1.31.9 or 1.30.7 packages or disable HTTP/2 (Rescana guidance).
  • Forks and embedded copies. Products built from NGINX source, and appliances or images that bundle their own NGINX binary, take the fix only when their maintainer ships it (Rescana guidance).
  • Kubernetes ingress controllers. The community kubernetes/ingress-nginx project was archived on 24 March 2026, and its README says there will be no further releases or security fixes after March 2026. Its last controller releases (v1.15.1, v1.14.5 and v1.13.9, published 19 March 2026) build NGINX 1.27.1, which is in the affected range, and its use-http2 setting defaults to "true". Clusters still running it should set use-http2: "false" in the controller ConfigMap now and plan a move to a maintained controller (Rescana guidance). F5 NGINX Ingress Controller (nginx/kubernetes-ingress) is a separate product. Its latest release when we checked, v5.8.0, was published at 08:23 EST on 18 November, before disclosure; its notes say it updates NGINX to 1.31.8, an affected version, and do not mention CVE-2026-123007. Do not treat it as fixed until F5 ships a release with fixed NGINX.

How to Find Your Exposure

The steps below are Rescana guidance unless a source is named.

1. Find every NGINX binary, not only the package. Check the installed version with nginx -v. For NGINX Plus, also check the package version with rpm -q nginx-plus or dpkg -l nginx-plus. Include NGINX inside container images (docker run --rm --entrypoint nginx <image> -v), Kubernetes ingress controllers and API gateways (kubectl exec <pod> -- nginx -v on the controller pods), and appliances whose web console or reverse proxy is NGINX. A software bill of materials (SBOM) or image scanner helps, but it often misses NGINX compiled into a vendor product.

2. Check whether the module is compiled in. nginx -V 2>&1 | grep -o with-http_v2_module shows whether the binary can speak HTTP/2. A binary without it is not affected by this CVE. Most distribution and official images include it, so a match only tells you the next step matters.

3. Check whether HTTP/2 is switched on. Dump the full effective configuration, including every included file, and look for both forms of the setting. Run the dump the way the running master was started, or you may be reading a different binary or file: tr '\0' ' ' < /proc/<master-pid>/cmdline shows the master's binary and any -c or -p arguments, and /proc/<master-pid>/exe -T with those same arguments uses the binary actually running. With a default install, the check is:

nginx -T 2>/dev/null | grep -nE '^\s*http2\s+on|listen[^;]*\bhttp2\b' | grep -vE '^[0-9]+:\s*#'

Since NGINX 1.25.1, the http2 on; directive enables HTTP/2 per server (or for the whole http block), and the older http2 parameter on listen is deprecated but still accepted. nginx.org's documentation says the listen parameter "configures the port", so one listen 443 ssl http2; line (the only form before 1.25.1) turns HTTP/2 on for every server sharing that address and port. HTTP/2 also works without TLS: a plain-text listener with HTTP/2 enabled accepts cleartext HTTP/2 (h2c) from clients that use it directly, so do not assume port 80 is out of scope.

4. Confirm from outside. Configuration reviews miss listeners managed by other tools, so test what clients actually get:

curl -sS -o /dev/null --http2 -w '%{http_version}\n' https://host.example/
openssl s_client -connect host.example:443 -servername host.example -alpn h2 </dev/null 2>/dev/null | grep -i '^ALPN'
curl -sS -o /dev/null --http2-prior-knowledge -w '%{http_version}\n' http://host.example/

A result of 2, or ALPN protocol: h2, means HTTP/2 is reachable on that name. Test each virtual host name, because the server NGINX selects can depend on the TLS server name, and repeat the openssl check without -servername to see what the default server offers. If a CDN or load balancer sits in front, test the origin address too, for example with curl --http2 --resolve host.example:443:<origin-ip> https://host.example/: Rapid7's proxying caveat only helps if attackers cannot bypass the front door.

5. Confirm the running process after you upgrade. Reloading NGINX re-reads the configuration but keeps the old binary. Restart the service, or use NGINX's on-the-fly binary upgrade (send USR2 to the master, then WINCH and QUIT to the old master). On Linux, ls -l /proc/$(cat /run/nginx.pid)/exe shows (deleted) when the binary on disk has been replaced but the master process is still running the old one (the PID file path varies by package), and /proc/<master-pid>/exe -v shows the version of the binary the master is actually running. Containers need a rebuild as well as a redeploy. The official nginx images on Docker Hub had 1.31.9 and 1.30.7 tags, and refreshed mainline, stable, latest and alpine tags, by 12:21 EST on 18 November. Some moving variant tags, including alpine-perl, mainline-alpine-perl and stable-alpine-perl, had last been pushed at 08:52 EST, before disclosure, when we checked at 14:08 EST, so confirm the NGINX version inside whichever variant you use. Rebuild any image built FROM nginx with a fresh pull. Redeploying an existing tag or pinned digest reruns the old binary, and images that install nginx from a distribution package stay vulnerable until that distributor ships. Then roll the pods and confirm each one with kubectl exec <pod> -- nginx -v.

6. Prioritise. Patch first where an untrusted client can open HTTP/2 straight to NGINX: internet-facing reverse proxies, ingress controllers with public load balancers, API gateways, and origins reachable without the CDN. Within that group, start with hosts that terminate TLS for many services, because a compromised worker there sees traffic and keys for all of them.

Workaround and Mitigation

Vendor position. F5's advisory lists the mitigation as "None", and the CVE record lists no workaround. The fix is to upgrade.

Interim option: turn HTTP/2 off (Rescana guidance). Because F5 limits the flaw to configurations that use HTTP/2, removing HTTP/2 from an instance takes it out of scope for this CVE until you can upgrade. Remove http2 on; from every server and http block, remove http2 from every listen line, run nginx -t, reload, confirm the old worker processes have exited (they keep serving connections opened before the reload), and then repeat the outside checks in step 4 to confirm that no name still offers h2. Plan for the trade-offs:

  • Browsers fall back to HTTP/1.1 with no user-visible error, but they open more connections. Watch worker_connections, file-descriptor limits and any connection-based rate limits or load balancer quotas.
  • gRPC breaks. gRPC needs HTTP/2, so any grpc_pass service, or client configured for HTTP/2 only, stops working. Those endpoints need the upgrade, not the workaround.
  • Load balancer or CDN to origin. If a load balancer or CDN talks HTTP/2 or gRPC to NGINX (for example, through HTTP/2 or gRPC target groups), disabling HTTP/2 at the origin breaks that hop. Switch that hop to HTTP/1.1 first, or patch.
  • HTTP/3 is not a safe substitute. It runs over QUIC in a separate module, and the same release fixes a separate use-after-free in HTTP/3 (CVE-2026-121810). Do not enable it on an unpatched build as a way to keep multiplexing.
  • Scope it. The http2 parameter on listen (the only form before 1.25.1) applies to the whole address and port, so every server sharing that address and port must drop it. Keep the change in configuration management so you can re-enable HTTP/2 deliberately after upgrading.

Controls that help but are not fixes (Rescana guidance).

  • Terminate HTTP/2 in front of NGINX. Rapid7's caveat about proxied connections suggests that a load balancer or CDN that terminates client HTTP/2 lowers the code-execution risk. That only works if the origin accepts traffic from the front door alone, for example through network allow-lists or authenticated origin pulls.
  • Shorten connection lifetime. Rapid7's route has to finish within one connection, and keepalive_time defaults to one hour. Lowering it on HTTP/2 servers shrinks the window for that published route. It does nothing for other possible routes or for crashes.
  • Keep ASLR on and workers unprivileged. Check that /proc/sys/kernel/randomize_va_space is 2, and that the user directive runs workers as a non-root account. Neither stops Rapid7's route, which recovers addresses through the flaw, but both limit what a cruder attempt achieves.
  • NGINX Plus R34 to R36. F5 lists no fix for these releases and recommends upgrading to a release that has the fix (37.3.0.1 or 37.0.8.1). Until you can upgrade, disable HTTP/2 on those instances (Rescana guidance).

Indicators of Compromise

F5, nginx.org and Rapid7 have published no indicators of compromise, and no exploitation has been reported to derive them from. The items below are detection leads, not IoCs (Rescana guidance).

  • Worker crashes. NGINX's master process restarts a crashed worker and logs an alert such as worker process 12345 exited on signal 11. A run of these on an HTTP/2 listener, especially when the instance has been stable before, is the clearest early sign. Each crash also drops the connections that worker was serving, so it is a service problem even without code execution.
  • One connection, enormous inbound volume. Rapid7's route needs on the order of a hundred gigabytes sent to NGINX over a single connection lasting minutes. Look in flow logs for single client flows with tens of gigabytes inbound to an NGINX listener, which normal web clients do not send.
  • Connection-level logging. Add $http2, $connection, $connection_requests and $connection_time to your log_format. That lets you spot single HTTP/2 connections with unusually high request counts and long lifetimes, and shows how much of your traffic uses HTTP/2 before you decide whether to disable it.
  • Post-exploitation. NGINX workers rarely start other programs. A shell, curl, wget or script interpreter whose parent is an NGINX worker deserves investigation. Baseline first, because some setups (embedded scripting modules, for example) legitimately run code inside the worker.
  • If you find signs of compromise. Worker processes hold the TLS private keys they serve with, along with other users' requests in memory. Rotate certificates and keys, session ticket keys, and any secrets in the NGINX configuration, and invalidate sessions for applications behind that instance.

Third-Party Risk (TPRM) Angle

Suppliers often put NGINX at the front door: reverse proxies and load balancers in front of SaaS applications, Kubernetes ingress controllers, API gateways, and the web consoles of appliances. Most of that sits where you cannot see it, and none of it can be patched by you. What you can do is find out quickly which suppliers run NGINX with HTTP/2 on paths that carry your data, and hold them to a date.

The risk concentrates in three supplier types:

  • SaaS and hosting providers that terminate TLS for your traffic. A compromised worker there can read requests, cookies and tokens passing through, and the TLS keys in memory.
  • Appliance and software vendors that ship NGINX inside their product. They fix on their own release schedule, and F5's lack of a fix for Plus R34 to R36 can hold up products built on those releases.
  • Suppliers running F5 Distributed Cloud or managing NGINX through NGINX One Console. F5 has not yet confirmed whether those services are affected, so ask what the supplier is doing in the meantime.

Send these four questions to suppliers in those groups now:

  1. Do you run NGINX Open Source or NGINX Plus with HTTP/2 enabled on internet-facing or customer-data paths, including inside appliances, containers or ingress controllers?
  2. Have you upgraded to NGINX 1.31.9 or 1.30.7, or NGINX Plus 37.3.0.1 or 37.0.8.1 (or your distributor's fixed package), including ingress controllers and rebuilt container images, and if not, when will you?
  3. If you run NGINX Plus R34 to R36, or an older release, for which F5 lists no fix, what is your mitigation until you move to a fixed release (for example, disabling HTTP/2)?
  4. Will you confirm in writing once patched?

Ask for evidence, not reassurance: the NGINX version and package build on the affected services, confirmation that processes and pods were restarted on the fixed build, the output of an outside HTTP/2 check if they disabled HTTP/2 instead, a review of NGINX error logs for worker crashes since 18 November, and a commitment to tell you within an agreed window if they find signs of exploitation. Record answers against each vendor record, and set follow-ups for suppliers on Plus R34 to R36 and for those relying on F5 Distributed Cloud until F5 updates its advisory, for those waiting on a distributor's fixed package, and for those running ingress-nginx or F5 NGINX Ingress Controller until they move or F5 ships a release with fixed NGINX.

What to do internally: inventory NGINX binaries and images, confirm where HTTP/2 is on, patch internet-facing instances first and restart them, disable HTTP/2 where you cannot patch today, and alert on worker crashes. We will update this advisory if CISA adds the flaw to KEV, exploitation in the wild is reported, F5 ships a fix for NGINX Plus R34 to R36 or an F5 NGINX Ingress Controller release with fixed NGINX, F5 updates Distributed Cloud's status, major distributors ship fixed packages, or NVD scoring changes.

Need help working through suppliers that run NGINX with HTTP/2 exposed to CVE-2026-123007? Our team can help you prioritize them and track their answers. Talk to an expert

Sources

Talk to an expert

Talk to Rescana about this advisory — or about how we help TPRM teams keep reviews moving.