Increasing trust with measured & verified boot

Michael "MC" Cardell Widerkrantz (Tillitis)

SEC-T 2026 · Day 1 · Main hall

Overview

In an era where trust in computing systems is paramount yet increasingly elusive, Michael "MC" Cardell Widerkrantz, a member of the technical staff at Tillitis, presented an insightful talk at SEC-T on enhancing system trustworthiness through measured and verified boot processes. Titled "Increasing trust with measured & verified boot," the presentation delved into the inherent complexities of traditional secure boot mechanisms and proposed a novel, more flexible approach, particularly for environments requiring frequent software updates without compromising cryptographic integrity.

Watch on YouTube

Visual summary for Increasing trust with measured & verified boot by Michael "MC" Cardell Widerkrantz
Visual summary for Increasing trust with measured & verified boot by Michael "MC" Cardell Widerkrantz

Key moments

  1. 0:00 Introduction to Measured Boot and trust challenges
  2. 2:00 Defining "Measured Boot" and its core principles
  3. 3:40 How Unique Device Secret (UDS) forms CDI
  4. 7:40 The problem: Updates change keys, losing secrets
  5. 8:30 Solution overview: Resets, chaining, and hybrid boot
  6. 11:45 Introducing verified boot to maintain CDI across updates
  7. 16:30 Guaranteed consistent CDI even with program updates
  8. 19:00 Open questions: Key distribution and downgrade attacks

Increasing trust with measured & verified boot

Speakers: Michael "MC" Cardell Widerkrantz (Tillitis)

Conference: SEC-T

YouTube: https://www.youtube.com/watch?v=H3BAsRau664

Overview

In an era where trust in computing systems is paramount yet increasingly elusive, Michael "MC" Cardell Widerkrantz, a member of the technical staff at Tillitis, presented an insightful talk at SEC-T on enhancing system trustworthiness through measured and verified boot processes. Titled "Increasing trust with measured & verified boot," the presentation delved into the inherent complexities of traditional secure boot mechanisms and proposed a novel, more flexible approach, particularly for environments requiring frequent software updates without compromising cryptographic integrity.

The talk addresses a critical challenge: how to genuinely trust a computer when existing solutions like Secure Boot and Trusted Platform Modules (TPMs) are often convoluted, with specifications spanning thousands of pages. MC introduces a simplified, yet robust, methodology rooted in the principles of Measured Boot but extended to incorporate Verified Boot capabilities. This hybrid approach aims to offer strong guarantees about the integrity and authenticity of software running on a device, ensuring that cryptographic keys remain consistent even when the underlying programs are updated.

This work is particularly significant for its open-source nature, exemplified by the Tillitis T key project. By detailing the evolution from basic measured boot to a sophisticated chained and verified boot system, MC highlights how hardware-backed trust anchors, combined with intelligent software design, can create systems that are both highly secure and adaptable. The discussion serves as a call to action for the security community, inviting collaboration on outstanding challenges like key distribution and downgrade attack mitigation.

Background

▶ Watch: Introduction to Measured Boot and trust challenges (0:00)

The foundational challenge MC addresses revolves around the inherent complexity and limitations of existing trust mechanisms in computing. While systems like Secure Boot and Trusted Platform Modules (TPMs) aim to establish a secure foundation, their specifications are notoriously intricate, making them difficult to implement correctly and audit effectively. MC humorously refers to the TPM specification as "huge," underscoring the need for simpler, more transparent alternatives.

His exploration begins with a nod to prior work, specifically Microsoft Research's Robust Internet of Things (RIOT) project, which has since evolved into the Trusted Computing Group's (TCG) DICE (Device Identifier Composition Engine) standard. While DICE itself has grown in complexity, MC emphasizes that it contains "nice nuggets" worth expanding upon. He then defines his core concept of "measurement": a trusted piece of code (often firmware or hardware) computes a hash digest of data (CPU instructions, critical data), stores this digest securely where it cannot be tampered with, and makes it available for reading by other components. This is presented as a simpler alternative to the Platform Configuration Registers (PCRs) found in TPMs.

The initial measured boot scheme MC describes envisions a "green field" hardware device without legacy x86 complexities. Here, a trusted bootloader firmware (resident in ROM or hardwired into the chip design) initiates the process. This bootloader measures the "first mutable code," termed Layer Zero. The measurement process is critical: it combines a Unique Device Secret (UDS)—a truly random, hardware-protected sequence inserted during manufacturing—with the hash of the program binary (representing its integrity). Optionally, a User-Supplied Secret (USS), such as a user-entered password, can also be incorporated.

These elements are combined to compute the Compound Device Identity (CDI). The Measured App ID is specifically defined as a hash over the entire program in memory, with Tillitis using the Blake2s hash function. The CDI itself is then derived as hash(UDS, USS, Measured App ID). This CDI serves as the base secret for the entire system; it is not persistent but can be used to generate other secrets or key pairs. A crucial aspect is its trusted on first use (TOFU) nature: a public key derived from the CDI is registered during initial provisioning, allowing subsequent verification that the corresponding private key resides within the specific device running the expected software.

However, a significant limitation emerges: the CDI and any derived private keys are directly dependent on the exact program binary. If even "one bit of the program" changes, the CDI and all derived cryptographic keys also change. While this offers strong integrity (a malicious app would generate "the wrong private key"), it presents an insurmountable problem for software updates, as every update would invalidate all existing keys, forcing a complete re-provisioning. This fundamental conflict between strong integrity and practical updateability forms the core problem that MC and Tillitis sought to solve.

Key Findings

▶ Watch: How Unique Device Secret (UDS) forms CDI (3:40)

The central discovery and contribution of MC's talk is the development of a hybrid Measured and Verified Boot system that resolves the critical dilemma of software updates invalidating cryptographic keys in a purely measured boot environment. The existing measured boot, while providing robust integrity guarantees by tying cryptographic identity directly to the executing software and hardware, inadvertently created a barrier to practical software maintenance. Any update, no matter how minor, would alter the program binary, thus changing the Compound Device Identity (CDI) and rendering all derived cryptographic keys useless.

Tillitis's solution introduces several interconnected mechanisms to overcome this:

  1. Hardware Resets and Chaining of Apps: The system leverages hardware resets that return control to the trusted bootloader. This allows for a chain of applications, where one program (or "layer") can execute, perform its function, and then trigger a reset, enabling the bootloader to load and measure the next program. This chaining is fundamental to building a multi-stage boot process.
  1. Two Kinds of App Identity Measurement: Beyond merely hashing the entire program binary (the "measured" identity), the system introduces a "verified" identity. This new identity is based on a digest of the publisher's public key and potentially the app name, allowing for verification against a trusted publisher without binding the identity to the exact binary.
  1. CDI Confidentiality Between Apps: To enhance security and modularity within the boot chain, the system ensures that the CDI of one layer is not directly visible to subsequent layers. Instead, a layer can leave specific data to be incorporated into the next layer's measurement, maintaining a cryptographically secure chain without exposing intermediate secrets.
  1. A Combined Boot Process: The most significant finding is the integration of these elements into a phased boot process. A designated "verifier" application (Layer Zero) is measured and launched. This verifier then takes on the role of cryptographically validating the next application against a publisher's signature. If the verification is successful, the verifier instructs the trusted firmware to load the next application, providing it with the verified digest (based on publisher key/app name) rather than the raw program hash. The firmware then loads the actual binary, hashes it, and compares it against this pre-verified digest. If they match, the new application is launched, and its CDI is computed using the chained measured app ID and the publisher-verified identity.

This innovative combination guarantees that the CDI remains consistent across software updates, provided the update originates from the same trusted publisher and maintains the expected identity (e.g., app name). It effectively allows for secure, integrity-preserving updates without the catastrophic loss of cryptographic keys, thereby addressing the core limitation of pure measured boot. The solution is presented as an open-source project, inviting community contributions to refine aspects like key distribution and robust downgrade attack mitigation.

Technical Deep Dive

▶ Watch: Solution overview: Resets, chaining, and hybrid boot (8:30)

The core of Tillitis's innovation lies in its intricate combination of measured and verified boot principles, orchestrated through hardware resets and a multi-stage application chaining mechanism. This system is designed to maintain cryptographic identity across software updates, a critical challenge for purely measured boot environments.

Chaining of Programs and CDI Confidentiality

The process begins with the trusted bootloader firmware, which incorporates a DICE engine. This bootloader, residing in ROM or hardware, is implicitly trusted.

  1. Layer Zero Measurement: The bootloader first measures Layer Zero, the initial mutable code.
  2. Chained Resets: After Layer Zero executes, it does not directly launch the next program. Instead, it triggers a reset back to the bootloader. This allows the bootloader to remain in control of all measurements.
  3. Inter-layer Measurement: A key feature is that one program can "leave something" to be used in the measurement of the next. For instance, Layer N can leave specific data.
  4. CDI Confidentiality: To ensure that the CDI of one layer (N) is not exposed to subsequent layers (N+1), the firmware plays an intermediary role. When Layer N performs a chain reset and leaves data, the firmware computes a Measured App ID using hash(current_CDI_of_Layer_N, data_left_by_Layer_N). A real hardware reset then occurs. Critically, the next layer (N+1) does not directly receive Layer N's CDI; its own CDI is derived from the firmware-computed Measured App ID, effectively creating a secure, opaque chain. This guarantees unique secrets for an entire boot chain without exposing intermediate CDIs.

Combined Measured and Verified Boot Stages

The system introduces a new concept of app identity for verified boot: a digest formed from the publisher's public key and potentially the app name. This identity is combined with the chained measured app ID to establish trust. The process unfolds in four distinct stages:

Stage 1: Load and Measure Layer Zero (The Verifier)

  • The firmware loads a small device application called the verifier.
  • The App ID is the verifier program binary itself.
  • The Measured App ID is a digest(entire verifier program).
  • The CDI for the verifier is computed as hash(Unique Device Secret (UDS), User-Supplied Secret (USS), Measured App ID of verifier).
  • The verifier application then starts execution.

Stage 2: Verifier Checks Signature and Prepares Next App

  • The verifier (now running as a device app) fetches metadata for the next program to be loaded. This metadata includes the publisher's public key, the signature over the next app's digest, and the app digest itself (representing the integrity of the next program). Optionally, the name of the next program might also be included.
  • The verifier's crucial task is to verify the signature over the app digest (and potentially the name) against the publisher's public key. If this verification fails, the process halts.
  • If successful, the verifier computes a new App ID specifically for the next program, based on digest(name_of_next_app, publisher's_key). This is the "verified" identity.
  • The verifier then initiates a system call reset back to the firmware. This reset call includes an "intention": to start the next app as a "verified app," providing the already verified app digest to the firmware.

Stage 3: Firmware Prepares for Verified Load

  • The firmware receives the reset call from the verifier.
  • It computes a new Measured App ID for the upcoming program. This is derived as digest(current_CDI_of_verifier, verified_App_ID_from_Stage_2). This step integrates the trust chain from the verifier into the measurement for the next app.
  • A real hardware reset then occurs, returning control to the bootloader.

Stage 4: Correct App Digest and New App Starts

  • The firmware starts again after the hardware reset. It proceeds to load the new program binary.
  • It computes a hash of the entire newly loaded program.
  • This computed hash is then compared against the verified app digest that was left by the verifier in Stage 2.
  • Integrity Check: If the hashes do not match, the system enters a fail state, indicating tampering or an incorrect program.
  • CDI Computation: If the hashes match, the firmware proceeds to compute the CDI for this new, verified app. The computation is hash(UDS, USS, Measured_App_ID_from_Stage_3).
  • Result: The new app starts. Crucially, its CDI is guaranteed to be the same even if the program binary is different from a previous version, as long as it originates from the same publisher and retains the same verified identity (publisher key + app name).

Guarantees Achieved

This multi-stage process provides several strong guarantees:

  • Correct Boot Stages: It ensures that the entire sequence of boot stages was executed as intended. Any modification to the verifier or the boot chain would result in a different CDI.
  • Verified Code Execution: The system guarantees that the verified code that ran was indeed the code intended.
  • Publisher and App Identity: It confirms that the loaded app originated from a specific publisher (via their key) and has a particular name. Changing the publisher or app name would also alter the CDI.

This sophisticated chaining and verification mechanism effectively allows Tillitis to solve the update problem, enabling secure software updates without the catastrophic loss of cryptographic keys that plagued earlier measured boot approaches.

Demo / Proof of Concept

▶ Watch: Introducing verified boot to maintain CDI across updates (11:45)

While the talk itself did not feature a live, interactive demonstration, MC clearly stated that Tillitis has "working code for this." He further elaborated on the practical implementation by referencing the "Tillitis T key" product, which is entirely open source, including its threat model. For the specific boot verification mechanisms discussed, he pointed to an "upcoming generation" of their product, with the boot verifier and management client application residing in their own dedicated repositories. This indicates that the concepts detailed in the technical deep dive are not merely theoretical but have been translated into tangible, open-source codebases, serving as a robust proof of concept for their innovative measured and verified boot architecture.

Defensive Implications

▶ Watch: Open questions: Key distribution and downgrade attacks (19:00)

The Tillitis approach to measured and verified boot offers significant defensive implications for developers, vendors, and users in securing computing systems. By addressing the limitations of traditional measured boot, it provides a pathway to stronger, more flexible security postures.

For Product Developers and Vendors:

  1. Enhanced Supply Chain Security: The combination of a Unique Device Secret (UDS), User-Supplied Secret (USS), and the Measured App ID for the Compound Device Identity (CDI) provides a strong cryptographic binding of software to specific hardware and user context. This helps ensure that only authorized software runs on a given device, mitigating risks from compromised supply chains or unauthorized modifications.
  2. Secure Software Updates: The most critical defensive implication is the ability to perform secure software updates without invalidating all derived cryptographic keys. By introducing the verifier app and the publisher-based app identity, vendors can push updates confidently, knowing that the device's cryptographic identity remains intact as long as the update is genuinely from the trusted publisher. This eliminates a major operational hurdle for maintaining security patches and new features.
  3. Layered Trust Architecture: The concept of chained applications and CDI confidentiality between layers allows for the construction of deeply secure, multi-stage boot processes. Each layer can contribute to the overall trust without exposing its specific secrets to subsequent, potentially less trusted, layers. This enables a granular approach to trust, where critical components can establish their integrity before handing off to more complex or user-facing applications.
  4. Open Source for Scrutiny and Collaboration: The Tillitis T key project being entirely open source encourages transparency and community review. This allows security researchers and other developers to scrutinize the implementation, identify potential weaknesses, and contribute to its hardening, fostering a more robust and trustworthy ecosystem.
  5. Reduced Complexity (Compared to TPMs): While still complex, the design aims to be simpler and more auditable than the vast specifications of traditional TPMs. This "simpler" approach can lead to fewer implementation bugs and easier verification of security properties.

Open Challenges and Defensive Considerations:

MC explicitly highlighted two significant open questions that require further defensive innovation:

  1. App Identity Measurement: The choice of what constitutes the "verified app identity" (just the app name, just the publisher's key, or both) has implications for key distribution. If only the publisher's key is used, every app would need a unique key pair, necessitating a robust and scalable public key distribution mechanism to all users. This is a non-trivial challenge, especially for large ecosystems.
  2. Downgrade Attacks: The current system, particularly when loading apps from a client (e.g., mobile phone or laptop), does not inherently store version information. This leaves it vulnerable to downgrade attacks, where an attacker could force the device to load an older, known-exploitable version of an application. Defending against this requires a mechanism to track and enforce minimum software versions, potentially through signed version manifests or secure non-volatile storage for version numbers. This is a critical area for future research and development to ensure comprehensive security.

In summary, Tillitis's work provides a compelling framework for building trust in modern computing environments, particularly for embedded and IoT devices. By enabling secure updates while maintaining strong cryptographic integrity, it addresses a fundamental weakness of prior measured boot systems. However, active engagement with the community is essential to fully mature the solution, especially in tackling the identified challenges of key distribution and downgrade attack prevention.

Key Takeaways

  • Traditional measured boot, while providing strong integrity by binding cryptographic keys to specific software, severely hinders software updates by invalidating all keys with any program change.
  • Tillitis's solution combines measured and verified boot principles, leveraging hardware resets and a multi-stage application chaining mechanism to enable secure software updates without losing cryptographic identity.
  • The Compound Device Identity (CDI) is foundational, derived from a Unique Device Secret (UDS), an optional User-Supplied Secret (USS), and the Measured App ID, ensuring cryptographic keys are unique to the device, user, and software.
  • A dedicated "verifier" application (Layer Zero) plays a crucial role by cryptographically verifying subsequent applications against a publisher's public key and app name before they are loaded, ensuring authenticity.
  • The system guarantees that the CDI remains consistent across software updates as long as the update originates from the same trusted publisher and maintains the expected identity.
  • Significant open challenges remain, including optimizing the definition of app identity for key distribution and, critically, implementing robust defenses against downgrade attacks where older, vulnerable software versions could be loaded.

About the Speaker(s)

Michael "MC" Cardell Widerkrantz is a member of the technical staff at Tillitis, a company focused on enhancing trust in computing systems through innovative boot processes. Beyond his work at Tillitis, he maintains a personal webpage at hack.org and a Gemini capsule. His presentation at SEC-T showcased his deep expertise in system security, cryptographic trust anchors, and the practical challenges of securing modern hardware and software ecosystems.

Reviews

Dr. Zero (Offensive Security Researcher) — SOLID

MC tackles the most infuriating part of DICE and pure measured boot: the fact that a single-bit patch nukes your entire key hierarchy. Tillitis's hybrid approach of a Layer Zero verifier passing publisher digests to firmware is an elegant, open-source fix to a real operational nightmare. It's solid defensive engineering, even if the glaring lack of anti-rollback counters keeps it from being perfect.

Heather Calloway (CISO) — SOLID

This is a hardware engineering talk aimed at solving the operational nightmare of measured boot: the fact that patching a binary destroys its cryptographic identity. It is deep in the weeds of bootloader mechanics, but the core business problem is highly relevant to how we manage fleet updates and embedded device lifecycles. Worth tracking for endpoint architects, though not ready for leadership review.

→ Top-rated talks at SEC-T 2026

All talks from SEC-T 2026