Apache shipped 2.4.71 on 11 November 2026 with three fixes, one of them critical, and that one is a race in the HTTP/2 module 1. The advisory names 2.4.55 through 2.4.70, and the standalone mod_h2 releases from 2.0.8 through 2.0.42 1. I have watched enough version ranges wash over an inventory that reports clean to stop treating the range as a measure of exposure. It tells me where to look and says nothing about what is reachable.

The write lands in the table that belongs to the connection

HTTP/2 carries many requests at once over one connection. mod_http2 keeps the connection on one thread and hands each stream to a worker thread. When a worker begins a request, assign_headers() copies the request’s headers into a table of its own.

One path skipped that private copy. If a request arrived with a Content-Type header, no Content-Length, and no body, the function added Content-Length: 0 to the headers table that belongs to the connection instead of the worker’s table 2. The threads draw from a shared allocator with no lock, so a write from the worker can land in memory the connection thread is using at that moment, and the heap of the child process is corrupted. Red Hat describes the root cause the same way, a worker thread writing into memory the connection thread owns 3.

The fix is a one line change, commit 824beab on the 2.4.x branch, which writes the header into the request’s own table 13. Apache labels the bug critical, and the scores disagree. The NVD record carries no score from NIST, an 8.1 from CISA-ADP with attack complexity marked high, and Red Hat scores it 9.8 43. Those two numbers are measuring the same code from different seats, and the gap between them is a reason to check reachability instead of arguing about the number.

The version string is wrong in both directions

The number on the box misleads in two directions.

Ubuntu 20.04 and 22.04 ship apache2 2.4.41 and 2.4.52, below the upstream range, and both are affected because Ubuntu carried a newer mod_http2 into those packages 2. A filter that starts at 2.4.55 misses them.

The other direction: on RHEL 9 and 10 the fix arrives as a mod_http2 package update and the httpd version number does not change 32. A host reporting 2.4.62 after patching is patched, and a host reporting 2.4.62 before patching is not, and httpd -v cannot tell them apart. I compare the module package against the vendor errata instead of the server banner.

A container image can also sit inside the affected range and carry no mod_http2 at all. Sysdig scanned one httpd image that the CVE matched on version and found no module inside it 3. That finding goes in the patch record as an accept risk with the module check attached, and the record is what keeps the image out of the queue.

The wire check counts more than the config

The reachability condition is a Protocols directive listing h2 or h2c, with the module loaded 2. Apache’s default is http/1.1, so somebody turned HTTP/2 on: a distribution package, a control panel, or an administrator chasing a performance score.

I grep the config to see what it was set to, then ask the server itself with a curl:

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

A 2 means the server negotiated HTTP/2 and the vulnerable code ran. A 1.1 means it did not. I run the same check with --http2-prior-knowledge against cleartext, because h2c reaches the same code and the public proof of concept targets it 3.

I have seen this check go wrong in two places. A CDN or load balancer that terminates HTTP/2 and forwards HTTP/1.1 to the origin protects nothing while a client can reach the origin address directly, and the public hostname only describes the CDN 2. And a Protocols line inside a virtual host replaces the server-wide setting rather than adding to it, so a mitigation applied to the main config leaves every vhost that carries its own line as exposed as before 2. I test the origin address rather than the public name, and I read the Protocols line in every vhost instead of trusting the global one.

A crash reproduction is not an exploitation report

This part matters more than the score. A public proof of concept landed on 12 November, a day after disclosure. It reproduces heap corruption on 2.4.70 under memory and thread sanitizers and runs clean on 2.4.71 32. Its README describes heap corruption and potential code execution, and the write-ups that analyzed it agree that it corrupts memory without delivering a payload 32.

Red Hat’s entry says public research demonstrated a reliable exploit against a default-configured server, and it names no research behind that claim; the two write-ups I read could not locate a matching exploit either 32. Apache and CISA reported no attacks, and the CVE was absent from the KEV catalog on 20 November 2.

I do not wait for an exploitation flag before I order this work. A one line fix and a public crash reproduction tell me the remaining work is timing, and timing is not a barrier I want to test against a web tier. I will not write “no known exploitation” into a memo as if it were a finding. The honest sentence is that nobody has reported it, which says something about reporting and nothing about use.

What I hand off, and in what order

The patch goes out through the automated deployment path. What I add is the order, and the order comes from reachability: internet-facing hosts that negotiate h2 or h2c first, then bundled httpd inside appliances and images, then internal servers where an attacker who is already inside would find them useful.

The cheap signal while the patch is in flight is Apache’s own error log. Memory corruption that misses its target kills the child process, and Apache records it as AH00052 with a segmentation fault and the pid, or AH00051 when a core file exists 2. A host with a clean history that starts producing those lines is the earliest evidence I will get, and it costs one search against logs I already collect.

The servers that negotiate HTTP/2 need the patch first, and the check costs a minute per host.


  1. Apache Software Foundation. (2026, November 11). Apache HTTP Server 2.4 vulnerabilities. https://httpd.apache.org/security/vulnerabilities_24.html ↩︎ ↩︎ ↩︎

  2. Waqas, M. (2026, November 21). Apache CVE-2026-119618 HTTP/2 RCE: Patching and hunting. ThreatDefence. https://threatdefence.com/article/apache-http-server-cve-2026-119618-http2-rce-patching-hunting ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎

  3. Sysdig Threat Research Team. (2026, November 13). HTTPd (CVE-2026-119618): Detecting heap corruption and RCE in Apache HTTP Server mod_http2. Sysdig. https://www.sysdig.com/blog/httpd-cve-2026-119618-detecting-heap-corruption-and-rce-in-apache-http-server-mod-http2 ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎

  4. National Institute of Standards and Technology. (2026, November 14). CVE-2026-119618 detail. National Vulnerability Database. https://nvd.nist.gov/vuln/detail/CVE-2026-119618 ↩︎