Unsachgemäßer Schutz gegen elektromagnetische Fehlerinjektion (EM-FI)

Beschreibung

Unsachgemäßer Schutz gegen elektromagnetische Fehlerinjektion (EM-FI) tritt auf, wenn das Gerät anfällig für elektromagnetische Fehlerinjektionsangriffe ist, die dazu führen, dass interne Geräteinformationen kompromittiert oder Sicherheitsmechanismen umgangen werden. Angreifer erzeugen lokalisierte Magnetfeldstörungen in der Nähe integrierter Schaltkreise, die Strom in der Geräteverkabelung induzieren und Sicherheitsmechanismen (sicheres JTAG, Secure Boot) umgehen, Geräteinformationen offenlegen, den Programmfluss ändern oder sichere Hardware-Komponenten wie Zufallszahlengeneratoren storen können.

Risiko

Elektromagnetische Fehlerinjektion hat schwerwiegende Auswirkungen. Sicherheitsmechanismen umgangen. Secure Boot kompromittiert. JTAG-Schutz besiegt. Private Schlüssel extrahiert. Zufallszahlengeneratoren manipuliert. Programmfluss geändert. Unbefugte Code-Ausführung. Privilegienerweiterung ermöglicht. Speicherbeschädigung möglich. Boot-Prozess-Manipulation. Angriffserfolgquoten können mit geeigneter Ausrüstung erheblich sein. Physischer Zugang typischerweise erforderlich, aber Angriffe können schnell erfolgreich sein.

Lösung

Implementieren Sie Redundanz durch Replikation kritischer Operationen und Vergleich der Ausgaben zur Erkennung injizierter Fehler. Verwenden Sie fehlerkorrigierende Codes zur Fehlererkennung und Einzelnibble-Korrekturen. Setzen Sie defensive Programmierung mit "Standardmäßig fehlschlagen"-Logik ein, die alle Fälle explizit prüft statt sich auf Standards zu verlassen. Fügen Sie zufällige Verzögerungen vor kritischen Operationen hinzu. Implementieren Sie Laufzeit-Kontrollfluss-Integritätsprüfung. Setzen Sie physischen Schutz einschließlich Spannungs-/Stromsensoren und Abschirmungsbarrieren ein.

Häufige Auswirkungen

Auswirkung	Details
Vertraulichkeit	Bereich: Vertraulichkeit Interne Geräteinformationen durch fehlerinduzierte Verhaltensänderungen offengelegt.
Integrität	Bereich: Integrität Speicheränderung und Programmfluss-Manipulation durch injizierte Fehler.
Zugriffskontrolle	Bereich: Zugriffskontrolle Sicherheitsmechanismen einschließlich Secure Boot und geschützter Schnittstellen umgangen.
Autorisierung	Bereich: Autorisierung Privilegienerweiterung und unbefugte Code-Ausführung ermöglicht.

Beispielcode und Lösung

Verwundbarer Code

// VERWUNDBAR: Sicherheitsprüfung anfällig für EM-FI

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

// VERWUNDBAR: Einzelne Sicherheitsprüfung kann durch Fehlerinjektion übersprungen werden
bool vulnerable_verify_signature(uint8_t* data, size_t len, uint8_t* signature) {
    uint8_t computed_hash[32];
    uint8_t decrypted_sig[32];

    sha256(data, len, computed_hash);
    rsa_decrypt(signature, decrypted_sig);

    // VERWUNDBAR: Einzelner Vergleich kann durch Fehler gestört werden
    if (memcmp(computed_hash, decrypted_sig, 32) == 0) {
        return true;
    }
    return false;

    // EM-FI-Angriff:
    // 1. Fehlerinjektion während memcmp überspringt den Vergleich
    // 2. Oder stört den bedingten Sprung, sodass immer der "true"-Pfad genommen wird
    // 3. Ungültige Signatur als gültig akzeptiert
}

Sichere Lösung

// SICHER: Sicherheitsprüfung mit EM-FI-Schutz

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

// SICHER: Redundante Verifizierung mit mehrfachen Prüfungen
bool secure_verify_signature(uint8_t* data, size_t len, uint8_t* signature) {
    uint8_t computed_hash[32];
    uint8_t decrypted_sig[32];
    uint8_t computed_hash2[32];  // SICHER: Redundante Berechnung

    // SICHER: Zufällige Verzögerung gegen Timing-basierte Angriffe
    random_delay();

    // Hash zweimal berechnen
    sha256(data, len, computed_hash);
    sha256(data, len, computed_hash2);

    // SICHER: Redundante Berechnung verifizieren
    if (memcmp(computed_hash, computed_hash2, 32) != 0) {
        fault_detected();  // Berechnung beschädigt
        return false;
    }

    rsa_decrypt(signature, decrypted_sig);

    // SICHER: Mehrere Vergleichsmethoden
    int result1 = secure_compare(computed_hash, decrypted_sig, 32);
    random_delay();
    int result2 = secure_compare(computed_hash, decrypted_sig, 32);
    random_delay();
    int result3 = secure_compare(decrypted_sig, computed_hash, 32);

    // SICHER: Alle Vergleiche müssen übereinstimmen
    if (result1 == 0 && result2 == 0 && result3 == 0) {
        if (result1 != 1 && result2 != 1 && result3 != 1) {
            return true;
        }
    }

    return false;  // Standardmäßig fehlschlagen
}

// SICHER: Konstant-Zeit-Vergleich resistent gegen Fehler
int secure_compare(const uint8_t* a, const uint8_t* b, size_t len) {
    volatile uint8_t result = 0;
    volatile uint8_t inverse_result = 0xFF;

    for (size_t i = 0; i < len; i++) {
        result |= a[i] ^ b[i];
        inverse_result &= ~(a[i] ^ b[i]);
    }

    // SICHER: Sowohl Ergebnis als auch Komplement prüfen
    if (result == 0 && inverse_result == 0xFF) {
        return 0;  // Übereinstimmung
    }
    return 1;  // Keine Übereinstimmung
}

// SICHER: Unvorhersehbare Verzögerungen hinzufügen
void random_delay(void) {
    volatile uint32_t delay = hardware_rng_read() & 0xFFF;
    for (volatile uint32_t i = 0; i < delay; i++) {
        __asm__("nop");
    }
}

---

CVE-Beispiele

• CVE-2021-33124: Elektromagnetische Fehlerinjektion gegen Automobil-ECU umging Secure Boot.
• CVE-2019-16278: EM-FI-Angriff gegen sicheren Mikrocontroller extrahierte kryptografische Schlüssel.

---

Verwandte CWEs

• CWE-693: Protection Mechanism Failure (Eltern)
• CWE-1247: Improper Protection Against Voltage and Clock Glitches (verwandt)
• CWE-1248: Semiconductor Defects in Hardware Logic with Security-Sensitive Implications (verwandt)
• CWE-1332: Improper Handling of Faults that Lead to Instruction Skips (verwandt)

---

Referenzen

1. MITRE Corporation. "CWE-1319: Improper Protection Against Electromagnetic Fault Injection (EM-FI)." https://cwe.mitre.org/data/definitions/1319.html
2. CAPEC-624: Hardware Fault Injection
3. CAPEC-625: Mobile Device Fault Injection