Skip to content
KitploitKITPLOIT
OutilsBlog
Soumettre
OutilsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

··Flux·Contact·Confidentialité·© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
CVE-2025-55182 — Exploit de preuve de concept pour CVE-2025-55182, une RCE critique non authentifiée dans React Server Components. Comprend un exploit Python automatisé, une analyse technique, des règles de détection et une configuration d'environnement de laboratoire pour des tests de sécurité autorisés. | Kitploit
Outils/GitHubGitHub/tinashelorenzi/cve-2025-55182
Analyse des VulnérabilitésExploitationExploitation d'Applications WebTests d'IntrusionDétection d'IntrusionApprentissage et ÉducationRed TeamingDéveloppement de Charges UtilesLabs et Pratique
GitHubtinashelorenzi/cve-2025-55182

CVE-2025-55182

Voir le dépôt
4il y a 9 moisPas encore vérifié

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →

À propos

Exploit de preuve de concept pour CVE-2025-55182, une RCE critique non authentifiée dans React Server Components. Comprend un exploit Python automatisé, une analyse technique, des règles de détection et une configuration d'environnement de laboratoire pour des tests de sécurité autorisés.

Partager

React2Shell (CVE-2025-55182) - Preuve de Concept

Une preuve de concept exhaustive et une ressource éducative pour CVE-2025-55182, une vulnérabilité critique d'exécution de code à distance affectant les composants serveur React avec un score CVSS de 10.0.

Python Version License CVSS

Avertissement légal

À DES FINS ÉDUCATIVES ET DE TEST AUTORISÉ UNIQUEMENT

Cet outil est fourni à des fins éducatives et de test de sécurité autorisé uniquement. L'accès non autorisé à des systèmes informatiques est illégal en vertu de diverses lois, notamment le Computer Fraud and Abuse Act (CFAA) aux États-Unis et des législations similaires dans le monde entier.

Vous devez :

  • Utiliser cet outil uniquement sur des systèmes que vous possédez ou pour lesquels vous avez reçu une autorisation écrite explicite de test
  • Vous conformer à toutes les lois locales, étatiques et fédérales applicables
  • Utiliser cet outil de manière responsable et éthique

L'auteur et les contributeurs :

  • Ne sont pas responsables de toute utilisation abusive ou de tout dommage causé par cet outil
  • N'approuvent ni n'encouragent l'accès non autorisé à des systèmes informatiques
  • Fournissent cet outil strictement à des fins éducatives et de sécurité défensive

En utilisant cet outil, vous reconnaissez avoir compris et accepté ces conditions.

📋 Table des matières

  • Vue d'ensemble
  • Détails de la vulnérabilité
  • Versions affectées
  • Analyse technique
  • Installation
  • Utilisation
  • Détection
  • Remédiation
  • Configuration de l'environnement de laboratoire
  • Références
  • Contributions
  • Auteur

🎯 Vue d'ensemble

React2Shell est une vulnérabilité critique découverte en décembre 2025 qui affecte les composants serveur React (RSC) et les frameworks qui les implémentent, en particulier Next.js. La vulnérabilité permet l'exécution de code à distance non authentifiée via une seule requête HTTP spécialement conçue.

Ce dépôt contient :

  • ✅ Script d'exploitation Python automatisé
  • ✅ Analyse technique détaillée
  • ✅ Règles de détection (Snort, OSQuery)
  • ✅ Guide de configuration de l'environnement de laboratoire
  • ✅ Documentation complète

🔍 Détails de la vulnérabilité

ChampDétails
Identifiant CVECVE-2025-55182
Score CVSS10.0 (Critique)
Vecteur d'attaqueRéseau
Complexité de l'attaqueFaible
Privilèges requisAucun
Interaction utilisateurAucune
ImpactCompromission complète du système (RCE)
Date de divulgationDécembre 2025

Qu'est-ce qui rend cela critique ?

  1. Aucune authentification requise – Exploitable par tout attaquant non authentifié
  2. Configurations par défaut vulnérables – Les applications Next.js standard créées avec create-next-app sont exploitables
  3. Haute fiabilité – Taux de réussite d'exploitation proche de 100 %
  4. Surface d'attaque étendue – Plus de 571 000 serveurs publics exécutant des composants React (données Shodan)
  5. Impact sévère – Exécution complète de code à distance avec les privilèges du processus Node.js

📦 Versions affectées

Composants serveur React

Versions vulnérables :

  • react-server-dom-webpack : 19.0.0, 19.1.0, 19.1.1, 19.2.0
  • react-server-dom-parcel : 19.0.0, 19.1.0, 19.1.1, 19.2.0
  • react-server-dom-turbopack : 19.0.0, 19.1.0, 19.1.1, 19.2.0

Versions corrigées :

  • React 19.0.1
  • React 19.1.2
  • React 19.2.1

Next.js

Versions vulnérables :

  • Toutes les versions ≥14.3.0-canary.77
  • Toutes les versions 15.x (avant correctif)
  • Toutes les versions 16.x (avant correctif)

Versions corrigées :

  • Consultez les versions de Next.js pour les mises à jour intégrant les correctifs React

Autres frameworks affectés

  • React Router (en mode RSC)
  • Waku
  • Redwood SDK
  • Divers frameworks compatibles RSC

🔬 Analyse technique

Cause racine

La vulnérabilité existe dans la fonction requireModule au sein de la logique de désérialisation des composants serveur React :

root@kitploit:~
function requireModule(metadata) {  
  var moduleExports = __webpack_require__(metadata[0]);  
  return moduleExports[metadata[2]];  // LIGNE VULNÉRABLE - Parcours de la chaîne de prototypes
}

La faille permet aux attaquants de parcourir la chaîne de prototypes de JavaScript via le protocole React Flight, accédant au constructeur Function via des propriétés comme constructor.constructor, permettant l'exécution de code arbitraire.

Chaîne d'exploitation

  1. Création de bloc factice – L'attaquant envoie des données multipart/form-data avec un objet bloc falsifié
  2. Pollution de prototype – Exploite __proto__ pour créer une structure auto-référentielle
  3. Abus du gestionnaire Blob – Déclenche le gestionnaire de désérialisation Blob interne de React
  4. Accès au constructeur Function – Parcourt constructor.constructor pour accéder à Function()
  5. Exécution de code – Injecte du JavaScript arbitraire via child_process.execSync()

Schéma du déroulement de l'attaque

root@kitploit:~
┌─────────────────────────────────────────────────────────────┐
│  L'attaquant envoie multipart/form-data avec en-tête Next-Action │
└──────────────────────┬──────────────────────────────────────┘
                       │
                       ▼
┌─────────────────────────────────────────────────────────────┐
│  Le serveur désérialise la charge utile via le protocole React Flight │
└──────────────────────┬──────────────────────────────────────┘
                       │
                       ▼
┌─────────────────────────────────────────────────────────────┐
│  Traitement de l'objet bloc factice avec pollution __proto__  │
└──────────────────────┬──────────────────────────────────────┘
                       │
                       ▼
┌─────────────────────────────────────────────────────────────┐
│  Le gestionnaire Blob invoque _formData.get(_prefix + id)   │
└──────────────────────┬──────────────────────────────────────┘
                       │
                       ▼
┌─────────────────────────────────────────────────────────────┐
│  Résout en Function("malicious_code")                        │
└──────────────────────┬──────────────────────────────────────┘
                       │
                       ▼
┌─────────────────────────────────────────────────────────────┐
│  Code arbitraire exécuté avec les privilèges du processus Node.js │
└─────────────────────────────────────────────────────────────┘

🚀 Installation

Prérequis

  • Python 3.7 ou supérieur
  • Bibliothèque requests

Configuration

root@kitploit:~
# Cloner le dépôt
git clone https://github.com/yourusername/react2shell-poc.git
cd react2shell-poc

# Installer les dépendances
pip install -r requirements.txt

# Rendre le script exécutable (Linux/macOS)
chmod +x react2shell.py

Requirements.txt

root@kitploit:~
requests>=2.31.0
urllib3>=2.0.0

💻 Utilisation

Utilisation de base

root@kitploit:~
python3 react2shell.py

Session interactive

root@kitploit:~
╔═══════════════════════════════════════════════════════════╗
║           React2Shell (CVE-2025-55182) PoC                ║
║                 CVSS 10.0 - RCE Critique                  ║
║                                                           ║
║  Affecté : React 19.0.0, 19.1.0, 19.1.1, 19.2.0          ║
║           Next.js ≥14.3.0-canary.77, 15.x, 16.x          ║
║                                                           ║
║  Cerberus Secure - Usage en laboratoire uniquement        ║
╚═══════════════════════════════════════════════════════════╝

[?] Entrez les informations de la cible :
    Hôte (ex. localhost ou 192.168.1.100) : localhost
    Port (ex. 3000) : 3000

[React2Shell]> id
[*] Cible : http://localhost:3000/
[*] Commande : id
[*] Construction de la charge utile d'exploitation...
[*] Envoi de la requête d'exploitation...
[+] Code de statut de la réponse : 200
[*] Analyse de la réponse...

╔═══════════════════════════════════════════════════════════╗
║                    SORTIE DE COMMANDE                     ║
╚═══════════════════════════════════════════════════════════╝
uid=1000(node) gid=1000(node) groups=1000(node)

[React2Shell]> whoami
[React2Shell]> pwd
[React2Shell]> ls -la
[React2Shell]> exit

Exemples de commandes

root@kitploit:~
# Reconnaissance système
[React2Shell]> id
[React2Shell]> whoami
[React2Shell]> uname -a
[React2Shell]> cat /etc/os-release

# Exploration du système de fichiers
[React2Shell]> pwd
[React2Shell]> ls -la
[React2Shell]> cat package.json

# Variables d'environnement (contiennent souvent des secrets)
[React2Shell]> printenv
[React2Shell]> echo $PATH

# Informations réseau
[React2Shell]> ifconfig
[React2Shell]> netstat -tulpn

Commandes disponibles

CommandeDescription
<toute commande shell>Exécute une commande sur la cible
helpAffiche le message d'aide
exit / quit / qQuitte l'outil

🛡️ Détection

Détection au niveau réseau (Snort v3)

Déployez cette règle Snort pour détecter les tentatives d'exploitation :

root@kitploit:~
alert http any any -> $LAN_NETWORK any (
    msg:"Tentative potentielle Next.js React2Shell / CVE-2025-55182";
    flow:to_server,established;
    content:"Next-Action"; http_header; nocase;
    content:"multipart/form-data"; http_header; nocase;
    pcre:"/Content-Disposition:\s*form-data;\s*name=\"0\"/s";
    pcre:"/\"status\"\s*:\s*\"resolved_model\"/s";
    pcre:"/\"then\"\s*:\s*\"\$1:__proto__:then\"/s";
    classtype:web-application-attack;
    sid:6655001;
    rev:1;
)

Logique de détection :

  • Surveille l'en-tête Next-Action (spécifique RSC)
  • Détecte les charges utiles multipart/form-data
  • Identifie les motifs spécifiques à l'exploitation : name="0", status: "resolved_model", then: "$1:__proto__:then"

Détection sur point de terminaison (OSQuery)

Utilisez cette règle OSQuery pour analyser les versions de paquets vulnérables :

root@kitploit:~
{
  "queries": {
    "detect_react2shell_vulnerable_packages": {
      "query": "SELECT name, version, path FROM npm_packages WHERE (name='react-server-dom-parcel' AND (version='19.0.0' OR (version >= '19.1.0' AND version < '19.1.2') OR version='19.2.0')) OR (name='react-server-dom-turbopack' AND (version='19.0.0' OR (version >= '19.1.0' AND version < '19.1.2') OR version='19.2.0')) OR (name='react-server-dom-webpack' AND (version='19.0.0' OR (version >= '19.1.0' AND version < '19.1.2') OR version='19.2.0'));",
      "interval": 3600,
      "description": "Détecte les versions vulnérables des paquets React Server Components affectés par CVE-2025-55182",
      "platform": "linux,windows,macos",
      "version": "1.0"
    }
  }
}

Avantages :

  • Analyse les points de terminaison pour les paquets vulnérables
  • Fonctionne dans les environnements de développement, staging et production
  • Peut être intégré dans les pipelines CI/CD
  • Fournit une alerte précoce avant le déploiement

Indicateurs d'analyse de logs

Recherchez ces motifs dans vos logs d'application :

root@kitploit:~
- Requêtes HTTP POST avec en-tête "Next-Action"
- Requêtes multipart/form-data inhabituelles vers la racine de l'application
- Messages d'erreur contenant "NEXT_REDIRECT" avec des valeurs de digest inattendues
- Pic d'erreurs 500 avec des traces de pile liées à React
- Création de processus enfant à partir de Node.js (execSync, spawn, exec)

🔧 Remédiation

Actions immédiates

1. Mettre à jour les paquets vulnérables

root@kitploit:~
# Vérifier les versions actuelles
npm list react-server-dom-webpack react-server-dom-parcel react-server-dom-turbopack

# Mettre à jour React vers la version corrigée
npm install [email protected] [email protected]

# Mettre à jour Next.js vers la dernière version corrigée
npm install next@latest

# Vérifier les mises à jour
npm list react react-dom next

2. Vérifier la reconstruction de l'application

root@kitploit:~
# Nettoyer le cache et reconstruire
rm -rf .next node_modules package-lock.json
npm install
npm run build

3. Déployer les applications mises à jour

  • Développement : Tester minutieusement dans l'environnement de staging
  • Staging : Valider toutes les fonctionnalités avant la production
  • Production : Déployer avec un plan de retour en arrière approprié

Mesures de sécurité à long terme

1. Mettre en œuvre des règles de pare-feu applicatif (WAF)

Bloquer les motifs suspects :

root@kitploit:~
- Requêtes avec en-tête "Next-Action" provenant de sources non fiables
- Données multipart/form-data avec des structures JSON suspectes
- Requêtes correspondant aux motifs de signature d'exploitation

2. Segmentation réseau

  • Isoler les applications React dans des zones réseau distinctes
  • Mettre en œuvre un filtrage strict du trafic sortant
  • Surveiller et alerter sur les connexions sortantes inhabituelles

3. Protection d'application en cours d'exécution (RASP)

  • Déployer des solutions RASP pour détecter et bloquer les tentatives d'exploitation
  • Surveiller la création suspecte de processus enfants
  • Alerter sur les motifs d'exécution de code inattendus

4. Scan de sécurité dans CI/CD

root@kitploit:~
# Exemple de workflow GitHub Actions
name: Scan de sécurité
on: [push, pull_request]

jobs:
  dependency-check:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Vérifier les paquets React vulnérables
        run: |
          npm audit --audit-level=critical
          npm list react-server-dom-webpack react-server-dom-parcel react-server-dom-turbopack

5. Surveillance et alertes

Configurer des alertes pour :

  • Déploiement de versions de paquets vulnérables
  • Motifs de tentative d'exploitation dans les logs
  • Création inattendue de processus enfants
  • Connexions réseau vers des destinations suspectes

🧪 Configuration de l'environnement de laboratoire

Option 1 : Application Next.js vulnérable

root@kitploit:~
# Créer une nouvelle application Next.js avec une version vulnérable
npx [email protected] vulnerable-app
cd vulnerable-app

# Installer la version vulnérable de React
npm install [email protected] [email protected]

# Démarrer le serveur de développement
npm run dev

Option 2 : Environnement Docker

Créer un Dockerfile :

root@kitploit:~
FROM node:18-alpine

WORKDIR /app

# Créer une application Next.js de base
RUN npx [email protected] vulnerable-app --typescript --tailwind --app --no-src-dir

WORKDIR /app/vulnerable-app

# Installer des versions vulnérables de React
RUN npm install [email protected] [email protected]

EXPOSE 3000

CMD ["npm", "run", "dev"]

Construire et exécuter :

root@kitploit:~
docker build -t react2shell-lab .
docker run -p 3000:3000 react2shell-lab

Option 3 : Docker Compose

Créer docker-compose.yml :

root@kitploit:~
version: '3.8'
services:
  vulnerable-app:
    build: .
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=development
    volumes:
      - ./app:/app/vulnerable-app

Exécuter :

root@kitploit:~
docker-compose up -d

Vérifier la vulnérabilité

Tester avec curl :

root@kitploit:~
curl -X POST http://localhost:3000/ \
  -H "Next-Action: x" \
  -H "Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryx8jO2oVc6SWP3Sad" \
  --data-binary @exploit_payload.txt

📚 Références

Avis de sécurité officiels

  • Avis de sécurité React - CVE-2025-55182
  • Avis de sécurité Next.js
  • NVD - CVE-2025-55182

Recherche et analyse

  • PoC original par maple3142
  • Recherche Wiz Security - Analyse React2Shell
  • Recherche Assetnote Security

Détection et atténuation

  • Documentation Snort
  • Documentation OSQuery
  • Documentation des composants serveur React

Vulnérabilités connexes

  • Log4Shell (CVE-2021-44228) - RCE similaire via désérialisation
  • Spring4Shell (CVE-2022-22965) - RCE au niveau framework

🤝 Contributions

Les contributions sont les bienvenues ! Veuillez suivre ces directives :

  1. Forker le dépôt
  2. Créer une branche de fonctionnalité (git checkout -b feature/amelioration)
  3. Valider vos modifications (git commit -am 'Ajouter une nouvelle méthode de détection')
  4. Pousser la branche (git push origin feature/amelioration)
  5. Créer une Pull Request

Domaines de contribution

  • Règles de détection supplémentaires (Suricata, Zeek, etc.)
  • Intégration avec des frameworks de sécurité (MISP, TheHive, etc.)
  • Variantes de charge utile améliorées
  • Analyse de sortie améliorée
  • Documentation et traductions supplémentaires

📝 Licence

Ce projet est sous licence MIT - voir le fichier LICENSE pour plus de détails.

👤 Auteur

Tinashe

  • Poste : Architecte de solutions en cybersécurité
  • Organisation : Cerberus Secure / iConnect SA
  • Localisation : Johannesburg, Afrique du Sud
  • LinkedIn : https://www.linkedin.com/in/tinashe-matanda/
  • GitHub : @tinashelorenzi

À propos de Cerberus Secure

Cerberus Secure est la division cybersécurité d'iConnect SA, spécialisée dans :

  • L'atténuation DDoS et la sécurité réseau
  • La conformité GRC (POPIA, ECT, PCI-DSS, HPCSA)
  • L'architecture de sécurité et la conception de solutions
  • La réponse aux incidents et le renseignement sur les menaces
  • Le développement de SIEM personnalisés (plateforme Olympus)

🙏 Remerciements

  • maple3142 - Recherche originale de preuve de concept
  • Wiz Security Research - Analyse complète de la vulnérabilité
  • Assetnote - Techniques d'exploitation améliorées
  • Équipe React - Réponse rapide et développement du correctif
  • Équipe Next.js - Mise en œuvre de l'atténuation au niveau framework

⚖️ Divulgation responsable

Cette vulnérabilité a été divulguée de manière responsable par des chercheurs en sécurité à l'équipe React. Cette PoC est publiée après :

  • La disponibilité des correctifs officiels
  • Un délai suffisant pour que les organisations mettent à jour
  • La divulgation publique par l'équipe de sécurité React

Chronologie :

  • Décembre 2025 : Découverte de la vulnérabilité
  • Décembre 2025 : Divulgation coordonnée à l'équipe React
  • Décembre 2025 : Correctifs publiés (19.0.1, 19.1.2, 19.2.1)
  • Décembre 2025 : Divulgation publique et publication de la PoC

Rappel : Utilisez cet outil de manière responsable et uniquement sur des systèmes que vous êtes autorisé à tester.

Pour toute question, préoccupation ou problème de sécurité concernant ce dépôt, veuillez ouvrir un ticket ou contacter directement le mainteneur.

Télécharger l’outil