Stack-basierter Buffer Overflow

Beschreibung

Stack-basierter Buffer Overflow ist eine Variante des Buffer Overflow, die auftritt, wenn ein auf dem Stack allokierter Puffer mit Daten überschrieben wird, die größer als seine zugewiesene Größe sind. Der Stack speichert lokale Variablen, Funktionsparameter und Rücksprungadressen. Wenn ein Stack-Puffer überläuft, kann er angrenzende Stack-Daten einschließlich gespeicherter Rücksprungadressen und Frame-Pointer überschreiben. Dies ermöglicht Angreifern, die Programmausführung zu kapern, indem sie die Rücksprungadresse auf angreifergesteuerten Code oder ROP-Gadgets umleiten. Stack-Overflows sind besonders gefährlich, weil die vorhersagbare Struktur des Stacks die Ausnutzung zuverlässiger macht als Heap-basierte Angriffe.

Risiko

Stack-basierte Buffer Overflows gehören zu den am besten ausnutzbaren Schwachstellentypen. Die LIFO-Struktur (Last In, First Out) des Stacks bedeutet, dass Rücksprungadressen vorhersagbar relativ zu lokalen Puffern gespeichert werden. Angreifer können Overflow-Abstände präzise berechnen, um Rücksprungadressen mit Adressen von eingeschleustem Shellcode oder ROP-Chains zu überschreiben. Während moderne Schutzmaßnahmen (ASLR, Stack-Canaries, DEP) die Ausnutzung erschweren, existieren Umgehungen und vielen Systemen fehlt vollständiger Schutz. Embedded-Systeme, Legacy-Anwendungen und Kernel-Code bleiben hochgradig anfällig. Erfolgreiche Ausnutzung gewährt beliebige Code-Ausführung mit den Privilegien des Prozesses.

Lösung

Verwenden Sie sichere String- und Speicherhandling-Funktionen mit expliziten Größenparametern. Aktivieren Sie Compiler-Schutzmaßnahmen: Stack-Canaries (-fstack-protector-all), ASLR, DEP/NX und CFI. Verwenden Sie speichersichere Sprachen (Rust, Go) oder C++-Container für neue Entwicklung. Setzen Sie statische Analyse (Coverity, CodeQL) und dynamische Analyse (ASan, Fuzzing) während der Entwicklung ein. Validieren Sie alle Eingabegrößen vor Pufferoperationen. Erwägen Sie die Verwendung von Compiler-Hardening-Flags: -D_FORTIFY_SOURCE=2, -fPIE, -Wl,-z,relro,-z,now. Für Legacy-Code prüfen Sie alle Verwendungen gefährlicher Funktionen wie strcpy, gets, sprintf und scanf mit %s.

Häufige Auswirkungen

Auswirkung	Details
Zugriffskontrolle	Bereich: Code-Ausführung Das Überschreiben von Rücksprungadressen ermöglicht beliebige Code-Ausführung, typischerweise mit vollen Privilegien des anfälligen Prozesses.
Verfügbarkeit	Bereich: Verfügbarkeit Stack-Beschädigung verursacht häufig Abstürze und Denial-of-Service, selbst wenn die Ausnutzung fehlschlägt.
Integrität	Bereich: Integrität Angreifer können lokale Variablen und Funktionsparameter modifizieren, um Programmverhalten zu ändern.

Beispielcode + Lösungscode

Anfälliger Code

#include <string.h>

// ANFÄLLIG: Stack-Buffer-Overflow
void process_input(char *user_input) {
    char buffer[64];           // Stack-allokierter Puffer
    char admin_flag = 0;       // Angrenzende Variable auf Stack

    strcpy(buffer, user_input); // Overflow überschreibt admin_flag und Rücksprungadresse

    if (admin_flag) {
        grant_admin_access();   // Angreifer kann dies auslösen
    }
}

// Stack-Layout (vereinfacht):
// [buffer 64 Bytes][admin_flag][gespeicherter EBP][Rücksprungadresse]
// Overflow kann admin_flag und Rücksprungadresse überschreiben

Korrigierter Code

#include <string.h>
#include <stdio.h>

// SICHER: Grenzengeprüfte Kopie
void process_input(const char *user_input) {
    char buffer[64];
    int admin_flag = 0;  // Getrennt vom Puffer

    // Sichere Kopie mit expliziter Größenbegrenzung verwenden
    size_t input_len = strlen(user_input);
    if (input_len >= sizeof(buffer)) {
        fprintf(stderr, "Eingabe zu lang\n");
        return;
    }

    strncpy(buffer, user_input, sizeof(buffer) - 1);
    buffer[sizeof(buffer) - 1] = '\0';

    // Admin-Prüfung sollte ordnungsgemäße Authentifizierung verwenden
    // nicht Stack-angrenzende Variablen
}

// Kompilieren mit: gcc -fstack-protector-all -D_FORTIFY_SOURCE=2 -pie -fPIE

---

Ausgenutzt in der Praxis

Sudo Baron Samedit (Linux-Systeme, 2021)

CVE-2021-3156 war ein Heap-basierter Overflow in sudo, der auch Stack-Speicher betraf und lokale Privilegieneskalation zu root auf den meisten Linux-Distributionen ermöglichte. Die Schwachstelle existierte fast 10 Jahre vor ihrer Entdeckung.

• https://blog.qualys.com/vulnerabilities-threat-research/2021/01/26/cve-2021-3156-heap-based-buffer-overflow-in-sudo-baron-samedit

Windows RPC DCOM-Schwachstelle (Windows, 2003)

MS03-026 war ein Stack-Buffer-Overflow in der Windows RPC DCOM-Schnittstelle, der vom Blaster-Wurm ausgenutzt wurde. Der Wurm infizierte Millionen von Windows-Systemen und verursachte weitreichende Internet-Störungen.

• https://docs.microsoft.com/en-us/security-updates/securitybulletins/2003/ms03-026

---

Tools zum Testen/Ausnutzen

• GDB + PEDA/GEF — Debugger-Erweiterungen für Exploit-Entwicklung und Stack-Analyse.

• ROPgadget — Tool zum Finden von ROP-Gadgets, um DEP-Schutz zu umgehen.

• pwntools — Exploit-Entwicklungsframework mit Stack-Overflow-Utilities.

---

CVE-Beispiele

• CVE-2021-3156 — Sudo Heap/Stack-Overflow ermöglicht lokale Root-Privilegieneskalation.

• CVE-2003-0352 — Windows RPC DCOM Stack-Overflow, ausgenutzt vom Blaster-Wurm.

---

Referenzen

1. MITRE. "CWE-121: Stack-based Buffer Overflow." https://cwe.mitre.org/data/definitions/121.html

2. CERT. "STR31-C. Guarantee that storage for strings has sufficient space." https://wiki.sei.cmu.edu/confluence/display/c/STR31-C