CVE-2025-55182 — React2Shell

Execução Remota de Código Crítica em Componentes do Servidor React.

Gravidade: CRÍTICA | CVSS v3.1: 10.0 (Máximo) | Status: Ativamente Explorado

---

O Que É Isso?

React2Shell é uma vulnerabilidade de segurança crítica nos Componentes do Servidor React (RSC) — um recurso moderno que permite ao React executar partes do seu aplicativo web no servidor em vez do navegador.

A falha permite que qualquer invasor na internet — sem nenhum login, nenhum acesso especial e nenhum conhecimento prévio do seu sistema — envie uma única requisição HTTP maliciosa para o seu servidor e execute qualquer código que desejar nele. Isso significa que eles podem roubar dados, instalar malware, bloquear seus arquivos com ransomware ou assumir o controle total do seu servidor.

Pense assim: seu servidor tem uma porta que deveria abrir apenas para visitantes confiáveis, mas acontece que qualquer um pode entrar — apenas batendo de uma maneira específica.

---

Referência Rápida

Propriedade	Valor
CVE ID	CVE-2025-55182 (também chamado de React2Shell)
Gravidade	Crítica — Execução Remota de Código (RCE)
Pontuação CVSS v3.1	10.0 / 10.0 (máximo possível)
Pontuação CVSS v4	9.3 / 10.0
Tipo de Fraqueza	CWE-502 — Desserialização de Dados Não Confiáveis
Método de Ataque	Única requisição HTTP POST, sem necessidade de autenticação
Descoberto Por	Lachlan Davidson (pesquisador de segurança)
Divulgado	3 de dezembro de 2025
Status do Exploit	Exploit público disponível — usado ativamente por invasores
CVE Relacionado	CVE-2025-66478 (Next.js — duplicata confirmada)

---

Quem é Afetado?

Versões Vulneráveis do React```

react-server-dom-webpack — versions 19.0.0, 19.1.0, 19.1.1, 19.2.0 react-server-dom-parcel — versions 19.0.0, 19.1.0, 19.1.1, 19.2.0 react-server-dom-turbopack — versions 19.0.0, 19.1.0, 19.1.1, 19.2.0

### Frameworks Afetados

| Framework / Ferramenta     | Escopo Afetado                                     |
|----------------------------|----------------------------------------------------|
| **Next.js 15.x – 16.x**    | Apenas App Router — Pages Router **NÃO** é afetado |
| **React Router RSC**       | Apenas canal instável / preview                    |
| **Redwood SDK**            | Apenas modo RSC                                    |
| **Waku**                   | Todas as versões com RSC habilitado                |
| **Expo**                   | Apenas builds preview RSC                          |
| **Vite RSC Plugin**        | Todas as integrações                               |
| **Parcel RSC Plugin**      | Todas as integrações                               |
| **Qualquer configuração RSC personalizada** | Qualquer servidor que use desserialização RSC Flight |

> ⚠️ **Importante:** Você está vulnerável mesmo que não use Server Actions ou Server Functions explicitamente — desde que React Server Components estejam habilitados no seu aplicativo.

> ✅ **Não afetado:** Aplicativos que usam apenas o Pages Router, ou aplicativos sem React no lado do servidor.

---

## Por Que Isso É Tão Perigoso?

Três razões tornam o React2Shell excepcionalmente grave:

1. **Nenhuma autenticação necessária.** Qualquer pessoa na internet pode tentar este ataque. Sem conta, sem token, sem acesso prévio necessário.

2. **Funciona em instalações padrão.** Um novo aplicativo Next.js criado com `create-next-app` — sem nenhuma configuração personalizada — é imediatamente explorável. Os desenvolvedores não precisam fazer nada errado para estar vulneráveis.

3. **Confiabilidade de quase 100%.** Pesquisadores de segurança confirmaram que o exploit funciona quase sempre contra servidores não corrigidos.

---

## Como o Ataque Funciona?

### A Causa Raiz — Em Português Claro

Quando seu servidor React recebe dados de um cliente, ele processa (desserializa) esses dados para entender o que fazer a seguir. O problema é que o React **nunca verifica se esses dados são seguros ou legítimos** — ele confia cegamente no que chega.

Um atacante explora isso enviando dados especialmente elaborados que sequestram o comportamento interno do JavaScript no servidor, permitindo-lhes, por fim, injetar e executar seu próprio código.

### Explicação Técnica

O exploit usa uma técnica chamada **poluição de protótipo (prototype pollution)**:

1. O atacante envia uma requisição HTTP POST manipulada para qualquer endpoint RSC (nenhuma URL especial necessária).
2. O analisador (parser) do React Flight Protocol processa o payload sem validação estrutural.
3. O payload malicioso polui `Object.prototype.then` — um objeto fundamental do JavaScript do qual todos os outros objetos herdam.
4. Isso concede ao atacante acesso ao construtor `Function` do JavaScript.
5. O atacante usa o construtor `Function` para executar código arbitrário como o processo do servidor Node.js.```
Step 1 — Attacker sends crafted HTTP POST
         ↓
Step 2 — React deserializes payload blindly
         ↓
Step 3 — Object.prototype.then is hijacked (prototype pollution)
         ↓
Step 4 — Function constructor is accessed
         ↓
Step 5 — Attacker's code runs on the server
         ↓
Step 6 — Attacker has full server control

Ilustração Simplificada do Código```js

// This is a simplified version of the vulnerable code path inside React function parseFlightRequest(req) { const flight = req.body;

// ❌ NO validation — the server trusts whatever arrives
const decoded = dangerousDeserialize(flight);  // Attack happens here

// If the attacker controls decoded.action → RCE
return executeServerReference(decoded.action);

}

### Como é a Aparência do Ataque```http
POST /?flight=1 HTTP/1.1
Content-Type: text/plain

{
  "status": "resolved_model",
  "$1:__proto__:then": "node:process.mainModule.require('child_process').execSync('id > /tmp/rce')",
  "_formData.get": "$1:constructor:constructor"
}

---

A auto-detecção do cabeçalho Proxy-Authorization é suportada ao analisar a solicitação inteira. O scanner tentará detectar automaticamente e configurar um Proxy-Authorization personalizado com base na solicitação original. Para pular, use --pauth No.

Obtendo IP público via API

O teler pode ser configurado para buscar seu endereço IP público usando um serviço. Isso é útil se a máquina não tiver acesso direto à Internet, por exemplo, a opção --public-ip api. O endereço IP obtido deste serviço será usado na saída do log se as solicitações recebidas tiverem o endereço IP 127.0.0.1.

No momento, há dois provedores suportados: ipinfo e ipapi.

[!NOTE] O ipapi está usando http para sua API, enquanto o ipinfo está usando https.

Opções

Aqui estão todas as opções que você pode usar com o teler.

[[--|--//]] Teler Options [[--|--//]]

Usage of teler:
  -c, --config string
        Specify teler configuration file

  -f, --format string
        Custom log format for file output

  -i, --input string
        Analyze logs from data persistence rather than buffer stream

  -j, --json
        Display the JSON format threat on the output

  -l, --logdev string
        --logdev=unix:///var/run/teler/teler.sock
        --logdev=unixgram:///var/run/teler/teler.sock
        --logdev=unixpacket:///var/run/teler/teler.sock
        --logdev=tcp://:2222
        --logdev=udp://:2222

  -o, --output string
        Save detected threats to a file

  -x, --concurrent int
        Set the concurrent value for the log handler (default 20)