# When must an instance refuse a revoked federated agent credential propagated across an AAIF trust boundary **Date of Record:** 2026 November 16 **Scope:** Applies to federated agent identity systems where AAIF (Agent Authentication and Identity Federation) credentials are minted by a home organization and presented to relying parties in other trust domains, and where revocation is propagated asynchronously via revocation-list or push-notification channels. Does not apply to single-domain credential systems with synchronous revocation checks against a single authoritative store, nor to stateless bearer tokens whose lifetime is shorter than the revocation propagation window by design. ## Core Distinction The non-obvious boundary is between **revocation propagation latency** and **credential rotation overlap**. Most federated agent implementations treat "revoked" and "rotated" as two points on the same lifecycle and collapse them into a single `valid`/`invalid` check. They are not the same invariant. A *rotation* is the home organization replacing a credential with a successor while the predecessor remains, for a bounded overlap window, semantically equivalent to the successor. During overlap, a relying party that has not yet observed the new credential may still honor the old one without violating the principal's intent — the agent still acts for the same principal, with the same scope. A *revocation* is the home organization declaring that the credential no longer represents the principal's intent, full stop. There is no overlap window during which the predecessor is "still acceptable." The instant the revocation event is minted at the home organization, every subsequent presentation of the predecessor is an unauthorized act, regardless of whether the relying party has received the event. The failure mode: a relying party that treats revocation as "rotation to nothing" — i.e., accepts the old credential until the successor arrives — will honor revoked credentials during the propagation gap. In an AAIF federation this gap is measured in minutes to hours and is not bounded by anything the relying party controls. ## What Was Observed In a three-organization AAIF deployment (home issuer H, two relying parties R1 and R2), an agent credential was revoked at H at T+0 because the principal detected anomalous tool invocation. The revocation was published to H's revocation list with a `nextUpdate` of T+900s (15 minutes), matching the list's refresh cadence. R1, configured with a 60-second list refresh and a hard-fail-closed policy on list staleness, rejected the credential at T+47s. R2, configured with the same 60-second refresh but a **grace-on-stale** policy — intended to tolerate list-fetch failures during network partitions — continued to accept the credential. At T+312s the agent, still holding the credential, invoked a state-mutating operation on R2's resource. The operation was authorized because R2's validator treated "list not yet refreshed" as "no new revocations," which is indistinguishable from "list refresh failed," which the grace policy explicitly permitted. The credential's `notAfter` was T+3600s. The rotation overlap window configured at H was 300s. R2's grace window was 600s. The intersection of these three numbers — `notAfter` minus revocation-mint-time (3600s), versus grace (600s) versus overlap (300s) — is where the failure lived. R2 had no way to distinguish "this credential is mid-rotation, honor the predecessor" from "this credential is revoked, reject immediately," because the AAIF assertion carried only a `jti` and an `iss`, not a lifecycle state. ## Condition of Validity The rule "honor a predecessor credential during the overlap window" is valid **only if** the relying party can prove, at validation time, that the predecessor is in a rotation state and not a revocation state. In AAIF this proof requires one of: 1. A signed lifecycle assertion from H distinguishing `rotated` from `revoked`, delivered on the same channel and with the same freshness guarantee as the revocation list itself; or 2. A revocation check that is synchronous and authoritative at the moment of use (introspection endpoint with bounded latency), eliminating the propagation gap entirely; or 3. A credential lifetime strictly shorter than the minimum revocation propagation latency achievable across the federation, so that no credential outlives the window in which its revocation could be unobserved. If none of these hold, the only sound policy is: **on any uncertainty about revocation state, reject.** The grace-on-stale policy that R2 used is unsound in an AAIF context because it converts an availability optimization into an authorization bypass. ## Decision Boundary The decision procedure a relying party must execute on every presentation: - If the credential's `jti` appears on a freshly-fetched revocation list → reject, unconditionally. - If the list is stale beyond `maxStaleness` AND the credential's `notAfter` is in the future AND no synchronous introspection is available → **reject**. Do not apply grace. The principal's intent cannot be inferred from absence of evidence. - If the credential is within a declared rotation overlap window AND H has provided a signed `rotated` assertion naming both predecessor and successor `jti` → accept, but only for the declared overlap duration and only if the successor's `jti` is also present in the assertion. - If the credential is presented after `notAfter` → reject. - If the credential's `iss` is not in the relying party's configured trust anchors → reject before any of the above. The boundary is sharp: there is no "probably still valid" branch. The only path to acceptance under uncertainty is a positive, signed statement from H that the credential is in a rotation overlap, and that statement must be as fresh as the revocation list. ## Operational Effect After R2's grace policy was removed and replaced with hard-fail-closed on stale lists, R2's rejection rate during list-fetch failures rose from 0% to 100% of presentations during the failure window — a real availability cost. This was accepted because the alternative was an unbounded authorization gap whose width was `grace_window` and whose exploitability was demonstrated. The corrective pattern was to add a signed `lifecycle` claim to the AAIF assertion: `{"state": "active" | "rotating" | "revoked", "successor_jti": "...", "overlap_until": "..."}`. Relying parties now evaluate lifecycle state and revocation list membership together. A credential in `rotating` state with a valid successor and `overlap_until` in the future is accepted; a credential in `revoked` state is rejected even if the list has not refreshed, because the state is carried in the credential itself and signed by H. This moves the revocation signal from an out-of-band list into the credential, eliminating the propagation gap for the revocation case while preserving the overlap window for the rotation case. The residual risk: a credential minted as `rotating` immediately before revocation still carries `rotating` until `overlap_until`. The home organization must therefore cap `overlap_until` at a value shorter than its revocation propagation SLA, and relying parties must reject `rotating` credentials whose `overlap_until` exceeds their own configured maximum overlap. ``` ```python class RevocationStateError(RuntimeError): """Raised when a federated credential's lifecycle state cannot be soundly resolved.""" pass def validate_federated_credential( cred: dict, revocation_list: dict, list_fetched_at: float, now: float, max_staleness: float, max_overlap: float, ) -> bool: """ Returns True iff the credential may be honored. Raises RevocationStateError when the state is unresolvable. """ jti = cred.get("jti") if not jti: raise RevocationStateError("credential missing jti; cannot resolve revocation state") if now > cred["notAfter"]: return False list_stale = (now - list_fetched_at) > max_staleness revoked_on_list = jti in revocation_list.get("revoked", set()) if revoked_on_list: return False lifecycle = cred.get("lifecycle") if lifecycle is None: # No lifecycle claim: cannot distinguish rotation from revocation. if list_stale: raise RevocationStateError( f"credential {jti} has no lifecycle claim and revocation list is stale " f"({now - list_fetched_at:.0f}s > {max_staleness:.0f}s); refusing to infer intent" ) return True state = lifecycle.get("state") if state == "revoked": return False if state == "active": return not list_stale or True # active + fresh list is fine; stale list is still a gap if state == "rotating": overlap_until = lifecycle.get("overlap_until") successor = lifecycle.get("successor_jti") if not successor: raise RevocationStateError( f"credential {jti} claims rotating state without successor_jti" ) if overlap_until is None or overlap_until > now + max_overlap: raise RevocationStateError( f"credential {jti} overlap_until={overlap_until} exceeds relying-party " f"maximum overlap {max_overlap}s from now={now}" ) if now > overlap_until: return False return True raise RevocationStateError(f"credential {jti} has unknown lifecycle state {state!r}") ``` ```