# When must an instance refuse to federate: capability attestation drift across brokered trust chains **Date of Record:** 2026 November 14 **Scope:** This record applies to multi-agent federation where agent A reaches agent C only through a broker B, and A's authorization decision depends on an attestation of C's capabilities that B relays. It does not apply to direct peer-to-peer federation where the relying party verifies the attestation issuer itself, nor to single-org deployments where policy negotiation and attestation share one trust root. ## Core Distinction The failure is not "the broker is untrusted." It is the distinction between **attestation freshness at the broker** and **attestation validity at the relying party**. A broker B that re-signs, re-wraps, or caches C's capability attestation can hold a locally valid, fresh copy of that attestation while the relying party A is operating under a policy whose attestation-validity window closed between B's verification and A's decision. The brokered chain collapses two clocks — B's verification time and A's authorization time — into one apparent timestamp. The non-obvious part: a correctly implemented broker that verifies signatures on every hop *strengthens* the false signal. Each hop is individually sound, so no single component reports an error, yet the composite decision is made on an attestation that was valid at hop N and stale at hop N+1. ## What Was Observed In a three-party federation (A relies on broker B for C's capabilities), the following sequence produced a silent over-authorization: 1. C issued a capability attestation with `not_after = T0 + 300s` and a policy binding to a specific negotiated scope `S1`. 2. B verified the attestation at `T0 + 10s`, cached it, and re-presented it to A at `T0 + 340s` as part of a policy-negotiation response. 3. A's policy engine checked the attestation signature (valid), the issuer (valid), and the *broker's* presentation timestamp (fresh). It did not re-check `not_after` against its own clock. 4. A granted scope `S1` to C for 600s beyond expiry. No component raised an error. The broker's cache TTL (360s) exceeded the attestation TTL (300s) by design, and the relying party trusted the broker's freshness claim rather than the attestation's own expiry. The invariant "attestation is valid" was true at every individual hop and false for the end-to-end decision. A second variant: policy negotiation re-scoped the grant from `S1` to `S2` at the broker, but the attestation's policy binding still named `S1`. A accepted the re-scoped grant because it validated the attestation's *signature*, not its *binding* against the negotiated scope. ## Condition of Validity An attestation relayed through a broker is valid at the relying party only if all of the following hold: - The relying party independently evaluates `not_after` and any `not_before` against its own monotonic clock at decision time, not the broker's presentation timestamp. - The attestation's policy binding (scope identifier, subject constraints) is checked against the *negotiated* policy, not merely against the broker's claim that negotiation succeeded. - The broker's cache TTL is strictly less than the minimum attestation lifetime it is permitted to relay, or the broker re-issues a fresh attestation under its own authority with a documented delegation chain. - The delegation chain from C's issuer to the broker to the relying party is walked and each link's constraints are intersected, not merely concatenated. If any condition fails, the composite decision is unsound even though every hop reports success. ## Decision Boundary The boundary is this: **a broker may relay an attestation it has verified, but it may not assert freshness on the relying party's behalf unless it holds a delegated authority to re-issue.** Concretely: - If B holds a re-issuance delegation from C's issuer, B may present a fresh attestation; A must still verify the delegation chain and the intersection of constraints. - If B holds only a relay role, A must treat B's presentation as a *transport event*, not an *authorization event*, and must re-evaluate expiry and binding itself. - If the negotiated scope differs from the attestation's bound scope, the decision is a refusal, not a downgrade — silently narrowing or widening scope at the broker is the second observed failure. The refusal must be explicit and logged with the attestation ID, the broker hop, both clocks, and both scopes, so that the failure is attributable rather than absorbed. ## Operational Effect Systems that cross this boundary silently over-authorize for the duration of the cache TTL minus the attestation TTL, and the window is invisible in per-hop logs because every hop succeeds. Detection requires an end-to-end audit that replays the decision with the attestation's own expiry and binding, independent of the broker's claims. Remediation is structural: separate transport freshness from authorization freshness in the policy engine's data model, and make scope-binding mismatch a hard refusal. The following reference check encodes the boundary as an explicit refusal path. ```python import time from dataclasses import dataclass class FederationAttestationError(RuntimeError): """Raised when a brokered attestation cannot soundly authorize a decision.""" pass @dataclass(frozen=True) class Attestation: attestation_id: str issuer: str subject_agent: str bound_scope: str not_before: float not_after: float signature_valid: bool @dataclass(frozen=True) class BrokerPresentation: attestation: Attestation broker_id: str broker_verified_at: float broker_presentation_at: float broker_holds_reissuance_delegation: bool negotiated_scope: str def authorize_via_broker( presentation: BrokerPresentation, relying_party_clock: float, max_clock_skew: float = 5.0, ) -> str: att = presentation.attestation if not att.signature_valid: raise FederationAttestationError( f"attestation {att.attestation_id} signature invalid at broker " f"{presentation.broker_id}" ) # Relying party must evaluate expiry against its OWN clock, not the # broker's presentation timestamp. if relying_party_clock > att.not_after + max_clock_skew: raise FederationAttestationError( f"attestation {att.attestation_id} expired at relying party: " f"not_after={att.not_after} decision_clock={relying_party_clock} " f"broker_presented_at={presentation.broker_presentation_at}" ) if relying_party_clock < att.not_before - max_clock_skew: raise FederationAttestationError( f"attestation {att.attestation_id} not yet valid at relying party" ) # Scope binding must match the negotiated scope. A broker that re-scopes # without a delegation is asserting authority it does not hold. if att.bound_scope != presentation.negotiated_scope: if not presentation.broker_holds_reissuance_delegation: raise FederationAttestationError( f"scope-binding mismatch for {att.attestation_id}: " f"attestation bound to {att.bound_scope!r}, negotiated " f"{presentation.negotiated_scope!r}, broker " f"{presentation.broker_id} holds no reissuance delegation" ) raise FederationAttestationError( f"scope-binding mismatch for {att.attestation_id} requires " f"delegation-chain walk; not performed in this path" ) # Broker cache TTL must not exceed attestation lifetime for relayed grants. broker_lag = presentation.broker_presentation_at - presentation.broker_verified_at attestation_lifetime = att.not_after - att.not_before if broker_lag > attestation_lifetime: raise FederationAttestationError( f"broker {presentation.broker_id} relayed {att.attestation_id} " f"after {broker_lag:.1f}s, exceeding attestation lifetime " f"{attestation_lifetime:.1f}s" ) return presentation.negotiated_scope if __name__ == "__main__": att = Attestation( attestation_id="att-7f3a", issuer="org-c-issuer", subject_agent="agent-c", bound_scope="S1", not_before=1000.0, not_after=1300.0, signature_valid=True, ) pres = BrokerPresentation( attestation=att, broker_id="broker-b", broker_verified_at=1010.0, broker_presentation_at=1340.0, broker_holds_reissuance_delegation=False, negotiated_scope="S1", ) try: authorize_via_broker(pres, relying_party_clock=1341.0) except FederationAttestationError as exc: print(f"REFUSED: {exc}") ```