Two Critical NGINX Vulnerabilities Allow Code Execution via HTTP/2

F5 has patched two critical NGINX HTTP/2 vulnerabilities that could allow unauthenticated code execution on the server. Administrators should check their versions and update affected instances.

· 4 min read · 5 comments

On November 18, 2026, F5 released fixes for two critical NGINX vulnerabilities that could allow unauthenticated code execution on the server. According to Wiz, which discovered the issues alongside Ikotas Labs, Metnir, Rapid7, and Xint, both bugs involve HTTP/2 handling. NGINX itself is at risk, even if the website code behind it is secure. Owners of affected servers should check their NGINX version and whether HTTP/2 is enabled, then install a patched release.

Where the bugs occur and how they differ

Both vulnerabilities require HTTP/2 to be enabled, but the conditions for exploitation differ. CVE-2026-123633 is a use-after-free bug: NGINX may consider a connection safe to close even though it is already processing a request received through that connection. When available connections run low, the server may close it and free memory that request processing still needs to access. This scenario applies to NGINX configured as a reverse proxy.

CVE-2026-123007 involves HTTP/2 flow-control accounting. An error in a counter can lead to an incorrect memory copy. This one does not require an application behind NGINX: researchers confirmed code execution on a server serving ordinary static files over HTTPS, without third-party modules.

Both issues received a CVSS 4.0 score of 9.2. A successful attack could allow an attacker to execute code on the server, steal data, modify websites, or disrupt services. NGINX’s role as a shared entry point makes this particularly concerning: one instance may serve several websites and APIs. Checking only the application behind the proxy is not enough here.

Affected versions and fixes

For NGINX OSS, CVE-2026-123007 affects versions 1.9.5 through 1.31.8, while CVE-2026-123633 affects versions 1.19.7 through 1.31.8. According to the researchers, the first bug had been in the code since 2015; the second had been there for almost six years. For both, the listed fixed releases are 1.30.7 in the stable branch and 1.31.9 in the mainline branch.

In Wiz’s table, both NGINX Plus vulnerabilities are listed as affecting releases starting with R33 and 37.0.0, but the fixed releases differ. For CVE-2026-123633, they are 37.0.7.1 and 37.2.0.1; for CVE-2026-123007, they are 37.0.8.1 and 37.3.0.1. When updating Plus, it is therefore important to check that the chosen release addresses both issues rather than relying on a fix for only one.

F5’s release also fixes other NGINX bugs. These include critical vulnerabilities involving HTTP/3, the DNS resolver, and the mail proxy. But their exploitation conditions differ: for example, the DNS resolver bug requires an attacker to control the upstream host name. It would be wrong to treat every item in the update as the same attack scenario affecting any server.

What to check on live websites

Website owners and administrators should first identify where NGINX is in use, which versions are running, and whether HTTP/2 is enabled. Prioritize instances an attacker can reach. Then install a patched release and check that the websites and APIs it serves still work. If one NGINX instance handles traffic for several projects, it is better to plan the update for that entire group rather than treat each website separately from the shared server.

If an immediate update is not possible, the temporary measure described by Wiz is to disable HTTP/2 on affected instances. Starting with NGINX 1.25.1, this means adding http2 off; to the relevant server blocks and removing the http2 parameter from listen directives. After changing the configuration, check application compatibility, reload NGINX, and make sure the old worker processes have exited. HTTP/2 can be re-enabled after the fix is installed.

Unexpected NGINX worker process crashes or commands launched by NGINX processes warrant investigation. The researchers describe these as general warning signs, however, not confirmation that either of these two vulnerabilities has been exploited. The absence of such signs is no substitute for checking the version and configuration.

My take: the risk lies at the shared entry point

I wouldn’t reduce this news to “update your web server.” The catch is that a team can review its own code carefully and still miss a vulnerability in front of it. That is especially true when one NGINX instance serves several products: the impact of a mistake depends not just on the number of servers, but on how many services run through them.

At the same time, I wouldn’t call every NGINX instance equally vulnerable: HTTP/2, the version, and, for one of the bugs, whether it acts as a proxy all matter. The sensible response is to establish those facts quickly, choose an appropriate patched release, and verify the result. Disabling HTTP/2 is useful as a temporary measure, not as a substitute for an update that is easy to forget once the urgency fades.

Sources

Where the news comes from. The text is a retelling in the author’s own words; the facts come from the source, the opinion is the author’s.

  1. Pre-auth RCE in Nginx HTTP/2 handling www.wiz.io

About the author

Nicolae Nistor

senior full-stack developer

For over ten years, I’ve been designing web services and examining other people’s solutions for hidden maintenance costs. In my free time, I see how many dependencies I can remove without losing functionality.

All posts by the author

Leave a comment

Not published. We’ll send a link to confirm your comment.

No links or ads. Your first comment is published after review. By sending a comment you agree to the privacy notice.

  1. Do you recommend treating every HTTP/2-enabled NGINX instance as an incident until patched, or is there a practical way to distinguish exposed systems from those merely running an affected build?

    1. I wouldn’t call every affected HTTP/2 instance an incident in the sense of confirmed compromise, but I would treat it as an urgent exposure until patched. The practical distinction is whether HTTP/2 is actually enabled on the NGINX listener and whether the running build is affected; that tells you about reachability, not whether anyone exploited it. Check logs and host integrity for signs of abuse, but don’t use a lack of obvious indicators as a reason to delay upgrading. Is HTTP/2 terminated directly on your NGINX hosts, or upstream at a load balancer?

      1. @nikita.nistor, I’ve seen the same split in production: HTTP/2 terminated at the load balancer, while NGINX only handled HTTP/1.1 on the backend. In that setup, the NGINX listener’s configuration mattered more than the public site’s protocol indicator, so I’d verify the actual upstream hop before prioritizing hosts. We still patched every affected build, but mapping where TLS and HTTP/2 terminate made the exposure review much faster.

  2. Do the affected-version checks depend only on the NGINX build, or should admins also verify how HTTP/2 is enabled in their config? It would help to know what to check on a live instance before scheduling the update.

    1. Check both: the exact NGINX build determines whether it’s affected, while the live config tells you whether HTTP/2 is enabled and therefore whether the exposure condition applies; config review is not a substitute for upgrading.