Ungeschützte vertrauliche Informationen auf Gerät sind für OSAT-Lieferanten zugänglich
Beschreibung
Ungeschützte vertrauliche Informationen auf einem Gerät, die für OSAT-Lieferanten (Outsourced Semiconductor Assembly and Test) zugänglich sind, treten auf, wenn ein Produkt vertrauliche Informationen nicht ausreichend vor OSAT-Lieferanten schützt, die Geräte in Vorproduktionsphasen handhaben. Wenn Chiphersteller Montage und Test auslagern, anstatt vertikal integriert zu bleiben, gelangen Geräte in OSAT-Einrichtungen in verletzlichen Vorproduktionszuständen mit zugänglichen Debug- und Testmodi. Dies erfordert Vertrauen in OSAT-Partner, typischerweise über Geheimhaltungsvereinbarungen. OSAT-Lieferanten bedienen jedoch mehrere Kunden, was das Risiko versehentlicher Informationsweitergabe erhöht. Zusätzlich stellen IT-Sicherheitsschwachstellen oder bösartige Insider bei OSAT-Einrichtungen Bedrohungen dar.
Risiko
OSAT-Exposition hat schwerwiegende Sicherheitsauswirkungen. Hauptschlüssel Dritten offengelegt. Debug-Fähigkeiten in Vorproduktion zugänglich. Vertrauliche Algorithmen offengelegt. Geschäftsgeheimnisse gefährdet. NDA allein bietet unzureichenden Schutz. Mehrere Kunden erhöhen Kreuzkontaminationsrisiko. Bösartige Insider können Geheimnisse extrahieren. Ein durchgesickerter Schlüssel kann eine gesamte Produktgeneration kompromittieren. Mittlere Wahrscheinlichkeit aber potenziell katastrophale Schwere.
Lösung
Stellen Sie sicher, dass OSAT-Lieferanten nur auf minimal notwendige Informationen über Testschnittstellen zugreifen. Entwerfen Sie Systeme so, dass Geräteentsperrungsanfragen nur für bestimmte Teile gelten, nicht für gesamte Produktlinien. Stellen Sie sicher, dass der nichtflüchtige Speicher (NVM) des Produkts von allen vertraulichen Informationen und Geheimnissen bereinigt wird, bevor er an einen OSAT übergeben wird. Sichern Sie alle OSAT-zu-Chiphersteller-Kommunikationen. Implementieren Sie gerätespezifische eindeutige Geheimnisse statt gemeinsamer Hauptschlüssel. Verwenden Sie Hardware-Sicherheitsmodule für sensible Operationen.
Häufige Auswirkungen
| Auswirkung | Details |
|---|---|
| Vertraulichkeit | Bereich: Vertraulichkeit Kryptographische Schlüssel und proprietäre Algorithmen offengelegt. |
| Integrität | Bereich: Integrität Firmware und Konfiguration können während des Tests modifiziert werden. |
| Zugriffskontrolle | Bereich: Zugriffskontrolle, Authentifizierung Debug-Anmeldeinformationen offengelegt, die zukünftige Angriffe ermöglichen. |
Beispielcode und Lösung
Verwundbarer Code
// VERWUNDBAR: Gerät mit für OSAT zugänglichem Hauptschlüssel
module vulnerable_device_secrets (
input wire clk,
input wire rst_n,
input wire test_mode, // Aktiv während OSAT-Tests
input wire [31:0] nvm_addr,
input wire nvm_read,
output reg [31:0] nvm_data
);
// VERWUNDBAR: Hauptschlüssel im NVM gespeichert
// Gleicher Schlüssel für ALLE Geräte der Produktlinie
reg [255:0] master_key;
// VERWUNDBAR: Debug-Entsperrschlüssel ebenfalls gespeichert
reg [63:0] debug_unlock_key;
// VERWUNDBAR: Proprietäre Algorithmenkoeffizienten
reg [31:0] algo_coefficients [0:15];
// VERWUNDBAR: NVM-Inhalte im Testmodus lesbar
always @(posedge clk or negedge rst_n) begin
if (!rst_n) begin
nvm_data <= 32'b0;
end else if (nvm_read) begin
// VERWUNDBAR: Gesamter NVM während OSAT-Test zugänglich
case (nvm_addr[7:0])
8'h00: nvm_data <= master_key[31:0]; // Schlüssel zugänglich!
8'h04: nvm_data <= master_key[63:32];
8'h08: nvm_data <= master_key[95:64];
// ... weitere Schlüsselbytes zugänglich
8'h20: nvm_data <= debug_unlock_key[31:0];
8'h24: nvm_data <= debug_unlock_key[63:32];
8'h40: nvm_data <= algo_coefficients[nvm_addr[5:2]];
default: nvm_data <= 32'b0;
endcase
end
end
// VERWUNDBAR: Kein Schutz während des Testmodus
// OSAT kann alle Geheimnisse über Testschnittstelle lesen
endmodule
// VERWUNDBAR: Gemeinsame Hauptschlüssel-Bereitstellung
module vulnerable_key_provisioning (
input wire clk,
input wire rst_n,
input wire provision_enable,
input wire [255:0] master_key_input,
output reg [255:0] device_key
);
// VERWUNDBAR: Gleicher Hauptschlüssel für alle Geräte programmiert
// Wenn OSAT Schlüssel von einem Gerät extrahiert, sind alle kompromittiert
always @(posedge clk or negedge rst_n) begin
if (!rst_n) begin
device_key <= 256'b0;
end else if (provision_enable) begin
// VERWUNDBAR: Direkte Hauptschlüsselspeicherung
device_key <= master_key_input;
end
end
endmodule
// VERWUNDBAR: Vorproduktionsgerät mit exponierten Geheimnissen
#include <stdint.h>
#include <string.h>
// VERWUNDBAR: Hauptschlüssel in Firmware eingebettet
// Dieses Firmware-Image geht an OSAT
static const uint8_t MASTER_KEY[32] = {
0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0x00
};
// VERWUNDBAR: Debug-Entsperrcode in Firmware
static const uint64_t DEBUG_UNLOCK = 0xDEADBEEFCAFEBABE;
// VERWUNDBAR: Testfunktion exponiert Geheimnisse
void vulnerable_test_interface(uint32_t command, uint8_t* response) {
switch (command) {
case 0x01: // Hauptschlüssel lesen
// VERWUNDBAR: Schlüssel über Testbefehl lesbar
memcpy(response, MASTER_KEY, sizeof(MASTER_KEY));
break;
case 0x02: // Debug-Entsperrung lesen
// VERWUNDBAR: Debug-Code lesbar
memcpy(response, &DEBUG_UNLOCK, sizeof(DEBUG_UNLOCK));
break;
case 0x03: // Speicherabzug
// VERWUNDBAR: Voller Speicherzugriff zum "Testen"
dump_memory(response);
break;
default:
break;
}
}
// VERWUNDBAR: NVM nicht vor OSAT-Übergabe bereinigt
typedef struct {
uint8_t master_key[32]; // VERWUNDBAR: Im Klartext
uint8_t debug_key[8]; // VERWUNDBAR: Im Klartext
uint8_t device_certificate[512];
uint32_t serial_number;
} nvm_contents_t;
void vulnerable_prepare_for_osat(void) {
// VERWUNDBAR: Keine Bereinigung sensibler Daten
// Gerät geht mit allen Geheimnissen intakt an OSAT
}
Sichere Lösung
// SICHER: Gerät mit geschützten Geheimnissen für OSAT-Übergabe
module secure_device_secrets (
input wire clk,
input wire rst_n,
input wire test_mode,
input wire production_mode, // Nach OSAT gefused
input wire [31:0] nvm_addr,
input wire nvm_read,
output reg [31:0] nvm_data
);
// SICHER: Gerätespezifischer eindeutiger Schlüssel aus PUF abgeleitet
// Nicht im NVM gespeichert, zur Laufzeit generiert
wire [255:0] device_unique_key;
// SICHER: Hauptschlüssel nicht auf Gerät gespeichert
// Hauptschlüssel bleibt im HSM der sicheren Einrichtung
// SICHER: Testmodus-Beschränkungen
reg [31:0] public_test_data [0:15]; // Nur nicht-sensible Testdaten
// SICHER: Sicherer Schlüsselspeicher - nicht über Testschnittstelle lesbar
// Schlüssel in isoliertem, nicht lesbarem Block gespeichert
secure_key_block u_key_block (
.clk(clk),
.rst_n(rst_n),
.production_mode(production_mode),
.device_key(device_unique_key)
);
// SICHER: Testmodus greift nur auf nicht-sensible Daten zu
always @(posedge clk or negedge rst_n) begin
if (!rst_n) begin
nvm_data <= 32'b0;
end else if (nvm_read) begin
if (test_mode && !production_mode) begin
// SICHER: Nur öffentliche Testdaten während OSAT zugänglich
if (nvm_addr < 32'h40) begin
nvm_data <= public_test_data[nvm_addr[5:2]];
end else begin
nvm_data <= 32'b0; // Sensible Bereiche geben Null zurück
end
end else if (production_mode) begin
// Produktionsmodus - andere Zugriffsregeln
// Schlüssel weiterhin nicht direkt lesbar
nvm_data <= read_production_nvm(nvm_addr);
end else begin
nvm_data <= 32'b0;
end
end
end
endmodule
// SICHER: Gerätespezifische eindeutige Schlüsselableitung
module secure_key_provisioning (
input wire clk,
input wire rst_n,
input wire provision_enable,
input wire [127:0] diversification_data, // Eindeutig pro Gerät
input wire production_fuse,
output wire [255:0] device_unique_key
);
// SICHER: PUF-basierte eindeutige Schlüsselgenerierung
wire [255:0] puf_response;
puf_block u_puf (
.clk(clk),
.rst_n(rst_n),
.challenge(diversification_data),
.response(puf_response)
);
// SICHER: Geräteschlüssel aus PUF abgeleitet - eindeutig pro Gerät
// Selbst wenn OSAT Schlüssel dieses Geräts extrahiert, sind andere Geräte sicher
kdf_block u_kdf (
.clk(clk),
.rst_n(rst_n),
.puf_secret(puf_response),
.diversifier(diversification_data),
.derived_key(device_unique_key)
);
// SICHER: Schlüssel nur verfügbar nachdem Produktions-Fuse gesetzt ist
// Während OSAT ist Schlüsselableitung deaktiviert
endmodule
// SICHER: Sichere NVM-Bereinigung vor OSAT
module secure_nvm_scrub (
input wire clk,
input wire rst_n,
input wire scrub_enable,
input wire scrub_complete,
output reg nvm_write_enable,
output reg [31:0] nvm_write_addr,
output reg [31:0] nvm_write_data
);
// SICHER: Alle sensiblen Bereiche vor OSAT-Übergabe bereinigen
localparam SCRUB_IDLE = 2'b00;
localparam SCRUB_ACTIVE = 2'b01;
localparam SCRUB_DONE = 2'b10;
reg [1:0] state;
reg [15:0] scrub_counter;
// Zu bereinigende sensible Adressbereiche
localparam SENSITIVE_START = 32'h0000_1000;
localparam SENSITIVE_END = 32'h0000_2000;
always @(posedge clk or negedge rst_n) begin
if (!rst_n) begin
state <= SCRUB_IDLE;
scrub_counter <= 16'b0;
nvm_write_enable <= 1'b0;
end else begin
case (state)
SCRUB_IDLE: begin
if (scrub_enable) begin
state <= SCRUB_ACTIVE;
scrub_counter <= 16'b0;
end
end
SCRUB_ACTIVE: begin
// SICHER: Alle sensiblen NVM-Stellen überschreiben
nvm_write_enable <= 1'b1;
nvm_write_addr <= SENSITIVE_START + {scrub_counter, 2'b00};
nvm_write_data <= 32'h0000_0000; // Oder Zufallsmuster
if (nvm_write_addr >= SENSITIVE_END) begin
state <= SCRUB_DONE;
nvm_write_enable <= 1'b0;
end else begin
scrub_counter <= scrub_counter + 1;
end
end
SCRUB_DONE: begin
nvm_write_enable <= 1'b0;
// Im Done-Zustand verbleiben bis Reset
end
endcase
end
end
endmodule
// SICHER: Sichere Handhabung für OSAT-Übergabe
#include <stdint.h>
#include <string.h>
#include <stdbool.h>
// SICHER: Kein Hauptschlüssel in Firmware
// SICHER: Gerätespezifische eindeutige Schlüsselableitung
// SICHER: Minimale Testschnittstelle
void secure_test_interface(uint32_t command, uint8_t* response) {
switch (command) {
case 0x01: // Nur Geräte-ID
// SICHER: Nur nicht-sensible Bezeichner
get_device_id(response);
break;
case 0x02: // Grundfunktionstest
// SICHER: Testergebnis, keine internen Daten
response[0] = run_basic_test() ? 0x01 : 0x00;
break;
case 0x03: // Fertigungstestmuster
// SICHER: Bekannte Testmuster, keine Geheimnisse
generate_test_pattern(response);
break;
// SICHER: Keine Befehle zum Lesen von Schlüsseln oder sensiblen Daten
default:
memset(response, 0, 64);
break;
}
}
// SICHER: Vor OSAT-Übergabe bereinigen
void secure_prepare_for_osat(void) {
// SICHER: Alle sensiblen NVM-Regionen bereinigen
scrub_nvm_region(SENSITIVE_KEY_REGION_START, SENSITIVE_KEY_REGION_SIZE);
scrub_nvm_region(DEBUG_KEY_REGION_START, DEBUG_KEY_REGION_SIZE);
// SICHER: Sensible Funktionen deaktivieren
disable_secure_debug();
disable_key_export();
// SICHER: Bereinigung abgeschlossen verifizieren
if (!verify_scrub_complete()) {
// Anhalten - nicht mit Geheimnissen an OSAT weiterleiten
enter_lockdown_mode();
}
set_device_state(DEVICE_STATE_PRE_OSAT);
}
// SICHER: Nach-OSAT-Bereitstellung
void secure_post_osat_provision(const uint8_t* device_diversifier) {
if (get_device_state() != DEVICE_STATE_POST_OSAT) {
return;
}
// SICHER: Eindeutigen Geräteschlüssel mittels PUF generieren
uint8_t puf_response[32];
get_puf_response(puf_response);
// SICHER: Eindeutigen Schlüssel ableiten (nie in Rohform gespeichert)
derive_device_key(puf_response, device_diversifier);
// SICHER: Produktionszustand setzen
blow_production_fuse();
set_device_state(DEVICE_STATE_PRODUCTION);
}
// SICHER: Verifizieren dass keine sensiblen Daten vor OSAT vorhanden
bool verify_ready_for_osat(void) {
// Prüfen ob alle sensiblen Bereiche bereinigt sind
if (!is_region_scrubbed(SENSITIVE_KEY_REGION_START, SENSITIVE_KEY_REGION_SIZE)) {
return false;
}
// Prüfen ob Debug deaktiviert ist
if (is_debug_enabled()) {
return false;
}
// Prüfen ob keine Zertifikate bereitgestellt sind
if (has_device_certificate()) {
return false;
}
return true;
}
CVE-Beispiele
- CVE-2019-14615: Vertrauliche Daten über Testschnittstellen während der Fertigung zugänglich.
- CVE-2020-8708: Debug-Schnittstellen legten sensible Informationen gegenüber Drittanbieter-Testeinrichtungen offen.
Verwandte CWEs
- CWE-285: Unsachgemäße Autorisierung (übergeordnet)
- CWE-1195: Fertigungs- und Lebenszyklus-Management-Belange (Kategorie)
- CWE-1244: Internes Asset unsicherem Debug-Zugriff ausgesetzt (verwandt)
- CWE-1263: Unsachgemäße physische Zugriffskontrolle (verwandt)
Referenzen
- MITRE Corporation. "CWE-1297: Unprotected Confidential Information on Device is Accessible by OSAT Vendors." https://cwe.mitre.org/data/definitions/1297.html
- NIST. "SP 800-193 Platform Firmware Resiliency Guidelines"
- Trusted Computing Group. "Hardware Security Guidelines"