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

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

Die Sprache C++ gibt dem Entwickler enorme Kontrolle über Speicher und Leistung, aber diese Freiheit bringt auch große Verantwortung mit sich. Laut OWASP und CWE entstehen Schwachstellen in C++-Anwendungen häufig durch falsche Speicherverwaltung, fehlende Grenzprüfungen und Unachtsamkeit im Umgang mit Zeigern. In diesem Artikel behandeln wir die 10 häufigsten Schwachstellen, auf die Anfänger stoßen. Sie erfahren, wie Sie diese erkennen und, was am wichtigsten ist, wie Sie sie vermeiden.

1. Pufferüberlauf (Buffer Overflow)

Der Klassiker. Diese Schwachstelle tritt auf, wenn ein Programm Daten über die Grenzen eines reservierten Puffers hinaus schreibt. Ein Angreifer kann benachbarte Speicherbereiche überschreiben, einschließlich der Rücksprungadresse einer Funktion, und die Kontrolle über die Codeausführung erlangen.

// Angreifbarer Code\nvoid vulnerable() {\n    char buffer[10];\n    std::cout << "Geben Sie eine Zeichenkette ein: ";\n    std::cin >> buffer; // Keine Längenprüfung!\n    std::cout << buffer << std::endl;\n}\n\n// Sichere Version\nvoid safe() {\n    char buffer[10];\n    std::cout << "Geben Sie eine Zeichenkette ein: ";\n    std::cin.getline(buffer, sizeof(buffer));\n    std::cout << buffer << std::endl;\n}

Wie man sich schützt: Verwenden Sie immer Funktionen mit Längenbegrenzung (strncpy, snprintf, std::string). Vermeiden Sie gets() und strcpy().

2. Speicherlecks (Memory Leaks)

Wenn Sie Speicher mit new reserviert, aber vergessen haben, ihn mit delete freizugeben, verbraucht das Programm nach und nach den Arbeitsspeicher. Für Serveranwendungen ist das eine Katastrophe – nach einigen Betriebsstunden stürzt der Dienst mit einem std::bad_alloc-Fehler ab.

// Beispiel für ein Speicherleck\nvoid leak() {\n    int* ptr = new int(42);\n    // delete ptr; vergessen\n}\n\n// Korrekter Ansatz\nvoid noLeak() {\n    std::unique_ptr<int> ptr = std::make_unique<int>(42);\n    // Speicher wird automatisch freigegeben, wenn der Gültigkeitsbereich verlassen wird\n}

Wie man sich schützt: Verwenden Sie intelligente Zeiger (std::unique_ptr, std::shared_ptr). Im Notfall – RAII (Resource Acquisition Is Initialization).

3. Hängende Zeiger (Dangling Pointers)

Ein Zeiger verweist auf bereits freigegebenen Speicher. Das Dereferenzieren eines solchen Zeigers ist undefiniertes Verhalten (UB). Dies kann zum Programmabsturz oder, schlimmer noch, zur Ausführung von schädlichem Code führen.

int* dangling() {\n    int x = 10;\n    return &x; // Fehler: Rückgabe der Adresse einer lokalen Variable!\n}\n\n// Richtig – Speicher auf dem Heap reservieren\nint* safe() {\n    int* ptr = new int(10);\n    return ptr;\n}

Wie man sich schützt: Weisen Sie dem Zeiger nach delete immer nullptr zu. Verwenden Sie intelligente Zeiger.

4. Ganzzahlüberlauf (Integer Overflow)

Wenn das Ergebnis einer arithmetischen Operation den Wertebereich des Datentyps überschreitet, kommt es zu einem Überlauf. Dies kann zu unerwarteten Folgen führen, z. B. zur Reservierung eines zu kleinen Puffers.

void check_size(size_t user_size) {\n    // Schwachstelle: Wenn user_size sehr groß ist, kann user_size + 1 klein werden\n    char* buffer = new char[user_size + 1];\n    // ...\n}\n\n// Schutz\nvoid safe_check(size_t user_size) {\n    if (user_size > std::numeric_limits<size_t>::max() - 1) {\n        throw std::overflow_error("Größe ist zu groß");\n    }\n    char* buffer = new char[user_size + 1];\n}

Wie man sich schützt: Überprüfen Sie die Grenzen vor arithmetischen Operationen. Verwenden Sie __builtin_add_overflow (GCC/Clang) oder Bibliotheken für sichere Arithmetik.

5. Nullzeiger (Null Pointer Dereference)

Dereferenzieren eines Nullzeigers