React2Shell (CVE-2025-55182): O RCE Crítico Que Está Transformando React e Next.js em Playground de Hackers
React2Shell é um RCE pré-autenticação CVSS 10.0 em React Server Components e Next.js. Saiba o que é, quem é afetado e como corrigir antes que atacantes...
✨TL;DR / Sumário Executivo
React2Shell é um RCE pré-autenticação CVSS 10.0 em React Server Components e Next.js. Saiba o que é, quem é afetado e como corrigir antes que atacantes...
💡 TL;DR (Resumo Executivo)
React2Shell (CVE-2025-55182) é um RCE pré-autenticação CVSS 10.0 em React Server Components e Next.js. Uma única requisição HTTP pode dar aos atacantes acesso total ao servidor. Configurações padrão são vulneráveis. Exploits estão circulando. Se você usa RSC ou Next.js, pare tudo e aplique o patch agora. Isso não é um exercício.
1. O Gancho: Por Que Isso Importa Agora
Nas últimas 24 horas, canais de segurança e infraestrutura de São Francisco a Bangalore se acenderam com um único tópico:
React2Shell (CVE-2025-55182) — uma vulnerabilidade de execução remota de código (RCE) pré-autenticação que expõe dezenas de milhares de aplicações em produção a controle total do servidor com uma única requisição HTTP.
Isso não é apenas mais um CVE assustador para seu backlog. Este é o tipo de bug que atinge todos os nervos de uma vez:
- Configurações padrão são afetadas.
- Frameworks populares (Next.js, stacks habilitados para RSC) são impactados.
- Exploits são confiáveis e já estão circulando na natureza.
- Telemetria em nuvem mostra centenas de milhares de instâncias expostas mundialmente.
Wiz reporta React/Next.js vulneráveis em ~39% dos ambientes em nuvem, e Unit 42 tem visibilidade de ~968k instâncias React/Next.js na internet pública.
Para quem viveu o Log4Shell, isso parece desconfortavelmente familiar. Mas desta vez, não é sobre uma biblioteca de logging escondida em microsserviços Java. É sobre a stack front-end que alimenta uma enorme fração da web moderna.
2. O Que React2Shell Realmente É (Em Português Claro)
React2Shell tem como alvo o protocolo "Flight" dos React Server Components—o protocolo binário que o React usa para comunicação entre cliente e servidor para RSC. Nas versões afetadas:
- O servidor confia e deserializa payloads RSC controlados pelo atacante de forma insegura.
- Uma única requisição HTTP crafted pode disparar execução de código arbitrário no servidor.
- Nenhuma autenticação é necessária.
- O ataque tem confiabilidade próxima a 100% em testes segundo a Wiz.
Como o Next.js implementa RSC e o protocolo Flight, ele herda o mesmo bug. Uma aplicação Next.js padrão criada com create-next-app e implantada com configurações padrão pode ser explorável sem nenhuma mudança de código customizado se estiver usando versões afetadas.
O advisory oficial do React confirma a classificação CVSS 10.0.
Detalhes Chave do CVE
| ID do CVE | Descrição | Status |
|---|---|---|
| CVE-2025-55182 | RCE core do React RSC / protocolo Flight | Primário |
| CVE-2025-66478 | Inicialmente atribuído para Next.js, depois mesclado como duplicata | Mesclado |
O nome popular "React2Shell" vem de pesquisadores que imediatamente reconheceram a severidade no nível do Log4Shell.
3. Por Que Isso Explodiu em 24 Horas
O advisory técnico foi publicado dias atrás, mas três fatores convergentes empurraram o React2Shell para território de "primeira página em todo Slack de tech":
3.1. PoCs Públicas e Exploração Ativa
Os primeiros write-ups foram cautelosos sobre detalhes, mas Wiz, Invicti e Unit 42 agora confirmam:
- Exploits RCE totalmente funcionais existem
- Código proof-of-concept público está circulando
- Scanning oportunista e exploração estão a todo vapor
3.2. Superfície de Ataque Massivamente Exposta
- React está em todo lugar; Next.js é o meta-framework React de facto.
- RSC está habilitado por padrão em setups modernos do app router do Next.js.
- Você pode estar vulnerável mesmo que nunca tenha conscientemente optado por recursos RSC sofisticados.
3.3. Telemetria em Escala de Nuvem Pareceu… Ruim
- Dados da Wiz: stacks React/Next.js vulneráveis em quase 4 de cada 10 ambientes em nuvem, com uma grande parcela voltada para a internet.
- Unit 42 vê quase um milhão de instâncias React/Next.js expostas na internet pública.
Times de segurança viram a combinação de popular + habilitado por padrão + RCE pré-auth + PoC + exploração e imediatamente entraram em modo "todas as mãos".
4. Como o Exploit Funciona (Deep Dive Técnico)
Em nível conceitual, React2Shell é um caso clássico de deserialização insegura em um protocolo customizado:
4.1. O Protocolo Flight
RSC usa o protocolo Flight para serializar árvores de componentes e server actions através da rede. É um formato híbrido binário/texto que:
- Codifica referências de componentes React
- Serializa props e state
- Lida com invocações de server actions
4.2. O Vetor de Ataque
4.3. Por Que É Tão Perigoso
- Pré-Auth: Nenhum login necessário. Endpoints públicos são exploráveis.
- Nível de Protocolo: O bug vive abaixo da sua lógica de aplicação. O atacante não se importa com o que seu código de negócio faz.
- Confiável: Taxa de sucesso próxima a 100% significa que exploração automatizada é trivial.
- Difundido: Setups padrão do Next.js com router
app/estão no escopo.
A análise da Invicti o descreve como um "RCE de uma requisição": pré-auth, sem interação do usuário, sem má configuração necessária além de rodar versões vulneráveis.
5. Quem É Afetado: O Raio de Impacto Completo
Do advisory oficial do React e write-ups de vendors, os componentes vulneráveis são:
5.1. Pacotes React Vulneráveis
Os seguintes pacotes na linha 19.x RSC / Flight são afetados:
| Pacote | Versões Vulneráveis | Versões Corrigidas |
|---|---|---|
react-server-dom-webpack | 19.0, 19.1.0, 19.1.1, 19.2.0 | 19.0.1, 19.1.2, 19.2.1+ |
react-server-dom-parcel | 19.0, 19.1.0, 19.1.1, 19.2.0 | 19.0.1, 19.1.2, 19.2.1+ |
react-server-dom-turbopack | 19.0, 19.1.0, 19.1.1, 19.2.0 | 19.0.1, 19.1.2, 19.2.1+ |
Fonte: Advisory do React
5.2. Frameworks e Ferramentas Vulneráveis
Qualquer framework ou bundler que embute ou depende de pacotes RSC afetados está no escopo:
- Next.js (App Router) — Ranges específicos de 15.x / 16.x e certas builds canary
- React Router RSC preview
- Redwood SDK
- Waku
- Plugin RSC do Vite (
@vitejs/plugin-rsc) - Plugin RSC do Parcel (
@parcel/rsc)
Microsoft e Unit 42 ambos fornecem ranges de versões afetadas explícitos e orientação de mitigação.
5.3. Quem NÃO É Afetado
Se você está em React puro lado cliente (SPA sem react-server-dom-* em nenhum lugar), você não é impactado por este bug específico. Mas muitas organizações usam frameworks que puxam esses pacotes de servidor indiretamente, e é por isso que ferramentas SBOM e visibilidade de dependências de repente importam muito.
6. O Que Atacantes Estão Realmente Fazendo Com React2Shell
A parte assustadora não é apenas que este exploit existe; é que múltiplos times de threat intel já estão observando ele sendo usado em escala.
6.1. Observações da Wiz
Wiz reporta:
- Confiabilidade próxima a 100% em seus testes de RCE
- Campanhas observadas colhendo credenciais de nuvem
- Cryptominers instalados (ex: XMRig)
- Shells usados para explorar máquinas comprometidas
6.2. Telemetria da Microsoft
Microsoft vê:
- Centenas de dispositivos comprometidos em organizações reais
- Payloads de pós-exploração incluindo reverse shells, RATs, e scripts de roubo de credenciais
- Alvo de endpoints de metadados de nuvem (AWS, Azure, GCP, Tencent) para roubo de tokens
6.3. Inteligência da Unit 42
Unit 42 viu:
- Atividade tipo Cobalt Strike
- Backdoors Linux customizados (ex: KSwapDoor)
- Campanhas de cryptomining
- Operações estilo IAB (initial access broker)
- Uma mistura de exploração oportunística e campanhas mais direcionadas
Isso não é um bug teórico "poderia ser ruim se alguém descobrir". Neste ponto, o ecossistema ofensivo tem o React2Shell totalmente integrado.
7. O Que Você Deve Fazer Agora Mesmo
Em linguagem de DevRel, aqui está o TL;DR: Trate React2Shell como um incidente ativo até que você tenha provado que está limpo e com patch aplicado.
7.1. Identifique Se Você É Afetado
Você precisa de inventário real, não intuição.
Pesquise dependências:
# Verifique pacotes vulneráveis
npm ls react-server-dom-webpack react-server-dom-parcel react-server-dom-turbopack
# Verifique versão do Next.js
npm ls next
# Para monorepos, escaneie todos os pacotes
npx lerna ls --all --long 2>/dev/null || npm ls --all | grep -E "react-server-dom|next@"Compare versões contra os ranges oficiais de:
Se você tem aplicações Next.js voltadas para a internet rodando versões vulneráveis, assuma que são alvos de alto risco imediatamente.
7.2. Aplique o Patch. Não Espere "O Próximo Sprint."
# Atualize pacotes React RSC
npm update react-server-dom-webpack react-server-dom-parcel react-server-dom-turbopack
# Atualize Next.js
npm update next
# Verifique versões
npm ls react-server-dom-webpack nextNúmeros exatos de versão podem evoluir, mas segundo os advisories:
- Atualize pacotes RSC para versões 19.x corrigidas (
19.0.1,19.1.2,19.2.1ou posterior) - Atualize Next.js para versões corrigidas na sua linha principal
Depois:
- Reconstrua suas imagens/artefatos de aplicação
- Reimplante todos os ambientes afetados (staging, prod, ambientes "temporários" de longa duração)
Proteções WAF de provedores de nuvem (Cloudflare, etc.) ajudam mas não são suficientes. Todo write-up sério chama explicitamente o patch como a única correção confiável.
7.3. Procure Sinais de Comprometimento
Porque a exploração já está acontecendo, seu trabalho não é apenas "patch and pray." É também resposta a incidentes:
Revise logs para:
- POSTs suspeitos para endpoints RSC/server action
- Comandos tipo shell vindos de processos
nodeounext-server
Procure por:
- Processos inesperados gerados por
node/next - Conexões de saída para ranges C2 conhecidos
- Cryptominers, ferramentas como
TruffleHog,Gitleaks - Scripts enumerando variáveis de ambiente e endpoints de metadados
Indicadores de Comprometimento (IOCs):
# Verifique processos suspeitos
ps aux | grep -E "(xmrig|miner|nc |/bin/sh|/bin/bash.*-i)"
# Verifique conexões de rede incomuns
netstat -an | grep ESTABLISHED | grep -v "127.0.0.1\|::1"
# Verifique processo Node.js para processos filhos suspeitos
pstree -p $(pgrep -f "next-server")Se você ver algo suspeito:
- Trate aquele node/container como comprometido
- Rotacione secrets e tokens imediatamente
- Siga seu playbook completo de IR
7.4. Use WAF / Controles de Rede como Escudo Temporário
Enquanto você aplica patches:
- Habilite quaisquer regras WAF específicas para React2Shell / RSC fornecidas pelo vendor
- Adicione rate limits temporários e detecção de anomalias em endpoints críticos
- Monitore picos em respostas 4xx/5xx em rotas RSC
Modelo mental: WAF == cinto de segurança, patch == pedal de freio. Você ainda precisa de freios.
8. O Quadro Maior: Front-End Agora É Back-End
A mensagem mais alta do React2Shell não é "React é inseguro." É que frameworks front-end modernos agora são frameworks back-end, e ainda estamos adaptando nossos modelos mentais.
O Mundo Antigo
- React era "só front-end"
- Segurança significava XSS, CSRF, CSP, etc.
- Bugs de servidor viviam em Java, Python, Go
O Novo Mundo
- React Server Components + meta-frameworks borram a linha entre cliente e servidor
- A stack "front-end" agora inclui runtimes de servidor, protocolos customizados (como Flight), e pipelines de renderização distribuída
- Um bug em um framework de UI pode se comportar como um bug em um framework de servidor core, com raio de impacto RCE completo
React2Shell é um exemplo clássico: uma falha em nível de protocolo em como server components deserializam dados leva a acesso shell direto nos servidores.
A Lição para Líderes de Engenharia
Se sua stack front-end está alimentando lógica de servidor, seu modelo de AppSec tem que tratá-la como infraestrutura crítica—porque atacantes já tratam.
Isso significa:
- SBOM e visibilidade de dependências agora são requisitos P0
- Times de front-end precisam de treinamento de segurança além de XSS
- Playbooks de resposta a incidentes devem cobrir servidores Node.js/Next.js
- Regras de WAF precisam entender padrões de tráfego RSC
9. Recursos e Leitura Adicional
Advisories Oficiais
Referência Rápida
| Item | Valor |
|---|---|
| CVE | CVE-2025-55182 |
| Score CVSS | 10.0 (Crítico) |
| Vetor de Ataque | Rede (Remoto) |
| Auth Necessária | Nenhuma |
| Interação do Usuário | Nenhuma |
| Impacto | Controle Total do Servidor |
10. Conclusão: Aja Agora, Pergunte Depois
React2Shell é o tipo de vulnerabilidade que separa organizações maduras em segurança do resto. Os fatos são claros:
- CVSS 10.0: Severidade máxima
- RCE pré-auth: Nenhum login necessário
- Configs padrão afetadas: A maioria das aplicações Next.js usando RSC
- Exploração ativa: Acontecendo agora mesmo
- Alta confiabilidade: Taxa de sucesso próxima a 100%
Suas ações:
- ✅ Audite suas dependências — Verifique pacotes vulneráveis
- ✅ Aplique patch imediatamente — Não espere o próximo sprint
- ✅ Procure comprometimento — Revise logs e processos
- ✅ Atualize seu modelo mental — Front-end agora é superfície de ataque
A comunidade de segurança fez seu trabalho ao divulgar e documentar esta vulnerabilidade. Agora cabe aos times de engenharia responder com urgência.
"No mundo antigo, front-end era uma reflexão tardia em auditorias de segurança. React2Shell é o alerta que muda tudo."
— O Time de Segurança gsstk
Fique seguro. Envie patches. Rotacione secrets.
Publicado: 27 de Janeiro de 2026