Sicherheit von C++-Anwendungen: Top-10 Schwachstellen für Anfänger

Einleitung: Warum ist C++-Code-Sicherheit entscheidend?

C++ ist eine der leistungsstärksten und performantesten Sprachen, aber ihre Flexibilität erfordert ein hohes Maß an Verantwortung vom Entwickler. Anders als viele moderne Sprachen mit automatischer Speicherverwaltung (Java, Python) bietet C++ direkten Zugriff auf Speicher und Systemressourcen. Dies eröffnet vielfältige Angriffsmöglichkeiten: von Pufferüberläufen bis hin zu Datenlecks.

Für angehende C++-Entwickler ist das Verständnis typischer Schwachstellen nicht nur Theorie, sondern eine Notwendigkeit. Ein Fehler von wenigen Zeilen kann zu einem Serverabsturz, Passwortlecks oder der Ausführung beliebigen Codes durch einen Angreifer führen. In diesem Artikel analysieren wir die Top 10 der häufigsten C++-Schwachstellen mit Beispielen und Schutzmethoden.

Top 10 C++-Schwachstellen mit Beispielen und Schutz

1. Pufferüberlauf (Buffer Overflow)

Problem: Schreiben von Daten über die Grenzen eines zugewiesenen Arrays hinaus. Dies ist ein klassisches C/C++-Problem, das das Überschreiben benachbarter Variablen, der Rücksprungadresse oder von Heap-Daten ermöglicht.

// Schwachstellenbeispiel#include <cstring>#include <iostream>

void vulnerable() {    char buffer[10];    std::cout << "Geben Sie einen String ein: ";    std::cin >> buffer; // Gefahr! Keine Längenprüfung}

int main() {    vulnerable();    return 0;}

Folgen: Ausführung beliebigen Codes (RCE), Programmabsturz.

Schutz: Verwenden Sie std::string, std::vector, sichere Funktionen (z. B. strncpy mit Größenangabe).

// Sichere Variante#include <string>#include <iostream>

void safe() {    std::string input;    std::getline(std::cin, input);    std::cout << "Sie haben eingegeben: " << input << std::endl;}

2. Speicherleck (Memory Leak)

Problem: Speicher wird über new/malloc zugewiesen, aber nicht über delete/free freigegeben. Mit der Zeit verbraucht die Anwendung den gesamten verfügbaren Arbeitsspeicher.

void leaky() {    int* data = new int[1000];    // delete[] data; vergessen}

Folgen: Denial of Service (DoS), Systemverlangsamung.

Schutz: Verwenden Sie intelligente Zeiger (std::unique_ptr, std::shared_ptr), RAII (Ressourcenbelegung ist Initialisierung).

#include <memory>void safe() {    std::unique_ptr<int[]> data = std::make_unique<int[]>(1000);    // Speicher wird automatisch freigegeben, wenn die Funktion verlassen wird}

3. Dereferenzierung von Nullzeigern (Null Pointer Dereference)

Problem: Versuch, auf Speicher an der Adresse nullptr zuzugreifen.

void process(int* ptr) {    *ptr = 42; // Wenn ptr == nullptr, stürzt das Programm ab}

Folgen: Sofortiger Absturz (Segmentation Fault), DoS.

Schutz: Überprüfen Sie Zeiger immer vor der Verwendung oder verwenden Sie Referenzen.

void safe(int* ptr) {    if (ptr) {        *ptr = 42;    } else {        // Fehlerbehandlung    }}

4. Ganzzahlüberlauf (Integer Overflow)

Problem: Das Ergebnis einer arithmetischen Operation überschreitet den Wertebereich des Datentyps. Dies kann zu unvorhersehbarem Verhalten führen, insbesondere bei der Arbeit mit Array-Indizes.

#include <cstdint>void vulnerable() {    uint16_t a = 65535;    uint16_t b = 1;    uint16_t sum = a + b; // Überlauf: 65536 -> 0}

Folgen: Logische Fehler, Pufferüberlauf (wenn für die Größenberechnung verwendet).

Schutz: Verwenden Sie Typen mit fester Breite (int32_t, int64_t), prüfen Sie