Integer Overflow oder Wraparound

Beschreibung

Integer Overflow oder Wraparound tritt auf, wenn eine arithmetische Operation einen numerischen Wert produziert, der den maximalen Wert überschreitet, der im Ziel-Integer-Typ gespeichert werden kann. Wenn dies geschieht, "wickelt" der Wert zu einer kleinen Zahl (oder negativen Zahl bei signed Integers) um. Bei unsigned Arithmetik wickelt Overflow zu Null um; bei signed Arithmetik ist das Verhalten in C/C++ undefiniert, wickelt aber typischerweise zum minimalen negativen Wert um. Integer Overflows sind besonders gefährlich, wenn das Ergebnis für Speicherallokationsgrößen, Array-Indizes oder sicherheitskritische Berechnungen verwendet wird.

Risiko

Integer-Overflow-Schwachstellen werden zu den CWE Top 25 der gefährlichsten Software-Schwächen gezählt. Sie ermöglichen Angreifern, große Werte in kleine Werte umzuwandeln, Größenprüfungen zu umgehen und unterdimensionierte Pufferallokationen zu verursachen, die anschließend überlaufen werden. Integer Overflows haben Remote Code Execution in unzähligen Anwendungen ermöglicht, von Bildprozessoren, die Breite×Höhe-Berechnungen durchführen, bis zu Netzwerkdiensten, die Längenfelder parsen. Kritische Sektoren einschließlich Finanzen (Transaktionsmanipulation), Gaming (Währungs-Exploits), Gesundheitswesen und industrielle Steuerungssysteme sind von schweren operativen Schäden durch Integer-Overflow-Exploitation betroffen.

Lösung

Validieren Sie immer, dass arithmetische Operationen nicht überläufen, bevor Sie sie durchführen. Verwenden Sie sichere Integer-Bibliotheken (SafeInt in C++, checked arithmetic in Rust). Prüfen Sie gegen Typgrenzen (INT_MAX, SIZE_MAX) vor Operationen. Verwenden Sie größere Integer-Typen, wo Overflow möglich ist. Aktivieren Sie Compiler-Optionen, die Overflow erkennen (-ftrapv für signed, -fsanitize=unsigned-integer-overflow). Vermeiden Sie das Mischen von signed und unsigned Integers in Berechnungen. Verwenden Sie statische Analysetools, um potentielle Overflow-Punkte zu identifizieren. Erwägen Sie die Verwendung von Arbitrary-Precision-Arithmetik für kritische Berechnungen.

Häufige Auswirkungen

Auswirkung	Details
Integrität	Bereich: Speicherbeschädigung Overflow in Größenberechnungen führt zu unterdimensionierten Allokationen und nachfolgenden Buffer Overflows.
Zugriffskontrolle	Bereich: Code-Ausführung Buffer Overflows, die aus Integer Overflow resultieren, ermöglichen beliebige Code-Ausführung.
Verfügbarkeit	Bereich: Ressourcenerschöpfung Overflow, der große Allokationen verursacht, führt zu Speichererschöpfung; Endlosschleifen durch Zähler-Overflow verursachen DoS.

Beispielcode + Lösungscode

Anfälliger Code

#include <stdlib.h>
#include <stdint.h>

// ANFÄLLIG: Multiplikations-Overflow
void *allocate_image(unsigned int width, unsigned int height) {
    // Wenn width * height überläuft, allokiert winzigen Puffer
    size_t size = width * height * 4;  // 4 Bytes pro Pixel

    char *buffer = malloc(size);

    // Schreiben in Puffer mit ursprünglichen Dimensionen verursacht Overflow
    for (unsigned int y = 0; y < height; y++) {
        for (unsigned int x = 0; x < width; x++) {
            buffer[(y * width + x) * 4] = 0;  // Massiver Overflow
        }
    }
    return buffer;
}

// ANFÄLLIG: Additions-Overflow in Schleife
void process_packets(uint16_t count, uint16_t size) {
    uint16_t total = count * size;  // Overflow wenn count=1000, size=100

    // total kann viel kleiner als erwartet sein
    char *buffer = malloc(total);
    // Verarbeitung nimmt ursprüngliche Größen an
}

// ANFÄLLIG: Signed Overflow (undefiniertes Verhalten)
int calculate_position(int base, int offset) {
    // Wenn offset groß positiv ist, kann Summe zu negativ überläufen
    int position = base + offset;

    if (position < 0) {
        return 0;  // Wird nie erreicht wenn Overflow wegoptimiert wird
    }
    return position;
}

Korrigierter Code

#include <stdlib.h>
#include <stdint.h>
#include <limits.h>
#include <stdbool.h>

// SICHER: Overflow vor Multiplikation prüfen
void *allocate_image_safe(size_t width, size_t height) {
    // Prüfen, dass width * height nicht überläuft
    if (width != 0 && height > SIZE_MAX / width) {
        return NULL;
    }
    size_t pixels = width * height;

    // Prüfen, dass pixels * 4 nicht überläuft
    if (pixels > SIZE_MAX / 4) {
        return NULL;
    }
    size_t size = pixels * 4;

    char *buffer = calloc(pixels, 4);  // calloc kann auch prüfen
    return buffer;
}

// SICHER: Overflow-prüfende Multiplikation
bool safe_multiply(size_t a, size_t b, size_t *result) {
    if (a != 0 && b > SIZE_MAX / a) {
        return false;  // Würde überläufen
    }
    *result = a * b;
    return true;
}

// SICHER: Overflow-prüfende Addition für signed Integers
bool safe_add_signed(int a, int b, int *result) {
    if (b > 0 && a > INT_MAX - b) {
        return false;  // Positiver Overflow
    }
    if (b < 0 && a < INT_MIN - b) {
        return false;  // Negativer Overflow
    }
    *result = a + b;
    return true;
}

// SICHER: Compiler-Built-ins verwenden (GCC/Clang)
void *allocate_checked(size_t count, size_t size) {
    size_t total;

    // __builtin_mul_overflow gibt true bei Overflow zurück
    if (__builtin_mul_overflow(count, size, &total)) {
        return NULL;
    }

    return malloc(total);
}

---

Ausgenutzt in der Praxis

Microsoft Windows Speech (Windows 11, 2025)

CVE-2025-58715 ist ein Integer Overflow in der Windows Speech-Komponente, der lokalen Angreifern ermöglicht, Privilegien zu SYSTEM zu eskalieren. CVSS-Score 8.8 mit hoher Auswirkung auf Vertraulichkeit, Integrität und Verfügbarkeit.

• https://msrc.microsoft.com/update-guide/

Finanzsektor-Transaktionsmanipulation (Banken, mehrfach)

Integer-Overflow-Schwachstellen in Bankensystemen haben Angreifern ermöglicht, Transaktionswerte zu manipulieren und erhebliche finanzielle Verluste zu verursachen. Die Implementierung von Eingabevalidierung und Grenzenprüfungen milderte diese Probleme.

• https://www.fsisac.com/

Gaming-Währungs-Exploits (Online-Spiele, mehrfach)

Mehrere Online-Spiele haben Exploits erlebt, bei denen Spieler Währungszähler überläufen lassen, um unbegrenzte In-Game-Mittel zu erhalten, was wirtschaftliche Störungen in Spiel-Ökosystemen verursacht.

• https://www.gamedeveloper.com/

OpenSSH Authentifizierungsumgehung (OpenSSH, 2002)

CVE-2002-0639 war ein Integer Overflow in OpenSSHs Challenge-Response-Authentifizierung, der Remote Code Execution ermöglichte und frühe reale Auswirkungen dieser Schwachstellenklasse demonstrierte.

• https://www.openssh.com/security.html

---

Tools zum Testen/Ausnutzen

• UBSan — Undefined-Behavior-Sanitizer, der signed Overflow erkennt.

• SafeInt — C++-Bibliothek für overflow-sichere Integer-Arithmetik.

• AFL++ — Fuzzer, der effektiv bei der Entdeckung von Integer-Overflow-Bedingungen ist.

• IntScope — Statischer Analysator für Integer-Schwachstellen.

---

CVE-Beispiele

• CVE-2025-58715 — Windows 11 Speech Integer Overflow für Privilegieneskalation.

• CVE-2002-0639 — OpenSSH Challenge-Response Integer Overflow.

• CVE-2023-4863 — libwebp Integer Overflow ermöglicht Heap-Buffer-Overflow.

---

Referenzen

1. MITRE. "CWE-190: Integer Overflow or Wraparound." https://cwe.mitre.org/data/definitions/190.html

2. CERT. "INT30-C. Ensure that unsigned integer operations do not wrap." https://wiki.sei.cmu.edu/confluence/display/c/INT30-C

3. CWE Top 25. "2024 CWE Top 25 Most Dangerous Software Weaknesses." https://cwe.mitre.org/top25/