# When must an instance refuse to accept a peer's attestation chain that validates but was minted under a rotated root **Date of Record:** 2026 November 16 **Scope:** Applies to cross-org agent-to-agent trust bootstrap where each party presents a verifiable identity (key-bound DID or equivalent) plus a root-anchored attestation chain, and where the verifying party maintains a trust store of foreign roots. Does not apply to intra-org trust where both parties share a single root authority, nor to cases where the peer's root is pinned by out-of-band configuration at deploy time. ## Core Distinction A signature that verifies is not the same as a signature that was authorized to exist. The distinction that matters here is between **cryptographic validity** (the chain's signatures check out against the root the peer presents) and **anchoring validity** (that root was, at the time of minting, the root we were willing to trust for that org). Rotation breaks the naive equation between the two. When an org rotates its root key, the old root remains cryptographically capable of signing chains forever. A chain minted under the retired root will verify perfectly against the retired root's public key. The question is not "does it verify" but "was the retired root still authorized to speak for this org at the moment this chain's leaf assertion was created." ## What Was Observed During a cross-org handshake between a scheduling agent (Org A) and a capacity-broker agent (Org B), Org B presented a three-link attestation chain: leaf agent key → intermediate delegation cert → root. The chain verified cleanly. Org A's trust store held Org B's root `R2` (current) and retained `R1` (retired) for a 30-day grace window to avoid breaking in-flight sessions. The leaf assertion carried `not_before` = T−9 days, `not_after` = T+21 days, and was signed by an intermediate whose own validity was `not_before` = T−40 days, `not_after` = T+200 days. The intermediate was signed directly by `R1`. `R1` had been retired at T−11 days — two days *before* the leaf assertion's `not_before`. The intermediate's `not_after` extended 200 days past rotation. The chain verified. The grace window admitted `R1`. The handshake succeeded. The peer was, in fact, a legitimate Org B agent — but it had been provisioned under the pre-rotation ceremony and its delegation path had never been re-anchored. It carried authority that Org B's current root policy no longer intended to grant, and Org A could not tell the difference between this and a stale-but-honest peer versus a compromised pre-rotation intermediate being replayed. The failure is subtle because every individual check passed: signature valid, time windows overlap, root present in trust store, grace window active. The invariant that was violated was temporal: *the leaf assertion must have been minted while the root that anchors it was in its authorized period.* No single-link check encodes this; it is a cross-link temporal constraint. ## Condition of Validity The anchoring invariant holds only when the verifier enforces the following, in order: 1. For each link, `mint_time(link)` (the signing event, not the `not_before`) falls within the root's authorized interval `[root.activated_at, root.retired_at + grace]`. 2. The leaf's `not_before` is not earlier than the deepest intermediate's `not_before` minus clock skew tolerance — i.e., a leaf cannot claim authority that predates the delegation path that carries it. 3. A retired root in grace is accepted **only** for chains whose leaf `not_before` is strictly before `root.retired_at`. Chains minted after retirement must anchor to the current root, full stop. Condition 3 is the non-obvious one. The grace window exists to honor sessions that were already live at rotation. It must not be read as "the retired root remains a valid anchor for new assertions." A chain whose leaf was minted after retirement but anchored to the retired root is a provisioning error or a replay, and must be rejected regardless of how cleanly it verifies. ## Decision Boundary Reject the handshake when: the chain verifies against a root in the grace set, **and** the leaf assertion's `not_before` (or the intermediate's signing time, whichever is later) is at or after that root's `retired_at`. Accept when the chain verifies against a grace-set root and all mint events precede `retired_at`. Accept unconditionally when the chain anchors to the current root and all time windows overlap the present. The boundary is the retirement timestamp, applied per-link to *mint events*, not to declared validity windows — declared windows are attacker-controlled and legitimately long-lived, so they cannot be the discriminator. ## Operational Effect Enforcing the boundary converts a silent authority-drift into a hard handshake failure with a recoverable remediation path: the peer must re-run its delegation ceremony under the current root. The cost is that honest peers provisioned just before a rotation will fail their first post-rotation handshake and must be re-anchored — which is the correct outcome, because a peer that cannot re-anchor is a peer whose delegation path is unmanaged. The verifier must emit a distinguishable error (`StaleRootAnchor`) separate from generic signature failure, so the peer's operator sees "re-anchor required" rather than "untrusted," which would send them debugging keys instead of ceremony. ```python class StaleRootAnchor(RuntimeError): """Raised when a chain verifies but its leaf was minted under a retired root.""" pass def verify_cross_org_chain(chain, trust_store, now): root = trust_store.lookup(chain.root_id) if root is None: raise StaleRootAnchor(f"unknown root {chain.root_id}") # Condition 1: every link's signature must verify against its issuer. for link in chain.links: if not link.signature_valid(): raise StaleRootAnchor(f"bad signature on link {link.id}") # Condition 3: retired root in grace is only valid for pre-retirement mints. if root.retired_at is not None: if now > root.retired_at + root.grace: raise StaleRootAnchor(f"root {root.id} past grace window") leaf_mint = chain.leaf.not_before if leaf_mint >= root.retired_at: raise StaleRootAnchor( f"leaf minted {leaf_mint} at/after root {root.id} " f"retired_at {root.retired_at}; re-anchor required" ) # Condition 2: leaf must not predate its delegation path. deepest_nb = max(link.not_before for link in chain.intermediates) if chain.leaf.not_before < deepest_nb - chain.skew_tolerance: raise StaleRootAnchor("leaf predates its delegation path") return chain.leaf.subject ```