RCE Nginx HTTP/2 : la complexité est la surface d'attaque
Les RCE Nginx HTTP/2 prouvent que les parseurs de protocoles avec état cachent les bugs critiques. Pourquoi, et quoi auditer dans votre stack.

Le code le plus dangereux d'Internet n'est pas votre application. C'est le parseur de protocole à état, écrit en C, placé devant elle, que tout le monde suppose éprouvé au combat. Les nouvelles vulnérabilités RCE de Nginx HTTP/2 — CVE-2026-123633 et CVE-2026-123007, toutes deux non authentifiées et notées 9,2 — sont la meilleure preuve de cette affirmation depuis des années. L'une d'elles a permis à des chercheurs d'obtenir un shell sur un Nginx standard qui ne servait que des fichiers statiques. Aucune application backend, aucun module tiers, aucun bug applicatif. Juste Nginx, HTTP/2 et un underflow d'entier présent dans le code depuis la version 1.9.5, sortie en 2015.
C'est la partie à contre-courant : nous passons énormément de temps à auditer notre propre code et presque aucun à réfléchir à la porte d'entrée. Pourtant, c'est par là qu'un bug de corruption mémoire vieux de dix ans peut offrir à un inconnu non authentifié l'exécution de code sur la machine qui termine votre TLS et voit tout.
Pourquoi HTTP/2 dans Nginx a toujours été un pari risqué
HTTP/1.1 est un protocole textuel. Il est simple, verbeux, et son modèle de parsing se ramène assez naturellement à « lire des octets jusqu'au délimiteur, valider, dispatcher ». On a trouvé des bugs dans les parseurs HTTP/1 — le request smuggling est tout un genre à lui seul —, mais la machine à états est assez petite pour qu'un ingénieur soigneux puisse la garder en tête.
HTTP/2 est une tout autre bête. Il est binaire, multiplexé et à état d'une manière qui traverse toute la connexion. Une seule connexion TCP transporte des dizaines de flux concurrents. Le contrôle de flux est suivi par flux et par connexion, avec des fenêtres glissantes de crédits. Les flux peuvent être ouverts, semi-fermés, réinitialisés et repriorisés dans n'importe quel ordre que le client juge bon. La compression d'en-têtes via HPACK implique que le parseur maintient une table dynamique partagée qui mute à chaque arrivée de trame. Chacune de ces fonctionnalités est un morceau d'état mutable qui doit rester cohérent face à des entrées hostiles, et le client contrôle entièrement ces entrées.
Nginx a hérité de toute cette machinerie d'état lorsqu'il a ajouté son module HTTP/2, et il l'a fait en C, dans une architecture événementielle où connexions et flux sont des objets sur le tas dont la durée de vie est gérée à la main. Cette combinaison — un état transversal riche plus une gestion mémoire manuelle — est exactement le terreau des use-after-free et des underflows d'entiers. Les deux CVE ici sont presque des caricatures du genre : l'une est un objet de connexion resté dans une liste « sûre à fermer » alors qu'une requête l'utilise activement ; l'autre est une comptabilité de contrôle de flux qui passe sous zéro et produit une copie mémoire invalide.
J'ai déjà défendu, à propos de l'écart entre spécification et implémentation, l'idée que les bugs se concentrent là où les invariants implicites d'une spécification rencontrent du code qui ne les fait pas respecter. HTTP/2 en est une étude de cas. La RFC 7540 (et désormais la 9113) décrit à quoi ressemblent les flux bien formés. L'espace dangereux, c'est tout ce que la spécification n'interdit pas explicitement mais que l'implémentation n'a jamais testé : trames partielles, transitions d'état dans des ordres bizarres, fenêtres manipulées aux valeurs limites.
Le use-after-free : réutilisable pendant qu'il est occupé
CVE-2026-123633 est la plus élégante des deux failles, et elle récompense une lecture attentive. Nginx tient une liste des connexions qu'il considère « réutilisables », c'est-à-dire sûres à fermer lorsqu'il a besoin de slots pour de nouvelles connexions. Une connexion HTTP/2 y entre dès qu'elle n'a plus aucun flux de requête actif. Jusque-là, rien de surprenant.
Le défaut tient à la façon dont une connexion quitte la liste — ou plutôt, ne la quitte pas. Envoyez seulement une partie d'une trame HEADERS. Nginx voit une trame incomplète, marque la connexion comme réutilisable, et attend. Envoyez ensuite le reste de la trame. Le handler crée un nouveau flux de requête et incrémente le compteur de traitement de la connexion, mais il ne retire jamais la connexion de la liste réutilisable. Vous obtenez alors une connexion qui traite simultanément une requête vivante et qui est marquée comme jetable. Si les slots de connexion s'épuisent, Nginx va chercher cette connexion dans la liste, la libère, et la requête en cours pointe vers de la mémoire libérée. Un classique use-after-free, accessible à n'importe quel client non authentifié capable de parler HTTP/2 à un reverse proxy.
Regardez ce qu'il faut pour trouver ce bug en lisant le code : il faut suivre l'appartenance d'un objet à une structure de données à travers deux transitions d'état différentes, déclenchées par des entrées réseau réparties sur plusieurs paquets. Ce n'est pas un bug qu'un linter détecte. Ce n'est même pas un bug que la plupart des fuzzers trouvent facilement, car il exige une interaction précise en deux temps — trame partielle, attente, trame complète — plus une pression mémoire pour déclencher la fermeture. C'est le genre de chose qui est resté caché pendant près de six ans, alors que Nginx est l'une des bases de code les plus lues de la planète.
L'underflow d'entier : une décennie au grand jour
CVE-2026-123007 est plus ancienne et, à certains égards, pire. Le contrôle de flux HTTP/2 fonctionne en accordant à chaque flux et à chaque connexion une fenêtre d'émission, un solde de crédits que l'émetteur décrémente à mesure qu'il transmet et que le récepteur recharge avec des trames WINDOW_UPDATE. Si la comptabilité de cette fenêtre déraille, on peut finir par calculer une taille de copie à partir d'une valeur qui a bouclé, et soudain on fait un memcpy depuis ou vers une mémoire qu'on n'aurait jamais dû toucher.
Les chercheurs ont démontré une exécution de code à distance à partir de cette primitive, sur une configuration à peu près par défaut — Nginx servant des fichiers statiques en HTTPS sur un système 64 bits. L'ASLR n'a pas suffi, car les deux vulnérabilités servent aussi de primitives de lecture mémoire avant l'escalade vers l'exécution de code. On fuite des pointeurs, on contourne la randomisation, puis on écrit. C'est de l'exploitation moderne standard, mais il faut bien l'intégrer : les mitigations comme l'ASLR augmentent le coût de l'exploitation sans l'empêcher, et tout bug qui vous donne une lecture plus une corruption équivaut en pratique à une partie perdue d'avance.
L'underflow a été livré dans Nginx 1.9.5 en 2015. Onze ans. Pendant ce temps, le code a été relu par des milliers d'ingénieurs, déployé par des millions d'opérateurs, passé au crible par tous les analyseurs statiques commerciaux du marché, et fuzzé — Nginx est bien fuzzé. Il a tout survécu. Si cela ne recalibre pas votre confiance dans « le libre et mature est sûr parce qu'il y a beaucoup d'yeux », rien ne le fera.

La partie dérangeante : l'IA a trouvé ce que le fuzzing n'avait pas trouvé
Voici le détail qui devrait empêcher les équipes sécurité de dormir. Wiz a trouvé les deux bugs avec un harnais de scan de code assisté par IA, puis a utilisé des modèles de pointe pour valider l'exploitabilité. Et ils n'étaient pas seuls : Ikotas Labs, Metnir, Rapid7 et Xint ont signalé indépendamment les mêmes failles à F5, pendant la même fenêtre de divulgation. Cinq équipes, deux bugs vieux de dix ans, convergeant au même moment.
Ce n'est pas une coïncidence. C'est un changement de phase. La barrière pratique qui protégeait autrefois ces vieux bugs de sécurité mémoire n'était pas qu'ils soient impossibles à trouver en théorie : c'est que suivre un état à travers des dizaines de chemins de code coûtait cher en attention humaine. Les modèles sont désormais assez bons pour ce type précis de raisonnement en plusieurs sauts, si bien que le coût s'est effondré. On a observé le même schéma récemment avec Java4Shell, où 65 octets se sont transformés en RCE — une autre faille de longue date révélée par des outils capables de suivre des interactions subtiles mieux que des humains fatigués.
Deux conséquences en découlent, et je serai direct sur les deux. D'abord, chaque équipe défensive dispose désormais de la même capacité de découverte : lancez-la sur votre propre stack avant que quelqu'un d'autre ne le fasse. Ensuite — et c'est là que je concède les limites de mon affirmation d'ouverture — les attaquants l'ont aussi, et la fenêtre entre « le bug devient trouvable » et « le bug est exploité » se réduit. La discussion sur Hacker News a fait ressortir un détail désagréable : le correctif de l'une des CVE est resté dans le dépôt public pendant une semaine avant la divulgation, avec un message de commit citant l'entreprise de sécurité qui l'avait signalé. Quiconque analyse les commits à la recherche de correctifs de sécurité — technique classique des black hats — avait une longueur d'avance. Les processus de divulgation coordonnée ont été conçus pour un monde où la découverte était rare. Ce monde n'existe plus.
Leçons pour le fuzzing des parseurs de protocoles
Si vous maintenez un parseur exposé au réseau — et beaucoup d'entre nous le font, dans des proxys, des passerelles API, des service meshes ou des protocoles maison —, ces bugs forment une checklist des endroits où vos tests sont probablement faibles.
- Fuzzez des séquences, pas seulement des messages. Les deux CVE exigent des interactions en plusieurs étapes : trames partielles, connexions suspendues, mises à jour de fenêtre aux valeurs limites. Un fuzzer qui mute des trames isolées ne trouvera jamais un bug qui nécessite trame A, une attente, puis trame B. Utilisez un fuzzing avec état ou sensible à la grammaire, qui modélise le cycle de vie de la connexion.
- Testez la durée de vie des objets sous pression de ressources. Le UAF ne se déclenche que lorsque Nginx doit récupérer des slots de connexion. Vos tests doivent tourner avec des limites de ressources artificiellement basses pour exécuter les chemins d'éviction.
- Vérifiez les invariants à chaque transition d'état. « Si processing > 0, la connexion ne doit pas être dans la liste réutilisable » se vérifie avec une seule assertion. Les invariants peu coûteux attrapent les bugs que la revue de code laisse passer.
- Déclenchez une erreur sur les dépassements d'entiers dans les builds de debug. Le bouclage signé et non signé dans l'arithmétique de contrôle de flux est précisément ce qui a produit CVE-2026-123007. Les sanitizers (UBSan) combinés au fuzzing auraient signalé ce problème il y a des années.
- Analysez les commits de votre amont à la recherche de correctifs de sécurité silencieux. Les défenseurs peuvent jouer le même jeu que les attaquants. Surveiller les commits qui ressemblent à des correctifs vous rapporte des jours d'avance.
Et une remarque de process, tirée de la couverture de divulgation après divulgation : les délais de divulgation qui raccourcissent existent parce que l'écart entre le correctif et l'exploit ne cesse de se réduire. Votre processus de réponse — inventaire, priorisation, déploiement progressif — compte davantage que n'importe quel correctif isolé.
Que faire de vos déploiements Nginx dès maintenant
La remédiation est ennuyeuse, et c'est une bonne nouvelle. Mettez à jour Nginx OSS vers 1.30.7 stable ou 1.31.9 mainline ; les clients Nginx Plus ont besoin des versions corrigées R33/R37. Si vous ne pouvez pas mettre à jour cette semaine, désactivez HTTP/2 — sur la 1.25.1 et les versions ultérieures, c'est http2 off; dans les blocs server concernés, et sur les versions plus anciennes, retirez le paramètre http2 des directives listen —, puis rechargez et vérifiez que les anciens workers ont bien quitté. C'est une mitigation brutale : vous perdez le multiplexage et la compression d'en-têtes, et les applications sensibles à la latence le sentiront. Mais elle ferme totalement les deux bugs, et c'est un changement de configuration, pas de code.
Pour la détection, la réponse honnête est que ces attaques sont difficiles à repérer dans les logs : l'exploitation ressemble à des séquences de trames HTTP/2 bizarres, puis, à terme, à des crashs inattendus de workers ou à des workers Nginx qui lancent des processus qu'ils ne devraient jamais lancer. Des workers qui crashent en boucle sur un Nginx exposé à Internet avec HTTP/2 activé méritent une investigation, pas seulement un redémarrage par le superviseur.
Une précision supplémentaire : HTTP/2 n'est pas activé par défaut dans Nginx, et les enquêtes situent son usage autour de 12 % des serveurs. À l'échelle d'Internet, cela représente tout de même des millions d'instances, mais vérifiez avant de paniquer — et vérifiez aussi vos load balancers et vos origines CDN, car le Nginx que vous avez oublié derrière l'ingress managé est celui qui se fait prendre.
La complexité n'a jamais été une frontière de sécurité. Ce n'était qu'une file d'attente — et la file avance plus vite maintenant.
La leçon plus large pour les infrastructures critiques
Prenez du recul et le schéma est clair : les bugs qui comptent le plus vivent désormais dans des implémentations de protocoles à état, non sûres sur le plan mémoire, au sein d'une infrastructure que tout le monde partage. Cette seule divulgation a livré dix CVE Nginx : des UAF HTTP/2, un UAF HTTP/3, un UAF du résolveur DNS, un UAF du proxy mail. Le fil conducteur n'est pas la négligence ; la base de code Nginx est rigoureuse selon les standards du C. Le fil conducteur, c'est que la gestion manuelle de la durée de vie à travers des machines à états asynchrones et pilotées par l'attaquant dépasse ce qu'une équipe peut vérifier à l'œil.
Où cela nous laisse-t-il ? Pas avec « tout réécrire en Rust », aussi tentant que soit ce refrain — même si réécrire dans un langage sûr en mémoire les parseurs les plus exposés est une très bonne idée, et que l'industrie s'y met lentement. Plus immédiatement : traitez vos proxys de bordure comme la cible d'audit la plus précieuse de votre stack, exigez du fuzzing avec état et des sanitizers des projets dont vous dépendez, et construisez la capacité opérationnelle de corriger ou de mitiger en quelques jours. L'époque où un bug vieux de onze ans pouvait attendre tranquillement qu'un humain le remarque est révolue. Les machines lisent la file désormais, des deux côtés.



