Remote Attestation and the RATS Architecture
1. Overview
A. Definition
Remote Attestation is a trusted-computing procedure by which a device, platform, or workload (the Attester) generates and conveys cryptographically signed Evidence of its configuration and integrity state, and a remote Verifier appraises that Evidence against trustworthy Reference Values and policy to decide "may this system be trusted?". The IETF standardized this as RATS (Remote ATtestation procedureS) (RFC 9334, Jan 2023), defining the roles, data, and flows of attestation in a common vocabulary.
The fundamental concern of remote attestation is "how can I be sure that a response from a party across the network was produced by untampered, trustworthy code?". Traditional authentication (a TLS server certificate, a user login) confirms "who the other party is (identity)" but says nothing about "in what state it is running (integrity)." A server holding the correct private key may already be seized by a rootkit or booted from tampered firmware; in that case identity authentication passes, yet the party is actually controlled by an attacker. Remote attestation is the technology that fills exactly this gap — the gap between proof of identity and proof of state.
This gap matters because the basis for a trust decision must be anchored in hardware. Software reporting "I am clean" about itself is meaningless, because an attacker who seizes that reporting code can forge the claim. The signature over Evidence must therefore be produced with a key bound to a tamper-resistant hardware Root of Trust such as a TPM, a security chip, or a TEE; only with this hardware basis can a remote verifier accept Evidence as "believable." Ultimately, remote attestation is the layer that exports the local trust state built by [[secure-boot]], [[tpm]], and [[confidential-computing]] to a third party across the network in a provable form.
B. Background and Necessity
The first driver behind remote attestation is the device-trust requirement of Zero Trust ([[zero-trust]]). Under the principle "never trust, always verify," Zero Trust judges device state at every access; here, "did this laptop really secure-boot with a patched OS?" must be confirmed with hardware Evidence rather than software self-report. For instance, Conditional Access that grants corporate-resource access only to devices that pass TPM-based device attestation has become established practice.
The need for such state attestation has grown clearer as supply-chain and insider threats rise. In the cloud, a CSP administrator operating the hardware and hypervisor effectively holds top-level privilege, yet customers in regulated industries (finance, healthcare, defense) demand a "do-not-even-trust-the-CSP (CSP-out-of-TCB)" model. Software self-report or contracts and audits cannot technically guarantee this requirement; only remote attestation — where the customer directly verifies hardware-issued Evidence — cryptographically proves the claim that "even the operator cannot peek inside." It is precisely this point that elevates remote attestation from a mere convenience feature to the core of regulatory response and the trust model.
The second driver is the spread of Confidential Computing. When processing sensitive data in the cloud, users want not to "believe" but to "be proven" that code runs inside a hardware-isolated region (TEE) that not even the CSP administrator can peer into. TEEs such as Intel TDX, AMD SEV-SNP, and ARM CCA issue Evidence carrying measurements of the execution environment, and the user injects secret keys and data into the TEE only after verifying it via remote attestation. In other words, remote attestation is the precondition for handing over data in confidential computing.
The third driver is IoT, edge, and supply-chain trust. As countless remotely and unattendedly operated devices are exposed to tampering, cloning, and firmware-swap risks, a central management server increasingly needs to periodically attest each device's boot state and firmware version to decide on quarantine or recovery. With the architecture standardized by RFC 9334 (2023) and the Evidence token format (EAT) by RFC 9711 (2025), remote attestation is maturing out of per-vendor silos into an interoperable foundational technology.
2. The Overall RATS Structure and Core Concepts
Remote attestation should be understood as a triangular structure with roles separated into "the one who produces Evidence → the one who appraises it → the one who makes the trust decision." The overall diagram below shows the roles and the flow of data (conceptual messages) defined by RFC 9334. The key point is that Evidence is not trusted as-is; the Verifier appraises it against Reference Values and Endorsements and converts it into a digested judgment called the Attestation Results, which the Relying Party then uses.
flowchart TD
ATT["Attester - TPM/TEE/DICE"]
VER["Verifier"]
RP["Relying Party"]
END["Endorser - manufacturer"]
RVP["Reference Value Provider"]
VO["Verifier Owner"]
ATT -->|"submit signed Evidence"| VER
END -.->|"key-trust Endorsements"| VER
RVP -.->|"golden Reference Values"| VER
VO -.->|"Appraisal Policy"| VER
VER -->|"Attestation Results"| RP
RP -->|"allow/deny/quarantine decision"| ATT
style ATT fill:#e8f0fe,stroke:#2f6fed,stroke-width:2px
style VER fill:#eafbea,stroke:#2f9e44,stroke-width:1px
style RP fill:#fef3e8,stroke:#ed8f2f,stroke-width:1px
A. Attester and Evidence
The Attester is the entity that produces trustworthy information about its own state — the Evidence. Evidence is a set of Claims such as boot measurements (hashes), firmware and kernel versions, TEE measurements, and device identifiers, and it is invariably signed with an Attestation Key bound to the hardware Root of Trust. The reason the signature must be anchored in hardware is clear: so that an attacker cannot forge Evidence by tampering with software alone, the "final signing" step that produces Evidence must be performed in a tamper-proof region.
A design distinction that matters here is the separation of "Measurement" and "Signing." Each boot stage computing the next stage's hash and accumulating (extending) it into the TPM's PCR (Platform Configuration Register) is measurement, while the TPM signing those accumulated PCR values with its own key and issuing them is the Evidence (a Quote in the TPM). The boot chain performs measurement, but the TPM alone performs signing; so even if higher-layer software is contaminated, the already-accumulated measurements themselves cannot be rolled back. This one-way nature of the PCR — "accumulation is possible but arbitrary writing is not" — is the core foundation of remote-attestation trust.
Evidence must also guarantee Freshness. To block a Replay in which an attacker stores once-valid Evidence and resends it, a Nonce sent by the Verifier is included in the Evidence, or timestamps and monotonic counters are used. Without freshness, only "the state at some past moment," not "this state at this very moment," is proven, which neutralizes real-time trust decisions.
B. The Verifier and Appraisal Inputs (Endorsements, Reference Values, Policy)
The Verifier is the brain that receives Evidence, performs Appraisal, and produces Attestation Results. The Verifier does not judge on Evidence alone but combines three inputs. First, Endorsements are certificates by which the manufacturer vouches that "the Attestation Key of this TPM/TEE belongs to genuine authentic hardware," underpinning the trustworthiness of the Evidence-signing key. Second, Reference Values are the Golden Measurement — "the measurement hash of normal firmware/kernel must be this value." Third, the Appraisal Policy stipulates "which PCRs to compare against which references, and what to allow or deny."
The elegance of this structure lies in the division of labor over trust bases. Whether the Evidence-signing key is genuine is the Endorser's (manufacturer's) responsibility; whether the measurement is normal is the Reference Value Provider's; how far to allow is the Verifier Owner's. Separating responsibilities this way means that, for example, when a kernel patch changes the normal measurement, only the Reference Values need updating while the hardware Endorsement is untouched. If roles were mixed, a breach of any one would collapse the whole; so RATS deliberately separates them to narrow the attack surface and the scope of change.
C. The Relying Party and the Attestation Results
The Relying Party is the entity that consumes the Attestation Results to make the actual decision (allow access, unseal a secret key, trigger quarantine or recovery). An important design principle is that the Relying Party does not interpret raw Evidence directly. Because understanding PCR values and measurement hashes requires deep hardware and firmware knowledge, that complexity is delegated to a specialized Verifier, and the Relying Party receives only a digested result such as "trustworthy or not, validity period, which attributes are satisfied." Thanks to this role separation, the verification logic is managed consistently from a central point, and countless Relying Parties (application servers, KMS, access gateways) can lightly reuse the trust decision.
D. Distinguishing Local and Remote Attestation
Attestation divides, by verification scope, into Local Attestation and Remote Attestation, and understanding this distinction is needed to place each technology precisely. Local attestation is two components within the same platform (e.g., two SGX enclaves) confirming each other's measurements, mediated by hardware without an external third party. Remote attestation, by contrast, proves state to a Verifier across the network, additionally requiring a public-key infrastructure (the manufacturer's certificate chain) to vouch for the authenticity of the signing key, plus freshness guarantees.
This difference matters because of the extension of the Trust Boundary. Local attestation closes trust within a single chip, whereas remote attestation widens trust beyond network and organizational boundaries. Because threats such as replay, man-in-the-middle, and key forgery grow accordingly, remote attestation must co-design defenses such as nonces, TLS binding (e.g., binding Evidence into the TLS certificate as in RA-TLS), and certificate-revocation checks. In short, remote attestation is an extended version of local attestation's trust, overlaid with cryptographic and protocol machinery to "deliver it far away in a provable form."
3. Attestation Data Flow — the Passport Model and the Background-Check Model
RFC 9334 formalizes the paths by which Evidence reaches the Relying Party via the Verifier into two Topological Patterns. The detailed flow below contrasts the difference between the two models — namely, "does the Attester carry the verification result around, or does the Relying Party mediate verification on its behalf?"
sequenceDiagram
participant A as Attester
participant V as Verifier
participant R as Relying Party
Note over A,R: Passport Model
A->>V: submit Evidence
V->>A: issue Attestation Results (signed passport)
A->>R: present Attestation Results
R->>R: check result signature/policy, then decide
Note over A,R: Background-Check Model
A->>R: submit Evidence
R->>V: forward Evidence (proxy verification request)
V->>R: return Attestation Results
R->>R: access decision based on result
A. The Passport Model
In the Passport Model, the Attester first presents Evidence to the Verifier and receives and keeps the Attestation Results ("passport") that the Verifier appraised and issued. When it later presents this passport to multiple Relying Parties (immigration officers), each Relying Party checks only the Verifier's signature and lets it through. It is exactly the analogy of a person receiving a passport from a country (the Verifier) and using it at multiple airports (Relying Parties).
The practical benefit of this model is minimizing the Relying Party's burden. The Relying Party needs no complex measurement-appraisal logic — only result-signature verification — and because a once-issued result is reused by many parties, Verifier traffic also drops. The challenge, on the other hand, is managing the validity period of the result. Since a device may have been tampered with in the meantime if the passport is old, an appropriate expiry and renewal cycle must be set. Another advantage is that attestation can be used even where the Relying Party is cut off from the external network, like an airport lounge.
B. The Background-Check Model
In the Background-Check Model, the Attester submits Evidence directly to the Relying Party, which forwards it to the Verifier to be appraised on its behalf, then receives the result back and decides. It is just like a hiring process in which the company (Relying Party) sends an applicant's submitted documents to a background-check agency (the Verifier) for confirmation.
This model's strength is Freshness guarantee and central control. Because the Relying Party mediates verification in real time at each access moment, it can always confirm the "state right now," and the verification policy can be concentrated in the Verifier and run consistently. In return, it depends on the real-time connection and availability between Relying Party and Verifier, and load concentrates on the Verifier, so caching and high-availability design are needed. In practice the two models are combined — for example, a mixed strategy that verifies sensitive transactions in real time via background-check while handling low-frequency access via passport.
To summarize the selection criteria of the two models, background-check is favorable in environments where freshness demands are high and the Relying Party is always online and the verification policy must be centrally controlled (financial transactions, real-time access control). Conversely, passport suits environments where there are many Relying Parties or they are intermittently offline, verification cost is to be distributed, and result reuse matters (edge/IoT fleets, distributed service meshes). The crux is the trade-off of "who bears the responsibility of verification, when, and how many times," to be decided by weighing the conflicting demands of latency, availability, and policy consistency. Because RFC 9334 also explicitly permits Combinations of the two models, a design applying different models per stage is standardly possible.
4. Evidence-Generation Mechanisms and a Comparison of Types
The implementation approach diverges by what produces the "Evidence" of remote attestation and how. The table below compares three representative hardware bases, but each one's principle and application context is explained in prose beneath the table.
| Category | TPM-based | TEE/Confidential-Computing-based | DICE-based (lightweight) |
|---|---|---|---|
| Root of Trust | discrete TPM/fTPM | CPU TEE (SGX/TDX/SEV/CCA) | chip-unique secret (UDS) |
| Evidence form | PCR Quote | TEE Report/Attestation Doc | per-layer certificate (CDI) |
| Main use | PC/server boot attestation | cloud workload isolation | IoT/MCU small devices |
| Attestation key | AK (Attestation Key) | TEE-derived signing key | per-layer derived key |
| Standard token | TPM structure / EAT | EAT/vendor format | X.509/CWT |
TPM-based attestation is the most mature approach. Each boot stage extends measurements into the PCR, and the TPM, including the Verifier's nonce, signs the PCR with the AK (Attestation Key) and issues a Quote. The Verifier checks this Quote's signature (an AK linked to the manufacturer's EK certificate) and the PCR values (against Reference Values). In the Linux camp, Keylime (a CNCF project) is the representative open source that continuously attests the boot and runtime integrity of large numbers of nodes this way. Windows device health attestation works on the same principle.
TEE/confidential-computing-based attestation attests the running workload itself. An Intel SGX enclave produces a report carrying code/data measurements (such as MRENCLAVE), which Intel's attestation service converts into signed Evidence. TDX and SEV-SNP issue similar Evidence per VM, and ARM CCA per Realm. The user verifies this Evidence via remote attestation to confirm that "the very code I uploaded is running, untampered, inside isolated hardware," and only then seals and delivers decryption keys and data to the TEE. In other words, attestation serves as the gate for key release.
As a concrete industry case, consider a scenario in which a financial cloud provider processes a customer's personal data in a TDX-based confidential VM. The customer's Key Management Service (KMS), as the Relying Party, verifies the Evidence issued by TDX via Intel's attestation service each time a workload comes up, and releases the decryption key only when the VM measurement matches the pre-registered Reference Value. If an attacker tampers with even one byte of the VM image, the measurement hash changes, attestation fails, the key is not delivered, and the data is never exposed in plaintext. In this way, remote attestation automatically links an integrity violation to a data-access cutoff through the equation "pass verification = obtain key." Indeed, major CSPs such as AWS Nitro Enclaves, Azure Confidential VM, and Google Confidential Space provide this pattern combined with KMS key policy.
DICE-based attestation is a lightweight approach for small IoT/MCU devices that cannot host a TPM. TCG's DICE (Device Identifier Composition Engine) feeds a chip-unique secret (UDS) and each boot layer's measurement into a key-derivation function to derive a per-layer Compound Device Identifier (CDI) and certificate. Because the derived key and certificate change entirely when the code changes, it expresses "what firmware state it is in" as a provable identity even without a separate security chip. Thus the Evidence-generation mechanism differs by environment (server, cloud, ultra-small device), but the common skeleton of "a signature bound to a hardware root + measurements + freshness" is identical.
5. In Depth — Standardization Trends and Confidential-Computing Linkage
The latest current of remote attestation can be summarized as "convergence toward interoperable common tokens and architectures." In the past, Intel, AMD, and TPM each used different Evidence formats, creating a large silo problem in which a Verifier had to implement a separate parser per vendor. The IETF RATS working group is resolving this along two axes.
First, the architecture standard (RFC 9334, Jan 2023) provides the common vocabulary of the roles, data, and topological models seen above, enabling different vendor solutions to be mapped onto a single canonical model. Its significance lies in creating an industry lingua franca for "what to call Evidence, who verifies, and how the result is conveyed."
Second, the Evidence-token standard EAT (Entity Attestation Token, RFC 9711, Apr 2025) defines a unified format that signs Evidence with COSE/JOSE on top of CWT/JWT. EAT is not a single fixed format but a framework that stipulates use-case-specific claims and algorithms through Profiles, and it can express composite devices and layered attestation via submodules. This opens a path for a Verifier to handle Evidence consistently by placing it in the common envelope of EAT even when TPM, TEE, and DICE produce different Evidence. EAT also defines standard Claims such as geographic location, boot counter, and OEM identifier, designed so that Attestation Results can be linked directly to access policy.
Third, coupling with confidential computing is accelerating. The CNCF/Linux Foundation CoCo (Confidential Containers) standardizes a structure that runs Kubernetes pods in a TEE and has a trusted attestation service (KBS/Trustee) deliver secrets only to workloads that pass remote attestation. An IETF draft (draft-poirier-rats-eat-da and others) seeking to converge TDX/SEV-SNP/CCA Evidence into an EAT profile is also in progress. Prospectively, a crypto-agility design to replace the RSA/ECDSA used for Evidence signing with post-quantum cryptography ([[post-quantum-crypto]], PQC) is emerging as a task.
Fourth, there is a movement to generalize and open-source the Verifier itself. The Linux Foundation CCC (Confidential Computing Consortium) Veraison project aims at a common component that appraises diverse Evidence — TPM, TEE, DICE, and more — within a single verification service. This reduces the cost of each organization redundantly implementing per-vendor verification logic, and standardizes Attestation Results (EAT) generation to simplify Relying Party consumption. Ultimately, as the four layers of architecture (RFC 9334), token (EAT), verifier (Veraison), and deployment (CoCo) mesh together, remote attestation is evolving from a particular vendor feature into a common layer of cloud-native trust infrastructure.
6. Considerations and Implications
First, it must be clearly recognized as proof of state, not proof of identity, and integrated into the security architecture. Remote attestation complements "what integrity state the party is in," which TLS and IAM cannot answer. In Zero Trust design, remote attestation should be placed as the primary basis for device/workload trust decisions and, for maximal effect, linked with Conditional Access and micro-segmentation. Zero Trust without attestation is half-done — "trust that does not look at state." In particular, in BYOD and remote-work environments, user authentication alone is insufficient; the terminal's boot and patch state must be confirmed with hardware Evidence to control real risk.
Second, Evidence freshness and result validity period must be managed as a lifecycle. Block replay with nonces and timestamps, and design result expiry/renewal policy in the Passport Model and real-time verification availability/caching in the Background-Check Model. Because "trust forever once it passes" is exposed to TOCTOU (time-of-check/time-of-use) attacks, it is preferable to apply differentiated re-attestation cycles by access sensitivity.
Third, operation of the Verifier and the Reference Values (Golden Measurement) determines success or failure. If the normal-measurement database is inaccurate or slow to update, it falsely flags a normal patch as tampering (harming availability) or passes tampering as normal (harming security). Firmware/kernel updates and Reference Value updates must be tied into CI/configuration management, and the Verifier must be managed as a high-availability, integrity-protected asset. Because a breach of the Verifier itself collapses all trust decisions, the Verifier is a top-grade protected asset.
Fourth, privacy and key management must be designed in balance. A hardware-unique Attestation Key can make a device globally trackable, so anonymization techniques such as DAA (Direct Anonymous Attestation), privacy CA, and key separation must be considered together. In addition, generation, injection, and revocation of attestation keys and Endorsement certificates must be controlled on an HSM ([[hsm]]) basis, and revocation/reissuance procedures on leakage must be stipulated as supply-chain security requirements.
Fifth, proactive response to standard convergence and the PQC transition is required. New systems should reduce vendor lock-in based on the RFC 9334 role model and the EAT (RFC 9711) token, and adopt a design mindful of linkage with confidential-computing (CoCo/Trustee) attestation services. In the long run, making the Evidence-signing algorithm a replaceable structure (crypto agility) to prepare for the PQC transition is the professional-engineer-level perspective. The crux is understanding that remote attestation is not a one-time verification but the terminus of the trust chain and an operational task that continuously attests and renews from the Root of Trust up to network trust.
Sixth, a fail-safe policy for attestation failure must be defined in advance. Whether to block immediately, allow in a restricted mode, or trigger automatic recovery on attestation failure is a balance between availability and security. Because unconditional blocking can cause a service outage on unattended servers and OT, an automated path that recovers to a trusted golden image and then re-attests must be designed, per the protect/detect/recover principles of NIST SP 800-193. Attestation is completed not as a "pass/fail" dichotomy but as an operational regime that includes resilience after failure.
References
- IETF, "RFC 9334: Remote ATtestation procedureS (RATS) Architecture" (2023.1), https://www.rfc-editor.org/rfc/rfc9334
- IETF, "RFC 9711: The Entity Attestation Token (EAT)" (2025.4), https://www.rfc-editor.org/rfc/rfc9711
- Trusted Computing Group, "DICE Attestation Architecture", https://trustedcomputinggroup.org/work-groups/dice-architectures/
- CNCF Keylime, "Remote Boot & Runtime Attestation", https://keylime.dev/
- Confidential Containers (CNCF), "Attestation / Trustee", https://confidentialcontainers.org/
In one line: Remote attestation is a procedure that proves "what integrity state a system is in" to a Verifier across the network using a signature, measurements, and freshness bound to a hardware Root of Trust; IETF RATS (RFC 9334) standardized the Attester/Verifier/Relying Party roles and the Passport and Background-Check models, EAT (RFC 9711) standardized a common Evidence token, and it has become the precondition for device/workload trust decisions and key release in Zero Trust and confidential computing.