TL;DR
- Vulnerability: CVE-2026-119618 is a critical race condition in Apache HTTP Server’s
mod_http2module that leads to heap memory corruption and unauthenticated remote code execution (RCE). - Scope: Affects Apache HTTP Server versions 2.4.55 through 2.4.70, and standalone
mod_h2GitHub releases 2.0.8 through 2.0.42. Patched in Apache 2.4.71 released on 11 November 2026. - Prerequisite: The target server must have HTTP/2 explicitly enabled via the
Protocolsdirective (h2orh2c). - Cloud Exposure: Wiz telemetry indicates 64% of cloud environments host affected instances, with 51% exposed publicly to the internet. No in-the-wild exploitation was reported at disclosure.
- Immediate Action: Upgrade to Apache 2.4.71 or distribution-patched packages. If upgrading must be delayed, restrict active protocols in configuration to
Protocols http/1.1.
A critical race condition vulnerability in the Apache HTTP Server HTTP/2 module, mod_http2, allows remote, unauthenticated attackers to corrupt heap memory and execute arbitrary code with web server process privileges. Tracked as cve-2026-119618, the security flaw carries a maximum CVSS v3 base score of 9.8 and impacts Apache HTTP Server versions 2.4.55 through 2.4.70. The issue was resolved upstream with the release of version 2.4.71 on 11 November 2026.
The flaw originates within the assign_headers() function when processing concurrent HTTP/2 request streams. When multiple execution threads attempt to handle shared stream resources without adequate synchronization locks, the module experiences state desynchronisation, corrupting memory pointers within the server’s heap. Standalone builds of the module published on GitHub under the mod_h2 project are similarly affected across versions 2.0.8 through 2.0.42.
Exploitation requires HTTP/2 protocol support to be explicitly enabled in the web server configuration via the Protocols directive using either h2 (HTTP/2 over TLS) or h2c (HTTP/2 over cleartext TCP). While no active in-the-wild exploitation had been observed at the time of vendor disclosure, cloud telemetry shows substantial exposure across enterprise environments. System administrators and SRE teams must verify protocol configurations and apply package updates immediately.
An Anatomy of CVE-2026-119618: Unauthenticated Heap Corruption in mod_http2
The vulnerability was discovered independently by Anthropic’s OSS Scanner—an automated security analysis initiative utilizing artificial intelligence models to inspect open-source codebases—and by security researchers Anthony Weems and Simon Scannell of Google Cloud Vulnerability Research. Anthropic initially reported the defect to the Apache Software Foundation on 26 October 2026.
Assessed with a CVSS v3 rating of 9.8 (Critical), cve-2026-119618 requires no authentication, special privileges, or direct user interaction. An attacker capable of establishing a network connection to an vulnerable Apache web server can submit maliciously timed HTTP/2 frame sequences to trigger the underlying race condition. Successful memory corruption grants the attacker arbitrary code execution under the security context of the parent or worker web server process (typically www-data, apache, or nobody).
| Parameter | Vulnerability Details |
|---|---|
| CVE Identifier | CVE-2026-119618 |
| CVSS v3.1 Score | 9.8 (Critical: CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H) |
| Vulnerability Class | Race Condition / Concurrent Execution Resource Management (CWE-362) |
| Subsystem | Apache mod_http2 (assign_headers() function) |
| Affected Core Versions | Apache HTTP Server 2.4.55 through 2.4.70 |
| Patched Core Version | Apache HTTP Server 2.4.71 (Released 11 November 2026) |
| Affected Standalone Builds | mod_h2 GitHub releases 2.0.8 through 2.0.42 |
| Prerequisite Condition | HTTP/2 protocol enabled via Protocols directive (h2 or h2c) |
The attack vector manifests over standardized network ports serving HTTP/2 traffic (typically TCP ports 80 and 443). Because HTTP/2 multiplexes multiple logical streams across a single underlying TCP connection, the vulnerability relies on the concurrent handling of these streams by worker threads inside the mod_http2 runtime engine.
Configuration Scope Notice
Loading the mod_http2 shared object via LoadModule http2_module modules/mod_http2.so is a prerequisite, but the server is only vulnerable if the Protocols directive explicitly lists h2 or h2c globally or within an active VirtualHost block.
Vulnerability Mechanism: Concurrency and Race Conditions in assign_headers()
To understand cve-2026-119618, one must examine how mod_http2 handles multiplexed request stream headers. Unlike HTTP/1.1, which processes transactions sequentially over discrete socket connections, HTTP/2 breaks protocol interactions down into binary frames (such as HEADERS, DATA, and CONTINUATION) transmitted across single or multiple concurrent streams.
When an incoming HTTP/2 stream receives header data, the engine passes the parsed headers to the assign_headers() function within mod_http2. This function is responsible for populating internal Apache request structures (specifically the request_rec table) with header key-value pairs before handoff to higher-level request processing modules. In vulnerable versions (2.4.55 to 2.4.70), assign_headers() fails to enforce mutex locks or atomic boundary synchronization when concurrent worker threads manipulate shared memory regions across multiplexed streams.
+-----------------------------------------------------------------------------------+
| HTTP/2 Client (Attacker) |
+-----------------------------------------------------------------------------------+
| |
| Stream 1: HEADERS / CONTINUATION | Stream 3: Reset / Pipeline
v v
+-----------------------------------------------------------------------------------+
| Apache Worker Threads |
| +-----------------------------------+ +------------------------------------+ |
| | Worker Thread A | | Worker Thread B | |
| | Processing Stream 1 | | Processing Stream 3 | |
| | Executing assign_headers() | | Mutating Shared Stream Context | |
| +-----------------------------------+ +------------------------------------+ |
+-----------------------------------------------------------------------------------+
| |
\------------------------- Thread Interleaving ------/
|
v
+----------------------------------------------+
| Unprotected Concurrent Write/Free Access |
| inside assign_headers() Memory Operations |
+----------------------------------------------+
|
v
+----------------------------------------------+
| Heap Corruption (Use-After-Free / Pointer |
| Overwrite in Apache Memory Pool) |
+----------------------------------------------+
When multiple processing threads service rapid, interleaved streams sharing underlying connection memory contexts, a race window opens. Thread A executes assign_headers() and reads or updates memory address pointers associated with the session’s stream configuration. Simultaneously, Thread B modifies or frees the same memory structures due to rapid stream resets, state changes, or concurrent frame delivery. This lack of thread safety leads to classical heap memory corruption dynamics, including Use-After-Free (UAF) states and pointer reference corruption within the Apache Portable Runtime (APR) memory allocation pool.
Under default upstream compilations, APR memory pools operate across shared thread space without isolated allocations for individual stream objects. An attacker who controls the timing and payload structure of incoming HTTP/2 frames can deliberately widen this race window, causing predictable heap layout corruption that can be leveraged to hijack control flow pointers and achieve remote code execution.
Severity and Blast Radius: Cloud Exposure Telemetry and Attack Vectors
According to cloud security telemetry from Wiz, 64% of cloud environments contain workloads running vulnerable versions of Apache HTTP Server. Furthermore, 51% of cloud environments host vulnerable instances that are directly exposed to the public internet. This high exposure rate stems from standard enterprise deployment patterns where Apache acts as an ingress reverse proxy, API gateway, or TLS termination point.
As reported by The Hacker News, while Red Hat’s security advisory indicated that public research had demonstrated a reliable exploit against default configurations, security telemetry providers including Wiz confirmed that no public exploit code was publicly hosted and no active exploitation in the wild was detected at the time of initial patch release on 11-12 November 2026.
If an attacker successfully achieves remote code execution via cve-2026-119618, the blast radius extends well beyond the compromised HTTP server process:
- Cloud Instance and Metadata Access: Web server worker processes running in cloud environments (such as AWS EC2, Google Compute Engine, or Azure VMs) often have access to the Instance Metadata Service (IMDS). An attacker achieving local code execution can query
http://169.254.169.254to extract temporary IAM role credentials, allowing lateral movement into broader cloud account resources. - Container and Cluster Escalation: In containerized deployments (Kubernetes, ECS, Docker), execution inside an Apache container provides an initial foothold. Attackers can attempt container escapes, service account token theft from
/var/run/secrets/kubernetes.io/serviceaccount, or lateral network probing against internal microservices. - Database and Backend Credential Extraction: Reverse proxy and application instances running Apache frequently store database connection strings, API keys, and TLS private keys in process memory or local configuration files (such as
.envor system environment variables).
Distribution Vulnerability Matrix: RHEL, Debian, Amazon Linux, and Ubuntu Status
Because Linux distributions backport security fixes and maintain custom package versioning schemes, tracking upstream Apache version numbers alone is insufficient. Below is the patch status and advisory tracking across major enterprise Linux distributions as of mid-November 2026.
| Platform / Distribution | Vulnerability Status | Fixed Package Version / Advisory Identifier |
|---|---|---|
| Apache HTTP Server Project | Fixed | Version 2.4.71 (Released 11 November 2026) |
| Red Hat Enterprise Linux 9 | Fixed | mod_http2-2.0.26-7.el9_9.1 (RHSA-2026:98981) |
| Red Hat Enterprise Linux 10 | Fixed | mod_http2-2.0.29-5.el10_3.1 (RHSA-2026:98978) |
| RHEL Extended Update Support (9.4, 9.6, 9.8, 10.0, 10.2) | Fixed | RHSA-2026:98968, RHSA-2026:98954, RHSA-2026:98982, RHSA-2026:98953, RHSA-2026:98979 |
| Red Hat Enterprise Linux 6, 7, and 8 | Not Affected | Older codebase does not contain the vulnerable code path |
| Red Hat JBoss Core Services | Affected | Fix pending vendor update |
| Debian Unstable (sid) | Fixed | apache2 2.4.71-1 |
| Debian Bookworm (12), Trixie (13), Forky (14) | Vulnerable | Fix pending in Debian security tracker |
| Amazon Linux 2, 2023, 2027 Preview | Vulnerable | Fix pending in Amazon Linux security tracker |
| Ubuntu Linux (All Supported Releases) | Vulnerable / Pending | No security tracker release at initial disclosure |
| Standalone mod_h2 (GitHub Release) | Vulnerable | Repository archived 9 June 2026 (Max release 2.0.42; no official post-2.0.42 release published) |
Administrators managing standalone deployments of the open-source mod_h2 module compiled directly from GitHub source code face unique maintenance challenges. The standalone repository was archived on 9 June 2026, leaving version 2.0.42 as the final release tag. Teams utilizing standalone module builds must transition to core Apache HTTP Server distribution packages or rely strictly on configuration-level mitigations.
Architectural Mitigation Dynamics: Stream Memory Allocators in Enterprise Linux
An important divergence in severity scoring occurred upon disclosure: while upstream maintainers and security vendors rated cve-2026-119618 as Critical (CVSS 9.8), Red Hat rated the vulnerability’s impact as Important on Red Hat Enterprise Linux 9 and 10.
This variance stems from explicit memory management choices implemented within Red Hat’s enterprise packaging of mod_http2. Standard upstream Apache builds allocate stream-handling structures within shared memory pools governed by the Apache Portable Runtime. Under high thread contention, corrupting an APR pool pointer allows an attacker to manipulate adjacent memory spaces used by parallel worker threads.
Upstream Standard Memory Pool Model vs. RHEL Hardened Per-Stream Model
Upstream Apache Memory Pool Architecture:
+--------------------------------------------------------------------+
| Apache APR Global / Shared Thread Memory Pool |
| |
| [Stream 1 State] [Stream 2 State] [Stream 3 State] [Pointers] |
| | ^ |
| +--- Threads access shared space (UAF corrupts pool)-+ |
+--------------------------------------------------------------------+
Result: Heap corruption affects adjacent thread contexts -> High RCE Probability
RHEL Hardened Per-Stream Allocator Model:
+---------------------------+ +---------------------------+
| Stream 1 Isolated Pool | | Stream 2 Isolated Pool |
| [Stream 1 State Data] | | [Stream 2 State Data] |
+---------------------------+ +---------------------------+
^ ^
| Memory Boundary | Memory Boundary
+---------------------------+ +---------------------------+
| Stream 3 Isolated Pool | | Stream 4 Isolated Pool |
+---------------------------+ +---------------------------+
Result: Corruption is localized to single stream -> Causes crash (DoS) rather than control flow hijack
In contrast, Red Hat’s custom-packaged mod_http2 binaries assign an isolated, discrete memory allocator to each individual HTTP/2 stream. When a race condition occurs within assign_headers() on RHEL 9 or 10, the resulting memory corruption is confined strictly to the memory arena assigned to that specific stream. Corrupting an isolated stream allocator causes the affected worker thread to fault and crash (resulting in Denial of Service for that single connection) rather than allowing cross-thread heap control required for execution flow hijacking. This architectural isolation significantly raises the exploitation barrier, justifying the lower severity classification on RHEL platforms.
Practical Guidance: Upgrading Packages and Disabling HTTP/2 Protocol Handling
To eliminate exposure to cve-2026-119618, operations teams must either upgrade Apache binaries to fixed versions or disable HTTP/2 protocol support globally across web server configurations.
Option 1: Complete Package Upgrade
For systems running enterprise distribution packages with active patch repositories, upgrade to fixed package releases using the native package manager.
On Red Hat Enterprise Linux 9:
# Verify current mod_http2 package version
rpm -qa | grep mod_http2
# Update mod_http2 package from official repositories (Test in staging first)
sudo dnf update -y mod_http2
# Restart Apache to load updated binary modules into memory
sudo systemctl restart httpd
On Debian Unstable (sid) or systems building from upstream source:
# Update package index and install patched apache2 package
sudo apt-get update && sudo apt-get install --only-upgrade apache2
# Gracefully restart Apache service
sudo systemctl reload apache2
Option 2: Configuration Mitigation (Disabling HTTP/2)
If binary upgrades cannot be deployed immediately due to vendor patch pending status (such as on Debian Bookworm, Amazon Linux, or Ubuntu) or strict change freeze windows, remove HTTP/2 support from server configuration files. This completely removes the attack vector by preventing mod_http2 from processing incoming client requests.
Locate all occurrences of the Protocols directive across the main configuration files (e.g., /etc/httpd/conf/httpd.conf, /etc/apache2/apache2.conf) and virtual host files (/etc/apache2/sites-enabled/* or /etc/httpd/conf.d/*).
# VULNERABLE CONFIGURATION EXAMPLE:
# Protocols h2 h2c http/1.1
# MITIGATED CONFIGURATION:
# Restrict protocol handling strictly to HTTP/1.1
Protocols http/1.1
After updating configuration files, validate the configuration syntax and reload the service:
# Check configuration syntax on RHEL/CentOS
sudo apachectl configtest
# Check configuration syntax on Debian/Ubuntu
sudo apache2ctl configtest
# Apply configuration changes without dropping active HTTP/1.1 connections
sudo systemctl reload httpd # or apache2
Virtual Host Override Advisory
The Protocols directive can be defined at both global server level and inside individual <VirtualHost> blocks. Overriding the global setting with Protocols http/1.1 will not protect a virtual host that explicitly re-enables h2 or h2c inside its own configuration block.
Verification, Threat Hunting, and Operational Posture Verification
To confirm mitigation effectiveness and audit web infrastructure for residual risk, platform security teams should execute systematic validation steps across all web server fleets.
1. Validating Protocol Negotiation Handshakes
Use curl or openssl from an external network host to test whether targeted web servers attempt HTTP/2 Application-Layer Protocol Negotiation (ALPN) or plain text upgrades.
# Test TLS ALPN negotiation for HTTP/2 (h2)
curl -sI --http2 https://<target-hostname> -o /dev/null -w "%{http_version}\n"
# Expected output for mitigated server:
# 1.1
# Verify via OpenSSL ALPN check
openssl s_client -connect <target-hostname>:443 -alpn h2 < /dev/null 2>&1 | grep "ALPN"
# Expected output for mitigated server:
# ALPN protocol: No protocol negotiated (or http/1.1)
2. Auditing Configuration Storage across Server Fleets
Execute shell commands across configuration directories to detect hidden or residual HTTP/2 protocol declarations:
# Search for active HTTP/2 protocol declarations in Apache configuration directories
grep -rnEi "Protocols.*(h2|h2c)" /etc/httpd/ /etc/apache2/ /etc/httpd/conf.d/ /etc/apache2/sites-enabled/ 2>/dev/null
# If output yields active directives, modify files to specify 'Protocols http/1.1'
3. Monitoring Crash Dumps and Worker Thread Abnormalities
Security Operations Center (SOC) analysts and SREs should monitor system logs for worker thread crashes associated with mod_http2. Exploitation attempts typically cause segmentation faults during initial shellcode tuning or race timing alignment.
# Inspect system log files for HTTP/2 process crashes
journalctl -u httpd -u apache2 --since "24 hours ago" | grep -Ei "segfault|SIGSEGV|SIGABRT|mod_http2"
# Check kernel message buffer for memory corruption faults
dmesg -T | grep -Ei "httpd|apache2"
Look specifically for memory access violations in mod_http2.so or libapr-1.so. Repeated segmentation faults originating from HTTP/2 handling threads indicate either active exploitation attempts or intense concurrent execution faults requiring immediate isolation.
Common Operational Mistakes
- Unloading the Module Without Configuration Cleanup: Removing
LoadModule http2_modulewithout removingProtocols h2from configuration files causes Apache configuration validation to fail upon restart. - Ignoring Inherited Directives: Setting
Protocols http/1.1in a global configuration file while leavingProtocols h2 http/1.1inside an included virtual host file leaves that specific virtual host fully vulnerable to cve-2026-119618. - Failure to Reload System Services: Updating configuration files on disk without performing a
systemctl reload httpdleaves active worker processes executing old in-memory directives.
Key Takeaways for Infrastructure and Application Security Teams
CVE-2026-119618 highlights the lingering memory safety risks present in complex C-based network infrastructure protocols. As multiplexed protocols like HTTP/2 increase state management complexity within traditional multi-threaded web servers, race conditions in header and stream parsing logic continue to emerge.
Infrastructure security teams must prioritize immediate updating of edge-facing Apache instances. Where official vendor patches remain pending across Linux distributions, modifying configuration directives to enforce Protocols http/1.1 provides an immediate, effective defense without requiring server downtime or binary compilation. Finally, the discovery of this issue by AI-driven security tools (Anthropic’s OSS Scanner) alongside cloud vulnerability research teams signals a shifting landscape in automated open-source bug hunting, underscoring the need for rapid patch deployment lifecycles across platform operations.
Frequently asked questions
Is Apache HTTP Server vulnerable if HTTP/2 is installed but not explicitly enabled in configuration?
No. The mod_http2 module only processes incoming client streams if the Protocols directive explicitly enables h2 (HTTP/2 over TLS) or h2c (HTTP/2 over cleartext TCP). If the directive is absent or set strictly to Protocols http/1.1, the vulnerable code paths in assign_headers() cannot be reached by network traffic.
How does modifying the Protocols directive to ‘Protocols http/1.1’ protect against CVE-2026-119618?
Setting Protocols http/1.1 forces Apache to reject client attempts to negotiate HTTP/2 via TLS ALPN extensions or HTTP/1.1 Upgrade headers. Because the server strictly operates in HTTP/1.1 mode, the mod_http2 processing loop and its vulnerable assign_headers() function are completely bypassed during request execution.
Why did Red Hat rate CVE-2026-119618 as Important while upstream vendor assessments rated it Critical (CVSS 9.8)?
Red Hat rates the vulnerability as Important on RHEL 9 and 10 because their package builds incorporate discrete per-stream memory allocators for mod_http2. This memory isolation design prevents heap memory corruption from easily escalating to cross-thread arbitrary code execution, reducing the primary impact to process-level Denial of Service.
Are standalone mod_h2 modules updated simultaneously with Apache HTTP Server core updates?
No. Standalone mod_h2 builds hosted on GitHub are maintained separately from core Apache HTTP Server releases. The standalone repository was archived in June 2026 with version 2.0.42 as its final release. Systems running standalone builds must apply configuration mitigations or migrate to core distribution packages.
Sources and further reading
- Critical Apache HTTP/2 Flaw Could Let Unauthenticated Attackers Execute Code Remotely (The Hacker News)
- Critical RCE Vulnerability in Apache HTTP Server: Everything You Need To Know | Wiz Blog (Wiz Blog)
This article was drafted with AI assistance from the publicly cited sources and passed automated checks for structure and sourcing. Verify critical details against the vendor advisories linked above before acting.