Lei Zhou
Library · Platform security

From specification to silicon: the SPDM/IDE trust chain

How DICE-rooted device identity, SPDM authentication and attestation, and IDE-protected interconnect compose into a verifiable end-to-end security model for heterogeneous confidential computing, and where storage and post-quantum cryptography fit today.

Lei Zhou · practitioner's synthesis · first published 19 April 2026 · corrected 15 November 2026 · about 15 minutes

About this copy. This article was first published on LinkedIn on 19 April 2026. This page is now the canonical copy. Six factual points were corrected on 15 November 2026 after checking them against primary sources, and a few unconfirmed details were generalised; all are listed in Corrections. Part of its argument continues in From chain of trust to chain of timing.

Revisiting research notes and blog posts I wrote a couple of years ago on confidential computing and OCP security protocols, I was struck by how quickly the industry has moved, from collaborative specification work to production deployment. What I was studying as emerging architecture in 2024 now ships in data-centre silicon. That prompted me to pull my notes together, update them against the current state of the art, and write this as much to sharpen my own understanding as to share it with others tracking the same space.

This article focuses on the trust chain that makes heterogeneous confidential computing architecturally coherent: how DICE-rooted device identity, SPDM-based authentication and attestation, and IDE-protected interconnect compose into a verifiable end-to-end security model, and where the NVMe storage layer and post-quantum cryptography fit into that picture today.

1. Why TLS alone cannot close the threat model

TLS protects data in transit across IP networks by establishing authenticated, encrypted channels between software endpoints. It is well understood, widely deployed and mature. But TLS says nothing about whether the hardware underneath those endpoints is trustworthy, and in heterogeneous compute environments that assumption gap is architecturally significant.

Consider a confidential AI inference workload in an OCP data centre: a tenant's proprietary model weights are loaded into GPU memory over a PCIe or CXL fabric, processed across compute nodes and persisted to NVMe storage, all on infrastructure shared with other tenants and administered by operators outside the tenant's trust boundary. The confidential computing threat model identifies three attack surfaces that TLS cannot address:

  • Physical interconnect attacks: sniffing, tampering with or replaying PCIe Transaction Layer Packets (TLPs) or CXL flits on the physical fabric. TLS terminates at the OS or application layer and never touches the wire between CPU and peripheral.
  • Rogue or cloned components: a counterfeit or compromised accelerator, NIC or storage controller that presents a legitimate-looking interface while exfiltrating data or forging measurement results. The conventional boot stack has no mechanism to verify cryptographically that a PCIe device is what it claims to be.
  • Unauthorised DMA: PCIe devices can read or write host memory asynchronously. An IOMMU confines where a device may write, but it does not authenticate the device or verify its firmware.

Closing these three attack surfaces requires extending the confidential computing trust model outward from the processor enclave to every participating component in the fabric. SPDM and IDE are the industry's collaborative response to exactly that requirement.

2. The OCP platform trust model: three requirements

The Open Compute Project's security appraisal work rests on one idea: trustworthiness in a distributed compute platform is not assumed but constructed, through a verifiable chain of evidence anchored in hardware and extended to every component through measurement and attestation.

In a typical OCP rack, CPU clusters, GPU nodes, DPU offload engines and NVMe storage controllers are connected over PCIe, CXL or InfiniBand. Each device has its own firmware, its own execution environment and its own attack surface. The platform's security posture is bounded by its least-attested component. Three requirements must be satisfied together:

  • Hardware root of trust. Each device needs a hardware-anchored identity provisioned at manufacture, implemented through the TCG DICE (Device Identifier Composition Engine) architecture. DICE derives a Compound Device Identifier (CDI) at each boot layer by applying a one-way function over the current layer's CDI and the hash of the next layer's firmware. A device running modified firmware produces a different CDI, and therefore a different, non-matching attestable identity.
  • Component authentication and attestation. Before a device is admitted to a confidential execution environment, a relying party verifies its identity and firmware integrity through a challenge-response protocol. Boot-time attestation establishes the initial trust state; runtime attestation continuity is still being standardised.
  • Integrity of the confidential execution environment. The TEE stack itself (Intel TDX, AMD SEV-SNP, Arm CCA) must be measured and its measurements reported to the relying party. Extending the same rigour to devices attached over PCIe and CXL is the problem SPDM and IDE were designed to solve.

3. SPDM: device authentication and firmware attestation across transports

The Security Protocol and Data Model (SPDM), defined by DMTF in DSP0274, is a transport-agnostic protocol for authenticating hardware components and exchanging cryptographic measurements over several transport bindings, including PCIe Data Object Exchange, MCTP, storage and TCP. It runs between a Requester, typically the host CPU, a BMC or a TEE Security Manager (TSM), and a Responder, the device: a GPU, NVMe controller, NIC or other endpoint.

Phase 1: capability and algorithm negotiation. The session opens with GET_CAPABILITIES and NEGOTIATE_ALGORITHMS, which settle the SPDM version, hash and asymmetric algorithms and measurement hash types before anything sensitive is exchanged. Negotiation also establishes whether the session will support key exchange for secured messaging, which IDE key management later depends on.

Phase 2: certificate-based device authentication. The Requester retrieves the Responder's certificate chain with GET_DIGESTS and GET_CERTIFICATE. The chain is issued by the manufacturer, provisioned at manufacture and rooted in the device's hardware root of trust. The Requester sends a CHALLENGE with a fresh nonce; the Responder signs it with an attestation private key that is protected by the root of trust and never leaves the device. Verifying that signature against the chain authenticates the device. A counterfeit cannot forge it without the genuine device's key.

Phase 3: firmware measurement and remote attestation. With GET_MEASUREMENTS, the Requester retrieves the Responder's signed firmware measurements, digests of individual firmware components computed by the root of trust during measured boot. A verification service compares them with reference values. A device with modified firmware produces measurements that deviate, and policy decides what follows. This is what defeats the rogue-component attack at its root.

SPDM does for hardware components what TLS does for software endpoints, with the trust anchor in a hardware root of trust rather than a software-managed certificate store. The authenticated identity is bound to the physical device through the DICE CDI chain, not to a software identity that can be stolen or copied.

4. IDE: confidentiality and integrity on the interconnect

Authentication and attestation establish that a device is trustworthy when it is admitted. Integrity and Data Encryption (IDE), defined by PCI-SIG for PCIe and by the CXL Consortium for CXL from 2.0, keeps it that way for every transaction afterwards by encrypting and integrity-protecting traffic on the link.

Selective IDE protects specific streams between a host and a device function, so confidential workload traffic can be separated from management traffic on the same link. Link IDE protects all traffic on one point-to-point link. The right mode depends on the deployment's isolation requirements and overhead budget.

The construction is AES-GCM over the TLP payload and relevant header fields, with replay protection. Keys reach the link in two steps. SPDM KEY_EXCHANGE and FINISH first establish a secure SPDM session using ephemeral key agreement, which gives that session forward secrecy. The IDE stream keys are then delivered over the session by the IDE key management protocol, IDE_KM: the host side programs the keys into the device (KEY_PROG) and switches them on (K_SET_GO). The SPDM session protects key delivery; it does not itself derive the stream keys.

That gives a critical architectural dependency: IDE establishment presupposes a completed SPDM authentication and measurement exchange. The two protocols are not independent. IDE's guarantees mean something only if the device at the other end of the encrypted link has been authenticated and its firmware verified. SPDM is the trust foundation; IDE is the runtime enforcement built on it. IDE without SPDM attestation is encryption without verified identity, which defeats the threat model.

For CXL, IDE covers all three protocols: CXL.io follows PCIe IDE, and CXL.cache and CXL.mem traffic is protected at the flit level. What link protection does not do is bring a memory device inside a confidential VM's trust boundary. CXL 3.1 added the TEE Security Protocol (TSP) for that, for directly attached memory devices. Attestation across CXL switch hops remains open.

5. The complete trust chain: composing DICE, SPDM and IDE

The architectural value comes from the composition, not from any one mechanism. Together they form a verifiable chain from manufacture through runtime:

  1. Root of trust and DICE identity (manufacture). The manufacturer provisions a device identity key pair anchored in the hardware root of trust and seeds the DICE CDI chain, binding each firmware layer's identity to its measured image. The manufacturer's CA issues the attestation certificate. This is the only step that happens outside the operational environment, and it cannot be repeated after the fact.
  2. Measured boot (power-on). The root of trust measures each firmware stage, from bootloader to main image, security firmware and configuration, and derives a new CDI at each layer. Tampering between manufacture and boot shows up as a CDI deviation that SPDM attestation can detect.
  3. SPDM authentication and attestation (session establishment). The Requester negotiates capabilities, retrieves the certificate chain, challenges with a fresh nonce and retrieves signed measurements. The verification result decides whether the device is admitted.
  4. IDE establishment (SPDM secure session, then IDE_KM). After successful attestation, KEY_EXCHANGE and FINISH set up a forward-secret SPDM session, over which IDE_KM programs and activates the stream keys. Every subsequent TLP on the protected stream is encrypted and integrity-protected.
  5. Workload admission and runtime. The device is admitted to the confidential environment. For TEE-IO, TDISP additionally manages the assignment of a device interface to a specific trust domain, giving VM-level granularity of device trust.

6. Where the industry has moved since 2024

When this architecture was discussed in OCP and DMTF working groups in 2023 and 2024, it was forward-looking specification work. Since then:

  • NVIDIA H100 (Hopper). In confidential computing mode the driver in the confidential VM establishes an SPDM session with the GPU. Each GPU carries a device identity key provisioned at manufacture; the verifier checks the certificate chain against NVIDIA's revocation service and compares signed firmware measurements with reference values before the GPU is moved to its ready state.
  • Intel TDX Connect on Xeon 6 (announced 2025). Intel announced TDX Connect, its TEE-IO implementation, to extend the TDX trust boundary to PCIe-attached devices. TDISP messages travel over SPDM secure sessions, giving VM-granularity device assignment with cryptographic trust between trust domains and device functions.
  • Micron 7500 and 6550 ION NVMe SSDs. Both support SPDM 1.2 attestation; the 6550 ION targets the OCP Datacenter NVMe SSD Specification 2.5. Version 2.7 of that specification (2026) has dedicated sections for SPDM certificates and SPDM firmware measurements. NVMe storage attestation has moved from proposal to shipping product.
  • Joint announcement, 28 May 2025. DMTF, the CXL Consortium, NVM Express, PCI-SIG, SNIA and TCG jointly announced SPDM's evolution to support post-quantum cryptography aligned with NSA's CNSA 2.0 suite. Broadcom stated that its PCIe Ethernet NICs and NVMe storage adapters use DMTF's SPDM and PQC standards.

7. The storage layer: where the architecture is still maturing

GPU attestation over SPDM is in production. The NVMe storage layer is where the next chapter is being written, and where the composition of security layers is most complex.

An NVMe controller that implements SPDM takes the Responder role, receiving SPDM messages either over MCTP through the NVMe Management Interface or in-band through the SPDM storage binding. Its firmware must include a correctly isolated SPDM responder: protected by the controller's root of trust, isolated from the data path, and itself included in the device's measurements. If the responder is not in the attestation evidence, the chain is broken at the storage layer. A compromised responder that reports clean measurements while the rest of the firmware is modified is exactly the attack measurement is meant to prevent.

For controllers that host mixed-criticality firmware, separating real-time block I/O from management and security functions, placing the SPDM responder in the right criticality domain is a non-trivial architecture decision. The security firmware must be isolated from the data path while sharing the same root of trust. Getting that partitioning wrong creates measurement gaps an attacker can exploit.

Above SPDM and IDE, TCG Opal, Ruby and Pyrite define self-encrypting drive key management and access control for data at rest on the media. IDE protects data in transit between host and controller; TCG governs keys for data at rest. Both must be composed correctly. IDE without media encryption leaves data unprotected after drive removal. A self-encrypting drive without SPDM attestation cannot have its controller firmware verified before it is trusted with key material.

8. The post-quantum frontier

The May 2025 roadmap is not distant planning. NSA's CNSA 2.0 guidance expects new National Security Systems acquisitions to be CNSA 2.0 compliant from January 2027, a date inside a typical silicon development cycle.

The practical threat is "harvest now, decrypt later" against recorded SPDM sessions. An adversary who captures SPDM key exchange traffic today, including the session that carries IDE key material, can attempt decryption once quantum capability is sufficient to break today's elliptic-curve key exchange. For infrastructure with a decade-plus operational life, that is not theoretical.

Integrating PQC into SPDM is more than substituting algorithms. Certificate chains rooted in the hardware root of trust must be reissued with PQC signatures, and manufacturers must move measurement signing to PQC algorithms at manufacture. The DICE CDI derivation itself uses symmetric key derivation and is not directly exposed, but the asymmetric cryptography in SPDM certificate chains and key exchange is. It is a layered migration, not a single switch.

9. Open problems

  • Multi-hop CXL attestation. CXL switch topologies do not yet have a fully standardised way to forward and verify attestation evidence across hops. A device two switches away cannot yet be attested with the rigour of a directly attached one.
  • Runtime attestation continuity. SPDM attestation is primarily a session-establishment mechanism. Continuous re-measurement through a workload's lifetime is handled inconsistently and is not yet standardised.
  • PQC migration for fielded devices. Devices already deployed with elliptic-curve attestation certificates cannot be reprovisioned with PQC certificates without root-of-trust involvement, and current specifications do not fully address that migration path.

The second of these has a counterpart outside security. A chain of trust verified once at admission says nothing about whether a device keeps behaving, or keeps meeting its deadlines, afterwards. From chain of trust to chain of timing applies the structure of this chain to timing in Physical AI systems.

Corrections, 15 November 2026

Checked against primary sources when this page became the canonical copy. The text above includes these corrections.

  1. IDE key establishment. The original said IDE session keys are negotiated through SPDM KEY_EXCHANGE and FINISH "via IDE_KM". The SPDM exchange creates the forward-secret secure session; IDE stream keys are programmed by the host side over that session using IDE_KM and activated with K_SET_GO.
  2. CXL. The original said CXL.cache and CXL.mem introduce attack surfaces "IDE alone does not address". CXL IDE protects CXL.cache and CXL.mem at the flit level as well as CXL.io. The remaining gap is bringing memory devices into a TEE trust boundary, which CXL 3.1 addresses with TSP for directly attached devices.
  3. Micron 7500. The original placed both Micron drives under OCP specification 2.5. Micron describes the 7500 against OCP specification 2.0; the 6550 ION against 2.5. Both support SPDM 1.2.
  4. OCP NVMe SSD specification 2.7. The original dated it October 2025. OCP listed 2.7 as coming soon in September 2025, and the published document carries a 2026 version date. Whether its SPDM sections are mandatory was not confirmed, so the text now says only that it has dedicated sections.
  5. Intel TDX Connect. The original said TEE-IO support "launched" in February 2025. The sources confirm an announcement in early 2025, not general availability.
  6. NVIDIA H100. The original gave a 2024 general-availability date, an ECC key type and an OCSP service. The SPDM session, per-device identity key and revocation check are supported by public sources; the date, key type and protocol name were not confirmed and have been removed.
  7. Smaller precision edits. Details that could not be confirmed from a primary source were generalised: the transport list (USB removed; bindings named instead), "IDevID" (now "device certificate chain"), the IDE key size and IV construction (now "AES-GCM with replay protection"), and the NVMe transport (the in-band storage binding added). No argument changed.

References

  1. DMTF, DSP0275: SPDM over MCTP binding and DSP0276: Secured Messages using SPDM over MCTP; libspdm reference implementation.
  2. CHIPS Alliance, Caliptra IDE_KM support (IDE_KM messages carried as application data over SPDM secure sessions; key programming).
  3. CXL Consortium, Insight into CXL 2.0 security features; CXL 3.1 white paper (TSP).
  4. Synopsys, TEE Device Interface Security Protocol (TDISP) for PCIe and CXL.
  5. Joint announcement, SPDM post-quantum support and CNSA 2.0 alignment, 28 May 2025.
  6. Micron, 7500 SSD and 6550 ION product brief; Open Compute Project, Datacenter NVMe SSD Specification 2.7.
  7. SecurityWeek, Intel TDX Connect bridges the CPU-GPU security gap, March 2025.
  8. NVIDIA H100 confidential computing: summary notes drawing on Gu et al., arXiv:2507.02770; NVIDIA Trusted Computing Solutions.
Source and licence

About this article

Written by Lei Zhou. Text © 2026 Lei Zhou, licensed CC BY 4.0. First published on LinkedIn, 19 April 2026; this is the canonical copy.

Product and specification status reflects the sources linked above and moves quickly. Check them before relying on any single claim.

Discussion

Corrections, questions or counter-examples?

If a claim here is wrong or out of date, I would like to hear about it. Comments are hosted in GitHub Discussions and need a GitHub account. Nothing loads from a third party until you click.