ReactOOPS - Writeup du Défi Web HTB

Auteur: TheStingR - Team ISP1337Hackers
Défi: ReactOOPS (Web)
Plateforme: Hack The Box
Difficulté: Très Facile - RETIRÉ
Date de résolution: 13 décembre 2025

Table des matières

1. Résumé Exécutif
2. Description du Défi
3. Analyse de la Vulnérabilité
4. Reconnaissance & Énumération
5. Procédure d'Exploitation
6. Extraction du Flag
7. Analyse Technique Approfondie
8. Défense & Atténuation
9. Leçons Apprises

---

Résumé Exécutif

ReactOOPS est un défi web qui exploite CVE-2025-55182 / CVE-2025-66478, une vulnérabilité critique d'exécution de code à distance non authentifiée dans les React Server Components et le Next.js App Router.

Constatations clés :

• ✅ Serveur : Next.js 16.0.6 avec React 19 (vulnérable)
• ✅ Vulnérabilité : Absence de vérification hasOwnProperty dans la désérialisation du protocole Flight
• ✅ Impact : RCE non authentifié avec privilèges root
• ✅ Exploitation : Une seule requête HTTP POST nécessaire

---

Description du Défi

Évaluation Initiale

Le défi présente une application Next.js soignée exécutant l'interface d'assistant NexusAI. L'application semble traiter les entrées utilisateur via les React Server Components, mais des anomalies subtiles dans la couche réactive laissent entrevoir des vulnérabilités sous-jacentes.

Pile Technologique

• Framework : Next.js 16.0.6
• Version React : 19.x
• Déploiement : Conteneur Docker (build standalone Next.js)
• Port serveur : 50183

Qu'est-ce qui rend cela vulnérable ?

L'application utilise :

1. React Server Components (RSC) - Rendu côté serveur avec communication client
2. Protocole Flight - Format de sérialisation pour la transmission de données RSC
3. Dépendances vulnérables - react-server-dom-webpack sans correctifs de sécurité

---

Analyse de la Vulnérabilité

Aperçu de CVE-2025-55182 / CVE-2025-66478

Qu'est-ce que le protocole Flight ?

Le protocole Flight est le format de sérialisation propriétaire de React pour transmettre des données entre le serveur et le client dans les architectures Server Component. Il utilise des références comme :

• $1 - Référence à l'objet à la position 1
• $1:path:to:value - Traversée de chemin de propriété

Le Contrôle de Sécurité Manquant

Code vulnérable dans ReactFlightReplyServer.js de React :

// Ligne ~450 : fonction getOutlinedModel
function getOutlinedModel(response, id) {
    let chunk = chunks.get(id);
    const value = chunk.value;
    
    // Traiter les références comme "$1:path:to:value"
    if (reference.startsWith('$')) {
        const refId = parseInt(reference.slice(1).split(':')[0]);
        const path = reference.slice(1).split(':').slice(1);
        
        let obj = chunks.get(refId).value;
        
        // BOUCLE VULNÉRABLE - AUCUNE VÉRIFICATION hasOwnProperty !
        for (let i = 0; i < path.length; i++) {
            obj = obj[path[i]];  // ← Permet l'accès à la chaîne de prototypes
        }
        return obj;
    }
}

La Version Sûre (Ce qu'elle devrait être) :

for (let i = 0; i < path.length; i++) {
    if (Object.prototype.hasOwnProperty.call(obj, path[i])) {
        obj = obj[path[i]];
    } else {
        throw new Error('Invalid property access');
    }
}

Pourquoi C'est Important

Sans la vérification hasOwnProperty, un attaquant peut traverser :

myObject[__proto__][then] → Chunk.prototype.then
myObject[__proto__][constructor] → Function
myObject[__proto__][constructor][prototype] → function.prototype

Chaîne d'Exploitation

Étape 1 : Envoyer la référence "$1:__proto__:then"
         │
         ├─ Accéder à myChunk[__proto__]
         └─ Puis accéder à [then] sur le prototype

Étape 2 : Créer un faux objet de type Promise
         │
         └─ { then: maliciousFunction }

Étape 3 : React appelle await sur cet objet
         │
         ├─ Invoque la méthode .then()
         └─ Exécute la fonction de l'attaquant

Étape 4 : Exécution de Code Arbitraire
         │
         └─ Le code s'exécute dans le contexte serveur en tant que root

Pourquoi Aucune Vérification d'Authentification ?

La vulnérabilité existe avant la validation de Next-Action :

Flux de traitement de la requête :
├─ Analyser les données du formulaire multipart
├─ Désérialiser le protocole Flight  ← RCE se produit ICI
│  └─ Traiter les références et objets
│  └─ Aucune vérification hasOwnProperty !
├─ Extraire l'en-tête Next-Action
├─ Valider l'ID d'action          ← Cela vient APRÈS
└─ Exécuter le gestionnaire d'action

En déclenchant la RCE pendant la désérialisation, les attaquants contournent tous les contrôles de sécurité au niveau des actions.

---

Reconnaissance & Énumération

Étape 1 : Test de Connexion Initial

# Tester si le service répond
curl -v http://<IP>:PORT/

Attendu : Application Next.js servant du HTML avec RSC activé

Étape 2 : Identification de la Technologie

Rechercher les indicateurs :

• En-têtes de réponse contenant les préfixes next-
• HTML contenant <script type="text/x-component">
• Présence d'artefacts du répertoire .next
• Points de terminaison POST sans authentification évidente

Étape 3 : Détection de la Vulnérabilité

L'indicateur le plus fiable est de tenter une attaque de pollution de prototype et d'observer la réponse :

# Charge utile de détection non destructive
# Envoie : ["$1:a:a"] référençant {}
# Vulnérable : {}.a.a lève une exception → HTTP 500 + E{"digest"
# Patché : hasOwnProperty empêche l'accès → pas de crash

---

Procédure d'Exploitation

Configuration de l'Environnement

# Naviguer vers le répertoire du défi
cd /Challenges/ReactOOPS

# Cloner le framework d'exploit react2shell
git clone https://github.com/freeqaz/react2shell.git

# Vérifier que tous les scripts sont exécutables
chmod +x react2shell/*.sh

Phase 1 : Détection (Preuve Non Destructive)

Objectif : Confirmer que le serveur est vulnérable sans causer de dommages

cd react2shell

# Exécuter la sonde de détection
./detect.sh http://<IP>:PORT

Ce qu'elle fait :

1. Crée une requête POST multipart avec l'en-tête Next-Action: x
2. Envoie la charge utile : ["$1:a:a"] référençant l'objet vide {}
3. Sur un serveur vulnérable : JavaScript tente d'accéder à {}.a.a
4. L'absence de vérification hasOwnProperty provoque un crash
5. Le serveur renvoie une erreur HTTP 500 avec un digest d'erreur

Sortie attendue :

[*] React2Shell Detection Probe (CVE-2025-55182 / CVE-2025-66478)
[*] Target: http://<IP>:PORT

[*] HTTP Status: 500
[!] VULNERABLE - Server returned 500 with E{"digest" pattern

[*] Response body:
0:{\"a\":\"$@1\",\"f\":\"\",\"b\":\"s8I48LfEDhqpCdFN5-HbU\"}
1:E{\"digest\":\"346246470\"}