The Patch That Will Never Come: NGINX's HTTP/2 RCEs and Ingress NGINX

When a carmaker issues a safety recall, you take the car to the dealer. What do you do when the dealer closed 8 months ago?
On November 18, F5 fixed 2 unauthenticated remote code execution flaws in NGINX's HTTP/2 implementation. If you run NGINX, you upgrade to 1.30.7 or 1.31.9 and move on. If you run the community Ingress NGINX controller, there is nothing to upgrade to. The project was retired, the repository is archived, and the last release shipped in March.
The recall has been issued, and nobody is left to honor it.
Unauthenticated RCE in Every NGINX That Speaks HTTP/2
Several teams found the same bugs independently, among them Wiz Research, Rapid7, and Xint, who named their work nginx2root. F5 assigned 2 CVEs:
- CVE-2026-123007: an integer underflow in HTTP/2 flow control that becomes an out-of-bounds heap write. Present since NGINX 1.9.5.
- CVE-2026-123633: a use-after-free in HTTP/2 connection handling, reachable in reverse proxy mode. Present since 1.19.7.
F5 rates both 9.2 on CVSS 4.0. Neither requires authentication: the attacker only needs to reach a server with HTTP/2 enabled (for CVE-2026-123633, one acting as a reverse proxy). Wiz kept its exploits private. Rapid7 published a proof of concept.
NGINX 1.9.5, the 2015 release that introduced HTTP/2, already contained the first bug, so it has lived for 11 years in one of the most audited codebases on the internet.
Vulnerable by Default, Exposed by Definition
Ingress NGINX ships its own NGINX, version 1.27.1. Both CVEs affect it, and patching your nodes does nothing. HTTP/2 is on by default, and an ingress controller is usually the reverse proxy you expose to the internet.
Affected version, HTTP/2 on, reachable: 3 conditions, all met out of the box, in every release. Credit where it is due: as of November 18, the Chainguard and Rancher forks backported both fixes within hours. Look at how, though: each now carries about 18 hand-written security patches on top of a 2024 NGINX. And the community image, the one most clusters run, gets nothing.
Here is the stopgap. Apply it before you read the rest. If you installed with the Helm chart, set controller.config.use-http2: "false" in your values instead, or the next helm upgrade reverts your edit:
apiVersion: v1
kind: ConfigMap
metadata:
name: ingress-nginx-controller
namespace: ingress-nginx
data:
use-http2: "false"It breaks gRPC, which requires HTTP/2 end to end, costs everyone else performance indefinitely, and closes far less than you think.
31 Unpatched CVEs
The 2 CVEs in the headlines are only part of the bill.
32 NGINX security advisories include version 1.27.1. The patch directory of the image shows exactly one security backport, CVE-2025-23419. That leaves 31 NGINX CVEs with no fix in the last community release, v1.15.1.

Not all 31 are reachable. 9 are in modules the image does not compile. 12 are in features that are off by default, and a configuration snippet can enable several of them: the same escape hatch that gave us IngressNightmare. 10 are in code the controller uses every day: HTTP/2, TLS 1.3, rewrites, and gRPC and HTTPS backends. You cannot turn these off without breaking the traffic they carry.
That ledger only counts NGINX. The controller's own code has an open entry too. On November 5, the Kubernetes Security Response Committee published CVE-2026-116472: the mirror-target annotation can reach an unauthenticated configuration API inside the controller and drop all traffic. It is rated low, because the attacker needs permission to create an Ingress. But read the advisory's own words:
"Kubernetes will not be issuing a fix for this CVE, because ingress-nginx maintenance ended in March 2026."
The issue carries the label cve/wontfix. It is the first wontfix CVE for the controller, and it will not be the last.
It gets worse. The nginx2root team chained the HTTP/2 bug with a Linux kernel SCTP (Stream Control Transmission Protocol) flaw to go from one network request to root on the host, from inside a container. Your ingress pod holds the TLS keys for every hostname in the cluster. With the chart's default ClusterRole, its service account can also list Secrets in every namespace.
3 Out of 4 Are Memory Bugs

Now count the ledger by type. 23 CVEs out of 31 are memory-safety bugs, mostly use-after-free and buffer overflows. Only 8 are logic flaws.
The NGINX developers are among the best C programmers in the world, and C still produces these bugs at a steady rate, in expert hands, for decades.
A memory-safe language removes the category behind those 23 bugs. In Go code that avoids the unsafe package, the garbage collector owns the lifetime of every object, so use-after-free cannot be expressed. Every slice access is bounds-checked, so a write past the end of a buffer does not corrupt the heap: the program stops.
Traefik has CVEs. Rapid Reset affected Go's HTTP/2 stack, and us with it. However, a malformed WINDOW_UPDATE frame in Go gets you a rejected connection, at worst a panic. It does not get you a write primitive into the heap. The bug exists, and its worst case is a denial of service.
That is why I chose Go for Traefik 10 years ago. A reverse proxy parses hostile input all day, and I did not want that parser to be one arithmetic mistake away from a shell.
A second difference is simpler than the language. When someone finds a CVE in Traefik, a team fixes it and ships a release. Every serious project has CVEs, and what matters is the day after: for Traefik, a patch; for Ingress NGINX, a ledger that can only grow.
Same YAML, Different Engine
Knowing you should leave is easy. Many clusters still run Ingress NGINX because leaving looked like a multi-quarter rewrite, and an active RCE is the worst time to rewrite your routing layer.
So we removed the need to rewrite. Traefik's Ingress NGINX provider reads your existing Ingress resources and their nginx.ingress.kubernetes.io annotations natively, more than 85 of them. Your manifests, Helm charts, and GitOps repositories stay as they are.
Annotations map directly onto Traefik's internal object model, with no generated config file in between. No template exists, so there is no template injection. Snippets go through an interpreter that understands a curated set of directives. You keep the behavior and lose the attack surface.
Migration takes 3 steps:
- Assess. Run the migration tool. In minutes, you know which Ingresses work as they are.
- Switch. Deploy Traefik next to NGINX. Both serve the same Ingresses. Shift traffic progressively, then decommission.
- Evolve, later. Move to Gateway API on the same instance, one route at a time. No deadline.
IBM Cloud, Nutanix, OVHcloud, SUSE, and TIBCO made this choice before these CVEs were disclosed.
Distro Zero: Nothing Left to Exploit
Memory safety in the binary is only half of the picture.
The other half is what ships next to it: a base distribution, a libc, OpenSSL, a shell, and a package manager. Each is somebody else's CVE feed that becomes yours. In July, we shipped Distro Zero, the Traefik hardened image. It contains one static, memory-safe Go binary. It has no shell, no libc, no OpenSSL, and no distribution layer.
Think about the nginx2root chain. After the first bug lands, the attacker needs something to work with. In an image with no shell and no second executable, they find an empty room.
The same logic applies to cryptography. Many FIPS-compliant proxies delegate to a C system library. In Distro Zero, FIPS 140-3 is enforced inside the binary, through the Go Cryptographic Module, validated under Cryptographic Module Validation Program (CMVP) certificate #5247.
None of this was built in response to these CVEs. Security posture is what you did in the years before the disclosure.
What to Do Now
- Mitigate: set use-http2: "false". If you front gRPC, restrict network access to the controller instead. Either way, you closed 2 CVEs out of 31.
- Investigate: look for any unexpected NGINX worker crash or process spawned by NGINX.
- Migrate: run the migration tool, deploy Traefik alongside, move traffic. Your Ingress resources do not change.
- Restore: turn HTTP/2 back on, now that your ingress is maintained.
The NGINX team did their job: a fix shipped with the disclosure. That is what a maintained project looks like. Ingress NGINX is not one. A fork can backport patches. It cannot fix the architecture.
You cannot patch an archived repository. You can only leave it.
Ready to move?
- Run the migration tool: know in minutes which Ingresses work as they are.
- Read the migration guide: deploy Traefik next to NGINX and cut over with zero downtime.
- Get Distro Zero: one memory-safe binary, FIPS 140-3 inside.
- Talk to us: we will help you plan the migration.



