
Containerisiertes Differenzial-Lab und stdlib-HTTP/2-PoC für CVE-2026-119618, ein Allocator-Race in mod_http2, das Heap-Korruption in Apache httpd 2.4.55-2.4.70 verursacht, mit ASan/TSan-Nachweisen.
mod_http2 Heap-Korruption in assign_headers()| CVE | CVE-2026-119618 |
| Komponente | Apache HTTP Server, Modul mod_http2 (eigenständiges mod_h2) |
| Betroffen | httpd 2.4.55 – 2.4.70 · mod_h2 2.0.8 – 2.0.42 |
| Behoben in | httpd 2.4.71 · mod_h2 2.0.43 |
| CWE | CWE-362 — Concurrent Execution using Shared Resource with Improper Synchronization |
| Auswirkung | Heap-Korruption in einem httpd-Kindprozess; potenzielle Remote-Code-Ausführung |
| Vektor | Netzwerk, unauthentifiziert, HTTP/2 (Klartext h2c oder TLS h2) |
| Auslöser | Eine HTTP/2-Anfrage ohne Body, die Content-Type und kein Content-Length enthält, wobei die Request-Header-Tabelle bis zur Kapazitätsgrenze gefüllt ist |
| Fix-Commit | 824beab9b9424d6cfb29595248fdbf6c3dddeab1 (Cherry-Pick von Trunk 5ed39287660daacd1233cb9bbc984b25fa9a4fe3) |
| Upstream-PR | apache/httpd#975 → apache/httpd#977, gemergt am 2026-11-09 |
| Danksagung | Anthropic's OSS Scanner (ANT-2026-MAPKT6MZ); Anthony Weems und Simon Scannell, Google Cloud Vulnerability Research |
| Sicherheitshinweis | https://httpd.apache.org/security/vulnerabilities_24.html |
| Workaround | h2 und h2c aus der Protocols-Direktive entfernen |
| Repository | https://github.com/googlesky/CVE-2026-119618 |
mod_http2 gibt jedem HTTP/2-Stream einen eigenen Pool, und dieser Pool
erbt den Allocator der Verbindung, die die Session besitzt. Der
Allocator hat keinen Mutex: apr_allocator_create() erzeugt keinen, daher
ist allocator_lock() für die gesamte Verbindung ein No-op. Die
Anfrageverarbeitung wird bewusst auf Worker-Threads mit einem privaten
Allocator (c2_transit_create()) verlagert, gerade damit ein Worker niemals
den Allocator der Verbindung berührt. assign_headers() bricht diese
Invariante: Bei einer Anfrage ohne Body, die Content-Type und kein
Content-Length enthält, schreibt der Worker das synthetisierte
Content-Length: 0 in die gemeinsame Stream-Tabelle statt in die
anfrageprivate r->headers_in. Wenn die Tabelle voll ist, alloziert dieser
Schreibvorgang einen neuen 8-KB-Knoten aus dem lock-freien Allocator der
Verbindung, während der Verbindungs-Thread aus derselben Free-List alloziert
oder an sie freigibt. Zwei Threads können denselben Knoten entnehmen, und
die daraus resultierende doppelte Eigentümerschaft korrumpiert den Heap des
httpd-Kindprozesses.
Dieses Repository enthält ein containerisiertes Differenzial-Labor, das die Korruption auf httpd 2.4.70 reproduziert, die Race mit ThreadSanitizer nachweist, httpd 2.4.71 unter demselben Traffic als sauber zeigt, jede verwandte Anfrageform durchspielt, den veröffentlichten Workaround verifiziert und einen 0-Day-Sweep auf der behobenen Linie dokumentiert.
modules/http2/h2_request.c, Apache httpd 2.4.70, assign_headers().
Die Zeilennummern stammen aus dem Release-Tarball von 2.4.70.
320: static void assign_headers(request_rec *r, const h2_request *req,
321: int no_body, int is_connect)
322: {
323: const char *cl;
324:
325: r->headers_in = apr_table_clone(r->pool, req->headers);
...
341: /* Unless we open a byte stream via CONNECT, apply content-length guards. */
342: if (!is_connect) {
343: cl = apr_table_get(req->headers, "Content-Length");
344: if (no_body) {
345: if (!cl && apr_table_get(req->headers, "Content-Type")) {
346: /* If we have a content-type, but already seen eos, no more
347: * data will come. Signal a zero content length explicitly.
348: */
349: apr_table_setn(req->headers, "Content-Length", "0");
350: }
351: }
Die Korrektur in 2.4.71 ändert eine Zeile:
- apr_table_setn(req->headers, "Content-Length", "0");
+ apr_table_setn(r->headers_in, "Content-Length", "0");
r->headers_in ist der Klon, der in Zeile 325 in r->pool erstellt wird, dem Request-Pool, der dem Worker-Thread gehört. req->headers ist die Tabelle des Streams, die aus dem Stream-Pool zugewiesen und vom Connection-Thread erreichbar ist.
h2_session_open_stream() (h2_session.c:117) erstellt den Pool pro Stream als Kind des Session-Pools und versieht ihn mit einem Tag:
apr_pool_create(&stream_pool, session->pool);
apr_pool_tag(stream_pool, "h2_stream");
stream = h2_stream_create(stream_id, stream_pool, session, ...);
Der Session-Pool ist ein Nachkomme des Connection-Pools, den der MPM
in child_main() (server/mpm/prefork/prefork.c:423) erstellt. Der Allocator dieses Pools
stammt aus apr_allocator_create(), und es wird niemals ein Mutex
darauf gesetzt:
/* memory/unix/apr_pools.c:164 */
static APR_INLINE void allocator_lock(apr_allocator_t *allocator)
{
#if APR_HAS_THREADS
if (allocator->mutex) /* NULL for the MPM allocator */
apr_thread_mutex_lock(allocator->mutex);
#endif
}
Die Anforderungsverarbeitung hingegen ist ausdrücklich so konzipiert, dass sie
diesen Allocator vermeidet. c2_transit_create() (h2_mplx.c:210) gibt jedem Worker
einen privaten Allocator:
/* We create a pool with its own allocator to be used for
* processing a request. This is the only way to have the processing
* independent of its parent pool in the sense that it can work in
* another thread.
*/
rv = apr_allocator_create(&allocator);
Der request_rec des Workers wird auf c2->pool erzeugt, einem Nachfahren des
Transit-Pools, sodass jede Allokation, die der Worker normalerweise vornimmt, privat ist.
Der verwundbare Schreibvorgang ist die Ausnahme: Er allokiert aus dem Stream-Pool,
dessen Allokator der der Verbindung ist.
apr_table_setn() bei einem fehlenden Schlüssel fällt auf apr_table_add() durch,
welches table_push() → apr_array_push_noclear() aufruft
(tables/apr_tables.c:126):
if (arr->nelts == arr->nalloc) {
int new_size = arr->nalloc <= 0 ? 1 : 2 * arr->nalloc;
apr_table_entry_t *new_elts = apr_palloc(arr->pool, elt_size * new_size);
...
}
Die Tabelle wird von h2_request_create() als
apr_table_make(pool, 10) erstellt, sodass nalloc bei 10 beginnt und sich verdoppelt: 10, 20,
40, 80, 160. Pseudo-Header werden nicht in der Tabelle gespeichert — sie werden zu
req->method, req->scheme, req->authority und req->path.
h2_request_end_headers() (h2_request.c:212) fügt genau einen Host-Eintrag hinzu.
Eine Anfrage mit 79 regulären Headern enthält daher 79 Einträge, Host
macht daraus 80, und nelts == nalloc == 80, wenn assign_headers() ausgeführt wird. Das
verwundbare apr_table_setn() vergrößert das Array auf 160 Einträge:
160 * sizeof(apr_table_entry_t) = 160 * 24 = 3840 bytes
allocator_align() (apr_pools.c:268) rundet dies auf MIN_ALLOC
(8192) auf, sodass der Schreibvorgang einen frischen 8-KB-Knoten vom Allocator des Stream-Pools anfordert, wann immer im aktiven Knoten des Pools weniger als 3840 Bytes übrig sind.
Das ist die Allokation, die das Rennen verursacht.
allocator_alloc() (apr_pools.c:289) durchläuft die Liste der freien Knoten
(allocator->free[index], allocator->max_index) und entnimmt einen Knoten;
allocator_free() (apr_pools.c:426) legt einen zurück und schreibt
max_index neu. Ohne Mutex sind dies unsynchronisierte Read-Modify-Write-
Sequenzen auf demselben apr_allocator_t — einem 200-Byte-Heap-Objekt,
das von apr_allocator_create() in child_main() alloziert wird. Zwei Threads können
denselben Knoten entnehmen, woraufhin zwei verschiedene Pools überlappenden
Speicher ausgeben.