Vulnerability

NGINX HTTP/2 RCE Vulnerabilities: What CVE-2026-123007 and CVE-2026-123633 Mean for Your Servers

Two critical NGINX HTTP/2 vulnerabilities expose servers to remote code execution. Learn how they work, which versions are affected, and how to stay protected.

·
10 min read
·
AI-assisted

AI tooling disclosure

Generative AI materially contributed to this article.

Human review confirmed by the author.

NGINX HTTP/2 RCE Vulnerabilities: What CVE-2026-123007 and CVE-2026-123633 Mean for Your Servers

A web server doesn't need a vulnerable application behind it to become an attacker's entry point. Sometimes, the weakness is in the server that receives the request.

On November 18, 2026, NGINX released security updates for two HTTP/2 memory-safety vulnerabilities: CVE-2026-123007 and CVE-2026-123633. Researchers demonstrated that both can lead to unauthenticated remote code execution (RCE) under their respective conditions. The first can affect an NGINX server serving ordinary static files; the second requires a more specific upstream/proxy and connection-pressure scenario. These are server-side bugs, not weaknesses in HTTP/2 clients.

NGINX commonly sits in front of authentication services, APIs, and customer-facing websites. Compromising one worker process may expose data and connections shared by multiple services.

The short version: If your deployment runs an affected NGINX build and accepts HTTP/2 traffic, prioritize an upgrade to NGINX Open Source 1.30.7 (stable) or 1.31.9 (mainline). For NGINX Plus, use a release that fixes both CVEs, such as PLS.37.0.8.1 LTS or PLS.37.3.0.1 CR. If you cannot patch immediately, temporarily disable HTTP/2 on the affected NGINX listeners. Disabling HTTP/2 is a mitigation for these two flaws—not for every vulnerability addressed in the same security release.

What happened on November 18?

Researchers at Wiz, Rapid7, Ikotas Labs, Metnir, and Xint independently reported findings involving these HTTP/2 weaknesses. The disclosures were coordinated with F5, which maintains NGINX. Wiz's disclosure timeline records October and November reports leading to the November 18 security release.

Wiz rates both issues 9.2 (Critical) under CVSS v4.0; CERT-EU reports 8.1 (High) under CVSS v3.1. NGINX's upstream advisories also use their own qualitative labels: major for CVE-2026-123007 and medium for CVE-2026-123633. These are different scoring systems, not conflicting CVE records. Exposure and exploit prerequisites remain central to prioritization.

A significant development followed the disclosure: Rapid7 published a proof-of-concept for CVE-2026-123007, demonstrating RCE against a vulnerable NGINX 1.31.8 Linux container. In its November 18 advisory, CERT-EU stated that no exploitation in the wild had been reported at the time of publication. That dated statement should not be read as a live assessment of attacker activity on November 19 or later. A public demonstration proves the bug can be exploited under tested conditions; it does not by itself establish active campaigns.

The two vulnerabilities at a glance

CVE-2026-123007

CVE-2026-123633

Bug class

Integer underflow and memory corruption in HTTP/2 flow control

Use-after-free in HTTP/2 connection handling

First affected NGINX OSS version

1.9.5

1.19.7

Required exposure

Vulnerable build with HTTP/2 enabled

Vulnerable build with HTTP/2 enabled, an upstream connection path, and connection-pressure conditions

Can static-file hosting be affected?

Yes

Not through the demonstrated proxy-dependent path

Possible impact

Memory disclosure, worker crash, or code execution

Memory corruption, worker crash, or code execution

Important: Those are the first affected upstream releases, not a single continuous vulnerable range: fixed stable 1.30.7 is numerically below vulnerable mainline 1.31.8. Linux distributions, appliances, and container-image maintainers may also backport fixes without changing the upstream version string. NGINX Plus uses a separate release scheme and may report an older underlying OSS version even when patched. Verify the full package revision and vendor advisory before declaring a deployment vulnerable or fixed.

Why an HTTP/2 flaw can become remote code execution

HTTP/2 allows multiple requests to share one network connection. Instead of waiting for one request to finish before starting another, the protocol uses streams, frames, and flow-control windows to coordinate data moving in both directions.

That efficiency introduces complicated state management. NGINX has to track which requests are active, which connections can be closed, how much data a client has permitted it to send, and which buffers remain valid. Both CVEs emerge when two pieces of that bookkeeping disagree.

CVE-2026-123007: A flow-control number crosses a dangerous boundary

HTTP/2 flow control works like a credit system. The client tells the server how much response data it is ready to receive, and the server maintains a counter representing that allowance. The HTTP/2 connection window must not exceed 2,147,483,647 bytes (2³¹−1); this protocol limit matters to the bug.

When NGINX queues response data, it accounts for the bytes it intends to send. If a stream ends before queued data is transmitted, the unused allowance must be returned. In the vulnerable code path, that refund can push an internal value beyond the protocol's permitted range.

The important distinction is that the initial refund exceeds the protocol limit but has not necessarily overflowed the machine integer. A later WINDOW_UPDATE bounds check subtracts that invalid counter from the maximum using unsigned arithmetic. That subtraction underflows, making an impossible amount of available credit appear acceptable. Later signed/unsigned conversions create a malformed response-buffer length; in the demonstrated TLS path, an out-of-bounds copy can follow. See Wiz's root-cause analysis and Rapid7's independent technical breakdown.

The security consequence is larger than a protocol error: memory can be exposed or corrupted, potentially giving an attacker a route to execute code in the NGINX worker process.

Why this one deserves special attention: Wiz confirmed code execution on official NGINX 1.31.7 and 1.31.8 builds, including a server delivering ordinary static files over HTTP/2 and TLS. It did not require a vulnerable backend application or a third-party NGINX module.

CVE-2026-123633: A connection is closed while its request is still alive

NGINX keeps track of connections it can reclaim when it needs capacity for new work. A connection with no active requests may be marked reusable and become a candidate for closure.

In one HTTP/2 processing path, NGINX marks a connection reusable while waiting for the rest of an incomplete request-header frame. After the request stream is created, the connection can incorrectly remain on the reusable list. If the worker then runs low on available connection slots while opening an upstream connection, its draining logic may close that supposedly idle client connection—even though an active request still uses it. The demonstrated failure also involves a connection-close error path; low connection capacity alone is not proof of exploitation.

The result is a use-after-free: request processing continues with a reference to memory that has already been released. If that memory is subsequently reused, the program may interpret unrelated data as connection or request state.

This path is most relevant to NGINX acting as a reverse proxy. Upstream activity, connection pressure, and memory timing make exploitability deployment-dependent.

Does “RCE” mean the attacker gets root?

No—not automatically. Demonstrated code execution occurs in the context of an NGINX worker process and its permissions, not inherently the NGINX master process or root privileges. A separate privilege-escalation flaw, exposed credentials, or an overly privileged container can worsen the outcome. For example, Xint reported chaining an NGINX RCE with a separate Linux kernel flaw to obtain host root in its lab. That is an additional attack chain—not root access granted by these two NGINX CVEs alone.

Who should investigate first?

Start with systems that combine a vulnerable build, HTTP/2 support, and network exposure. In particular, examine:

  1. Internet-facing NGINX reverse proxies handling customer traffic or forwarding to APIs and applications.

  2. NGINX instances serving static assets over HTTPS, because CVE-2026-123007 does not require a backend.

  3. Containers, Kubernetes ingress deployments, and vendor appliances that bundle their own NGINX binaries rather than using the host's package.

  4. Origin servers behind CDNs or WAFs, especially where clients can reach the origin directly or the intermediary passes HTTP/2 traffic through.

  5. Internal HTTP/2 services reachable by less-trusted systems. “Not public” does not mean “not attackable.”

A CDN or WAF that terminates HTTP/2 may disrupt the exploit's low-level frame sequence, but does not patch a vulnerable origin. Check the edge-to-origin protocol and whether clients can bypass the intermediary.

How to check an NGINX server for exposure

These are non-exploit checks intended for inventory and configuration review. Run them on hosts or containers you administer.

1. Identify the NGINX build

nginx -v 2>&1
nginx -V 2>&1

The first prints the version. The second prints build options and compiled modules. In particular, look for --with-http_v2_module, because NGINX's HTTP/2 module is an optional build feature. Having the module is necessary but not sufficient for exposure; HTTP/2 must also be enabled.

Record the full vendor package revision or running container image digest. On Debian/Ubuntu, dpkg-query -W 'nginx*' may help; on RPM-based systems, use rpm -qa | grep -i nginx. For Kubernetes, verify the actual ingress/gateway implementation, its running image, and its vendor security advisory—not the host's nginx binary or a stale Dockerfile.

2. Inspect the on-disk configuration for HTTP/2

sudo nginx -T 2>/dev/null | grep -nE \
  '^[[:space:]]*(http2[[:space:]]+on|listen[[:space:]][^;#]*[[:space:]]http2)([[:space:];]|$)'

nginx -T tests and prints the configuration currently on disk, expanding include files. It does not prove that already-running workers are using the same configuration, especially if files were edited without a successful reload. Review inherited http {} settings, virtual hosts, and both IPv4/IPv6 listeners. A text search can miss multiline or unusual formatting and is an initial triage aid, not a parser or proof of exploitability.

3. Look for reverse-proxy paths

sudo nginx -T 2>/dev/null | grep -nE \
  '^[[:space:]]*(proxy_pass|fastcgi_pass|grpc_pass|uwsgi_pass|scgi_pass)[[:space:]]'

These directives can identify upstream-facing routes worth reviewing for CVE-2026-123633. The command is illustrative rather than exhaustive; a match does not establish that an attacker can trigger the connection-draining bug, and no match is not a conclusive exclusion.

4. Check externally negotiated HTTP/2, if useful

curl -sS -o /dev/null -w '%{http_version}\n' --http2 https://example.com/

Replace the domain with one you administer, and use a curl build that supports HTTP/2. A result of 2 indicates the public endpoint reached by curl negotiated HTTP/2. It does not prove an origin NGINX worker handled HTTP/2; a load balancer or CDN can terminate it first. Likewise, a result of 1.1 does not rule out HTTP/2 on another hostname, port, or origin route.

How to fix CVE-2026-123007 and CVE-2026-123633

Option A: Upgrade NGINX—the preferred solution

The NGINX project shipped both fixes on November 18, 2026, as confirmed by the official release announcement.

Product

Release fixing both HTTP/2 CVEs

NGINX Open Source, stable

1.30.7

NGINX Open Source, mainline

1.31.9

NGINX Plus, PLS.37 LTS track

PLS.37.0.8.1

NGINX Plus, PLS.37 continuous release (CR)

PLS.37.3.0.1

For NGINX Plus, do not stop at PLS.37.0.7.1 or PLS.37.2.0.1 simply because those builds address CVE-2026-123633. They predate the separate CVE-2026-123007 fix. Also note that old R34–R36 releases do not have an in-place fixed version listed in Rapid7's remediation table; follow the NGINX Plus supported upgrade paths, not upstream OSS version comparisons.

A safe production rollout should include configuration validation, a canary or staged deployment, smoke tests for authentication and proxy routes, and an explicit rollback plan. Do not roll back to an exposed, vulnerable HTTP/2 configuration: if you must revert a package, keep the temporary HTTP/2 mitigation in place. Validate the running release after rollout and ensure old workers have exited.

Option B: Temporarily disable HTTP/2

If an immediate upgrade is impossible, disabling HTTP/2 removes the required protocol exposure for these two CVEs.

For NGINX 1.25.1 or later, review the affected server blocks and use:

server {
    listen 443 ssl;
    server_name example.com;

    http2 off;

    # Keep your existing TLS and location configuration here.
}

Also remove the older http2 parameter from every affected listen directive. Check any http2 on; inherited from the http {} context, other TLS virtual hosts sharing the address/port, and both IPv4/IPv6 listeners. An http2 off; line in one server block is not a substitute for reviewing the effective listener configuration.

For versions before 1.25.1, where the standalone http2 directive is unavailable, remove http2 from listen directives—for example, change listen 443 ssl http2; to listen 443 ssl;.

Then test and reload:

sudo nginx -t && sudo nginx -s reload

Confirm the new configuration is in use and that old workers have drained or exited; active connections on old workers may persist during a graceful reload. Verify actual ALPN negotiation on each affected hostname or route (and, if possible, the origin itself). Test clients and any gRPC or other HTTP/2-dependent integrations before treating the mitigation as complete—disabling HTTP/2 may break them.

Critical limitation: The November 18 release also fixes separate problems such as CVE-2026-121810 (HTTP/3 use-after-free), CVE-2026-123634 (resolver use-after-free), and CVE-2026-113425 (mail-proxy use-after-free), among other issues. Disabling HTTP/2 does not mitigate these. Patch the complete release even if you have disabled HTTP/2. See the full upstream advisory list.

What should security teams monitor?

No single log entry reliably proves one of these CVEs was exploited. Still, several signals merit investigation, particularly on exposed, unpatched systems:

  • Unexpected NGINX worker crashes or restarts, including segmentation faults or repeated process exits.

  • Unusual child processes started by an NGINX worker, such as shells or administrative utilities that are not part of normal operations.

  • Abnormal long-lived HTTP/2 sessions, unusual traffic volume, or suspicious patterns of HTTP/2 flow-control activity where detailed protocol telemetry is available.

  • Unexpected changes to website content, configuration, credentials, or files accessible to the NGINX worker identity.

  • Surprising outbound connections initiated by a host or container whose primary job is to serve inbound web traffic.

For CVE-2026-123007, the public research describes substantial HTTP/2 traffic in its demonstrated exploitation path. Rapid7 reported approximately 128 GB of HTTP/2 traffic for its specific Linux/x86-64 proof-of-concept, which took about 2.5 minutes in the published demonstration and depended on particular glibc memcpy behavior and CPU features. Those are constraints of that published exploit strategy, not verified minimum requirements for every possible exploit. Bandwidth/connection-lifetime limits therefore affect practical likelihood without eliminating exposure. Standard access logs will generally not record the WINDOW_UPDATE and stream-control details needed to prove an attempt, and raw network inspection may be limited by TLS encryption.

If compromise is suspected, preserve relevant process, container, network, and log evidence before disruptive changes where feasible. Investigate under an incident-response process, rotate credentials that may have been accessible to the worker, and avoid treating a clean restart as proof that the host was never compromised.

Why this disclosure matters beyond NGINX

CVE-2026-123007 remained in affected NGINX code for over a decade, dating back to 2015. Wiz describes using AI-assisted analysis, while independent teams also uncovered related flaws. AI helped some researchers investigate these bugs; it was not a prerequisite for discovering or exploiting them.

The broader lesson is not that HTTP/2 is inherently insecure or that every longstanding codebase is doomed. It is that complex, mature infrastructure continues to contain memory-safety defects, and improvements in automated code analysis are making them easier to uncover.


Sources and further reading

  1. Wiz Research — Unauthenticated Remote Code Execution in NGINX: CVE-2026-123633 and CVE-2026-123007 (November 18, 2026)

  2. NGINX — Official security advisories

  3. NGINX — November 18, 2026 release announcement

  4. Rapid7 — CVE-2026-123007 technical research and proof-of-concept disclosure (November 18, 2026)

  5. CERT-EU — Critical vulnerabilities in NGINX

  6. Xint — NGINX2Root technical research and separate kernel escalation chain (November 18, 2026)

  7. NGINX — HTTP/2 module configuration reference

  8. NGINX — NGINX Plus release notes

  9. Qualys — NGINX2Root remediation and CVSS score comparison

Comments(0)

Join the discussion by logging into your account.

No comments yet. Be the first to comment!

Sanju Singh

Passionate developer sharing knowledge about modern web technologies and best practices.

Subscribe to Sanju Singh's Newsletter

Direct email dispatches when new stories are published. Zero algorithms.