""" L9 -- Autonomous Kill System. Two departures from the original design, both load-bearing. FIRST: RULES COME IN TWO CLASSES, NOT ONE. The original specification was a flat list of hardcoded thresholds -- privilege escalation, unexpected process, dormant process, repeated denials -- each firing a kill. Against the threat model the framework itself assumes (adaptive, patient, perfect memory, and able to READ THIS FILE) a flat threshold list is a map of exactly how far to go without being stopped. An adversary paces one request under every limit, indefinitely. So conditions are split by what they actually mean: ABSOLUTE Never legitimate under any circumstances. One occurrence is proof, so there is no threshold to pace under and no window to wait out. A write to a read-only region is not "a lot of risk", it is an invariant that did not hold. ACCUMULATING Individually plausible, suspicious in aggregate. These carry BOTH a burst trigger and an EWMA, because a burst check alone is blind to the patient enumeration that is the whole point of the threat model. Same fix as L2's denial tracker, and the same one the multi-agent-mcl work arrived at independently. SECOND: THE KILLER READS ONLY HOST-OBSERVED EVIDENCE. "No LLM decides, no policy engine decides" is necessary but not sufficient. If a kill can be computed from guest-reported claims then a compromised guest has two attacks: stay quiet to avoid tripping it, or fabricate claims to trip it against a legitimate run and deny service to the operator. `Evidence.from_run` therefore filters to the host-observed actor band before anything is counted, and tests assert that guest claims can neither cause nor prevent a kill. FAIL CLOSED. If the evaluator itself raises, the verdict is KILL. An exception in the safety system must never mean "carry on" -- that is how a monitoring bug becomes a containment bypass. There is deliberately no disable, no override, no threshold setter and no way to register a predicate at runtime. The rules are frozen module constants. An adversary who can add a rule can add one that never fires. """ from __future__ import annotations import enum from dataclasses import dataclass, field from typing import Callable, Iterable, List, Optional, Sequence, Tuple from ames.events import Capability, EventType # The tracker is a generic burst+EWMA rate detector; it is named for its first # use in L2. Reused here rather than reimplemented so there is one # implementation of this logic in the codebase, already under test. from containment.broker import DenialSignal, DenialTracker as RateTrigger from containment.envstate import EnvironmentMonitor, MutationVerdict from containment.vmspec import is_host_observed class KillReason(enum.Enum): # --- absolute: one occurrence is proof --------------------------------- CONTAINMENT_FAILURE = "containment_failure" # read-only region changed PRIVILEGE_ESCALATION = "privilege_escalation" # a priv raise was granted UNATTRIBUTED_ACTION = "unattributed_action" # Gate 1 lineage break DORMANT_PROCESS = "dormant_process" # actor alive past RUN_END EVALUATOR_FAILURE = "evaluator_failure" # fail-closed # --- accumulating: plausible alone, not in aggregate -------------------- DENIAL_BURST = "denial_burst" DENIAL_SUSTAINED = "denial_sustained" MUTATION_BURST = "unexplained_mutation_burst" MUTATION_SUSTAINED = "unexplained_mutation_sustained" ABSOLUTE_REASONS = frozenset({ KillReason.CONTAINMENT_FAILURE, KillReason.PRIVILEGE_ESCALATION, KillReason.UNATTRIBUTED_ACTION, KillReason.DORMANT_PROCESS, KillReason.EVALUATOR_FAILURE, }) # Gate 1 violation codes that are absolute kills rather than report-only. # Each means the lineage graph is broken, so attribution is guesswork and no # later judgement about "who did this" can be trusted. FATAL_GATE1_CODES = frozenset({ "UNATTRIBUTED_ACTION", "ACTION_AFTER_EXIT", "ORPHAN_SPAWN", "EXIT_WITHOUT_SPAWN", "DOUBLE_SPAWN", "RESPAWN_AFTER_EXIT", }) @dataclass(frozen=True) class Evidence: """Host-observed facts only. Never guest testimony. Construct via `from_run` rather than by hand in production: the filtering is the security property, and a hand-built Evidence can assert anything. """ containment_failed: bool = False fatal_gate1_codes: Tuple[str, ...] = () dormant_actors: int = 0 privilege_escalation_granted: bool = False denial_signal: Optional[DenialSignal] = None unexplained_mutations: int = 0 guest_claims_seen: int = 0 # recorded for context, never evaluated @staticmethod def from_run(*, monitor: Optional[EnvironmentMonitor] = None, gate1_violation_codes: Iterable[str] = (), broker_history: Iterable = (), denial_signal: Optional[DenialSignal] = None, ledger_events: Iterable = ()) -> "Evidence": """Assemble evidence, discarding anything the guest could have authored. Every input here is produced by a host-side component: L7's monitor, L8's Gate 1 over the ledger, L2's broker. Ledger events are filtered to the host-observed actor band, so a guest that floods claims changes only `guest_claims_seen`, which nothing evaluates. """ host_events, guest_events = [], 0 for ev in ledger_events: if is_host_observed(ev.actor_id): host_events.append(ev) else: guest_events += 1 priv_granted = False for ev in host_events: if ev.event_type is EventType.CAPABILITY_REQUEST and len(ev.payload) >= 2: cap, granted = ev.payload[0], ev.payload[1] if cap == int(Capability.PRIVILEGE_RAISE) and granted == 1: priv_granted = True # A granted privilege raise should be impossible: L2 lists it in # NEVER_IN_RUN. Seeing one recorded means the policy engine was bypassed # or replaced, which is itself the emergency. for dec in broker_history: if (dec.request.capability is Capability.PRIVILEGE_RAISE and dec.verdict.granted): priv_granted = True codes = tuple(c for c in gate1_violation_codes if c in FATAL_GATE1_CODES) dormant = sum(1 for c in gate1_violation_codes if c == "UNTERMINATED_ACTOR") unexplained = 0 contained_failed = False if monitor is not None: contained_failed = monitor.containment_failed unexplained = len(monitor.by_verdict(MutationVerdict.UNEXPLAINED)) return Evidence( containment_failed=contained_failed, fatal_gate1_codes=codes, dormant_actors=dormant, privilege_escalation_granted=priv_granted, denial_signal=denial_signal, unexplained_mutations=unexplained, guest_claims_seen=guest_events, ) @dataclass(frozen=True) class KillVerdict: kill: bool reasons: Tuple[KillReason, ...] detail: str = "" @property def absolute(self) -> bool: """True if any reason is one that needs no accumulation.""" return any(r in ABSOLUTE_REASONS for r in self.reasons) class KillSwitch: """Evaluates host-observed evidence and decides whether to stop. Deliberately exposes no way to disable, override, add a rule, or move a threshold after construction. Thresholds are constructor arguments so an operator can tune sensitivity for an environment; they cannot be changed while a run is in flight, and no argument can switch a rule off. """ def __init__(self, *, mutation_burst: int = 3, mutation_window_s: float = 60.0, mutation_ewma_threshold: float = 0.30) -> None: # Independent of L2's denial tracker: unexplained mutations and denied # requests are different signals and should not share a budget. self._mutation_trigger = RateTrigger( window_seconds=mutation_window_s, burst_threshold=mutation_burst, ewma_threshold=mutation_ewma_threshold, ) self._tripped = False self._verdict: Optional[KillVerdict] = None # --- evaluation --------------------------------------------------------- def evaluate(self, evidence: Evidence) -> KillVerdict: """Total. Any internal failure yields KILL, never a pass.""" try: reasons: List[KillReason] = [] details: List[str] = [] # --- absolute --------------------------------------------------- if evidence.containment_failed: reasons.append(KillReason.CONTAINMENT_FAILURE) details.append("a read-only region was modified; an L1 invariant did not hold") if evidence.privilege_escalation_granted: reasons.append(KillReason.PRIVILEGE_ESCALATION) details.append("a privilege raise was granted, which L2 lists as never grantable") if evidence.fatal_gate1_codes: reasons.append(KillReason.UNATTRIBUTED_ACTION) details.append( "lineage broken (" + ", ".join(sorted(set(evidence.fatal_gate1_codes))) + "); attribution is guesswork once the graph has holes" ) if evidence.dormant_actors > 0: reasons.append(KillReason.DORMANT_PROCESS) details.append( f"{evidence.dormant_actors} actor(s) alive past RUN_END; a dormant " f"process is how persistence survives a run boundary" ) # --- accumulating ---------------------------------------------- sig = evidence.denial_signal if sig is not None: if sig.instantaneous: reasons.append(KillReason.DENIAL_BURST) details.append(f"denial burst: {sig.detail or sig.recent_denials}") if sig.cumulative: reasons.append(KillReason.DENIAL_SUSTAINED) details.append(f"sustained denial rate {sig.ewma:.3f} (patient enumeration)") if evidence.unexplained_mutations: m = None for _ in range(evidence.unexplained_mutations): m = self._mutation_trigger.record(denied=True, now=self._tick()) if m is not None: if m.instantaneous: reasons.append(KillReason.MUTATION_BURST) details.append(f"{m.recent_denials} unexplained mutations in window") if m.cumulative: reasons.append(KillReason.MUTATION_SUSTAINED) details.append(f"sustained unexplained-mutation rate {m.ewma:.3f}") verdict = KillVerdict(bool(reasons), tuple(reasons), "; ".join(details)) except Exception as exc: # noqa: BLE001 -- deliberate # An exception in the safety system must not mean "carry on". verdict = KillVerdict( True, (KillReason.EVALUATOR_FAILURE,), f"kill evaluator raised {type(exc).__name__}: {exc}; failing closed", ) if verdict.kill: self._tripped = True self._verdict = verdict return verdict def _tick(self) -> float: # Monotonic counter rather than wall clock: the trigger only needs # ordering, and a clock the guest could influence is an input the guest # could influence. self._counter = getattr(self, "_counter", 0.0) + 1.0 return self._counter # --- state -------------------------------------------------------------- @property def tripped(self) -> bool: """Once tripped, always tripped. A kill is not reconsidered: the condition that caused it may not recur, and 'it stopped happening' is exactly what a successful attacker produces.""" return self._tripped @property def verdict(self) -> Optional[KillVerdict]: return self._verdict def kill_payload(verdict: KillVerdict) -> bytes: """Encode a kill decision for the ledger as a denied capability. Recorded as host-observed: the host decided, so it is evidence rather than testimony, and survives a compromised guest. """ from ames.canonical import payload_capability_request reasons = ",".join(r.value for r in verdict.reasons) return payload_capability_request( Capability.PROCESS_SPAWN, False, f"KILL[{reasons}] {verdict.detail}"[:512] )