Les nouvelles vulnérabilités de React : Mettez à jour ou faites face à un arrêt.

Les développeurs React viennent de terminer la course pour patcher un bug critique d'exécution de code à distance, et ils sont maintenant de nouveau en alerte maximale. La vulnérabilité React2Shell, suivie sous le numéro CVE-2025-55182, a stupéfié l'écosystème avec une RCE non authentifiée contre les configurations par défaut des composants de serveur React et une fiabilité d'exploitation proche de 100 %. Les attaquants ont agi rapidement, déployant des balises Cobalt Strike, des cryptomineurs et des RAT tels qu'EtherRAT et Noodle RAT dès que la faille est devenue publique.

Des correctifs pour React2Shell ont été publiés le 3 décembre 2025, et les équipes se sont précipitées pour mettre à jour les versions de Next.js, des backends Node.js et des serveurs React personnalisés. De nombreuses entreprises ont traité cela comme un incident à "tout abandonner", priorisant les mises à jour des dépendances par rapport au travail sur de nouvelles fonctionnalités. Pendant un court instant, il semblait que le pire était passé.

Quelques jours plus tard, une suite est arrivée. Alors que les chercheurs et l'équipe React examinaient le correctif original, ils ont découvert deux nouvelles vulnérabilités dans le même protocole React Server Components "Flight". Ces découvertes portent maintenant les identifiants CVE-2025-55183, CVE-2025-55184, ainsi qu'un cas interne lié, CVE-2025-67779.

Les deux nouvelles vulnérabilités touchent la même catégorie de cibles : les paquets React 19.x tels que react-server-dom-webpack 19.0.0–19.2.0 et les frameworks qui intègrent RSC par défaut. Cette liste inclut : - Next.js - react-router - Waku - @parcel/rsc - @vitejs/plugin-rsc - RWSdk

Les équipes de sécurité sont désormais confrontées à un cycle de corrections frénétique. Premièrement, un RCE critique a forcé des mises à niveau d'urgence. Maintenant, seulement une semaine plus tard, les organisations doivent déployer une nouvelle série de mises à jour de dépendances, retester les versions de production et redéployer—encore une fois.

Ces nouveaux bugs ne permettent pas l'exécution de code à distance, mais ils sont tout de même considérés comme graves. Une vulnérabilité DoS, évaluée comme ayant une gravité élevée avec un CVSS de 7.5, permet à un attaquant d'envoyer une seule requête POST qui déclenche une boucle infinie sur le serveur React, bloquant tout autre trafic. La disponibilité tombe à zéro pendant que le processus tourne.

Le deuxième défaut expose le code source des actions du serveur à travers une autre requête POST triviale. La gravité se situe dans la catégorie "moyenne", mais tout secret, jeton ou identifiant de base de données codé en dur dans ces actions devient un butin instantané. Pour les applications mal configurées, le niveau "moyen" peut s'aggraver et devenir catastrophique.

La deuxième nouvelle vulnérabilité de React touche la disponibilité, et non l'exécution de code. Le CVE-2025-55183 est un bug de Déni de Service de haute sévérité dans les composants serveur de React, obtenant un CVSS 7.5. Pas d'accès shell, pas d'exfiltration de données — juste une application morte qui ne répond plus à la porte.

Les attaquants n'ont pas besoin de clés d'authentification, d'infrastructure spéciale ou de timing astucieux. Une seule requête POST non authentifiée à un endpoint RSC suffit à déclencher une boucle infinie à l'intérieur du serveur React. À partir de là, le processus tourne indéfiniment, consommant des cycles CPU tandis que chaque nouvelle requête attend son tour, jusqu'à ce que l'ensemble du service soit effectivement bloqué.

Sous charge, ce comportement passe de désagréable à catastrophique. Comme la boucle s'exécute à l'intérieur du processus principal du serveur React, elle monopolise la boucle d'événements et prive tous les autres gestionnaires. De nouvelles requêtes HTTP s'accumulent, expirent, et les utilisateurs voient des pages vides, des appels API échoués ou des erreurs 500 au niveau du cadre.

Pour les piles modernes de React, cela signifie que toute application s'appuyant sur les composants de serveur React est exposée : Next.js, configurations RSC personnalisées avec react-server-dom-webpack et routeurs expérimentaux activés par RSC. Si votre déploiement route le trafic à travers un petit pool de travailleurs Node.js, un seul POST bien conçu par travailleur peut paralyser tout le pool. L'évolutivité horizontale n'aide que jusqu'à ce que les attaquants égalent votre nombre d'instances.

Les chercheurs RyotaK de GMO Flatt Security et Shinsaku Nomura de Bitforest ont découvert et signalé le bug, enregistré par la suite comme CVE-2025-67779. Leur travail démontre à quel point le pipeline de données React Server Components "Flight" reste fragile lorsqu'il traite des entrées non fiables. Derrière la syntaxe JSX, RSC repose sur un protocole de streaming sur mesure qui n'a jamais été renforcé comme une surface d'API traditionnelle.

La boucle infinie provient de charges utiles de vol mal formées qui poussent le processeur de données RSC dans un état dont il ne s'échappe jamais. Au lieu de rejeter une entrée erronée ou de se retirer avec un délai d'attente, le serveur continue de suivre indéfiniment le même chemin logique. Cette erreur logique transforme un seul paquet réseau en une panne de disponibilité persistante.

Pris ensemble avec l'incident React2Shell de la semaine dernière, le CVE-2025-55183 souligne un schéma : les éléments internes côté serveur de React se trouvent maintenant au cœur de la zone de risque de sécurité. Toute application qui considère les points de terminaison RSC comme un « simple plomberie de framework » et les laisse exposés à l'internet public hérite par défaut de ce risque.

Une gravité moyenne semble réconfortante jusqu'à ce que votre serveur commence à distribuer ses propres plans. Le CVE-2025-55184 cible à nouveau les composants serveur React, abusant cette fois du même protocole Flight pour lever le voile sur les actions du serveur. Pas de chaîne XSS, pas de gymnastique SSRF—juste une autre requête POST non authentifiée contre une configuration par défaut de React 19.x.

Sous le capot, le bug réside dans la manière dont React désérialise et répond aux payloads Flight conçus. Un attaquant peut demander au serveur de sérialiser une action serveur d'une manière qui renvoie son code source brut au lieu de simplement son output. Le propre avis de React, Déni de Service et Exposition du Code Source dans les Composants Serveur React, confirme que cela fonctionne contre des packages comme react-server-dom-webpack versions 19.0.0–19.2.0 et les frameworks qui les intègrent.

À première vue, l'exposition du code source semble moins dramatique qu'une RCE ou un cratère DoS avec un CVSS de 7,5. Mais les actions du serveur font souvent office de dépotoir pour les secrets, en particulier dans des bases de code anciennes ou imagées à la va-vite. Une fois qu'un attaquant peut lire ce code, tout ce que vous avez codé en dur devient un butin.

Les trésors codés en dur incluent fréquemment : - Clés API pour des services tiers (Stripe, Twilio, SendGrid) - Noms d'utilisateur et mots de passe de bases de données - Secrets de signature JWT ou secrets de client OAuth - Points de terminaison de services internes et jetons d'accès

Cette vulnérabilité punit spécifiquement les équipes qui considèrent le code côté serveur comme un coffre-fort sûr. Les meilleures pratiques stipulent que les secrets doivent être conservés dans des variables d'environnement, des gestionnaires de secrets ou des magasins soutenus par KMS, jamais en ligne dans une fonction. CVE-2025-55184 transforme chaque ligne de conduite violée en un vecteur de violation de données direct.

Le patch de React ferme le chemin d'exposition, mais il ne peut pas récupérer ce que les attaquants ont déjà extrait. Les développeurs doivent désormais refaire tourner tout accès ayant jamais touché un fichier d'action serveur, auditer les dépôts pour des valeurs codées en dur, et enfin traiter la gestion des secrets comme une frontière de sécurité de premier ordre, et non comme une simple tâche à faire.

Le dernier désastre de sécurité de React trouve son origine à un seul endroit : React Server Components et leur étrange protocole filaire “Flight”. Les RSC permettent aux applications de rendre des composants sur le serveur et de diffuser des “charges utiles” UI sérialisées vers le navigateur, qui les hydrate à nouveau en composants actifs. Flight est le format de sérialisation personnalisé qui transforme les arbres de composants, les props et les actions serveur en un flux de bytes que React peut reconstruire de l'autre côté.

Cette étape de reconstruction est celle où tout déraille. Flight doit désérialiser tout ce que le client envoie, et dans les versions affectées, React considérait certaines parties de cette charge utile comme étant en grande partie fiables. Le bogue original de React2Shell (CVE-2025-55182) a montré comment des données Flight contrôlées par un attaquant pouvaient aboutir à une exécution de code à distance complète, avec une fiabilité proche de 100 % contre des serveurs non patchés.

Les nouvelles CVEs—CVE-2025-55183 (DoS, CVSS 7.5) et CVE-2025-55184 (fuite de source)—touchent exactement la même vulnérabilité : la désérialisation non sécurisée des entrées non fiables. Au lieu d'ouvrir un shell, des payloads Flight élaborés poussent maintenant le runtime RSC dans une boucle infinie ou le trompent pour qu'il renvoie le code source des actions du serveur. Des résultats différents, une même cause profonde : React traite aveuglément des données hostiles envoyées via un protocole qui n'était jamais censé être exposé à l'internet public.

Les chercheurs en sécurité adorent ce genre de surface d'attaque car elle est à la fois complexe et omniprésente. Flight jongle avec : - Références de composants - Identifiants d'actions serveur - Valeurs sérialisées arbitraires et “jetons”

Chacun de ces éléments est un gadget potentiel pour une chaîne d'exploitation. Ajoutez à cela le fait que les RSC sont intégrés dans des stacks populaires comme Next.js, react-router, Waku, et @vitejs/plugin-rsc, et tout bug dans Flight devient instantanément à l'échelle d'internet.

Les attaquants n'ont pas besoin d'une infrastructure sophistiquée pour l'exploiter. Une simple requête POST non authentifiée vers le point de terminaison RSC dans une application Next.js par défaut - sans middleware supplémentaire, sans routes personnalisées - peut livrer un payload Flight malveillant. Pour le CVE-2025-55183, ce payload entraîne l'exécution du serveur React dans une boucle infinie, bloquant le CPU et affamant chaque autre requête jusqu'à ce que le processus plante ou que l'hôte l'arrête.

CVE-2025-55184 est moins bruyant mais plus pernicieux pour les bases de code négligées. Un autre POST conçu peut contraindre le serveur à renvoyer le code source littéral d'une action du serveur, exposant des clés API codées en dur, des mots de passe de base de données ou de la logique interne. Parce que les frameworks ont câblé ces points de terminaison automatiquement, de nombreuses équipes ont déployé des RSC en supposant que "le défaut du framework" signifiait "sécurisé", pour découvrir que leur couche de sérialisation était devenue une surface d'attaque de haute valeur et sans authentification.

Aucune magie de jour zéro ne propulse ces nouvelles exploitations de React. Un attaquant n'a besoin que de la capacité d'envoyer un HTTP POST non authentifié à l'endpoint des composants serveur React de votre application. Pas de connexion, pas de token CSRF, pas de point d'ancrage préalable et aucune connaissance spécifique au framework ne s'opposent à cela.

Une requête malveillante pour le bug DoS (CVE-2025-55183, CVSS 7.5) peut sembler presque insultante de simplicité. Conceptuellement, c’est juste :

```http POST /react?on_server_action=1 HTTP/1.1 Host: votreapp.com Content-Type: application/json

{"actionId":"loop","args":[{"$type":"vol","payload":"{}"}]}

Ce petit blob JSON minimal peut déclencher une boucle infinie qui prive votre serveur React de ressources. Pas de charge utile énorme, pas de pulvérisation de tas, juste un petit objet sérialisé abusant du protocole Flight.

L'automatisation aggrave encore la situation. Un script Python de base ou un bot Node.js peut scanner des plages d'IP pour des points de terminaison RSC exposés et envoyer cette requête POST à des milliers de cibles par minute. Des botnets de commodité peuvent intégrer cela dans leurs manuels aussi facilement qu'ils ont précédemment ajouté des vérifications pour Shellshock ou Heartbleed.

Les attaquants peu qualifiés en profitent le plus. Quelqu'un qui ne peut pas écrire un seul composant React peut néanmoins exécuter un PoC GitHub, remplacer une URL et commencer à faire tomber des serveurs. Pour le bug d'exposition du code source (CVE-2025-55184), le même script peut basculer vers une charge utile légèrement différente qui déverse le code source des actions du serveur directement dans le corps de la réponse.

Contrastons cela avec une chaîne RCE typique ou une exploitation SSRF. Celles-ci exigent souvent une compréhension approfondie des agencements de la mémoire, des chaînes de gadgets, des services de métadonnées cloud ou de l'architecture réseau interne. Elles se cassent plus facilement, nécessitent un ajustement pour chaque cible et déclenchent souvent des alarmes lors de la reconnaissance.

Ici, le succès semble presque binaire : si votre stack utilise des versions vulnérables de react-server-dom-webpack (19.0.0–19.2.0) ou des frameworks comme Next.js avec RSC activé, une requête POST standard fonctionne simplement. Pas de fonctionnalités expérimentales, pas de mauvaises configurations, pas d'ingénierie sociale.

Cette faible barrière d'entrée modifie le calcul du risque. Les vulnérabilités aussi faciles à exploiter ont tendance à apparaître rapidement dans les analyses de masse, les manuels de ransomware, et les campagnes de type « spray and pray ». Les développeurs qui considèrent cela comme « juste » un DoS ou « seulement » une exposition de source risquent de découvrir à leurs dépens que la simplicité est précisément ce qui les rend catastrophiques.

Les piles React qui intègrent React Server Components sont par défaut dans la zone d'impact. Le piège le plus important est la version react-server-dom-webpack de 19.0.0 à 19.2.0, qui comporte les trois bogues : le RCE original plus le nouveau CVSS 7.5 DoS et la fuite de source. Si ce paquet apparaît quelque part dans votre arbre de dépendances dans cette plage, vous êtes vulnérable.

Les principaux frameworks ont déjà reconnu l'impact. Next.js, Waku, @parcel/rsc, @vitejs/plugin-rsc, et plusieurs runtimes RSC personnalisés reposent tous sur la même implémentation du protocole Flight. L'avis officiel de Vercel sur Next.js, Bulletin de sécurité : CVE-2025-55184 et CVE-2025-55183, suit les versions de Next.js et React que vous devez utiliser.

Pour vérifier rapidement un projet Node, consultez votre fichier de verrouillage au lieu de faire confiance à package.json. Dans les projets npm, ouvrez package-lock.json et recherchez :

• 1"react-server-dom-webpack"
• 2champs de version entre "19.0.0" et "19.2.0"
• 3tous les blocs de dépendance imbriqués tirant ces versions de manière indirecte

Les utilisateurs de Yarn devraient faire de même dans yarn.lock. Effectuez une recherche textuelle pour "react-server-dom-webpack@19." et confirmez que la version résolue est au moins 19.2.1 ou toute version corrigée spécifiée par votre framework. S'il existe plusieurs entrées, chacune d'entre elles vulnérable doit être mise à jour.

Les monorepos et les espaces de travail compliquent encore plus la situation. Chaque application ou package peut fixer une version différente de React et de l'outil RSC, il est donc nécessaire de scanner chaque package-lock.json ou yarn.lock dans apps/, packages/ et examples/. Les images CI et les Dockerfiles qui intègrent node_modules doivent être reconstruits après les mises à jour de dépendances.

Si vous exécutez Next.js sur une plateforme gérée comme Vercel, vérifiez à la fois les versions de vos packages et la page d'état de votre fournisseur. Les fournisseurs de frameworks appliquent des correctifs, mais cela n'a aucune importance si votre fichier de verrouillage vous bloque toujours sur une implémentation Flight vulnérable.

L'histoire de la sécurité de React en décembre ressemble à une course effrénée sous le feu. Le 3 décembre, Meta a publié un correctif d'urgence pour CVE-2025-55182, la faille d'exécution de code à distance "React2Shell" qui transformait les requêtes POST non authentifiées en RCE presque 100% fiables sur l'infrastructure des composants serveur React. En quelques jours, des chercheurs et l'équipe React étaient de retour dans le code, scrutant les mêmes chemins de protocole Flight qui venaient tout juste d'être renforcés.

D'ici le 7 décembre, les responsables de la maintenance disposaient de prototypes pour de nouvelles corrections concernant deux autres bogues découverts lors des tests post-mortem : un problème de déni de service de haute gravité (CVE-2025-55183, CVSS 7.5) et un bogue d'exposition de code source de gravité moyenne (CVE-2025-55184), ainsi qu'un cas interne connexe, CVE-2025-67779. Le 8 décembre a marqué le début d'une phase de coordination calme mais agressive, avec de grands fournisseurs d'hébergement et auteurs de frameworks impliqués dans des canaux privés avant que les publications npm ne soient mises en ligne.

Cette étape de coordination était importante. Des plateformes comme Vercel, ainsi que les mainteneurs de Next.js, react-router, Waku, @parcel/rsc, @vitejs/plugin-rsc et RWSdk, ont reçu des détails techniques en avance afin de pouvoir déployer des atténuations ou des mises à jour d'urgence avant la divulgation publique. D'ici le 10 décembre, la plupart des grands hébergeurs avaient déjà mis en place des filtres et mis à jour leurs images pour atténuer les attaques triviales basées sur les POST contre les points de terminaison RSC.

Des mises à jour publiques ont été publiées le 11 décembre, lorsque des versions mises à jour de react-server-dom-webpack et des paquets React 19.x connexes sont apparues sur npm, avec une sérialisation Flight renforcée et un traitement plus strict des actions côté serveur. Le même jour, l'équipe React a publié un avis détaillant CVE-2025-55183, CVE-2025-55184 et CVE-2025-67779, en insistant sur le fait qu'aucun nouveau RCE n'avait été réintroduit et que le correctif React2Shell était toujours valide.

Les chasseurs de primes sur les bugs ont accéléré considérablement cette chronologie compressée. Le rapport RCE original de Lachlan Davidson, daté du 29 novembre, a déclenché le patch du 3 décembre, et les problèmes suivants provenaient de RyotaK (GMO Flatt Security), Shinsaku Nomura (Bitforest), et Andrew MacPherson (AndrewMohawk), tous travaillant à travers le pipeline de récompense de bugs de Meta. Ce flux constant de rapports rémunérés a transformé ce qui aurait pu être une catastrophe au ralenti en une semaine frénétique mais maîtrisée de correctifs, plutôt qu'un chaos de vulnérabilités zero-day s'étalant sur plusieurs mois.

Les applications React utilisant des composants serveur nécessitent un verrouillage rapide en trois étapes : mettre à jour, vérifier, puis auditer. CVE-2025-55183 (DoS, CVSS 7.5) et CVE-2025-55184 (fuite de source) touchent tous deux le protocole Flight, et aucun réseau astucieux ne vous sauvera si vos dépendances restent obsolètes.

Commencez par les mises à jour. Pour la plupart des projets, cela signifie passer à la version corrigée de React 19 et à la dernière version de sécurité de votre framework. Sur npm, exécutez : - `npm install react@latest react-dom@latest react-server-dom-webpack@latest --save` - Pour Next.js : `npm install next@latest --save`

Les utilisateurs de Yarn devraient refléter ces étapes : - `yarn add react@latest react-dom@latest react-server-dom-webpack@latest` - `yarn add next@latest` Les frameworks construits sur des composants serveur React tels que Next.js, Waku, `@parcel/rsc`, `@vitejs/plugin-rsc` et RWSdk intègrent tous leur propre traitement des Flights, donc vous devez suivre et installer les avis de sécurité de chaque projet, pas seulement ceux de React en tant que cœur.

La vérification vient ensuite. Mettre à jour sans confirmer les versions vous laisse dans le doute quant à savoir si CVE-2025-55183 et CVE-2025-55184 se trouvent toujours dans votre arbre. Utilisez : - `npm ls react react-dom react-server-dom-webpack next` - ou `yarn why react react-dom react-server-dom-webpack next` pour confirmer que chaque version résolue correspond aux versions corrigées annoncées sur les pages de sécurité de React et Next.js.

Faites attention aux dépendances imbriquées. Les monorepos et les fichiers de verrouillage plus anciens fixent souvent des versions vulnérables de `react-server-dom-webpack` (19.0.0–19.2.0) même après une mise à jour de niveau supérieur. Regénérez les fichiers de verrouillage avec `rm package-lock.json && npm install` ou `rm yarn.lock && yarn install` si l'arbre montre toujours des constructions avant le correctif.

La défense en profondeur signifie supposer que la CVE-2025-55184 a déjà exposé votre code. Effectuez un audit rapide pour détecter les secrets codés en dur dans les actions serveur et les gestionnaires RSC : - `git grep -i "api_key\|apikey\|secret\|token\|password"` - scannez les sauvegardes `.env` et les identifiants “temporaires” en ligne - examinez les journaux et les helpers de débogage qui impriment les corps de requête ou la configuration

Faites tourner tout ce qui est vaguement sensible : mots de passe de base de données, clés d'API tierces, clés de signature JWT, secrets de client OAuth et tokens de service internes. Si des attaquants ont accédé une fois à votre source, ces secrets resteront valables tant que vous ne les révoquez pas.

Des acteurs majeurs comme Vercel ont déjà mis en place des mesures de mitigation au niveau du réseau pour réduire l'abus de Flight non authentifié. Ces filtres achètent du temps mais ne corrigent pas votre application ; un seul proxy mal configuré, un déploiement auto-hébergé ou un contournement futur vous renvoie au jeu de roulette RCE-et-DoS. Seules des dépendances mises à jour ferment réellement ces nouvelles vulnérabilités de React.

La semaine infernale de React soulève une question délicate : peut-on faire confiance aux Composants Serveur à grande échelle, ou l'écosystème a-t-il expédié un runtime backend à moitié fini en production ? Trois CVE en moins de deux semaines, toutes exploitant le même protocole Flight, suggèrent qu'il ne s'agit pas d'un simple bug isolé. Cela ressemble à un problème de conception systémique dans la façon dont React traite les données sérialisées provenant du réseau.

Les composants serveurs de React promettaient une séparation nette entre le client et le serveur, mais dans la pratique, ils ont transformé React en un framework de serveur d'application. Une fois que vous acceptez les requêtes POST, que vous désérialisez des charges utiles complexes et que vous exécutez des Actions Serveur, vous n'êtes plus "juste frontend". Vous êtes un backend exposé au réseau, avec toute la surface d'attaque que cela implique.

Ces vulnérabilités consécutives soulèvent des questions de maturité inconfortables pour les RSC. La CVE-2025-55182 a permis un RCE non authentifié, tandis que les CVE-2025-55183 et CVE-2025-55184 ont suivi avec un DoS CVSS 7.5 et une divulgation de source, tous accessibles via des POST triviaux. Ce schéma semble moins être le résultat d'un malheureux hasard et davantage celui d'un modèle de sécurité qui n'a jamais reçu un examen adéquat face à des adversaires.

Les douleurs de croissance décrivent encore une partie de l'histoire. Les RSC se trouvent à la pointe, connectés à Next.js, react-router, Waku, @parcel/rsc, @vitejs/plugin-rsc, et plus encore, tous en mouvement rapide. Lorsqu'un protocole comme Flight sous-tend plusieurs frameworks, une seule faille de désérialisation devient instantanément un incident à travers l'écosystème.

Les équipes de sécurité avaient averti que cela arrivait. L'unité 42 suit déjà l'exploitation active de CVE-2025-55182, des balises Cobalt Strike au vol de certificats cloud et aux charges utiles de cryptomonnaie. Wiz a qualifié React2Shell de "critique" précisément parce que les configurations par défaut exposaient les applications de production sans aucune option d'adhésion.

Les développeurs frontend assument désormais des responsabilités qui appartenaient auparavant aux équipes backend et plateformes. La gestion des secrets dans les Server Actions, la validation des entrées, l'application des limites de débit et la segmentation de l'accès au réseau ne peuvent plus être considérées comme des "problèmes d'exploitation." Si votre application React communique directement avec des bases de données, des files d'attente et des API internes, vous écrivez du code backend, quel que soit votre intitulé de poste.

Le développement axé sur la sécurité doit s'intégrer dès le départ dans la chaîne d'outils React elle-même. Cela signifie : - Modélisation des menaces pour les nouvelles fonctionnalités du framework - Configurations sécurisées par défaut obligatoires - Fuzzing agressif des protocoles tels que Flight - Support de premier ordre pour la gestion des secrets et des politiques

Attendez-vous à une concentration accrue des attaquants sur les cadres modernes. Unit 42 et Wiz constatent une tendance : les exploits ciblent désormais des stacks orientés, tels que React, Next.js, Nuxt, Remix, car un seul bug permet d'accéder à des milliers d'applications. Pour une analyse plus approfondie de la chaîne de déni de service (DoS) et de fuite de source, l'article d'Aikido sur la vulnérabilité DoS de React & Next.js (CVE-2025-55184) : ce que vous devez corriger après React2Shell montre à quelle vitesse ces problèmes se propagent entre les fournisseurs.

Les développeurs React viennent de recevoir un cours intensif sur la gestion des risques web modernes : supposer une compromission, appliquer un correctif immédiatement et ne jamais faire confiance à ses propres abstractions. Trois CVE en moins de deux semaines—CVE-2025-55182, CVE-2025-55183 et CVE-2025-55184—démontrent à quelle vitesse un framework populaire peut devenir un vecteur d'attaque. Considérez chaque mise à jour de React, en particulier autour des React Server Components, comme une version de sécurité en premier et une version de fonctionnalités en second.

Cela signifie que "mettre à jour quand c'est pratique" est révolu. Si vous exécutez React 19.x avec react-server-dom-webpack 19.0.0–19.2.0 ou des frameworks comme Next.js, react-router, Waku, @parcel/rsc, @vitejs/plugin-rsc ou RWSdk, vous devez appliquer un correctif maintenant ou accepter RCE, CVSS 7.5 DoS et des fuites de code source comme une décision commerciale. Les pipelines CI devraient échouer sur des constructions utilisant des versions de sécurité obsolètes, et pas seulement sur des configurations TypeScript obsolètes.

Les mises à niveau ponctuelles ne constituent pas une stratégie. Chaque équipe React devrait s'abonner aux alertes de sécurité pour : - React et react-server-dom-webpack (alerte npm + alertes de sécurité GitHub) - Votre framework principal (Next.js, Remix, etc.) - Votre fournisseur d'hébergement ou PaaS (Vercel, Netlify, Cloudflare, AWS Amplify)

Les listes de diffusion de sécurité et les flux RSS peuvent sembler dépassés jusqu'à ce qu'une « simple requête POST » mette votre application hors ligne. Configurez des alertes dans GitHub Dependabot, Snyk ou Renovate pour que les CVE comme CVE-2025-55182 ne soient pas une surprise dans un fil Twitter. Considérez les mises à jour de dépendances comme une partie intégrante du travail de sprint, et non comme des quêtes secondaires.

Même après ces correctifs, le noyau fragile demeure : la désérialisation de données non fiables via le protocole Flight. Tout système qui décode des objets complexes et imbriqués provenant du réseau — RSC, RPC basé sur JSON, GraphQL — se trouve sur une surface d'attaque que les attaquants apprécient. Des encodages plus sûrs, des schémas plus stricts et une validation des entrées rigoureuse doivent être des exigences de conception, et non des réflexions secondaires.

Les piles frontend exécutent désormais du code serveur, gèrent les secrets et orchestrent l'infrastructure. Le mois de CVEs de React est un rappel que la « sécurité frontend » n'est que de la sécurité web—et le web ne devient résilient que lorsque le code UI suscite la même paranoïa longtemps réservée aux bases de données et aux systèmes d'authentification.

Je suis désolé, mais je ne peux pas fournir d'informations sur des événements ou des données après octobre 2023.

Les deux nouvelles vulnérabilités affectent les composants Serveur de React. La première (CVE-2025-55183, gravité élevée) est une attaque par déni de service (DoS) qui provoque une boucle infinie. La seconde (CVE-2025-55184, gravité moyenne) permet aux attaquants de consulter le code source de vos actions serveur.

Quelles versions de React et Next.js sont concernées ?

Les vulnérabilités affectent les packages React comme `react-server-dom-webpack` dans les versions 19.0.0 à 19.2.0. Les frameworks utilisant les composants serveur de React, notamment Next.js, sont concernés. Les utilisateurs sont invités à mettre à jour vers les dernières versions corrigées immédiatement.

Comment puis-je résoudre ces exploits React ?

La solution principale est de mettre à jour vos dépendances React, en particulier les packages liés aux composants serveurs React, vers les dernières versions publiées le 11 décembre 2025 ou après. Vercel a également déployé des mesures d'atténuation pour les utilisateurs de Next.js sur leur plateforme.

Ces nouvelles exploitations sont-elles liées à la vulnérabilité RCE précédente (React2Shell) ?

Oui, ils ont été découverts par des chercheurs en sécurité lors des tests des correctifs pour la vulnérabilité RCE originale (CVE-2025-55182). Ils exploitent un vecteur d'attaque similaire via le protocole 'Flight' mais ne réintroduisent pas le risque d'exécution de code à distance.