Unsachgemäße Validierung von Integritätsprüfwerten

Beschreibung

Unsachgemäße Validierung von Integritätsprüfwerten ist eine Schwachstelle, die auftritt, wenn ein Produkt Integritätsprüfwerte wie Prüfsummen, Hashes oder Nachrichtenauthentifizierungscodes (MACs) in empfangenen Daten nicht oder falsch validiert. Während die Daten Integritätsprüfwerte enthalten können, überspringt die empfangende Anwendung entweder den Verifizierungsschritt, führt die Verifizierung falsch durch, verwendet schwache Algorithmen, die anfällig für Kollisionsangriffe sind, oder ignoriert Verifizierungsfehler. Dies unterscheidet sich von fehlender Integritätsunterstützung (CWE-353), da das Protokoll oder Format Integritätsmechanismen enthält, die Implementierung diese aber nicht ordnungsgemäß nutzt. Eine unsachgemäße Verifizierung der berechneten Prüfsumme gegen die empfangene Prüfsumme kann Angreifern ermöglichen, bösartige Daten einzuschleusen, den Anwendungszustand zu korrumpieren oder Malware über scheinbar legitime Kanäle zu verteilen.

Risiko

Unsachgemäße Integritätsvalidierung ermöglicht die Verarbeitung korrupter oder böswillig modifizierter Daten als wären sie gültig, was schwerwiegende Sicherheitsrisiken über mehrere Angriffsvektoren hinweg schafft. Angreifer können mit Prüfsumme versehene Daten modifizieren in dem Wissen, dass die empfangende Anwendung die Prüfsumme nicht ordnungsgemäß verifiziert, was Man-in-the-Middle-Angriffe, Supply-Chain-Kompromittierungen und Malware-Verteilung ermöglicht. Dateiformate mit Integritätsfeldern, die nicht ordnungsgemäß geprüft werden, ermöglichen unentdeckte bösartige Modifikationen. Das Risiko ist besonders schwerwiegend, weil die Anwesenheit von Prüfsummenfeldern ein falsches Sicherheitsgefühl erzeugt, während sie keinen tatsächlichen Schutz bieten. In Software-Distributionsszenarien können böswillige Akteure Programme ändern, bevor sie Endbenutzer erreichen, während sie gültig erscheinende Prüfsummen beibehalten, besonders wenn schwache Algorithmen wie MD5 verwendet werden. Die Flame-Malware von 2012 demonstrierte, wie nationalstaatliche Akteure MD5-Kollisionsschwachstellen ausnutzen könnten, um Microsoft-Zertifikate zu fälschen und Malware über Windows Update zu verteilen. Zusätzlich verstarken menschliche Faktoren das Risiko — Studien zeigen, dass mehr als ein Drittel der Benutzer Prüfsummen-Nichtübereinstimmungen nicht erkennen, selbst wenn sie explizit gebeten werden, diese zu verifizieren.

Lösung

Implementieren Sie ordnungsgemäße Integritätsprüfvalidierung genau wie durch das Protokoll oder die Formatspezifikation vorgegeben. Berechnen Sie die erwartete Prüfsumme und vergleichen Sie diese mit dem empfangenen Wert unter Verwendung von Konstant-Zeit-Vergleichsfunktionen, um Timing-Angriffe zu verhindern. Lehnen Sie Daten sofort ab, wenn Integritätsprüfungen fehlschlagen — verarbeiten Sie niemals trotz Verifizierungsfehlern weiter. Verwenden Sie kryptografisch starke Hash-Algorithmen wie SHA-256 oder SHA-3 anstelle von veralteten Algorithmen wie MD5 oder SHA-1, die anfällig für Kollisionsangriffe sind. Für kritische Anwendungen kombinieren Sie Prüfsummen mit digitalen Signaturen, um sowohl Integrität als auch Authentizität zu gewährleisten. Implementieren Sie Datei-Integritätsüberwachungslösungen (FIM), die kritische Dateien kontinuierlich gegen bekannte gute Baselines validieren. In Software-Distributionspipelines validieren Sie Code-Herkunft in jeder Phase statt nur am Ende des Build-Prozesses zu signieren. Erwägen Sie die Implementierung von Zertifikat-Pinning und sicheren Update-Kanälen mit mehreren Verifizierungsebenen für Software-Updates.

Häufige Auswirkungen

Auswirkung	Details
Integrität	Umfang: Integrität, Ändere Anwendungsdaten modifizieren - Das Überspringen oder unsachgemäße Durchführen von Integritätsprüfungen ermöglicht das Einschleusen bösartiger Daten aus ungültigen Quellen. Angreifer können übertragene Daten ändern, während sie schwache Prüfsummen neu berechnen, um sie anzupassen, was Erkennung nahezu unmöglich macht.
Integrität	Umfang: Integrität, Ändere Datenkorruption - Geparste und verwendete Daten können ohne ordnungsgemäße Verifizierung korrupt sein, was zu Anwendungsfehlfunktionen, Abstürzen oder Ausnutzung nachgelagerter Schwachstellen führt.
Nichtabstreitbarkeit	Umfang: Nichtabstreitbarkeit, Ändere Aktivitäten verbergen - Ohne ordnungsgemäße Integritätsverifizierung ist es unmöglich festzustellen, ob Daten nach der Übertragung verändert wurden, wodurch Prüfpfade eliminiert werden und Angreifer ihre Spuren verwischen können.

Beispielcode

Anfälliger Code

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

// ANFÄLLIG: Prüfsumme berechnet aber nie verifiziert
typedef struct {
    uint32_t checksum;
    uint32_t length;
    char data[1024];
} Message;

int process_message_no_verification(Message *msg) {
    // ANFÄLLIG: Prüfsummenfeld existiert wird aber komplett ignoriert
    // Angreifer kann Daten ohne Erkennung modifizieren
    printf("Verarbeite: %s\n", msg->data);
    return execute_command(msg->data);  // Gefährlich!
}

// ANFÄLLIG: Verifizierungsfehler wird ignoriert
int process_message_ignore_failure(Message *msg) {
    uint32_t calculated = calculate_crc32(msg->data, msg->length);

    if (calculated != msg->checksum) {
        // ANFÄLLIG: Gibt nur Warnung aus, verarbeitet trotzdem weiter
        printf("Warnung: Prüfsummen-Nichtübereinstimmung (erwartet %08x, erhalten %08x)\n",
               msg->checksum, calculated);
    }

    // ANFÄLLIG: Verarbeitet potenziell korrumpierte/bösartige Daten
    return execute_command(msg->data);
}

// ANFÄLLIG: Verwendet schwachen MD5-Algorithmus anfällig für Kollisionsangriffe
int verify_download_md5(const char *file_path, const char *expected_md5) {
    char calculated_md5[33];
    calculate_md5_hash(file_path, calculated_md5);

    // ANFÄLLIG: MD5 ist kryptografisch gebrochen
    // Angreifer können Dateien mit gleichem MD5 aber anderem Inhalt erstellen
    if (strcmp(calculated_md5, expected_md5) == 0) {
        return install_software(file_path);  // Könnte Malware sein!
    }
    return -1;
}

Korrigierter Code

#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <openssl/sha.h>
#include <openssl/crypto.h>

typedef struct {
    unsigned char checksum[32];  // SHA-256
    uint32_t length;
    char data[1024];
} SecureMessage;

// KORRIGIERT: Ordnungsgemäße Validierung mit starkem Algorithmus und Konstant-Zeit-Vergleich
int process_message_secure(SecureMessage *msg) {
    unsigned char calculated[32];

    // KORRIGIERT: Verwende starken kryptografischen Hash (SHA-256)
    SHA256((unsigned char*)msg->data, msg->length, calculated);

    // KORRIGIERT: Verwende Konstant-Zeit-Vergleich um Timing-Angriffe zu verhindern
    if (CRYPTO_memcmp(calculated, msg->checksum, 32) != 0) {
        // KORRIGIERT: Ablehnen und Fehler protokollieren - NICHT verarbeiten
        log_security_event("Integritätsprüfung fehlgeschlagen - Nachricht abgelehnt");
        return -1;
    }

    // Nur nach erfolgreicher Verifizierung verarbeiten
    return execute_command(msg->data);
}

// KORRIGIERT: Ordnungsgemäße Software-Verifizierung mit SHA-256 und Signatur
int verify_download_secure(const char *file_path,
                           const char *expected_sha256,
                           const char *signature,
                           EVP_PKEY *public_key) {
    unsigned char calculated_hash[32];
    unsigned char hash_hex[65];

    // KORRIGIERT: SHA-256 statt MD5 verwenden
    if (calculate_sha256_file(file_path, calculated_hash) != 0) {
        return -1;
    }

    // In Hex zur Vergleich konvertieren
    for (int i = 0; i < 32; i++) {
        sprintf((char*)&hash_hex[i*2], "%02x", calculated_hash[i]);
    }
    hash_hex[64] = '\0';

    // KORRIGIERT: Konstant-Zeit-Vergleich
    if (CRYPTO_memcmp(hash_hex, expected_sha256, 64) != 0) {
        log_security_event("SHA-256-Verifizierung fehlgeschlagen");
        return -1;
    }

    // KORRIGIERT: Zusätzlich digitale Signatur für Authentizität verifizieren
    if (!verify_signature(file_path, signature, public_key)) {
        log_security_event("Signaturverifizierung fehlgeschlagen");
        return -1;
    }

    // Sowohl Integrität als auch Authentizität verifiziert
    return install_software(file_path);
}

Der anfällige Code demonstriert drei häufige Fehler: Prüfsummen komplett ignorieren, Fehler protokollieren aber Ausführung fortsetzen, und kryptografisch gebrochene Algorithmen wie MD5 verwenden. Der korrigierte Code verwendet SHA-256 für starke Integritätsprüfung, nutzt Konstant-Zeit-Vergleich um Timing-Seitenkanalangriffe zu verhindern, und kombiniert Hash-Verifizierung mit digitalen Signaturen für Verteidigung in der Tiefe.

---

Ausgenutzt in der Praxis

Flame-Malware MD5-Kollisionsangriff (Microsoft/Naher Osten, 2012)

Die Flame-Malware, entdeckt 2012, repräsentiert die erste bekannte reale Ausnutzung von MD5-Kollisionsschwachstellen für Malware-Verteilung. Nationalstaatliche Angreifer fälschten ein Microsoft-Code-Signing-Zertifikat durch Ausnutzung des schwachen MD5-Hash-Algorithmus, der vom Microsoft Terminal Server Licensing Service verwendet wurde. Die Angreifer verwendeten einen zuvor unbekannten MD5 Chosen-Prefix-Kollisionsangriff, um ein betrügerisches Zertifikat zu erstellen, das von Microsoft zu stammen schien. Dieses gefälschte Zertifikat wurde dann verwendet, um Malware-Komponenten zu signieren, die über einen Man-in-the-Middle-Angriff gegen Windows Update verteilt wurden. Der Angriff wurde als "Weltklasse-Kryptoanalyse" erforderndbeschrieben und betraf Computer hauptsächlich in Ländern des Nahen Ostens für Cyber-Spionagezwecke.

• https://www.microsoft.com/en-us/msrc/blog/2012/06/flame-malware-collision-attack-explained
• https://blog.trailofbits.com/2012/06/11/analyzing-the-md5-collision-in-flame/

SolarWinds Supply-Chain-Angriff (SolarWinds/US-Regierung, 2020)

Der SolarWinds SUNBURST-Angriff kompromittierte Software-Integritätsverifizierung durch Einschleusen von bösartigem Code direkt in die Build-Pipeline vor der finalen Signierung. Russische nationalstaatliche Angreifer erlangten Zugang zur SolarWinds-Entwicklungsumgebung und fügten die SUNBURST-Backdoor in den Orion-Plattform-Quellcode ein. Da der bösartige Code vor Abschluss des Build-Prozesses eingeführt wurde, erschienen die final signierten DLLs legitim, da sie mit dem gültigen SolarWinds-Zertifikat digital signiert waren. Dieser Angriff demonstrierte, dass End-of-Pipeline-Signierung unzureichend ist — Integrität muss während des gesamten Entwicklungs- und Distributionsprozesses validiert werden. Der Angriff betraf etwa 18.000 Organisationen einschließlich US-Regierungsbehörden, mit geschätzten Kosten von 12 Millionen Dollar pro betroffener Firma.

• https://www.fortinet.com/resources/cyberglossary/solarwinds-cyber-attack
• https://unit42.paloaltonetworks.com/solarstörm-supply-chain-attack-timeline/

---

Tools zum Testen/Ausnutzen

• hashcat — Fortgeschrittenes Passwort-Wiederherstellungs- und Hash-Cracking-Tool, das Schwächen in verschiedenen Hash-Algorithmen demonstrieren und Kollisionsresistenz testen kann.

• HashClash — Framework für MD5- und SHA-1-Differential-Kollisionsangriffe, das praktische Ausnutzung schwacher Integritätsalgorithmen demonstriert.

• OSSEC — Open-Source Datei-Integritätsüberwachungs-Tool (FIM), das unautorisierte Änderungen an Dateien durch Vergleich von Prüfsummen gegen bekannte Baselines erkennt.

---

CVE-Beispiele

• CVE-2012-0158 — Microsoft Office-Schwachstelle, bei der Integritätsprüfungen umgangen wurden, was beliebige Codeausführung durch fehlerhafte Dokumente ermöglichte.

• CVE-2019-9169 — GNU C Library Heap-basierter Buffer-Overflow, bei dem unsachgemäße Validierung der Eingabeintegrität Speicherkorruption ermöglichte.

• CVE-2020-14882 — Oracle WebLogic Server Authentifizierungs-Bypass, bei dem Integritätsvalidierung von Session-Tokens unsachgemäß implementiert war.

---

Referenzen

1. MITRE Corporation. "CWE-354: Improper Validation of Integrity Check Value." https://cwe.mitre.org/data/definitions/354.html

2. Microsoft Security Response Center. "Flame malware collision attack explained." Juni 2012. https://www.microsoft.com/en-us/msrc/blog/2012/06/flame-malware-collision-attack-explained

3. NIST NCCoE. "Data Integrity: Detecting and Responding to Ransomware and Other Destructive Events." https://www.nccoe.nist.gov/data-integrity-detecting-and-responding-ransomware-and-other-destructive-events

4. OWASP. "Software and Data Integrity Failures." https://owasp.org/Top10/A08_2021-Software_and_Data_Integrity_Failures/