TL;DR
Two critical remote code execution flaws in the HTTP/2 implementation of NGINX were disclosed today. This page tracks what is public, explains what it means for the NGINX servers you run, and shows how Miggo can protect you while you upgrade.
Last updated: November 18, 2026, 18:56 IST. This page is updated on a rolling basis as new details become public.
The Short of It
- Two memory corruption vulnerabilities in NGINX, CVE-2026-123633 and CVE-2026-123007, were disclosed today (November 18, 2026) together with a security release from F5.
- Both are rated 9.2 under CVSS 4.0, require no authentication and affect servers that have HTTP/2 enabled.
- Researchers have demonstrated reliable remote code execution, with ASLR defeated, against an NGINX server that only serves static files, with no backend application and no third-party modules.
- Miggo customers can stop this exploit without patching using Miggo's in-app sensor detection and blocking.
- Miggo Mitigation Lab found that a WAF rule cannot reliably block either vulnerability, which makes protection inside the running environment essential until you upgrade.
- The exploit conditions mean modern deployments are less likely to be affected.
- No exploitation in the wild has been reported as of publication.
What Are the NGINX HTTP/2 Vulnerabilities?
NGINX is the most widely used open-source web server in the world, and Netcraft's September 2026 survey counts more than 225 million websites running on it. It sits at the front door of modern applications as a web server, reverse proxy, load balancer and Kubernetes ingress controller.
Both flaws are in the way NGINX handles HTTP/2 connections. CVE-2026-123007 is an integer underflow in the HTTP/2 flow-control window calculation (CWE-191) that leads to a heap buffer overflow. CVE-2026-123633 is a use-after-free, in which NGINX frees the memory of an HTTP/2 connection while a request on that connection is still using it. What makes these flaws different from most web vulnerabilities is where they live. NGINX processes every request before any application code, authentication or business logic runs, so an attacker does not need a vulnerable application behind it. Even more viciously, because of its prominence as a Kubernetes ingress controller, regular SCA may not show you where you have nginx deployed.
What Is Public So Far
Why the NGINX HTTP/2 Flaws Will Be Hard to Patch Quickly
Upgrading an application dependency is a routine change for most engineering teams. Upgrading the web server that sits in front of every application is a larger job, and NGINX tends to be in more places than any single team knows about.
First, NGINX is everywhere, and many instances are hard to see. It runs as the ingress controller in Kubernetes clusters, it is baked into container base images, it is installed through operating system packages and it is embedded inside commercial products and appliances. A dependency scan of your application code will not find it.
Second, fixed builds arrive on different schedules. Teams that install NGINX from Debian, Ubuntu, Red Hat or Alpine repositories need to wait for their distribution to ship a backported fix, and pinned container images and Helm charts keep vulnerable versions alive until someone rebuilds them.
Third, the fastest workaround has a cost. Disabling HTTP/2 removes the attack surface, but it can slow down sites that rely on HTTP/2 multiplexing and it breaks services that depend on HTTP/2 end to end, such as gRPC. Many teams will not be able to switch it off everywhere without testing first.
The result is a gap between the moment the vulnerabilities are public and the moment every exposed server is running a fixed build. Attackers tend to move fastest in exactly that gap.
Which of Your Servers Are Actually Exposed?
Knowing that you run NGINX is not enough to plan a response. Four questions decide whether a given server is at risk: whether it runs an affected version, whether HTTP/2 is enabled, whether attackers can reach it directly and, for CVE-2026-123633, whether it opens upstream connections through proxy_pass, subrequests or upstream resolution.
Miggo answers those questions from runtime evidence. Using DeepTracing™, Miggo maps the NGINX instances that are actually running in your environment, the versions they are running on and how they are exposed. That lets your team start the rollout with the internet-facing servers that matter most, instead of working through an inventory of every NGINX installation.
CVE-2026-123007 is the broader of the two, because it needs nothing beyond HTTP/2 and works against a server that only serves static files. Start the rollout with internet-facing servers that accept HTTP/2 directly.
We have found that the real-world scenarios for exploitation are narrower for customers using a modern stack. Because the vulnerabilities require a massive amount of traffic to be sent to the nginx server directly, any layer-7 proxy or load balancer between nginx and the wider internet severely hampers the ability to exploit the vulnerability. More robust setups include but aren’t limited to:
- Running behind a WAF like Cloudflare, AWS WAF, Akamai, and others.
- Fronting nginx behind a load-balancer like Envoy or HAProxy,
- Exposing nginx through your cloud’s TLS-terminating LB, such as AWS ALB.
As mentioned above, even when running servers behind another layer, care must be taken that nginx is not directly exposed through other means. Miggo customers can use Miggo’s AppDNA to detect such instances.
How Miggo Protects You Before the Patch
The Miggo Mitigation Lab analyzed both NGINX flaws and ruled out mitigating this vulnerability with a Web Application Firewall (WAF) rule. Instead, the Miggo Mitigation Lab was able to generate a Miggo Sensor rule to protect against these flaws from inside the running environment. Miggo's in-app sensor blocks this exploit where it executes, so protection is in place without configuration changes to NGINX and without waiting for every server to be upgraded. This ability to triage the vulnerability and determine at what layer or layers it is mitigable, is Defense-in-Depth in practice.
What to Do Now
- Find every NGINX instance in your environment, including ingress controllers, container base images, distribution packages and NGINX embedded inside other products.
- Check which instances have HTTP/2 enabled, and prioritize the internet-facing ones that accept HTTP/2 directly.
- Upgrade to NGINX 1.30.7 or 1.31.9, the fixed NGINX Plus releases, or your distribution's patched package as soon as it is available.
- Reload NGINX, confirm that old worker processes have exited and verify the version the running server reports, not only the version that is installed.
- If you cannot upgrade right away, put a runtime mitigation in place or disable HTTP/2 temporarily by setting http2 off; (NGINX 1.25.1 and later) or removing the http2 parameter from listen directives. Test services such as gRPC first.
- Watch for unexpected NGINX worker crashes, commands launched by NGINX processes and long-lived HTTP/2 connections that send unusually large amounts of data.
Get Protected While You Patch
Miggo can show you which of your NGINX servers are exposed to CVE-2026-123633 and CVE-2026-123007 and protect them while your team rolls out the fix.
If you’re concerned about these NGINX vulnerabilities, our team can help you find exposed servers and put protection in place right away. Contact us here
This page is updated on a rolling basis. Check back for new details as they become public.



