Overflow minimal - Versionsgeschichte

Thomas.will: /* Beispielcode (kopierbar) */

2025-11-03T20:22:04Z

Beispielcode (kopierbar)

Thomas.will am 3. November 2025 um 20:21 Uhr

2025-11-03T20:21:55Z

Thomas.will am 3. November 2025 um 20:17 Uhr

2025-11-03T20:17:30Z

Thomas.will: /* Analyse mit GDB */

2025-11-03T20:06:44Z

Analyse mit GDB

Thomas.will: /* Beobachtbares Verhalten */

2025-11-03T20:06:09Z

Beobachtbares Verhalten

Thomas.will: /* Testen */

2025-11-03T20:05:35Z

Testen

Thomas.will: /* Kompilieren */

2025-11-03T20:04:00Z

Kompilieren

Thomas.will: /* Beispielcode (kopierbar) */

2025-11-03T20:03:42Z

Beispielcode (kopierbar)

Thomas.will: /* Kurzbeschreibung */

2025-11-03T20:03:29Z

Kurzbeschreibung

Thomas.will: /* Voraussetzungen */

2025-11-03T20:03:20Z

Voraussetzungen

@@ Zeile 11: / Zeile 11: @@
    #include <stdio.h>
    #include <string.h>
-−
    void func(char *input)
+   {

@@ Zeile 31: / Zeile 31: @@
 == Kompilieren ==
 Stack-Protector deaktiviert, Debug-Symbole aktiv:
-*gcc -fno-stack-protector -z execstack -g -o overflow_minimal overflow_minimal.c
+* 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
+* gcc -g -fsanitize=address -fno-omit-frame-pointer -o overflow_minimal_asan overflow_minimal.c
 == Testen ==
 Normale Eingabe (≤ 6 Zeichen):
-*./overflow_minimal ABCDEF
+* ./overflow_minimal ABCDEF
   Ausgabe: Du hast eingegeben: ABCDEF
-*echo $?
+* echo $?
 Kurze Überschreitung (7 Zeichen):
-*./overflow_minimal ABCDEFG
+* ./overflow_minimal ABCDEFG
   Du hast eingegeben: ABCDEFG
   Segmentation fault
-*echo $?
+* echo $?
 == Analyse mit GDB ==
 Das GNU Debugger (gdb) ist ein Werkzeug, um den Programmablauf zu verstehen und Fehler (wie hier durch Buffer Overflow) gezielt zu untersuchen.
-Alle folgenden Schritte dienen der **Analyse**, nicht der Ausnutzung.
+Alle folgenden Schritte dienen der Analyse, nicht der Ausnutzung.
-*gdb --args ./overflow_minimal "$(python3 -c 'print("A"*200)')"
+* gdb --args ./overflow_minimal "$(python3 -c 'print("A"*200)')"
    # Startet gdb mit dem Programm und einem 200-Byte-String als Argument.
-   # (gdb) run    → Programm starten
+* run
-   # (gdb) bt     → Backtrace anzeigen (zeigt Aufrufkette zum Absturz)
+   # Programm starten
-   # (gdb) info registers → Registerstatus (RIP, RSP, RBP usw.)
+* bt
-   # (gdb) frame 0 → In das aktuelle Stackframe wechseln
+   # Backtrace anzeigen (zeigt Aufrufkette zum Absturz)
-   # (gdb) info locals → Lokale Variablen (z. B. buffer) anzeigen
+* info registers
-  # (gdb) x/64bx $rsp → 64 Bytes Speicher ab Stackpointer anzeigen (in hex)
+   # Registerstatus (RIP, RSP, RBP usw.)
-  # (gdb) x/s $rsp → Speicher als String anzeigen
+* frame 0
-   # (gdb) disassemble func → Assemblercode der Funktion anzeigen
+   # In das aktuelle Stackframe wechseln
 === Erklärung der wichtigsten GDB-Befehle ===
-* **run**
+* run
-   Startet das Programm unter gdb-Kontrolle. Wenn ein Absturz (Segmentation fault) auftritt, stoppt gdb an der Absturzstelle.
+   Startet das Programm unter gdb-Kontrolle. Stoppt bei Absturz (Segmentation fault).
-* **bt / backtrace**
+* bt
    Zeigt die komplette Aufrufkette vom main() über func() bis zur Absturzstelle.
-* **info registers**
+* info registers
-   Zeigt CPU-Register an, z. B.:
+   Zeigt CPU-Register an, z. B. rip (Instruktionszeiger), rbp/rsp (Stackpointer). Überprüfen, ob der Overflow Rücksprungadressen überschrieben hat.
-* **x/64bx $rsp**
+* x/64bx $rsp
-   Dump des Stackinhalts (64 Bytes, Byteweise, hex).
+   Dump des Stackinhalts (64 Bytes, Byteweise). Praktisch, um zu sehen, wie der Eingabestring den Stack überschreibt.
-* **x/s $rsp**
+* x/s $rsp
-   Zeigt Speicher als String an. Bei Overflows erkennt man hier oft endlose „A“-Zeichen.
+   Speicher als String anzeigen. Hier erkennt man oft endlose "A"-Zeichen bei Overflow.
-* **info frame**
+* info frame
-   Zeigt, wie groß das aktuelle Stackframe ist, welche Adresse die Rücksprungadresse enthält und wo lokale Variablen liegen.
+   Zeigt Stackframe-Größe, Rücksprungadresse und Lage der lokalen Variablen.
-* **disassemble func**
+* disassemble func
-   Zeigt die CPU-Instruktionen der Funktion `func`.
+   Zeigt CPU-Instruktionen der Funktion func. Hilfreich, um den Absturzpunkt zu lokalisieren.
-* **break func / step / next**
+* break func
-   Mit `break func` setzt du einen Breakpoint, um den Ablauf zu stoppen, bevor die gefährliche Stelle ausgeführt wird.
+   Setzt einen Breakpoint vor der gefährlichen Stelle.
-* **info locals / info args**
+* next / step / finish
-   Zeigt lokale Variablen (z. B. `buffer`) und Funktionsargumente an.
+   next: nächste Zeile ausführen, step: Funktionsaufruf betreten, finish: Funktion bis Ende ausführen.
-* **print buffer**
+* info locals / info args
-   Gibt den Inhalt von Variablen aus (wenn Debug-Symbole vorhanden).
+   Zeigt lokale Variablen und Funktionsargumente an, z. B. den Inhalt von buffer.
-* **x/32x $rbp-0x20**
+* print buffer
-   Zeigt den Stackbereich unterhalb des Framepointers, wo der lokale Puffer liegt.
+  Inhalt von Variablen anzeigen.
-  So erkennt man visuell, wie viele Bytes überschrieben wurden.
 === Beispielanalyse ===
-*gdb --args ./overflow_minimal "$(python3 -c 'print("A"*40)')"
+* gdb --args ./overflow_minimal "$(python3 -c 'print("A"*40)')"
-  (gdb) run
+* run
    Program received signal SIGSEGV, Segmentation fault.
-  (gdb) bt
+* bt
     #0  func (input=0x7fffffffde80 "AAAAAAAAAAAA...") at overflow_minimal.c:9
     #1  0x00005555555551a2 in main (argc=2, argv=0x7fffffffe2d8) at overflow_minimal.c:18
-  (gdb) info registers
+* info registers
     rip = 0x4141414141414141  ← Rücksprungadresse durch "AAAA" überschrieben
-  (gdb) x/32bx $rsp
+* x/32bx $rsp
 x7fffffffdc80: 0x41 0x41 0x41 0x41 ...
    → Der Stack wurde mit 0x41 (ASCII 'A') gefüllt – typisches Overflow-Symptom.
 === Weitere nützliche Befehle ===
-  *x/200bc $rsp       → zeigt 200 Bytes als char
+* x/200bc $rsp       → zeigt 200 Bytes als char
-  *x/10i $rip         → zeigt 10 Instruktionen ab aktueller Codeadresse
+* x/10i $rip         → zeigt 10 Instruktionen ab aktueller Codeadresse
-  *info proc mappings → zeigt Speicherbereiche (Text, Stack, Heap)
+* info proc mappings → zeigt Speicherbereiche (Text, Stack, Heap)
-  *quit               → gdb beenden
+* quit               → gdb beenden
 == Sicherer Fix (Kontrast) ==

@@ Zeile 49: / Zeile 49: @@
 == Analyse mit GDB ==
-Beispiel:
+Das GNU Debugger (gdb) ist ein Werkzeug, um den Programmablauf zu verstehen und Fehler (wie hier durch Buffer Overflow) gezielt zu untersuchen.
-*gdb --args ./overflow_minimal "$(python3 -c 'print(\"A\"*200)')"
+Alle folgenden Schritte dienen der **Analyse**, nicht der Ausnutzung.
-   # in gdb: run
-   # nach Crash: bt
+*gdb --args ./overflow_minimal "$(python3 -c 'print("A"*200)')"
-   # nützliche Befehle: bt, info registers, x/32x $rsp, disas
+   # Startet gdb mit dem Programm und einem 200-Byte-String als Argument.
 == Sicherer Fix (Kontrast) ==
@@ Zeile 66: / Zeile 145: @@
 * 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.

@@ Zeile 49: / Zeile 49: @@
 == Analyse mit GDB ==
-* Beispiel:
+Beispiel:
-  gdb --args ./overflow_minimal "$(python3 -c 'print(\"A\"*200)')"
+*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
 == Sicherer Fix (Kontrast) ==

← Nächstältere Version		Version vom 3. November 2025, 20:06 Uhr
Zeile 47:		Zeile 47:
	*echo $?		*echo $?
	139		139
−
−	~~== 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 ==		== Analyse mit GDB ==

@@ Zeile 7: / Zeile 7: @@
 == Beispielcode (kopierbar) ==
-* Datei: overflow_minimal.c
+*cat overflow_minimal.c
    /* overflow_minimal.c - Buffer Overflow Demonstration */
    #include <stdio.h>

@@ Zeile 1: / Zeile 1: @@
 = 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.
+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=

@@ Zeile 4: / Zeile 4: @@
 =Voraussetzungen=
-* Debian/Ubuntu oder eine ähnliche Linux-Distribution mit gcc, gdb und python3.
+Debian/Ubuntu oder eine ähnliche Linux-Distribution mit gcc, gdb und python3.
 == Beispielcode (kopierbar) ==