Heap-basierter Buffer Overflow

Beschreibung

Heap-basierter Buffer Overflow ist eine Buffer-Overflow-Schwachstelle, die in der Heap-Speicherregion auftritt, wo dynamisch allokierter Speicher residiert. Wenn ein Programm mehr Daten in einen Heap-allokierten Puffer schreibt als dessen zugewiesene Größe, beschädigt es angrenzende Heap-Strukturen einschließlich anderer allokierter Objekte, Heap-Metadaten (Chunk-Header, Free-Listen) und Kontrolldaten. Anders als Stack-Overflows, bei denen Rücksprungadressen direktes Control-Flow-Hijacking ermöglichen, erfordern Heap-Overflows das Beschädigen von Heap-Verwaltungsstrukturen oder Funktionspointern, die in Heap-Objekten gespeichert sind, um Code-Ausführung zu erreichen.

Risiko

Heap-Overflows sind hochgradig gefährlich, obwohl sie generell schwieriger auszunutzen sind als Stack-Overflows. Moderne Ausnutzungstechniken wie Heap-Feng-Shui, Use-After-Free-Verkettung und das Beschädigen von C++-VTable-Pointern machen Heap-Overflows zuverlässig ausnutzbar. Heap-Metadaten-Beschädigung kann beliebige Write-Primitives ermöglichen. Browser-Engines, Dokument-Parser und Multimedia-Codecs enthalten häufig Heap-Overflow-Schwachstellen, die Remote Code Execution ermöglichen. Die Komplexität der Heap-Ausnutzung hat ausgefeilte Techniken hervorgebracht, die Schutzmaßnahmen wie ASLR durch Information Disclosure oder Heap-Spraying umgehen.

Lösung

Verwenden Sie speichersichere Allokations-Wrapper, die Puffergrößen verfolgen. Bevorzugen Sie C++-Container (std::vector, std::string) gegenüber rohen Heap-Allokationen. Verwenden Sie AddressSanitizer während der Entwicklung, um Heap-Overflows zu erkennen. Implementieren Sie Heap-Hardening: aktivieren Sie glibc-Heap-Schutzmaßnahmen, verwenden Sie gehärtete Allokatoren (OpenBSD malloc, mimalloc, tcmalloc mit Hardening). Validieren Sie alle Größen vor Heap-Operationen. Verwenden Sie statische Analyse, um nicht übereinstimmende Allokations-/Kopiergrößen zu finden. Erwägen Sie Rust oder andere speichersichere Sprachen für sicherheitskritische Komponenten.

Häufige Auswirkungen

Auswirkung	Details
Zugriffskontrolle	Bereich: Code-Ausführung Heap-Metadaten-Beschädigung ermöglicht beliebige Write-Primitives; VTable-/Funktionspointer-Beschädigung ermöglicht Code-Ausführung.
Integrität	Bereich: Integrität Angrenzende Heap-Objekte können beschädigt werden, was zu Manipulation der Anwendungslogik führt.
Verfügbarkeit	Bereich: Verfügbarkeit Heap-Beschädigung verursacht typischerweise Abstürze bei nachfolgenden Allokationen oder Freigaben.

Beispielcode + Lösungscode

Anfälliger Code

#include <stdlib.h>
#include <string.h>

// ANFÄLLIG: Heap-Buffer-Overflow
void process_data(char *input, size_t len) {
    char *buffer = malloc(64);  // Heap-allokierter Puffer

    // Keine Größenprüfung - Heap-Overflow wenn len > 64
    memcpy(buffer, input, len);

    // Angrenzende Heap-Chunks beschädigt
    process(buffer);
    free(buffer);
}

// ANFÄLLIG: Integer-Overflow führt zu Heap-Overflow
void parse_packet(unsigned int size, char *data) {
    // Integer-Overflow: size + 1 wrapt zu 0
    char *buf = malloc(size + 1);
    memcpy(buf, data, size);  // Massiver Overflow
    buf[size] = '\0';
}

Korrigierter Code

#include <stdlib.h>
#include <string.h>
#include <stdint.h>

// SICHER: Größengeprüfte Heap-Allokation
void process_data(const char *input, size_t len) {
    if (len > 1024) {  // Vernünftiges Maximum
        return;
    }

    char *buffer = malloc(len + 1);
    if (!buffer) return;

    memcpy(buffer, input, len);
    buffer[len] = '\0';

    process(buffer);
    free(buffer);
}

// SICHER: Integer-Overflow-Schutz
void parse_packet(size_t size, const char *data) {
    // Auf Integer-Overflow prüfen
    if (size > SIZE_MAX - 1) {
        return;
    }

    char *buf = malloc(size + 1);
    if (!buf) return;

    memcpy(buf, data, size);
    buf[size] = '\0';

    // Puffer verwenden...
    free(buf);
}

---

Ausgenutzt in der Praxis

Internet Explorer Use-After-Free/Heap-Overflow-Kette (Microsoft, 2014)

CVE-2014-1776 kombinierte Heap-Overflow und Use-After-Free in Internet Explorer und wurde von APT-Gruppen für gezielte Angriffe ausgenutzt, bevor Patches verfügbar waren.

• https://www.fireeye.com/blog/threat-research/2014/04/new-zero-day-exploit-targeting-internet-explorer-versions-9-through-11-identified-in-targeted-attacks.html

Chrome V8 Heap-Overflow (Google Chrome, mehrfach)

Mehrere Heap-Overflow-Schwachstellen in Chromes V8-JavaScript-Engine wurden in freier Wildbahn ausgenutzt und demonstrieren das fortlaufende Risiko in Browser-JavaScript-Engines.

• https://chromereleases.googleblog.com/

---

Tools zum Testen/Ausnutzen

• AddressSanitizer — erkennt Heap-Buffer-Overflows zur Laufzeit während der Entwicklung.

• how2heap — Bildungsrepository, das Heap-Ausnutzungstechniken demonstriert.

• HeapLAB — Praktische Heap-Ausnutzungs-Trainingsplattform.

---

CVE-Beispiele

• CVE-2014-1776 — Internet Explorer Use-After-Free, ausgenutzt bei gezielten Angriffen.

• CVE-2022-0609 — Chrome Use-After-Free, in freier Wildbahn ausgenutzt.

---

Referenzen

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

2. Phrack. "Once upon a free()." http://phrack.org/issues/57/9.html