Unzureichender Schutz gegen Hardware-Überhitzung
Beschreibung
Unzureichender Schutz gegen Hardware-Überhitzung tritt auf, wenn ein Hardware-Gerät keine oder unzureichende Schutzmaßnahmen hat, um übermäßigen Temperaturanstieg zu verhindern. Hardware-Geräte geben verbrauchte Energie als Wärme ab und erhöhen damit die Gerätetemperatur. Bei Halbleitern erhöhen höhere Betriebsfrequenzen die Verlustleistung und den thermischen Output. CMOS-Leckstrom steigt mit der Temperatur und erzeugt eine positive Rückkopplung, die thermisches Durchgehen und permanente Geräteschäden auslösen kann. Geräte ohne Temperatursensoren, angemessene Kühlung oder Isolierung sind anfällig für bösartige Software, die absichtlich Überhitzungsbedingungen herbeiführt.
Risiko
Schwachstellen durch Hardware-Überhitzung haben schwerwiegende Auswirkungen. Permanente Geräteschäden durch thermisches Durchgehen. Denial of Service durch induzierte Überhitzung. Sicherheitsrisiken durch übermäßige Temperaturen. Zuverlässigkeitsprobleme. Brandgefahr in extremen Fällen. Komponentendegradation. Reduzierte Gerätelebensdauer. Datenverlust bei thermischer Abschaltung. Hohe Wahrscheinlichkeit, wenn Geräte keine thermischen Schutzmechanismen haben.
Lösung
Temperaturober- und -untergrenzen mittels Temperatursensoren sowohl im Silizium als auch auf Plattformebene während der Architektur- und Designphase durchsetzen. Kühllösungen wie Lüfter unterstützen, die basierend auf Gerätebetriebsanforderungen moduliert werden können, um eine stabile Temperatur während der Implementierungsphase aufrechtzuerhalten. Thermisches Throttling implementieren, um die Betriebsfrequenz zu reduzieren, wenn Temperaturen sichere Schwellenwerte überschreiten. Automatische Abschaltmechanismen für kritische Temperaturereignisse hinzufügen.
Häufige Auswirkungen
| Auswirkung | Details |
|---|---|
| Verfügbarkeit | Bereich: Verfügbarkeit Denial of Service durch Ressourcenverbrauch, Geräteschäden und Systeminstabilität durch Überhitzung. |
| Integrität | Bereich: Integrität Permanente Geräteschäden, die die Hardware-Integrität und Zuverlässigkeit beeinträchtigen. |
Beispielcode
Verwundbarer Code
// VERWUNDBAR: Hardware ohne thermischen Schutz
module vulnerable_processor (
input wire clk,
input wire rst_n,
input wire [31:0] instruction,
input wire execute,
output reg [31:0] result,
output reg result_valid
);
// VERWUNDBAR: Keine thermische Überwachung
// Keine Temperatursensoren
// Kein thermisches Throttling
// Keine Notabschaltung
reg [63:0] accumulator;
always @(posedge clk or negedge rst_n) begin
if (!rst_n) begin
result <= 32'b0;
result_valid <= 1'b0;
accumulator <= 64'b0;
end else if (execute) begin
// VERWUNDBAR: Uneingeschränkte Ausführung leistungsintensiver Operationen
// Bösartiger Code kann kontinuierlich Multiply-Accumulate ausführen
// um Stromverbrauch und Wärmeerzeugung zu maximieren
case (instruction[31:28])
4'hF: begin // Leistungsintensives Multiply-Accumulate
accumulator <= accumulator +
(instruction[15:0] * instruction[27:16]);
result <= accumulator[31:0];
result_valid <= 1'b1;
end
// ... andere Instruktionen
default: begin
result <= 32'b0;
result_valid <= 1'b0;
end
endcase
// Angriffsszenario:
// 1. Bösartige Software sendet kontinuierlich 0xF-Instruktionen
// 2. Multiply-Accumulate läuft mit maximaler Rate
// 3. Stromverbrauch steigt sprunghaft
// 4. Temperatur steigt ohne Throttling
// 5. Thermisches Durchgehen möglich
// 6. Geräteschäden oder Brandgefahr
end
end
endmodule
// VERWUNDBAR: Plattform ohne thermisches Management
module vulnerable_platform (
input wire clk,
input wire rst_n,
// Mehrere Prozessorkerne
input wire [31:0] core0_instr,
input wire [31:0] core1_instr,
input wire [31:0] core2_instr,
input wire [31:0] core3_instr,
output wire [31:0] core0_result,
output wire [31:0] core1_result,
output wire [31:0] core2_result,
output wire [31:0] core3_result
);
// VERWUNDBAR: Keine Temperatursensoren auf Plattformebene
// Keine Lüftersteuerung
// Keine Leistungsbegrenzung
// Keine Lastverteilung basierend auf Temperatur
// Alle Kerne können gleichzeitig mit voller Leistung laufen
// Keine Koordination zur Verhinderung von thermischem Durchgehen
vulnerable_processor core0 (
.clk(clk), .rst_n(rst_n),
.instruction(core0_instr),
.execute(1'b1),
.result(core0_result)
);
vulnerable_processor core1 (
.clk(clk), .rst_n(rst_n),
.instruction(core1_instr),
.execute(1'b1),
.result(core1_result)
);
// Weitere Kerne...
endmodule
Sichere Lösung
// SICHER: Hardware mit umfassendem thermischem Schutz
module secure_processor (
input wire clk,
input wire rst_n,
input wire [31:0] instruction,
input wire execute,
// SICHER: Thermische Überwachungsschnittstelle
input wire [11:0] temperature_reading, // Vom Temperatursensor
input wire thermal_warning, // Warnschwelle überschritten
input wire thermal_critical, // Kritische Schwelle überschritten
output reg [31:0] result,
output reg result_valid,
output reg thermal_throttle_active,
output reg thermal_shutdown
);
// SICHER: Thermische Schwellenwerte (in Sensoreinheiten)
localparam TEMP_NORMAL = 12'd2048; // Normalbetrieb
localparam TEMP_WARNING = 12'd3072; // Throttling beginnen
localparam TEMP_CRITICAL = 12'd3584; // Notabschaltung
// SICHER: Throttling-Zustandsmaschine
reg [1:0] thermal_state;
localparam STATE_NORMAL = 2'b00;
localparam STATE_THROTTLE = 2'b01;
localparam STATE_SHUTDOWN = 2'b10;
// SICHER: Throttle-Zähler für reduzierte Ausführungsrate
reg [3:0] throttle_counter;
wire throttle_allow_exec;
// SICHER: Thermisches Zustandsmanagement
always @(posedge clk or negedge rst_n) begin
if (!rst_n) begin
thermal_state <= STATE_NORMAL;
thermal_throttle_active <= 1'b0;
thermal_shutdown <= 1'b0;
end else begin
case (thermal_state)
STATE_NORMAL: begin
thermal_throttle_active <= 1'b0;
thermal_shutdown <= 1'b0;
// SICHER: Temperatur überwachen und Zustände wechseln
if (temperature_reading >= TEMP_CRITICAL) begin
thermal_state <= STATE_SHUTDOWN;
end else if (temperature_reading >= TEMP_WARNING) begin
thermal_state <= STATE_THROTTLE;
end
end
STATE_THROTTLE: begin
thermal_throttle_active <= 1'b1;
thermal_shutdown <= 1'b0;
// SICHER: Bei Abkühlung in Normalzustand zurückkehren
if (temperature_reading < TEMP_NORMAL) begin
thermal_state <= STATE_NORMAL;
end else if (temperature_reading >= TEMP_CRITICAL) begin
thermal_state <= STATE_SHUTDOWN;
end
end
STATE_SHUTDOWN: begin
thermal_throttle_active <= 1'b1;
thermal_shutdown <= 1'b1;
// SICHER: Wiederaufnahme erst nach deutlicher Abkühlung
if (temperature_reading < TEMP_NORMAL) begin
thermal_state <= STATE_NORMAL;
end
end
endcase
end
end
// SICHER: Ausführungsrate drosseln
always @(posedge clk or negedge rst_n) begin
if (!rst_n) begin
throttle_counter <= 4'b0;
end else begin
throttle_counter <= throttle_counter + 1;
end
end
// SICHER: Ausführung nur jeden 4. Zyklus bei Throttling erlauben
assign throttle_allow_exec = (thermal_state == STATE_NORMAL) ||
(thermal_state == STATE_THROTTLE &&
throttle_counter[1:0] == 2'b00);
// SICHER: Ausführung mit thermischem Schutz
reg [63:0] accumulator;
always @(posedge clk or negedge rst_n) begin
if (!rst_n) begin
result <= 32'b0;
result_valid <= 1'b0;
accumulator <= 64'b0;
end else if (thermal_shutdown) begin
// SICHER: Keine Ausführung während thermischer Abschaltung
result_valid <= 1'b0;
end else if (execute && throttle_allow_exec) begin
// SICHER: Nur ausführen wenn thermisch sicher
case (instruction[31:28])
4'hF: begin
accumulator <= accumulator +
(instruction[15:0] * instruction[27:16]);
result <= accumulator[31:0];
result_valid <= 1'b1;
end
default: begin
result <= 32'b0;
result_valid <= 1'b0;
end
endcase
end else begin
result_valid <= 1'b0;
end
end
endmodule
// SICHER: Plattform mit thermischem Management
module secure_platform (
input wire clk,
input wire rst_n,
// Mehrere Prozessorkerne
input wire [31:0] core0_instr,
input wire [31:0] core1_instr,
input wire [31:0] core2_instr,
input wire [31:0] core3_instr,
// SICHER: Temperatursensor-Eingänge
input wire [11:0] package_temp,
input wire [11:0] core0_temp,
input wire [11:0] core1_temp,
input wire [11:0] core2_temp,
input wire [11:0] core3_temp,
input wire [11:0] ambient_temp,
// SICHER: Kühlungssteuerung
output reg [7:0] fan_speed_pwm,
output reg power_limit_active,
output reg emergency_shutdown,
output wire [31:0] core0_result,
output wire [31:0] core1_result,
output wire [31:0] core2_result,
output wire [31:0] core3_result
);
// SICHER: Thermische Schwellenwerte auf Plattformebene
localparam PACKAGE_TEMP_MAX = 12'd3500;
localparam FAN_MIN_PWM = 8'd64;
localparam FAN_MAX_PWM = 8'd255;
// SICHER: Thermische Signale pro Kern
wire [3:0] core_thermal_warning;
wire [3:0] core_thermal_shutdown;
// SICHER: Thermisches Management auf Plattformebene
always @(posedge clk or negedge rst_n) begin
if (!rst_n) begin
fan_speed_pwm <= FAN_MIN_PWM;
power_limit_active <= 1'b0;
emergency_shutdown <= 1'b0;
end else begin
// SICHER: Dynamische Lüftersteuerung basierend auf heißestem Kern
reg [11:0] max_core_temp;
max_core_temp = core0_temp;
if (core1_temp > max_core_temp) max_core_temp = core1_temp;
if (core2_temp > max_core_temp) max_core_temp = core2_temp;
if (core3_temp > max_core_temp) max_core_temp = core3_temp;
// SICHER: Lineare Lüfterkurve
if (max_core_temp < 12'd2048) begin
fan_speed_pwm <= FAN_MIN_PWM;
end else if (max_core_temp >= PACKAGE_TEMP_MAX) begin
fan_speed_pwm <= FAN_MAX_PWM;
end else begin
fan_speed_pwm <= FAN_MIN_PWM +
((max_core_temp - 12'd2048) * (FAN_MAX_PWM - FAN_MIN_PWM)) /
(PACKAGE_TEMP_MAX - 12'd2048);
end
// SICHER: Leistungsbegrenzung bei geringem thermischem Spielraum
power_limit_active <= (package_temp > 12'd3200);
// SICHER: Notabschaltung bei kritischen Temperaturen
emergency_shutdown <= (package_temp >= PACKAGE_TEMP_MAX) ||
(|core_thermal_shutdown);
end
end
// SICHER: Kerne mit thermischem Schutz instanziieren
secure_processor core0 (
.clk(clk), .rst_n(rst_n && !emergency_shutdown),
.instruction(core0_instr),
.execute(!power_limit_active || !core_thermal_warning[0]),
.temperature_reading(core0_temp),
.thermal_warning(core0_temp > 12'd3072),
.thermal_critical(core0_temp > 12'd3584),
.result(core0_result),
.thermal_throttle_active(core_thermal_warning[0]),
.thermal_shutdown(core_thermal_shutdown[0])
);
// Ähnliche Instanziierung für andere Kerne...
endmodule
CVE-Beispiele
- CVE-2020-8694: Intel RAPL-Energieverwaltungsschwachstelle, die Seitenkanal-Angriffe über den Stromverbrauch ermöglicht.
- CVE-2020-8695: Intel Running Average Power Limit (RAPL) Informationsoffenlegung durch Leistungsüberwachung.
Verwandte CWEs
- CWE-693: Protection Mechanism Failure (übergeordnet)
- CWE-1206: Power, Clock, Thermal, and Reset Concerns (Kategorie)
Referenzen
- MITRE Corporation. "CWE-1338: Improper Protections Against Hardware Overheating." https://cwe.mitre.org/data/definitions/1338.html
- Intel. "Thermal Management for Processors"
- JEDEC. "Thermal Measurement and Management Standards"