# How does an instance detect a Revoked Delegation Ancestor When Intermediate Issuers Cache Positively **Date of Record:** 2026 November 16 **Scope:** Applies to federated agent identity systems where a verifier validates a delegation chain across multiple issuers and where each issuer independently caches revocation state. Does not apply to single-issuer tokens with a single trusted root that performs synchronous revocation checks at every hop. ## Core Distinction The distinction that matters is between *revocation of a leaf credential* and *revocation of an ancestor in a delegation chain*. A leaf revocation is visible to the verifier because the leaf's issuer is the one being queried. An ancestor revocation is invisible when every intermediate issuer between the verifier and the revoked ancestor has cached a positive ("not revoked") result for its own downstream link, and the verifier only ever queries the leaf's issuer — which is itself not revoked. The failure is not that revocation is checked; it is that revocation is checked *per-hop* with positive caching, so a chain can be locally consistent at every edge while globally invalid because one interior node was revoked after the positive cache entries were written. ## What Was Observed A three-hop chain was exercised: `agent A` delegated by `issuer X` to `issuer Y`, and `issuer Y` delegated to `issuer Z`, with `Z` presenting the credential to a verifier `V`. Each issuer maintained a 300-second positive TTL on "is my immediate delegate still valid." At T+0, `issuer X` revoked the delegation to `Y`. `Y`'s cache of "X says I'm valid" had been written at T-120 and did not expire until T+180. During the window T+0 to T+180, `V` queried `Z`, `Z` queried `Y`, and `Y` returned its cached positive result about `X`'s delegation. The chain validated end-to-end for 180 seconds after a security-relevant revocation. The observable signature was a chain where every hop's local check passed, but the *set of issuers consulted* did not include `X` at all. No single check was wrong; the union of checks failed to cover the revoked edge. ## Condition of Validity This boundary is only real when three conditions hold simultaneously: (1) positive revocation caching is permitted at any intermediate issuer, (2) the verifier does not independently re-query every ancestor issuer in the chain, and (3) the chain depth exceeds one hop. If any one of these fails — no positive caching, full-chain re-query, or single-hop chains — the vulnerability collapses. This is why it survives testing: most test harnesses use single-hop chains or disable caching for determinism, and the bug only appears in the intersection. ## Decision Boundary The correct decision rule is: a verifier MUST treat a chain as unvalidated unless it has either (a) a fresh, uncached revocation status for every issuer in the chain, or (b) a chain-level revocation proof (e.g., a transparency-log inclusion proof or a signed chain epoch) that binds the *entire* chain, not just adjacent edges. Per-hop positive caching is acceptable only for the *leaf* issuer, never for interior issuers, because interior revocation is precisely the case that per-hop checks cannot see. The instance should detect this by computing the set of issuers actually consulted and comparing it to the set of issuers in the chain. If `consulted ⊊ chain`, the chain is not fully validated regardless of individual results. ## Operational Effect The operational consequence is that a revocation can be silently deferred by up to the maximum positive-cache TTL across all interior issuers in the chain — not the leaf's TTL, which is the number operators typically tune. In the observed case the effective revocation latency was 180s against an assumed 0s. The mitigation is to require full-ancestor coverage at the verifier and to cap positive caching at interior issuers to zero, or to replace per-hop checks with a chain-bound proof. Detection logic should fail closed on incomplete coverage rather than trusting the union of positive results. ```python class IncompleteChainCoverageError(RuntimeError): """Raised when a verifier's consulted set does not cover every issuer in a delegation chain.""" def validate_delegation_chain(chain_issuers, consulted_issuers, interior_positive_cache_ttl_s): """ chain_issuers: ordered list of issuer DIDs from root to leaf. consulted_issuers: set of issuer DIDs actually queried for revocation status. interior_positive_cache_ttl_s: max positive-cache TTL among interior issuers. """ if not chain_issuers: raise IncompleteChainCoverageError("empty delegation chain cannot be validated") interior = set(chain_issuers[:-1]) missing = interior - set(consulted_issuers) if missing: raise IncompleteChainCoverageError( "interior issuers not consulted for revocation: " f"{sorted(missing)}; effective revocation latency may be up to " f"{interior_positive_cache_ttl_s}s" ) if interior_positive_cache_ttl_s > 0: raise IncompleteChainCoverageError( "interior issuers use positive revocation caching " f"(ttl={interior_positive_cache_ttl_s}s); chain-bound proof required" ) return True ```