Zurück zur Schwachstellen-Datenbank

Unsachgemäße Validierung von Array-Index

Beschreibung

Unsachgemäße Validierung von Array-Index tritt auf, wenn ein Programm nicht vertrauenswürdige Eingaben verwendet, um einen Array-Index zu berechnen oder direkt zu verwenden, ohne zu validieren, dass der Index innerhalb der gültigen Grenzen des Arrays liegt. Dies kann zum Zugriff auf Speicher außerhalb der Array-Grenzen führen, entweder vor dem Array-Start (negative Indizes) oder nach dem Array-Ende (Indizes größer oder gleich der Array-Länge). Angreifer können diese Schwäche ausnutzen, um beliebige Speicherstellen zu lesen oder zu schreiben, was zu Informationsoffenlegung, Datenbeschädigung oder Code-Ausführung führt.

Risiko

Unsachgemäße Array-Index-Validierung ist hochgradig ausnutzbar und führt häufig zu schwerwiegenden Sicherheitsschwachstellen. Wenn Angreifer Array-Indizes kontrollieren, können sie je nach Kontext beliebige Lese- oder Schreib-Primitive erreichen. Lesezugriff ermöglicht Informationsoffenlegung und ASLR-Umgehung. Schreibzugriff ermöglicht Speicherbeschädigung und Code-Ausführung. Diese Schwachstellenklasse ist besonders verbreitet in Anwendungen, die strukturierte Datenformate, Netzwerkprotokolle oder benutzerkontrollierte Konfigurationen verarbeiten. Die einfache Ausnutzbarkeit macht sie zu einem häufigen Ziel bei realen Angriffen.

Lösung

Validieren Sie Array-Indizes immer gegen sowohl Minimum (0 oder gültige untere Grenze) als auch Maximum (Array-Länge - 1) Werte vor der Verwendung. Verwenden Sie unsigned Integer-Typen für Indizes, wenn negative Werte ungültig sind, aber prüfen Sie trotzdem obere Grenzen. Implementieren Sie grenzenprüfende Array-Zugriffsfunktionen oder verwenden Sie sichere Container (std::vector::at() in C++ wirft Exception bei Out-of-bounds). Aktivieren Sie Compiler- und Laufzeit-Grenzenprüfung, wo verfügbar. Verwenden Sie statische Analysetools, um ungeprüfte Array-Zugriffe zu identifizieren. Erwägen Sie speichersichere Sprachen, die Grenzenprüfung erzwingen.

Häufige Auswirkungen

AuswirkungDetails
IntegritätBereich: Speicherbeschädigung

Out-of-bounds-Schreiben durch ungültigen Index beschädigt angrenzenden Speicher, potenziell einschließlich Kontrollstrukturen.
VertraulichkeitBereich: Informationsoffenlegung

Out-of-bounds-Lesen legt sensible Daten aus angrenzenden Speicherstellen offen.
ZugriffskontrolleBereich: Code-Ausführung

Beliebiges Schreiben durch kontrollierten Index ermöglicht das Überschreiben von Funktionspointern, Rücksprungadressen oder anderen Kontrolldaten.

Beispielcode + Lösungscode

Anfälliger Code

#include <stdio.h>

// ANFÄLLIG: Benutzergesteuerter Index ohne Grenzenprüfung
int get_value(int *array, int user_index) {
    // Keine Validierung - beliebiges Lesen wenn user_index außerhalb der Grenzen ist
    return array[user_index];
}

// ANFÄLLIG: Nur obere Grenze geprüft
void set_value(int *array, int array_size, int index, int value) {
    if (index < array_size) {
        // Fehlende Prüfung auf negativen Index!
        array[index] = value;  // Beliebiges Schreiben wenn index < 0
    }
}

// ANFÄLLIG: Index aus geparster Nachricht
void process_message(unsigned char *msg, int msg_len) {
    int type_counts[256];
    memset(type_counts, 0, sizeof(type_counts));

    for (int i = 0; i < msg_len; i++) {
        int msg_type = msg[i];
        int msg_index = msg[i + 1];  // Benutzergesteuerter Index

        // Keine Grenzenvalidierung für msg_index
        type_counts[msg_index]++;  // Out-of-bounds wenn msg_index >= 256
    }
}

Korrigierter Code

#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>

// SICHER: Vollständige Grenzenvalidierung
bool get_value_safe(const int *array, size_t array_size,
                    size_t index, int *out_value) {
    // size_t ist unsigned, behandelt Negativ via Wrap
    if (index >= array_size) {
        return false;  // Außerhalb der Grenzen
    }
    *out_value = array[index];
    return true;
}

// SICHER: Beide Grenzen für signed Index prüfen
bool set_value_safe(int *array, size_t array_size,
                    int index, int value) {
    // Auf negativ UND obere Grenze prüfen
    if (index < 0 || (size_t)index >= array_size) {
        return false;  // Ungültiger Index
    }
    array[index] = value;
    return true;
}

// SICHER: Geparsten Index vor Verwendung validieren
bool process_message_safe(const unsigned char *msg, size_t msg_len) {
    int type_counts[256];
    memset(type_counts, 0, sizeof(type_counts));

    // Byte-Paare verarbeiten (Typ, Index)
    for (size_t i = 0; i + 1 < msg_len; i += 2) {
        unsigned char msg_index = msg[i + 1];

        // msg_index ist unsigned char (0-255), passt in array[256]
        // Trotzdem explizit validieren für Defense-in-Depth
        if (msg_index < 256) {
            type_counts[msg_index]++;
        }
    }
    return true;
}

// C++ SICHER: Grenzengeprüften Zugriff verwenden
#ifdef __cplusplus
#include <vector>
#include <stdexcept>

int get_value_cpp(const std::vector<int>& array, size_t index) {
    return array.at(index);  // Wirft std::out_of_range wenn ungültig
}
#endif

Ausgenutzt in der Praxis

Automated Logic WebCtrl / Carrier i-Vu (Gebäudeautomation, 2025)

CVE-2025-0657 ist eine kritische Schwachstelle in Automated Logic WebCtrl und Carrier i-Vu Gen5-Router-Geräten, bei der unsachgemäße Validierung von Array-Indizes speziell gestalteten BACnet MS/TP-Paketen ermöglicht, ungültige Speicherzugriffe zu verursachen, was zu Geräte-Fehlerzustanden und Netzwerkunverfügbarkeit führt.

Juniper Junos OS (Netzwerkausrüstung, 2023)

Unsachgemäße Validierung von Array-Index-Schwachstellen in Juniper Junos OS und Junos OS Evolved ermöglichten Angreifern, Denial-of-Service-Bedingungen auf Netzwerkinfrastruktur zu verursachen.

Linux-Kernel Array-Index-Schwachstellen (Linux, mehrfach)

Mehrere unsachgemäße Array-Index-Validierungsschwachstellen wurden in Linux-Kernel-Subsystemen entdeckt, die potenziell lokale Privilegieneskalation ermöglichen.

Tools zum Testen/Ausnutzen

  • AddressSanitizer — erkennt Out-of-bounds-Array-Zugriff zur Laufzeit.

  • Coverity — statische Analyse, die ungeprüfte Array-Indizes identifiziert.

  • CodeQL — semantische Code-Analyse zum Finden von Array-Index-Schwachstellen.

CVE-Beispiele

  • CVE-2025-0657 — Automated Logic WebCtrl Array-Index-Schwachstelle.

  • CVE-2022-0847 — Dirty Pipe: Linux-Kernel Array-Index-Fehler ermöglicht Privilegieneskalation.

  • CVE-2021-22555 — Linux Netfilter Heap Out-of-bounds-Schreiben über Array-Index.

Referenzen

  1. MITRE. "CWE-129: Improper Validation of Array Index." https://cwe.mitre.org/data/definitions/129.html

  2. CERT. "ARR30-C. Do not form or use out-of-bounds pointers or array subscripts." https://wiki.sei.cmu.edu/confluence/display/c/ARR30-C