Integer Underflow (Wrap oder Wraparound)

Beschreibung

Integer Underflow tritt auf, wenn eine arithmetische Subtraktionsoperation ein Ergebnis produziert, das kleiner als der minimale Wert ist, der im Ziel-Integer-Typ gespeichert werden kann, wodurch der Wert zu einer großen positiven Zahl (bei unsigned) oder zum maximalen positiven Wert (bei signed Integers) "umwickelt". Zum Beispiel produziert das Subtrahieren von 1 von einer unsigned Null den maximalen unsigned Wert (z.B. 4294967295 für 32-bit). Integer Underflows sind besonders gefährlich, wenn der resultierende große Wert für Pufferallokation, Schleifenzähler oder Array-Indizes verwendet wird, was oft zu Buffer Overflows oder Denial-of-Service führt.

Risiko

Integer-Underflow-Schwachstellen können schwerwiegende Sicherheitskonsequenzen haben. Wenn ein untergelaufener Wert als Puffergröße verwendet wird, resultiert dies in massiven Allokationen, die Speichererschöpfung oder nachfolgende Buffer Overflows verursachen. Bei Verwendung als Array-Index führt der riesige positive Wert zu Out-of-bounds-Zugriff. Angreifer nutzen diese Schwachstellen aus, indem sie Eingaben bereitstellen, die Subtraktionen veranlassen, negative Zwischenergebnisse in signed Arithmetik zu produzieren, oder indem sie Werte manipulieren, um unsigned Arithmetik zum Unterläufen zu bringen. Diese Schwachstellenklasse betrifft DNS-Server, Netzwerkprotokolle und jeden Code, der Größenberechnungen mit Subtraktion durchführt.

Lösung

Validieren Sie, dass Subtraktionsoperationen nicht unterlaufen, bevor Sie sie durchführen. Prüfen Sie, dass der Minuend größer oder gleich dem Subtrahend ist, bevor Sie unsigned Subtraktion durchführen. Verwenden Sie sichere Arithmetikfunktionen, die Underflow-Bedingungen erkennen. Vermeiden Sie das Mischen von signed und unsigned Integers in Berechnungen. Validieren Sie bei Typkonvertierungen, dass Werte innerhalb gültiger Bereiche sind. Aktivieren Sie Compiler-Sanitizer (-fsanitize=unsigned-integer-overflow) während der Entwicklung. Verwenden Sie size_t für größenbezogene Berechnungen und prüfen Sie Grenzen vor Operationen.

Häufige Auswirkungen

Auswirkung	Details
Verfügbarkeit	Bereich: Denial-of-Service Underflow, der massive Allokationsanforderungen produziert, verursacht Speichererschöpfung und Abstürze.
Integrität	Bereich: Speicherbeschädigung Untergelaufene Größen oder Indizes führen zu Buffer Overflows und Speicherbeschädigung.
Zugriffskontrolle	Bereich: Code-Ausführung Buffer Overflows, die aus Underflow resultieren, ermöglichen beliebige Code-Ausführung.

Beispielcode + Lösungscode

Anfälliger Code

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

// ANFÄLLIG: Unsigned Underflow
void process_data(uint32_t length, uint32_t header_size) {
    // Wenn header_size > length, unterläuft dies zu riesigem Wert
    uint32_t data_size = length - header_size;

    char *buffer = malloc(data_size);  // Massive Allokation oder winzig bei Wrap
    // ...
}

// ANFÄLLIG: Längen-Underflow beim Protokoll-Parsing
void parse_packet(const char *packet, size_t packet_len, size_t header_len) {
    // Underflow wenn header_len > packet_len
    size_t payload_len = packet_len - header_len;

    // payload_len ist jetzt riesiger positiver Wert
    char *payload = malloc(payload_len);  // Speichererschöpfung

    memcpy(payload, packet + header_len, payload_len);  // Over-Read
}

// ANFÄLLIG: Signed-zu-Unsigned-Cast nach Underflow
void copy_data(int len) {
    int actual_len = len - HEADER_SIZE;

    // Wenn actual_len negativ ist, macht Cast zu size_t ihn riesig
    char *buf = malloc((size_t)actual_len);

    read_data(buf, actual_len);  // Desaster
}

Korrigierter Code

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

// SICHER: Auf Underflow vor Subtraktion prüfen
bool process_data_safe(uint32_t length, uint32_t header_size, char **out_buffer) {
    // Validieren: können wir ohne Underflow subtrahieren?
    if (header_size > length) {
        return false;  // Würde unterlaufen
    }

    uint32_t data_size = length - header_size;

    // Zusätzliche Plausibilitätsprüfung
    if (data_size > MAX_DATA_SIZE) {
        return false;
    }

    *out_buffer = malloc(data_size);
    return (*out_buffer != NULL);
}

// SICHER: Längen vor Subtraktion validieren
int parse_packet_safe(const char *packet, size_t packet_len,
                      size_t header_len, char **payload, size_t *payload_len) {
    // Auf Underflow prüfen
    if (header_len > packet_len) {
        return -1;  // Ungültig: Header größer als Paket
    }

    *payload_len = packet_len - header_len;

    // Vernünftige Grenzen prüfen
    if (*payload_len > MAX_PAYLOAD_SIZE) {
        return -1;
    }

    *payload = malloc(*payload_len);
    if (!*payload) {
        return -1;
    }

    memcpy(*payload, packet + header_len, *payload_len);
    return 0;
}

// SICHER: Signed-Wert vor Cast validieren
bool copy_data_safe(int len) {
    if (len < HEADER_SIZE) {
        return false;  // Nicht genug Daten für Header
    }

    int actual_len = len - HEADER_SIZE;

    // actual_len ist hier garantiert nicht-negativ
    char *buf = malloc((size_t)actual_len);
    if (!buf) return false;

    read_data(buf, actual_len);
    free(buf);
    return true;
}

---

Ausgenutzt in der Praxis

MaraDNS Integer Underflow (MaraDNS, 2024)

CVE in MaraDNS DNS-Server, bei dem ein Integer Underflow in der decomp_get_rddata-Funktion während der DNS-Paketdekompression Remote-Angreifern ermöglicht, Denial-of-Service zu verursachen. Wenn rdlength kleiner als rdata ist, unterläuft die Subtraktion und verursacht unmögliche Speicherallokationsversuche.

• https://github.com/samboy/MaraDNS/security/advisories/

NVIDIA Triton Inference Server (NVIDIA, 2025)

Integer-Underflow-Schwachstelle in NVIDIA Triton Inference Server ermöglicht Denial-of-Service oder potentielle Speicherbeschädigung durch manipulierte Inferenzanfragen.

• https://nvidia.custhelp.com/app/answers/detail/a_id/

VMware-Produkte (VMware, 2025)

Integer-Underflow-Schwachstellen gemeldet in VMware Cloud Foundation, VMware Fusion und VMware Workstation, die Virtualisierungssicherheit beeinträchtigen.

• https://www.vmware.com/security/advisories/

---

Tools zum Testen/Ausnutzen

• UBSan — erkennt signed Integer Underflow (undefiniertes Verhalten).

• AddressSanitizer — erkennt Speicherprobleme, die aus Underflow resultieren.

• AFL++ — Fuzzer zur Entdeckung von Underflow-Bedingungen durch Grenzfälle.

---

CVE-Beispiele

• CVE-2022-42475 — Fortinet FortiOS SSL-VPN Heap-Underflow, in freier Wildbahn ausgenutzt.

• CVE-2023-27997 — Fortinet FortiGate Buffer-Underflow RCE.

• CVE-2024-3094 — XZ Utils Backdoor mit Integer-Manipulation.

---

Referenzen

1. MITRE. "CWE-191: Integer Underflow (Wrap or Wraparound)." https://cwe.mitre.org/data/definitions/191.html

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