
Laboratorio differenziale containerizzato e PoC HTTP/2 in stdlib per CVE-2026-119618, una race nell'allocatore di mod_http2 che causa corruzione dell'heap in Apache httpd 2.4.55-2.4.70, con evidenze ASan/TSan.
mod_http2 in assign_headers()| CVE | CVE-2026-119618 |
| Componente | Apache HTTP Server, modulo mod_http2 (mod_h2 autonomo) |
| Interessato | httpd 2.4.55 – 2.4.70 · mod_h2 2.0.8 – 2.0.42 |
| Corretto in | httpd 2.4.71 · mod_h2 2.0.43 |
| CWE | CWE-362 — Esecuzione concorrente con risorsa condivisa e sincronizzazione impropria |
| Impatto | Corruzione dell'heap in un processo figlio di httpd; potenziale esecuzione di codice remoto |
| Vettore | Rete, non autenticato, HTTP/2 (h2c in chiaro o h2 su TLS) |
| Attivazione | Una richiesta HTTP/2 senza corpo che trasporta Content-Type e nessun Content-Length, con la tabella degli header della richiesta riempita fino alla capacità massima |
| Commit di correzione | 824beab9b9424d6cfb29595248fdbf6c3dddeab1 (cherry-pick del trunk 5ed39287660daacd1233cb9bbc984b25fa9a4fe3) |
| PR upstream | apache/httpd#975 → apache/httpd#977, unito il 09-11-2026 |
| Crediti | Anthropic's OSS Scanner (ANT-2026-MAPKT6MZ); Anthony Weems e Simon Scannell, Google Cloud Vulnerability Research |
| Advisory | https://httpd.apache.org/security/vulnerabilities_24.html |
| Soluzione alternativa | rimuovere h2 e h2c dalla direttiva Protocols |
| Repository | https://github.com/googlesky/CVE-2026-119618 |
mod_http2 assegna a ogni stream HTTP/2 un pool proprio, e tale pool
eredita l'allocatore della connessione che possiede la sessione.
L'allocatore non ha mutex: apr_allocator_create() non ne crea uno, quindi
allocator_lock() è un no-op per l'intera connessione. L'elaborazione delle
richieste viene deliberatamente spostata su thread di lavoro con un
allocatore privato (c2_transit_create()) proprio affinché un worker
non tocchi mai l'allocatore della connessione. assign_headers() infrange
tale invariante: per una richiesta senza corpo che trasporta Content-Type
e nessun Content-Length, il worker scrive il Content-Length: 0
sintetizzato nella tabella dello stream condivisa invece che in
r->headers_in privato della richiesta. Quando la tabella è piena, tale
scrittura alloca un nuovo nodo da 8 KB dall'allocatore senza lock della
connessione mentre il thread della connessione sta allocando dalla stessa
free list o liberando verso di essa. Due thread possono estrarre lo stesso
nodo e la conseguente doppia proprietà corrompe l'heap del processo figlio
di httpd.
Questo repository contiene un laboratorio differenziale containerizzato che riproduce la corruzione su httpd 2.4.70, dimostra la race condition con ThreadSanitizer, mostra httpd 2.4.71 pulito sotto lo stesso traffico, esercita ogni forma di richiesta affine, verifica la soluzione alternativa pubblicata e registra una scansione 0-day sulla linea corretta.
modules/http2/h2_request.c, Apache httpd 2.4.70, assign_headers().
I numeri di riga provengono dal tarball della release 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: }
La correzione nella versione 2.4.71 modifica una riga:
- apr_table_setn(req->headers, "Content-Length", "0");
+ apr_table_setn(r->headers_in, "Content-Length", "0");
r->headers_in è il clone creato alla riga 325 in r->pool, il pool della richiesta
posseduto dal thread worker. req->headers è la tabella dello stream,
allocata dal pool dello stream e raggiungibile dal thread della connessione.
h2_session_open_stream() (h2_session.c:117) crea il pool per-stream
come figlio del pool della sessione e lo contrassegna:
apr_pool_create(&stream_pool, session->pool);
apr_pool_tag(stream_pool, "h2_stream");
stream = h2_stream_create(stream_id, stream_pool, session, ...);
Il session pool è un discendente del connection pool che l'MPM
crea in child_main() (server/mpm/prefork/prefork.c:423). L'allocator di quel pool
proviene da apr_allocator_create(), e non viene mai impostato alcun mutex
su di esso:
/* 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
}
L'elaborazione delle richieste, d'altra parte, è esplicitamente progettata per evitare
quell'allocatore. c2_transit_create() (h2_mplx.c:210) assegna a ogni worker
un allocatore privato:
/* 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);
Il request_rec del worker viene creato su c2->pool, un discendente del
transit pool, quindi ogni allocazione che il worker effettua normalmente è privata.
La scrittura vulnerabile è l'eccezione: essa alloca dallo stream pool,
il cui allocatore è quello della connessione.
apr_table_setn() su una chiave assente ricade su apr_table_add(),
che chiama table_push() → apr_array_push_noclear()
(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);
...
}
La tabella viene creata da h2_request_create() come
apr_table_make(pool, 10), quindi nalloc parte da 10 e raddoppia: 10, 20,
40, 80, 160. Gli pseudo-header non vengono memorizzati nella tabella — diventano
req->method, req->scheme, req->authority e req->path.
h2_request_end_headers() (h2_request.c:212) aggiunge esattamente una voce Host.
Una richiesta con 79 header regolari contiene quindi 79 voci, Host
porta a 80, e nelts == nalloc == 80 quando viene eseguito assign_headers(). La
chiamata vulnerabile apr_table_setn() fa crescere l'array a 160 voci:
160 * sizeof(apr_table_entry_t) = 160 * 24 = 3840 bytes
allocator_align() (apr_pools.c:268) arrotonda a MIN_ALLOC
(8192), quindi la scrittura richiede un nuovo nodo da 8 KB all'allocator dello stream pool
ogni volta che il nodo attivo del pool ha meno di 3840 byte rimanenti.
Questa è l'allocazione che genera la race.
allocator_alloc() (apr_pools.c:289) scorre la lista dei nodi liberi
(allocator->free[index], allocator->max_index) ed estrae un nodo;
allocator_free() (apr_pools.c:426) ne reinserisce uno e riscrive
max_index. Senza mutex, queste sono sequenze di read-modify-write non sincronizzate
sullo stesso apr_allocator_t — un oggetto heap da 200 byte
allocato da apr_allocator_create() in child_main(). Due thread possono
estrarre lo stesso nodo, dopodiché due pool diversi distribuiscono memoria
sovrapposta.
ThreadSanitizer cattura esattamente questo su 2.4.70
(evidence/tsan-vulnerable.txt):