Apache mod_http2 flaw lets HTTP/2 traffic reach RCE
CVE-2026-119618 is a critical race condition in Apache's HTTP/2 module. Who is affected, why HTTP/2 has to be on, and how to fix it.
By Yaali. November 14, 2026, 6 min read, Vulnerabilities, Patching.
Apache HTTP Server has a critical flaw, CVE-2026-119618, in mod_http2, the module that serves HTTP/2 (the second major version of the web's HyperText Transfer Protocol). It is a race condition: two threads touch the same memory at the same time without proper locking, and the result is heap corruption. An attacker who can send HTTP/2 requests, with no account and no prior access, can trigger it and, Red Hat's analysis says, steer the corruption toward running commands on the server. That is remote code execution (RCE), the worst outcome for a public web server. Apache fixed it in version 2.4.71 on November 11, 2026.
The affected code ships in Apache HTTP Server 2.4.55 through 2.4.70, and in the standalone mod_h2 package from GitHub, versions 2.0.8 through 2.0.42. Releases 2.4.54 and earlier do not contain the vulnerable code. One condition decides whether a server is reachable at all: HTTP/2 has to be turned on through the Protocols directive. A server configured for HTTP/1.1 only never runs the broken code and is not affected. Red Hat rates the flaw Critical with a CVSS score of 9.8 out of 10. As of November 12, 2026 it was not in the CISA Known Exploited Vulnerabilities (KEV) catalog and no in-the-wild exploitation had been confirmed.

How it works, and why HTTP/2 has to be on
HTTP/2 lets one connection carry many requests at once, each on its own stream, so a browser does not have to open a new connection per file. To keep up, mod_http2 spreads the work for those streams across worker threads while a separate connection thread manages the shared connection state. That split is where the bug lives.
In the function that assigns request headers, a worker thread writes into memory owned by the connection thread through a shared, lock-free allocator, with no synchronization between the two. Red Hat classifies it as CWE-362, a race condition caused by improper synchronization. By sending crafted concurrent HTTP/2 requests, an attacker makes the two threads collide and corrupt the heap. Heap corruption on its own is a crash; shaped carefully, it is a path to controlling what the process does next.
The Protocols directive is the switch that matters. HTTP/2 is negotiated as h2 over TLS or h2c in cleartext, and a server only speaks it when h2 or h2c appears in Protocols. If that directive lists http/1.1 only, requests never reach the vulnerable function. This is why two servers on the same Apache build can have very different exposure: the one terminating HTTP/2 is at risk, the HTTP/1.1 reverse proxy behind it is not.
What an attacker gets, and the exploitation picture
Code execution through mod_http2 runs as the user Apache runs as, usually a low-privilege web account. That is still enough to read everything the web server can read: the files it serves, the TLS private keys it loads, application configuration and any database credentials in it, and it gives a foothold to pivot deeper into the network. No login is needed to reach the flaw, so an internet-facing server with HTTP/2 on is directly exposed.
The exploitation status needs stating plainly, because sources describe it differently. Red Hat, whose advisory is the authoritative one here, says public research has demonstrated a reliable exploit against a default-configured server with the module enabled. Censys reports that no public proof of concept had been identified as of November 12, 2026. A third-party proof of concept published that day reproduces the heap corruption on 2.4.70 under memory sanitizers and comes back clean on 2.4.71, but it does not demonstrate code execution and its author is not linked to the teams that reported the bug. In short: a working exploit is credible and may already exist privately, none is public yet, and nothing has been seen in the wild. No indicators of compromise have been published, which is expected for a memory-corruption bug that leaves little clean trace. The one signal worth watching is unexplained Apache worker crashes or segmentation faults in the error log around the time of concurrent HTTP/2 traffic, since a failed attempt corrupts memory before it succeeds.

What to do
Upgrade to Apache HTTP Server 2.4.71 or later. If you run the standalone mod_h2 package from GitHub, there is no fixed mod_h2 release yet, so move to a patched Apache HTTP Server build instead. Apache has published no workaround other than turning HTTP/2 off until you can patch.
Check the mod_http2 package version, not the httpd banner. RHEL-family and Ubuntu builds backport the fix into their own package without changing the upstream version string, so httpd -v or apache2 -v can keep reporting 2.4.x while the module is already patched, or still show a version that looks safe while the module is not. On RHEL and its rebuilds, the module is its own package: run rpm -q mod_http2 and compare it against the version in Red Hat advisory RHSB-2026-017 or your distribution's advisory. On Debian and Ubuntu, mod_http2 ships inside apache2-bin, so check dpkg -l apache2-bin; Ubuntu backported newer module code, so match the package version to Ubuntu's advisory rather than reading the number alone.
If you cannot patch today, disable HTTP/2. Set Protocols http/1.1 in the main configuration and in every virtual host that overrides Protocols, then restart Apache for it to take effect. This removes the exposure at the cost of HTTP/2's performance, and it is a stopgap, not the fix.
To tell whether HTTP/2 is even on, do two checks. Confirm the module is loaded: httpd -M 2>/dev/null | grep http2 on RHEL, or apache2ctl -M 2>/dev/null | grep http2 on Debian and Ubuntu. Then look for where it is enabled: grep -ri protocols /etc/httpd/ /etc/apache2/ lists every Protocols line, so you can see which sites include h2 or h2c. If the module is absent or no site negotiates HTTP/2, that server is not exposed, though you should still patch it on your normal schedule.
The distro-package trap
This flaw is a clean example of why the httpd version banner is the wrong thing to trust on a packaged install. Distributions patch in place and leave the version number alone, so a vulnerability tracker that reads the banner can report either a false alarm or a false all-clear. The package version is the fact that matters.
Red Hat's rating adds one more wrinkle worth knowing. While the upstream flaw is Critical, Red Hat rates the mod_http2 packages in RHEL 9 and RHEL 10 as Important rather than Critical, because those builds give each HTTP/2 stream its own allocator, which substantially raises the difficulty of exploiting the race. That lowers the odds against a RHEL 9 or 10 server; it does not make them safe, and Red Hat still ships the fix. Treat its advisory as the authoritative source for the RHEL-family packages and patch accordingly.
Working out which of your Apache servers actually terminate HTTP/2 from the internet is the hard part of this, and it is the kind of question our attack surface management work answers by mapping what is reachable rather than what an inventory claims. The underlying bug, a shared buffer written without a lock, is also exactly what we probe for in a web application test. If you want a second opinion on your exposure, open the chat and Yaali, our AI agent, will pass the question to the engineer who would do the work.
Sources: Red Hat RHSB-2026-017, Red Hat CVE-2026-119618, Censys advisory, Horizon3 analysis, Rescana, Wiz, Apache HTTP Server mod_http2 documentation.
Read next
- Node.js patched 16 flaws: upgrade your runtime
- Skyfall and Mior break AMD confidential VMs
- aiohttp 3.14.4 fixes four denial-of-service flaws
Back to the blog, or tell us about your system in the chat. Yaali, our AI agent, answers first and brings in an engineer.