nginx HTTP/2 RCE: What CVE-2026-123633 and CVE-2026-123007 Mean and What to Do Today

Two nginx HTTP/2 flaws disclosed on 18 Nov 2026 allow unauthenticated code execution. Affected versions, how to find every nginx you run, how to patch, and the HTTP/2 workaround.

Xplorr team

The people who build Xplorr

8 min read
nginx HTTP/2 RCE: What CVE-2026-123633 and CVE-2026-123007 Mean and What to Do Today
In this post
  1. What was disclosed?
  2. How do the two bugs work?
  3. How do you find every nginx you run?
  4. How do you patch?
  5. What if you cannot upgrade today?
  6. What should you watch for?
  7. The short version

On 18 November 2026 F5 released nginx 1.30.7 and 1.31.9, fixing two HTTP/2 flaws that Wiz Research and several other teams reported. Both can be reached without authentication, neither depends on the application behind nginx, and Wiz rates both Critical (CVSS 4.0 9.2) with a path to remote code execution.

The takeaway for this week: find every nginx you run that has HTTP/2 enabled, including the copies inside container images and ingress controllers, and upgrade it to 1.30.7 (stable) or 1.31.9 (mainline). Where you cannot upgrade today, turn HTTP/2 off on those servers until you can.

Infographic titled Two nginx HTTP/2 bugs. Patch, or turn HTTP/2 off. A sidebar with four steps for this week: find every nginx including those in images and ingress pods; patch to OSS 1.30.7 or 1.31.9, Plus per the F5 advisory; or switch HTTP/2 off and reload; watch for worker crashes, odd child processes and long HTTP/2 streams. A table compares CVE-2026-123633, a use after free on an HTTP/2 connection affecting 1.19.7 to 1.31.8 and most exposed on reverse proxies short of free connections, with CVE-2026-123007, an integer underflow in HTTP/2 flow control affecting 1.9.5 to 1.31.8 and reachable on HTTP/2 over TLS on 64 bit even when serving static files. Wiz rates both Critical, CVSS 4.0 9.2; nginx.org rates them medium and major. Cards note that both give a memory read so ASLR alone does not stop them, that a CDN that terminates HTTP/2 helps only partly, and that distro packages backport fixes under their own version numbers. A band lists the workaround: remove http2 from listen lines, set http2 off on 1.25.1 and later, reload and confirm with curl.
The two flaws side by side, and what to do until every nginx is patched.

What was disclosed?

Two separate bugs, both in nginx’s HTTP/2 code:

CVE-2026-123633 CVE-2026-123007
Kind of bug Use after free on an HTTP/2 connection Integer underflow in HTTP/2 flow control, leading to an out of bounds copy
nginx Open Source affected 1.19.7 to 1.31.8 1.9.5 to 1.31.8 (every release since 2015)
nginx Plus affected R33 and later, 37.0.0 and later R33 and later, 37.0.0 and later
Fixed in Open Source 1.30.7, 1.31.9 1.30.7, 1.31.9
Fixed in nginx Plus 37.0.7.1, 37.2.0.1 37.0.8.1, 37.3.0.1
Most exposed Reverse proxies running low on free connections HTTP/2 over TLS on 64 bit systems, even serving static files
Wiz rating Critical, CVSS 4.0 9.2 Critical, CVSS 4.0 9.2
nginx.org severity medium major

The ratings differ between the researchers and the nginx.org advisory page. Plan around the higher one: Wiz describes working code execution against official builds, and that is what matters for your exposure.

The same release fixes two more issues that nginx.org lists as medium: a use after free in the resolver (CVE-2026-123634, affecting 0.6.18 to 1.31.8) and a use after free in HTTP/3. Upgrading closes all four.

How do the two bugs work?

You do not need the internals to patch, but they explain which servers are most at risk.

CVE-2026-123633 is a lifetime bug. nginx keeps a list of connections it may close when it runs short of free connection slots. An HTTP/2 connection can stay on that list after a request on it has started. If nginx then reclaims that connection while the request is still running, and building the GOAWAY frame that closes it fails, the connection’s memory is freed while the request still uses it. Running low on connection slots is far more likely on a busy reverse proxy, which is why Wiz calls proxy setups the more likely target.

CVE-2026-123007 is arithmetic. HTTP/2 lets each side cap how much data the other may send, and raise that allowance with WINDOW_UPDATE frames. When nginx gave back unused allowance it did not check the protocol maximum, so a counter could overflow, a later bounds check underflowed, and the result was a negative length passed to a memory copy in the TLS send path. Wiz showed it against official 1.31.7 and 1.31.8 builds serving plain static files, with no third party module and no backend at all. An attacker needs to send a large number of WINDOW_UPDATE frames to get there.

Both bugs can also leak memory to the attacker, which is how Wiz got past ASLR. That makes these more than a crash: an attacker who gets code running in an nginx worker sits in front of every application that nginx serves, and can read or change their traffic.

Two things limit the risk today. Wiz has not published its exploits, and exploitation is not trivial: the attacker has to leak addresses, shape the heap and handle different builds and configurations. And the attacker needs an HTTP/2 connection to nginx itself, so a CDN or WAF that terminates HTTP/2 in front of it may absorb the attack. Do not rely on either. Exploits for bugs like this tend to follow the patch diff within days, and origins behind a CDN are often reachable directly.

How do you find every nginx you run?

The nginx you know about is the easy one. The ones that get missed are inside container images, ingress controllers and appliances.

On a host, check the version and whether HTTP/2 is on anywhere in the loaded configuration:

nginx -v
# Print the full loaded config and look for HTTP/2 on listen lines or the http2 directive
sudo nginx -T 2>/dev/null | grep -nE '^\s*(listen\s.*\bhttp2\b|http2\s+on)'

In Kubernetes, list every container image that looks like nginx, then ask a running pod for its real version, because a tag such as stable or a vendor image name does not tell you which nginx is inside:

kubectl get pods -A -o jsonpath='{range .items[*]}{.metadata.namespace}{"\t"}{.metadata.name}{"\t"}{range .spec.containers[*]}{.image}{" "}{end}{"\n"}{end}' \
  | grep -iE 'nginx|ingress'

kubectl exec -n <namespace> <pod> -- nginx -v

Ingress controllers built on nginx carry their own nginx build, and so do many base images and Helm charts. Check the version inside each one rather than the version on the host.

For anything installed from a Linux distribution package, nginx -v is not the whole answer. Debian, Ubuntu, RHEL and others often backport security fixes into an older version number. Check your distribution’s security tracker for these CVE IDs before deciding a package is vulnerable or fixed.

Then confirm from outside which public endpoints actually negotiate HTTP/2:

curl -sI --http2 https://example.com -o /dev/null -w '%{http_version}\n'
# 2 means HTTP/2 was negotiated, 1.1 means it was not

Run it against your origins directly, not only the CDN hostname, since the CDN may speak HTTP/2 to clients while your origin is what the attacker reaches.

How do you patch?

Upgrade to a fixed release:

  • nginx Open Source: 1.30.7 on the stable branch or 1.31.9 on mainline.
  • nginx Plus: 37.0.8.1 or 37.3.0.1 cover both CVEs (37.0.7.1 and 37.2.0.1 fix only CVE-2026-123633). Follow F5’s advisory for your release line.
  • Container images: rebuild on a base image that contains a fixed nginx, then confirm with docker run --rm <image> nginx -v before you roll out. A rebuild that pulls a cached layer still ships the old binary.
  • Ingress controllers and vendor products: wait for the vendor’s release that bundles a fixed nginx, and use the workaround below in the meantime.

After the upgrade, reload or restart and check the version again from inside the running process or pod, not from the package manager.

What if you cannot upgrade today?

Both bugs need HTTP/2, so turning HTTP/2 off removes the attack surface until you can patch. Clients fall back to HTTP/1.1, which every browser and HTTP client supports. Expect some loss of performance on pages with many requests, not breakage.

On nginx 1.25.1 and later, set http2 off; and remove the http2 parameter from listen:

server {
    listen 443 ssl;          # was: listen 443 ssl http2;
    http2 off;               # nginx 1.25.1 and later

    server_name example.com;
    # ...
}

On versions before 1.25.1 there is no http2 directive; remove http2 from every listen line. In both cases check every server block that shares the same address and port, since HTTP/2 left on in one of them can keep it enabled for that socket.

Then apply and verify:

sudo nginx -t && sudo nginx -s reload

# Old workers keep serving existing connections until they finish.
# Make sure only workers started after the reload remain.
ps -o pid,lstart,cmd -C nginx

curl -sI --http2 https://example.com -o /dev/null -w '%{http_version}\n'   # expect 1.1

Test your application on HTTP/1.1 before you rely on this in production, and turn HTTP/2 back on once the fixed release is in place.

What should you watch for?

There are no published indicators that confirm exploitation of these two bugs. Wiz suggests general signs worth alerting on:

  • nginx worker processes crashing or restarting unexpectedly (worker process ... exited on signal 11 in the error log).
  • Commands or child processes started by nginx workers, which nginx itself never does.
  • Long lived HTTP/2 connections sending unusually large volumes of data or very many WINDOW_UPDATE frames, which may point to attempts at CVE-2026-123007.

The short version

  1. List every nginx you run, including inside images, ingress controllers and vendor products.
  2. Upgrade to 1.30.7 or 1.31.9 (nginx Plus 37.0.8.1 or 37.3.0.1), and verify the running version.
  3. Where you cannot upgrade today, turn HTTP/2 off and confirm with curl.
  4. Watch for worker crashes and unexpected child processes until everything is patched.

Sources: Wiz Research and the nginx security advisories, both 18 November 2026.

If you are tightening how your team tracks what runs where, our post on what building cloud cost integrations teaches you covers the inventory gaps cloud APIs leave behind. To see every account, cluster and resource you pay for in one place, try Xplorr free.

ShareLinkedInX

Written by

Xplorr team

The people who build Xplorr

Written together by the engineers who build Xplorr: the AWS, Azure, GCP and Kubernetes collectors, the console, and the alerting behind them.

About Xplorr

Related posts

All articles
What Building Cloud Cost Integrations Actually Teaches You
Engineering

What Building Cloud Cost Integrations Actually Teaches You

Five findings from the AWS, Azure, GCP and OpenCost collectors: a placeholder that hides unused storage, an API with no step parameter, and cost data that is absent unless you opt in.

Xplorr team

10 min read

Free plan, no credit card

See your AWS, Azure and GCP spend in one place

Connect a cloud account and find what is driving the bill. Start on the Free plan for 1 cloud account, no credit card required.