Windows x86 Buffer Overflow PoC für Anfänger

Dies ist ein einfaches, in sich geschlossenes Tutorial zu Stack-basierten Buffer-Overflow-Exploits für 32-Bit-Windows. Es sind keine externen Anleitungen erforderlich – alles Nötige ist hier enthalten.

Was ist dieses Repository?

• vulnerable.c: Ein einfaches Programm mit einer unsicheren gets()-Funktion.
• messageBox.asm: Ein kleine Assembly-Payload, die nach dem Überlauf ausgeführt wird.
• exploit.c: Ein Beispiel, wie der Überlauf ausgelöst werden könnte.

Dieses Projekt vermittelt eine Kernidee: Unsicheres Einlesen von Eingaben kann einem Angreifer ermöglichen, die Rücksprungadresse zu überschreiben und die Ausführung umzuleiten.

Die Schwachstelle: gets() hat keine Größenbegrenzung

In vulnerable.c macht das Programm Folgendes:

char buffer[32];
gets(buffer);

Das Programm reserviert 32 Bytes für buffer und ruft dann gets() auf, um Eingaben zu lesen. Das Problem: gets() prüft die Puffergröße nicht. Es liest so lange Zeichen, bis es einen Zeilenumbruch findet. Wenn der Benutzer 40 oder 50 Zeichen eingibt, laufen die zusätzlichen Zeichen über den 32-Byte-Puffer über.

Wie der Speicher auf dem Stack angeordnet ist

Wenn eine C-Funktion ausgeführt wird, speichert der Stack (eine Speicherregion):

1. Lokale Variablen (wie buffer)
2. Das gespeicherte EBP (Basispointer der aufrufenden Funktion)
3. Die gespeicherte Rücksprungadresse (wohin die CPU springen soll, wenn die Funktion zurückkehrt)

Stellen Sie es sich so vor:

Niedrigere Adressen (oberer Rand des Stacks in der Darstellung)
[  buffer (32 Bytes)  ]
[    saved EBP (4 Bytes)     ]
[  return address (4 Bytes)  ]
Höhere Adressen (unterer Rand)

Wenn gets() den buffer mit zu vielen Eingaben überläuft, überschreiben die zusätzlichen Bytes das gespeicherte EBP und dann die Rücksprungadresse.

Wenn wir den Überlauf sorgfältig so konstruieren, dass eine bestimmte Adresse in das Feld der Rücksprungadresse gesetzt wird, springt die CPU zu dieser Adresse, wenn die Funktion versucht zurückzukehren.

Wie der Exploit funktioniert: Schritt für Schritt

1. Das Programm startet und reserviert buffer[32] auf dem Stack.
2. Es ruft gets(buffer) auf, um eine Zeile Benutzereingabe zu lesen.
3. Wir senden eine Zeichenkette, die länger als 32 Bytes ist (sagen wir 50 Bytes).
4. gets() hat keine Größenprüfung, daher schreibt es alle 50 Bytes in den Puffer.
5. Die zusätzlichen 18 Bytes laufen über den buffer hinaus und überschreiben das gespeicherte EBP und die Rücksprungadresse.
6. Wir konstruieren den Überlauf sorgfältig so, dass die Rücksprungadresse auf den Shellcode auf dem Stack zeigt.
7. Wenn die Funktion zurückkehrt, liest die CPU die überschriebene Rücksprungadresse.
8. Die CPU springt zum Shellcode.
9. Der Shellcode wird mit den Berechtigungen des Programms ausgeführt.

Dies ist die einfachste Form der Codeausführung durch einen Pufferüberlauf.

Was im Shellcode passiert: Die Payload

messageBox.asm ist ein kleines Stück Code, das nach dem Überlauf ausgeführt werden soll.

Es macht Folgendes:

1. USER32.DLL laden: Ruft LoadLibraryA mit dem String "USER32.DLL" auf, um sicherzustellen, dass die Bibliothek im Speicher ist.
2. Argumente für MessageBoxA vorbereiten: Schiebt vier Argumente auf den Stack (Fensterhandle, Nachrichtentext, Beschriftung, Schaltflächentyp).
3. MessageBoxA aufrufen: Ruft die Windows-API-Funktion auf, um ein Meldungsfenster mit dem Text "CAN I HACK THE PC?" anzuzeigen.
4. Sauber beenden: Ruft ExitProcess auf, um das Programm sicher zu beenden.

Der entscheidende Punkt: Dies ist ausführbarer Code, der ausgeführt wird, nachdem der Überlauf die Ausführung darauf umgeleitet hat. Wenn das Meldungsfenster auf dem Bildschirm erscheint, beweist es drei Dinge:

1. Der Pufferüberlauf hat funktioniert und die Rücksprungadresse überschrieben.
2. Die Ausführung ist zum Shellcode auf dem Stack gesprungen.
3. Der Shellcode wurde erfolgreich ausgeführt und hat Windows-API-Aufrufe getätigt.

In einem echten Angriff könnte diese Payload alles tun: Daten stehlen, einen Benutzer anlegen, Malware herunterladen usw. Das Meldungsfenster ist nur eine sichtbare, sichere Möglichkeit zu demonstrieren, dass beliebige Codeausführung stattgefunden hat.

Diese spezielle Payload verwendet fest codierte Speicheradressen für MessageBoxA (0x751D8830) und ExitProcess (0x7437ADB0). Diese Adressen sind spezifisch für ein System. Die Payload müsste für eine andere Windows-Version oder ein anderes System angepasst werden.

So bauen und führen Sie die Demo aus

Schritt 1: Schutzmaßnahmen deaktivieren

Moderne Windows-Versionen haben mehrere Sicherheitsfunktionen, die diesen Exploit verhindern:

• Stack Canaries (GS-Flag): Erkennt Stack-Überschreibungen.
• ASLR (DYNAMICBASE): Randomisiert Speicheradressen, sodass fest codierte Adressen nicht funktionieren.
• DEP/NX (NXCOMPAT): Markiert den Stack als nicht ausführbar, um Codeausführung dort zu verhindern.

Für dieses Lernbeispiel deaktivieren wir alle.

Schritt 2: Unter Windows kompilieren

Verwenden Sie MSVC (Microsoft Visual C++) mit bestimmten Flags:

cl /c /GS- /W3 /Zl vulnerable.c
link /SUBSYSTEM:CONSOLE /DYNAMICBASE:NO /NXCOMPAT:NO vulnerable.obj /OUT:vulnerable.exe

Bedeutung der Flags:

• /GS- deaktiviert den Pufferüberlaufschutz des Stacks.
• /DYNAMICBASE:NO deaktiviert die Address Space Layout Randomization (ASLR).
• /NXCOMPAT:NO deaktiviert DEP und erlaubt die Ausführung von Code auf dem Stack.

Wenn Sie die ausführbare Datei bereits haben, können Sie die Schutzmaßnahmen mit editbin deaktivieren:

editbin /NXCOMPAT:NO /DYNAMICBASE:NO vulnerable.exe

Schritt 3: Ausführen

1. Starten Sie vulnerable.exe.
2. Geben Sie bei der Eingabeaufforderung eine lange Zeichenkette ein (mehr als 32 Zeichen).
3. Wenn der Überlauf funktioniert, wird die gespeicherte Rücksprungadresse überschrieben.
4. Das Programm kann abstürzen, zu einer zufälligen Speicheradresse springen oder (bei einem echten Exploit mit geeignetem Shellcode) die Payload ausführen.

Warum die README vollständig ist

Diese README erklärt:

1. Was gets() ist und warum es unsicher ist (keine Größenbegrenzung).
2. Wie der Stack lokale Variablen, gespeicherte Register und Rücksprungadressen speichert.
3. Wie ein Überlauf die Rücksprungadresse überschreiben kann.
4. Wie die CPU die Rücksprungadresse verwendet, wenn eine Funktion zurückkehrt.
5. Wie Shellcode ausgeführt werden kann, wenn die Rücksprungadresse darauf zeigt.
6. Welche Schutzmaßnahmen es gibt und warum wir sie deaktivieren.
7. Wie das Beispiel gebaut und ausgeführt wird.

Sie verstehen jetzt den gesamten Ablauf eines Buffer-Overflow-Exploits. Lesen Sie die Codedateien und vergleichen Sie sie mit dieser Erklärung, um Ihr Verständnis zu festigen.

Wichtiger Sicherheitshinweis

Dieses Beispiel dient nur zu Lernzwecken. Verwenden Sie diese Technik nicht gegen Systeme, die Ihnen nicht gehören oder für deren Test Sie keine ausdrückliche Erlaubnis haben. Unbefugter Zugriff auf Computersysteme ist illegal.