
Laboratorio diferencial contenerizado y PoC HTTP/2 en stdlib para CVE-2026-119618, una condición de carrera en el asignador de mod_http2 que provoca corrupción del heap en Apache httpd 2.4.55-2.4.70, con evidencia de ASan/TSan.
mod_http2 de Apache httpd en assign_headers()| CVE | CVE-2026-119618 |
| Componente | Apache HTTP Server, módulo mod_http2 (mod_h2 independiente) |
| Afectados | httpd 2.4.55 – 2.4.70 · mod_h2 2.0.8 – 2.0.42 |
| Corregido en | httpd 2.4.71 · mod_h2 2.0.43 |
| CWE | CWE-362 — Ejecución concurrente usando un recurso compartido con sincronización incorrecta |
| Impacto | Corrupción del heap en un proceso hijo de httpd; posible ejecución remota de código |
| Vector | Red, sin autenticación, HTTP/2 (h2c en texto claro o h2 sobre TLS) |
| Disparador | Una petición HTTP/2 sin cuerpo que incluye Content-Type y no incluye Content-Length, con la tabla de cabeceras de la petición llena hasta su capacidad |
| Commit de corrección | 824beab9b9424d6cfb29595248fdbf6c3dddeab1 (cherry-pick del trunk 5ed39287660daacd1233cb9bbc984b25fa9a4fe3) |
| PR upstream | apache/httpd#975 → apache/httpd#977, fusionado el 2026-11-09 |
| Crédito | OSS Scanner de Anthropic (ANT-2026-MAPKT6MZ); Anthony Weems y Simon Scannell, Google Cloud Vulnerability Research |
| Aviso | https://httpd.apache.org/security/vulnerabilities_24.html |
| Solución alternativa | eliminar h2 y h2c de la directiva Protocols |
| Repositorio | https://github.com/googlesky/CVE-2026-119618 |
mod_http2 asigna a cada flujo HTTP/2 un pool propio, y ese pool
hereda el asignador de la conexión que posee la sesión. El
asignador no tiene mutex: apr_allocator_create() no crea ninguno, por lo que
allocator_lock() no hace nada para toda la conexión. El procesamiento de peticiones
se traslada deliberadamente a hilos de trabajo con un asignador privado
(c2_transit_create()) precisamente para que un hilo de trabajo nunca toque
el asignador de la conexión. assign_headers() rompe esa invariante: para una
petición sin cuerpo que incluye Content-Type y no incluye Content-Length, el
hilo de trabajo escribe el Content-Length: 0 sintetizado en la tabla de flujos
compartida en lugar de en el r->headers_in privado de la petición. Cuando la tabla
está llena, esa escritura asigna un nuevo nodo de 8 KB desde el asignador
sin bloqueos de la conexión mientras el hilo de la conexión está asignando desde o
liberando hacia la misma lista de libres. Dos hilos pueden extraer el mismo nodo, y
la doble propiedad resultante corrompe el heap del proceso hijo de httpd.
Este repositorio contiene un laboratorio diferencial en contenedores que reproduce la corrupción en httpd 2.4.70, demuestra la condición de carrera con ThreadSanitizer, muestra httpd 2.4.71 limpio bajo el mismo tráfico, ejercita todas las variantes de petición hermanas, verifica la solución alternativa publicada y registra un barrido de 0-day sobre la línea corregida.
modules/http2/h2_request.c, Apache httpd 2.4.70, assign_headers().
Los números de línea provienen del tarball de la versión 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 corrección en 2.4.71 cambia una línea:
- apr_table_setn(req->headers, "Content-Length", "0");
+ apr_table_setn(r->headers_in, "Content-Length", "0");
r->headers_in es el clon creado en la línea 325 en r->pool, el pool de la solicitud propiedad del hilo trabajador. req->headers es la tabla del stream, asignada desde el pool del stream y accesible por el hilo de conexión.
h2_session_open_stream() (h2_session.c:117) crea el pool por stream como hijo del pool de la sesión y lo etiqueta:
apr_pool_create(&stream_pool, session->pool);
apr_pool_tag(stream_pool, "h2_stream");
stream = h2_stream_create(stream_id, stream_pool, session, ...);
El pool de sesiones es un descendiente del pool de conexiones que el MPM
crea en child_main() (server/mpm/prefork/prefork.c:423). El asignador de ese pool
proviene de apr_allocator_create(), y nunca se establece un mutex
sobre él:
/* 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
}
El procesamiento de solicitudes, por otro lado, está diseñado explícitamente para evitar
ese asignador. c2_transit_create() (h2_mplx.c:210) le da a cada worker
un asignador privado:
/* 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);
El request_rec del worker se crea en c2->pool, un descendiente del
pool de tránsito, por lo que cada asignación que el worker normalmente realiza es privada.
La escritura vulnerable es la excepción: asigna desde el pool de flujo,
cuyo asignador es el de la conexión.
apr_table_setn() sobre una clave ausente recurre a apr_table_add(),
que llama a 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 tabla es creada por h2_request_create() como
apr_table_make(pool, 10), por lo que nalloc comienza en 10 y se duplica: 10, 20,
40, 80, 160. Los pseudoencabezados no se almacenan en la tabla — se convierten en
req->method, req->scheme, req->authority y req->path.
h2_request_end_headers() (h2_request.c:212) añade exactamente una entrada Host.
Por lo tanto, una solicitud con 79 encabezados regulares contiene 79 entradas, Host
hace 80, y nelts == nalloc == 80 cuando se ejecuta assign_headers(). El
apr_table_setn() vulnerable hace crecer el arreglo a 160 entradas:
160 * sizeof(apr_table_entry_t) = 160 * 24 = 3840 bytes
allocator_align() (apr_pools.c:268) redondea eso a MIN_ALLOC
(8192), por lo que la escritura solicita un nodo nuevo de 8 KB al asignador
del pool de streams siempre que al nodo activo del pool le queden menos de 3840 bytes.
Esa es la asignación que genera la condición de carrera.
allocator_alloc() (apr_pools.c:289) recorre la lista de nodos libres
(allocator->free[index], allocator->max_index) y extrae un nodo;
allocator_free() (apr_pools.c:426) devuelve uno y reescribe
max_index. Sin mutex, estas son secuencias de lectura-modificación-escritura
no sincronizadas sobre el mismo apr_allocator_t — un objeto de heap de 200 bytes
asignado por apr_allocator_create() en child_main(). Dos hilos pueden
extraer el mismo nodo, tras lo cual dos pools distintos entregan memoria
solapada.
ThreadSanitizer captura exactamente esto en 2.4.70
(evidence/tsan-vulnerable.txt):