Rationale

Limits of traditional approaches

Embedded computing devices are increasingly required to process and protect large volumes of sensitive data, proprietary algorithms, and complex software components with diverse security and criticality requirements. These systems are increasingly powered by feature-rich operating systems such as Linux, which has become the de facto software platform for a wide range of embedded devices.

Modern embedded software stacks comprise a complex collection of technologies, including bootloaders, secure boot chains, operating system kernels, device drivers, interrupt handlers, cryptographic libraries, networking stacks, file systems, trusted services, middleware, and runtime environments. As embedded systems evolve toward greater connectivity, AI-enabled workloads, and multi-domain execution, the amount of privileged software continues to grow, significantly expanding the system’s attack surface. In conventional monolithic architectures, where strong isolation boundaries are absent, the Trusted Computing Base (TCB)—the set of hardware and software components responsible for enforcing the system’s security guarantees—includes a substantial portion of the software stack. As a result, the TCB grows in size and complexity together with the system itself. Since a vulnerability in any TCB component can compromise the security of the entire platform, this trend represents a critical challenge for the billions of embedded devices deployed worldwide.

Addressing this challenge requires architectures that minimize the TCB by design while providing strong isolation between software domains and integrating robust runtime security mechanisms. Achieving these objectives without sacrificing performance is essential for next-generation embedded, cyber-physical, and Physical AI systems.

Numbers and insights for systems with Linux-based TCB

Despite its widespread adoption, Linux was not designed to serve as a minimal Trusted Computing Base, making it unsuitable as the sole foundation for high-assurance security architectures: - Linux kernel: ~27 million lines of code (and growing) that include device drivers, schedulers, filesystems, network stacks, protocol implementations, and other functionalities - Each component is a potential attack surface - More than 3,000 Linux kernel CVEs were disclosed in 2024 - Researchers now observe ~14 new kernel CVEs per day - Maintaining security across this massive codebase is now becoming economically and operationally unsustainable - Security mechanisms can introduce a drop of the application performance up to 35%

Isn’t a hardware-based TEE such as ARM TrustZone enough?

ARM TrustZone and similar technologies provide a two-world execution model (secure and non-secure), enabling specific security operations. They were designed to serve a different purpose than implementing a TCB for complex Linux-based software. In fact, they suffer from critical limitations:

  1. No guaranteed availability: Being meant for hosting passive, on-demand software invoked by untrusted software (e.g., a Linux-based system), when the latter gets compromised the TEE software can be disabled

  2. Coarse-grained isolation: Only secure/nonsecure distinction; not flexible for multiple security domains

  3. Limited scalability: APIs are fragmented and don’t support modern deployment patterns

  4. Insufficient for dynamic threats: Can’t adapt to evolving threat models

Why BCA?

Bunker-Centric Architecture (BCA) introduces a hypervisor-based architecture that provides fine-grained, dynamic isolation that enriches the capabilities provided by hardware security modes. By splitting the system into two separated domains, Bunker and Open World, with mixed levels of security, BCA aims at:

  • minimizing the Trusted Computing Base with an on-chip zero-trust approach for non-critical software in Open World (e.g., a canonical Linux-based system)

  • providing a confidential computing environment to host active software to guarantee availability of essential functions even when Open World gets compromised or crashes

  • paying security-related overhead only when needed

  • providing the possibility to safely switch the device into a degraded mode, if under attack

  • providing tamper-proof security mechanisms for updates, logging, and runtime monitoring

Ground Principles

Bunker-Centric Architecture with its reference implementation provided by Accelerat offers:

  1. Minimal TCB: Only essential code runs in secure partition

  2. Zero-Trust Architecture: No component besides those in Trusted Computing Base (TCB) are inherently trusted

  3. Hardware Root of Trust: Take advantage of hardware-backed mechanisms (when available) as anchors for security related features.

  4. Isolation by Design: Type-1 CLARE-hypervisor enforces strict boundaries between secure and general purpose environments, with a software-based flexible configuration of the boundaries of the TCB

  5. Compliance-Ready: Designed to meet security requirements required by standards and regulations, like EU’s CRA, IEC 62443, ISO 21434, and others

  6. Yocto-Based: Reference design built on proven embedded Linux tooling for production deployments