NGINX2Root: what we patched this week, what we checked first, and what I'd do differently

On this page23 sections
- On November 18, 2026, nginx released 1.30.7 (stable) and 1.31.9 (mainline). Together they fix ten CVEs. The one that matters to almost everyone is CVE-2026-123007, a memory corruption bug in HTTP/2 flow control that F5 scores 9.2 Critical (CVSS 4.0). It affects every release from 1.9.5 through 1.31.8 that has HTTP/2 turned on, and a public proof of concept already exists.
- The fix is to upgrade to 1.30.7 or 1.31.9, or to your distro’s backported package, and then restart nginx. A reload won’t do it. If you can’t patch today, turn HTTP/2 off. That closes the two HTTP/2 bugs but not the HTTP/3, resolver, mail proxy or TLS 1.3 issues.
Don’t trust
nginx -von distro builds. Check containers and ingress controllers separately. If you still run the retired Kubernetes ingress-nginx controller, no fix is coming, and this week is a good reason to finish migrating off it.If you run nginx with HTTP/2 enabled, and most of us do on anything serving HTTPS, you have a remotely reachable, pre-auth memory corruption bug to patch this week. Upgrade to nginx 1.30.7 or 1.31.9 (or your distro’s fixed package), restart the service, and check your containers and ingress controllers separately. That’s the short version. The rest of this post explains how we worked through it as a team on Wednesday, because the details are where people get caught.
What actually happened
On November 18, 2026, nginx shipped 1.30.7 on the stable branch and 1.31.9 on mainline, fixing ten CVEs in one go. github F5, which maintains nginx and issues its CVEs, published all ten records the same morning. atlasumatlasum Xint, one of the research teams involved, grouped five of them, plus a Linux kernel bug, under the name “NGINX2Root”. precursorsecurityxint That’s the name you’ll see in your Slack channels. Wiz Research, Rapid7, Ikotas Labs and Metnir independently found and reported the HTTP/2 bugs too. When five separate teams land on the same 11-year-old bug in the same few weeks, I read that as a sign it won’t stay quiet for long.
The headline is CVE-2026-123007. nginx.org lists it as “Memory corruption in HTTP/2 flow control”, severity major, vulnerable 1.9.5–1.31.8, not vulnerable 1.31.9+ and 1.30.7+ F5’s advisory is K000163926. It scores the bug CVSS 4.0 9.2 (Critical) and CVSS 3.1 8.1 (High), classifies it as CWE-191 integer underflow, and describes the impact as: “An attacker could leverage this vulnerability to crash the NGINX worker process, corrupt its memory, or potentially execute code remotely.” Red Hat rates it Critical and Ubuntu gives it High priority.
The bug has been in the code since HTTP/2 support landed in nginx 1.9.5 on September 22, 2015. Xint ran a Shodan count on November 10, 2026: 56.7 million hosts reported as nginx, 11.94 million of them (21.1%) exposed an identifiable version, and among those, 98.9% fell inside the affected range. That doesn’t mean 98.9% are exploitable. HTTP/2 has to be on, and distro backports muddy version strings. It does tell you how wide the net is.
The bug in plain English
HTTP/2 lets a client tell the server how much response data it’s willing to receive. This is the flow-control “window”. The client raises it with WINDOW_UPDATE frames, and nginx tracks the remaining credit for the whole connection in a counter.
When nginx queues response data, it subtracts that size from the counter up front. If the stream that owns the queued data gets cancelled, nginx refunds the credit. The refund didn’t check the protocol’s maximum window size. A client that bumps the window to the limit and then cancels streams with queued data can push the counter past the maximum. After that, a later bounds check does an unsigned subtraction that wraps around to a huge number, the check stops working, and the counter can be inflated much further. Eventually that value is treated as a negative length, and the TLS send path does an out-of-bounds memory copy. Rapid7’s write-up and Wiz’s write-up both walk through the code if you want the details. I’m deliberately not going further than that here.
The fix is a small commit: “HTTP/2: account for queued frames when validating WINDOW_UPDATE”.
Two points from the research matter for how you prioritize.
First, the code runs as the nginx worker user (usually www-data or nginx), not root. That’s still bad. Your worker sees decrypted traffic and holds your TLS private keys in memory. Xint also chained it with a separate, still-unpatched Linux kernel SCTP use-after-free, present since Linux 4.15 (2018), to get root on the host, and says the chain “escaped a Docker container running nginx and obtained root on the underlying host.” That kernel bug has no CVE and no patch yet.
Second, ASLR doesn’t save you. F5’s record says code execution is possible “on systems with Address Space Layout Randomization (ASLR) disabled or when the attacker can bypass ASLR,” but Luxembourg’s CERT (CIRCL) is blunt in its TR-105 report: “Disabling Address Space Layout Randomization (ASLR) is not a prerequisite for the NGINX2ROOT exploits described by the researchers.” Wiz agrees: according to Precursor Security’s live blog, Wiz researcher Nir Ohfeld said on X that the team got “reliable remote code execution (ASLR defeated)” against nginx serving nothing but static files. If a scanner or a colleague tries to downgrade the finding because ASLR is on, push back.
Is it being exploited?
As of November 19, 2026, nobody has reported in-the-wild exploitation, and none of the ten CVEs is in CISA’s KEV catalog. There is a public proof of concept. On disclosure day Rapid7’s Stephen Fewer published one (github.com/sfewer-r7/CVE-2026-123007) showing unauthenticated RCE against the official nginx 1.31.8 Docker image with http2 on and TLS. Xint and Wiz have said they won’t release theirs.
That exploit has real-world limits, and Rapid7 is upfront about them. It needs roughly 128 GB of HTTP/2 traffic on one connection: about two minutes on a 10 Gbit/s link, about seventeen minutes on 1 Gbit/s. Below roughly 300 Mbit/s, nginx’s default one-hour connection lifetime kills the connection before the exploit finishes. It also depends on a specific glibc memcpy routine selected on x86-64 CPUs with AVX-512. And if a CDN or proxy terminates HTTP/2 in front of you, the attacker’s exact frames probably never reach nginx.
So it’s noisy, it’s not trivial, and today it’s narrow. I wouldn’t use any of that as a reason to wait. Wiz points out that mass exploitation usually starts against packaged products where thousands of installs share an identical build. A lot of nginx installs look exactly like that.
The other nine CVEs, briefly
Most write-ups focus on CVE-2026-123007, and that’s right. But “turn off HTTP/2” is not a complete answer, so here’s the rest of the release in one place. Version ranges are nginx.org’s, and CVSS 4.0 scores are F5’s.
| CVE | What it is | Reachable when | Affected | nginx / F5 |
|---|---|---|---|---|
| CVE-2026-123007 | HTTP/2 flow-control memory corruption | HTTP/2 enabled | 1.9.5–1.31.8 | major / 9.2 |
| CVE-2026-123633 | HTTP/2 use-after-free | HTTP/2 + proxying to a backend + worker low on worker_connections | 1.19.7–1.31.8 | medium / 9.2 |
| CVE-2026-121810 | HTTP/3 use-after-free | HTTP/3 (QUIC) + proxying | 1.25.0–1.31.8 | medium / 9.2 |
| CVE-2026-123634 | Resolver use-after-free | resolver + variable-based proxy_pass + mirror or SSI subrequest | 0.6.18–1.31.8 | medium / 9.2 |
| CVE-2026-113425 | Mail proxy use-after-free | mail proxy with auth_http | 0.5.33–1.31.8 | major / 9.2 |
| CVE-2026-118899 | Infinite loop reading request body over TLS 1.3 | Any HTTPS listener with TLS 1.3 (the default) | 1.13.0–1.31.8 | major / 8.7 |
| CVE-2026-120967 | Client cert check bypass via SNI in stream | Stream ssl_verify_client in specific SNI setups | 1.25.5–1.31.8 | medium / 6.3 |
| CVE-2026-123640 | Insufficient validation in stream ssl_preread | ssl_preread routing | 1.15.2–1.31.8 | minor / 6.9 |
| CVE-2026-125283 | Buffer overflow with alias + try_files | Uncommon config | 0.9.6–1.31.8 | minor / 6.9 |
| CVE-2026-120993 | NULL deref with PROXY protocol v2 | Mainline only | 1.31.4–1.31.8 | minor / 6.9 |
The one I’d flag for ops teams is CVE-2026-118899. It’s “only” a DoS, but it hits basically every HTTPS listener on a modern nginx, and F5 lists no workaround. A stuck worker stops serving every connection it holds. CVE-2026-118899 That alone is a reason to patch rather than just flip HTTP/2 off and call it done.
One more thing: 1.30.7 carries nine of the ten fixes. CVE-2026-120993’s code never shipped on the 1.30.x branch, so stable isn’t missing anything there.
Don’t confuse these three things
Every time an nginx CVE drops, someone on the team asks whether our Kubernetes ingress is affected. The answer depends on which “nginx” you mean.
nginx open source (nginx.org) is the thing these CVEs are about. Fixed in 1.30.7 and 1.31.9.
NGINX Plus is F5’s commercial build. F5’s records list fixes in 37.3.0.1 (CR track) and 37.0.8.1 (LTS track). Plus R33 through R36 are listed as affected with no fixed version, so if you’re on an R-series release, plan the move to a 37.x build.
ingress-nginx (kubernetes/ingress-nginx) is the community Kubernetes controller, and it is retired. The Kubernetes Steering and Security Response Committees were explicit back in January: “There will be no more releases for bug fixes, security patches, or any updates of any kind after the project is retired.” kubernetes The final releases shipped in March 2026. privatedevopsdev On November 5, 2026, the project published CVE-2026-116472, a low-severity issue with the mirror-target annotation, with no fix. Its HTTP/2 is on by default, so it carries CVE-2026-123007 and will never get a patched build. If you still have it running, this is your sign.
F5’s NGINX Ingress Controller is a different project. Its docs list 5.8.0 as bundling NGINX 1.31.9 / Plus R37.3.0.1. Heads-up: a couple of live blogs reported that 5.8.0 shipped 1.31.8. As far as I can tell, that came from an older “Update NGINX to 1.31.8” line in the auto-generated GitHub release notes. F5’s changelog, its technical specifications page (“All images include NGINX 1.31.9”) and independent image checks all say 1.31.9. Still, verify the binary in your own pods. NGINX Gateway Fabric is fixed in 2.9.0.
Forks and bundlers (OpenResty, Kong, APISIX, nginx-proxy, random “nginx + php” images) ship on their own schedules. When the fixes landed, OpenResty’s latest was 1.31.8.1, built on the vulnerable 1.31.8. Treat anything that embeds nginx as affected until its maintainer says otherwise.
Am I affected? The checks we ran, in order
We did this across roughly 140 hosts and a handful of clusters. This is the order I’d recommend.
Start with the version and the build flags
nginx -v
nginx -V 2>&1 | tr ' ' '\n' | grep -E '^--with-(http_v2_module|http_v3_module|mail|stream|stream_ssl_preread_module)$'No --with-http_v2_module means no HTTP/2 code, so neither HTTP/2 bug applies to that binary. Most packaged builds have it.
Then check what the config actually turns on. nginx -T dumps the full config with includes resolved:
sudo nginx -T 2>/dev/null | sed 's/#.*//' | grep -nE \
-e 'http2|quic|http3' \
-e '^[[:space:]]*(mail|stream)[[:space:]]*\{' \
-e '\b(resolver|mirror|ssi|auth_http|try_files)\b' \
-e '\b(ssl_preread|ssl_verify_client|proxy_protocol)\b'Match the hits against the table above. Two warnings. nginx -T reads the config on disk, which may differ from what’s loaded if someone edited without reloading. And its output can contain secrets, so don’t paste it into a public ticket.
Then confirm from outside whether HTTP/2 is actually negotiated:
openssl s_client -connect example.com:443 -servername example.com -alpn h2 </dev/null 2>&1 \
| grep -E 'ALPN protocol|No ALPN negotiated'ALPN protocol: h2 means HTTP/2 is reachable. If there’s a CDN in front, this tests the CDN. Run it against the origin directly too, circlxint because an attacker who can reach your origin IP doesn’t care about your CDN.
Now the one that tripped up two of our juniors: distro packages keep their old version numbers. Debian 12 reports 1.22.1, Ubuntu 22.04 reports 1.18.0, and Ubuntu 24.04 reports 1.24.0 whether or not they’re patched, because the fix arrives as a new package revision. computingforgeeks +2 Check the full package version and the changelog:
# Debian / Ubuntu
dpkg-query -W -f='${Package} ${Version}\n' 'nginx*'
apt changelog nginx 2>/dev/null | grep -cE 'CVE-2026-(123007|123633)'
# RHEL / Rocky / Alma / Fedora
rpm -q nginx
rpm -q --changelog nginx | grep -E 'CVE-2026-(123007|123633)'
# Alpine
apk list --installed 'nginx*'A count of 0 in the changelog means that package doesn’t carry the fix.
Containers next. A host package check tells you nothing about what’s inside your images:
docker ps --format '{{.Names}}\t{{.Image}}'
docker exec <container> nginx -v
docker run --rm --entrypoint nginx <image> -vAnd Kubernetes
# Is the retired community controller running anywhere?
kubectl get pods --all-namespaces --selector app.kubernetes.io/name=ingress-nginx
# What nginx is actually inside your ingress pods?
kubectl exec -n <ns> <ingress-pod> -- nginx -vThe first kubectl command is the one the Kubernetes project itself recommends for finding ingress-nginx. We found one forgotten install in a staging cluster this way.
How to fix it, per platform
The goal everywhere is the same: get onto 1.30.7 or 1.31.9, or a distro package that explicitly lists these CVEs, and restart the process. I’d pick stable (1.30.7) unless you already run mainline. Mainline 1.31.9 also starts rejecting header lines without a colon and chunked bodies with excessive framing overhead, which can break odd clients that relied on nginx being lenient.
Back up and test first, every time
sudo cp -a /etc/nginx /root/nginx-backup-$(date +%F)
sudo nginx -tnginx.org packages (fastest path today)
nginx.org’s own repos had 1.31.9-1 and 1.30.7-1 on November 18 for Debian, Ubuntu, RHEL, SLES, Amazon Linux 2023 and Alpine. If you already use them:
# Debian / Ubuntu with the nginx.org repo
sudo apt update && sudo apt install --only-upgrade nginx
# RHEL / Rocky / Alma with the nginx.org repo
sudo dnf upgrade nginxIf you’re on distro packages and your distro hasn’t shipped a fix yet, switching to the nginx.org repo is a legitimate option. precursorsecurity Their packaging differs from Debian/Ubuntu’s (different file layout, no nginx-common, no sites-enabled by default), kernelhost so don’t do this switch for the first time on a production box at 5pm. Follow the official instructions at nginx.org/en/linux_packages.html, including the signing key and the apt pin, and test on one server first.
Ubuntu and Debian packages
At the time of writing, there’s no fix yet. Ubuntu’s CVE page lists every release from 16.04 through 26.10 as “Vulnerable”, and Debian’s tracker lists bookworm (1.22.1-9+deb12u10), trixie (1.26.3-3+deb13u10), forky and sid as vulnerable. When the USN or DSA lands, it’s the usual:
sudo apt update && sudo apt install --only-upgrade nginx nginx-commonUntil then: mitigate (next section), or move to nginx.org packages.
RHEL, Rocky, AlmaLinux
Red Hat lists RHEL 8 (nginx:1.24 stream), RHEL 9 (default plus the 1.24 and 1.26 streams) and RHEL 10 as affected, rated Critical, with no RHSA yet. AlmaLinux got ahead of upstream and shipped fixed builds on November 18. Install these versions or later:
- AlmaLinux 8, nginx:1.24 stream:
nginx-1.24.0-3.module_el8.10.0+4373+4291aaad.6.alma.4almalinux - AlmaLinux 9 default (1.20):
nginx-1.20.1-32.el9_9.1.alma.4almalinux - AlmaLinux 9, nginx:1.24:
nginx-1.24.0-9.module_el9.9.0+356+d723c317.1.alma.4almalinux - AlmaLinux 9, nginx:1.26:
nginx-1.26.3-10.module_el9.9.0+357+ccfac862.1.alma.2almalinux - AlmaLinux 10:
nginx-1.26.3-16.el10_3.1.alma.3almalinux
AlmaLinux notes that retired module streams get nothing. That includes nginx:1.14, which is still the default stream on AlmaLinux 8. If that’s you, switching streams is part of the fix:
dnf module list nginx
sudo dnf module reset nginx
sudo dnf module enable nginx:1.24
sudo dnf upgrade nginx
rpm -q nginxRocky and RHEL users: watch for the RHSA/RLSA, and mitigate in the meantime.
Alpine
Alpine 3.24 and edge have nginx-1.30.7-r0. Alpine 3.22 and 3.23 were not fixed at the time of writing.
apk update && apk upgrade nginx
apk list --installed nginxDocker
The official images were rebuilt on November 18. nginx:1.31.9 and nginx:1.30.7 carry the fix, and latest, mainline and stable point at them on the common architectures. rescana +3 Atlas Security noticed that some moving tags lagged on less common architectures (riscv64, and stable-alpine on 386, arm/v7, ppc64le), so pin the version tag rather than trusting a floating one:
FROM nginx:1.30.7
# or FROM nginx:1.31.9 / nginx:1.31.9-alpinedocker pull nginx:1.30.7
docker build --pull --no-cache -t myapp-web:patched .
docker compose up -d --force-recreate
docker exec <container> nginx -v # should say 1.30.7Rebuilding the base doesn’t help if your running containers aren’t recreated, and pinned digests never move. Images that bundle nginx (nginx-proxy, OpenResty-based images, vendor appliances) need their own maintainers to ship a rebuild.
Kubernetes
- F5 NGINX Ingress Controller: 5.8.0 (Helm chart 2.9.0). nginx F5’s advisory also lists 2026-lts-r11 for the LTS track.
- NGINX Gateway Fabric: 2.9.0.
- Community ingress-nginx: no fix. Start the migration to Gateway API or another maintained controller. In the meantime, disable HTTP/2 through the controller’s ConfigMap (
use-http2: "false"), and put a CDN or HTTP/2-terminating load balancer in front if you can.
After any controller upgrade, kubectl exec into a pod and run nginx -v. Don’t take the chart version’s word for it.
NGINX Plus
Move to 37.3.0.1 (CR) or 37.0.8.1 (LTS). R33 through R36 have no fixed release.
Restart, don’t reload
This is the mistake I expect to see most, so it gets its own heading. nginx -s reload and systemctl reload nginx start new workers from the binary that’s already running in memory. Upgrading the package replaces the file on disk, not the running master. Atlas tested it: after a reload, the server kept answering as 1.31.8 while nginx -v cheerfully reported 1.31.9.
So, after upgrading:
sudo nginx -t && sudo systemctl restart nginxIf you can’t drop connections, nginx’s documented on-the-fly binary upgrade (USR2 to the master, then WINCH/QUIT to the old one) also works. Practice it on staging first. Then confirm nothing is still running the old, deleted binary:
ls -l /proc/[0-9]*/exe 2>/dev/null | grep -F 'nginx (deleted)'Empty output is what you want.
If you can’t patch today
Be clear-eyed about this part: none of these is a fix. They close specific paths, and each one has a cost.
Turn off HTTP/2. This closes CVE-2026-123007 and CVE-2026-123633. On nginx 1.25.1 and later, set it in every server block that shares the port, and remove http2 from listen:
server {
listen 443 ssl;
http2 off;
# ...
}On older versions (1.9.5 to 1.25.0, which covers Ubuntu 22.04/24.04 and Debian 12 stock packages), change listen 443 ssl http2; to listen 443 ssl;. Check IPv6 listen [::]:443 lines too. HTTP/2 is negotiated per listening socket, so one server block still saying http2 can keep it on for the whole port. Clients fall back to HTTP/1.1 fine, but native gRPC breaks, so check with whoever owns gRPC services before you flip it. Apply it, then verify from outside with the openssl s_client -alpn h2 check above. You want No ALPN negotiated.
A reload only applies the change to new connections. Existing HTTP/2 sessions stay on old workers until they close. If you think someone might already be working on you, restart.
For the other paths: remove listen ... quic lines and set http3 off; for CVE-2026-121810 (and clear any Alt-Svc header advertising h3). Point proxy_pass at a fixed upstream block instead of a variable-built hostname, and avoid mirror/SSI there, for CVE-2026-123634. Restrict mail proxy listeners to trusted networks for CVE-2026-113425. There’s no workaround for the TLS 1.3 loop, CVE-2026-118899. That one waits for the patch.
On hosts that don’t use SCTP (almost all web servers), block the kernel module to break the root-escalation chain until a kernel fix exists. CIRCL and Xint both recommend this:
grep -E '^CONFIG_IP_SCTP=' "/boot/config-$(uname -r)" # m = module (blockable), y = built in (not)
lsmod | grep -w sctp
echo 'install sctp /bin/false' | sudo tee /etc/modprobe.d/disable-sctp.conf
modprobe -n -v sctp # should now print: install /bin/falseThis doesn’t unload a module that’s already loaded, and it can’t touch SCTP built into the kernel. For containers, do it on the host, because they share the host’s kernel.
How we rolled it out
Nothing clever here, just discipline. We patched internet-facing HTTPS edge first, then anything with HTTP/3, mail or variable upstreams, then internal listeners. CIRCL is right that internal listeners are still reachable “from actors able to reach that listener”, so they’re not exempt, just later.
For each group we followed the same steps. Take one canary host out of the load balancer, upgrade, nginx -t, restart, verify, put it back, and watch error rates and latency for 30 minutes. Then do 25%, then the rest. Our rollback plan was the config backup plus the previous package version pinned in our repo mirror. To be honest, the only realistic reason to roll back is a mainline behaviour change breaking a client, which is one more reason to prefer 1.30.7.
How to verify you’re done
On each host, after restart:
nginx -v # 1.30.7 / 1.31.9, or the fixed distro revision
ls -l /proc/[0-9]*/exe 2>/dev/null | grep -F 'nginx (deleted)' # should be empty
curl -sI https://your-site.example | grep -i '^server:' # if server_tokens is onFrom outside, re-run your scanner, and if you disabled HTTP/2 as a stopgap, turn it back on after patching and confirm ALPN protocol: h2 again. Plenty of teams will forget that last step and quietly lose HTTP/2 for months.
What to watch for in logs
This is the uncomfortable bit. An attack on CVE-2026-123007 leaves almost nothing in access logs. Xint explains why: the WINDOW_UPDATE and RST_STREAM frames that trigger it aren’t logged as requests, and TLS hides them on the wire. So look elsewhere. CIRCL suggests correlating “NGINX worker processes spawning unexpected executables, abnormal worker exits/core dumps, unusual long-lived HTTP/2 connections with large inbound traffic but limited logged requests, and unusual outbound connections or DNS activity.”
Worker crashes:
sudo grep -E 'worker process [0-9]+ exited on signal' /var/log/nginx/error.log
sudo coredumpctl list nginxChildren of workers. There should basically never be any
for w in $(pgrep -f 'nginx: worker'); do pgrep -a -P "$w"; doneLong-lived, receive-heavy connections. Run it twice a minute apart and compare bytes_received:
sudo ss -tinp state established '( sport = :443 )'None of these on its own proves anything. Workers segfault for boring reasons too. But if you find a worker crash next to a multi-gigabyte inbound HTTP/2 connection from one IP, isolate the box, keep the logs, and treat the TLS keys and anything the worker could reach as exposed: reissue certs, rotate credentials.
What I’d tell the team (and what I’m telling myself)
A few lessons from this week, in no particular order.
We didn’t have a reliable inventory of where nginx runs. We had one for hosts. We did not have one for “images that happen to contain nginx”, and that’s where the long tail was: a vendor appliance, a sidecar, two internal tools built FROM nginx:alpine eighteen months ago. Your SBOM or image scanner should be able to answer “which running images contain nginx < 1.30.7” in one query. If it can’t, fix that before the next one.
Floating tags and nginx -v both lie, in different ways. Pin versions in Dockerfiles, and teach people that distro backports keep old version strings. Half the confusion in our channel on Wednesday came from someone seeing “1.18.0” on Ubuntu 22.04 and assuming it was either hopelessly vulnerable or definitely patched. Neither assumption was safe. The package changelog answers the question.
Retired software is a decision, not a default. Everyone knew ingress-nginx was going away in March. Some of us still had it running in November. That’s on us.
And the one I keep coming back to: AI tools did a lot of the finding here. Xint says that after one of its researchers found CVE-2026-123007, “a fully automated Xint scan found the other four without human guidance”. Wiz found both HTTP/2 flaws with its own AI tool, Wiz Atlas. On top of that, several teams found the same flaws independently. Whatever you think about that, the gap between a fix shipping and a working exploit existing was zero days this time. Rapid7’s PoC went up the same morning. Our patch SLAs for internet-facing edge components were written for a slower world. We’re shortening ours.
Close
Patch to 1.30.7 or 1.31.9 (or your distro’s fixed build), restart rather than reload, check every container and ingress controller, and block SCTP on hosts that don’t need it. If you can’t patch today, turn HTTP/2 off and put it back once you have.
A few things are still moving, so expect updates: Ubuntu, Debian, Red Hat and Rocky packages; a CVE and fix for the kernel SCTP flaw; NVD scores; and any KEV listing if exploitation starts. I’ll update this post as those land.
Official references worth bookmarking:
- nginx security advisories: https://nginx.org/en/security_advisories.html
- nginx changes for 1.31.9: https://nginx.org/en/CHANGES
- F5 K000163926 (CVE-2026-123007): https://my.f5.com/manage/s/article/K000163926
- F5 K000163930 (CVE-2026-118899): https://my.f5.com/manage/s/article/K000163930 f5
- CIRCL TR-105: https://www.circl.lu/pub/tr-105/
- Xint NGINX2Root write-up: https://xint.io/blog/nginx2root-remote-code-execution
- Rapid7 CVE-2026-123007 analysis: https://www.rapid7.com/blog/post/ve-cve-2026-123007-critical-nginx-http-2-integer-underflow-leads-to-rce-fixed/
- Wiz write-up: https://www.wiz.io/blog/nginx-http2-rce-vulnerabilities
- Ubuntu tracker: https://ubuntu.com/security/CVE-2026-123007
- Debian tracker: https://security-tracker.debian.org/tracker/CVE-2026-123007
- Red Hat: https://access.redhat.com/security/cve/CVE-2026-123007
- AlmaLinux: https://almalinux.org/blog/2026-11-18-nginx2root/
- Kubernetes ingress-nginx statement: https://kubernetes.io/blog/2026/01/29/ingress-nginx-statement/
F5 NGINX Ingress Controller changelog: https://docs.nginx.com/nginx-ingress-controller/changelog/
Caveats
Distro fix status is changing hour by hour. Everything here was accurate on November 19, 2026, so check your vendor’s tracker before acting. The NGINX Ingress Controller 5.8.0 version question had conflicting reports. F5’s own docs and image checks say 1.31.9, but verify inside your own pods. NGINX Plus R33’s status differs slightly between sources: Wiz and F5’s records list R33 as affected, while Rapid7’s table starts at R34. Either way, there’s no fix for the R-series. CIRCL’s report described 1.31.9 as “scheduled for 19 November”. That was a time-zone artifact, and the release has been on nginx.org since November 18. Finally, the “roughly 140 hosts” and our rollout timings describe our environment, not yours.
Need engineers who stay?
Dedicated developers at $3,500 per developer per month, working your backlog on 2-week sprints with a named technical lead.

