Hardware-Kindblock fehlerhaft mit ubergeordnetem System verbunden

Beschreibung

Hardware-Kindblock fehlerhaft mit ubergeordnetem System verbunden tritt auf, wenn Signale zwischen einer Hardware-IP-Komponente und dem ubergeordneten Systemdesign fehlerhaft verbunden sind, was Sicherheitsrisiken verursacht. Hardware-IP-Komponenten benötigen ordnungsgemäße Kommunikation mit ubergeordneten Systemen für korrekte Funktionalitat. Fehlerhafte Verbindungen können, obwohl sie möglicherweise funktionale Probleme vermeiden, Sicherheitsschwachstellen einführen. Beispielsweise wenn ein Reset-Eingang mit einem Debug-Modus-Reset anstelle eines systemweiten Hard-Resets verbunden wird, was die Datenintegritat gefährdet, oder wenn Sicherheitsstufensignale auf Masse gelegt anstatt ordnungsgemäß verbunden werden.

Risiko

Fehlerhafte Signalverbindungen haben schwerwiegende Sicherheitsauswirkungen. Sicherheitsstufen können falsch zugewiesen werden. Debug-Signale können unsachgemäß weitergeleitet werden. Reset-Verhalten kann kompromittiert werden. Interrupts können verloren gehen oder fehlgeleitet werden. Zugriffskontrolle kann umgangen werden. Privilegientrennung kann versagen. Informationen können über Sicherheitsdomanen hinweg durchsickern. Systemsicherheitsannahmen können verletzt werden.

Lösung

Verwenden Sie Verifikation auf Systemebene, um sicherzustellen, dass Komponenten korrekt verbunden sind und dass Designsicherheitsanforderungen nicht durch Interaktionen zwischen verschiedenen IP-Blöcken verletzt werden. Uberprüfen Sie Integrationscode auf Signalverbindungsfehler. Implementieren Sie formale Verifikation sicherheitskritischer Signalpfade. Dokumentieren Sie erwartete Verbindungen und verifizieren Sie diese gegen die Implementierung. Testen Sie Sicherheitsfunktionalitat nach der Integration.

Häufige Auswirkungen

Auswirkung	Details
Vertraulichkeit	Umfang: Vertraulichkeit Speicher lesen - Fehlerhafte Verbindungen können sensible Daten freilegen.
Integritat	Umfang: Integritat Speicher modifizieren - Sicherheitskontrollen können umgangen werden.
Verfügbarkeit	Umfang: Verfügbarkeit DoS - System kann aufgrund fehlerhafter Signalisierung fehlfunktionieren.
Zugriffskontrolle	Umfang: Zugriffskontrolle Schutzmechanismus umgehen - Sicherheitsstufensignale können kompromittiert werden.

Beispielcode und Lösung

Verwundbarer Code

// VERWUNDBAR: TrustZone-Sicherheitsstufe auf Masse gelegt statt verbunden

module vulnerable_system_integration (
    input wire clk,
    input wire reset_n,
    // AXI-Master-Schnittstelle von CPU
    input wire [31:0] cpu_awaddr,
    input wire cpu_awvalid,
    input wire cpu_awprot_secure,  // CPU-Sicherheitsstufensignal
    output wire cpu_awready,
    // AXI-Slave-Schnittstelle zum Speicher
    output wire [31:0] mem_awaddr,
    output wire mem_awvalid,
    output wire mem_awprot_secure,  // Speicher-Sicherheitsstufe
    input wire mem_awready
);

    // VERWUNDBAR: Sicherheitsstufensignal auf 0 (sicher) gelegt
    // anstatt mit CPU-Ausgang verbunden

    axi_interconnect interconnect_inst (
        .clk(clk),
        .reset_n(reset_n),
        // Master-Schnittstelle
        .s_awaddr(cpu_awaddr),
        .s_awvalid(cpu_awvalid),
        // VERWUNDBAR: Auf sichere Stufe gelegt anstatt verbunden
        .s_awprot_secure(1'b0),  // Sollte sein: cpu_awprot_secure
        .s_awready(cpu_awready),
        // Slave-Schnittstelle
        .m_awaddr(mem_awaddr),
        .m_awvalid(mem_awvalid),
        .m_awprot_secure(mem_awprot_secure),
        .m_awready(mem_awready)
    );

    // Problem: Alle Transaktionen erscheinen als "sicher"
    // Nicht-sichere Welt kann auf sicheren Speicher zugreifen!

endmodule

// VERWUNDBAR: Interrupt-Signale nicht verbunden
module vulnerable_csr_integration (
    input wire clk,
    input wire reset_n,
    // CSR-Schnittstelle
    input wire [7:0] csr_addr,
    input wire [31:0] csr_write_data,
    input wire csr_write,
    output wire [31:0] csr_read_data,
    // Interrupt-Signale (sollten verbunden sein)
    output wire tamper_interrupt,
    output wire error_interrupt,
    output wire overflow_interrupt
);

    // CSR-Registerblock-Instanz
    csr_register_file csr_inst (
        .clk(clk),
        .reset_n(reset_n),
        .addr(csr_addr),
        .write_data(csr_write_data),
        .write_enable(csr_write),
        .read_data(csr_read_data),
        // VERWUNDBAR: Interrupt-Ports nicht verbunden
        .tamper_int(),       // Sollte sein: tamper_interrupt
        .error_int(),        // Sollte sein: error_interrupt
        .overflow_int()      // Sollte sein: overflow_interrupt
    );

    // VERWUNDBAR: Interrupts gehen verloren
    // System wird nie über Sicherheitsereignisse benachrichtigt!
    // Manipulationsversuche bleiben unerkannt

endmodule

// VERWUNDBAR: Reset-Signal fehlerhaft verbunden
module vulnerable_reset_connection (
    input wire clk,
    input wire system_hard_reset_n,
    input wire debug_soft_reset_n,
    // Sicherheitssubsystem
    output wire security_reset_n
);

    // Sicherheitssubsystem benötigt Hard-Reset um sensiblen Zustand zu loschen
    security_controller sec_ctrl (
        .clk(clk),
        // VERWUNDBAR: Mit Debug-Reset statt Hard-Reset verbunden
        .reset_n(debug_soft_reset_n),  // Sollte sein: system_hard_reset_n
        .security_reset_n(security_reset_n)
    );

    // Problem: Debug-Reset loscht Sicherheitszustand nicht
    // Sensible Daten bleiben über Debug-Resets hinweg bestehen
    // Angreifer kann Debug-Reset verwenden um Zugriff zu bewahren

endmodule

// VERWUNDBAR: Software-Fehlkonfiguration die Hardware-Probleme widerspiegelt

#include <stdint.h>

// VERWUNDBAR: Falsche Registeradress-Definitionen
// Kopier-Einfuge-Fehler von anderer Chip-Version

#define SECURITY_CTRL_BASE  0x40001000  // Falsch! Sollte 0x40002000 sein
#define CRYPTO_ENGINE_BASE  0x40002000  // Falsch! Sollte 0x40003000 sein

typedef struct {
    volatile uint32_t ctrl;
    volatile uint32_t status;
    volatile uint32_t key[8];
} crypto_regs_t;

void vulnerable_crypto_init(void) {
    // VERWUNDBAR: Zugriff auf falsches Peripheriegerat aufgrund Adressfehler
    crypto_regs_t* crypto = (crypto_regs_t*)CRYPTO_ENGINE_BASE;

    // Tatsächlich wird in anderes Peripheriegerat geschrieben!
    crypto->ctrl = 0x01;  // Krypto aktivieren (aber falsche Adresse)

    // Problem: Sicherheitscontroller bei 0x40002000 wird modifiziert
    // Krypto-Engine bei 0x40003000 wird nicht konfiguriert
    // Sicherheit kann deaktiviert werden statt Krypto zu aktivieren!
}

// VERWUNDBAR: Interrupt-Handler mit falschem Interrupt verbunden
void vulnerable_interrupt_setup(void) {
    // Manipulations-Handler mit falscher Interrupt-Nummer verbinden
    register_interrupt_handler(
        IRQ_TIMER,  // VERWUNDBAR: Sollte IRQ_TAMPER sein
        tamper_handler
    );

    // Timer-Interrupts losen Manipulations-Handler aus
    // Manipulationsereignisse werden nie behandelt!
}

Sichere Lösung

// SICHER: TrustZone-Sicherheitsstufe ordnungsgemäß verbunden

module secure_system_integration (
    input wire clk,
    input wire reset_n,
    // AXI-Master-Schnittstelle von CPU
    input wire [31:0] cpu_awaddr,
    input wire cpu_awvalid,
    input wire cpu_awprot_secure,
    output wire cpu_awready,
    // AXI-Slave-Schnittstelle zum Speicher
    output wire [31:0] mem_awaddr,
    output wire mem_awvalid,
    output wire mem_awprot_secure,
    input wire mem_awready,
    // Debug-/Verifizierungsausgange
    output wire security_mismatch
);

    // SICHER: Sicherheitsstufensignal ordnungsgemäß verbunden
    wire internal_security_level;

    axi_interconnect interconnect_inst (
        .clk(clk),
        .reset_n(reset_n),
        // Master-Schnittstelle
        .s_awaddr(cpu_awaddr),
        .s_awvalid(cpu_awvalid),
        // SICHER: Ordnungsgemäß mit CPU-Ausgang verbunden
        .s_awprot_secure(cpu_awprot_secure),
        .s_awready(cpu_awready),
        // Slave-Schnittstelle
        .m_awaddr(mem_awaddr),
        .m_awvalid(mem_awvalid),
        .m_awprot_secure(mem_awprot_secure),
        .m_awready(mem_awready),
        // SICHER: Internes Signal für Verifizierung
        .security_level_internal(internal_security_level)
    );

    // SICHER: Sicherheitssignal-Weitergabe verifizieren
    assign security_mismatch = (cpu_awprot_secure != internal_security_level);

endmodule

// SICHER: Interrupt-Signale ordnungsgemäß verbunden
module secure_csr_integration (
    input wire clk,
    input wire reset_n,
    // CSR-Schnittstelle
    input wire [7:0] csr_addr,
    input wire [31:0] csr_write_data,
    input wire csr_write,
    output wire [31:0] csr_read_data,
    // Interrupt-Signale - ordnungsgemäß deklariert und verbunden
    output wire tamper_interrupt,
    output wire error_interrupt,
    output wire overflow_interrupt,
    // Kombinierter Interrupt für System
    output wire system_interrupt
);

    // Interne Interrupt-Signale
    wire int_tamper;
    wire int_error;
    wire int_overflow;

    // CSR-Registerblock-Instanz
    csr_register_file csr_inst (
        .clk(clk),
        .reset_n(reset_n),
        .addr(csr_addr),
        .write_data(csr_write_data),
        .write_enable(csr_write),
        .read_data(csr_read_data),
        // SICHER: Alle Interrupt-Ports ordnungsgemäß verbunden
        .tamper_int(int_tamper),
        .error_int(int_error),
        .overflow_int(int_overflow)
    );

    // SICHER: Mit Ausgangen verbinden
    assign tamper_interrupt = int_tamper;
    assign error_interrupt = int_error;
    assign overflow_interrupt = int_overflow;

    // SICHER: Kombinierter Interrupt für Systemebenen-Behandlung
    assign system_interrupt = int_tamper | int_error | int_overflow;

endmodule

// SICHER: Reset-Signal korrekt verbunden
module secure_reset_connection (
    input wire clk,
    input wire system_hard_reset_n,
    input wire debug_soft_reset_n,
    // Sicherheitssubsystem
    output wire security_reset_n
);

    // SICHER: Sicherheitssubsystem mit korrektem Reset verbunden
    security_controller sec_ctrl (
        .clk(clk),
        // SICHER: Mit Hard-Reset verbunden
        .reset_n(system_hard_reset_n),
        .security_reset_n(security_reset_n)
    );

    // Sicherheitszustand wird bei System-Reset ordnungsgemäß geloscht

endmodule

// SICHER: Verbindungsverifizierungsmodul
module connection_verifier (
    input wire clk,
    input wire reset_n,
    // Zu verifizierende Signale
    input wire [31:0] expected_security_level,
    input wire [31:0] actual_security_level,
    input wire expected_interrupt,
    input wire actual_interrupt,
    input wire expected_reset,
    input wire actual_reset,
    // Verifizierungsausgange
    output reg connection_error,
    output reg [7:0] error_code
);

    always @(posedge clk or negedge reset_n) begin
        if (!reset_n) begin
            connection_error <= 1'b0;
            error_code <= 8'h00;
        end
        else begin
            connection_error <= 1'b0;

            // SICHER: Sicherheitsstufen-Verbindung verifizieren
            if (expected_security_level != actual_security_level) begin
                connection_error <= 1'b1;
                error_code <= 8'h01;  // Sicherheitsstufen-Nichtübereinstimmung
            end

            // SICHER: Interrupt-Verbindung verifizieren
            if (expected_interrupt != actual_interrupt) begin
                connection_error <= 1'b1;
                error_code <= 8'h02;  // Interrupt-Verbindungsfehler
            end

            // SICHER: Reset-Verbindung verifizieren
            if (expected_reset != actual_reset) begin
                connection_error <= 1'b1;
                error_code <= 8'h03;  // Reset-Verbindungsfehler
            end
        end
    end

endmodule

// SICHER: Formale Verifikations-Assertions
module formal_connection_check (
    input wire clk,
    input wire cpu_secure,
    input wire interconnect_secure,
    input wire memory_secure
);

    // SICHER: Formale Assertions zur Verbindungsverifizierung
    `ifdef FORMAL
        // Sicherheitsstufe muss korrekt weitergegeben werden
        always @(posedge clk) begin
            assert(cpu_secure == interconnect_secure);
            assert(interconnect_secure == memory_secure);
        end

        // Cover-Property um Sicherheitsübergange sicherzustellen
        cover property (@(posedge clk) cpu_secure == 1'b1);
        cover property (@(posedge clk) cpu_secure == 1'b0);
    `endif

endmodule

// SICHER: Software mit verifizierten Registeradressen

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

// SICHER: Verifizierte Registeradressen aus Datenblatt
#define SECURITY_CTRL_BASE  0x40002000  // Verifiziert
#define CRYPTO_ENGINE_BASE  0x40003000  // Verifiziert
#define INTERRUPT_CTRL_BASE 0x40004000  // Verifiziert

// SICHER: Signatur-Bytes zur Peripheriegerat-Identifizierung
#define CRYPTO_ENGINE_ID    0x43525950  // "CRYP"
#define SECURITY_CTRL_ID    0x53454355  // "SECU"

typedef struct {
    volatile uint32_t id;       // Peripheriegerat-ID-Register
    volatile uint32_t ctrl;
    volatile uint32_t status;
    volatile uint32_t key[8];
} crypto_regs_t;

// SICHER: Peripheriegerat vor Verwendung verifizieren
bool verify_peripheral(volatile uint32_t* base, uint32_t expected_id) {
    return (*base == expected_id);
}

bool secure_crypto_init(void) {
    crypto_regs_t* crypto = (crypto_regs_t*)CRYPTO_ENGINE_BASE;

    // SICHER: Verifizieren dass auf korrektes Peripheriegerat zugegriffen wird
    if (!verify_peripheral(&crypto->id, CRYPTO_ENGINE_ID)) {
        log_error("Krypto-Engine nicht an erwarteter Adresse gefunden");
        return false;
    }

    // Jetzt sicher zu konfigurieren
    crypto->ctrl = 0x01;  // Krypto aktivieren
    return true;
}

// SICHER: Korrekte Interrupt-Einrichtung mit Verifizierung
typedef struct {
    int irq_number;
    const char* name;
    void (*handler)(void);
} interrupt_mapping_t;

static const interrupt_mapping_t interrupt_table[] = {
    {IRQ_TAMPER,   "Manipulation", tamper_handler},
    {IRQ_ERROR,    "Fehler",       error_handler},
    {IRQ_OVERFLOW, "Überlauf",     overflow_handler},
    {IRQ_TIMER,    "Timer",        timer_handler},
};

bool secure_interrupt_setup(void) {
    // SICHER: Handler aus verifizierter Tabelle registrieren
    for (int i = 0; i < sizeof(interrupt_table)/sizeof(interrupt_table[0]); i++) {
        if (!register_interrupt_handler(
                interrupt_table[i].irq_number,
                interrupt_table[i].handler)) {
            log_error("Registrierung von %s-Interrupt fehlgeschlagen",
                      interrupt_table[i].name);
            return false;
        }
    }

    // SICHER: Verifizieren dass alle Sicherheits-Interrupts registriert sind
    if (!verify_interrupt_registered(IRQ_TAMPER)) {
        log_error("Manipulations-Interrupt nicht registriert");
        return false;
    }

    return true;
}

// SICHER: Selbsttest für Peripheriegerat-Verbindungen
bool test_peripheral_connections(void) {
    bool all_passed = true;

    // Krypto-Engine testen
    if (!verify_peripheral(
            (volatile uint32_t*)CRYPTO_ENGINE_BASE,
            CRYPTO_ENGINE_ID)) {
        log_error("Krypto-Engine-Verbindung fehlgeschlagen");
        all_passed = false;
    }

    // Sicherheitscontroller testen
    if (!verify_peripheral(
            (volatile uint32_t*)SECURITY_CTRL_BASE,
            SECURITY_CTRL_ID)) {
        log_error("Sicherheitscontroller-Verbindung fehlgeschlagen");
        all_passed = false;
    }

    // Interrupts durch Auslösung und Verifizierung testen
    if (!test_interrupt_path(IRQ_TAMPER)) {
        log_error("Manipulations-Interrupt-Pfad fehlgeschlagen");
        all_passed = false;
    }

    return all_passed;
}

---

CVE-Beispiele

Hardware-Integrationsschwachstellen wurden in verschiedenen SoC-Designs gefunden, bei denen sicherheitskritische Signale fehlerhaft verbunden waren, was zu Berechtigungserweiterung oder Umgehung von Sicherheitskontrollen führte.

---

Verwandte CWEs

• CWE-284: Unzureichende Zugriffskontrolle (ubergeordnet)
• CWE-1197: Integrationsprobleme (Kategorie)
• CWE-1396: Zugriffskontrolle (umfassende Kategorie)
• CWE-1254: Fehlerhafte Granularitat der Vergleichslogik (verwandt)

---

Referenzen

1. MITRE Corporation. "CWE-1276: Hardware Child Block Incorrectly Connected to Parent System." https://cwe.mitre.org/data/definitions/1276.html
2. ARM. "AMBA Integration Guidelines"
3. Synopsys. "IP Integration Best Practices"