
NFS Underground 2 — Netzwerk-Remote-Code-Execution (zwei Heap-Overflow-RCE-Vektoren, CVSS 9.8)
Zwei Heap-Pufferüberlauf-Schwachstellen im Mehrspieler-Netzwerkcode von Need for Speed Underground 2, die Remote-Code-Execution durch angreiferkontrollierte Netzwerkpakete ermöglichen.
| Produkt | Need for Speed Underground 2 (SPEED2.EXE) |
| Version | PC (Windows) |
| Hersteller | Electronic Arts |
| Plattform | Windows x86 (32-Bit-PE) |
| Schweregrad | Kritisch (CVSS 3.1: 9.8 — AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H) |
| Angriffsvektor | Netzwerk (TCP-Schlüsselaustausch, UDP-Spielsession) |
| Auswirkung | Remote-Code-Execution — keine Benutzerinteraktion über das Beitreten zu einem Spiel hinaus |
| Datum | November 2026 |
Das Opfer startet das Spiel und tritt einer Mehrspieler-Session bei — LAN oder online. Ein bösartiger Server (RCE-1) oder ein beliebiger Peer in derselben Lobby (RCE-2) sendet ein einziges manipuliertes Paket. Das Spiel des Opfers lässt einen Heap-Puffer mit angreiferkontrollierten Daten überlaufen, korrumpiert die Funktionszeigertabelle eines benachbarten Netzwerkobjekts und führt beim nächsten Frame-Tick beliebigen Code aus. Keine Dateiübertragung, kein Laden von Spielständen, keine Benutzerinteraktion über das Verbinden hinaus.
Die Binärdatei besitzt keinerlei moderne Exploit-Mitigationsmaßnahmen:
| Mitigation | Status |
|---|---|
| ASLR | Keine — feste Image-Basis 0x00400000 |
| Stack-Cookies (/GS) | Vorhanden, aber irrelevant — der Überlauf zielt auf den Heap, nicht auf den Stack |
| DEP | Keine — /NXCOMPAT nicht gesetzt, der Heap ist ausführbar |
| Paketvalidierung | Keine — die angreiferkontrollierte Länge gelangt direkt an recv() |
| ID | Vektor | Ort | Auslöser | CVSS 3.1 |
|---|---|---|---|---|
| RCE-1 | TCP-Schlüsselaustausch | FUN_00759910 | Bösartiger Server oder MITM sendet manipulierte Handshake-Antwort | 9.8 Kritisch |
| RCE-2 | UDP-Spielsession | FUN_007510c0 | Ein beliebiger Peer in derselben Lobby sendet ein einziges übergroßes Paket | 8.1 Hoch |
Beide lassen heap-allokierte Puffer mit angreiferkontrollierten Daten überlaufen, korrumpieren die Funktionszeigertabellen (14 Einträge) benachbarter C++-Netzwerkobjekte und erreichen beliebige Codeausführung über den eigenen Vtable-Dispatch-Mechanismus des Spiels.
Attacker sends crafted packet
│
├── RCE-1: TCP key exchange, header bytes 0xFF 0xFF
│ → FUN_00759910 parses length as 32,769 bytes
│ → recv(32769) into 16,388-byte session buffer
│
└── RCE-2: UDP game session, length field 0x7FFF
→ FUN_007510c0 parses length as 32,769 bytes
→ recv(32769) into ~1,024-byte circular buffer slot
│
▼
Heap overflow (16,381 or 30,000+ bytes past buffer)
│
▼
Adjacent network object vtable overwritten
(14 function pointers: constructor, destructor, process_packet,
send, close, listen, accept, configure, stats, read_buffer, ...)
│
▼
Game dispatches through corrupted pointer on next tick
│
▼
Arbitrary code execution
Alle Netzwerk-Empfangsaufrufe laufen über FUN_0074a6d0 bei 0x74a6d0:
// Thin wrapper — passes caller's size directly to Winsock
if (param_5 == NULL)
recv(*(param_1 + 0x18), param_2, param_3, 0); // param_3 = attacker-controlled
else
recvfrom(*(param_1 + 0x18), param_2, param_3, 0, param_5, param_6);
Keine Begrenzung, keine Grenzprüfung. Welche Länge auch immer der Aufrufer aus dem Wire-Format berechnet, sie geht direkt an recv().
Der Überlauf wird über die normale Netzwerk-Update-Schleife des Spiels ausgelöst, die in jedem Frame aufgerufen wird:
Game main loop (FUN_004e6c30 / FUN_004e77a0 / FUN_004f2840)
→ FUN_00584f20 (network subsystem tick)
→ FUN_00740600 (network update)
→ FUN_0074e8e0 (packet processor)
→ FUN_00754490 (TCP state machine)
→ FUN_00759910 — RCE-1 OVERFLOW
→ vtable dispatch: CALL [peer + 0x30]
→ FUN_00751660 (read_buffer)
→ FUN_007510c0 — RCE-2 OVERFLOW
Keine Menünavigation, kein Tastendruck — die eigene Frame-Schleife des Spiels verarbeitet eingehende Pakete und löst den Überlauf aus.
Die Netzwerkobjekt-Factory FUN_00751940 allokiert 0x214 Bytes und installiert 14 Funktionszeiger:
| Offset | Eintrag | Ursprüngliches Ziel |
|---|---|---|
| +0x00 | Konstruktor | FUN_00751940 |
| +0x04 | Destruktor | FUN_00751490 |
| +0x08 | connect | LAB_00752200 |
| +0x0C | process_packet | FUN_00757900 |
| +0x10 | send | FUN_00751750 |
| +0x14 | close | FUN_00751520 |
| +0x18 | listen | LAB_00751880 |
| +0x1C | close_alias | FUN_00751520 |
| +0x20 | accept | LAB_00751500 |
| +0x24 | configure | LAB_00753ab0 |
| +0x28 | timestamp | GetTickCount |
| +0x2C | stats | FUN_00751560 |
| +0x30 | read_buffer | FUN_00751660 |
| +0x34 | write_buffer | LAB_00751700 |
Wenn der Überlauf diese Zeiger korrumpiert, leitet der eigene Dispatch-Code des Spiels (CALL [object + offset]) die Ausführung an die vom Angreifer gewählte Adresse um.
Jedes Skript belegt beide Vektoren auf einer anderen Ebene der Exploit-Kette:
| # | Skript | Vektor | Was es belegt |
|---|---|---|---|
| 1 | network_rce_proof.js | RCE-1 (TCP) | 16.381-Byte-Heap-Überlauf über die Puffergrenze hinaus |
| 2 | network_rce_proof.js | RCE-2 (UDP) | Überlauf von über 30.000 Bytes über den Ringpuffer-Slot hinaus |
| 3 | network_eip_control.js | RCE-1 (TCP) | 14/14 Vtable-Zeiger auf 0x41414141 korrumpiert |
| 4 | network_eip_control.js | RCE-2 (UDP) | 14/14 Vtable-Zeiger auf 0x41414141 korrumpiert |
| 5 | network_rce_ace.js | RCE-1 (TCP) | MessageBoxA("RCE Succeeded") über korrumpierten Vtable-Dispatch |
| 6 | network_rce_ace.js | RCE-2 (UDP) | MessageBoxA("RCE Succeeded") über korrumpierten Vtable-Dispatch |
Alle Nachweise laufen über Frida im eigenen Adressraum des Spiels. Es wird kein Netzwerkverkehr gesendet — jedes Skript allokiert Heap-Puffer, die den realen Strukturen entsprechen, repliziert die exakte Überlauf-Geometrie und verifiziert jedes korrumpierte Byte.
Detaillierte Reproduktionsschritte und erwartete Ausgaben finden sich in poc/README.md.
Was belegt ist:
0x400000)Was nicht belegt ist:
Jedes Glied der Kette ist unabhängig verifiziert. Die fehlende Grenzprüfung ist im dekompilierten Code vorhanden. Die Überlauf-Mathematik wird im eigenen Heap des Spiels demonstriert. Die Codeausführung ist live. Die Kette ist mathematisch sicher.