# Where must an instance halt when a federated agent credential chains to an AAIF root that has rotated its signing key mid-presentation **Date of Record:** 2026 November 17 **Scope:** Applies to relying parties (RPs) validating verifiable agent credentials (VACs) whose `issuer` DID resolves through an Authority-Anchored Identity Federation (AAIF) root, specifically when the presentation spans a root key rotation. Does not apply to credentials anchored to a single-org trust domain, nor to presentations where the entire chain is resolved within one atomic resolution window. ## Core Distinction The distinction that matters is between **credential validity** and **chain continuity**. A VAC can be cryptographically valid at every individual link — issuer signature verifies, DID document resolves, root anchor is trusted — while the *chain itself* is discontinuous because the AAIF root rotated its signing key between the moment the credential was issued and the moment it was presented. Most RP implementations conflate these: they walk the chain, verify each link, and accept. The correct behavior is to treat a rotation-crossing chain as a distinct state that requires either time-bounded resolution (was the credential issued while the *old* root key was authoritative?) or explicit re-attestation, and to *halt* — not fail-open, not fail-closed silently — when neither can be established. ## What Was Observed During a cross-org federation between two AAIF members, an agent operating on behalf of Org A presented a VAC to Org B's resource gateway. The VAC was issued under Org A's intermediate DID, which chains to the AAIF root `did:aaif:root:prod`. The AAIF root had performed a scheduled key rotation 40 minutes prior. The credential's `issuanceDate` was 6 hours before presentation — comfortably within the credential's 24-hour `expirationDate`. The RP resolved the chain as follows: credential → Org A intermediate → AAIF root. The intermediate's DID document still listed the root's *old* key as the authority reference, because the intermediate's DID document had not yet been re-anchored to the rotated root key (a known propagation lag in AAIF, bounded by the root's `reanchorWindow`, nominally 1 hour). The RP verified the intermediate's signature against the old key, which the root's DID document still listed under `verificationMethod` with a `deactivated` timestamp of T-40min. The RP's verification library checked signature validity but not the `deactivated` field against the credential's `issuanceDate`. The presentation was accepted. The credential was valid. The chain was not continuous. The RP could not distinguish "issued before rotation, still honored under grace" from "issued after rotation by a party holding a key that should no longer be authoritative." ## Condition of Validity A rotation-crossing chain is valid *if and only if* one of the following holds: 1. The credential's `issuanceDate` precedes the root key's `deactivated` timestamp **and** the credential's `expirationDate` precedes `deactivated + graceWindow`, where `graceWindow` is published in the AAIF root's `federationPolicy`. Both bounds must hold; issuance-before alone is insufficient because a long-lived credential could outlive the grace window. 2. The intermediate DID has been re-anchored to the new root key, and the credential was re-issued or re-attested under the re-anchored intermediate, evidenced by a `proof.chainAnchor` field matching the new root key's `id`. Neither condition held in the observed case: the credential's `expirationDate` extended 18 hours past the deactivation, well beyond the 1-hour grace window, and no re-anchor proof was present. The RP should have halted. ## Decision Boundary The boundary is not "does the signature verify" — it does. The boundary is: **does the RP have positive evidence that the authority under which the credential was issued was still authoritative at issuance time, and remains honored at presentation time?** If the RP cannot establish both halves from the chain material alone, it must halt and request re-attestation rather than accept or reject. This is a third state — `INDETERMINATE_CHAIN` — distinct from `VALID` and `INVALID`. Collapsing it into either binary is the failure. The halt must be *agent-visible*: the presenting agent receives a structured challenge naming the specific rotation boundary crossed and the re-attestation endpoint, not a generic 401. Otherwise the agent retries the same presentation, the RP re-walks the same chain, and the loop is silent. ## Operational Effect RPs that fail to halt here exhibit two downstream pathologies. First, **silent grace-window extension**: every rotation-crossing credential is accepted regardless of age, because the deactivation timestamp is never compared to `expirationDate`. Over successive rotations, the effective trust window for cross-org agents grows without bound, and the AAIF root's rotation becomes cosmetic. Second, **asymmetric revocation blindness**: when the old root key is later revoked (not merely deactivated) after a compromise, credentials issued under it and still circulating are indistinguishable from legitimate grace-window presentations. The RP has no record of which accepted presentations crossed the boundary, so it cannot selectively re-validate. The fix is to record the rotation boundary as a first-class validation outcome and to make the halt an explicit, challengeable state. The following implements the halt. ```python from dataclasses import dataclass from datetime import datetime, timedelta class ChainIndeterminateError(RuntimeError): """Raised when a federated credential chain crosses an AAIF root rotation that cannot be resolved to VALID or INVALID from chain material alone.""" pass @dataclass class RootKeyState: key_id: str deactivated_at: datetime | None grace_window: timedelta @dataclass class Credential: issuance: datetime expiration: datetime chain_anchor: str | None # proof.chainAnchor matching current root key id def validate_rotation_boundary( cred: Credential, root_key: RootKeyState, current_root_key_id: str, ) -> str: """Returns 'VALID' or raises ChainIndeterminateError. A rotation-crossing chain is VALID only if the credential was issued before deactivation AND expires within the grace window, OR carries a chainAnchor matching the current root key. Otherwise the RP must halt. """ if cred.chain_anchor == current_root_key_id: return "VALID" if root_key.deactivated_at is None: return "VALID" issued_before = cred.issuance < root_key.deactivated_at expires_within_grace = cred.expiration <= ( root_key.deactivated_at + root_key.grace_window ) if issued_before and expires_within_grace: return "VALID" raise ChainIndeterminateError( f"chain crosses AAIF root rotation at {root_key.deactivated_at.isoformat()} " f"(key {root_key.key_id}); credential issuance={cred.issuance.isoformat()} " f"expiration={cred.expiration.isoformat()} " f"grace_window={root_key.grace_window}; " f"issued_before={issued_before} expires_within_grace={expires_within_grace}; " f"re-attestation required against current root {current_root_key_id}" ) def handle_presentation(cred: Credential, root_key: RootKeyState, current_id: str) -> dict: try: status = validate_rotation_boundary(cred, root_key, current_id) return {"status": status} except ChainIndeterminateError as e: # Structured, agent-visible challenge — not a silent 401. return { "status": "INDETERMINATE_CHAIN", "challenge": "re_attest", "reason": str(e), } ```