# What happens when an instance revokes an agent attestation while a downstream federation peer is mid-handshake **Date of Record:** 2026 November 15 **Scope:** Applies to cross-organizational agent identity federation where trust is established via signed attestations (e.g., W3C Verifiable Credentials, SPIFFE-style SVIDs, or bespoke JWT attestation chains) and revocation is propagated asynchronously across organizational boundaries. Does not apply to single-org deployments where revocation and issuance share a synchronous transaction boundary, nor to purely capability-based systems with no identity binding. ## Core Distinction The critical distinction is between **attestation validity at time of issuance** and **attestation validity at time of use**, and specifically the window during which a *handshake* (the multi-step exchange in which a relying party verifies an attestation chain, negotiates a session, and commits to a trust decision) straddles a **revocation event** originating at the issuer. Most federation designs treat revocation propagation as an eventually-consistent event stream. This is correct for steady-state authorization checks. It is *wrong* for the handshake path, because the handshake is a multi-round-trip commitment protocol: the relying party (RP) may verify the attestation in round 1, but only *commit* to the trust relationship in round N after policy evaluation, key agreement, and possibly human or automated approval. If the attestation is revoked between rounds, the RP commits to a trust relationship that the issuer has already disowned. The resulting failure is not a security breach in the classic sense (the RP did verify a genuinely-signed attestation) but a **phantom trust relationship**: the RP believes it holds a valid session with a peer that the peer's own issuer considers untrusted. ## What Was Observed In a three-org federation (issuer A, relying party B, intermediary broker C), the following sequence reproduced a phantom trust window: 1. Agent `agent-x` at org A presents a signed attestation to RP B, with a `validUntil` of +24h. 2. B fetches A's revocation list (a signed, timestamped CRL-like document) at T0. `agent-x` is not listed. Verification passes. 3. B begins a multi-round handshake with its own policy engine and a downstream broker C (which independently verifies the same attestation against a *cached* copy of A's revocation list, age 11 minutes). 4. At T0+40s, org A revokes `agent-x` (compromised credential, key rotation, or policy change). A publishes a new revocation list with `thisUpdate = T0+40s`. 5. B completes its handshake at T0+95s, commits the session, and issues a downstream capability token to C at T0+100s. 6. C accepts the token at T0+102s, validating `agent-x`'s attestation against its cached list (still pre-revocation). Result: a fully "valid" trust chain spanning A→B→C exists for `agent-x` at T0+102s, while A's authoritative state says `agent-x` is revoked as of T0+40s. The window is bounded by `max(CRL cache TTL across all peers) + handshake duration`. In the observed deployment, cache TTL was 15 minutes and handshake duration was ~95s, yielding a worst-case phantom window of ~16.5 minutes. The non-obvious part: **the phantom window is not closed by shortening cache TTLs alone**, because the handshake itself is longer than the propagation budget in the worst case, and because revocation propagation is push-based and lossy—a single dropped revocation event extends the window until the next pull. ## Condition of Validity The phantom-trust invariant holds (i.e., the system is safe) only if at least one of the following is enforced: - **Revocation-pinned handshake:** the RP re-fetches the issuer's revocation state at the *final* round of the handshake, not the first, and the commit is conditional on that final fetch. This requires the handshake protocol to expose a commit barrier—many do not. - **Short-lived attestations with mandatory re-issuance:** `validUntil - issuedAt` is shorter than the revocation propagation budget, so that even an unpropagated revocation cannot outlive the attestation. This trades availability for safety. - **Revocation-aware session binding:** the session token issued at commit time carries a revocation epoch (a monotonic counter from the issuer), and downstream peers reject tokens whose epoch is older than their locally-known epoch. This requires the epoch to be propagated alongside revocation, which most CRL/OCSP designs do not provide. If none of these holds, the system is *eventually* consistent but *transiently* unsafe, and the transient window is long enough to be operationally exploitable. ## Decision Boundary The operational decision is: **at what point in the handshake does the relying party treat the attestation as a commitment, and does it re-validate at that point?** - If the RP treats verification as a one-time gate at handshake start, it must accept the phantom window as a known risk and bound it via attestation lifetime. - If the RP treats verification as a continuous obligation, it must re-validate at commit and at every downstream token issuance—which increases latency and revocation-list load, and requires the downstream broker to share the issuer's revocation state (not a stale cache). - The boundary is crossed when `handshake_duration + max_cache_ttl > attestation_lifetime`. Below that threshold, stale-cache acceptance is safe because the attestation expires before the phantom window closes. Above it, the phantom window is *unbounded by attestation lifetime* and must be closed by protocol change. ## Operational Effect The practical effect is that federation peers must publish and honor a **revocation propagation budget** as a first-class SLA, and relying parties must *fail closed* when they cannot confirm that the budget is met. Concretely: - Downstream brokers must not accept cached revocation lists older than the budget; if they cannot refresh, they must reject the attestation rather than proceed on stale data. - Handshake protocols must expose a commit barrier at which revocation is re-checked, or the relying party must refuse to issue downstream tokens for attestations whose issuer's revocation state it cannot freshly confirm. - Issuers must emit a monotonic **revocation epoch** with every revocation event so that peers can detect gaps (a received epoch `n+2` without `n+1` indicates a lost event and forces a full pull). The failure mode to guard against in code is the silent acceptance of a stale or gapped revocation state. The following guard is the minimal enforcement point: ```python import time from dataclasses import dataclass class RevocationStateError(RuntimeError): """Raised when a relying party cannot confirm fresh, gap-free revocation state.""" pass @dataclass class RevocationSnapshot: issuer: str epoch: int fetched_at: float revoked_subjects: frozenset class FederationHandshake: def __init__(self, max_cache_age_s: float, expected_epoch: int): self.max_cache_age_s = max_cache_age_s self.expected_epoch = expected_epoch def commit(self, subject: str, snapshot: RevocationSnapshot) -> None: age = time.monotonic() - snapshot.fetched_at if age > self.max_cache_age_s: raise RevocationStateError( f"revocation snapshot for {snapshot.issuer} is {age:.1f}s old, " f"exceeds budget {self.max_cache_age_s}s; refusing to commit handshake" ) if snapshot.epoch != self.expected_epoch: raise RevocationStateError( f"revocation epoch gap for {snapshot.issuer}: expected " f"{self.expected_epoch}, got {snapshot.epoch}; a revocation event " f"was likely lost in propagation" ) if subject in snapshot.revoked_subjects: raise RevocationStateError( f"subject {subject} revoked by {snapshot.issuer} at epoch " f"{snapshot.epoch}; handshake must not commit" ) ```