Skip to content
KitploitKITPLOIT
HerramientasExploitsBlog
Log in
Enviar
HerramientasExploitsBlog
Enviar

¡Herramientas de Hacking, PenTest y Ciberseguridad para tu Arsenal de Seguridad!

Kitploit es un directorio de herramientas de hacking, ciberseguridad y pentesting. Descubre las últimas actualizaciones de proyectos para encontrar vulnerabilidades, analizar sistemas, automatizar pruebas y fortalecer tu seguridad.

FeedsContactoPrivacidad© 2026 Kitploit

Directorio de Herramientas

Categorías

Ver todas las categorías
Loading categories
CVE-2026-119618 — 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. | Kitploit
Herramientas/GitHubGitHub/googlesky/cve-2026-119618
Escáneres de Vulnerabilidades WebSeguridad de ContenedoresAnálisis Dinámico (Sandboxing)ExplotaciónSeguridad WebFuzzingPapers e InvestigaciónLabs y Práctica
GitHubgooglesky/cve-2026-119618

CVE-2026-119618

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.

147hace 2 díasAún no revisado
Ver Repositorio

Más Populares

Ver todos →

Descubre las herramientas más usadas por nuestra comunidad.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 El kit de herramientas OSINT definitivo: grafo de investigación, puntuación de confianza, familias de alias, mapa, línea de tiempo e informes. 49 módulos, más de 400 sitios, sin necesidad de claves API.

    1.0k
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Aplicación de Ejecución con un Solo Toque GhostLock (CVE-2026-43499)

    627
  • 3

    looking-glass

    anonghosty/looking-glass

    Plataforma CSIRT que ingiere informes de Shadowserver en MongoDB y los reproduce como mapas interactivos, análisis, hallazgos, avisos y paneles ejecutivos.

    416
  • 4

    jumpserver

    jumpserver/jumpserver

    JumpServer es una plataforma de gestión de accesos privilegiados (PAM) de código abierto que proporciona a los equipos de DevOps y TI acceso seguro y bajo demanda a endpoints SSH, RDP, Kubernetes, base de datos y RemoteApp a través de un navegador web.

    379
  • 5

    ARTEX

    baarai/artex

    Plataforma de pruebas de penetración autónoma multiagente basada en LLM con agentes planificadores/trabajadores, grafos de activos y de exploración, registro de tráfico MITM y reevaluación de vulnerabilidades.

    330
  • 6

    Aliens_eye

    arxhr007/aliens_eye

    Motor de OSINT impulsado por IA para descubrir y mapear más de 7.700 identidades en redes sociales en toda la web

    288

Explora todas las herramientas

Explora nuestra colección de herramientas

Ver todas las herramientas →
Compartir

CVE-2026-119618 — Corrupción del heap en mod_http2 de Apache httpd en assign_headers()

CVECVE-2026-119618
ComponenteApache HTTP Server, módulo mod_http2 (mod_h2 independiente)
Afectadoshttpd 2.4.55 – 2.4.70 · mod_h2 2.0.8 – 2.0.42
Corregido enhttpd 2.4.71 · mod_h2 2.0.43
CWECWE-362 — Ejecución concurrente usando un recurso compartido con sincronización incorrecta
ImpactoCorrupción del heap en un proceso hijo de httpd; posible ejecución remota de código
VectorRed, sin autenticación, HTTP/2 (h2c en texto claro o h2 sobre TLS)
DisparadorUna 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ón824beab9b9424d6cfb29595248fdbf6c3dddeab1 (cherry-pick del trunk 5ed39287660daacd1233cb9bbc984b25fa9a4fe3)
PR upstreamapache/httpd#975 → apache/httpd#977, fusionado el 2026-11-09
CréditoOSS Scanner de Anthropic (ANT-2026-MAPKT6MZ); Anthony Weems y Simon Scannell, Google Cloud Vulnerability Research
Avisohttps://httpd.apache.org/security/vulnerabilities_24.html
Solución alternativaeliminar h2 y h2c de la directiva Protocols
Repositoriohttps://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.


1. Causa raíz

1.1 El código afectado

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.

1.2 El pool del stream comparte el asignador sin bloqueos de la 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.

1.3 La escritura solo asigna cuando la tabla de encabezados está llena

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.

1.4 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):

Descargar herramienta