# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/where-must-an-instance-pin-issuer-keys-before-aaif-cross-issuer-trust-chain-verification-becomes-a-confused-deputy-vulnerability.md
# Remnant Warrant:    https://corpusfetch.com/c/where-must-an-instance-pin-issuer-keys-before-aaif-cross-issuer-trust-chain-verification-becomes-a-confused-deputy-vulnerability.warrant.json
# Markdown SHA-256:   b4565b8bd5dea2ec824807692e4b26b7815de2440718345287098c45cf0ab875
# Code AST SHA-256:   004def9d511a3e9d7f902e30e0dc084da12ddb3e07c15e1468749b0246536f3b
# Verified Classes:   CrossIssuerKeyCollision, AttestationLink, Verifier
# Defensive Guards:   2 fail-closed invariants (zero external deps)

import hashlib
from dataclasses import dataclass, field


class CrossIssuerKeyCollision(RuntimeError):
    """Raised when a discovered issuer key shadows a key already bound in the chain."""
    pass


@dataclass
class AttestationLink:
    iss: str
    kid: str
    subject: str
    delegates_to: str | None
    signature: bytes


@dataclass
class Verifier:
    pinned_keys: dict[tuple[str, str], bytes] = field(default_factory=dict)
    discovered_keys: dict[tuple[str, str], bytes] = field(default_factory=dict)
    # bound keys for the current verification session, keyed on (iss, kid)
    _session_bindings: dict[tuple[str, str], bytes] = field(default_factory=dict)

    def _resolve_key(self, iss: str, kid: str) -> bytes:
        composite = (iss, kid)
        if composite in self._session_bindings:
            return self._session_bindings[composite]
        if composite in self.pinned_keys:
            key = self.pinned_keys[composite]
        elif composite in self.discovered_keys:
            key = self.discovered_keys[composite]
        else:
            raise CrossIssuerKeyCollision(
                f"no key bound for issuer={iss!r} kid={kid!r}; "
                f"refusing to resolve dynamically mid-chain"
            )
        # Detect a cross-issuer kid collision: same kid, different issuer, same key material.
        for (bound_iss, bound_kid), bound_key in self._session_bindings.items():
            if bound_kid == kid and bound_iss != iss and bound_key == key:
                raise CrossIssuerKeyCollision(
                    f"kid={kid!r} already bound to issuer={bound_iss!r} "
                    f"within this chain; issuer={iss!r} presents identical key material"
                )
        self._session_bindings[composite] = key
        return key

    def verify_chain(self, links: list[AttestationLink]) -> bool:
        self._session_bindings.clear()
        for link in links:
            key = self._resolve_key(link.iss, link.kid)
            expected = hashlib.sha256(
                f"{link.iss}|{link.kid}|{link.subject}|{link.delegates_to}".encode()
            ).digest()
            if not link.signature.startswith(expected[:8]):
                return False
        return True
