Unzureichende physische Zugangskontrolle

Beschreibung

Unzureichende physische Zugangskontrolle tritt auf, wenn ein Produkt den Zugang zu bestimmten Informationen einschränkt, aber nicht ausreichend gegen unbefugte Akteure mit physischem Zugriff auf diese Bereiche schützt. Zugangsbeschränkte Produktbereiche können zugänglich werden, wenn physische Schutzmaßnahmen unzureichend sind. Die erforderliche Robustheit hängt vom Produkttyp ab. Die ordnungsgemäße Auswahl, Implementierung und Herstellung physischer Schutzmechanismen sind entscheidend für die gesamte Produktsicherheit.

Risiko

Unzureichender physischer Schutz hat schwerwiegende Sicherheitsauswirkungen. Debug-Schnittstellen können zugänglich sein. Kryptografische Schlüssel können extrahiert werden. Firmware kann modifiziert werden. Hardware kann mittels Reverse Engineering analysiert werden. Seitenkanalangriffe werden einfacher. Speicherinhalte können ausgelesen werden. Sicherheitskonfigurationen können verändert werden. Manipulationserkennungsmaßnahmen können umgangen werden. Gefälschte Geräte können hergestellt werden.

Lösung

Integrieren Sie Anti-Manipulationsmaßnahmen, die erkennen oder davor schutzen, wenn das Produkt manipuliert wurde. Die Schutzanforderungen hängen von akzeptablen Risikoniveaus ab. Etablieren Sie Methoden, um festzustellen, ob der Schutzmechanismus ausreicht, um unbefugten Zugriff zu verhindern. Stellen Sie sicher, dass alle Schutzmechanismen zum Zeitpunkt der Herstellung und Auslieferung vollständig aktiviert sind.

Häufige Auswirkungen

Auswirkung	Details
Vertraulichkeit	Umfang: Vertraulichkeit Speicher lesen - Physischer Zugriff kann die Extraktion sensibler Daten einschließlich kryptografischer Schlüssel ermöglichen.
Integrität	Umfang: Integrität Speicher modifizieren - Physischer Zugriff kann die Modifikation von Firmware oder Sicherheitskonfigurationen ermöglichen.
Zugriffskontrolle	Umfang: Zugriffskontrolle Schutzmechanismus umgehen - Umgangene physische Schutzmaßnahmen können Debug-Schnittstellen und andere Angriffsflächen freilegen.

Beispielcode und Lösung

Verwundbarer Code

// VERWUNDBAR: Debug-Schnittstelle ohne physischen Zugriffsschutz

module vulnerable_debug_controller (
    input wire clk,
    input wire reset_n,
    // VERWUNDBAR: Debug-Signale direkt an Pins freigelegt
    input wire tck,      // JTAG-Takt - auf der Platine freigelegt
    input wire tms,      // JTAG-Modusauswahl
    input wire tdi,      // JTAG-Daten rein
    output wire tdo,     // JTAG-Daten raus
    // Interner Debug-Zugriff
    output reg [31:0] debug_addr,
    output reg [31:0] debug_write_data,
    output reg debug_write,
    output reg debug_read,
    input wire [31:0] debug_read_data
);

    // VERWUNDBAR: JTAG immer aktiviert
    // Keine Fuse- oder Secure-Boot-Prüfung
    // Angreifer mit physischem Zugang kann JTAG nutzen

    reg [3:0] jtag_state;
    reg [31:0] shift_register;

    // JTAG-Zustandsmaschine
    always @(posedge tck or negedge reset_n) begin
        if (!reset_n) begin
            jtag_state <= 4'h0;  // Test-Logic-Reset
        end
        else begin
            // Vollständige JTAG-Implementierung
            // VERWUNDBAR: Keine Authentifizierung erforderlich
            // VERWUNDBAR: Keine physische Manipulationserkennung
        end
    end

    // VERWUNDBAR: Debug gewährt vollen Speicherzugriff
    always @(posedge clk) begin
        if (jtag_command_valid) begin
            // Angreifer kann jeden Speicher lesen
            debug_addr <= jtag_address;
            debug_read <= jtag_read_cmd;
            debug_write <= jtag_write_cmd;
            debug_write_data <= jtag_data;
        end
    end

endmodule

// VERWUNDBAR: Schlüsselspeicher ohne physischen Schutz
module vulnerable_key_storage (
    input wire clk,
    input wire reset_n,
    input wire [7:0] addr,
    output reg [31:0] read_data
);

    // VERWUNDBAR: Schlüssel im Klartext im SRAM gespeichert
    // Physisches Probing kann Inhalte lesen
    reg [31:0] key_memory [0:255];

    // VERWUNDBAR: Keine Manipulationserkennung
    // VERWUNDBAR: Keine Speicherverschlüsselung
    // VERWUNDBAR: Kein aktives Löschen bei Manipulation

    always @(posedge clk) begin
        read_data <= key_memory[addr];
    end

endmodule

// VERWUNDBAR: Software ohne physische Manipulationsreaktion

#include <stdint.h>

// VERWUNDBAR: Schlüssel in ungeschütztem Speicher
static uint8_t encryption_key[32] = {
    0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
    0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10,
    // ... weitere Schlüsselbytes
};

void vulnerable_init(void) {
    // VERWUNDBAR: Keine Prüfung auf Manipulationsereignisse
    // VERWUNDBAR: Debug-Schnittstelle nicht deaktiviert

    // Schlüssel aus ungeschütztem Flash laden
    load_key_from_flash(encryption_key);

    // Normalbetrieb starten
    // Angreifer mit physischem Zugang kann:
    // 1. Speicherbus abhören
    // 2. Debug-Schnittstelle nutzen
    // 3. Flash-Inhalte modifizieren
}

// VERWUNDBAR: Keine physischen Sicherheitsprüfungen
int vulnerable_authenticate(const char* password) {
    // Einfacher Vergleich - keine Anti-Probing-Maßnahmen
    return (strcmp(password, stored_password) == 0);
}

Sichere Lösung

// SICHER: Debug-Schnittstelle mit physischem Zugriffsschutz

module secure_debug_controller (
    input wire clk,
    input wire reset_n,
    // Debug-Signale
    input wire tck,
    input wire tms,
    input wire tdi,
    output wire tdo,
    // Physische Sicherheitseingänge
    input wire tamper_detected,      // Physischer Manipulationssensor
    input wire case_open,            // Gehäuseöffnungssensor
    input wire voltage_anomaly,      // Spannungsstörungserkennung
    input wire debug_auth_fuse,      // Fuse: 1=Debug erfordert Authentifizierung
    input wire debug_disable_fuse,   // Fuse: 1=Debug dauerhaft deaktiviert
    // Authentifizierung
    input wire [127:0] debug_challenge,
    input wire [127:0] debug_response,
    input wire debug_auth_request,
    // Interner Debug-Zugriff
    output reg [31:0] debug_addr,
    output reg [31:0] debug_write_data,
    output reg debug_write,
    output reg debug_read,
    input wire [31:0] debug_read_data,
    // Status
    output reg tamper_lockout,
    output reg debug_enabled
);

    // SICHER: Debug-Zustand
    reg debug_authenticated;
    reg [3:0] auth_failures;

    // SICHER: Physische Manipulationsreaktion
    always @(posedge clk or negedge reset_n) begin
        if (!reset_n) begin
            tamper_lockout <= 1'b0;
            debug_enabled <= 1'b0;
            debug_authenticated <= 1'b0;
            auth_failures <= 4'h0;
        end
        else begin
            // SICHER: Sofortige Sperrung bei physischer Manipulation
            if (tamper_detected || case_open || voltage_anomaly) begin
                tamper_lockout <= 1'b1;
                debug_enabled <= 1'b0;
                debug_authenticated <= 1'b0;
                // Schlüssellöschung auslösen
            end

            // SICHER: Debug-Deaktivierungs-Fuse prüfen
            if (debug_disable_fuse) begin
                debug_enabled <= 1'b0;
            end
            // SICHER: Debug erfordert Authentifizierung wenn Fuse gesetzt
            else if (debug_auth_fuse) begin
                if (debug_auth_request && !tamper_lockout) begin
                    if (verify_debug_auth(debug_challenge, debug_response)) begin
                        debug_authenticated <= 1'b1;
                        debug_enabled <= 1'b1;
                        auth_failures <= 4'h0;
                    end
                    else begin
                        auth_failures <= auth_failures + 1;
                        if (auth_failures >= 4'd10) begin
                            tamper_lockout <= 1'b1;  // Zu viele Fehlversuche
                        end
                    end
                end
            end
        end
    end

    // SICHER: Debug-Zugriff durch Authentifizierung und Manipulationsstatus geschützt
    wire debug_access_allowed = debug_enabled && debug_authenticated && !tamper_lockout;

    always @(posedge clk) begin
        if (debug_access_allowed && jtag_command_valid) begin
            debug_addr <= jtag_address;
            debug_read <= jtag_read_cmd;
            debug_write <= jtag_write_cmd;
            debug_write_data <= jtag_data;
        end
        else begin
            debug_read <= 1'b0;
            debug_write <= 1'b0;
        end
    end

endmodule

// SICHER: Schlüsselspeicher mit physischem Schutz
module secure_key_storage (
    input wire clk,
    input wire reset_n,
    input wire [7:0] addr,
    input wire tamper_detected,
    input wire case_open,
    output reg [31:0] read_data,
    output reg key_valid
);

    // SICHER: Verschlüsselter Schlüsselspeicher
    reg [31:0] encrypted_key_memory [0:255];
    reg [127:0] memory_encryption_key;

    // SICHER: Manipulationsreaktion
    always @(posedge clk or negedge reset_n) begin
        if (!reset_n) begin
            key_valid <= 1'b1;
        end
        else if (tamper_detected || case_open) begin
            // SICHER: Alle Schlüssel bei Manipulation nullen
            integer i;
            for (i = 0; i < 256; i = i + 1) begin
                encrypted_key_memory[i] <= 32'h0;
            end
            memory_encryption_key <= 128'h0;
            key_valid <= 1'b0;
        end
    end

    // SICHER: Entschlüsselten Schlüssel nur ohne Manipulation zurückgeben
    always @(posedge clk) begin
        if (key_valid && !tamper_detected) begin
            read_data <= decrypt(encrypted_key_memory[addr], memory_encryption_key);
        end
        else begin
            read_data <= 32'h0;
        end
    end

endmodule

// SICHER: Aktive Mesh-Manipulationserkennung
module tamper_mesh (
    input wire clk,
    input wire reset_n,
    input wire [31:0] mesh_sense,  // Mesh-Draht-Kontinuitätssensoren
    output reg tamper_detected
);

    // SICHER: Aktive Mesh-Überwachung
    reg [31:0] expected_pattern;
    reg [31:0] actual_pattern;

    always @(posedge clk or negedge reset_n) begin
        if (!reset_n) begin
            tamper_detected <= 1'b0;
            expected_pattern <= 32'hA5A5A5A5;
        end
        else begin
            actual_pattern <= mesh_sense;

            // SICHER: Durchtrennung oder Abhörung von Mesh-Drähten erkennen
            if (actual_pattern != expected_pattern) begin
                tamper_detected <= 1'b1;
            end

            // Muster rotieren um ausgefeilte Angriffe zu erkennen
            expected_pattern <= {expected_pattern[30:0], expected_pattern[31]};
        end
    end

endmodule

// SICHER: Software mit physischer Manipulationsreaktion

#include <stdint.h>

// SICHER: Schlüssel durch Secure Element geschützt
// Nicht im Hauptspeicher gespeichert

void secure_init(void) {
    // SICHER: Manipulationsstatus vor allen Operationen prüfen
    if (check_tamper_flags()) {
        enter_lockout_mode();
        return;
    }

    // SICHER: Boot-Integrität verifizieren
    if (!verify_secure_boot()) {
        zeroize_all_keys();
        enter_lockout_mode();
        return;
    }

    // SICHER: Debug in Produktion deaktivieren
    if (is_production_device()) {
        disable_debug_interface();
    }

    // SICHER: Manipulationsüberwachung aktivieren
    enable_tamper_sensors();
    register_tamper_interrupt(tamper_handler);

    // Normalbetrieb
}

// SICHER: Manipulations-Interrupt-Handler
void tamper_handler(void) {
    // Sofort alle sensiblen Daten löschen
    zeroize_all_keys();
    zeroize_sensitive_memory();

    // Krypto-Operationen deaktivieren
    disable_crypto_engine();

    // Ereignis protokollieren (in geschütztem Speicher)
    log_tamper_event();

    // Sperrmodus aktivieren - keine Wiederherstellung ohne Werksreset
    enter_lockout_mode();
}

// SICHER: Anti-Probing-Maßnahmen bei der Authentifizierung
int secure_authenticate(const char* password) {
    // Zufällige Verzögerung hinzufügen um Timing-Analyse zu verhindern
    random_delay();

    // Zeitkonstanten Vergleich verwenden
    int result = constant_time_compare(password, stored_password);

    // Rauschen zum Stromverbrauch hinzufügen
    dummy_crypto_operation();

    return result;
}

// SICHER: Periodische Sicherheitsprüfungen
void periodic_security_check(void) {
    // Mesh-Integrität prüfen
    if (!verify_mesh_integrity()) {
        tamper_handler();
    }

    // Spannungspegel prüfen
    if (!verify_voltage_levels()) {
        tamper_handler();
    }

    // Speicherintegritat verifizieren
    if (!verify_memory_checksums()) {
        tamper_handler();
    }
}

---

CVE-Beispiele

Schwachstellen durch physischen Zugriff wurden in verschiedenen Geräten ausgenutzt, darunter Zahlungsterminals, Secure Elements und IoT-Geräte, bei denen Angreifer Probing, Fault Injection oder Debug-Schnittstellenzugriff nutzten, um Geheimnisse zu extrahieren.

---

Verwandte CWEs

• CWE-284: Unzureichende Zugriffskontrolle (übergeordnet)
• CWE-1243: Sensible nichtflüchtige Informationen nicht während des Debuggens geschützt (untergeordnet)
• CWE-1191: On-Chip Debug-/Test-Schnittstelle mit unzureichender Zugriffskontrolle (verwandt)
• CAPEC-401: Physisches Hacking von Hardware (Angriffsmuster)

---

Referenzen

1. MITRE Corporation. "CWE-1263: Improper Physical Access Control." https://cwe.mitre.org/data/definitions/1263.html
2. Common Criteria. "Physical Security Requirements"
3. FIPS 140-3. "Security Requirements for Cryptographic Modules"