logo

Incorrect Initialization of Resource

Incomplete Class
Structure: Simple
Description

This weakness occurs when a system fails to properly set up a resource during its creation, leaving it in an unstable, incorrect, or insecure state when used later.

Extended Description

In software, this often happens due to reliance on implicit or default initialization. For instance, in C, stack memory isn't automatically cleared, and many scripting languages assign a default null or zero value to uninitialized variables. This can lead to critical security flaws if the resource controls access, like an authentication flag, or holds sensitive configuration data. In hardware, similar issues arise from incorrect reset values, misconfigured security fuses, or physical defects. Even if fuses are programmed correctly, broken lines or interfering hardware can corrupt the value. This incorrect initialization during boot or reset can compromise the entire device's security posture from the start.
Common Consequences 3
Scope: Confidentiality

Impact: Read MemoryRead Application DataUnexpected State

Scope: AuthorizationIntegrity

Impact: Gain Privileges or Assume Identity

Scope: Other

Impact: Varies by Context

The technical impact can vary widely based on how the resource is used in the product, and whether its contents affect security decisions.
Potential Mitigations 4
Phase: Implementation
Choose the safest-possible initialization for security-related resources.
Phase: Implementation
Ensure that each resource (whether variable, memory buffer, register, etc.) is fully initialized.
Phase: Implementation
Pay close attention to complex conditionals or reset sources that affect initialization, since some paths might not perform the initialization.
Phase: Architecture and Design
Ensure that the design and architecture clearly identify what the initialization should be, and that the initialization does not have security implications.
Demonstrative Examples 3

ID : DX-162

Consider example design module system verilog code shown below. The register_example module is an example parameterized module that defines two parameters, REGISTER_WIDTH and REGISTER_DEFAULT. Register_example module defines a Secure_mode setting, which when set makes the register content read-only and not modifiable by software writes. register_top module instantiates two registers, Insecure_Device_ID_1 and Insecure_Device_ID_2. Generally, registers containing device identifier values are required to be read only to prevent any possibility of software modifying these values.

Code Example:

Bad
Verilog

// Parameterized Register module example // Secure_mode : REGISTER_DEFAULT[0] : When set to 1 register is read only and not writable// module register_example #( parameter REGISTER_WIDTH = 8, // Parameter defines width of register, default 8 bits parameter [REGISTER_WIDTH-1:0] REGISTER_DEFAULT = 2**REGISTER_WIDTH -2 // Default value of register computed from Width. Sets all bits to 1s except bit 0 (Secure _mode) ) ( input [REGISTER_WIDTH-1:0] Data_in, input Clk, input resetn, input write, output reg [REGISTER_WIDTH-1:0] Data_out );

reg Secure_mode;

always @(posedge Clk or negedge resetn)

verilog
These example instantiations show how, in a hardware design, it would be possible to instantiate the register module with insecure defaults and parameters.
In the example design, both registers will be software writable since Secure_mode is defined as zero.

Code Example:

Good
Verilog

register_example #(

verilog

ID : DX-163

This code attempts to login a user using credentials from a POST request:

Code Example:

Bad
PHP


// $user and $pass automatically set from POST request*
if (login_user($user,$pass)) {
```
$authorized = true;
}


php
Because the $authorized variable is never initialized, PHP will automatically set $authorized to any value included in the POST request if register_globals is enabled. An attacker can send a POST request with an unexpected third value 'authorized' set to 'true' and gain authorized status without supplying valid credentials.
Here is a fixed version:
Code Example:
Good
PHP
php


...*
This code avoids the issue by initializing the $authorized variable to false and explicitly retrieving the login credentials from the $_POST variable. Regardless, register_globals should never be enabled and is disabled by default in current versions of PHP.
ID : DX-222
The following example code is excerpted from the Access Control module, acct_wrapper, in the Hack@DAC'21 buggy OpenPiton System-on-Chip (SoC). Within this module, a set of memory-mapped I/O registers, referred to as acct_mem, each 32-bit wide, is utilized to store access control permissions for peripherals [REF-1437]. Access control registers are typically used to define and enforce permissions and access rights for various system resources.
However, in the buggy SoC, these registers are all enabled at reset, i.e., essentially granting unrestricted access to all system resources [REF-1438]. This will introduce security vulnerabilities and risks to the system, such as privilege escalation or exposing sensitive information to unauthorized users or processes.
Code Example:
Bad
Verilog
module acct_wrapper #(
...


verilog


acct_mem[j] <= 32'hffffffff;**
end
end
...
To fix this issue, the access control registers must be properly initialized during the reset phase of the SoC. Correct initialization values should be established to maintain the system's integrity, security, predictable behavior, and allow proper control of peripherals. The specifics of what values should be set depend on the SoC's design and the requirements of the system. To address the problem depicted in the bad code example [REF-1438], the default value for "acct_mem" should be set to 32'h00000000 (see good code example [REF-1439]). This ensures that during startup or after any reset, access to protected data is restricted until the system setup is complete and security procedures properly configure the access control settings.
Code Example:
Good
Verilog
module acct_wrapper #(
...


verilog


acct_mem[j] <= 32'h00000000;**
end
end
...
  
Observed Examples 5
CVE-2020-27211Chain: microcontroller system-on-chip uses a register value stored in flash to set product protection state on the memory bus and does not contain protection against fault injection (Improper Protection against Electromagnetic Fault Injection (EM-FI)) which leads to an incorrect initialization of the memory bus (Incorrect Initialization of Resource) causing the product to be in an unprotected state.
CVE-2023-25815chain: a change in an underlying package causes the gettext function to use implicit initialization with a hard-coded path (Incorrect Initialization of Resource) under the user-writable C:\ drive, introducing an untrusted search path element (Uncontrolled Search Path Element) that enables spoofing of messages.
CVE-2022-43468WordPress module sets internal variables based on external inputs, allowing false reporting of the number of views
CVE-2022-36349insecure default variable initialization in BIOS firmware for a hardware board allows DoS
CVE-2015-7763distributed filesystem only initializes part of the variable-length padding for a packet, allowing attackers to read sensitive information from previously-sent packets in the same memory location
  
References 3
acct_wrapper.sv
2021
https://github.com/HACK-EVENT/hackatdac21/blob/65d0ffdab7426da4509c98d62e163bcce642f651/piton/design/chip/tile/ariane/src/acct/acct_wrapper.sv#L39
ID: REF-1437
Bad Code acct_wrapper.sv
2021
https://github.com/HACK-EVENT/hackatdac21/blob/65d0ffdab7426da4509c98d62e163bcce642f651/piton/design/chip/tile/ariane/src/acct/acct_wrapper.sv#L79C1-L86C16
ID: REF-1438
Good Code acct_wrapper.sv
2021
https://github.com/HACK-EVENT/hackatdac21/blob/062de4f25002d2dcbdb0a82af36b80a517592612/piton/design/chip/tile/ariane/src/acct/acct_wrapper.sv#L84
ID: REF-1439
 
  
    
 
 
Applicable Platforms 
 
 
 
 
 
Languages:
 
 
 Not Language-Specific : Undetermined 
 
 
Technologies:
 
 
 Not Technology-Specific : Undetermined 
 
 
 
  
 
 
Modes of Introduction 
 
 
 
 
 
  Implementation  
 
  Manufacturing  
 
  Installation  
 
  System Configuration  
 
  Operation  
 
 
 
          
 
 
Related Weaknesses 
 
 
 
 
  ChildOf:
 Improper Initialization (CWE-665)