What runs here
On a Cortex-A-class HPC, this layer establishes trust before the hypervisor and operating systems start, then keeps selected security functions available during operation. The implementation depends on the SoC and platform; a trusted execution environment (TEE) is one part of the security architecture.
| Component | Role |
|---|---|
| Boot ROM and root-of-trust configuration | Start from implicitly trusted code and anchor verification in protected key material or a public-key hash. |
| Authenticated boot stages | Initialize hardware and verify subsequent executable images and security-relevant configuration before use. |
| Secure monitor firmware | Mediate transitions between Arm Secure and Non-secure execution states. |
| TEE runtime and trusted applications | Provide isolated services such as controlled key use, cryptographic operations and protected storage. |
| Boot policy and recovery logic | Enforce accepted versions, choose a bootable image and handle verification failures. |
“Each stage verifies the next” is a useful introduction, but real chains can branch: one loader may authenticate several payloads. Trusted Firmware-A provides an example covering secure firmware and the normal-world bootloader; the platform must extend verification through its remaining software. Trusted Firmware-A documentation.
Why it looks like this
An HPC starts a substantial software stack from external storage and serves workloads that change through updates. Separating a small trust foundation from frequently updated applications limits how much code must handle secrets or enforce boot policy. It also creates dependencies: firmware, hypervisor, operating systems and trusted applications need compatible interfaces and coordinated recovery.
The silicon shapes the design. Arm TrustZone provides Secure and Non-secure execution states, with protection extending into memory, peripherals and bus transactions. A TEE uses these mechanisms; it may also use an HSM or another security processor for selected operations. Its protection depends on the complete SoC configuration. Arm TrustZone for Cortex-A.
Verification, storage access and memory initialization consume startup time. Engineers must budget them against vehicle availability requirements and measure complete boot and wake-up paths. Existing SoC security hardware can reduce additional component cost, but protected memory, integration and maintenance still have costs.
The node’s QM–ASIL B context does not establish the safety integrity of its TEE. Secure boot checks authenticity and integrity; an authentic image can still contain defects. Safety-related dependencies need their own analysis, timing evidence and development measures under ISO 26262.
How it connects
Below this layer are reset logic, protected root keys, memory controllers, cryptographic hardware and storage. Firmware configures access restrictions before releasing less-trusted software, including restrictions for DMA-capable devices such as accelerators.
Above it, the authenticated loader starts the hypervisor or operating system and supplies validated boot configuration. Verification must cover executable payloads and configuration that can change their security properties; checking only the initial loader leaves gaps.
During operation, OS clients reach trusted applications through a driver and controlled calls into secure firmware. GlobalPlatform’s TEE Client API specifies communication between ordinary applications and trusted applications; its TEE Internal Core API specifies services available inside the TEE. Shared buffers require careful validation because the caller can be hostile. Client API, Internal Core API.
An OTA client supplies candidate images, while trusted boot policy decides what may execute. Other nodes authenticate their own software independently. Secure boot on the HPC does not authenticate network traffic or prove a peer’s current state.
Compared with other node classes
- HPC safety island: Boot ROM and HSM-backed verification commonly protect a smaller MCU software stack, with separate reset, startup and safety dependencies.
- Zone controller and MCU-based ECU: A flash bootloader typically verifies a more compact application image, potentially using an HSM; a rich TEE service boundary is less central.
- Smart node / LIN slave: ROM or a simple bootloader reflects tighter memory and cost constraints; cryptographic verification capabilities must be checked for the actual device.
Best practices
- Document the trust chain, including configuration, accelerator firmware, recovery images and every alternate boot path.
- Protect production trust anchors and signing keys; define provisioning, key rotation and debug-access policy.
- Combine signature checks with rollback protection, and coordinate version enforcement with power-loss-safe recovery.
- Keep trusted services small; authorize each operation and validate shared-memory inputs before use.
- Verify memory and peripheral isolation, including DMA paths, against the SoC’s security documentation.
- Test corrupted images, interrupted updates, incompatible versions and verification failures against startup deadlines and vehicle recovery requirements.
Common pitfalls
- Treating a valid signature as proof that software is safe, current or free of vulnerabilities.
- Leaving recovery, manufacturing or diagnostic boot paths outside the authentication policy.
- Assuming a TEE automatically provides physical-attack resistance, real-time guarantees or safety partitioning.
- Rejecting an image without defining how the vehicle reports the fault and reaches an appropriate degraded or safe condition.