Integer Coercion-Fehler

Beschreibung

Integer Coercion-Fehler ist eine Schwachstelle, die auftritt, wenn primitive Datentypen während Typkonvertierungsoperationen falsch gecastet, erweitert oder gekürzt werden. Diese Schwäche entsteht, wenn ein Wert eines Integer-Typs in einen anderen Integer-Typ konvertiert wird, der den ursprünglichen Wert nicht ordnungsgemäß darstellen kann, was zu Datenverlust, unerwarteten Wertänderungen oder sicherheitskritischen Fehlern führt. In Sprachen wie C und C++ erzeugt die Unterscheidung zwischen impliziter Coercion durch den Compiler und explizitem Casting durch den Programmierer subtile Schwachstellen. Wenn ein größerer Integer-Typ in einen kleineren konvertiert wird (Trunkierung), oder wenn signed und unsigned Typen gemischt werden, kann der resultierende Wert erheblich vom Original abweichen und möglicherweise Sicherheitsprüfungen umgehen oder Buffer Overflows verursachen.

Risiko

Integer-Coercion-Fehler stellen erhebliche Sicherheitsrisiken dar, weil sie stillschweigend Daten beschädigen und Sicherheitsmechanismen umgehen können, die zum Schutz gegen andere Schwachstellen entwickelt wurden. Wenn Integer-Werte gekürzt oder unsachgemäß konvertiert werden, können Größenberechnungen falsch werden, was zu unterdimensionierten Pufferallokationen führt, die Buffer Overflows zur Folge haben. Diese Fehler können dazu führen, dass Anwendungen in undefinierte Ausführungszustände, Endlosschleifen oder unerwartete Abstürze geraten und die Systemverfügbarkeit beeinträchtigen. In sicherheitskritischen Kontexten wie Authentifizierungssystemen oder kryptografischen Implementierungen kann Integer Coercion Angreifern ermöglichen, Validierungsprüfungen zu umgehen und unbefugten Zugriff zu erlangen oder beliebigen Code auszuführen.

Lösung

Verhindern Sie Integer-Coercion-Fehler durch Verwendung konsistenter Integer-Typen in Berechnungen und explizite Validierung von Werten vor Typkonvertierungen. Setzen Sie sichere Integer-Bibliotheken wie SafeInt (C++) oder IntegerLib ein, die Overflow- und Trunkierungsbedingungen erkennen und behandeln. Bei der Konvertierung zwischen Integer-Typen verifizieren Sie immer, dass der Quellwert innerhalb des gültigen Bereichs des Zieltyps liegt, bevor Sie die Konvertierung durchführen. Aktivieren Sie Compiler-Warnungen für implizite Typkonvertierungen und behandeln Sie diese Warnungen als Fehler. In Sprachen mit stärker Typisierung bevorzugen Sie die Verwendung der passenden Integer-Größe für die Aufgabe und vermeiden Sie unnötige Konvertierungen. Implementieren Sie Laufzeitprüfungen für kritische Operationen und verwenden Sie statische Analysetools, um potentielle Coercion-Probleme während der Entwicklung zu identifizieren.

Häufige Auswirkungen

Auswirkung	Details
Verfügbarkeit	Bereich: Verfügbarkeit Integer Coercion führt oft zu undefinierten Ausführungszuständen, die in Endlosschleifen oder Abstürzen resultieren. Der Ressourcenverbrauch steigt, wenn die Anwendung in Fehlerzustande gerät, was möglicherweise Denial-of-Service-Bedingungen verursacht.
Integrität, Vertraulichkeit, Verfügbarkeit	Bereich: Integrität, Vertraulichkeit, Verfügbarkeit In einigen Fällen können Integer-Coercion-Fehler zu ausnutzbaren Buffer-Overflow-Bedingungen führen, die die Ausführung beliebigen Codes ermöglichen. Dies kompromittiert alle drei Sicherheitseigenschaften, da Angreifer sensible Daten lesen, Systemzustand modifizieren und Anwendungen zum Absturz bringen können.
Datenintegrität	Bereich: Integrität Integer-Coercion-Fehler führen dazu, dass falsche Werte für betroffene Variablen gespeichert werden, was Anwendungsdaten beschädigt und möglicherweise zu falschem Programmverhalten oder Sicherheitsumgehungen führt.

Beispielcode

Anfälliger Code (C)

Der folgende Code demonstriert ein anfälliges Muster, bei dem ein signed Integer zu einem unsigned Typ coerciert wird und möglicherweise eine Grenzenprüfung umgeht:

#include <stdio.h>
#include <string.h>

void process_data(char *buffer, int user_length) {
    char internal_buffer[256];

    // Anfällig: signed int verglichen mit unsigned size_t
    // Wenn user_length negativ ist, passiert diese Prüfung, aber memcpy schlägt fehl
    if (user_length > sizeof(internal_buffer)) {
        printf("Fehler: Länge zu groß\n");
        return;
    }

    // user_length wird implizit zu size_t (unsigned) konvertiert
    // Ein negativer Wert wird zu einer sehr großen positiven Zahl
    memcpy(internal_buffer, buffer, user_length);

    printf("Verarbeitet %d Bytes\n", user_length);
}

int main() {
    char data[512] = "Einige Daten";

    // Angreifer liefert negative Länge
    int malicious_length = -1;  // Wird 0xFFFFFFFF bei Konvertierung zu size_t

    process_data(data, malicious_length);
    return 0;
}

Die Schwachstelle tritt auf, weil der Vergleich user_length > sizeof(internal_buffer) einen signed Integer mit einem unsigned Wert vergleicht. Wenn user_length negativ ist, passiert er die Prüfung, wird aber in memcpy() zu einem massiven unsigned Wert konvertiert, was einen Buffer Overflow verursacht.

Korrigierter Code (C)

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

int process_data_safe(char *buffer, int user_length) {
    char internal_buffer[256];

    // Fix 1: Explizit zuerst auf negative Werte prüfen
    if (user_length < 0) {
        printf("Fehler: Negative Länge nicht erlaubt\n");
        return -1;
    }

    // Fix 2: Konsistente Typen für Vergleich verwenden
    size_t safe_length = (size_t)user_length;

    if (safe_length > sizeof(internal_buffer)) {
        printf("Fehler: Länge zu groß\n");
        return -1;
    }

    // Jetzt ist die Konvertierung sicher
    memcpy(internal_buffer, buffer, safe_length);

    printf("Verarbeitet %zu Bytes\n", safe_length);
    return 0;
}

// Alternative: Von Anfang an size_t verwenden
int process_data_better(char *buffer, size_t user_length) {
    char internal_buffer[256];

    // Keine Coercion nötig - Typen stimmen überein
    if (user_length > sizeof(internal_buffer)) {
        printf("Fehler: Länge zu groß\n");
        return -1;
    }

    memcpy(internal_buffer, buffer, user_length);
    printf("Verarbeitet %zu Bytes\n", user_length);
    return 0;
}

int main() {
    char data[512] = "Einige Daten";

    // Sichere Behandlung von potenziell bösartiger Eingabe
    int user_input = -1;
    process_data_safe(data, user_input);  // Ordnungsgemäß abgelehnt

    return 0;
}

Der Fix stellt sicher, dass negative Werte explizit geprüft werden, bevor eine Typkonvertierung stattfindet. Die Verwendung konsistenter unsigned Typen wie size_t für Längenparameter eliminiert die Coercion-Schwachstelle vollständig.

Ausgenutzt in der Praxis

FORCEDENTRY Zero-Click Exploit (Apple/NSO Group, 2021)

Der FORCEDENTRY-Exploit, entwickelt von NSO Group, nutzte eine Integer-Overflow-Schwachstelle in Apples CoreGraphics-Bildrendering-Bibliothek aus, um Pegasus-Spyware auf iPhones ohne jegliche Benutzerinteraktion zu deployen. Der Angriff verwendete bösartig gestaltete PDF-Dateien, die als GIF-Bilder getarnt waren, um den Integer Overflow auszulösen und Apples BlastDoor-Sandbox-Sicherheit zu umgehen. Citizen Lab entdeckte den Exploit bei der Analyse des Telefons eines saudischen Aktivisten und fand heraus, dass er mindestens seit Februar 2021 in Gebrauch war. Die Schwachstelle betraf iOS-, macOS- und watchOS-Geräte, was Apple veranlasste, Notfall-Patches herauszugeben und anschließend Klage gegen NSO Group einzureichen.

https://citizenlab.ca/2021/09/forcedentry-nso-group-imessage-zero-click-exploit-captured-in-the-wild/

Heartbleed OpenSSL-Schwachstelle (Mehrere Organisationen, 2014)

Obwohl primär als Buffer-Over-Read klassifiziert, demonstrierte die Heartbleed-Schwachstelle (CVE-2014-0160), wie unsachgemäße Behandlung von Integer-Werten in Grenzenprüfungen zu katastrophalen Sicherheitsausfällen führen kann. Der anfällige Code validierte nicht, dass eine Integer-Payload-Länge mit der tatsächlichen Paketdatengröße übereinstimmte, was Angreifern ermöglichte, bis zu 64KB Serverspeicher pro Anfrage zu lesen. Angreifer nutzten diesen Fehler aus, um private Schlüssel, Session-Cookies und Passwörter von Millionen von Servern zu stehlen. Zum Zeitpunkt der Offenlegung waren etwa 17% der sicheren Webserver anfällig, und Angriffe dauerten jahrelang an, einschließlich Vorfälle bei Community Health Systems und der kanadischen Steuerbehörde.

https://www.csoonline.com/article/562859/the-heartbleed-bug-how-a-flaw-in-openssl-caused-a-security-crisis.html

BeautyChain Smart Contract Exploit (BeautyChain, 2018)

Eine Integer-Overflow-Schwachstelle im BeautyChain (BEC) Ethereum Smart Contract ermöglichte Angreifern, Sicherheitsprüfungen zu umgehen und eine astronomische Anzahl von Token aus dem Nichts zu generieren. Die Schwachstelle existierte in der Token-Transfer-Funktion, wo die Multiplikation größer Werte das Ergebnis zu einer kleinen Zahl umwickeln ließ, Validierungsprüfungen passierte, während massive Beträge auf Angreifer-Wallets gutgeschrieben wurden. Dieser Vorfall führte zum Verlust des gesamten Token-Werts des Vertrags und führte dazu, dass der Token von Börsen genommen wurde. Der Angriff verdeutlichte, wie Integer-Behandlungsprobleme in Blockchain-Anwendungen unmittelbare und irreversible finanzielle Konsequenzen haben können.

https://www.comparitech.com/blog/information-security/integer-overflow-attack/

Tools zum Testen/Ausnutzen

Clang Static Analyzer — Statisches Analysetool, das Integer-Konvertierungsprobleme, Vorzeichenfehler und potentielle Overflow-Bedingungen in C/C++-Code erkennt.
Cppcheck — Open-Source-Tool für statische Analyse für C/C++, das Integer-Coercion-Fehler, Trunkierungsprobleme und Vorzeichenkonvertierungsprobleme identifiziert.
PVS-Studio — Kommerzieller statischer Analysator, der eine breite Palette von Integer-bezogenen Schwachstellen erkennt, einschließlich Coercion-Fehler, Overflow und unsachgemäße Typkonvertierungen.

CVE-Beispiele

CVE-2022-2639 — Ein Integer-Coercion-Fehler im Linux-Kernel-openvswitch-Modul verhinderte ordnungsgemäße Fehlererkennung und ermöglichte eine nachfolgende Out-of-bounds-Write-Schwachstelle.
CVE-2021-30860 — Integer Overflow in Apples CoreGraphics-Bibliothek, ausgenutzt von NSO Groups FORCEDENTRY, um beliebige Code-Ausführung über bösartige PDFs zu erreichen.
CVE-2009-1385 — Integer Underflow im e1000-Treiber für Linux-Kernel ermöglichte Remote-Angreifern, Denial-of-Service über manipulierte Netzwerk-Frames zu verursachen.

Referenzen

MITRE Corporation. "CWE-192: Integer Coercion Error." Common Weakness Enumeration. https://cwe.mitre.org/data/definitions/192.html
Seacord, Robert C. "Secure Coding in C and C++, Second Edition." Addison-Wesley Professional, 2013.
CERT Coordination Center. "INT31-C. Ensure that integer conversions do not result in löst or misinterpreted data." SEI CERT C Coding Standard. https://wiki.sei.cmu.edu/confluence/display/c/INT31-C.+Ensure+that+integer+conversions+do+not+result+in+löst+or+misinterpreted+data
Citizen Lab. "FORCEDENTRY: NSO Group iMessage Zero-Click Exploit Captured in the Wild." September 2021. https://citizenlab.ca/2021/09/forcedentry-nso-group-imessage-zero-click-exploit-captured-in-the-wild/