Regel
Verhindern gemeinsame Segmentierung Fehler Muster.
Null Zeiger Dereferenzen, Puffer Überläufe,
und use-after-free Fehler verursachen Abstürze und Sicherheit Schwachstellen.

Unterstützte Sprachen: C/C++

Einführung

Segmentierungsfehler sind nach wie vor die häufigste Ursache für Abstürze und ausnutzbare Schwachstellen in C/C++-Anwendungen. Diese Speicherzugriffsverletzungen treten auf, wenn Code versucht, Speicher zu lesen oder zu schreiben, der ihm nicht gehört, typischerweise durch Null-Zeiger-Dereferenzen, Pufferüberläufe, "Dangling Pointers" oder den Zugriff auf freigegebenen Speicher. Ein einziger Segfault kann Produktionsserver zum Absturz bringen, aber schlimmer noch, viele Segfault-Muster lassen sich zur Ausführung von beliebigem Code ausnutzen.

Warum das wichtig ist

Auswirkungen auf die Sicherheit: Pufferüberläufe und "Use-after-free"-Schwachstellen sind die Grundlage der meisten Angriffe auf Speicherbeschädigung. Angreifer nutzen diese aus, um Rücksprungadressen zu überschreiben, Shellcode einzuschleusen oder den Programmkontrollfluss zu manipulieren. Bei der Heartbleed-Schwachstelle von 2014 handelte es sich um einen Pufferüberlauf. Moderne Exploits zielen immer noch auf diese Muster ab, da sie Angreifern direkten Speicherzugriff ermöglichen.

Stabilität des Systems: Bei Segmentierungsfehlern stürzt Ihre Anwendung sofort ab, ohne dass es zu einer Verbesserung der Leistung kommt. In Produktionssystemen bedeutet dies, dass Anfragen abgebrochen, Transaktionen unterbrochen und der Status beschädigt wird. Im Gegensatz zu Ausnahmen in höheren Sprachen, die abgefangen werden können, beenden Segmentierungsfehler den Prozess und erfordern einen Neustart und Wiederherstellungsverfahren.Erweiterung der Angriffsfläche: Jede ungeprüfte Zeigerdereferenz, strcpy, memcpyoder Array-Zugriff ohne Bound-Checking ist ein potentieller Einstiegspunkt für die Ausnutzung. Angreifer ketten diese Schwachstellen aneinander und nutzen eine davon, um den Speicher so zu beschädigen, dass eine andere ausgenutzt werden kann.

Code-Beispiele

❌ Nicht konform:

void process_user_data(const char* input) {
    char buffer[64];
    strcpy(buffer, input);  // No bounds checking

    char* token = strtok(buffer, ",");
    while (token != NULL) {
        process_token(token);
        token = strtok(NULL, ",");
    }
}

int* get_config_value(int key) {
    int* value = (int*)malloc(sizeof(int));
    *value = lookup_config(key);
    return value;  // Caller must free, but no documentation
}

Warum es unsicher ist: Die strcpy() Aufruf verursacht einen Pufferüberlauf, wenn die Eingabe 63 Bytes überschreitet, was Angreifern erlaubt, den Stapelspeicher zu überschreiben. Der get_config_value() Funktion entweicht bei jedem Aufruf Speicher und es besteht die Gefahr, dass ein Dangling Pointer entsteht, wenn ein Aufrufer den Speicher freigibt, während ein anderer Code noch darauf verweist.

✅ Konform:

void process_user_data(const char* input) {
    if (!input) return;

    size_t input_len = strlen(input);
    char* buffer = malloc(input_len + 1);
    if (!buffer) return;

    strncpy(buffer, input, input_len);
    buffer[input_len] = '\0';

    char* token = strtok(buffer, ",");
    while (token != NULL) {
        process_token(token);
        token = strtok(NULL, ",");
    }

    free(buffer);
}

int get_config_value(int key, int* out_value) {
    if (!out_value) return -1;

    *out_value = lookup_config(key);
    return 0;  // Caller owns out_value memory
}

Warum es sicher ist: Nullzeigerprüfungen verhindern Dereferenzierungsabstürze. Dynamische Zuweisung beseitigt feste Puffergrößengrenzen. Grenzengeprüftes Kopieren mit strncpy() verhindert Überlauf. Klare Semantik der Eigentümerschaft in get_config_value() wo der Aufrufer Speicher zur Verfügung stellt, um Zuweisungsverwirrungen und Lecks zu vermeiden.

Schlussfolgerung

Die Speichersicherheit in C und C++ erfordert eine defensive Programmierung bei jeder Zeigeroperation und Speicherzuweisung. Segmentierungsfehler sind nicht unvermeidlich, sondern lassen sich durch konsequente Nullprüfungen, Bound-Validierung und eindeutige Speicherbesitzmuster verhindern. Das Abfangen dieser Muster vor der Produktion verhindert sowohl Abstürze als auch ausnutzbare Schwachstellen.