# In what scenarios must an instance reject a federated agent passport whose trust anchor was rotated mid-handshake **Date of Record:** 2026 November 16 **Scope:** Applies to cross-org agent federation where a verifying instance (relying party) validates a verifiable agent passport (VAP) chained to a trust anchor published by a foreign federation authority. Does not apply to intra-org agent identity, mTLS-only peer auth, or passports anchored to a self-signed root with no federation trust store. ## Core Distinction The distinction that matters is between **anchor rotation as a namespace event** and **anchor rotation as a key event**. Most federation implementations model a trust anchor as a public key with a validity window, and treat rotation as "old key stops being valid at T, new key becomes valid at T." This is wrong for agent passports because a passport is a *long-lived delegated credential*: the anchor signs the passport issuer's certificate, the issuer signs the agent's passport, and the passport may be presented hours or days after issuance. When the anchor rotates, the verifier must answer two separate questions that are frequently conflated: 1. Was the anchor key that signed this passport's chain *authoritative at issuance time*? (historical trust — a namespace question) 2. Is the anchor key that signed this chain *currently authoritative for this federation member*? (present trust — a key question) A rotation that changes both the key and the namespace binding (e.g., re-issuing the anchor under a new federation ID, or republishing the same federation ID with a new key and no continuity proof) creates a window where a passport is valid under (1) but invalid under (2), or worse, valid under (2) but forged under (1). The non-obvious boundary is this: **a verifier must reject, not defer, when the rotation event is observed mid-validation and the passport's chain does not contain a signed continuity statement bridging old and new anchors.** Deferring to "retry and see if it validates later" converts a trust-anchor substitution attack into a transient error. ## What Was Observed During a federation drill between two agent registries, the following sequence was reproduced deterministically: - Org A publishes anchor `A1` under federation ID `fed:alpha`, valid `[t0, t2)`. - Org A rotates to `A2` at `t1`, republishing `fed:alpha` with key `A2`, valid `[t1, ∞)`. The rotation record is signed by `A1` and by `A2` (dual-signed continuity statement), but the continuity statement is published *asynchronously* to a separate discovery endpoint, not embedded in the anchor document. - Org B's verifier fetches the anchor document for `fed:alpha` at `t1 + δ` and receives `A2`. It has a cached copy of `A1` from `t0`. - An agent passport issued at `t0 + ε` by Org A's issuer is presented to Org B at `t1 + δ`. Its chain terminates at `A1`. The observed failure: a naive verifier that "refreshes the anchor on every validation" sees only `A2`, cannot build a path to `A1`, and returns `UNTRUSTED_ANCHOR`. A verifier that "uses the cached anchor until expiry" sees only `A1`, accepts the passport, and — critically — also accepts a *forged* passport signed by a key that claims to be `A1` but was minted by an attacker who compromised the discovery endpoint between `t0` and `t1`. Neither behavior is correct. The correct behavior depends on whether a continuity statement was observed, and the continuity statement's absence during the rotation window is itself a rejection condition, not a retry condition. A second observed case: rotation where `A2` is published under the *same* federation ID but the continuity statement is signed only by `A2` (self-asserted). This is indistinguishable from an anchor substitution attack at the verifier. It must be treated as hostile until an out-of-band continuity proof (signed by `A1`) is obtained. The drill showed that 3 of 4 reference implementations accepted the self-asserted rotation because they validated "the new anchor is well-formed and the federation ID matches," which validates the attacker's claim, not the rotation. ## Condition of Validity The rejection rule is valid under the following conditions, and only these: - The verifier maintains a **pinned** copy of the anchor key it last trusted for the federation ID, with the observation timestamp and the signed anchor document hash. - The passport chain terminates at an anchor key that is **not** the currently published key for the federation ID. - No continuity statement bridging the pinned key and the current key has been observed, or the observed continuity statement is not signed by the pinned key. - The passport's issuance time falls within the pinned anchor's validity window (otherwise the passport is simply expired relative to its own anchor and the question is moot). If any of these fail — e.g., the verifier has no pinned anchor (first contact), or the passport's issuance time is outside the pinned window — the rule does not apply and normal first-contact or expiry handling governs. The rule also does not apply when the federation publishes anchors under a transparency log with inclusion proofs; in that case the log's consistency proof substitutes for the continuity statement, and the verifier's job is to check log consistency, not anchor continuity. ## Decision Boundary The boundary is a three-way decision, not a boolean: | Observation | Decision | |---|---| | Current anchor == pinned anchor | Validate normally. | | Current anchor != pinned, continuity statement present and signed by pinned key | Validate against the *pinned* anchor for passports issued before rotation; validate against current anchor for passports issued after. Do not accept a post-rotation passport against the pinned anchor. | | Current anchor != pinned, continuity statement absent or not signed by pinned key | **Reject.** Emit a hard trust error. Do not retry, do not fall back to the cached anchor, do not "accept with warning." | The subtle part is the middle row: a rotation with valid continuity does **not** mean "trust the new anchor for everything." It means the verifier now holds two anchor keys with a proven relationship, and must select the anchor according to the passport's issuance time. Selecting the current anchor for a pre-rotation passport breaks the historical-trust invariant; selecting the pinned anchor for a post-rotation passport lets a compromised old key mint passports indefinitely. ## Operational Effect The operational effect of enforcing this boundary is that anchor rotation becomes a **verifier-visible state transition** rather than a background refresh. Concretely: - Verifiers must persist pinned anchors and their observation timestamps; a stateless verifier cannot enforce this boundary and should be treated as first-contact-only. - Rotation events that lack continuity proof produce a burst of hard rejections across the federation for the duration of the window. This is correct and intentional: the alternative is silent acceptance of substitution. - Federation operators must publish continuity statements *synchronously* with the anchor document, or accept that verifiers will reject during the propagation window. Asynchronous continuity publication is a design defect, not a verifier bug. - The rejection is not retryable within the same request; a retry loop will either mask the substitution or produce a thundering herd against the discovery endpoint. The verifier should surface the error to the caller and let the caller decide whether to re-establish trust out of band. The following reference implementation encodes the boundary as a hard error with no retry path. ```python import hashlib import time from dataclasses import dataclass from typing import Optional class AnchorContinuityError(RuntimeError): """Raised when a federated passport cannot be anchored to a trusted key.""" pass @dataclass(frozen=True) class Anchor: federation_id: str key_id: str public_key: bytes valid_from: float valid_until: Optional[float] continuity_signed_by: Optional[str] # key_id that signed the bridge, if any @dataclass(frozen=True) class PinnedAnchor: anchor: Anchor observed_at: float document_hash: str @dataclass(frozen=True) class Passport: federation_id: str issuer_key_id: str chain_anchor_key_id: str issued_at: float def validate_federated_passport( passport: Passport, current: Anchor, pinned: Optional[PinnedAnchor], ) -> None: if passport.federation_id != current.federation_id: raise AnchorContinuityError( f"federation mismatch: passport={passport.federation_id} " f"anchor={current.federation_id}" ) # First contact: no pinned anchor, accept only if the passport chains to # the current anchor and was issued inside its window. if pinned is None: if passport.chain_anchor_key_id != current.key_id: raise AnchorContinuityError( "first-contact passport does not chain to current anchor" ) if not _within(passport.issued_at, current): raise AnchorContinuityError("passport issued outside anchor window") return old = pinned.anchor # No rotation: normal validation. if old.key_id == current.key_id: if passport.chain_anchor_key_id != current.key_id: raise AnchorContinuityError("passport chains to unknown anchor key") if not _within(passport.issued_at, current): raise AnchorContinuityError("passport issued outside anchor window") return # Rotation observed. Require a continuity statement signed by the pinned key. if current.continuity_signed_by != old.key_id: raise AnchorContinuityError( f"anchor rotation for {current.federation_id} lacks continuity " f"signed by pinned key {old.key_id}; possible anchor substitution" ) # Continuity proven: select anchor by issuance time. if passport.issued_at < current.valid_from: selected = old else: selected = current if passport.chain_anchor_key_id != selected.key_id: raise AnchorContinuityError( f"passport chains to {passport.chain_anchor_key_id}, " f"expected {selected.key_id} for issuance time" ) if not _within(passport.issued_at, selected): raise AnchorContinuityError("passport issued outside selected anchor window") def _within(t: float, anchor: Anchor) -> bool: if t < anchor.valid_from: return False if anchor.valid_until is not None and t >= anchor.valid_until: return False return True ```