Buffer Overflow: Die unsichtbare Gefahr in 6 Bytes

Kurzbeschreibung

Dieses Lehrbeispiel zeigt, wie ein unsicherer Kopiervorgang in C bei einem 6-Byte-Puffer zu einem Stack-Buffer-Overflow und damit zu einem Absturz führen kann. Nur Analyse/Lehre in einer isolierten VM. Kein Exploit.

Voraussetzungen

Debian/Ubuntu oder eine ähnliche Linux-Distribution mit gcc, gdb und python3.

Beispielcode (kopierbar)

cat overflow_minimal.c

 /* overflow_minimal.c - Buffer Overflow Demonstration */
 #include <stdio.h>
 #include <string.h>

 void func(char *input)
 {
     char buffer[6];   // Nur 6 Bytes Puffer (einschließlich NUL)
     strcpy(buffer, input);  // Absichtlich unsicher: keine Längenprüfung
     printf("Du hast eingegeben: %s\n", buffer);
 }

 int main(int argc, char *argv[])
 {
     if (argc < 2) {
         printf("Usage: %s <input>\n", argv[0]);
         return 1;
     }
     func(argv[1]);
     return 0;
 }

Kompilieren

Stack-Protector deaktiviert, Debug-Symbole aktiv:

 gcc -fno-stack-protector -z execstack -g -o overflow_minimal overflow_minimal.c

Analyse mit AddressSanitizer:

 gcc -g -fsanitize=address -fno-omit-frame-pointer -o overflow_minimal_asan overflow_minimal.c

Testen

Normale Eingabe (≤ 6 Zeichen):

 ./overflow_minimal ABCDEF
 # Ausgabe: Du hast eingegeben: ABCDEF

Kurze Überschreitung (7 Zeichen):

 ./overflow_minimal ABCDEFG

Zuverlässiger Crash (lange Eingabe):

 ./overflow_minimal "$(python3 -c 'print(\"A\"*200)')"

Beobachtbares Verhalten

Kurze Überläufe überschreiben zunächst nur lokale Daten; der Absturz kann verzögert auftreten.
Lange Eingaben überschreiben meist die Rücksprungadresse und führen zu SIGSEGV.
Mit ASAN-Kompilation erhältst du eine klare Meldung („stack-buffer-overflow“) mit Backtrace.

Analyse mit GDB

Beispiel:

 gdb --args ./overflow_minimal "$(python3 -c 'print(\"A\"*200)')"
 # in gdb: run
 # nach Crash: bt
 # nützliche Befehle: bt, info registers, x/32x $rsp, disas

Trainer-Hinweis: Stack-Layout (saved RBP, return address, lokale Variablen) erläutern.

Sicherer Fix (Kontrast)

 void func_safe(char *input)
 {
     char buffer[6];
     snprintf(buffer, sizeof buffer, "%s", input);
     printf("Du hast eingegeben: %s\n", buffer);
 }

Fazit

Schon minimale Programmierfehler können massive Sicherheits- oder Stabilitätsprobleme verursachen.
Sorgfalt bei Puffergrößen, Eingabevalidierung und das Nutzen moderner Schutzmechanismen sind Pflicht in der sicheren Softwareentwicklung.

Overflow minimal

Inhaltsverzeichnis