Two critical HTTP/2 vulnerabilities in NGINX could allow remote attackers to execute code on vulnerable web servers without authentication, even when the websites and applications running behind them have no known security flaws.
The vulnerabilities, tracked as CVE-2026-123633 and CVE-2026-123007, were publicly disclosed on November 18, 2026, following coordinated research involving Wiz, Ikotas Labs, Metnir, Rapid7 and Xint.
Researchers demonstrated remote code execution using both vulnerabilities. Successful exploitation could give an attacker access to the NGINX server, potentially exposing application data, website content and other services that share the same infrastructure.
F5 and the NGINX project released corrected NGINX Open Source versions 1.30.7 (stable) and 1.31.9 (mainline) on November 18. NGINX Plus customers must select the appropriate commercial build because the two flaws have different first-fixed versions.
Both vulnerabilities require HTTP/2 to be enabled on the affected server, but the additional conditions are different. One involves reverse-proxy behavior under connection pressure. The other can affect a server that only delivers static website files.
The immediate recommendation: Identify NGINX instances accepting HTTP/2, confirm the actual installed and running versions, and install a release that fixes both vulnerabilities. If upgrading must be delayed, temporarily disabling client-facing HTTP/2 can reduce exposure.
NGINX HTTP/2 Vulnerabilities: Key Facts
- Disclosure date: November 18, 2026.
- Affected software: Vulnerable versions of NGINX Open Source and NGINX Plus.
- CVE identifiers: CVE-2026-123633 and CVE-2026-123007.
- Researchers’ severity assessment: Critical, CVSS v4.0 score 9.2 for each vulnerability.
- NGINX advisory classifications: Medium for CVE-2026-123633 and major for CVE-2026-123007.
- Vulnerability types: HTTP/2 use-after-free and HTTP/2 flow-control integer underflow.
- Potential impact: Memory corruption, worker-process failure and unauthenticated remote code execution under demonstrated conditions.
- Required feature: HTTP/2 must be enabled for client connections to the affected NGINX server.
- Fixed NGINX Open Source versions: 1.30.7 stable and 1.31.9 mainline.
- Public exploitation status: Successful researcher demonstrations; no confirmed real-world exploitation campaign established by the cited disclosures.
Why These Two NGINX Security Flaws Matter
NGINX is commonly deployed at the front of web applications, API platforms and enterprise infrastructure.
For example, a company might use one NGINX reverse proxy to receive HTTPS traffic for several services: a customer website, an internal application portal and an API used by mobile applications.
The applications behind the proxy could be fully patched and securely coded. That would not necessarily protect them from a vulnerability in the NGINX server handling their incoming connections.
This is what makes the November disclosure significant.
Both vulnerabilities exist in NGINX’s own HTTP/2 processing rather than in application code supplied by a website operator.
The research demonstrates that an attacker may reach vulnerable memory-handling functionality by sending specially constructed network traffic to an HTTP/2-enabled server.
If that attack achieves code execution, the consequences depend on the privileges available to the NGINX worker process and the environment around it.
Possible outcomes include access to information available to the compromised process, unauthorized changes, additional investigation of neighboring systems or service disruption.
A successful exploit does not automatically mean an attacker has root privileges or unrestricted access to every backend application.
For organizations tracking related risks across server software, our CVE Vulnerabilities and Enterprise Security Hub provides additional patching and remediation coverage.
CVE-2026-123633: HTTP/2 Use-After-Free Vulnerability
CVE-2026-123633 involves a use-after-free condition in NGINX’s handling of HTTP/2 connections.
To understand the problem, consider how a busy web server manages its available network connections.
NGINX can mark certain connections as reusable when they appear to be idle. If available connection slots become scarce, it may close reusable connections to make room for new activity.
Researchers found a condition in which an HTTP/2 connection can remain incorrectly marked as reusable while a request is being processed.
When the server subsequently closes that connection and releases its memory, the ongoing request may still reference data that no longer belongs to it.
This is a use-after-free vulnerability.
Memory allocated to the previous connection can be reused for other operations. Continuing to interpret that memory as the original connection data may cause corruption or unintended program behavior.
Wiz researchers demonstrated how the issue could progress beyond a worker crash to remote code execution under suitable conditions.
Who Is Exposed to CVE-2026-123633?
This issue is especially relevant to affected NGINX reverse proxies that accept HTTP/2 requests from clients and forward traffic to backend servers.
The reported exploitation path also depends on conditions involving available connection slots and the handling of reusable connections.
Therefore, the mere presence of NGINX does not prove that a particular deployment meets every condition required for successful exploitation.
However, an internet-facing reverse proxy running an affected version with HTTP/2 enabled should be investigated and patched promptly.
CVE-2026-123007: HTTP/2 Flow-Control Memory Corruption
CVE-2026-123007 involves a different weakness in HTTP/2 flow-control accounting.
HTTP/2 uses flow-control mechanisms to coordinate how much data can be transmitted across connections and streams.
These mechanisms help prevent a sender from overwhelming a receiver with more data than it is prepared to handle.
Researchers discovered that incorrect accounting of a flow-control value could cause an integer underflow.
That underflow could subsequently result in an invalid memory-copy operation and memory corruption.
Unlike CVE-2026-123633, this vulnerability does not require NGINX to operate as a reverse proxy in the demonstrated attack scenario.
Wiz researchers reported achieving remote code execution against an NGINX instance serving ordinary static files over HTTPS on a 64-bit system.
That distinction is important: A server hosting a basic HTML website can still require remediation if it uses an affected NGINX version with HTTP/2 enabled.
The affected code dates back to NGINX 1.9.5, released in 2015. This means the underlying issue existed for more than a decade before coordinated disclosure in November 2026.
How the Two NGINX HTTP/2 Vulnerabilities Differ
| Feature | CVE-2026-123633 | CVE-2026-123007 |
|---|---|---|
| Technical issue | HTTP/2 use-after-free | HTTP/2 flow-control integer underflow |
| First affected Open Source version | 1.19.7 | 1.9.5 |
| HTTP/2 required | Yes | Yes |
| Additional conditions | Reverse-proxy processing and connection-resource pressure | Can affect ordinary static-file serving |
| Researcher CVSS v4.0 score | 9.2 | 9.2 |
| NGINX advisory severity | Medium | Major |
| Security impact demonstrated by researchers | Remote code execution | Remote code execution |
The different severity labels reflect differences between the research assessment and NGINX’s own advisory classification. Administrators should evaluate the verified technical impact and their deployment exposure rather than relying on a single label alone.
Which NGINX Versions Are Vulnerable?
The official NGINX security advisories and coordinated researcher disclosure identify the following Open Source version ranges.
| Vulnerability | Affected NGINX Open Source versions | First fixed versions |
|---|---|---|
| CVE-2026-123633 | 1.19.7 through 1.30.6; 1.31.0 through 1.31.8 | 1.30.7 stable / 1.31.9 mainline |
| CVE-2026-123007 | 1.9.5 through 1.30.6; 1.31.0 through 1.31.8 | 1.30.7 stable / 1.31.9 mainline |
NGINX officially released the corrected Open Source builds on November 18, 2026.
The release also contains fixes for other security issues, including problems in the resolver, HTTP/3 processing, TLS-related request handling and additional modules.
For supported Open Source deployments, moving to version 1.30.7 or 1.31.9 addresses both HTTP/2 vulnerabilities covered in this report.
When using distribution-maintained NGINX packages, administrators should check the vendor’s package-level security advisory. Linux distributions may backport a fix while retaining an older upstream version number.
NGINX Plus: Which Commercial Builds Fix Both CVEs?
NGINX Plus has different fixed-build requirements for the two vulnerabilities.
This is an important detail because an update that addresses one CVE may not necessarily fix the other.
| NGINX Plus vulnerability | First fixed builds identified by researchers |
|---|---|
| CVE-2026-123633 | 37.0.7.1 and 37.2.0.1 |
| CVE-2026-123007 | 37.0.8.1 and 37.3.0.1 |
For an organization seeking protection against both vulnerabilities, the practical target is a supported commercial release that incorporates both corrections, such as the specified 37.0.8.1 or 37.3.0.1 builds.
Customers running older NGINX Plus R-series releases should consult the relevant F5 advisory for supported upgrade paths.
Organizations using NGINX Ingress Controller, distribution packages, appliances or other bundled NGINX software should identify the actual embedded NGINX version and consult that product’s vendor guidance.
A version number from NGINX Open Source should not automatically be applied to every commercial product.
How to Check Your NGINX Version and HTTP/2 Exposure
Security teams should assess both the NGINX version and whether an affected listener actually accepts HTTP/2 connections.
Step 1: Check the Installed NGINX Version
On the relevant Linux server, run:
nginx -vThis displays the NGINX version reported by the executable being invoked.
For additional build information, use:
nginx -VThe detailed output can help administrators identify compilation options and available modules.
Remember that multiple NGINX installations, containers or vendor-packaged instances may exist in the same environment.
Step 2: Review the Active Configuration
To display the active configuration and included configuration files, use:
nginx -TReview HTTP/2 directives and HTTPS listener settings, particularly configurations using http2 on; or older listen directives containing the http2 parameter.
Because configuration files may contain sensitive paths and settings, their output should be handled appropriately.
Step 3: Check the Negotiated Protocol
From an authorized testing system, HTTP/2-capable clients can help determine which protocol a web endpoint negotiates.
For example:
curl -sS -o /dev/null -w '%{http_version}\n' --http2 https://example.com/Replace the example domain with a service you are authorized to assess.
If the result is 2, the tested endpoint negotiated HTTP/2.
However, a public website may be served through a CDN, load balancer or other intermediary. In that situation, the result describes the connection to the intermediary, not necessarily the protocol enabled on the NGINX origin server.
Administrators should inspect and test each relevant network layer rather than assume the public site’s result describes the origin configuration.
Step 4: Include Containers and Kubernetes Deployments
Review container images and deployed workloads that run NGINX or package it within another product.
For Kubernetes-based systems, inspect the NGINX implementation and version actually deployed by the relevant ingress or application component.
Updating the Kubernetes worker node does not automatically replace an affected NGINX binary inside a container.
How to Patch NGINX Without Breaking Production Websites
Security updates for a web server require careful deployment because NGINX may sit in front of business-critical applications.
However, testing requirements should not become an excuse to leave exposed HTTP/2 infrastructure vulnerable indefinitely.
- Inventory: Identify all NGINX Open Source, NGINX Plus and vendor-bundled deployments, including cloud instances, reverse proxies, Kubernetes workloads and static web servers.
- Confirm HTTP/2 exposure: Review client-facing listeners and determine where the vulnerable protocol is enabled.
- Select the right fix: Use 1.30.7 or 1.31.9 for the relevant Open Source branch, or a commercial build fixing both CVEs.
- Prepare backups and rollback: Preserve approved configuration backups and test application compatibility in a representative environment.
- Upgrade: Install the verified vendor-supported package or rebuild the affected application image.
- Test configuration: Run
nginx -tto identify configuration syntax errors before applying changes. - Activate the corrected binary: Restart the service, perform the documented executable upgrade procedure or redeploy replacement containers as appropriate.
- Verify: Confirm the running NGINX version, browser and API functionality, and expected server health.
One operational mistake to avoid is installing a patched package but continuing to run the older NGINX executable.
A configuration reload does not automatically replace the executable image of every running worker process. Administrators should use their platform’s supported binary-update procedure and confirm the corrected version is active.
Temporary Mitigation: Disable HTTP/2 If Patching Is Delayed
Both November vulnerabilities depend on client-facing HTTP/2 support.
If a corrected build cannot immediately be deployed, temporarily disabling HTTP/2 on affected NGINX listeners can reduce exposure.
On NGINX versions supporting the newer directive, beginning with 1.25.1, administrators can use:
http2 off;This directive belongs in an appropriate HTTP or server configuration context.
Also remove the HTTP/2 parameter from applicable listen directives. On older NGINX versions, removing that parameter is the relevant way to disable the protocol.
After making the configuration changes:
- Review the relevant server blocks and confirm HTTP/2 is disabled where required.
- Run
nginx -tto validate the configuration. - Reload NGINX using the platform’s approved procedure.
- Confirm that older workers have exited and the updated configuration is active.
- Test affected applications, including browser connections, API clients and integrations.
- Check the negotiated protocol from the relevant network path.
Disabling HTTP/2 may change performance and connection behavior for some applications. Organizations should evaluate those operational effects.
This is a temporary mitigation, not a permanent fix. The vulnerable code remains in the installed software until the correct security update is applied.
After upgrading and verifying the patched release, teams can re-enable HTTP/2 according to normal change-management procedures.
Why October’s NGINX Security Update Is Not Enough
NGINX issued an earlier security update on October 14, 2026, addressing five different vulnerabilities.
Those fixes included memory-safety problems involving asynchronous I/O, configuration script evaluation and certain alias/rewrite operations.
The corrected Open Source builds for that release were 1.30.6 stable and 1.31.7 mainline.
CyberUpdates365 covered the original fixes in our October NGINX vulnerabilities and patching analysis.
The new HTTP/2 vulnerabilities are different.
NGINX Open Source versions 1.30.6 and 1.31.7 can still be affected by the November issues. Even the later 1.31.8 release is identified as vulnerable.
Therefore, an organization that installed October’s patches should not assume that its NGINX deployment is protected against CVE-2026-123633 and CVE-2026-123007.
Security teams need to confirm the November fixes independently.
Does Secure Application Code Protect Against These Flaws?
No. Secure application code is important, but it cannot repair a vulnerability in the NGINX server processing incoming HTTP/2 connections.
Consider a WordPress website or a PHP application hosted behind NGINX.
The application might have no known security vulnerability, yet the reverse proxy in front of it could still contain one of these HTTP/2 memory-safety defects.
The reverse situation can also occur: NGINX may be patched while the application runtime behind it remains vulnerable.
These are separate security layers.
For an example involving the application runtime rather than the web server, see our earlier PHP2Shell remote code execution investigation. That report concerns PHP vulnerabilities, not the November NGINX flaws.
This distinction is useful when building a patch inventory. Web server, application runtime, dependencies, operating system and container images can each require their own security updates.
Is There Evidence of Active Exploitation?
Wiz and other researchers independently discovered and reported the vulnerabilities, and the research team demonstrated unauthenticated remote code execution.
That establishes technical exploitability under the demonstrated conditions.
However, the cited November 18 public disclosures do not confirm a widespread criminal exploitation campaign or identify specific organizations compromised through either CVE.
Researcher demonstrations should not be confused with verified attacks in production environments.
The absence of a confirmed public exploitation report also does not prove that no exploitation has occurred.
Organizations should therefore treat the findings seriously, prioritize exposed deployments and monitor reputable vendor and incident-response sources for any new exploitation evidence.
What Security Teams Should Monitor
The research identifies several investigation areas that may help defenders spot suspicious activity or assess the condition of an exposed NGINX deployment.
- Unexpected worker crashes: Repeated NGINX worker failures or restarts without an established operational explanation.
- Unusual child processes: Shell commands or other unexpected programs launched by NGINX processes.
- Abnormal HTTP/2 connection behavior: Unusual long-lived sessions, repeated protocol errors or anomalous flow-control behavior where suitable telemetry is available.
- Configuration changes: Unauthorized changes to NGINX configuration files or binaries.
- Suspicious outbound traffic: Network connections from web servers to unexpected destinations.
- Post-compromise indicators: Unexpected files, processes, credentials or administrative activity on the affected host.
These are general defensive investigation priorities, not confirmed unique indicators of compromise for either CVE.
If an exposed NGINX instance shows signs of compromise, preserve relevant evidence and investigate before concluding that installing the patch alone has resolved the incident.
Why AI-Assisted Research Matters in This Disclosure
Wiz reported using AI-assisted code-analysis tools during the investigation, including its Wiz Atlas research tooling.
The findings are notable because one vulnerability dates back to 2015, while the other existed for several years before discovery.
Memory-safety flaws can be difficult to identify because the conditions leading to corruption may involve interactions across multiple internal code paths.
AI-assisted analysis may help researchers investigate those interactions more efficiently.
However, the use of AI in the research does not establish that attackers used AI to exploit production NGINX servers.
It also does not mean AI independently discovered every vulnerability without human guidance.
The confirmed development is that researchers used additional analysis capabilities to identify and validate serious weaknesses in widely deployed software.
CyberUpdates365 Analysis: What US Businesses Should Prioritize
The November NGINX disclosure highlights a security problem that can easily be overlooked when organizations focus primarily on application-level vulnerabilities.
A business may invest in secure coding, vulnerability scanning and application firewalls while still relying on an outdated web server at the edge of its infrastructure.
That edge server may process traffic for several otherwise secure applications.
The wide version range of CVE-2026-123007 also means older deployments and seemingly simple static websites deserve attention.
For US enterprises, cloud hosting providers, software-as-a-service operators and small businesses, the practical priorities are:
- Maintain an accurate inventory of internet-facing NGINX servers and their owners.
- Record whether client-facing HTTP/2 is enabled on each deployment.
- Track actual patch status across Open Source, commercial and vendor-bundled installations.
- Use supported fixed builds rather than assuming October’s updates are sufficient.
- Temporarily restrict vulnerable protocol functionality when immediate remediation is operationally impossible.
- Verify the updated executable is running and continue monitoring for suspicious behavior.
The most useful question is not simply whether an organization uses NGINX.
It is whether any reachable NGINX instance still runs affected HTTP/2 code, and how quickly that exposure can be removed.
Frequently Asked Questions
What are the new NGINX HTTP/2 vulnerabilities?
CVE-2026-123633 and CVE-2026-123007 are two memory-safety vulnerabilities disclosed on November 18, 2026. Researchers demonstrated that each could allow unauthenticated remote code execution under the relevant conditions.
Which NGINX versions fix both vulnerabilities?
NGINX Open Source 1.30.7 stable and 1.31.9 mainline contain fixes for both. NGINX Plus customers should select a commercial build covering both CVEs, including the appropriate 37.0.8.1 or 37.3.0.1 releases.
Is CVE-2026-123007 more widely applicable?
It has a broader affected-version history and was demonstrated against an NGINX server serving static files without a backend application. Actual exposure still requires the affected software and HTTP/2 configuration.
Are the NGINX flaws actively exploited?
Researchers confirmed code execution in testing, but the cited public disclosures did not establish a real-world exploitation campaign as of November 18, 2026.
Does disabling HTTP/2 fix the vulnerabilities?
No. Disabling client-facing HTTP/2 can temporarily reduce exposure to the two vulnerable paths, but the underlying flaws remain until corrected software is installed.
How do I check whether my NGINX server supports HTTP/2?
Review active NGINX configuration using nginx -T and inspect the relevant listener settings. Authorized client tests can also help verify the negotiated protocol, but CDN and proxy layers must be considered.
Is NGINX 1.30.6 still safe after the October security update?
It contains October’s fixes but is affected by the November vulnerabilities. Organizations using the standard Open Source branch should update to 1.30.7 or another supported release containing the corrections.
Does this affect WordPress or other websites hosted behind NGINX?
It can. The vulnerabilities are in NGINX’s HTTP/2 handling, so exposure does not require a flaw in WordPress or another backend application. The server version and configuration determine applicability.
Final Takeaway
NGINX’s November 18, 2026 security release fixes two serious HTTP/2 vulnerabilities that researchers demonstrated could enable unauthenticated remote code execution.
CVE-2026-123633 involves unsafe handling of HTTP/2 connection memory, while CVE-2026-123007 affects HTTP/2 flow-control accounting and can reach servers delivering ordinary static content.
Organizations running affected NGINX deployments should prioritize updating to the corrected Open Source or NGINX Plus releases and verify that all relevant instances are using the patched binaries.
Where upgrades cannot be completed immediately, temporarily disabling HTTP/2 may reduce exposure while remediation is prepared.
For administrators, the priority is clear: identify HTTP/2-enabled NGINX deployments, apply the November security fixes and validate protection in the running environment.
Official Sources and Further Reading
- NGINX — Official Security Advisories
- NGINX — November 18, 2026 Security Release Announcement
- Wiz Research — Unauthenticated RCE in NGINX: CVE-2026-123633 and CVE-2026-123007
- F5 — CVE-2026-123633 Security Advisory
- F5 — CVE-2026-123007 Security Advisory
- NGINX Documentation — HTTP/2 Module and Configuration Directives




