Résumé exécutif

Le 3 décembre 2025, les développeurs React ont divulgué CVE-2025-55182, une vulnérabilité critique d'exécution de code à distance (RCE) affectant les React Server Components (RSC) avec un score CVSS maximum de 10.0. La vulnérabilité a été découverte par le chercheur en sécurité Lachlan Davidson et signalée le 29 novembre 2025. Cette vulnérabilité provient d'une désérialisation non sécurisée dans le protocole React Flight, permettant à des attaquants non authentifiés d'exécuter du code arbitraire sur des serveurs vulnérables. La faille affecte les versions React 19.x et des frameworks populaires comme Next.js, React Router, Waku et Redwood SDK. Une exploitation active par des groupes de menaces liés à la Chine a déjà été observée quelques heures après la divulgation publique, rendant l'application immédiate de correctifs critique pour les organisations.

---

Qu'est-ce que CVE-2025-55182 ?

Vue d'ensemble de la vulnérabilité

CVE-2025-55182, familièrement connu sous le nom de "React2Shell" (établissant des parallèles avec Log4Shell), est une vulnérabilité de désérialisation non sécurisée dans le protocole "Flight" des React Server Components (RSC). La vulnérabilité permet à des attaquants non authentifiés d'envoyer des requêtes HTTP spécialement conçues vers des serveurs vulnérables et d'obtenir l'exécution de code arbitraire dans le contexte de l'application React.

Caractéristiques clés

• Score CVSS : 10.0 (Gravité maximale)

• Vecteur d'attaque : Réseau, non authentifié, aucune interaction utilisateur requise

• Complexité d'attaque : Faible

• Impact : Compromission complète—confidentialité, intégrité et disponibilité toutes affectées

• Composant affecté : Implémentation du protocole Flight des React Server Components

• Nomenclature : CVE-2025-55182 pour React ; CVE-2025-66478 pour Next.js (ultérieurement considéré comme doublon)

La vulnérabilité est particulièrement préoccupante car elle affecte les configurations par défaut—les applications n'ont pas besoin de définir explicitement des Server Functions pour être vulnérables. Le simple fait de prendre en charge les React Server Components suffit pour l'exploitation.

---

Analyse technique approfondie : Comment fonctionne la vulnérabilité

Le protocole React Flight

Les React Server Components (RSC) ont introduit une architecture sophistiquée où une partie du rendu des composants se produit sur le serveur plutôt que dans le navigateur. Cela améliore les performances en réduisant la taille des charges utiles et en permettant des capacités côté serveur comme l'accès aux bases de données et la gestion des secrets.

Le protocole React Flight est le mécanisme de transport léger basé sur HTTP qui sérialise et désérialise les arbres de composants et les appels de fonctions serveur entre le client et le serveur. Lorsqu'un utilisateur déclenche une Server Action (par exemple, en cliquant sur un bouton), le navigateur initie une requête POST avec une charge utile Flight sérialisée. Le serveur désérialise ensuite cette charge utile pour reconstruire les arguments de la fonction et exécuter la fonction serveur appropriée.

La cause première : Désérialisation non sécurisée

La vulnérabilité réside dans la logique de désérialisation de FlightReplyServer, spécifiquement dans des packages comme :

• react-server-dom-webpack

• react-server-dom-parcel

• react-server-dom-turbopack

Lorsque le serveur reçoit une charge utile Flight entrante, il désérialise le corps de la requête HTTP brute en objets JavaScript. Cependant, le processus de désérialisation ne parvient pas à valider et contraindre correctement la structure des données. Au lieu d'appliquer des schémas stricts, l'implémentation étend implicitement les propriétés des objets, créant une faille logique.

Mécanisme de pollution de prototype

La technique d'exploitation exploite une vulnérabilité de pollution de prototype côté serveur. Voici comment cela fonctionne :

1. Injection de charge utile malveillante : Un attaquant crée une charge utile Flight contenant des clés malveillantes telles que __proto__ ou constructor.

2. Expansion de propriété : Pendant la désérialisation, React étend ces propriétés sans validation appropriée, leur permettant de traverser la chaîne de prototypes des objets JavaScript.

3. Pollution de la chaîne de prototypes : Les clés injectées modifient les prototypes JavaScript de base et les objets globaux sur le serveur.

4. Chaînage de gadgets : Une fois les prototypes pollués, l'attaquant peut influencer quels chemins de code sont invoqués. En chaînant ces objets pollués avec du code existant (connu sous le nom de "gadgets"), l'attaquant peut atteindre des fonctions dangereuses.

5. Exécution de code arbitraire : L'attaquant peut invoquer des fonctions comme child_process.execSync() ou accéder au module process pour exécuter des commandes système avec les privilèges du processus Node.js.

Exemple de structure de charge utile

Une charge utile conceptuelle simplifiée pourrait ressembler à ceci :

{
  "then": "$1:__proto__:then",
  "status": "resolved_model",
  "reason": -1,
  "value": "{\"then\": \"$B0\"}",
  "_response": {
    "_prefix": "process.mainModule.require('child_process').execSync('id');",
    "_formData": {
      "get": "$1:constructor:constructor"
    }
  }
}

La structure exacte de la charge utile varie en fonction de la configuration du bundler et des gadgets disponibles, mais le principe reste : les données sérialisées malveillantes influencent l'exécution côté serveur pour exécuter du code arbitraire.

---

Versions et produits affectés

Versions React vulnérables

• React 19.0.0

• React 19.1.0

• React 19.1.1

• React 19.2.0

Packages Server-DOM affectés

• react-server-dom-parcel

• react-server-dom-turbopack

• react-server-dom-webpack

Versions Next.js affectées

Next.js hérite de la vulnérabilité via son implémentation de RSC et du protocole Flight :

• Next.js 15.0.4 et antérieures dans la ligne 15.x

• Next.js 15.1.0 à 15.1.8

• Next.js 15.2.0 à 15.2.5

• Next.js 15.3.0 à 15.3.5

• Next.js 15.4.0 à 15.4.7

• Next.js 15.5.0 à 15.5.6

• Next.js 16.0.0 à 16.0.6

• Versions canary antérieures (14.3.0-canary.77 et ultérieures)

Frameworks et outils en aval

La vulnérabilité se propage à tout framework ou outil qui intègre ou dépend de packages React vulnérables :

• React Router (mode RSC)

• Waku

• Redwood SDK

• Expo

• Plugin Parcel RSC

• Plugin Vite RSC

Échelle de l'impact

Selon la société de recherche sur les menaces Wiz :

• 39 % des environnements cloud contiennent des instances vulnérables de Next.js ou React

• 69 % des environnements cloud ont React ou Next.js déployés

• 61 % des déploiements React sont accessibles publiquement

• Cela signifie qu'environ 44 % de tous les environnements cloud ont des instances Next.js exposées publiquement

---

Versions corrigées et mises à jour

Correctifs React

Correctifs Next.js

Autres frameworks

Chaque framework a publié des correctifs. Les utilisateurs doivent consulter les avis officiels pour React Router, Waku, Expo et Redwood SDK pour leurs versions corrigées spécifiques.

---

Activité d'exploitation réelle

Réponse des acteurs de menaces

Quelques heures après la divulgation publique du 3 décembre 2025, la veille sur les menaces a révélé des tentatives d'exploitation rapides :

• Des groupes de menaces liés à la Chine incluant Earth Lamia et Jackpot Panda ont commencé une exploitation active

• Plus de 80 adresses IP identifiées en train de scanner pour des instances vulnérables

• Les données du honeypot AWS MadPot ont montré des tentatives d'exploitation persistantes avec débogage et raffinement délibérés

• Les acteurs de menaces ont passé jusqu'à une heure à dépanner systématiquement leurs exploits contre des cibles en direct

Méthodologie d'attaque observée

Les acteurs de menaces ont employé des modèles d'exploitation méthodiques :

1. Reconnaissance automatisée : Utilisation d'outils de scan automatisés avec randomisation de l'agent utilisateur pour sonder les points de terminaison vulnérables

2. Test de charges utiles : Tentatives de multiples charges utiles d'exploit pour déterminer lesquelles fonctionnaient contre des cibles spécifiques

3. Exécution de commandes : Test de commandes de reconnaissance comme whoami, id, uname

4. Tentatives de persistance : Écriture de fichiers dans le répertoire /tmp/ (par exemple, /tmp/pwned.txt)

5. Énumération de privilèges : Tentatives de lecture de /etc/passwd pour obtenir des informations sur les utilisateurs

Indicateurs de compromission

Indicateurs réseau :

• Requêtes HTTP POST avec des en-têtes next-action ou rsc-action-id

• Corps de requêtes contenant des motifs $@

• Corps de requêtes avec des motifs "status":"resolved_model"

• Requêtes vers des points de terminaison comme /_next/flight ou /_next/data/

Indicateurs basés sur l'hôte :

• Génération de processus inattendue depuis des applications Node.js/React (par exemple, execSync exécutant des commandes système)

• Écritures de fichiers suspectes dans le répertoire /tmp/

• Exécution inattendue de commandes de reconnaissance (whoami, id, uname, cat /etc/passwd)

• Nouveaux processus enfants générés par Node.js avec un comportement inhabituel

---

Stratégies d'atténuation

Actions immédiates (Priorité : CRITIQUE)

1. Appliquer les correctifs immédiatement

Pour les projets React :

npm install react@19.2.1 react-dom@19.2.1
npm install react-server-dom-webpack@19.2.1
npm install react-server-dom-parcel@19.2.1
npm install react-server-dom-turbopack@19.2.1

Pour les projets Next.js :

npm install next@latest

Vérifier que les versions corrigées sont installées :

npm audit | grep CVE-2025-55182
npm list react next

2. Déployer des règles WAF

Tous les principaux fournisseurs de CDN et WAF ont publié des règles de protection d'urgence :

• Cloudflare : Déployé automatiquement pour tous les clients, y compris le niveau gratuit

• AWS WAF : Règles incluses dans l'ensemble standard mais nécessitant une activation manuelle

• Vercel : Protège automatiquement tous les projets hébergés (mais l'application de correctifs reste nécessaire)

• Google Cloud : Règles Cloud Armor appliquées automatiquement pour Firebase

• Akamai : Règles disponibles pour les utilisateurs d'App & API Protector

• F5 : Signatures améliorées avec mode Haute Précision activé

• Palo Alto Networks : Mises à jour de prévention des menaces

Important : La protection WAF est temporaire et donne du temps pour l'application de correctifs. L'application de correctifs directs sur l'application est non négociable.

Atténuations secondaires (Si l'application de correctifs est retardée)

1. Restrictions au niveau réseau

• Bloquer ou restreindre l'accès aux points de terminaison RSC (/_next/flight, /_next/data/, points de terminaison d'actions serveur) aux plages IP de confiance

• Implémenter une limitation de débit sur les points de terminaison suspectés vulnérables

• Activer le filtrage de réputation IP pour bloquer les ASN malveillants connus

2. Journalisation et surveillance améliorées

• Journaliser toutes les requêtes POST vers les points de terminaison de fonctions serveur

• Surveiller les motifs de requêtes suspects contenant __proto__, constructor, ou des motifs $@

• Implémenter la détection d'anomalies pour la génération de processus Node.js

• Alerter sur les tentatives de lecture de fichiers sensibles comme /etc/passwd

3. Détection et réponse aux points de terminaison (EDR)

Déployer des agents EDR sur les serveurs pour :

• Détecter les comportements anormaux des processus Node.js

• Surveiller la génération inattendue de processus enfants

• Alerter sur l'accès aux API dangereuses (execSync, exec, spawn)

• Prévenir l'exécution malveillante grâce à l'analyse comportementale

---

Détection et réponse aux incidents

Méthodologie de détection

Les équipes de sécurité doivent mettre en œuvre une détection multicouche :

1. Détection au niveau WAF : Utiliser les règles WAF fournies par les fournisseurs pour capturer les charges utiles malveillantes

2. Analyse de journaux : Rechercher dans les journaux des motifs d'indicateurs de compromission

3. Surveillance comportementale : Surveiller le comportement des processus Node.js et les appels système

4. Scan de dépendances : Scanner en continu les dépendances avec des outils comme npm audit ou des outils SBOM dédiés

Procédures de réponse aux incidents

Si une exploitation est suspectée :

1. Confinement immédiat :

   • Isoler les serveurs affectés du réseau

   • Préserver les preuves médico-légales (journaux, dumps mémoire, système de fichiers)

   • Identifier l'étendue de la compromission

2. Investigation :

   • Examiner les journaux d'accès pour les requêtes malveillantes

   • Vérifier les processus inattendus générés par Node.js

   • Scanner /tmp/ et autres répertoires inscriptibles pour des fichiers suspects

   • Examiner l'historique des commandes et les variables d'environnement

   • Vérifier la présence de web shells ou de portes dérobées

3. Remédiation :

   • Appliquer les correctifs de sécurité à tous les systèmes affectés

   • Renouveler tous les identifiants et secrets (clés API, mots de passe de base de données, tokens CI/CD)

   • Scanner les indicateurs de mouvement latéral

   • Examiner et réinitialiser les clés SSH et les tokens d'authentification

4. Récupération :

   • Reconstruire les systèmes compromis à partir d'images fiables

   • Restaurer à partir de sauvegardes propres après vérification

   • Implémenter une surveillance et des alertes améliorées

   • Effectuer des évaluations de sécurité sur les systèmes connexes

---

Meilleures pratiques pour la sécurité React/Next.js

Recommandations architecturales

1. Minimiser l'utilisation des Server Components :

   • Utiliser les Server Components uniquement lorsque nécessaire

   • Préférer le rendu côté client pour les fonctionnalités moins critiques

   • Auditer soigneusement les points de terminaison des fonctions serveur

2. Validation des entrées :

   • Implémenter une validation de schéma stricte sur toutes les données désérialisées

   • Utiliser TypeScript pour la sécurité des types sur les fonctions serveur

   • Implémenter des listes blanches pour les fonctions appelables

3. Principe du moindre privilège :

   • Exécuter les processus Node.js avec les permissions minimales requises

   • Éviter d'exécuter en tant que root ou avec des capacités excessives

   • Utiliser la conteneurisation avec des capacités restreintes

4. Gestion des dépendances :

   • Maintenir une nomenclature logicielle (SBOM) à jour

   • Auditer régulièrement les dépendances avec npm audit et des outils de sécurité

   • Implémenter un scan automatisé des dépendances dans les pipelines CI/CD

   • Envisager d'utiliser des fichiers de verrouillage et des vérifications d'intégrité

5. Surveillance et observabilité :

   • Implémenter une journalisation complète pour les fonctions serveur

   • Surveiller les comportements de processus anormaux

   • Configurer des alertes pour les motifs suspects

   • Utiliser le traçage distribué pour suivre les flux de requêtes

6. Segmentation réseau :

   • Restreindre l'accès aux points de terminaison des fonctions serveur aux clients légitimes

   • Implémenter une limitation de débit pour prévenir les attaques par force brute

   • Utiliser des VPC et des ACL réseau pour isoler les composants vulnérables

---

Chronologie et divulgation

---

Conclusion

CVE-2025-55182 représente un moment charnière pour la sécurité de l'écosystème React. La combinaison d'une gravité maximale (CVSS 10.0), d'une facilité d'exploitation, d'un impact large sur l'écosystème React et d'une exploitation active immédiate fait de cette faille un incident de sécurité critique. Contrairement à de nombreuses vulnérabilités qui restent théoriques, cette faille a été activement exploitée par des acteurs de menaces parrainés par des États quelques heures après sa divulgation.

Points clés à retenir

• Appliquer les correctifs immédiatement : Mettre à niveau vers React 19.2.1+ et Next.js vers les dernières versions corrigées

• Vérifier la protection : Confirmer que les règles WAF sont actives si vous utilisez Cloudflare, Vercel, AWS ou d'autres fournisseurs

• Rechercher les compromissions : Examiner les journaux pour les indicateurs de compromission et enquêter sur les activités suspectes

• Planifier la défense : Implémenter les recommandations architecturales pour prévenir des vulnérabilités similaires

• Rester informé : Surveiller les avis officiels de React, Next.js et des fournisseurs de sécurité pour les mises à jour

La réponse rapide de la communauté React et l'effort coordonné de correction démontrent des pratiques de sécurité matures. Cependant, les organisations doivent agir rapidement pour s'assurer de bénéficier de ces protections. Tout retard dans l'application de correctifs augmente considérablement le risque de compromission par des acteurs de menaces actifs.