React2Shell (CVE-2025-55182) : Le Fantôme de la Désérialisation dans la Machine RSC

Dans les dernières semaines de 2025, alors que la plupart des équipes d’ingénierie se préparaient à la période de freeze des fêtes, une vulnérabilité est apparue, redéfinissant la sécurité web moderne. Surnommée “React2Shell” et suivie sous le numéro CVE-2025-55182, cette faille n’était pas simplement un bug — c’était une rupture fondamentale dans le modèle de confiance des React Server Components (RSC).

Avec un score CVSS de 10.0, React2Shell permet à des attaquants non authentifiés d’exécuter du code à distance (RCE) via une seule requête HTTP spécialement conçue. À l’image du célèbre Log4Shell de 2021, le danger réside dans son ubiquité et la nature “silencieuse” du protocole sous-jacent.

Dans cette analyse approfondie, nous explorons la mécanique du protocole “Flight” des RSC, la faille de désérialisation qui a ouvert la porte au chaos, et comment vous pouvez protéger votre infrastructure en 2026.

1. Qu’est-ce que le protocole Flight des RSC ?

Pour comprendre React2Shell, il faut d’abord comprendre le protocole Flight.

Traditionnellement, les applications React envoyaient du JSON ou du HTML. Avec l’avènement de React 19 et de l’App Router, React a introduit React Server Components (RSC). Les RSC permettent au serveur de rendre des composants UI et de les diffuser au client dans un format propriétaire appelé Flight.

Comment les données circulent dans Flight

Lorsqu’un client demande un RSC ou invoque une “Action Serveur”, le serveur n’envoie pas simplement du HTML ; il envoie un flux d’objets JavaScript sérialisés. Ces objets représentent :

• Arbres de composants : La structure de votre UI.
• Props : Données transmises aux composants.
• Références serveur : Identifiants pour des fonctions pouvant être appelées sur le serveur.
• Promises : Espaces réservés pour des données qui ne sont pas encore arrivées.

Le protocole Flight utilise une syntaxe spécifique où chaque ligne est préfixée par des IDs (par ex., 1:, 2:) et des symboles spéciaux comme $@ pour les références ou $B pour les Blobs.

Le décodeur côté serveur (présent dans des packages comme react-server-dom-webpack) est responsable de prendre les données entrantes du client — comme les arguments pour une Action Serveur — et de les reconstituer en objets JavaScript utilisables par le serveur. C’est là que le fantôme se cachait.

2. La vulnérabilité : CVE-2025-55182 expliquée

La cause principale de React2Shell est une faille de désérialisation non sécurisée. Plus précisément, le décodeur côté serveur de React ne validait pas les propriétés des objets lors de la reconstruction du flux Flight.

Pollution du prototype côté serveur

La vulnérabilité exploite une faiblesse classique de JavaScript : la pollution du prototype. En JavaScript, presque tous les objets héritent de Object.prototype. Si un attaquant peut injecter des propriétés dans le prototype, il peut modifier le comportement de tous les objets du système.

Lors du processus de décodage, React utilisait des noms de propriétés fournis par la charge utile Flight entrante pour accéder à des valeurs sans vérifier si ces propriétés appartenaient bien à l’objet lui-même (c’est-à-dire qu’il manquait des vérifications hasOwnProperty).

La faille : En créant une charge utile qui référencait des propriétés comme __proto__ ou masquait des méthodes internes comme then, un attaquant pouvait tromper l’environnement d’exécution React pour parcourir la chaîne de prototypes et exécuter des fonctions non autorisées.

3. Anatomie de l’exploitation : de la requête à la shell

L’intelligence — et la terreur — de React2Shell réside dans le fait qu’elle ne nécessite aucune authentification. Un attaquant trouve simplement un endpoint acceptant des payloads RSC (ce qui concerne presque toutes les routes dans une application Next.js avec App Router par défaut) et envoie une requête POST.

La chaîne d’attaque

Les chercheurs ont identifié une “chaîne d’engrenage” en quatre étapes qui transforme cette faille de désérialisation en une shell complète :

Étape 1 : La boucle auto-référentielle : L’attaquant envoie une requête multipart/form-data contenant un objet “faux chunk”. Cet objet imite la classe interne Chunk de React.

Étape 2 : Masquage de propriété : La charge définit la propriété then de ce faux chunk pour référencer Chunk.prototype.then. Cela crée une référence circulaire qui force le serveur à “attendre” l’objet.

Étape 3 : Le gestionnaire de Blob ($B) : L’attaquant utilise le préfixe $B (réservé aux Blobs) pour déclencher une fonction interne spécifique de React. Cette fonction est trompée pour rechercher une référence malveillante.

Étape 4 : Exécution du code : En enchaînant ces gadgets, l’attaquant obtient un accès aux modules process ou child_process de Node.js. Il peut alors exécuter des commandes système comme whoami, curl, ou même lancer une shell inversée.

Un exemple (conceptuel) de charge utile malveillante :

POST /api/server-action HTTP/1.1
Content-Type: multipart/form-data; boundary=----Boundary
Next-Action: [Action_ID]

------Boundary
Content-Disposition: form-data; name="0"
{"then":"$1:__proto__:then","status":"resolved_model","value":"payload_here"}
------Boundary
Content-Disposition: form-data; name="1"
"$@0"
------Boundary--

Note : Il s’agit d’une représentation simplifiée. Les exploits réels utilisent une obfuscation Unicode complexe pour contourner les signatures WAF de base.

4. Pourquoi ce “Fantôme de la Désérialisation” ?

Contrairement aux injections SQL ou XSS traditionnelles, React2Shell intervient avant même que votre code applicatif ne s’exécute.

Contournement des couches d’authentification

Parce que le protocole Flight est géré au niveau du framework (dans les internals de React), la charge utile malveillante est désérialisée avant d’atteindre votre middleware ou vos vérifications d’authentification. Si le framework traite le flux, la RCE est déjà déclenchée.

Surface d’attaque

La vulnérabilité ne se limite pas aux applications utilisant “Actions Serveur”. Toute application exécutant une version vulnérable de React 19 supportant RSC est potentiellement à risque. Cela inclut :

• Next.js (15.x et 16.x)
• React Router (en mode RSC)
• Waku
• Intégrations RSC avec Vite/Parcel

5. Impact dans le monde réel (2025-2026)

Au début de 2026, les données sur l’impact de React2Shell sont stupéfiantes.

Exploitation généralisée

Des sociétés de sécurité comme Wiz et Mandiant ont rapporté que 39 % des environnements cloud contenaient au moins une instance React vulnérable dans les 48 heures suivant la divulgation. Les scanners automatisés ont rapidement exploité la bug, entraînant :

• Cryptojacking : Déploiement massif de mineurs XMRig sur Vercel et AWS Lambda.
• Exfiltration de données : Utilisation de la RCE pour interroger les endpoints de métadonnées cloud (comme 169.254.169.254) afin de voler des rôles IAM et des identifiants de bases de données.
• Backdoors persistantes : Les familles de malware “SNOWLIGHT” et “COMPOOD” ont été observées utilisant React2Shell pour établir des points d’ancrage permanents dans les réseaux d’entreprise.

Incident Cloudflare

Dans un événement notable de “dommages collatéraux”, Cloudflare a connu une brève panne en décembre 2025. La cause ? Un déploiement d’urgence de protections WAF visant à bloquer des payloads Flight malformés, qui a été si agressif qu’il a accidentellement cassé le trafic React légitime pour des milliers de sites.

6. Suis-je vulnérable ? (Checklist)

Si vous utilisez une application React construite entre fin 2024 et fin 2025, vous êtes probablement dans la ligne de mire.

Package	Versions vulnérables	Versions corrigées
React	19.0.0 – 19.2.0	19.0.1, 19.1.2, 19.2.1+
Next.js	15.0.0 – 16.0.6	15.1.0, 16.0.7+
react-server-dom-webpack	< 19.0.1	19.0.1+

Avertissement : Les versions Canary et expérimentales de React (notamment celles après 14.3.0-canary.77) sont également très vulnérables.

7. Détection & stratégies d’atténuation

Atténuation immédiate : Le bouclier WAF

Si vous ne pouvez pas appliquer de patch immédiatement, votre première ligne de défense est un Web Application Firewall (WAF). Vous devriez bloquer toute requête POST qui :

• Contient les en-têtes Next-Action ou rsc-action-id.
• Contient la chaîne $@ suivie de marqueurs de traversal de propriété comme :__proto__ ou :constructor.
• Présente des structures multipart/form-data exceptionnellement complexes dirigées vers des endpoints RSC.

La correction permanente : Patchs

Mettre à jour vos dépendances est la seule façon de tuer le “Fantôme”.

# Mettre à jour Next.js
npm install next@latest react@latest react-dom@latest

# Vérifiez votre fichier lock pour ces packages :
# react-server-dom-webpack
# react-server-dom-turbopack

Le patch introduit des vérifications strictes hasOwnProperty et renforce le décodeur Flight contre la traversal du prototype d’objet.

Surveillance en runtime

Déployez des outils comme Falco ou Sysdig pour surveiller les processus suspects issus de votre runtime Node.js.

• Indicateur de compromission (IoC) : processus node lançant sh, bash, curl, ou wget.
• Indicateur de compromission (IoC) : connexions sortantes inattendues vers des IPs C2 (Command & Control) connues ou pools de minage.

8. Leçons pour l’avenir de la sécurité React

React2Shell est un signal d’alarme pour l’ère “Server-First” du développement web. À mesure que nous déplaçons plus de logique côté serveur via RSC et Actions Serveur, nous réintroduisons d’anciennes vulnérabilités sous des formes plus abstraites.

La sérialisation n’est jamais sûre : tout protocole qui reconstitue des objets complexes à partir d’entrées client constitue une énorme surface d’attaque.

Sécurité au niveau du framework : Les développeurs comptent sur la sécurité par défaut des frameworks. Quand le framework lui-même devient vecteur, la sécurité applicative standard (JWT, CSRF) peut ne pas suffire.

L’effet “Log4j” : Les applications modernes reposent sur une pile profonde de dépendances. Un bug dans un sous-package central comme react-server-dom-webpack peut compromettre des millions d’applications en aval.

Conclusion

React2Shell (CVE-2025-55182) sera mémorisé comme le moment où la communauté React a affronté sa première crise de sécurité majeure au niveau de l’infrastructure. En comprenant la mécanique de désérialisation du protocole Flight, vous pouvez mieux vous défendre contre ce “fantôme” et construire des applications plus résilientes.

Avez-vous audité vos node_modules aujourd’hui ? Le fantôme de RSC pourrait encore rôder dans vos déploiements 2025.