# L0 — Adversarial Validation Engine **Status:** complete, within an honestly stated scope. 15 tests (8 scenario, 7 property). 250 total across the repo. --- ## What L0 is here, and what it can't be L0 sits outside the L1–L9 stack rather than inside it: every other layer defends the run; this one checks whether the layers actually hold — and whether they hold **together**, not just individually. The original design described it as the layer that turns every "not verified here" note across these docs into something checked on real hardware. That can't be built in this environment. This sandbox has no `/dev/kvm` and no kernel privileges, so `containment.backend.FirecrackerBackend` is still exactly what its own docstring says: *"reviewed but not exercised... until the L0 adversarial validation engine runs it on real hardware."* That sentence is still true after this module. Whether Firecracker actually isolates, whether the fanotify/eBPF collector L7 assumes delivers what `MutationObservation` expects, whether vsock actually enforces one-direction-only data flow — none of that is checked here, and nothing below claims otherwise. What **is** honestly buildable, and is what got built: ## 1. Full-stack composed scenarios (`validation/scenarios.py`) Every adversarial test suite in this repo, up to this point, tests one layer with the layers below it faked or hand-constructed. L9's own tests build `Evidence` by typing `containment_failed=True` directly; L1's tests never drive a real `Broker`. That's the *correct* way to unit-test a layer in isolation, and it leaves exactly one thing unchecked: does the composition actually work when real components are wired together, not a hand-typed stand-in for what one "should" produce. `ScriptedBackend` is the piece that makes this possible without touching `Supervisor.run()`'s lifecycle. A guest, in reality, acts *while* the VM is running — between L1's `PROCESS_SPAWN(VM_ACTOR_ID)` and its `PROCESS_EXIT(VM_ACTOR_ID)`. Since `Supervisor.run()` is one synchronous call, the only place caller code still runs inside it is `backend.wait()`. `ScriptedBackend.wait()` runs a caller-supplied script there, so anything it does through `supervisor.record_guest_claim()` or the new `supervisor.emit_host_event()` seam lands at exactly the sequence position a real interleaved action would have. Six scenarios, each driving real components end to end: | Scenario | Composes | Proves | |---|---|---| | `clean_baseline_run` | everything | true-negative baseline — nothing fires on nothing | | `read_only_breach_triggers_absolute_kill` | real L7 `EnvironmentMonitor` → real `Evidence` → real `KillSwitch` | L7's `containment_failed` and L9's absolute rule agree | | `patient_enumeration_defeats_burst_not_ewma` | real `Broker`/`DenialTracker` → real `KillSwitch` | the EWMA path fires from real denial pacing, not a hand-built signal | | `well_formed_multi_actor_run_passes_gate1` | real guest spawn/act/exit + real host-attributed broker decision, interleaved | a legitimate multi-actor run doesn't false-positive | | `unattributed_guest_action_after_run_end_is_fatal` | real Gate 1 over a real malformed ledger → real `KillSwitch` | persistence-after-exit is fatal through the real path, not a literal `fatal_gate1_codes` tuple | | `concealed_capability_narrative_flags_drift_but_never_kills` | real `DriftMonitor` alongside real `KillSwitch` | L6 is *structurally* incapable of killing, not just documented as advisory | That last one is the one worth dwelling on. Every L6 doc asserts, in prose, that drift findings can't kill. This scenario doesn't trust the prose: it manufactures a real `OUTCOME_MISMATCH` (a guest narrating a grant for a capability the broker actually denied — the concealment shape `multi-agent-mcl` models) and checks the kill verdict is bit-for-bit identical to the clean baseline despite it. `Evidence.from_run` has no parameter that consumes a `DriftFinding` — there is no path to check, which is a stronger claim than "the current code doesn't happen to use it." ### Two bugs this caught in itself before a single test was written Running the scenarios directly (before writing any assertions) surfaced two real mistakes, both worth recording rather than quietly fixing: 1. `Ledger.all_events()` only yields **sealed** blocks. A guest claim recorded after `Supervisor.run()` returns sits in `_pending` — invisible to Gate 1 until something seals a new block over it. The `unattributed_guest_action_after_run_end_is_fatal` scenario originally showed a clean Gate 1 result, which was wrong; the fix is an explicit second `seal_block()` call, and the fact that it's needed at all is itself a small, honest finding about what "the run is over" actually means for an operator inspecting the ledger immediately after `run()` returns. 2. `record_guest_claim` enforces Gate 1's lineage rule exactly like a real guest action would: an actor must be spawned before anything else can be attributed to it. The `concealed_capability_narrative` scenario's first draft skipped the spawn and got an unintended `UNATTRIBUTED_ACTION` kill instead of the intended drift-only finding — caught by running the scenario, not by trusting the docstring describing what it should do. ### A gap this surfaced, left open rather than papered over `record_guest_claim` always attributes a spawn with `parent=NO_PARENT` — there is currently no way to record a guest process as a structural child of `VM_ACTOR_ID`, only as a root actor. Gate 1 still accepts this (a root-level spawn/exit pair is legal on its own), but it means the lineage graph doesn't actually connect "the VM" to "the guest process inside it" the way the framework's narrative implies. Fixing it means adding a `parent` parameter to `Supervisor.record_guest_claim` — real API surface, and a decision for whoever owns L1's supervisor next, not something this scenario module should quietly work around. ## 2. Property-based fuzzing (`validation/properties.py`, `tests/test_l0_properties.py`) Every example-based test in this repo answers "does the code handle *this* attack a human thought of" — necessary, and also exactly the kind of test an adversary who has read the test file can plan around. A hand-picked example set is finite and knowable. Property-based testing (via Hypothesis) asks a different question — does an invariant hold for every input in a class, including ones nobody picked — across machine-generated cases on every run. Seven properties, each checked against 100–300 generated cases per run: - Canonical encode/decode round-trips for **any** structurally valid `Event`, not just the pinned conformance vectors. - Merkle inclusion proofs verify for every index, for randomly generated leaf lists from size 0 to 40. - The empty tree is always `ZERO_DIGEST`. - Flipping one byte of one leaf always changes the root (a cheap avalanche/no-collision spot check, not a claim about BLAKE3's cryptographic properties). - Gate 1 accepts **any** randomly generated, internally consistent process lineage tree — not just the hand-built ones in `test_tamper.py`. - Removing any one actor's spawn from any randomly generated tree always leaves Gate 1 unsatisfied — a fuzzed version of gate1.py's own claim that "hiding an action requires hiding a consistent set of events." - Duplicating any one actor's spawn always trips `DOUBLE_SPAWN` specifically. ### The bug fuzzing caught immediately The duplicated-spawn property failed on its first run. The test appended the duplicate at the *end* of the stream, which — depending on the randomly generated topology — could land after that actor had already exited, and Gate 1 correctly reported `RESPAWN_AFTER_EXIT` instead of `DOUBLE_SPAWN`: a different, equally correct rejection, but not the one the test claimed to check. Hypothesis's shrinking found the minimal case in seconds. The fix was to insert the duplicate immediately after the original spawn, while the actor is provably still live, which pins down `DOUBLE_SPAWN` regardless of topology. This is precisely the class of bug example-based testing structurally cannot find — a hand-picked example doesn't accidentally land on the wrong side of an exit boundary — and it's the strongest evidence in this repo that fuzzing and example-based testing are complementary rather than redundant. --- ## Not guaranteed - **Anything about real hardware.** Firecracker's actual isolation, the fanotify/eBPF collector, vsock's actual one-directionality — none of it. This module validates composition and logical invariants in software. - **Exhaustiveness of the lineage generator.** `lineage_stream` produces a random forest with actors created in valid order and exited in reverse — not every legal interleaving Gate 1 would accept. The properties checked don't require covering every legal interleaving, only that generated streams are genuinely legal ones. - **That six scenarios exhaust the composition space.** They're the six that correspond to a specific claim made elsewhere in these docs (L7↔L9, L2↔L9, a legitimate multi-actor run, persistence-after-exit, L6's advisory boundary, and a clean baseline). More compositions are possible; these are the ones this pass checked. ## What's left **Resolved since this doc was written:** the L3/L4 question is answered in `docs/l3_l4_audit.md` — about half subsumed by L1/L8, half not, with the un-subsumed half (per-binary verification, spawn-token authorization) now implemented host-side in `containment/identity.py`. What remains is only the hardware-dependent work named above: exercising `FirecrackerBackend` on a host with `/dev/kvm`, validating the fanotify/eBPF collector, and confirming vsock's one-directionality.