# In what scenarios must an instance treat a signed delegation chain as revoked before the revocation event itself propagates **Date of Record:** 2026 November 15 **Scope:** Applies to cross-org agent federation where an agent's authority is proven by a verifiable credential chain (issuer → delegating principal → acting agent) and revocation is distributed asynchronously via a revocation list, status-list bit, or gossip channel. Does not apply to single-org deployments with synchronous, strongly-consistent authorization checks, nor to credentials whose validity window is shorter than the revocation propagation bound. ## Core Distinction A verifiable credential proves **what was authorized at signing time**. It does not, and structurally cannot, prove **what remains authorized now**. The gap between those two claims is the revocation window. The non-obvious failure is the assumption that a credential is *valid* until a revocation record referencing it is *observed*. In a federated setting across trust domains, there is no global clock and no shared sequencer, so "observed" is a per-verifier, per-path property. The invariant that actually holds is weaker and asymmetric: **absence of a revocation record is not evidence of non-revocation; it is evidence only of the verifier's propagation lag.** A correct verifier must treat the credential as *conditionally revoked* whenever the elapsed time since the credential's last known-good status check exceeds the issuing domain's declared propagation bound — even if no revocation record has arrived. The revocation event and its propagation are distinct; the failure mode is binding trust to the event's arrival rather than to the bound on its arrival. ## What Was Observed During a federation incident, org A revoked a delegation credential for an agent operating under org B's trust root at T=0. Org A's revocation list published at T+40s. Org B's verifier polled the list on a 300s interval and had a cached "valid" result from T−260s. Between T=0 and the next poll, the agent continued to invoke a downstream service in org C, which trusted org B's attestation transitively. Org C accepted the chain because org B's attestation carried a freshness claim (`checked_at: T−260s`) that org C validated only against a *local* maximum cache age of 600s — a threshold chosen for org B's own internal agents, not for the cross-org propagation bound org A had declared (120s). Three observations followed: 1. The credential's own `exp` was 24h out and provided no protection; short-lived credentials are not a substitute for propagation-aware freshness when the delegation chain is long-lived by design. 2. The revocation list was correct and timely. The failure was entirely in the *consumer's* decision to treat a stale positive as a current positive. 3. Org C's transitive trust had no independent path to org A's status list, so it inherited org B's lag without inheriting org B's knowledge of org A's declared bound. ## Condition of Validity The "valid until observed revoked" stance is safe **only** under the conjunction: - every verifier in the transitive chain polls the *originating* issuer's status source (or a source with a proven bounded lag), and - the maximum cache age enforced at each hop is ≤ the originating domain's declared propagation bound, and - the chain carries, per link, the originating bound rather than a locally invented one, and - verifiers fail *closed* when a status check cannot complete within the bound. If any conjunct fails, the safe default flips: an unrefreshed positive must be treated as revoked. The subtlety is that the bound is a property of the **originating issuer**, not of the hop doing the checking. A verifier that substitutes its own freshness policy — however reasonable locally — silently widens the window for every downstream consumer. ## Decision Boundary The decision is not "is there a revocation record?" but "has the time since last confirmed non-revocation exceeded the originating bound?" Concretely: - If `now − last_confirmed_ok ≤ origin_propagation_bound` → treat as valid (positive, current). - If `last_confirmed_ok` is absent, or the status source is unreachable, or `now − last_confirmed_ok > origin_propagation_bound` → treat as **revoked** for authorization purposes, even though no revocation event has been seen. This is the boundary: an *unknown* status past the bound is operationally equivalent to *revoked*. - The bound must be carried in the credential chain (`propagation_bound_s` per issuer), signed by the issuer, and the *minimum* across the chain governs. The failure to avoid is treating the third case as "valid, pending refresh." That is the exact window in which a revoked agent retains transitive authority. ## Operational Effect Enforcing the bound-aware rule converts an unbounded, silent over-permission window into a bounded, explicit fail-closed window. The operational cost is availability: during issuer status-source outages, agents are denied once the bound elapses. That cost is correct and must be surfaced as a distinct denial reason (`status_stale`) rather than conflated with `revoked`, so operators can distinguish a propagation outage from an actual revocation. The system must also reject chains whose issuers omit a signed propagation bound — an unbounded issuer is an un-verifiable issuer in a federation, and should be treated as failing the trust condition at chain-validation time, not at authorization time. ```python from __future__ import annotations from dataclasses import dataclass from datetime import datetime, timedelta class RevocationPropagationError(RuntimeError): """Raised when a delegation chain cannot be trusted because status freshness exceeds the originating issuer's propagation bound.""" @dataclass(frozen=True) class ChainLink: issuer: str propagation_bound_s: int # signed by issuer; must be present last_confirmed_ok: datetime | None # last positive status check revoked_seen: bool = False def authorize(chain: list[ChainLink], now: datetime) -> None: if not chain: raise RevocationPropagationError("empty delegation chain") # The governing bound is the minimum across all issuers in the chain. bounds = [] for link in chain: if link.propagation_bound_s is None or link.propagation_bound_s <= 0: raise RevocationPropagationError( f"issuer {link.issuer!r} declares no valid propagation bound; " "unbounded issuers are un-verifiable in a federation" ) bounds.append(link.propagation_bound_s) governing_bound = timedelta(seconds=min(bounds)) for link in chain: if link.revoked_seen: raise RevocationPropagationError( f"issuer {link.issuer!r}: explicit revocation observed" ) if link.last_confirmed_ok is None: raise RevocationPropagationError( f"issuer {link.issuer!r}: no confirmed non-revocation; " "treating unknown status as revoked (fail-closed)" ) age = now - link.last_confirmed_ok if age > governing_bound: # No revocation event seen, but freshness exceeded the bound: # operationally equivalent to revoked. raise RevocationPropagationError( f"issuer {link.issuer!r}: status stale by {age.total_seconds():.0f}s " f"> governing bound {governing_bound.total_seconds():.0f}s; " "status_stale treated as revoked" ) if __name__ == "__main__": t0 = datetime(2026, 11, 14, 12, 0, 0) good = [ChainLink("org-a", 120, t0 - timedelta(seconds=30))] authorize(good, t0) # passes stale = [ChainLink("org-a", 120, t0 - timedelta(seconds=260))] try: authorize(stale, t0) except RevocationPropagationError as exc: print("denied:", exc) ```