Critical PHP and Node.js flaws php2shell + node2shellTest my domain
ApacheHTTP/2RCECVEVulnerabilityWeb hosting

CVE-2026-119618: remote code execution in Apache HTTP Server's HTTP/2 module

CVE-2026-119618: memory corruption in mod_http2, Apache HTTP Server 2.4.55 to 2.4.70, fixed in 2.4.71. Patch analysis, fixed packages, workaround.

by 16 min read
CVE-2026-119618: remote code execution in Apache HTTP Server's HTTP/2 module

Background

On 11 November 2026, the Apache project released version 2.4.71 of its HTTP server. It fixes three flaws, one of them rated critical: CVE-2026-119618, in mod_http2, the module that implements HTTP/2.

The advisory is one sentence long. A synchronization defect between threads in the assign_headers() function corrupts the server's memory and can lead to remote code execution. Apache gives no CVSS score, no exploitation condition and no workaround.

Secondary sources contradict each other on several points: the score, whether exploit code exists, the fixed version of the standalone module. So we went back to primary sources. We read the fix and compared the mod_http2 code across ten httpd releases, from 2.4.55 to 2.4.71.

We did not reproduce the flaw in a lab. This article separates what we read in the code from what rests on advisories and on third-party work.

Technical summary

ItemValue
IdentifierCVE-2026-119618, assigned by Apache
Componentmod_http2, function assign_headers() (modules/http2/h2_request.c)
ClassCWE-362, concurrent execution using a shared resource with improper synchronization
Severity"Critical" for Apache, with no score. Red Hat: CVSS 3.1 of 9.8. NVD record in "Received" status
Affected versionsApache HTTP Server 2.4.55 to 2.4.70; standalone mod_h2 module 2.0.8 to 2.0.42
FixApache HTTP Server 2.4.71, released on 11 November 2026
ConditionHTTP/2 enabled. A server restricted to HTTP/1.1 is not affected
DiscoveryAnthropic's OSS Scanner (26 October), then Anthony Weems and Simon Scannell, Google Cloud (3 November)
ExploitationNone reported as of 12 November; not in the KEV catalog (10 November edition)

The 9.8 score comes from Red Hat, with the vector AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H. Neither Apache nor NVD publishes one at this date. Several articles present it as the official score of the CVE, which it is not.

That vector carries AC:L, low attack complexity. For a race condition that corrupts a memory allocator, this is a severe reading. Red Hat justifies it by the existence of a reliable public exploit, a point we come back to below.

We would treat this flaw as critical on any Internet-facing Apache server that negotiates HTTP/2. Our way of sorting this kind of advisory is described in the article on vulnerability prioritization.

Affected systems

Three conditions must be met:

  1. an Apache HTTP Server version between 2.4.55 and 2.4.70;
  2. the mod_http2 module loaded;
  3. HTTP/2 offered to clients, meaning h2 (over TLS) or h2c (cleartext) in a Protocols directive, at server or virtual host level.

The lower bound has an explanation. 2.4.55 is the release that moved mod_http2 from the 1.15 line to the 2.0 line, with a rewritten internal architecture. 2.4.54 still ships 1.15.28.

The default value of Protocols in httpd is http/1.1. A server built from source is therefore only exposed if its administrator enabled HTTP/2. Distributions sometimes make that choice for them: on Debian and Ubuntu, a2enmod http2 loads the module and declares the protocols in one step.

The standalone mod_h2 module, distributed on GitHub, is affected from 2.0.8 to 2.0.42. Its repository has been archived since 9 June 2026 and stops at 2.0.42. Some sources mention a fixed 2.0.43 release: we could not find it anywhere. 2.4.71 itself still reports mod_http2 as 2.0.42, with the fix included.

Two practical consequences follow. The mod_http2 version number does not tell you whether the fix is present. And those who built mod_h2 separately have no other path than the module shipped with httpd 2.4.71.

Distributions

Distributions backport the fix without changing the upstream version number. The package is what matters, not the server banner.

DistributionStatus recorded on 12 November 2026
Debian 13 (trixie)Fixed by apache2 2.4.71-1~deb13u1 (DSA-6620-1)
Debian 12 (bookworm)Marked vulnerable, no fixed package (2.4.68-1deb12u1 and 2.4.67-1deb12u3)
Debian forky, sidforky vulnerable (2.4.69-1), sid fixed (2.4.71-1)
RHEL 9Fixed by mod_http2 2.0.26-7.el9_9.1 (RHSA-2026
), severity "Important"
RHEL 10Fixed by mod_http2 2.0.29-5.el10_3.1 (RHSA-2026
), severity "Important"
RHEL 8 and earlierNot affected
AlmaLinux, CloudLinux 9 / 10Fixed by 2.0.26-6.el9_8.2.alma.1 and 2.0.29-4.el10_2.2.alma.1, according to CloudLinux
cPanel (EasyApache 4)Version 2.4.71 available in the stable channel, according to CloudLinux
Ubuntu, SUSENo record published for this CVE when we checked

Red Hat also published errata for its extended support releases (9.4, 9.6, 9.8, 10.0, 10.2). JBoss Core Services and Red Hat's hardened images are listed as affected, with no fix referenced at this date.

Container images deserve separate attention. An httpd image built before 11 November ships a vulnerable version and will keep doing so until it is rebuilt.

How it works

The advisory does not describe the mechanism. What follows comes from our reading of the httpd 2.4.70 and 2.4.71 code, complemented by Red Hat's statement, which confirms the cause.

Two threads per request

HTTP/2 multiplexes several requests over one connection. In mod_http2, one thread holds the connection with the client: it reads frames and creates an object per stream. Each request is then handed to a worker thread, which runs the usual Apache modules.

These two threads are not allowed to share their working memory. Allocators in the APR library are not re-entrant, and a comment in h2_mplx.c says so: each worker thread gets its own allocator for that reason.

The request headers, however, are read by the connection thread. They are stored in a table (req->headers) allocated from the stream's memory, hence on the connection side.

The write in the wrong place

When the worker thread picks up the request, assign_headers() starts by copying that table into its own, r->headers_in. All subsequent processing should work on the copy.

One line is an exception. If the request has no body, carries a Content-Type and no Content-Length, the module adds a Content-Length: 0. Up to 2.4.70, it added it to the original table:

-                apr_table_setn(req->headers, "Content-Length", "0");
+                apr_table_setn(r->headers_in, "Content-Length", "0");

That line is the entire fix. The worker thread was writing into a table that belongs to the connection thread, and that depends on its allocator.

The defect also had a functional effect, visible in the code: the header was written to the original after the copy, so it never reached the request being processed. The line had not been doing its job since 2.4.55.

From the write to the corruption

An APR table is an array that doubles in size when full. The headers table is created with ten slots. If adding Content-Length lands on a full table, the worker thread triggers an allocation in the stream's memory.

Meanwhile, the connection thread keeps allocating and freeing for the other streams. Two threads then operate on the same allocator without a lock. Red Hat describes it in the same terms: a worker thread writes into memory owned by the connection thread through a shared, lock-free allocator.

The author of a public proof of concept places the most favorable case at 80 entries in the table, that is 79 headers sent by the client. Apache's default limit is 100 fields (LimitRequestFields). The request therefore remains valid on a standard configuration.

Kill chain

From an HTTP/2 request to allocator corruption

  1. 1

    Bodyless request

    the client sends headers with a Content-Type, no Content-Length, and closes the stream in the same frame.

  2. 2

    Full table

    the number of headers is chosen so that the stream's table has no free slot left.

  3. 3

    Cross-thread write

    the worker thread adds Content-Length: 0 to the connection thread's table, which has to grow.

  4. 4

    Shared allocator

    both threads allocate at the same time from the same allocator, and two calls can receive the same block.

  5. Corrupted memory

    the process heap is inconsistent. The outcome ranges from a crash to an attacker-controlled write.

The first three steps can be read in the httpd 2.4.70 code. The last two rest on Red Hat's statement and on a public proof of concept that we did not run.

Not all versions are equal

Comparing releases, we noticed that stream memory has not always been allocated the same way. This detail changes how hard exploitation is.

httpd versionsmod_http2Stream memory
2.4.55 to 2.4.632.0.11 to 2.0.27Connection's allocator
2.4.64 to 2.4.662.0.32 to 2.0.35Per-stream allocator
2.4.67 to 2.4.702.0.39 to 2.0.42Connection's allocator

The per-stream allocator was removed in mod_h2 2.0.39, following problems reported with third-party modules. Versions 2.4.67 to 2.4.70, the most recent and therefore the most common on well-maintained systems, went back to the shared allocator.

This explains Red Hat's dual rating. Its packages for RHEL 9 and 10 allocate each stream from a separate allocator, which, according to the vendor, "substantially increases the complexity" of exploitation. The flaw is rated "Important" there rather than "Critical".

We would not read this table as a list of safe versions. The faulty write is present from 2.4.55 to 2.4.70, and Apache lists the whole range as affected.

Exploitation status

Sources do not say the same thing, and they are better quoted separately.

Red Hat writes that public research has demonstrated a reliable exploit against a default-configured server with the HTTP/2 module enabled. The record points to no publication. Wiz, on the same day, states that no exploit code is available and that no attack has been reported.

What we found sits between the two. A GitHub repository publishes a containerized lab and code that triggers the race. According to its README, the results on 2.4.70 are crashes and AddressSanitizer and ThreadSanitizer reports, including a use-after-free. On 2.4.71, the same traffic produces nothing.

That code demonstrates the corruption, not code execution. Its author in fact describes the latter as a "potential" impact. We found no complete published exploit chain.

Two things still make us keep the critical rating. The two credited teams, at Anthropic and Google, are the kind that take a bug all the way to exploitation. And denial of service is already a given: bringing down Apache processes with a few thousand requests no longer takes any research.

Wiz estimates that 64% of the cloud environments it observes contain a version in the affected range, and 51% a publicly exposed instance. The vendor notes that these figures do not account for configuration. The share actually exposed, where HTTP/2 is enabled, is therefore lower and is not known.

Checking a server

The version and loaded modules can be read on the server itself:

apachectl -v
apachectl -M | grep -i http2

No output from the second command means the module is not loaded and the server is not affected. Otherwise, the remaining question is whether HTTP/2 is offered:

grep -RniE '^\s*Protocols' /etc/apache2 /etc/httpd 2>/dev/null

Each virtual host can carry its own directive. A single h2 or h2c is enough to expose the server.

On RHEL and its derivatives, the fix can be confirmed in the package changelog:

rpm -q --changelog mod_http2 | grep CVE-2026-119618

From the outside, all you can establish is that HTTP/2 is negotiated:

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

A 2 in the output means the connection used HTTP/2. It does not say who speaks it. Behind a CDN or a load balancer, that device often terminates HTTP/2 and relays to Apache over HTTP/1.1, in which case the module is not reached through that path. The origin server still has to be unreachable directly.

The Server banner does not settle it either. It is often hidden, and a package fixed by a distribution keeps its old version number.

Remediation

  1. Upgrade to Apache HTTP Server 2.4.71, or install the distribution's fixed package.
  2. Restart the service. The module is loaded in memory: until the processes are restarted, the old code keeps running.
  3. Rebuild container images based on an earlier version, then redeploy.
  4. Start with Internet-facing servers that negotiate HTTP/2, including origin servers behind a CDN if they can still be reached directly.

Workaround

Apache publishes no workaround. Red Hat does state that a server restricted to HTTP/1.1 is not vulnerable, and that is the measure we would apply where the upgrade has to wait.

It means removing h2 and h2c from every Protocols directive, virtual hosts included:

Protocols http/1.1

On Debian and Ubuntu, a2dismod http2 followed by a restart achieves the same result. Clients fall back to HTTP/1.1 without errors. The cost is a performance loss on pages that load many resources.

We would not count on lowering LimitRequestFields to block the request. The headers table doubles at 10, 20, 40 and then 80 entries, and the faulty write happens whatever their number.

Looking for signs of compromise

Neither Apache nor vendors have published indicators of compromise. The request that triggers the flaw is a valid HTTP/2 request, with no signature of its own on the network.

The only signal we see is indirect. A failed attempt most often brings down a process, which Apache records in its error log:

grep -E 'AH00052|exit signal (Segmentation fault|Aborted)' /var/log/apache2/error.log

The log path varies by distribution (/var/log/httpd/error_log on RHEL). A series of crashes after 11 November, on a server that had been stable until then, is worth correlating with the access logs of the same moment.

This signal has two limits. An isolated crash has many other possible causes. And a successful exploit does not necessarily leave a crash behind.

Timeline

Two teams reported the flaw eight days apart, with no apparent link between them. The first report came from an automated analysis tool. When two researchers find the same defect within the same fortnight, it is reasonable to assume others can find it too.

The fix shipped sixteen days after the first report. Its commit is titled "assign_headers update table", with no mention of security, and is dated 9 November, two days before the advisory.

Timeline

Timeline of CVE-2026-119618

Report

  1. 26 October 2026

    First report

    Anthropic's OSS Scanner reports the flaw to the Apache security team (reference ANT-2026-MAPKT6MZ).

  2. 3 November 2026

    Second report

    Anthony Weems and Simon Scannell, of Google Cloud Vulnerability Research, report the same defect.

Fix

  1. 9 November 2026, 01

    Fix commit

    one line changed in h2_request.c, backported to the 2.4.x branch at 02.

  2. 11 November 2026

    Apache HTTP Server 2.4.71

    release, advisory and announcement on oss-security.

  3. 11 November 2026, 12

    Red Hat record

    CVSS 9.8, errata for RHEL 9 and 10 the same day. NVD record published at 15.

Aftermath

  1. 12 November 2026

    Status at this date

    NVD record without a score, flaw absent from the KEV catalog, public proof of concept limited to a crash.

Dates taken from Apache's security page, the httpd git repository, and the Red Hat and NVD records. Times in UTC.

The other fixes in 2.4.71

The same release fixes two flaws of lower severity.

CVE-2026-106023, rated "important", is a NULL pointer dereference in mod_md, the ACME certificate management module. It crashes a process during request handling and affects versions 2.4.30 to 2.4.70.

CVE-2026-109163, rated "low", is a one-byte stack overflow in mod_vhost_alias. It only affects 2.4.69 and 2.4.70 and follows an earlier fix.

mod_http2 had already received at least two memory corruption fixes in 2026: CVE-2026-23918 (double free, fixed in 2.4.67) and CVE-2026-48913 (use-after-free, fixed in 2.4.68). The pace of fixes in this module is a good reason to ask, server by server, whether HTTP/2 is actually useful there.

Knowing where Apache runs

Upgrading is simple on a server you know about. The hard part, on the day of an advisory like this one, is finding all the others: the old server behind a marketing site, the internal tool published for a contractor, the staging environment left online.

Apache is also the server that runs PHP on a large share of hosting setups. The machines affected by php2shell three weeks ago are often the same ones, and those that were not updated then now carry both.

That list is not drawn up on the day of the advisory. It is kept current continuously, by inventorying your external attack surface.

Frequently asked questions about CVE-2026-119618

What is CVE-2026-119618?

A flaw in Apache HTTP Server's HTTP/2 module, rated critical by Apache. A worker thread writes into a structure that belongs to the connection thread, which corrupts the process's memory allocator. Apache states that it can lead to remote code execution.

Which Apache versions are affected?

Versions 2.4.55 to 2.4.70, when mod_http2 is loaded and HTTP/2 is enabled. Versions 2.4.54 and earlier ship a previous generation of the module, which does not contain the code at fault. 2.4.71 is fixed.

Is my server affected if HTTP/2 is disabled?

No. The flaw is only reachable if h2 or h2c appears in a Protocols directive. A server that only speaks HTTP/1.1 never runs the vulnerable code.

Is there a workaround?

Apache publishes none. Removing h2 and h2c from every Protocols directive, then restarting the service, closes the attack path until the upgrade. Clients fall back to HTTP/1.1.

Is the flaw being exploited?

No exploitation has been reported as of 12 November 2026, and the flaw is not in CISA's KEV catalog. Public code triggers the memory corruption and crashes a process. Red Hat mentions a reliable exploit demonstrated publicly, without giving a reference.

Why does Red Hat rate the flaw "Important" on RHEL 9 and 10?

Because its packages allocate each HTTP/2 stream from a separate allocator, which makes exploitation harder according to the vendor. The 9.8 score and the critical rating apply to the upstream code. The RHEL 9 and 10 packages still need updating.

Are Nginx and other servers affected?

No. The defect is in the mod_http2 code, specific to Apache HTTP Server. It is not a weakness of the HTTP/2 protocol.

Sources

Let’s discuss your external exposure

Request a personalized Flawfence demo and discover your real exposure level.