Zurück zur Schwachstellen-Datenbank

Unsachgemäße Behandlung von Fehlern, die zu Befehlsübersprüngen führen

Beschreibung

Die unsachgemäße Behandlung von Fehlern, die zu Befehlsübersprüngen führen, tritt auf, wenn dem Gerät Schaltungen oder Sensoren fehlen oder diese fehlerhaft implementiert sind, die das Überspringen sicherheitskritischer CPU-Befehle erkennen und abmildern. Änderungen der Betriebsbedingungen können unerwartetes Hardwareverhalten einschließlich Befehlsübersprüngen verursachen. Sicherheitssensitive bedingte Verzweigungen (wie Passwortverifizierung), die als einzelne CPU-Befehle implementiert sind, werden verwundbar, wenn sie übersprungen werden, was möglicherweise die Verzweigungslogik umkehrt. Angreifer nutzen dies durch Fehlerinjektionstechniken aus, um Hardware-Betriebsbedingungen zu manipulieren.

Risiko

Befehlsübersprungs-Schwachstellen haben schwerwiegende Auswirkungen. Sicherheitsprüfungen umgangen. Authentifizierung besiegt. Bedingte Verzweigungen umgekehrt. Schutzmechanismen umgangen. Unbefugte Code-Ausführung. Beliebiger Speicherzugriff. Privilegienerweiterung ermöglicht. Kryptografische Operationen beschädigt. Hohe Wahrscheinlichkeit wenn Fehlerinjektionsschutz fehlt.

Lösung

Entwerfen Sie während der Architektur- und Entwurfsphase sichere Ausfallmechanismen für Eingabebedingungen außerhalb der Toleranz. Implementieren Sie redundante Operationen mit Mehrheitsentscheidung. Fügen Sie Fehlerkennungs-Canaries oder Überwachungsschaltungen hinzu. Stellen Sie sicher, dass die Schutzstärke die Erkennungslatenz berücksichtigt. Entwerfen Sie kritische Geheimlöschung bei Fehlererkennung.

Häufige Auswirkungen

AuswirkungDetails
ZugriffskontrolleBereich: Zugriffskontrolle

Schutzmechanismen durch Befehlsübersprung umgangen.
IntegritätBereich: Integrität

Ausführungslogik verändert, unbefugte Aktionen ermöglicht.
AuthentifizierungBereich: Authentifizierung

Authentifizierungsprüfungen übersprungen, unbefugter Zugriff ermöglicht.
VertraulichkeitBereich: Vertraulichkeit

Datenschutz durch übersprungene Sicherheitsprüfungen umgangen.

Beispielcode und Lösung

Verwundbarer Code

// VERWUNDBAR: Einzelbefehl-Sicherheitsprüfung

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

// VERWUNDBAR: Einzelner Vergleichsbefehl
bool vulnerable_verify_password(const char* input, const char* stored) {
    // VERWUNDBAR: strcmp kompiliert zu einzelnem Vergleich
    // Fehlerinjektion kann dies überspringen
    if (strcmp(input, stored) != 0) {
        return false;  // Kann übersprungen werden!
    }
    return true;
}

// VERWUNDBAR: Secure Boot mit einzelnem Prüfpunkt
void vulnerable_secure_boot(void) {
    uint8_t* firmware = load_firmware();
    uint8_t* signature = load_signature();

    // VERWUNDBAR: Einzelne bedingte Verzweigung
    if (!verify_signature(firmware, signature)) {
        halt_system();  // Kann übersprungen werden!
    }
    execute_firmware(firmware);
}

Sichere Lösung

// SICHER: Fehlerresistente Sicherheitsprüfungen

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

// SICHER: Redundante Verifizierung mit mehrfachen Prüfungen
bool secure_verify_password(const char* input, const char* stored) {
    volatile int result1, result2, result3;

    // SICHER: Mehrere redundante Vergleiche
    result1 = strcmp(input, stored);
    result2 = strcmp(input, stored);
    result3 = strcmp(input, stored);

    // SICHER: Mehrheitsentscheidung
    int match_count = 0;
    if (result1 == 0) match_count++;
    if (result2 == 0) match_count++;
    if (result3 == 0) match_count++;

    // SICHER: Alle drei müssen übereinstimmen
    if (match_count != 3 && match_count != 0) {
        fault_detected();  // Fehler erkannt - Ergebnisse inkonsistent
        return false;
    }
    return (match_count == 3);
}

// SICHER: Secure Boot mit redundanten Prüfungen
void secure_boot_protected(void) {
    uint8_t* firmware = load_firmware();
    uint8_t* signature = load_signature();

    volatile bool pass1 = verify_signature(firmware, signature);
    volatile bool pass2 = verify_signature(firmware, signature);
    volatile bool pass3 = verify_signature(firmware, signature);

    // SICHER: Fluss-Integritätsvariable
    volatile uint32_t flow_check = 0;
    if (!pass1) flow_check |= 0x01;
    if (!pass2) flow_check |= 0x02;
    if (!pass3) flow_check |= 0x04;

    // SICHER: Verifizieren, dass alle Prüfungen liefen und übereinstimmten
    if (flow_check != 0x00 && flow_check != 0x07) {
        fault_detected();
        secure_halt();
    }
    if (flow_check == 0x07) secure_halt();

    // SICHER: Zusätzliche Canary-Prüfung vor Ausführung
    if (flow_check != 0x00 || !pass1 || !pass2 || !pass3) secure_halt();

    execute_firmware(firmware);
}

CVE-Beispiele

  • CVE-2019-15894: Fehlerinjektion umging den Verifizierungsmodus und ermöglichte beliebige Code-Ausführung.
  • CVE-2020-0069: Befehlsübersprung ermöglichte Secure-Boot-Umgehung in MediaTek-Prozessoren.

Verwandte CWEs

  • CWE-1384: Improper Handling of Physical or Environmental Conditions (Eltern)
  • CWE-1247: Improper Protection Against Voltage and Clock Glitches (verwandt)
  • CWE-1206: Power, Clock, Thermal, and Reset Concerns (Kategorie)

Referenzen

  1. MITRE Corporation. "CWE-1332: Improper Handling of Faults that Lead to Instruction Skips." https://cwe.mitre.org/data/definitions/1332.html
  2. Riscure. "Fault Injection Attacks and Countermeasures"
  3. ARM. "Security Considerations for Cortex-M Processors"