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.
assign_headers() de mod_http2 d'Apache httpd| CVE | CVE-2026-119618 |
| Composant | Apache 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é dans | httpd 2.4.71 · mod_h2 2.0.43 |
| CWE | CWE-362 — Exécution concurrente utilisant une ressource partagée avec une synchronisation incorrecte |
| Impact | Corruption de tas dans un processus enfant httpd ; exécution de code à distance potentielle |
| Vecteur | Réseau, non authentifié, HTTP/2 (h2c en clair ou h2 via TLS) |
| Déclencheur | Une 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 correction | 824beab9b9424d6cfb29595248fdbf6c3dddeab1 (cherry-pick du trunk 5ed39287660daacd1233cb9bbc984b25fa9a4fe3) |
| PR amont | apache/httpd#975 → apache/httpd#977, fusionnée le 2026-11-09 |
| Crédit | OSS 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 |
| Contournement | retirer h2 et h2c de la directive Protocols |
| Dépôt | https://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.
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.
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.
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.
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) :