Unsachgemäßes Sperrverhalten nach Energiezustandsübergängen

Beschreibung

Unsachgemäßes Sperrverhalten nach Energiezustandsübergängen tritt auf, wenn Register-Sperrbit-Schutz Änderungen an der Systemkonfiguration deaktiviert, sobald das Bit gesetzt ist, diese Schutzmaßnahmen aber nach Energiezustandsübergängen programmierbar werden. Geräte verlassen sich typischerweise auf vertrauenswürdige Firmware oder Software, um kritische Systemressourcen zu konfigurieren und sie dann über ein programmierbares Sperrbit zu sperren. Das Problem tritt auf, wenn Sperrbits entsperrt werden, geschützte Registerwerte zurückgesetzt werden oder Sperren nach Energiezustandsübergängen wie dem Eintritt in oder Aufwachen aus Energiesparmodi umprogrammierbar werden. Dies erzeugt ein Verwundbarkeitsfenster, in dem Angreifer geschützte Konfigurationen modifizieren könnten.

Risiko

Sperrverhaltensprobleme nach Energieübergängen haben schwerwiegende Sicherheitsauswirkungen. Sicherheitskonfigurationen können auf entsperrte Standardwerte zurückgesetzt werden. Geschützte Register können nach dem Schlaf beschreibbar werden. Angreifer können Energiesparmodus-Übergänge erzwingen, um Sperren zu löschen. Boot-Sicherheitseinstellungen können umgangen werden. Debug-Schnittstellen können nach dem Aufwachen wieder aktiviert werden. Speicherschutz kann deaktiviert werden. Firmware-Integritätsprüfungen können umgangen werden. Kritische Systemeinstellungen können modifiziert werden.

Lösung

Überprüfen Sie Sicherheitssperrbit-Schutzmaßnahmen über alle unterstützten Energiezustandsübergänge. Stellen Sie sicher, dass Sperren nach Energieübergängen bestehen bleiben oder sicher wiederhergestellt werden. Initialisieren Sie Sperrregister auf gesperrten (nicht entsperrten) Zustand bei Reset. Testen Sie Sperr-Programmierablauf und -Eigenschaften während Pre-Silicon- und Post-Silicon-Validierung einschließlich Energieübergangsszenarien. Implementieren Sie Sperrzustandspersistenz über Energiezustände. Überprüfen Sie Sicherheitskonfiguration nach dem Aufwachen aus Energiesparmodi.

Häufige Auswirkungen

Auswirkung	Details
Zugriffskontrolle	Bereich: Zugriffskontrolle Speicher modifizieren – Durch Sperrbit geschützte Systemkonfiguration kann nach Energiezustandsübergängen modifiziert werden, was die Zugriffskontrolle kompromittiert. Hohe Wahrscheinlichkeit.

Beispielcode und Lösung

Verwundbarer Code

// VERWUNDBAR: Sperren werden nach Energieübergang auf entsperrten Zustand zurückgesetzt

module vulnerable_power_lock (
    input wire clk,
    input wire reset_n,
    input wire sleep_mode,
    input wire wake_signal,
    input wire [31:0] write_data,
    input wire write_enable,
    input wire set_lock,
    output reg [31:0] config_register,
    output reg [31:0] lock_register
);

    reg power_state;

    always @(posedge clk or negedge reset_n) begin
        if (!reset_n) begin
            config_register <= 32'h0;
            lock_register <= 32'h0;  // VERWUNDBAR: Standardmäßig entsperrt
            power_state <= 1'b0;
        end
        else if (wake_signal && power_state) begin
            // VERWUNDBAR: Aufwachen aus Schlaf setzt Sperren zurück!
            power_state <= 1'b0;
            lock_register <= 32'h0;  // Sperren beim Aufwachen gelöscht!
        end
    end

endmodule

Sichere Lösung

// SICHER: Sperren bleiben über Energiezustandsübergänge bestehen

module secure_power_lock (
    input wire clk,
    input wire reset_n,
    input wire sleep_mode,
    input wire wake_signal,
    input wire [31:0] write_data,
    input wire write_enable,
    input wire set_lock,
    output reg [31:0] config_register,
    output reg [31:0] lock_register
);

    reg power_state;
    reg [31:0] saved_config;
    reg [31:0] saved_locks;

    always @(posedge clk or negedge reset_n) begin
        if (!reset_n) begin
            config_register <= 32'h0;
            lock_register <= 32'hFFFFFFFF;  // SICHER: Standardmäßig gesperrt!
            power_state <= 1'b0;
        end
        else if (sleep_mode && !power_state) begin
            power_state <= 1'b1;
            saved_config <= config_register;
            saved_locks <= lock_register;
        end
        else if (wake_signal && power_state) begin
            // SICHER: Sperren beim Aufwachen wiederherstellen, nicht löschen
            power_state <= 1'b0;
            lock_register <= saved_locks;
            config_register <= saved_config;
        end
    end

endmodule

// SICHER: Firmware überprüft Sperren nach Energieübergängen

void secure_sleep_handler(void) {
    save_context();
    uint32_t locks_before = get_lock_status();

    enter_low_power_mode();
    // ... System schläft ...
    restore_context();

    // SICHER: Sperren nach Aufwachen überprüfen
    uint32_t locks_after = get_lock_status();

    if (locks_after != locks_before) {
        log_security_event("Sperrzustand nach Aufwachen geändert");
        restore_security_locks(locks_before);

        if (get_lock_status() != locks_before) {
            panic("Sicherheitssperren können nicht wiederhergestellt werden!");
        }
    }

    verify_protected_configuration();
    continue_operation();
}

---

CVE-Beispiele

• Energiezustandsübergangs-Schwachstellen wurden in verschiedenen SoC-Designs gefunden, bei denen Sicherheitssperren während Schlaf/Aufwach-Zyklen gelöscht oder zurückgesetzt wurden
• CAPEC-166: Force the System to Reset Values

---

Verwandte CWEs

• CWE-667: Improper Locking (übergeordnet)
• CWE-1199: General Circuit and Logic Design Concerns (Kategoriemitglied)
• CWE-1206: Power, Clock, Thermal, and Reset Concerns (Kategoriemitglied)
• CWE-1231: Improper Prevention of Lock Bit Modification (verwandt)

---

Referenzen

1. MITRE Corporation. "CWE-1232: Improper Lock Behavior After Power State Transition." https://cwe.mitre.org/data/definitions/1232.html
2. Hack@DAC'21 OpenPiton SoC-Sicherheitsanalyse
3. Richtlinien zur Sicherheit der Energieverwaltung