NGINX HTTP/2 RCE: CVE-2026-123007 & CVE-2026-123633 | SAFE

NGINX HTTP/2 RCE: Two Critical Flaws Turn Protocol Handling into Remote Code Execution

Nov 18, 2026 12 minute read

Overview

An HTTP/2 implementation flaw that remained in NGINX for more than a decade exposes a path from unauthenticated network traffic to remote code execution. What begins as a flow-control accounting error can progress into memory corruption, allowing execution within an NGINX worker process. A separate exploit chain, NGINX2Root, further establishes how an initial worker compromise can be combined with a Linux kernel vulnerability to achieve root access on the underlying host.

On November 18, 2026, F5 released security updates addressing two critical vulnerabilities in NGINX’s HTTP/2 implementation: CVE-2026-123007 and CVE-2026-123633. Both carry a CVSS v4.0 score of 9.2 (Critical) and affect NGINX Open Source and NGINX Plus deployments.

The vulnerabilities expose two distinct failures in HTTP/2 processing:

  • CVE-2026-123007: An integer underflow in flow-control accounting allows invalid window values to propagate into unsafe memory operations, potentially enabling memory disclosure, heap corruption, and remote code execution (RCE). The vulnerable code dates back to NGINX 1.9.5, released in 2015, and can be reached even on servers serving static content.
  • CVE-2026-123633: A connection-lifecycle flaw allows an active HTTP/2 connection to remain incorrectly marked reusable. Under connection-resource pressure, NGINX may release memory still referenced by an active request, creating a use-after-free condition with potential RCE impact.

Neither vulnerability requires authentication or a weakness in the application behind NGINX. Both target the protocol-processing layer, where NGINX handles incoming traffic before forwarding requests to backend services.

This makes the affected infrastructure particularly sensitive. NGINX frequently terminates external connections and routes traffic across enterprise applications, APIs, and internal services. Code execution at this layer can expose resources accessible to the NGINX worker, potentially expanding the impact beyond any individual application.

Exploit implementations have established the feasibility of unauthenticated RCE under specific runtime conditions, including memory disclosure and Address Space Layout Randomization (ASLR) bypass. Although the demonstrated techniques have significant environmental dependencies, the underlying vulnerabilities affect a broader range of HTTP/2-enabled deployments.

The November 18 NGINX security release fixes both vulnerabilities in NGINX Open Source 1.30.7 (stable) and 1.31.9 (mainline). Internet-facing HTTP/2 deployments should be prioritized for immediate remediation.

Vulnerabilities at a Glance

Attribute CVE-2026-123007 CVE-2026-123633
Vulnerability HTTP/2 flow-control memory corruption HTTP/2 connection use-after-free
CVSS v4.0 9.2 – Critical 9.2 – Critical
CVSS v3.1 8.1 – High 8.1 – High
CWE CWE-191 – Integer Underflow CWE-416 – Use After Free
Authentication Not required Not required
Attack complexity High High
Prerequisites HTTP/2 enabled HTTP/2 enabled, upstream proxying, low available worker connections
Potential impact Memory disclosure, heap corruption, RCE Memory corruption, DoS, RCE
Affected NGINX OSS 1.9.5–1.31.8 1.19.7–1.31.8
Fixed NGINX OSS 1.30.7 / 1.31.9 1.30.7 / 1.31.9

Technical Analysis: Two Paths to Memory Corruption

Both vulnerabilities arise when NGINX continues operating on invalid internal state. CVE-2026-123007 breaks HTTP/2 flow-control limits; CVE-2026-123633 leaves an active connection eligible for resource reclamation. Subsequent memory operations trust these states, creating exploitable conditions.

CVE-2026-123007: From Flow-Control Accounting to Memory Corruption

HTTP/2 multiplexes multiple requests and responses over a single connection. To regulate transmission, it implements flow control at both the stream and connection levels.

NGINX tracks connection-level transmission credit using h2c->send_window. Clients grant additional credit through WINDOW_UPDATE frames, but RFC 9113, Section 6.9 limits the permitted flow-control window to 2³¹ – 1 bytes (2,147,483,647 bytes).

CVE-2026-123007 breaks this invariant during response cleanup.

1. Stream cancellation creates an invalid window refund

When NGINX queues HTTP/2 DATA frames, it deducts their lengths from the available connection-level transmission credit. If queued data is canceled before transmission, NGINX refunds the unused allowance.

The affected cleanup path in ngx_http_v2_filter_cleanup() performs:

h2c->send_window += window;

The vulnerable implementation does not adequately enforce the maximum permitted connection window during this refund.

By manipulating HTTP/2 stream lifecycles and flow-control settings, including SETTINGS_INITIAL_WINDOW_SIZE, an attacker can cause selected streams to terminate while the underlying connection remains open.

When their queued response data is discarded, NGINX restores the previously reserved credit. This refund can push h2c->send_window beyond the HTTP/2 maximum.

The immediate result is an invalid internal state rather than memory corruption itself.

2. Unsigned integer underflow bypasses validation

NGINX validates incoming connection-level window updates using logic equivalent to:

if (window > NGX_HTTP_V2_MAX_WINDOW - h2c->send_window) {
// Reject invalid update
}

The check assumes h2c->send_window is already within the permitted range.

Once that assumption is violated, subtracting the excessive counter from NGX_HTTP_V2_MAX_WINDOW underflows in unsigned arithmetic, producing a very large positive value instead of a negative remaining allowance.

The intended bounds check can consequently accept updates that should have been rejected.

Repeated WINDOW_UPDATE operations can then increase the invalid counter beyond the range representable by a signed 64-bit integer.

3. Corrupted accounting propagates into memory-copy operations

The inflated connection window eventually influences ngx_http_v2_send_chain(), where it helps determine how much response data NGINX can transmit.

On the affected execution path, converting an excessively large unsigned value into a signed off_t can produce a negative length. That value can propagate into buffer metadata, leaving the buffer’s end pointer before its start pointer.

When ngx_ssl_send_chain() processes the malformed buffer, a further conversion to the unsigned size_t type can turn the negative length into an extremely large copy size.

Depending on the selected memory-copy implementation, this can produce out-of-bounds memory access rather than an immediate crash.

Under suitable runtime conditions, the resulting primitive can support memory disclosure, heap corruption, ASLR bypass, and ultimately code execution within the NGINX worker process.

The critical failure is the transition from invalid HTTP/2 accounting to unsafe memory handling. The integer underflow does not directly execute code; it corrupts the assumptions on which subsequent buffer-processing operations rely.

CVE-2026-123007 - Breaking the HTTP/2 Flow-Control Invariant

Figure 1: CVE-2026-123007 – Breaking the HTTP/2 Flow-Control Invariant

CVE-2026-123633: When an Active Connection Is Reclaimed as Idle

CVE-2026-123633 affects NGINX’s connection lifecycle rather than flow-control arithmetic.

NGINX maintains reusable connections that can be closed when a worker needs to recover connection resources. An HTTP/2 connection without active streams may legitimately be marked reusable, but this status must be cleared when a new request stream begins processing.

The vulnerable implementation fails to consistently enforce that transition.

1. An incomplete HEADERS frame leaves the connection reusable

An HTTP/2 client can transmit part of a HEADERS frame, causing NGINX to wait for the remaining data. While no active streams exist, NGINX may mark the connection reusable.

When the remaining frame data arrives, NGINX creates a new stream and begins processing the request. However, the connection’s reusable status is not immediately cleared.

The connection now occupies an inconsistent state: it carries an active request while remaining eligible for resource reclamation.

2. Connection draining releases memory still in use

When a proxied request requires an upstream connection and the worker approaches its worker_connections limit, NGINX may invoke ngx_drain_connections() to reclaim reusable connections. The incorrectly marked HTTP/2 connection can be selected even though it carries an active request.

NGINX attempts to send an HTTP/2 GOAWAY frame before closing the connection. If that operation fails under the relevant conditions, the connection may be closed immediately and its associated memory pool released. Higher-level request processing can subsequently resume while retaining references to objects allocated from the freed pool. This creates a use-after-free condition. If the released memory is subsequently reused, stale references may access or manipulate unrelated allocations, potentially causing a worker crash, memory corruption, or arbitrary code execution.

3. The official patch restores the missing lifecycle transition

The NGINX source-code fix adds an explicit state change immediately after HTTP/2 stream creation:

h2c->processing++;
ngx_reusable_connection(h2c->connection, 0);

The added operation marks the connection non-reusable once an active stream exists.

CVE-2026-123633 - Active HTTP/2 Connection Reclaimed During Request Processing

Figure 2: CVE-2026-123633 – Active HTTP/2 Connection Reclaimed During Request Processing

Unlike CVE-2026-123007, this vulnerability has narrower prerequisites. The F5 advisory identifies HTTP/2, upstream proxying, and a low number of available worker connections as essential conditions.

An HTTP/2 static-content server without upstream proxying does not satisfy the documented exploitation requirements for this vulnerability.

Beyond NGINX: The Potential for Downstream Compromise

Successful exploitation of these vulnerabilities can provide code execution within the NGINX worker process. While this does not inherently grant root privileges, the compromised worker may expose application credentials, sensitive configuration, and access to internal services.

The broader impact is illustrated by the NGINX2Root disclosure, which describes an exploit chain combining CVE-2026-123007 with a separate Linux kernel SCTP vulnerability to escalate from NGINX worker-level execution to root access on the underlying host.

This escalation requires an independently exploitable kernel vulnerability and suitable runtime conditions. It is not an inherent capability of either NGINX HTTP/2 flaw.

For enterprise deployments, the practical impact therefore depends on the privileges of the NGINX worker, accessible backend services, container isolation, and the security posture of the underlying host.

HTTP/2 Termination Changes the Attack Path

Whether attacker-controlled HTTP/2 frames reach the vulnerable NGINX implementation directly is a decisive factor in assessing exposure.

When NGINX terminates an external HTTP/2 connection, an unauthenticated client can influence the protocol frames and connection-state transitions processed by the vulnerable code.

If a CDN, WAF, or load balancer independently terminates HTTP/2, the original client frame sequence may not be preserved. Instead, the intermediary establishes a separate backend connection with its own protocol state. For exploitation techniques requiring precise manipulation of WINDOW_UPDATE, HEADERS, and stream-cancellation behavior, this can interrupt the required attack sequence.

However, upstream termination should not automatically be treated as a complete mitigation.

If the intermediary establishes a new HTTP/2 connection to NGINX, backend protocol behavior may still be influenced by client activity. Direct origin exposure and alternative ingress paths may also bypass the intended termination boundary.

HTTP/2 Termination Changes the Attack Path

Figure 3: HTTP/2 Termination Changes the Attack Path

The relevant assessment is whether an untrusted client can cause the vulnerable NGINX instance to process the HTTP/2 frame sequences required for exploitation.

This is particularly important for enterprises with multiple ingress gateways, shared reverse proxies, private application endpoints, and origins reachable outside their primary CDN or WAF architecture.

Remediation: Close the Reachable Attack Paths

The official NGINX security advisories identify 1.30.7 (stable) and 1.31.9 (mainline) as the fixed NGINX Open Source releases for both CVEs.

NGINX Plus requires branch-specific updates.

Vulnerability NGINX Plus 37.0 branch Later 37.x branch
CVE-2026-123007 37.0.8.1 37.3.0.1
CVE-2026-123633 37.0.7.1 37.2.0.1

Because the first fixed builds differ, organizations should deploy a release containing fixes for both vulnerabilities. The F5 advisory summary provides the applicable branch and update information.

Immediate Defensive Actions

1. Patch affected NGINX deployments. Prioritize internet-facing HTTP/2 listeners, reverse proxies, API gateways, and shared application infrastructure. Verify security backports for distribution-managed packages and redeploy container workloads using patched images.

2. Disable HTTP/2 if immediate patching is not possible. For NGINX versions supporting the standalone directive:

server {
listen 443 ssl;
http2 off;
}

For older versions, remove http2 from affected listen directives. Validate the configuration using nginx -t, reload NGINX, and confirm that HTTP/2 is no longer negotiated. Ensure previously active vulnerable workers and connections have been retired.

3. Validate protocol termination and origin reachability. Determine whether NGINX directly processes external HTTP/2 frames, whether upstream intermediaries reconstruct backend connections, and whether alternative routes bypass those controls.

4. Assess NGINX-derived products and container workloads. Inventory embedded NGINX installations, including ingress controllers, OpenResty, and vendor-maintained appliances. Verify the applicable security fixes using vendor advisories and deployed package or image versions.

5. Investigate memory-corruption and post-exploitation signals. Monitor unexpected NGINX worker crashes, segmentation faults, unusual subprocess execution, and abnormal outbound connections. Where protocol-aware telemetry exists, examine unusual HTTP/2 control-frame behavior and sustained connection-resource pressure.

The CERT-EU advisory identifies worker crashes as useful investigative signals, but not definitive indicators of successful RCE. Conventional HTTP access logs may also lack visibility into the protocol-frame sequences required to identify exploitation attempts.

6. Review kernel and container exposure. For containerized deployments, assess kernel patch status, SCTP availability, container privileges, mounted host resources, and isolation boundaries. Where SCTP is unnecessary, disabling access to the protocol may reduce exposure to the separate kernel escalation path, subject to the host’s module and kernel configuration.

Disabling HTTP/2 provides a temporary mitigation for CVE-2026-123007 and CVE-2026-123633 but does not address other vulnerabilities disclosed in the November 18 NGINX security release, including those affecting HTTP/3, DNS resolution, and mail proxying. Organizations should apply the latest patched NGINX release for comprehensive remediation.

Conclusion

CVE-2026-123007 and CVE-2026-123633 demonstrate how subtle failures in HTTP/2 flow-control accounting and connection lifecycle management can escalate into critical memory-safety vulnerabilities. Their significance lies in the attack surface they expose: NGINX processes untrusted network traffic at the entry point to enterprise applications, making the security of the underlying web infrastructure as consequential as that of the applications themselves.

Although both vulnerabilities carry identical severity ratings, their exploitation prerequisites differ substantially. CVE-2026-123007 affects a broader range of HTTP/2 deployments, while CVE-2026-123633 requires specific reverse-proxy and resource-management conditions.

Applying the patched NGINX releases addresses both vulnerabilities. For environments where immediate patching is not feasible, disabling HTTP/2 provides an interim mitigation until the security updates can be deployed.

References

  1. NGINX – Security Release Announcement (November 18, 2026)
  2. F5 – Security Advisory for CVE-2026-123007
  3. F5 – Security Advisory for CVE-2026-123633
  4. F5 – November 2026 NGINX Security Advisory Summary
  5. NGINX – Official Security Advisories and Affected Versions
  6. NGINX – Official Source-Code Fix for CVE-2026-123633
  7. CERT-EU – Critical Vulnerabilities in NGINX (2026-022)
  8. IETF – RFC 9113: HTTP/2, Section 6.9 (Flow Control)
  9. NGINX2Root – Official Vulnerability Disclosure
  10. NGINX2Root – Full Technical Analysis by Xint
  11. Amazon Linux – CVE-2026-123007 Security Tracking
  12. Amazon Linux – CVE-2026-123633 Security Tracking
See how SAFE transforms your CTEM Unified exposure visibility, AI-driven prioritization, and quantified risk in business terms. Built for enterprise scale.