DEV Community: Annais Molina Fuentes

CVE-2025-55182 · React2Shell: RCE en React Server Components via Prototype Pollution

Annais Molina Fuentes — Sun, 03 May 2026 07:16:06 +0000

Este es un resumen. El análisis completo — walkthrough de la causa raíz, payload íntegro, framework de explotación, artefactos forenses y patch diffing — vive en blog.deviannt.com.

TL;DR: El deserializador Flight de React evalúa como Promise cualquier objeto que tenga un método .then, independientemente de su tipo real. Un atacante envenena Object.prototype.then mediante un POST multipart manipulado, forzando al servidor a ejecutar JavaScript arbitrario a través del constructor de Function. El resultado se exfiltra por la cabecera HTTP X-Action-Redirect. Sin autenticación. Determinista. CVSS v3.1: 10.0 (Critical).

La superficie de ataque

Los React Server Components (RSC) se estabilizaron en React 19 junto con las Server Actions — un modelo en el que los componentes de UI se ejecutan directamente en el servidor y se comunican con el cliente mediante una capa de serialización propia llamada el protocolo Flight. Cuando el cliente invoca una Server Action, envía una petición POST multipart con un payload serializado. El servidor lo deserializa, ejecuta la acción y devuelve el resultado en streaming.

El protocolo Flight no es JSON. Es un formato de streaming con chunks tipados. Su mecanismo central: si un objeto deserializado tiene una función .then, el runtime lo resuelve como una Promise.

Esa suposición es la raíz de esta vulnerabilidad.

⚠️ Cualquier aplicación Next.js que use el App Router con React Server Components está afectada — la configuración por defecto desde Next.js 14. No es necesario que el desarrollador haya definido Server Actions explícitamente. La presencia de los paquetes RSC afectados es suficiente.

Causa raíz

// VULNERABLE — React 19.0.0 / 19.1.0 / 19.1.1 / 19.2.0
if (obj && typeof obj.then === 'function') {
  // comprobación conductual — bypasseable vía cadena de prototipos
}

Si un atacante escribe una función en Object.prototype.then, todos los objetos planos del runtime la heredan. El deserializador ya no puede distinguir una Promise real de un objeto contaminado — e invoca new Function(_prefix) sobre contenido controlado por el atacante.

La cadena de explotación

Reconocimiento — identificar una aplicación Next.js con React 19.0.0–19.2.0 y App Router. Cualquier endpoint que procese multipart/form-data con cabecera Next-Action es un objetivo válido. No se necesita ruta específica ni conocimiento previo de la estructura de la aplicación.
Construcción del payload — body multipart donde __proto__:then envenena Object.prototype, _formData.get se redirige a $1:constructor:constructor y _prefix transporta el JavaScript a ejecutar.
Envío de la petición — un único POST al root con Next-Action: x. El WAF ve una petición multipart bien formada y la reenvía sin inspeccionarla. No se activan firmas de inyección estándar.
Evaluación en el servidor — el deserializador Flight encuentra un objeto con .then (heredado del prototipo contaminado). Llama a new Function(_prefix). Ejecuta el código del atacante.
Exfiltración — el resultado de execSync() se interpola en el digest del error NEXT_REDIRECT. Next.js lo convierte en un 307 con X-Action-Redirect: /login?a=<output>. Se decodifica el parámetro.

Sin inyección de shell. Sin subida de archivos. Sin autenticación. Una sola petición POST.

RCE básico: whoami, id y uname -a ejecutados sobre el servidor Node.js vulnerable.

El payload completo, el one-liner mínimo con curl y el framework de explotación completo react2shell.py — con módulos para shell interactiva persistente, exfiltración de variables de entorno, defacement y denegación de servicio selectiva — están documentados en blog.deviannt.com.

El parche

Publicado simultáneamente en las tres ramas activas de React 19: 19.0.1, 19.1.2, 19.2.1 (3 de diciembre de 2025).

// VULNERABLE
- resolvedValue = resolvedValue[key];

// PARCHEADO
+ if (!resolvedValue.hasOwnProperty(key)) break;
+ resolvedValue = resolvedValue[key];

Los guards con hasOwnProperty bloquean el recorrido de la cadena de prototipos. El atacante ya no puede llegar al constructor de Function mediante $1:constructor:constructor. La cadena se rompe en su primer eslabón.

Verifica si tu instalación está parcheada:

node -e "const r = require('react'); const [maj,min,pat] = r.version.split('.').map(Number); \
  console.log('React:', r.version, (maj===19 && (min<2||(min===2&&pat<1))) ? '❌ VULNERABLE' : '✓ Parcheado')"

🔴 Advisory post-parche: Las versiones inicialmente parcheadas (19.0.1, 19.1.2, 19.2.1) contienen dos CVEs derivados: CVE-2025-55184 (DoS, CVSS 7.5) y CVE-2025-55183 (Exposición de Código Fuente, CVSS 5.3). Actualiza a 19.0.2, 19.1.3 o 19.2.2.

Una lección estructural

La confianza conductual es más débil que la confianza de identidad. La comprobación typeof obj.then === 'function' fue diseñada para ser flexible y funcionar con cualquier thenable. Esa flexibilidad es precisamente lo que la hizo explotable. Cuando un límite de seguridad depende del comportamiento de un objeto en lugar de su identidad, la prototype pollution se convierte en una llave maestra.

Análisis completo → blog.deviannt.com · CVE-2025-55182 · React2Shell

— devianntsec // investigación en seguridad & más

CVE-2025-55182 · React2Shell: RCE in React Server Components via Prototype Pollution

Annais Molina Fuentes — Sun, 03 May 2026 07:12:47 +0000

This is a summary. The full analysis — root cause walkthrough, complete payload, exploitation framework, forensic artifacts, and patch diffing — lives at blog.deviannt.com.

TL;DR: React's Flight deserializer evaluates any object with a .then method as a Promise, regardless of its actual type. An attacker poisons Object.prototype.then through a crafted multipart POST, forcing the server to execute arbitrary JavaScript via the Function constructor. The result is exfiltrated through the X-Action-Redirect HTTP header. No authentication required. Deterministic. CVSS v3.1: 10.0 (Critical).

The attack surface

React Server Components (RSC) stabilized in React 19 alongside Server Actions — a model where UI components execute directly on the server and communicate with the client through a custom serialization layer called the Flight protocol. When a client invokes a Server Action, it sends a multipart POST with a serialized payload. The server deserializes it, executes the action, and streams the result back.

The Flight protocol is not JSON. It is a streaming format with typed chunks. Its core mechanism: if a deserialized object has a .then function, the runtime resolves it as a Promise.

That assumption is the root of this vulnerability.

⚠️ Any Next.js application using the App Router with React Server Components is affected — the default since Next.js 14. Explicitly defined Server Actions are not required. The presence of the affected RSC packages is sufficient

Root cause

// VULNERABLE — React 19.0.0 / 19.1.0 / 19.1.1 / 19.2.0
if (obj && typeof obj.then === 'function') {
  // behavioral check — bypassable via prototype chain
}

If an attacker writes a function to Object.prototype.then, every plain object in the runtime inherits it. The deserializer can no longer distinguish a real Promise from a poisoned plain object — and calls new Function(_prefix) on attacker-controlled content.

The exploit chain

Reconnaissance — identify a Next.js app running React 19.0.0–19.2.0 with App Router. Any endpoint processing multipart/form-data with a Next-Action header is a valid target. No specific route or prior knowledge of the app structure needed.
Payload construction — multipart body where __proto__:then poisons Object.prototype, _formData.get is redirected to $1:constructor:constructor, and _prefix carries the JavaScript to execute.
Request delivery — single POST to root with Next-Action: x. WAFs see a well-formed multipart request and forward without inspection. No standard injection signatures triggered.
Server-side evaluation — the Flight deserializer encounters an object with .then (inherited from the poisoned prototype). Calls new Function(_prefix). Executes attacker code.
Exfiltration — execSync() output is interpolated into a NEXT_REDIRECT error digest. Next.js converts it into a 307 with X-Action-Redirect: /login?a=<output>. Decode the parameter.

No shell injection. No file upload. No authentication. One POST request.

Basic RCE: whoami, id and uname -a executed on the vulnerable Node.js server.

The complete payload structure, the minimal curl one-liner, and the full exploitation framework react2shell.py — with modules for persistent interactive shell, environment variable exfiltration, defacement, and selective denial of service — are documented at blog.deviannt.com.

The patch

Released simultaneously across three React 19 branches: 19.0.1, 19.1.2, 19.2.1 (December 3, 2025).

// VULNERABLE
- resolvedValue = resolvedValue[key];

// PATCHED
+ if (!resolvedValue.hasOwnProperty(key)) break;
+ resolvedValue = resolvedValue[key];

hasOwnProperty guards prevent prototype chain traversal. The attacker can no longer reach the Function constructor through $1:constructor:constructor. Chain broken at the first link.

Verify your installation:

node -e "const r = require('react'); const [maj,min,pat] = r.version.split('.').map(Number); \
  console.log('React:', r.version, (maj===19 && (min<2||(min===2&&pat<1))) ? '❌ VULNERABLE' : '✓ Patched')"

🔴 Post-patch advisory: The initial patch versions (19.0.1, 19.1.2, 19.2.1) also contain two follow-on CVEs: CVE-2025-55184 (DoS, CVSS 7.5) and CVE-2025-55183 (Source Code Exposure, CVSS 5.3). Update to 19.0.2, 19.1.3, or 19.2.2.

One structural lesson

Behavioral trust is weaker than identity trust. The typeof obj.then === 'function' check was designed to be flexible and work with any thenable. That flexibility is exactly what made it exploitable. When a security boundary depends on an object's behavior rather than its identity, prototype pollution becomes a master key.

Full analysis → blog.deviannt.com · CVE-2025-55182 · React2Shell
— devianntsec // security research & beyond