Interne Hardware- oder Debug-Modi erlauben Umgehung von Sperren

Beschreibung

Interne Hardware- oder Debug-Modi erlauben Umgehung von Sperren tritt auf, wenn der Systemkonfigurationsschutz während des Debug-Modus oder anderer interner Hardware-Modi umgangen werden kann. Gerätekonfigurationskontrollen werden typischerweise gesperrt, nachdem ein vertrauenswürdiges Firmware-Modul (z.B. BIOS/Bootloader) sie während des Power-Resets eingestellt hat. Dieses Sperrbit verhindert weitere Änderungen der Systemkonfiguration wie Speicherschutzeinstellungen. Wenn die Hardware jedoch Debug-Funktionen oder interne Modi unterstützt, können diese potenziell die Sperrschutzmaßnahmen umgehen und vermeintlich geschützte Konfiguration modifizieren.

Risiko

Debug-Modus-Sperrumgehung hat schwerwiegende Sicherheitsauswirkungen. Sicherheitssperren können durch Debug-Schnittstellen umgangen werden. Geschützte Konfiguration kann im Testmodus modifiziert werden. JTAG-Zugriff kann Sperrbits löschen. Scan-Modus kann Sperrumgehung ermöglichen. Fertigungstestmodi können ausnutzbar sein. Sicherheitsgrenzen können verletzt werden. Firmware-Integrität kann kompromittiert werden. Speicherschutz kann deaktiviert werden.

Lösung

Entfernen Sie Debug-/Scan-Modus-Umgehungen aus sicherheitskritischer Sperrlogik. Erfordern Sie Authentifizierung, bevor Debug-Modus Sperren umgehen kann. Implementieren Sie separate Debug-Register, die die Sicherheit nicht beeinflussen. Schließen Sie Debug-Signale von Sperr-Reset-Bedingungen aus. Deaktivieren Sie Debug-Sperrumgehung in Produktion per Fuse. Testen Sie Sperrverhalten über alle Debug- und Testmodi. Prüfen Sie alle Pfade, die den Sperrzustand beeinflussen können. Erwägen Sie separate Sperrmechanismen für Debug und Produktion.

Häufige Auswirkungen

Auswirkung	Details
Zugriffskontrolle	Bereich: Zugriffskontrolle Umgehung von Schutzmechanismen – Sperrbit-Schutzmaßnahmen können durch Debug- oder interne Modi umgangen werden, was Zugriff und Modifikation der Systemkonfiguration ermöglicht, selbst wenn die Sperre aktiv sein sollte.

Beispielcode und Lösung

Verwundbarer Code

// VERWUNDBAR: Debug-Modus umgeht Sperrschutz

module vulnerable_debug_lock (
    input wire clk,
    input wire reset_n,
    input wire [31:0] write_data,
    input wire write_enable,
    input wire set_lock,
    input wire scan_mode,
    input wire debug_unlocked,
    output reg [31:0] protected_config,
    output reg lock_status
);

    always @(posedge clk or negedge reset_n) begin
        if (!reset_n) begin
            protected_config <= 32'h0;
            lock_status <= 1'b0;
        end
        else begin
            if (set_lock) lock_status <= 1'b1;

            // VERWUNDBAR: Debug-Modi umgehen Sperre!
            if (write_enable && (!lock_status || scan_mode || debug_unlocked)) begin
                protected_config <= write_data;
            end
        end
    end

endmodule

Sichere Lösung

// SICHER: Debug-Modus kann Sicherheitssperren nicht umgehen

module secure_debug_lock (
    input wire clk,
    input wire reset_n,
    input wire [31:0] write_data,
    input wire write_enable,
    input wire set_lock,
    input wire scan_mode,
    input wire debug_unlocked,
    output reg [31:0] protected_config,
    output reg lock_status
);

    always @(posedge clk or negedge reset_n) begin
        if (!reset_n) begin
            protected_config <= 32'h0;
            lock_status <= 1'b0;
        end
        else begin
            if (set_lock) lock_status <= 1'b1;

            // SICHER: Sperre ist absolut – Debug-Modi umgehen sie nicht
            if (write_enable && !lock_status) begin
                protected_config <= write_data;
            end
            // scan_mode und debug_unlocked beeinflussen Sperre NICHT
        end
    end

endmodule

// SICHER: Firmware überprüft, dass Debug nicht Sperren umgehen kann

void secure_security_init(void) {
    configure_security_settings();
    set_security_lock();
    verify_debug_isolation();
}

bool verify_debug_isolation(void) {
    bool secure = true;

    if (can_enable_debug()) {
        enable_debug_mode();

        uint32_t before = *(volatile uint32_t*)PROTECTED_CONFIG;
        *(volatile uint32_t*)PROTECTED_CONFIG = ~before;
        uint32_t after = *(volatile uint32_t*)PROTECTED_CONFIG;

        if (after != before) {
            log_error("Debug-Modus umgeht Sicherheitssperre!");
            secure = false;
        }

        disable_debug_mode();
    }

    return secure;
}

---

CVE-Beispiele

Debug-Modus-Sperrumgehungs-Schwachstellen wurden in verschiedenen SoC-Designs gefunden, bei denen JTAG oder Scan-Modus Sicherheitssperren löschen oder umgehen könnten.

---

Verwandte CWEs

• CWE-667: Improper Locking (übergeordnet)
• CWE-1199: General Circuit and Logic Design Concerns (Kategoriemitglied)
• CWE-1207: Debug and Test Problems (Kategoriemitglied)
• CWE-1191: On-Chip Debug and Test Interface With Improper Access Control (verwandt)

---

Referenzen

1. MITRE Corporation. "CWE-1234: Hardware Internal or Debug Modes Allow Override of Locks." https://cwe.mitre.org/data/definitions/1234.html
2. REF-1375: OpenPiton SoC Register Lock-Implementierung
3. Richtlinien zur Debug-Sicherheit