Skip to content
KitploitKITPLOIT
StrumentiExploitsBlog
Log in
Invia
StrumentiExploitsBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

FeedContattoPrivacy© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
CVE-2026-119618 — 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. | Kitploit
Strumenti/GitHubGitHub/googlesky/cve-2026-119618
Scanner di Vulnerabilità WebSicurezza dei ContenitoriAnalisi Dinamica (Sandboxing)ExploitSicurezza WebFuzzingPaper e RicercaLab e Pratica
GitHubgooglesky/cve-2026-119618

CVE-2026-119618

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.

1472 giorni faNon ancora revisionato
Vedi Repository

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 Il toolkit OSINT definitivo: grafo di indagine, punteggio di affidabilità, famiglie di alias, mappa, timeline e report. 49 moduli, oltre 400 siti, nessuna chiave API richiesta.

    1.1k
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # App di esecuzione con un tocco GhostLock (CVE-2026-43499)

    628
  • 3

    looking-glass

    anonghosty/looking-glass

    Piattaforma CSIRT che importa i report di Shadowserver in MongoDB e li riproduce come mappe interattive, analisi, risultati, avvisi e dashboard executive.

    413
  • 4

    jumpserver

    jumpserver/jumpserver

    JumpServer è una piattaforma open-source di gestione degli accessi privilegiati (PAM) che fornisce ai team DevOps e IT un accesso sicuro e on-demand a endpoint SSH, RDP, Kubernetes, database e RemoteApp tramite un browser web.

    366
  • 5

    ARTEX

    baarai/artex

    Piattaforma di penetration testing autonoma multi-agente basata su LLM con agenti planner/worker, grafi di asset e di esplorazione, registrazione del traffico MITM e retesting delle vulnerabilità.

    329
  • 6

    Aliens_eye

    arxhr007/aliens_eye

    Motore OSINT basato sull'IA per scoprire e mappare oltre 7.700 identità sui social media in tutto il web

    287

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →
Condividi

CVE-2026-119618 — Corruzione dell'heap di Apache httpd mod_http2 in assign_headers()

CVECVE-2026-119618
ComponenteApache HTTP Server, modulo mod_http2 (mod_h2 autonomo)
Interessatohttpd 2.4.55 – 2.4.70 · mod_h2 2.0.8 – 2.0.42
Corretto inhttpd 2.4.71 · mod_h2 2.0.43
CWECWE-362 — Esecuzione concorrente con risorsa condivisa e sincronizzazione impropria
ImpattoCorruzione dell'heap in un processo figlio di httpd; potenziale esecuzione di codice remoto
VettoreRete, non autenticato, HTTP/2 (h2c in chiaro o h2 su TLS)
AttivazioneUna 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 correzione824beab9b9424d6cfb29595248fdbf6c3dddeab1 (cherry-pick del trunk 5ed39287660daacd1233cb9bbc984b25fa9a4fe3)
PR upstreamapache/httpd#975 → apache/httpd#977, unito il 09-11-2026
CreditiAnthropic's OSS Scanner (ANT-2026-MAPKT6MZ); Anthony Weems e Simon Scannell, Google Cloud Vulnerability Research
Advisoryhttps://httpd.apache.org/security/vulnerabilities_24.html
Soluzione alternativarimuovere h2 e h2c dalla direttiva Protocols
Repositoryhttps://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.


1. Causa principale

1.1 Il codice interessato

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.

1.2 Il pool dello stream condivide l'allocatore lock-free 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.

1.3 La scrittura alloca solo quando la tabella delle intestazioni è piena

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.

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

Scarica lo strumento