ReactOOPS - Writeup do Desafio Web HTB

Autor: TheStingR - Team ISP1337Hackers
Desafio: ReactOOPS (Web)
Plataforma: Hack The Box
Dificuldade: Muito Fácil - Aposentado
Data de Resolução: 13 de dezembro de 2025

Índice

1. Resumo Executivo
2. Descrição do Desafio
3. Análise de Vulnerabilidade
4. Reconhecimento e Enumeração
5. Passo a Passo da Exploração
6. Extração da Flag
7. Análise Técnica Detalhada
8. Defesa e Mitigação
9. Lições Aprendidas

---

Resumo Executivo

ReactOOPS é um desafio web que explora CVE-2025-55182 / CVE-2025-66478, uma vulnerabilidade crítica de Execução Remota de Código não autenticada em React Server Components e no App Router do Next.js.

Principais Descobertas:

• ✅ Servidor: Next.js 16.0.6 com React 19 (vulnerável)
• ✅ Vulnerabilidade: Verificação hasOwnProperty ausente na desserialização do protocolo Flight
• ✅ Impacto: RCE não autenticada com privilégios de root
• ✅ Exploração: Requer uma única requisição HTTP POST

---

Descrição do Desafio

Avaliação Inicial

O desafio apresenta uma aplicação Next.js refinada executando a interface de assistente da NexusAI. A aplicação parece lidar com a entrada do usuário por meio de React Server Components, mas pequenas falhas na camada reativa sugerem vulnerabilidades subjacentes.

Pilha de Tecnologia

• Framework: Next.js 16.0.6
• Versão do React: 19.x
• Implantação: Contêiner Docker (build standalone do Next.js)
• Porta do Servidor: 50183

O Que Torna Isso Vulnerável?

A aplicação usa:

1. React Server Components (RSC) - Renderização no lado do servidor com comunicação com o cliente
2. Protocolo Flight - Formato de serialização para transmissão de dados RSC
3. Dependências Vulneráveis - react-server-dom-webpack sem patches de segurança

---

Análise de Vulnerabilidade

Visão Geral da CVE-2025-55182 / CVE-2025-66478

O que é o Protocolo Flight?

O protocolo Flight é o formato de serialização proprietário do React para transmitir dados entre servidor e cliente em arquiteturas de Server Components. Ele usa referências como:

• $1 - Referência ao objeto na posição 1
• $1:path:to:value - Travessia de caminho de propriedade

A Verificação de Segurança Ausente

Código Vulnerável em ReactFlightReplyServer.js do React:

// Line ~450: getOutlinedModel function
function getOutlinedModel(response, id) {
    let chunk = chunks.get(id);
    const value = chunk.value;
    
    // Process references like "$1:path:to:value"
    if (reference.startsWith('$')) {
        const refId = parseInt(reference.slice(1).split(':')[0]);
        const path = reference.slice(1).split(':').slice(1);
        
        let obj = chunks.get(refId).value;
        
        // VULNERABLE LOOP - NO hasOwnProperty CHECK!
        for (let i = 0; i < path.length; i++) {
            obj = obj[path[i]];  // ← Allows prototype chain access
        }
        return obj;
    }
}

A Versão Segura (Como Deveria Ser):

for (let i = 0; i < path.length; i++) {
    if (Object.prototype.hasOwnProperty.call(obj, path[i])) {
        obj = obj[path[i]];
    } else {
        throw new Error('Invalid property access');
    }
}

Por Que Isso Importa

Sem a verificação de hasOwnProperty, um atacante pode percorrer:

myObject[__proto__][then] → Chunk.prototype.then
myObject[__proto__][constructor] → Function
myObject[__proto__][constructor][prototype] → function.prototype

Cadeia de Exploração

Step 1: Send reference "$1:__proto__:then"
         │
         ├─ Access myChunk[__proto__]
         └─ Then access [then] on the prototype

Step 2: Create fake Promise-like object
         │
         └─ { then: maliciousFunction }

Step 3: React calls await on this object
         │
         ├─ Invokes the .then() method
         └─ Executes attacker's function

Step 4: Arbitrary Code Execution
         │
         └─ Code runs in server context as root

Por Que Não Há Verificação de Autenticação?

A vulnerabilidade existe antes da validação do Next-Action:

Request Processing Flow:
├─ Parse multipart form data
├─ Deserialize Flight protocol  ← RCE HAPPENS HERE
│  └─ Process references and objects
│  └─ No hasOwnProperty check!
├─ Extract Next-Action header
├─ Validate action ID          ← This comes AFTER
└─ Execute action handler

Ao acionar RCE durante a desserialização, os atacantes contornam todas as verificações de segurança no nível da ação.

---

Reconhecimento e Enumeração

Passo 1: Teste de Conexão Inicial

# Test if service is responding
curl -v http://<IP>:PORT/

Esperado: Aplicação Next.js servindo HTML com RSC habilitado

Passo 2: Identificação da Tecnologia

Procure por indicadores:

• Cabeçalhos de resposta contendo prefixos next-
• HTML contendo <script type="text/x-component">
• Presença de artefatos do diretório .next
• Endpoints POST sem autenticação óbvia

Passo 3: Detecção de Vulnerabilidade

O indicador mais confiável é tentar um ataque de poluição de protótipo e observar a resposta:

# Non-destructive detection payload
# Sends: ["$1:a:a"] referencing {}
# Vulnerable: {}.a.a throws → HTTP 500 + E{"digest"
# Patched: hasOwnProperty prevents access → no crash

---

Passo a Passo da Exploração

Configuração do Ambiente

# Navigate to challenge directory
cd /Challenges/ReactOOPS

# Clone react2shell exploit framework
git clone https://github.com/freeqaz/react2shell.git

# Verify all scripts are executable
chmod +x react2shell/*.sh

Fase 1: Detecção (Prova Não Destrutiva)

Objetivo: Confirmar que o servidor está vulnerável sem causar danos

cd react2shell

# Run the detection probe
./detect.sh http://<IP>:PORT

O Que Ela Faz:

1. Cria uma requisição POST multipart com o cabeçalho Next-Action: x
2. Envia o payload: ["$1:a:a"] referenciando o objeto vazio {}
3. Em servidor vulnerável: JavaScript tenta acessar {}.a.a
4. A verificação ausente de hasOwnProperty causa uma falha
5. O servidor retorna HTTP 500 com digest de erro

Saída Esperada:

[*] React2Shell Detection Probe (CVE-2025-55182 / CVE-2025-66478)
[*] Target: http://<IP>:PORT

[*] HTTP Status: 500
[!] VULNERABLE - Server returned 500 with E{"digest" pattern

[*] Response body:
0:{\"a\":\"$@1\",\"f\":\"\",\"b\":\"s8I48LfEDhqpCdFN5-HbU\"}
1:E{\"digest\":\"346246470\"}

[!] This server is running a vulnerable version of React RSC / Next.js

Interpretação:

• HTTP 500: ✅ Falha detectada
• E{"digest" na resposta: ✅ Formato de tratamento de erros do React
• Conclusão: Servidor está VULNERÁVEL

Fase 2: Execução Remota de Código (Prova de Conceito)

Objetivo: Verificar a execução arbitrária de comandos