DICE hardware requirements define how an embedded platform can create a device identity tied to both a device-specific secret and the software that begins running after reset. The Device Identifier Composition Engine (DICE) creates a Compound Device Identifier (CDI) before handing control to the first mutable code. For automation equipment and other embedded systems, this offers a hardware-rooted way to distinguish software states for potential use in device attestation, including where a Trusted Platform Module (TPM) is not available.
How DICE derives a Compound Device Identifier
The CDI combines two inputs: the Unique Device Secret (UDS) and a cryptographic measurement of the first mutable code. A measurement is a hash, or equivalent cryptographic representation, of code or data. The first mutable code is the first software that is not inherently trusted and runs after DICE completes its operations. DICE may also include measurements of hardware state or configuration when those factors influence execution of that code.
This sequence matters because the CDI is associated with both the platform and its measured starting software state. If the first mutable code or an included configuration changes, the resulting CDI changes. A software update, for example, produces a different identifier when the updated code is measured. This can support attestation of which software state is running, but the CDI alone does not establish trust: the surrounding attestation process and protection of the identifier remain important.
DICE hardware requirements begin with secret isolation
The UDS is normally known only to DICE and is used to derive the CDI. It must be statistically unique and uncorrelated with other UDS values, and it must not be reused as an identity value by another entity. Its security strength must be at least as strong as that of the device’s attestation process. Where that process is determined by software outside the manufacturer’s control, the specification recommends a UDS of at least 256 bits. The UDS should not be rewritable; changing it changes the device identity and may disrupt attestation or access to stored device secrets.
DICE must have exclusive read access to the UDS. In practical hardware terms, the design must prevent other code or interfaces from observing the secret. The specification also addresses debug access: if a device has a debug port or mode, it may be enabled only at reset or by software running after DICE, and attempts to read the UDS while debug is enabled must be denied or return a value uncorrelated with the secret.
These controls make the reset sequence a security boundary. DICE must execute without interference each time the device resets and before any mutable code. It measures the first mutable code, derives the CDI, disables further UDS access until the next reset, and securely erases values that could reveal the UDS before transferring control.
Choosing a protected derivation method
The UDS and code measurement must be combined through a one-way function so that knowing the CDI and the measurement does not make it feasible to recover the secret. The specification gives two examples:
- Hash-based derivation: H(UDS || H(First Mutable Code)), where the code is hashed and combined with the UDS before a further hash.
- HMAC-based derivation: HMAC(UDS, H(First Mutable Code)), using the UDS as the HMAC key.
The manufacturer selects the method; the specification does not require one approach for interoperability. It describes HMAC as providing stronger protection for the UDS than a simple hash construction. The chosen one-way function must meet the security strength of the attestation process. Where attestation is determined by software outside manufacturer control, the CDI strength should be at least 256 bits.
Immutability and trusted updates
DICE can be immutable or securely updateable under the control of its manufacturer. An immutable implementation must remain unchanged by the end of manufacturing. An updateable implementation must use a manufacturer-controlled secure update process and continue to comply with the specification after an update.
Updates to DICE or its dependencies are not reflected in the CDI. That makes the integrity of the DICE update mechanism a key trust consideration: users rely on those protections to have confidence that changes in the UDS, measured first mutable code, or included configuration are what account for CDI differences. The manufacturer-controlled update process should not change the CDI.
Protecting the CDI after generation
Deriving the CDI is only one part of a secure implementation. The device must protect the CDI from unauthorized reading, writing, or modification. The specification does not prescribe a particular CDI protection mechanism, so system designers need to account for the platform’s memory, execution flow, and hardware access controls.
DICE must place the CDI where the measured first mutable code has exclusive access for as long as that access is needed. The first mutable code is expected to use the CDI and erase it, along with values that could reveal it, after use. If hardware cannot protect the identifier, the first mutable code must reduce opportunities for exposure. A leaked CDI may create risks such as replay or impersonation, so limiting its lifetime and access is a design priority.
Practical implications for embedded system designers
For engineers developing programmable components, the DICE model connects boot-time measurement to device identity through a defined hardware sequence. Design reviews should verify that:
- DICE runs first after reset and measures the intended first mutable code.
- The UDS is unique, sufficiently strong, and isolated from debug and other access paths.
- The derivation function prevents recovery of the UDS from the CDI and known measurement.
- Any DICE update mechanism is secure and trusted, since its changes are not represented in the CDI.
- The CDI and intermediate secret-related values are protected and erased when no longer needed.
DICE does not replace the broader security architecture or define how the CDI must be used in an attestation protocol. It establishes a hardware-rooted derivation process whose value depends on correct measurement, secret isolation, trusted engine behavior, and careful handling of the resulting identifier. For industrial and embedded platforms, treating these requirements as part of boot and hardware design helps make software-state identity a deliberate, reviewable part of the system’s security model.