Skip to content
KitploitKITPLOIT
OutilsExploitsBlog
Log in
Soumettre
OutilsExploitsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

FluxContactConfidentialité© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
CVE-2026-119618 — Laboratoire différentiel conteneurisé et PoC HTTP/2 en stdlib pour CVE-2026-119618, une course dans l'allocateur de mod_http2 provoquant une corruption du tas dans Apache httpd 2.4.55-2.4.70, avec preuves ASan/TSan. | Kitploit
Outils/GitHubGitHub/googlesky/cve-2026-119618
Scanners de Vulnérabilités WebSécurité des ConteneursAnalyse Dynamique (Sandboxing)ExploitationSécurité WebFuzzingArticles et RechercheLabs et Pratique
GitHub
googlesky/cve-2026-119618

CVE-2026-119618

Laboratoire différentiel conteneurisé et PoC HTTP/2 en stdlib pour CVE-2026-119618, une course dans l'allocateur de mod_http2 provoquant une corruption du tas dans Apache httpd 2.4.55-2.4.70, avec preuves ASan/TSan.

Voir le dépôt
147il y a 2 joursPas encore vérifié

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 La boîte à outils OSINT ultime : graphe d'enquête, notation de confiance, familles d'alias, carte, chronologie et rapports. 49 modules, plus de 400 sites, aucune clé API requise.

    1.0k
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Application d'exécution en un clic GhostLock (CVE-2026-43499)

    634
  • 3

    looking-glass

    anonghosty/looking-glass

    Plateforme CSIRT qui ingère les rapports Shadowserver dans MongoDB et les rejoue sous forme de cartes interactives, d'analyses, de constats, d'avis et de tableaux de bord exécutifs.

    417
  • 4

    jumpserver

    jumpserver/jumpserver

    JumpServer est une plateforme open-source de Gestion des Accès Privilégiés (PAM) qui offre aux équipes DevOps et IT un accès sécurisé et à la demande aux terminaux SSH, RDP, Kubernetes, bases de données et RemoteApp via un navigateur web.

    383
  • 5

    ARTEX

    baarai/artex

    Plateforme autonome de tests d'intrusion multi-agents basée sur des LLM, avec agents planificateur/ouvrier, graphes d'actifs et d'exploration, enregistrement du trafic MITM et retest des vulnérabilités.

    328
  • 6

    SafeLine

    chaitin/safeline

    WAF auto-hébergé et proxy inverse qui filtre le trafic HTTP malveillant, bloque les injections SQL, les XSS et les attaques de robots, avec limitation de débit et chiffrement dynamique HTML/JS.

    288

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →
Partager

CVE-2026-119618 — Corruption de tas dans assign_headers() de mod_http2 d'Apache httpd

CVECVE-2026-119618
ComposantApache HTTP Server, module mod_http2 (mod_h2 autonome)
Affectéhttpd 2.4.55 – 2.4.70 · mod_h2 2.0.8 – 2.0.42
Corrigé danshttpd 2.4.71 · mod_h2 2.0.43
CWECWE-362 — Exécution concurrente utilisant une ressource partagée avec une synchronisation incorrecte
ImpactCorruption de tas dans un processus enfant httpd ; exécution de code à distance potentielle
VecteurRéseau, non authentifié, HTTP/2 (h2c en clair ou h2 via TLS)
DéclencheurUne requête HTTP/2 sans corps portant Content-Type et sans Content-Length, avec la table d'en-têtes de requête remplie à capacité
Commit de correction824beab9b9424d6cfb29595248fdbf6c3dddeab1 (cherry-pick du trunk 5ed39287660daacd1233cb9bbc984b25fa9a4fe3)
PR amontapache/httpd#975 → apache/httpd#977, fusionnée le 2026-11-09
CréditOSS Scanner d'Anthropic (ANT-2026-MAPKT6MZ) ; Anthony Weems et Simon Scannell, Google Cloud Vulnerability Research
Avis de sécuritéhttps://httpd.apache.org/security/vulnerabilities_24.html
Contournementretirer h2 et h2c de la directive Protocols
Dépôthttps://github.com/googlesky/CVE-2026-119618

mod_http2 attribue à chaque flux HTTP/2 son propre pool, et ce pool hérite de l'allocateur de la connexion qui possède la session. Cet allocateur n'a pas de mutex : apr_allocator_create() n'en crée pas, donc allocator_lock() est une opération sans effet pour toute la connexion. Le traitement des requêtes est délibérément déplacé vers des threads de travail dotés d'un allocateur privé (c2_transit_create()), précisément pour qu'un worker ne touche jamais l'allocateur de la connexion. assign_headers() brise cet invariant : pour une requête sans corps qui porte Content-Type et pas de Content-Length, le worker écrit le Content-Length: 0 synthétisé dans la table de flux partagée au lieu du r->headers_in privé de la requête. Lorsque la table est pleine, cette écriture alloue un nouveau nœud de 8 Ko depuis l'allocateur sans verrou de la connexion, tandis que le thread de connexion alloue depuis la même liste libre ou y libère. Deux threads peuvent retirer le même nœud, et la double propriété qui en résulte corrompt le tas du processus enfant httpd.

Ce dépôt contient un laboratoire différentiel conteneurisé qui reproduit la corruption sur httpd 2.4.70, prouve la condition de course avec ThreadSanitizer, montre httpd 2.4.71 sain sous le même trafic, exerce toutes les formes de requêtes voisines, vérifie le contournement publié et consigne un balayage de 0-day sur la branche corrigée.


1. Cause racine

1.1 Le code affecté

modules/http2/h2_request.c, Apache httpd 2.4.70, assign_headers(). Les numéros de ligne proviennent de l'archive de la version 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:         }

Le correctif dans la version 2.4.71 modifie une ligne :

-                apr_table_setn(req->headers, "Content-Length", "0");
+                apr_table_setn(r->headers_in, "Content-Length", "0");

r->headers_in est le clone créé à la ligne 325 dans r->pool, le pool de requêtes appartenant au thread worker. req->headers est la table du flux, allouée depuis le pool de flux et accessible par le thread de connexion.

1.2 Le pool de flux partage l'allocateur sans verrou de la connexion

h2_session_open_stream() (h2_session.c:117) crée le pool par flux comme enfant du pool de session et le marque :

apr_pool_create(&stream_pool, session->pool);
apr_pool_tag(stream_pool, "h2_stream");
stream = h2_stream_create(stream_id, stream_pool, session, ...);

Le pool de sessions est un descendant du pool de connexions que le MPM crée dans child_main() (server/mpm/prefork/prefork.c:423). L'allocateur de ce pool provient de apr_allocator_create(), et aucun mutex n'y est jamais défini :

/* 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
}

Le traitement des requêtes, en revanche, est explicitement conçu pour éviter cet allocateur. c2_transit_create() (h2_mplx.c:210) attribue à chaque worker un allocateur privé :

    /* 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);

Le request_rec du worker est créé sur c2->pool, un descendant du pool de transit, de sorte que chaque allocation effectuée normalement par le worker est privée. L'écriture vulnérable fait exception : elle alloue depuis le pool de flux, dont l'allocateur est celui de la connexion.

1.3 L'écriture n'alloue que lorsque la table d'en-têtes est pleine

apr_table_setn() sur une clé absente passe à apr_table_add(), qui appelle 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 table est créée par h2_request_create() sous la forme apr_table_make(pool, 10), donc nalloc commence à 10 et double : 10, 20, 40, 80, 160. Les pseudo-en-têtes ne sont pas stockés dans la table — ils deviennent req->method, req->scheme, req->authority et req->path. h2_request_end_headers() (h2_request.c:212) ajoute exactement une entrée Host.

Une requête avec 79 en-têtes réguliers contient donc 79 entrées, Host en fait 80, et nelts == nalloc == 80 lorsque assign_headers() s'exécute. Le apr_table_setn() vulnérable fait croître le tableau jusqu'à 160 entrées :

160 * sizeof(apr_table_entry_t) = 160 * 24 = 3840 bytes

allocator_align() (apr_pools.c:268) arrondit cela à MIN_ALLOC (8192), de sorte que l'écriture demande un nouveau nœud de 8 Ko à l'allocateur du pool de flux chaque fois que le nœud actif du pool a moins de 3840 octets restants. C'est cette allocation qui entre en course.

1.4 La course

allocator_alloc() (apr_pools.c:289) parcourt la liste des nœuds libres (allocator->free[index], allocator->max_index) et retire un nœud ; allocator_free() (apr_pools.c:426) en remet un et réécrit max_index. Sans mutex, il s'agit de séquences lecture-modification-écriture non synchronisées sur le même apr_allocator_t — un objet tas de 200 octets alloué par apr_allocator_create() dans child_main(). Deux threads peuvent retirer le même nœud, après quoi deux pools différents distribuent des zones mémoire qui se chevauchent.

ThreadSanitizer capture exactement cela sur 2.4.70 (evidence/tsan-vulnerable.txt) :

Télécharger l’outil