Zurück zur Schwachstellen-Datenbank

Out-of-bounds-Lesen

Beschreibung

Out-of-bounds-Lesen ist eine Schwachstelle, die auftritt, wenn Software Daten von einer Speicherstelle außerhalb der beabsichtigten Grenzen eines Puffers liest. Dies geschieht, wenn Array-Indizes, Pointer-Arithmetik oder Puffer-Offsets falsch berechnet oder nicht ordnungsgemäß gegen Puffergrenzen validiert werden. Während Out-of-bounds-Lesen typischerweise nicht direkt Code-Ausführung ermöglicht, kann es sensible Informationen aus angrenzendem Speicher offenlegen, einschließlich kryptografischer Schlüssel, Passwörter, Benutzerdaten und Speicheradressen, die helfen, ASLR zu umgehen. Die Heartbleed-Schwachstelle demonstrierte, dass Out-of-bounds-Lesen katastrophale Auswirkungen in großem Maßstab haben kann.

Risiko

Out-of-bounds-Lesen stellt erhebliche Vertraulichkeitsrisiken dar, indem es sensible im Speicher gespeicherte Daten offenlegt. In kryptografischen Anwendungen können sie private Schlüssel und Session-Geheimnisse leaken. In Webservern können sie Authentifizierungs-Token, Benutzeranmeldedaten und persönliche Daten offenlegen. Speicheradressen-Leaks ermöglichen Angreifern, ASLR zu umgehen, was die nachfolgende Ausnutzung von Speicherbeschädigungs-Schwachstellen erleichtert. In manchen Fällen verursacht das Lesen von nicht gemapptem Speicher Abstürze, die zu Denial-of-Service führen. Die Heartbleed-Schwachstelle ermöglichte Angreifern, bis zu 64KB Serverspeicher pro Anfrage zu lesen, betraf Millionen von Servern und legte unzählige private Schlüssel und Benutzeranmeldedaten offen.

Lösung

Validieren Sie immer, dass Leseoperationen innerhalb allokierter Puffergrenzen bleiben. Verwenden Sie sichere Container-Typen, die Grenzenprüfung durchführen (std::vector, std::array in C++). Aktivieren Sie Compiler-Grenzenprüfung, wo verfügbar. Verwenden Sie AddressSanitizer während der Entwicklung, um Out-of-bounds-Lesen zu erkennen. Implementieren Sie strikte Eingabevalidierung für Array-Indizes und Puffer-Offsets. Überprüfen Sie alle Pointer-Arithmetik auf potentiellen Underflow/Overflow. Erwägen Sie speichersichere Sprachen für sicherheitskritische Datenverarbeitung.

Häufige Auswirkungen

AuswirkungDetails
VertraulichkeitBereich: Vertraulichkeit

Sensible Daten einschließlich Anmeldedaten, kryptografischer Schlüssel und persönlicher Informationen können aus angrenzenden Speicherstellen offengelegt werden.
VerfügbarkeitBereich: Verfügbarkeit

Das Lesen von nicht gemappten Speicherseiten verursacht Segmentation Faults und Anwendungsabstürze.
ZugriffskontrolleBereich: Sicherheitsumgehung

Geleakte Speicheradressen ermöglichen ASLR-Umgehung und erleichtern die Ausnutzung anderer Schwachstellen.

Beispielcode + Lösungscode

Anfälliger Code

#include <string.h>

// ANFÄLLIG: Out-of-bounds-Lesen
void heartbleed_like(char *data, size_t claimed_len) {
    char response[65536];

    // Angreifer behauptet größere Länge als tatsächliche Daten
    // Liest über Datenpuffer hinaus in angrenzenden Speicher
    memcpy(response, data, claimed_len);

    send_response(response, claimed_len);  // Leakt Speicherinhalte
}

// ANFÄLLIG: Array-Index nicht validiert
int get_item(int *array, size_t array_size, int index) {
    // Negativer Index oder index >= array_size liest out-of-bounds
    return array[index];
}

Korrigierter Code

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

// SICHER: Länge gegen tatsächliche Daten validieren
void safe_response(char *data, size_t actual_len, size_t claimed_len) {
    char response[65536];

    // Minimum von behaupteter und tatsächlicher Länge verwenden
    size_t copy_len = claimed_len < actual_len ? claimed_len : actual_len;

    // Zusätzliche Grenzenprüfung gegen Response-Puffer
    if (copy_len > sizeof(response)) {
        copy_len = sizeof(response);
    }

    memcpy(response, data, copy_len);
    send_response(response, copy_len);
}

// SICHER: Grenzengeprüfter Array-Zugriff
int get_item_safe(int *array, size_t array_size, size_t index) {
    if (index >= array_size) {
        return -1;  // Fehlerindikator oder Exception werfen
    }
    return array[index];
}

Ausgenutzt in der Praxis

Heartbleed (OpenSSL, 2014)

CVE-2014-0160 (Heartbleed) war ein Out-of-bounds-Lesen in OpenSSLs TLS-Heartbeat-Erweiterung, das Angreifern erlaubte, bis zu 64KB Serverspeicher pro Anfrage zu lesen. Die Schwachstelle betraf geschätzte 17% der sicheren Webserver und legte private Schlüssel, Session-Cookies und Benutzeranmeldedaten offen. Sie bleibt eine der einflussreichsten jemals entdeckten Schwachstellen.

Cloudbleed (Cloudflare, 2017)

Ein Parser-Bug in Cloudflares HTML-Parser verursachte Out-of-bounds-Lesen, das sensible Daten aus anderen Kundenanfragen in gecachte Seiten leakte. Die geleakten Daten umfassten Passwörter, API-Schlüssel und Authentifizierungs-Token.

Tools zum Testen/Ausnutzen

  • AddressSanitizer — Laufzeiterkennung von Out-of-bounds-Lesen mit präziser Fehlermeldung.

  • Valgrind — Speicherfehlerdetektor, der ungültige Lesezugriffe identifiziert.

  • AFL++ — Fuzzer, der effektiv beim Auslösen von Out-of-bounds-Bedingungen ist.

CVE-Beispiele

  • CVE-2014-0160 — Heartbleed OpenSSL Buffer-Over-Read, der Serverspeicher offenlegt.

  • CVE-2017-0143 — EternalBlue SMB Out-of-bounds-Lesen, das WannaCry ermöglichte.

Referenzen

  1. MITRE. "CWE-125: Out-of-bounds Read." https://cwe.mitre.org/data/definitions/125.html

  2. Heartbleed. "The Heartbleed Bug." https://heartbleed.com/