Fehlerhafte Register-Standardwerte oder Modulparameter

Beschreibung

Fehlerhafte Register-Standardwerte oder Modulparameter treten auf, wenn Hardware-Designparameter oder Register-Standardwerte während des Designs falsch gesetzt werden. System-on-Chip (SoC) Hardware-Designs haben IP-Module mit Parametern und Registern, die Daten speichern oder Operationen steuern. Diese Parameter und Standardwerte werden initial während des Designs festgelegt. Wenn sicherheitskritische Parameter oder Standardwerte falsch gesetzt sind -- sei es durch Implementierungsfehler oder Spezifikationen, die nicht alle Systemzustände berücksichtigen -- kann die Hardware ausgenutzt werden. Parameter und Standardwerte sollten sowohl im normalen Betrieb als auch in Debug-Modi sicher sein.

Risiko

Fehlerhafte Register-Standardwerte haben schwerwiegende Sicherheitsauswirkungen. Debug-Schnittstellen können standardmäßig aktiviert sein. Sicherheitsfunktionen können initial deaktiviert sein. Zugriffskontrollen können standardmäßig permissiv sein. Kryptographische Funktionen können schwache Standardschlüssel verwenden. Schutzmechanismen aktivieren sich möglicherweise nicht automatisch. Boot-Sicherheit kann durch Standardwerte umgangen werden. Privilegierungsstufen können standardmäßig erhöht sein. Speicherbereiche können standardmäßig ungeschützt sein.

Lösung

Stellen Sie sicher, dass alle sicherheitskritischen Parameter den sichersten Zustand als Standard haben. Überprüfen Sie, dass Standardwerte die Sicherheit sowohl im normalen als auch im Debug-Modus durchsetzen. Dokumentieren Sie alle sicherheitsrelevanten Standardwerte. Implementieren Sie Secure-by-Default-Designprinzipien. Überprüfen Sie Standardwerte bei Sicherheitsaudits. Testen Sie, dass Standardwerte vor der Firmware-Initialisierung nicht ausgenutzt werden können. Verwenden Sie Hardware zur Durchsetzung sicherer Standardwerte, die nicht überschrieben werden können. Erwägen Sie die Verwendung von Fuses für permanente Sicherheitsstandardwerte. Implementieren Sie Defense in Depth mit mehreren Standardschutzmaßnahmen.

Häufige Auswirkungen

Auswirkung	Details
Vertraulichkeit, Integrität, Verfügbarkeit	Bereich: Alle Variiert je nach Kontext – Die Auswirkung hängt davon ab, welche Parameter oder Register fehlerhafte Standardwerte haben. Sicherheitsumgehung, Informationsoffenlegung oder Rechteeskalation sind möglich.
Zugriffskontrolle	Bereich: Zugriffskontrolle Umgehung von Schutzmechanismen – Fehlerhafte Standardwerte können Schutzmechanismen deaktiviert lassen.

Beispielcode und Lösung

Verwundbarer Code

// VERWUNDBAR: Sicherheitsfunktionen standardmäßig deaktiviert

module vulnerable_security_controller #(
    // VERWUNDBAR: Debug standardmäßig aktiviert
    parameter DEBUG_ENABLED = 1,
    // VERWUNDBAR: Sicherheitsprüfungen standardmäßig deaktiviert
    parameter SECURITY_CHECK_ENABLED = 0,
    // VERWUNDBAR: Permissive Zugriffskontrolle als Standard
    parameter DEFAULT_ACCESS_LEVEL = 3'b111  // Voller Zugriff
) (
    input wire clk,
    input wire reset_n,
    input wire [31:0] access_request,
    output reg access_granted
);

    reg debug_mode;
    reg security_enabled;
    reg [2:0] access_level;

    always @(posedge clk or negedge reset_n) begin
        if (!reset_n) begin
            // Standardwerte sind unsicher!
            debug_mode <= DEBUG_ENABLED;        // Debug standardmäßig AN
            security_enabled <= SECURITY_CHECK_ENABLED;  // Sicherheit AUS
            access_level <= DEFAULT_ACCESS_LEVEL;  // Voller Zugriff
        end
    end

    // Sicherheitsprüfungen können durch Standardwerte umgangen werden
    always @(*) begin
        if (debug_mode || !security_enabled) begin
            access_granted = 1'b1;  // Immer Zugriff gewähren
        end else begin
            access_granted = check_access(access_request, access_level);
        end
    end

endmodule

// VERWUNDBAR: Krypto-Modul mit schwachem Standardschlüssel
module vulnerable_crypto_engine #(
    // VERWUNDBAR: Standardschlüssel ist nur Nullen
    parameter [127:0] DEFAULT_KEY = 128'h0
) (
    input wire clk,
    input wire reset_n,
    input wire [127:0] plaintext,
    input wire [127:0] key_input,
    input wire key_valid,
    output reg [127:0] ciphertext
);

    reg [127:0] encryption_key;

    always @(posedge clk or negedge reset_n) begin
        if (!reset_n) begin
            // VERWUNDBAR: Schwacher Standardschlüssel
            encryption_key <= DEFAULT_KEY;  // Nur Nullen!
        end
        else if (key_valid) begin
            encryption_key <= key_input;
        end
    end

    // Wenn Firmware keinen Schlüssel setzt, wird schwacher Standard verwendet
    always @(posedge clk) begin
        ciphertext <= encrypt_aes(plaintext, encryption_key);
    end

endmodule

// VERWUNDBAR: Speicherschutz mit permissiven Standardwerten
module vulnerable_memory_controller (
    input wire clk,
    input wire reset_n,
    input wire [31:0] address,
    input wire read_enable,
    input wire write_enable,
    output reg [31:0] data_out,
    output reg access_error
);

    // Schutzkonfiguration
    reg [31:0] protected_region_start;
    reg [31:0] protected_region_end;
    reg protection_enabled;

    always @(posedge clk or negedge reset_n) begin
        if (!reset_n) begin
            // VERWUNDBAR: Schutz standardmäßig deaktiviert
            protection_enabled <= 1'b0;
            // VERWUNDBAR: Kein Bereich standardmäßig geschützt
            protected_region_start <= 32'hFFFFFFFF;
            protected_region_end <= 32'h00000000;
        end
    end

    // Gesamter Speicher zugänglich, bis Firmware Schutz aktiviert

endmodule

// VERWUNDBAR: Firmware verlässt sich auf unsichere Hardware-Standardwerte

void vulnerable_init(void) {
    // Nimmt an, dass Hardware-Standardwerte sicher sind – möglicherweise nicht!

    // Hardware-Debug ist standardmäßig AN
    // Angreifer kann ausnutzen, bevor dies ausgeführt wird

    // Irgendwann Debug deaktivieren...
    disable_debug_interface();  // Zu spät, wenn Angreifer bereits gehandelt hat

    // Irgendwann Sicherheit aktivieren...
    enable_security_checks();   // Sicherheit war während des Boots aus!
}

// VERWUNDBAR: Kryptographischen Schlüssel nicht setzen
void vulnerable_crypto_init(void) {
    // VERWUNDBAR: Nimmt an, dass Standardschlüssel sicher ist
    // Hardware hat Nur-Null-Standardschlüssel!

    // Verschlüsselung mit Standard-(schwachem) Schlüssel starten
    start_encryption();
}

Sichere Lösung

// SICHER: Sicherheitsfunktionen standardmäßig aktiviert

module secure_security_controller #(
    // Debug standardmäßig deaktiviert
    parameter DEBUG_ENABLED = 0,
    // Sicherheitsprüfungen standardmäßig aktiviert
    parameter SECURITY_CHECK_ENABLED = 1,
    // Restriktive Zugriffskontrolle als Standard
    parameter DEFAULT_ACCESS_LEVEL = 3'b000  // Kein Zugriff
) (
    input wire clk,
    input wire reset_n,
    input wire [31:0] access_request,
    input wire privileged_mode,
    output reg access_granted
);

    reg debug_mode;
    reg security_enabled;
    reg [2:0] access_level;
    reg initialized;

    always @(posedge clk or negedge reset_n) begin
        if (!reset_n) begin
            // Sichere Standardwerte
            debug_mode <= DEBUG_ENABLED;        // Debug AUS
            security_enabled <= SECURITY_CHECK_ENABLED;  // Sicherheit AN
            access_level <= DEFAULT_ACCESS_LEVEL;  // Minimaler Zugriff
            initialized <= 1'b0;
        end
        else begin
            // Initialisierung verfolgen
            if (configure_complete) begin
                initialized <= 1'b1;
            end
        end
    end

    // Sicherheit auch vor der Initialisierung durchgesetzt
    always @(*) begin
        if (!initialized) begin
            // Vor Init: sehr restriktiv
            access_granted = privileged_mode;  // Nur privilegierter Boot-Code
        end
        else if (security_enabled) begin
            access_granted = check_access(access_request, access_level);
        end
        else begin
            // Sicherheit deaktivieren erfordert explizite privilegierte Aktion
            access_granted = 1'b1;
        end
    end

endmodule

// SICHER: Krypto-Modul mit sicherer Standard-Behandlung
module secure_crypto_engine (
    input wire clk,
    input wire reset_n,
    input wire [127:0] plaintext,
    input wire [127:0] key_input,
    input wire key_valid,
    output reg [127:0] ciphertext,
    output reg key_set,
    output reg crypto_ready
);

    reg [127:0] encryption_key;

    always @(posedge clk or negedge reset_n) begin
        if (!reset_n) begin
            // Kein Standardschlüssel – muss explizit gesetzt werden
            encryption_key <= 128'h0;
            key_set <= 1'b0;
            crypto_ready <= 1'b0;
        end
        else if (key_valid) begin
            // Schlüssel muss explizit bereitgestellt werden
            encryption_key <= key_input;
            key_set <= 1'b1;
            crypto_ready <= 1'b1;
        end
    end

    // Nur verschlüsseln, wenn Schlüssel korrekt gesetzt wurde
    always @(posedge clk) begin
        if (crypto_ready && key_set) begin
            ciphertext <= encrypt_aes(plaintext, encryption_key);
        end else begin
            // Nullen ausgeben wenn nicht bereit – keinen schwachen Standard verwenden
            ciphertext <= 128'h0;
        end
    end

endmodule

// SICHER: Speicherschutz standardmäßig aktiviert
module secure_memory_controller (
    input wire clk,
    input wire reset_n,
    input wire [31:0] address,
    input wire read_enable,
    input wire write_enable,
    input wire privileged_mode,
    output reg [31:0] data_out,
    output reg access_error
);

    // Schutzkonfiguration
    reg [31:0] protected_region_start;
    reg [31:0] protected_region_end;
    reg protection_enabled;
    reg configuration_locked;

    always @(posedge clk or negedge reset_n) begin
        if (!reset_n) begin
            // SICHER: Schutz standardmäßig aktiviert
            protection_enabled <= 1'b1;
            // SICHER: Gesamter Speicher standardmäßig geschützt
            protected_region_start <= 32'h00000000;
            protected_region_end <= 32'hFFFFFFFF;
            configuration_locked <= 1'b0;
        end
    end

    // Zugriffskontrolle ab Boot aktiv
    always @(*) begin
        if (protection_enabled) begin
            if (address >= protected_region_start &&
                address <= protected_region_end) begin
                // Geschützter Bereich – Privileg erforderlich
                access_error = !privileged_mode;
            end else begin
                access_error = 1'b0;
            end
        end else begin
            access_error = 1'b0;
        end
    end

endmodule

// SICHER: Sichere Standardwerte auf Systemebene
module secure_soc_defaults #(
    // Alle Sicherheitsfunktionen standardmäßig AN
    parameter SECURE_BOOT_ENABLED = 1,
    parameter MEMORY_ENCRYPTION_ENABLED = 1,
    parameter DEBUG_DISABLED = 1,
    parameter JTAG_LOCKED = 1,
    parameter DMA_PROTECTION_ENABLED = 1
) (
    input wire clk,
    input wire reset_n,
    output wire secure_boot_active,
    output wire memory_encrypted,
    output wire debug_locked,
    output wire jtag_disabled,
    output wire dma_protected
);

    // Sichere Standardwerte zum Synthesezeitpunkt angewendet
    assign secure_boot_active = SECURE_BOOT_ENABLED;
    assign memory_encrypted = MEMORY_ENCRYPTION_ENABLED;
    assign debug_locked = DEBUG_DISABLED;
    assign jtag_disabled = JTAG_LOCKED;
    assign dma_protected = DMA_PROTECTION_ENABLED;

    // Diese können nicht ohne Hardware-Modifikation geändert werden

endmodule

// SICHER: Firmware mit expliziter Sicherheitsinitialisierung

void secure_init(void) {
    // Sichere Standardwerte überprüfen
    if (is_debug_enabled()) {
        panic("Sicherheitsverletzung: Debug beim Boot aktiviert!");
    }

    if (!is_security_check_enabled()) {
        panic("Sicherheitsverletzung: Sicherheitsprüfungen deaktiviert!");
    }

    // Hardware-Standardwerte sind sicher, aber trotzdem überprüfen
    verify_secure_defaults();

    // Mit normaler Initialisierung fortfahren
    complete_secure_boot();
}

// SICHER: Explizite Schlüsselinitialisierung erforderlich
void secure_crypto_init(void) {
    // Sicheren Schlüssel generieren oder abrufen
    uint8_t key[16];

    if (!get_secure_key(key, sizeof(key))) {
        panic("Verschlüsselungsschlüssel könnte nicht erhalten werden");
    }

    // Schlüssel vor jeder Verschlüsselung explizit setzen
    if (!crypto_set_key(key, sizeof(key))) {
        panic("Verschlüsselungsschlüssel könnte nicht gesetzt werden");
    }

    // Überprüfen, dass Schlüssel gesetzt wurde
    if (!crypto_is_ready()) {
        panic("Krypto-Engine nach Schlüsselsetzen nicht bereit");
    }

    // Schlüssel vom Stack löschen
    secure_memzero(key, sizeof(key));

    // Jetzt sicher Verschlüsselung zu verwenden
}

// Überprüfungsfunktion
bool verify_secure_defaults(void) {
    bool secure = true;

    // Alle sicherheitskritischen Standardwerte prüfen
    if (read_register(DEBUG_CONTROL) & DEBUG_ENABLE_BIT) {
        log_error("Debug aktiviert – sollte standardmäßig deaktiviert sein");
        secure = false;
    }

    if (!(read_register(SECURITY_CONTROL) & SECURITY_ENABLE_BIT)) {
        log_error("Sicherheit deaktiviert – sollte standardmäßig aktiviert sein");
        secure = false;
    }

    if (read_register(ACCESS_CONTROL) != MINIMAL_ACCESS_DEFAULT) {
        log_error("Zugriffskontrolle nicht auf minimalem Standard");
        secure = false;
    }

    return secure;
}

---

CVE-Beispiele

Schwachstellen durch fehlerhafte Standardwerte wurden in verschiedenen SoC-Designs gefunden, bei denen Sicherheitsfunktionen standardmäßig deaktiviert waren oder schwache Standardkonfigurationen verwendeten.

---

Verwandte CWEs

• CWE-1188: Insecure Default Initialization of Resource (verwandt)
• CWE-453: Insecure Default Variable Initialization (verwandt)
• CWE-1199: General Circuit and Logic Design Concerns (Kategoriemitglied)

---

Referenzen

1. MITRE Corporation. "CWE-1221: Incorrect Register Defaults or Module Parameters." https://cwe.mitre.org/data/definitions/1221.html
2. Secure-by-Default Designprinzipien
3. Richtlinien zur Hardware-Sicherheitskonfiguration