19 novembre 2026 Piratages Florent Montel

NGINX2Root (CVE-2026-123007): check and patch nginx, without panicking

NGINX2Root: the short answer (TL;DR)

Le 18 novembre 2026, nginx a corrigé cinq vulnérabilités regroupées sous le nom NGINX2Root. La plus grave, CVE-2026-123007, touche HTTP/2. Sur le papier, elle permet d'exécuter du code sur le serveur sans compte. En pratique, l'attaque est lourde, bruyante et liée à un matériel précis. Pas de panique, donc, mais une correction à planifier : mettre à jour vers nginx 1.30.7 ou 1.31.9, et désactiver HTTP/2 d'ici là si la mise à jour doit attendre.

  • Ce qui est touché : nginx open source de 1.9.5 à 1.31.8 avec HTTP/2 activé, et NGINX Plus avant 37.0.8.1 et 37.3.0.1.

  • Pourquoi c'est difficile : la seule attaque publique envoie environ 128 Go sur une seule connexion et ne fonctionne que sur certains processeurs x86-64. Les chercheurs qui ont une méthode plus aboutie la gardent pour eux et jugent ce type de faille difficile à exploiter à distance.

  • Et le passage root ? Il demande une seconde faille, dans le noyau Linux. Elle n'est pas encore corrigée, mais une ligne de configuration la bloque.

  • Exploitation : une preuve de concept fonctionne en laboratoire. Aucune exploitation dans la nature n'est signalée et la faille n'est pas au catalogue KEV de la CISA.

  • Quoi faire en premier : corriger les serveurs nginx exposés sur Internet dont la version vulnérable est visible, puis vérifier en interne ceux dont la version est masquée.

  • Contournement : http2 off; couvre CVE-2026-123007 et CVE-2026-123633. Les trois autres CVE demandent des configurations rares.

Qu'est-ce que la vulnérabilité NGINX2Root (CVE-2026-123007) ?

NGINX2Root (CVE-2026-123007) est une vulnérabilité de corruption mémoire dans le contrôle de flux HTTP/2 de nginx, publiée le 18 novembre 2026. Elle est notée 9,2 en CVSS 4.0. Le même vecteur indique une complexité d'attaque élevée et des prérequis côté cible. Elle permet, sous conditions, une exécution de code à distance (RCE) sans authentification. Le nom couvre aussi quatre autres CVE nginx corrigées le même jour.

Pourquoi l'exploitation de NGINX2Root est-elle difficile en pratique ?

La note de 9,2 décrit le pire cas. Les chercheurs qui ont publié l'attaque détaillent eux-mêmes ses limites.

  • Un volume énorme sur une seule connexion. La preuve de concept de Rapid7 envoie environ 128 Go de trafic HTTP/2 sur une seule connexion. Il faut environ 2 minutes sur un lien à 10 Gbit/s et 17 minutes à 1 Gbit/s. Sous 300 Mbit/s environ, l'attaque échoue : nginx ferme par défaut toute connexion au bout d'une heure.

  • Un matériel précis pour l'attaque publique. La preuve de concept de Rapid7 repose sur une version particulière de la copie mémoire de la glibc, choisie sur les processeurs x86-64 qui ont les instructions AVX-512. Ailleurs, elle fait planter le processus worker, qui redémarre aussitôt. Wiz Research indique avoir exécuté du code sur les binaires officiels nginx 1.31.7 et 1.31.8, avec une autre méthode qu'il ne publie pas.

  • Une exploitation exigeante. Wiz rappelle que ces failles « sont difficiles à exploiter à distance ». L'attaquant doit faire fuir des adresses mémoire, préparer le tas et s'adapter à chaque version, compilation et configuration.

  • Une attaque qui se voit. Une page web pèse quelques mégaoctets. Une connexion qui en reçoit plus de cent gigaoctets sort de l'ordinaire dans n'importe quelle supervision réseau.

  • Un CDN qui fait écran. Quand un CDN ou un proxy termine la connexion HTTP/2, les trames de l'attaquant ne sont très probablement pas retransmises telles quelles jusqu'à nginx.

  • Des droits limités. Le code s'exécute avec les droits du worker nginx (nginx ou www-data), pas avec ceux de root. Rapid7 n'a pas obtenu l'accès root par cette seule faille.

  • Une recette incomplète. Xint, qui a nommé NGINX2Root, a retenu les dernières étapes de ses exploits. Wiz ne publie pas les siens.

Ce n'est pas une raison pour attendre. Le correctif est simple et une technique d'exploitation s'améliore avec le temps. Mais NGINX2Root n'est pas une faille qu'un attaquant peut lancer en masse sur Internet en quelques heures. Le temps de corriger proprement existe.

Comment un attaquant passe-t-il de HTTP/2 à root avec NGINX2Root ?

HTTP/2 fait passer plusieurs flux sur une seule connexion. Pour qu'un flux ne sature pas les autres, chaque côté annonce combien de données il accepte de recevoir : c'est le contrôle de flux. Quand un flux est annulé, nginx rend la fenêtre inutilisée à la connexion sans vérifier le maximum prévu par HTTP/2. Le compteur déborde, et nginx finit par copier de la mémoire hors des limites prévues.

L'attaque complète se déroule en trois temps :

  1. L'attaquant ouvre une connexion HTTP/2 vers le serveur et y envoie, pendant plusieurs minutes, une très grande quantité de trames construites pour déclencher l'erreur. Il n'a besoin d'aucun compte.

  2. La corruption mémoire lui donne l'exécution de code dans le processus worker de nginx, qui tourne avec des droits limités.

  3. Xint enchaîne ensuite avec une seconde faille, dans le module SCTP du noyau Linux, pour obtenir les droits root sur l'hôte. Xint indique y être parvenu aussi depuis un nginx exécuté dans un conteneur Docker, car tous les conteneurs partagent le noyau de l'hôte.

Cette faille noyau n'a pas encore de correctif ni d'identifiant CVE. Xint retient ses détails tant qu'elle n'est pas corrigée. Elle se bloque pourtant simplement : empêcher le chargement du module SCTP, que la plupart des serveurs web n'utilisent pas (voir « Comment se protéger »).

Corriger nginx ferme la porte d'entrée. Bloquer le module SCTP ferme la seconde étape, en attendant un correctif du noyau.

Les quatre autres CVE corrigées le même jour visent des configurations moins courantes :

  • CVE-2026-123633 (HTTP/2) : un reverse proxy dont les emplacements de connexion libres s'épuisent, sous un grand nombre de connexions de l'attaquant.

  • CVE-2026-121810 (HTTP/3) : HTTP/3 activé et nginx qui relaie les requêtes vers un serveur en amont.

  • CVE-2026-123634 (résolveur DNS) : à la fois la directive resolver, un proxy_pass dont la destination vient de la requête et la directive mirror. L'attaquant doit en plus contrôler les réponses DNS d'un domaine.

  • CVE-2026-113425 (module mail) : le proxy mail de nginx avec auth_http, et un port IMAP, POP3 ou SMTP joignable par l'attaquant.

Quelles versions de nginx sont vulnérables, et NGINX2Root est-elle exploitée ?

Annoncé par les chercheurs. Selon Xint, chacune des cinq CVE permet une exécution de code sans authentification dans une configuration donnée. La chaîne complète mène aux droits root grâce à la faille SCTP du noyau Linux.

Confirmé de manière indépendante. L'équipe nginx a publié le 18 novembre 2026 les avis des cinq CVE, leurs plages de versions et les versions corrigées 1.30.7 et 1.31.9. Ces deux versions corrigent dix CVE au total. Cinq équipes ont trouvé ces failles chacune de leur côté : Wiz Research, Ikotas Labs, Metnir, Rapid7 et Xint. Rapid7 a publié une preuve de concept pour CVE-2026-123007, avec les limites décrites plus haut. Wiz et Xint ont obtenu l'exécution de code sans publier leur méthode.

Pas encore observé. Au 18 novembre 2026, aucune exploitation dans la nature n'est signalée, et CVE-2026-123007 ne figure pas au catalogue KEV de la CISA. Nous suivons ces deux points et mettrons cet article à jour s'ils changent.

Tableau 1 : concerné / non concerné

CVEComposantVersions vulnérablesGravité (avis nginx)Concerné si
CVE-2026-123007Contrôle de flux HTTP/21.9.5 à 1.31.8MajeureHTTP/2 activé. Toutes les versions depuis 2015.
CVE-2026-113425Module mail proxy0.5.33 à 1.31.8MajeureProxy mail avec auth_http joignable. Bloc mail dans la configuration.
CVE-2026-123633HTTP/2 (use-after-free)1.19.7 à 1.31.8MoyenneHTTP/2 activé sur un reverse proxy.
CVE-2026-121810HTTP/3 (use-after-free)1.25.0 à 1.31.8MoyenneHTTP/3 activé (listen ... quic) et relais vers un serveur en amont.
CVE-2026-123634Résolveur DNS0.6.18 à 1.31.8MoyenneDirectives resolver et mirror, avec un proxy_pass construit depuis la requête.
Non concernéLes cinq composants1.30.7 et plus, 1.31.9 et plusCorrigéVersion corrigée installée et service redémarré. Sans HTTP/2, CVE-2026-123007 et CVE-2026-123633 ne s’appliquent pas.

Suis-je concerné par la vulnérabilité NGINX2Root ?

Comment vérifier si mon serveur nginx est vulnérable ?

  1. Relevez la version de nginx.

nginx -v

Une version 1.30.7, 1.31.9 ou plus récente téléchargée depuis le site officiel de nginx est corrigée. Pour un paquet de distribution, la version affichée peut rester ancienne alors que le correctif est appliqué : cherchez l'identifiant de la CVE dans le changelog du paquet.

# Debian, Ubuntu
apt changelog nginx 2>/dev/null | grep -m1 CVE-2026-123007
# RHEL, Rocky, Alma
rpm -q --changelog nginx | grep -m1 CVE-2026-123007

2.Vérifiez si HTTP/2 ou HTTP/3 est actif.

sudo nginx -T 2>/dev/null | grep -nE "http2|listen[^;]*quic"

A http2 on; or listen 443 ssl http2; line indicates HTTP/2. A listen ... quic line indicates HTTP/3, affected by CVE-2026-121810.

3.Repérez le module mail, le résolveur et le miroir.

  1. Vérifiez si le module SCTP du noyau est chargé (étape de passage à root).

sudo nginx -T 2>/dev/null | grep -nE "^\s*(mail\s*\{|resolver\s|mirror\s|auth_http\s)"
  1. Listez les conteneurs qui embarquent nginx.

lsmod | grep -w sctp
  1. List the containers that ship nginx.

docker ps --format '{{.Names}} {{.Image}}' | grep -i nginx
docker exec <conteneur> nginx -v

Kubernetes ingress controllers, appliance images and devices that embed nginx, including some F5 products, are updated through their vendor's patches, not through the system package manager: follow their advisories.

Comment repérer mes serveurs nginx exposés à NGINX2Root depuis Internet ?

Trois informations suffisent pour classer un actif exposé, et elles s'obtiennent sans envoyer d'exploit.

HTTP/2 est-il proposé ? La commande affiche 2 quand HTTP/2 est négocié.

curl -s -o /dev/null --http2 -w '%{http_version}\n' https://www.acme.example

Qui répond, nginx ou un CDN ? Un en-tête propre à un CDN indique que la connexion HTTP/2 se termine sans doute sur le CDN, avant d'atteindre votre nginx.

curl -sI https://www.acme.example | grep -iE '^(server|via|x-cache|cf-ray)'

Quelle version ? Server: nginx/1.24.0 donne la version. Server: nginx sans numéro (directive server_tokens off) impose une vérification en interne.

Un actif qui négocie HTTP/2 et affiche une version vulnérable passe en tête. Viennent ensuite les versions masquées, puis les serveurs placés derrière un CDN ou un répartiteur de charge. Pour ceux-là, vérifiez si nginx accepte aussi HTTP/2 en direct, sur son adresse IP. C'est la logique de priorisation des vulnérabilités appliquée à une seule CVE.

Comment se protéger de NGINX2Root ?

ProduitVersion corrigéeStatut au 18 novembre 2026
nginx open source, stable1.30.7Disponible. Publiée par l’équipe nginx le 18 novembre 2026.
nginx open source, mainline1.31.9Disponible. Publiée par l’équipe nginx le 18 novembre 2026.
NGINX Plus, branche 37.037.0.8.1Disponible. Voir l’avis F5.
NGINX Plus, branche 37.337.3.0.1Disponible. Voir l’avis F5.
Images Docker officiellesnginx:stable, nginx:mainlineMises à jour le 18 novembre 2026. Retirer l’image et redéployer les conteneurs.
Paquets des distributions LinuxSelon la distributionCorrectif rétroporté, calendrier propre à chaque éditeur. Chercher la CVE dans le changelog du paquet.
Équipements et produits qui embarquent nginxSelon l’éditeurSuivre l’avis de l’éditeur. Ingress controllers, appliances, produits F5.

Quelle version de nginx corrige NGINX2Root ?

Installez nginx 1.30.7 (branche stable) ou 1.31.9 (branche mainline), ou le paquet de votre distribution qui contient le correctif. Redémarrez ensuite le service : un simple rechargement relit la configuration mais garde l'ancien binaire en mémoire.

sudo nginx -t && sudo systemctl restart nginx
nginx -v

Pour NGINX Plus, passez en 37.0.8.1 sur la branche 37.0 ou en 37.3.0.1 sur la branche 37.3. Les versions R34 à R36 ne reçoivent pas de correctif et doivent passer sur une branche maintenue. Pour les équipements et images d'éditeurs, appliquez leurs correctifs. Pour un site en hébergement mutualisé, le correctif dépend de l'hébergeur : relancez-le.

Comment désactiver HTTP/2 dans nginx en attendant le correctif ?

Désactivez HTTP/2 dans chaque bloc server (nginx 1.25.1 et plus récent) :

server {
    listen 443 ssl;
    http2 off;
}

Sur les versions plus anciennes, retirez le paramètre http2 des directives listen : listen 443 ssl http2; devient listen 443 ssl;. Testez puis rechargez :

sudo nginx -t && sudo systemctl reload nginx

Les navigateurs repassent en HTTP/1.1 sans action de leur part. Les services gRPC, qui ont besoin de HTTP/2, s'arrêtent : prévoyez-le. Ce contournement couvre CVE-2026-123007 et CVE-2026-123633. Pour HTTP/3, retirez les directives listen ... quic. Pour le résolveur, remplacez le proxy_pass construit depuis la requête par un upstream fixe, ou retirez mirror. Pour le module mail, limitez l'accès aux ports mail par pare-feu.

Si HTTP/2 doit rester actif, réduire la durée de vie des connexions rend l'attaque plus exigeante en débit. Ce réglage ne corrige rien, il réduit seulement la fenêtre.

keepalive_time 10m;

Comment bloquer le passage à root en attendant un correctif du noyau ?

Aucun correctif du noyau Linux n'est disponible pour la faille SCTP utilisée par Xint. Empêchez le chargement du module SCTP, que la plupart des serveurs web n'utilisent pas :

echo 'install sctp /bin/false' | sudo tee /etc/modprobe.d/disable-sctp.conf
lsmod | grep -w sctp

Ce réglage empêche le chargement du module. Il ne décharge pas un module déjà chargé : si lsmod l'affiche, redémarrez le serveur après avoir vérifié qu'aucune application n'utilise SCTP. Il ne s'applique pas si SCTP est compilé directement dans le noyau. Sur un hôte de conteneurs, appliquez-le sur l'hôte : un nginx dans un conteneur partage le noyau de l'hôte.

Que faire si un serveur nginx a déjà été compromis ?

Le reconstruire. La chaîne NGINX2Root peut aller jusqu'aux droits root : un serveur dont la compromission est suspectée se reconstruit à partir d'une image saine. Renouvelez ensuite les clés privées TLS et les secrets présents sur l'hôte.

Comment détecter une tentative d'exploitation de NGINX2Root ?

  • Une connexion HTTP/2 très longue qui reçoit des dizaines de gigaoctets. C'est le signe le plus net de l'attaque publique :

ss -tinp state established '( sport = :443 )'
  • Des arrêts répétés des processus worker dans les journaux d'erreur :

grep -E "worker process [0-9]+ exited on signal" /var/log/nginx/error.log
  • Des processus enfants inattendus sous un worker nginx (un shell, curl, wget) :

ps -eo pid,ppid,user,cmd --forest | grep -A3 "nginx: worker"
  • Des connexions sortantes inhabituelles depuis le serveur web, de nouveaux comptes ou de nouveaux fichiers SUID.

  • Un module SCTP chargé sans raison sur un serveur web.

Quelles CVE NGINX2Root s'appliquent à mon serveur ? (script de tri)

Ce script de tri tourne en lecture seule sur un serveur. Il ne déclenche aucune vulnérabilité : il lit la version et la configuration, puis indique quelles CVE de NGINX2Root s'appliquent.

#!/bin/sh
# Tri NGINX2Root en lecture seule. A lancer en root (nginx -T lit toute la configuration).
v=$(nginx -v 2>&1 | sed 's|.*nginx/||')
fixed=1.31.9; case "$v" in 1.30.*) fixed=1.30.7;; esac
if [ "$(printf '%s\n' "$fixed" "$v" | sort -V | head -1)" = "$fixed" ]; then
  echo "nginx $v : corrigé"
else
  echo "nginx $v : version amont vulnérable (vérifier le changelog si paquet de distribution)"
fi
conf=$(nginx -T 2>/dev/null)
echo "$conf" | grep -qE '^\s*http2\s+on|listen[^;]*\bhttp2\b' && echo "HTTP/2 actif : CVE-2026-123007, CVE-2026-123633"
echo "$conf" | grep -qE 'listen[^;]*\bquic\b' && echo "HTTP/3 actif : CVE-2026-121810"
echo "$conf" | grep -qE '^\s*mail\s*\{' && echo "Module mail : CVE-2026-113425"
echo "$conf" | grep -qE '^\s*resolver\s' && echo "$conf" | grep -qE '^\s*mirror\s' && echo "Resolver et mirror : CVE-2026-123634"
lsmod 2>/dev/null | grep -qw sctp && echo "Module SCTP chargé : étape root possible"

Comment Patrowl détecte-t-il NGINX2Root sur vos actifs exposés ?

Le jour de la publication, le CERT Patrowl a ajouté le contrôle #1892 aux Trending Attacks, la rubrique des attaques en cours. Il a vérifié tous les actifs nginx suivis en modes EASM et Pentested, sans envoyer d'exploit. Déclencher la faille en production aurait risqué de faire planter vos serveurs : nous ne l'avons pas fait.

Pour chaque actif, la vérification suit cinq étapes :

  1. Repérer les actifs où nginx ou OpenResty a été détecté : en-tête Server, pages d'erreur par défaut, détection de technologies.

  2. Ouvrir une connexion TLS qui propose HTTP/2 et HTTP/1.1, et noter le protocole choisi par le serveur. Sur les ports HTTP, vérifier si HTTP/2 est accepté sans TLS.

  3. Vérifier que c'est bien nginx qui termine HTTP/2, et pas un CDN ou un répartiteur de charge placé devant. Les paramètres HTTP/2 envoyés par nginx ont une signature qui lui est propre.

  4. Lire l'en-tête Alt-Svc pour savoir si HTTP/3 est annoncé, et les bannières des ports mail pour repérer le proxy mail de nginx.

  5. Comparer la version visible aux versions corrigées. Une version d'OpenResty est ramenée à la version nginx sur laquelle elle repose.

Chaque sonde est une requête standard, comme celle d'un navigateur.

Au 18 novembre 2026, le contrôle #1892 est en statut « Potentially impacted » pour 127 équipes clientes, sur 4 894 actifs. Ce statut veut dire « à vérifier », pas « compromis ».

Chaque client concerné reçoit aussi une vulnérabilité de niveau Info, « NGINX2Root : CVE-2026-123007 follow-up file of your assets », avec un fichier Excel joint. Le fichier classe ses actifs et dit par où commencer :

CatégorieCe que cela veut direAction
Vulnerable versionVersion vulnérable visible. nginx répond lui-même en HTTP/2 et annonce une version touchée.À corriger en premier. Mettre à jour, ou http2 off; en attendant.
Shared hostingServeur cPanel mutualisé. Le serveur appartient à l’hébergeur.Relancer l’hébergeur. Le correctif est de son ressort.
To checkVersion masquée ou paquet de distribution. nginx répond sans version, ou avec une version qui peut contenir un correctif rétroporté.Vérifier en interne avec nginx -v et le changelog du paquet.
Behind a front-endUn répartiteur de charge est placé devant nginx. La connexion HTTP/2 s’arrête sans doute avant nginx.Vérifier si nginx accepte HTTP/2 en direct, puis planifier la mise à jour.

La consigne reste la même pour tous : mettre à jour nginx, désactiver HTTP/2 en attendant si besoin, bloquer le module SCTP et relancer l'hébergeur pour les serveurs mutualisés. Le CERT Patrowl suit la menace en continu, une méthode détaillée dans notre article sur le threat hunting proactif avec l'IA agentique. Le même déroulé avait servi pour wp2shellen juillet 2026 : le contrôle était intégré quelques heures après la publication du code d'attaque.

Que surveiller dans les prochains jours après NGINX2Root ?

  • Les distributions Linux publient leurs paquets corrigés à leur rythme. Tant que leur avis n'est pas sorti, le contournement HTTP/2 reste la protection disponible.

  • Le correctif du noyau Linux pour la faille SCTP. D'ici là, le blocage du module reste la parade.

  • La publication d'une méthode d'exploitation plus simple que celle de Rapid7, par exemple celle de Wiz, changerait l'urgence. Nous la surveillons.

  • 1.30.7 et 1.31.9 arrivent peu après 1.30.6 et 1.31.7, qui corrigeaient déjà d'autres CVE nginx. Un serveur resté sur une version antérieure cumule les deux séries.

  • Nous suivons l'éventuelle inscription au catalogue KEV et mettrons à jour cet article et le contrôle #1892 en conséquence.

  • Le scénario rappelle PHP2Shell : une exécution de code sans authentification dans un composant que presque tous les sites web utilisent.

FAQ

Questions fréquentes sur NGINX2Root

Pourquoi la vulnérabilité s’appelle-t-elle NGINX2Root ?

Le nom, donné par les chercheurs de Xint, décrit le trajet de l’attaque : d’un simple visiteur du serveur nginx jusqu’aux droits root sur l’hôte. Il regroupe cinq CVE corrigées le 18 novembre 2026, dont CVE-2026-123007 dans le contrôle de flux HTTP/2.

NGINX2Root est-elle facile à exploiter ?

Non. L’attaque publique envoie environ 128 Go sur une seule connexion HTTP/2 et ne fonctionne que sur certains processeurs x86-64. Sous 300 Mbit/s environ, elle échoue. Les méthodes plus abouties de Wiz et Xint ne sont pas publiées. Elle donne les droits du worker nginx, pas root. Aucune exploitation dans la nature n’est signalée. La mise à jour reste nécessaire, mais sans précipitation.

nginx -v affiche une ancienne version alors que mon paquet est à jour : suis-je protégé contre NGINX2Root ?

Oui, si CVE-2026-123007 figure dans le changelog du paquet. Les distributions Linux rétroportent souvent le correctif sans changer le numéro de version amont. Vérifiez avec apt changelog nginx (Debian, Ubuntu) ou rpm -q --changelog nginx (RHEL, Rocky, Alma).

Faut-il redémarrer nginx après la mise à jour contre NGINX2Root ?

Oui. Un rechargement relit la configuration mais garde l’ancien binaire vulnérable en mémoire. Après l’installation de nginx 1.30.7, 1.31.9 ou du paquet corrigé, redémarrez le service avec systemctl restart nginx, puis contrôlez la version avec nginx -v.

Désactiver HTTP/2 contre NGINX2Root casse-t-il mon site ?

Non pour un site web classique : les navigateurs repassent en HTTP/1.1 d’eux-mêmes. Les services gRPC, qui ont besoin de HTTP/2, s’arrêtent en revanche. La directive http2 off; couvre CVE-2026-123007 et CVE-2026-123633, pas les trois autres CVE de NGINX2Root.

Faut-il mettre à jour le noyau Linux contre NGINX2Root ?

Pas encore possible : la faille SCTP utilisée pour passer root n’a pas de correctif à ce jour. En attendant, bloquez le chargement du module SCTP avec la ligne install sctp /bin/false dans /etc/modprobe.d/disable-sctp.conf. La plupart des serveurs web n’utilisent pas SCTP.

Un nginx dans un conteneur Docker est-il protégé de NGINX2Root ?

Non. Le conteneur partage le noyau de l’hôte, et Xint indique avoir obtenu les droits root sur l’hôte depuis un nginx conteneurisé. Récupérez l’image officielle corrigée (nginx:stable en 1.30.7, nginx:mainline en 1.31.9), redéployez les conteneurs et bloquez le module SCTP sur l’hôte.

Mon site est derrière un CDN : dois-je quand même corriger NGINX2Root ?

Oui, mais la priorité baisse. Un CDN qui termine la connexion HTTP/2 ne retransmet très probablement pas les trames de l’attaque jusqu’à nginx. La protection tient seulement si le serveur nginx d’origine n’est pas joignable en direct. Filtrez son accès sur les plages d’adresses du CDN, et planifiez la mise à jour.

Mon site est en hébergement mutualisé : que faire face à NGINX2Root ?

Contactez votre hébergeur. Sur un serveur mutualisé, comme un serveur cPanel, nginx appartient à l’hébergeur et lui seul peut installer nginx 1.30.7 ou 1.31.9. Demandez-lui la date de correction et s’il a désactivé HTTP/2 en attendant.

NGINX2Root figure-t-elle au catalogue KEV de la CISA ?

Non, au 18 novembre 2026. Aucune exploitation dans la nature n’est signalée à cette date. Une preuve de concept existe, mais elle demande des conditions de laboratoire difficiles à réunir. Cet article sera mis à jour en cas d’inscription au catalogue KEV ou d’exploitation observée.

Comment Patrowl vérifie-t-il NGINX2Root sans risque pour mes serveurs ?

Sans envoyer d’exploit. Pour chaque actif nginx suivi en modes EASM et Pentested, Patrowl regarde si HTTP/2 est actif, si c’est nginx ou un CDN qui répond, et quelle version est annoncée. Chaque sonde est une requête standard. Le contrôle #1892 classe ensuite chaque actif : Vulnerable version, Shared hosting, To check ou Behind a front-end.