React2Shell (CVE-2025-55182): El Fantasma de la Deserialización en la Máquina RSC

En las últimas semanas de 2025, mientras la mayoría de los equipos de ingeniería se preparaban para el período de vacaciones, surgió una vulnerabilidad que redefinió la seguridad moderna en la web. Apodada “React2Shell” y rastreada como CVE-2025-55182, esta falla no fue solo un error más: fue una ruptura fundamental en el modelo de confianza de los React Server Components (RSC).

Con una puntuación CVSS de 10.0, React2Shell permite a atacantes no autenticados lograr la Ejecución Remota de Código (RCE) mediante una única solicitud HTTP especialmente diseñada. Al igual que el infame Log4Shell de 2021, el peligro radica en su ubicuidad y en la naturaleza “silenciosa” del protocolo subyacente.

En este análisis profundo, exploramos la mecánica del protocolo “Flight” de RSC, la falla de deserialización que abrió la puerta al caos, y cómo puedes proteger tu infraestructura en 2026.

1. ¿Qué es el Protocolo Flight de RSC?

Para entender React2Shell, primero debemos comprender el Protocolo Flight.

Tradicionalmente, las aplicaciones React enviaban JSON o HTML. Con la llegada de React 19 y el App Router, React introdujo los React Server Components (RSC). Los RSC permiten que el servidor renderice componentes de UI y los transmita al cliente en un formato propietario llamado Flight.

Cómo se mueve la data en Flight

Cuando un cliente solicita un RSC o invoca una “Acción del Servidor”, el servidor no solo envía HTML; envía un flujo de objetos JavaScript serializados. Estos objetos representan:

• Árboles de Componentes: La estructura de tu UI.
• Props: Datos pasados a los componentes.
• Referencias al Servidor: Identificadores para funciones que pueden ser llamadas en el servidor.
• Promesas: Marcadores de datos que aún no han llegado.

El protocolo Flight usa una sintaxis específica donde las líneas están precedidas por IDs (por ejemplo, 1:, 2:) y símbolos especiales como $@ para referencias o $B para Blobs.

El decodificador del lado del servidor (que se encuentra en paquetes como react-server-dom-webpack) es responsable de tomar los datos entrantes del cliente—como argumentos para una Acción del Servidor—y reconstruirlos en objetos JavaScript que el servidor puede usar. Aquí es donde el fantasma se escondía.

2. La Vulnerabilidad: CVE-2025-55182 Explicada

La causa raíz de React2Shell es una falla de deserialización insegura. Específicamente, el decodificador del lado del servidor de React no validaba las propiedades de los objetos durante la reconstrucción del flujo Flight.

Contaminación del Prototipo en el Servidor

La vulnerabilidad aprovecha una debilidad clásica de JavaScript: Contaminación del Prototipo. En JavaScript, casi todos los objetos heredan de Object.prototype. Si un atacante puede inyectar propiedades en el prototipo, puede cambiar el comportamiento de todos los objetos en el sistema.

Durante el proceso de decodificación, React usaba nombres de propiedades suministrados por la carga útil Flight entrante para acceder a valores sin verificar si esas propiedades pertenecían al propio objeto (es decir, carecía de verificaciones hasOwnProperty).

La falla: Al crear una carga útil que hacía referencia a propiedades como __proto__ o que shadoweaba métodos internos como then, un atacante podía engañar al entorno de React para recorrer la cadena del prototipo y ejecutar funciones no autorizadas.

3. Anatomía del Exploit: De la Solicitud a la Shell

La brillantez—y el terror—de React2Shell es que no requiere autenticación. Un atacante simplemente encuentra un endpoint que acepte cargas útiles RSC (que casi cualquier ruta en una aplicación Next.js con App Router por defecto) y envía una solicitud POST.

La Cadena de Ataque

Los investigadores identificaron una “cadena de gadgets” de cuatro etapas que convierte este error de deserialización en una shell completa:

Etapa 1: El Bucle Autorreferencial: El atacante envía una solicitud multipart/form-data que contiene un objeto “chunk falso”. Este objeto imita la clase interna Chunk de React.

Etapa 2: Shadowing de Propiedades: La carga útil establece la propiedad then de este chunk falso para que haga referencia a Chunk.prototype.then. Esto crea una referencia circular que obliga al servidor a “esperar” el objeto.

Etapa 3: El manejador de Blobs ($B): El atacante usa el prefijo $B (reservado para Blobs) para activar una función interna específica de React. Esta función es engañada para buscar una referencia maliciosa.

Etapa 4: Ejecución de Código: Al encadenar estos gadgets, el atacante obtiene acceso a los módulos process o child_process de Node.js. Luego puede ejecutar comandos del sistema como whoami, curl, o incluso lanzar una shell inversa.

Un ejemplo (conceptual) de carga útil maliciosa:

POST /api/server-action HTTP/1.1
Content-Type: multipart/form-data; boundary=----Boundary
Next-Action: [Action_ID]

------Boundary
Content-Disposition: form-data; name="0"
{"then":"$1:__proto__:then","status":"resolved_model","value":"payload_here"}
------Boundary
Content-Disposition: form-data; name="1"
"$@0"
------Boundary--

Nota: Esto es una representación simplificada. Los exploits del mundo real usan ofuscación Unicode compleja para evadir firmas básicas de WAF.

4. Por qué se llama “El Fantasma de la Deserialización”

A diferencia de inyecciones SQL tradicionales o XSS, React2Shell sucede antes de que incluso se ejecute el código de tu aplicación.

Evasión de capas de autenticación

Debido a que el protocolo Flight se maneja a nivel del framework (dentro de las internals de React), la carga útil maliciosa se deserializa antes de que llegue a tu middleware o controles de autenticación. Si el framework procesa el flujo, la RCE ya está activada.

Área de superficie objetivo

La vulnerabilidad no se limita a aplicaciones que usan “Acciones del Servidor”. Cualquier aplicación que ejecute una versión vulnerable de React 19 que soporte RSC está potencialmente en riesgo. Esto incluye:

• Next.js (15.x y 16.x)
• React Router (en modo RSC)
• Waku
• Integraciones RSC de Vite/Parcel

5. Impacto en el Mundo Real (2025-2026)

A principios de 2026, los datos sobre el impacto de React2Shell son asombrosos.

Explotación generalizada

Empresas de seguridad como Wiz y Mandiant reportaron que el 39% de los entornos en la nube contenían al menos una instancia vulnerable de React en 48 horas tras la divulgación. Los escáneres automatizados rápidamente aprovecharon la falla, causando:

• Cryptojacking: despliegue masivo de mineros XMRig en Vercel y AWS Lambda.
• Exfiltración de datos: atacantes usan la RCE para consultar endpoints de metadatos en la nube (como 169.254.169.254) y robar roles IAM y credenciales de bases de datos.
• Puertas traseras persistentes: las familias de malware “SNOWLIGHT” y “COMPOOD” usaron React2Shell para establecer puntos de apoyo permanentes en redes empresariales.

Incidente en Cloudflare

En un evento de “daño colateral” notable, Cloudflare experimentó una breve caída en diciembre de 2025. ¿La causa? Un despliegue de emergencia de mitigaciones WAF diseñadas para bloquear cargas útiles Flight malformadas fue tan agresivo que accidentalmente rompió el tráfico legítimo de React en miles de sitios.

6. ¿Soy vulnerable? (Lista de verificación)

Si estás ejecutando una aplicación React construida entre finales de 2024 y finales de 2025, probablemente estás en la mira.

Paquete	Versiones vulnerables	Versiones parcheadas
React	19.0.0 – 19.2.0	19.0.1, 19.1.2, 19.2.1+
Next.js	15.0.0 – 16.0.6	15.1.0, 16.0.7+
react-server-dom-webpack	< 19.0.1	19.0.1+

Advertencia: Las versiones Canary y Experimentales de React (especialmente las posteriores a 14.3.0-canary.77) también son altamente vulnerables.

7. Detección y Estrategias de Mitigación

Mitigación inmediata: La protección WAF

Si no puedes parchear de inmediato, tu primera línea de defensa es un Web Application Firewall (WAF). Debes bloquear cualquier solicitud POST que:

• Contenga los encabezados Next-Action o rsc-action-id.
• Contenga la cadena $@ seguida de marcadores de traversal de propiedades como :__proto__ o :constructor.
• Tenga estructuras multipart/form-data inusualmente complejas dirigidas a endpoints RSC.

La solución definitiva: Parchear

Actualizar tus dependencias es la única forma de eliminar el “Fantasma.”

# Actualizar Next.js
npm install next@latest react@latest react-dom@latest

# Verifica tu lockfile para los siguientes paquetes:
# react-server-dom-webpack
# react-server-dom-turbopack

El parche introduce verificaciones estrictas de hasOwnProperty y refuerza el decodificador Flight contra traversal de objetos en el prototipo.

Monitoreo en tiempo de ejecución

Implementa herramientas como Falco o Sysdig para vigilar la creación de procesos sospechosos desde tu entorno Node.js.

• Indicador de compromiso (IoC): proceso node que genera sh, bash, curl o wget.
• Indicador de compromiso (IoC): conexiones salientes inesperadas a IPs C2 conocidas o pools de minería.

8. Lecciones para el futuro de la seguridad en React

React2Shell es una llamada de atención para la era “Server-First” del desarrollo web. A medida que trasladamos más lógica al servidor mediante RSC y Acciones del Servidor, estamos reintroduciendo viejas clases de vulnerabilidades de formas nuevas y más abstractas.

La serialización nunca es segura: cualquier protocolo que vuelva a ensamblar objetos complejos desde la entrada del cliente es un vector de ataque masivo.

Seguridad a nivel de framework: los desarrolladores confían en que los frameworks sean seguros por defecto. Cuando el propio framework es el vector, la seguridad estándar de la aplicación (como JWTs o tokens CSRF) puede no ser suficiente.

El efecto “Log4j”: las aplicaciones web modernas se construyen sobre una pila profunda de dependencias. Un error en un paquete central como react-server-dom-webpack puede comprometer millones de aplicaciones descendientes.

Conclusión

React2Shell (CVE-2025-55182) será recordado como el momento en que la comunidad React enfrentó su primera crisis de seguridad a nivel de infraestructura. Al entender la mecánica de deserialización del protocolo Flight, puedes defenderte mejor contra este “fantasma” y construir aplicaciones más resistentes.

¿Has auditado hoy tus node_modules? El fantasma del RSC todavía podría estar acechando en tus despliegues de 2025.