Skip to main content

nginx 1.30.7 and 1.31.9 Fix Two HTTP/2 Code Execution Bugs

9 min read
Patch nginx on my servers

We check each server and ingress, move nginx to 1.30.7 or 1.31.9, and restart it.

nginx 1.30.7 and 1.31.9 shipped on November 18 with fixes for CVE-2026-123007 and CVE-2026-123633, two HTTP/2 bugs that can let an attacker run code on the server. How to check your servers, patch them, and switch HTTP/2 off until you can.

What Shipped on November 18

On November 18, 2026, nginx released 1.30.7 on the stable branch and 1.31.9 on mainline. Together they fix ten security issues. Two of them deserve attention today. CVE-2026-123007 and CVE-2026-123633 are memory-safety bugs in the HTTP/2 code, and researchers have shown that each one can let an attacker run code on the server without logging in.

Fixed builds were in the official nginx.org package repositories and on Docker Hub the same afternoon, so most servers can be patched today with an ordinary package upgrade. A server that cannot be upgraded yet can switch HTTP/2 off, which blocks both attacks in the meantime. Neither CVE is in CISA's catalog of known exploited vulnerabilities as we write this, and the teams that built working exploits are keeping them private for now. That leaves a short, clear window to patch.

nginx -v                                    # 1.9.5 to 1.31.8 is affected
nginx -V 2>&1 | grep -o with-http_v2_module # HTTP/2 compiled in

The Two Bugs at a Glance

CVE-2026-123007CVE-2026-123633
What it isMemory corruption in HTTP/2 flow controlUse-after-free in HTTP/2
Severity on nginx.orgMajorMedium
CVSS 4.0 and 3.1 from F59.2 and 8.19.2 and 8.1
Affected versions1.9.5 to 1.31.81.19.7 to 1.31.8
What it needsHTTP/2 switched onHTTP/2 to clients, requests proxied to a backend, and a worker running low on connections
Fixed in1.30.7 and 1.31.91.30.7 and 1.31.9

The ratings look contradictory and are not. F5 gives both bugs 9.2 under CVSS 4.0 because the worst outcome is the same, code execution over the network. The nginx project rates CVE-2026-123633 as medium because its conditions are narrow. CVE-2026-123007 is the one that matters to nearly everyone. It needs nothing more than HTTP/2 being on, and the vulnerable code has shipped in every release since HTTP/2 support arrived in nginx 1.9.5 in 2015.

How the Flow Control Bug Works

HTTP/2 lets many requests share one connection, and flow control limits how much response data the server may send before the client says it is ready for more. nginx tracks what is left for the whole connection in a counter called send_window. When a stream is cancelled while its response is still queued, nginx hands the unused allowance back to that counter. Before this release it did so without checking the maximum the protocol allows.

Wiz Research walks through what happens next. If the client has raised the allowance in the meantime, the refund pushes the counter past the maximum. The bounds check on the next WINDOW_UPDATE frame subtracts the counter from that maximum using an unsigned number, the result wraps around to a huge value, and the check waves further increases through. The inflated counter eventually becomes a negative length in the TLS send path, and that ends as an out-of-bounds memory copy on the heap.

Wiz confirmed code execution, with ASLR bypassed, on the official 1.31.7 and 1.31.8 builds over HTTPS on 64-bit systems. The target served nothing but static files, with no backend application and no third-party module. The fix, commit b89c4100 in the nginx repository, makes nginx count frames that are still queued when it validates a WINDOW_UPDATE.

How the Use-After-Free Works

nginx keeps a list of idle connections it may close when it needs room for new ones, and an HTTP/2 connection with no active requests can sit on that list. The bug let a connection stay there after a request had started on it. If that request then made nginx open a connection to a backend at a moment when free connection slots were scarce, nginx could pick the very connection it was serving, close it, free its memory and carry on with the request using pointers into memory that was no longer its own.

That is why this one needs a reverse proxy setup and a worker short of connections, and why Wiz expects it to be used mostly against nginx in front of an application. Commit 0c87dd1d fixes it by taking the connection off the reusable list as soon as a stream is created.

Five Teams Found the Same Bugs

Wiz Research, Ikotas Labs, Metnir, Rapid7 and Xint reported these flaws to F5 independently. Wiz says an AI-assisted code scanning harness found its two, and Xint says a fully automated scan found four of its five nginx bugs without human guidance. Wiz described the same pattern behind last month's PHP fixes, which we covered in PHP Patches Two Unauthenticated RCEs. Those PHP flaws went onto CISA's exploited list on October 26, five days after the fixes shipped, which is a fair guide to how long a quiet window lasts now. The nginx advisory page shows how fast this is moving, with two entries for 2025 and 36 for 2026 so far, ten of them in this release alone.

Xint also chained CVE-2026-123007 with a separate Linux kernel flaw in SCTP and reached root on the host, including from nginx running inside a Docker container. That kernel bug has no fix yet, and it has its own section below.

Is Your Server Exposed?

CVE-2026-123007 needs three things on the same server. The version has to be unpatched, the binary has to include the HTTP/2 module, and the configuration has to switch HTTP/2 on. These commands answer each question, and the last one shows what the internet actually sees.

nginx -v 2>&1
nginx -V 2>&1 | grep -q -- --with-http_v2_module && echo "HTTP/2 module present"
sudo nginx -T 2>/dev/null | grep -nE 'listen .*http2|http2 +on'
openssl s_client -connect example.com:443 -servername example.com -alpn h2 </dev/null 2>&1 | grep ALPN

Run the last line from outside your network with your own domain in place of example.com. "ALPN protocol: h2" means the server accepts HTTP/2, and "No ALPN negotiated" means it does not. When a CDN sits in front of nginx, that test only reaches the CDN, so repeat it against the origin. Wiz notes that a CDN or WAF which terminates HTTP/2 may break parts of the exploit, depending on the provider, but an origin that can be reached directly is exposed all the same.

The version string can mislead on distribution packages. Ubuntu, Debian and Red Hat backport security fixes into the version they originally shipped, so nginx -v on Ubuntu 24.04 prints 1.24.0 before and after a fix. Compare the full package version from dpkg -l nginx or rpm -q nginx with your distribution's advisory instead.

Patching Today

If you install nginx from the nginx.org repositories, the fixed packages are already there. When we checked the package indexes on the evening of November 18, stable 1.30.7 was available for Ubuntu 24.04, Debian 12 and the RHEL 9 family, and mainline 1.31.9 for Ubuntu 24.04 and Debian 13.

sudo apt update && sudo apt install --only-upgrade nginx   # Debian, Ubuntu
sudo dnf upgrade nginx                                     # RHEL family
sudo systemctl restart nginx
nginx -v

Restart, do not just reload. A reload reads the configuration again but keeps the binary that is already running, so the old code stays in memory until the master process is replaced.

The official Docker image got 1.30.7 and 1.31.9 tags, Alpine variants included, on November 18. Pull the new tag, rebuild every image that uses nginx as its base, and redeploy. A container that is already running keeps the version it was built with.

Ubuntu's and Debian's own nginx packages are not fixed yet. At the time of writing, Ubuntu's CVE tracker lists every supported release as needing a fix for both CVEs, and Debian's tracker lists bookworm, trixie and sid as vulnerable. Until those updates land, servers on distribution packages should switch HTTP/2 off, or move to the nginx.org repository if the team is ready to own that change.

F5 has also published fixed NGINX Plus builds. The exact build for each release line is in its advisories K000163926 and K000163928.

Until You Can Patch, Switch HTTP/2 Off

F5, Wiz and Xint all point to the same stopgap. On nginx 1.25.1 and later, add http2 off; to each affected server block and remove http2 from its listen lines. On older versions, remove http2 from the listen line.

server {
    listen 443 ssl;
    http2 off;
    # the rest of the server block stays as it is
}

Xint advises changing every server block that shares the same address and port, not just the main site. Then run nginx -t, reload, and repeat the openssl check until it prints "No ALPN negotiated". Browsers and API clients fall back to HTTP/1.1 without complaint. Native gRPC is the exception, because it needs HTTP/2, so test any gRPC service on that port first.

This only covers the two HTTP/2 bugs. The same release also fixes use-after-free bugs in HTTP/3, in the resolver and in the mail proxy, plus five other issues, so the upgrade remains the real fix.

Kubernetes Ingress Controllers

F5's own controllers were updated the same day. NGINX Ingress Controller 5.8.0 and NGINX Gateway Fabric 2.9.0 came out on November 18, and both build on nginx 1.31.9.

The community controller, kubernetes/ingress-nginx, is a different story. The Kubernetes project retired it, best-effort maintenance ended in March 2026, and the repository is now archived. Its last release, controller v1.15.1 from March 19, bundles nginx 1.27.1 and has HTTP/2 on by default through its use-http2 option. No patched release will come. If you still run it, switch HTTP/2 off in the controller's ConfigMap today and plan the move to a maintained controller.

apiVersion: v1
kind: ConfigMap
metadata:
  name: ingress-nginx-controller
  namespace: ingress-nginx
data:
  use-http2: "false"

That name and namespace are the Helm chart defaults. Find yours with kubectl get configmap -A | grep ingress-nginx and add the key to the existing ConfigMap, rather than replacing it, so the rest of your settings stay.

The Kernel Bug in the Chain

The SCTP flaw that Xint used to get from the nginx worker to root has been in the Linux kernel since version 4.15 in 2018, and there is no kernel patch yet. On many distributions the SCTP module is installed by default and loads automatically the first time a program opens an SCTP socket. Web servers rarely need SCTP, which is mostly used for telecom signalling, so most hosts can simply stop it from loading.

echo "install sctp /bin/false" | sudo tee /etc/modprobe.d/disable-sctp.conf
lsmod | grep sctp

This blocks loading through modprobe and nothing more. A module that is already loaded stays loaded, so if lsmod prints a line, unload it with sudo modprobe -r sctp or reboot. A kernel with SCTP built in is not covered at all.

Signs Worth a Second Look

An attack on CVE-2026-123007 leaves little in the access log. The WINDOW_UPDATE and RST_STREAM frames that trigger it are not requests, so nginx never logs them, and TLS hides them on the wire. Wiz and Xint suggest looking in other places.

  • A failed attempt can kill a worker, which shows up in the error log as signal 11 or a worker that exited on a signal.
  • A normal nginx worker never starts another program. An auditd rule on execve for the worker's user will catch one that does.
  • One client holding a connection open for minutes while sending a lot of data and receiving very little matches the attack Xint tested.
sudo grep -Ei 'signal 11|exited on signal|segfault' /var/log/nginx/error.log
sudo ss -tinp state established '( sport = :443 )'

Workers crash for ordinary reasons too, so a crash on its own is a reason to look closer, not proof. A worker that starts a shell is different and calls for incident response straight away. Our guide on detecting and responding to a compromised Linux server covers the first hour.

What This Means for Your Team

For most teams this is an evening's work. Fixed packages exist, the stopgap is one line per server block, and nothing so far points to attacks in the wild. Start with servers that face the internet directly with HTTP/2 on, then any cluster still running community ingress-nginx, which will never receive an update.

Our own site has no nginx in its request path, so there was nothing to patch here. This is the third serious HTTP/2 or nginx flaw we have written about this year, after NGINX Rift in May and Apache's mod_http2 fix last week. What helped each time was being able to roll a patch out within a day, and our guide to patching on a schedule without a maintenance window shows how to set that up.

If you would rather hand the checking and patching to someone else, we do it as part of our security and compliance work.

Sources

Read how we handle it in Cybersecurity.

Related News

Security

Two Critical NGINX Bugs Dropped This Week And Who Is Actually At Risk

F5 shipped out-of-band patches on June 17, 2026 for two critical NGINX flaws, CVE-2026-42530 and CVE-2026-42055, both CVSS 9.2 and both unauthenticated. The headline is scary, but the exploitable surface is narrow. Here is which versions and configs are at risk, why it is a denial of service for most rather than code execution, and what to do.

Security

nginx Patches Three CVEs, One a 9.2 Critical Bug That Sat Hidden in the Code Since 2011

nginx patched three CVEs on July 15, 2026: a 9.2-rated critical heap buffer overflow in map regex matching (CVE-2026-42533) present since 2011, an uninitialized-memory bug that unnamed regex captures trigger through either the slice directive or ordinary background cache updates (CVE-2026-60005), and a use-after-free in the SSI filter (CVE-2026-56434) present since 2009. Fixed in 1.30.4 stable and 1.31.3 mainline. With the config patterns to audit for, five read-only audit commands, and the detail most coverage gets wrong about the second bug.

Security

The New libssh2 SSH Flaw Is Client-Side, Not Your sshd, and apt upgrade Will Not Fix the Copies That Matter

CVE-2026-55200 is an out-of-bounds write in the libssh2 client library that a malicious or compromised SSH server can use to corrupt a connecting client's memory, and a public proof-of-concept is already out. The corrections that matter: it is client-side and not an OpenSSH or sshd bug, the severity rating is disputed across scorers, and the real cleanup is finding the statically linked and vendored copies a distribution update never touches.