L7 — Environment Mutation Detection

Status: state model, classifier and L2 correlation complete. 41 tests. Collector (fanotify/eBPF) not exercised — needs kernel privileges.

The attack

install a package → modify a config → replace an executable → exploit later

Each step is unremarkable alone. Only the sequence is an attack, and only against a frozen baseline is the sequence visible.

What this layer is actually for here

In a naive stack L7 catches ordinary configuration drift. In this stack L1 already makes the rootfs read-only and discards the overlay after every run, so drift of that kind cannot persist. That makes L7's real job different, and more valuable:

L7 detects that a layer below has already failed.

A write to a read-only region is not "unexpected configuration change". It is evidence that the hypervisor, the kernel, or the mount enforcement did not hold. That is the framework's own premise — assume every other layer has already failed — turned into a tripwire, and it is why this layer is not a nicer report on facts L1 already knows.

containment_failed is therefore not a score to weigh. It means an invariant enforced structurally did not hold, so the response is to stop.

Why not hash everything every second

The original design called for hashing the filesystem, memory maps, process list, kernel state and loaded libraries once per second. That does not survive contact with a real filesystem: a 100k-file rootfs is tens of gigabytes of reads per minute. The monitor becomes the dominant workload and is the first thing an operator disables under load — a control that gets switched off is worse than no control, because it is still on the architecture diagram.

So capture is event-driven (fanotify/eBPF) and verification is incremental against a merkle baseline. An observation touches one entry; the root is recomputed over digests, never by re-reading file content. Full re-verification is a checkpoint operation, not a polling loop.

Three verdicts

Verdict	Meaning
`EXPECTED`	A writable region changed and an L2 grant explains it
`UNEXPLAINED`	A writable region changed and nothing explains it
`IMPOSSIBLE`	A read-only region changed — a layer below failed

The join with L2 is the point of the layer. The interesting signal is not "a file changed" — it is "a file changed and no permitted action explains it." A broker refusal does not stop a write that bypasses the broker, which is precisely why observation is needed alongside authorisation.

Path handling

Classification happens after normalisation, because a path that classifies differently before and after is a bypass: /workspace/../rootfs/libc.so must be judged as /rootfs/libc.so.

Two subtleties, both found by tests rather than by design:

/../escape is legitimate. POSIX resolves a climb above root back to root, so it means /escape — which classifies as an unknown region, i.e. immutable. The test asserting this originally expected an error; the code was right and the test was wrong.
Leading slashes must be collapsed. POSIX leaves exactly two leading slashes implementation-defined and Python preserves them, so //rootfs/libc.so would miss the /rootfs prefix. That failed safe today (unknown regions classify immutable) but was latent — a policy change making unknown regions permissive would have turned it into a hole.

Unknown regions default to immutable: an unclassified path that turns out to be writable is a hole, whereas a false alarm is only noise. Prefix matching is anchored at a directory boundary so /rootfs-evil cannot pass as a child of /rootfs.

Prefix matching is safe here in a way L2's package allowlist is not: a filesystem hierarchy is a prefix tree, and these prefixes describe operator-chosen mount points, not agent-supplied names.

Baseline integrity

The baseline is frozen by seal() and cannot be modified afterwards. A reference an adversary can move is not a reference — that is the failure mode of anomaly detectors retrained on live traffic, and the same reason L5 will need a frozen distribution.

The merkle root is computed over (path, digest) leaves sorted by path, so it is a function of the file set rather than of the order the collector happened to walk them.

Collector hygiene is enforced: an observation whose before == after is rejected, because a collector reporting unchanged files would let real changes hide in the volume it generates.

Not guaranteed

The collector itself. fanotify/eBPF needs kernel privileges this sandbox lacks. Its output shape is MutationObservation, so the adapter is deliberately thin — untested code should be as small as possible.
Completeness. An observation never delivered is never classified. A collector inside the guest could be silenced; it belongs on the host side of the L1 boundary for the same reason the ledger producer does.
Memory, process and kernel state. Only filesystem mutation is modelled here. The other channels in the original design need their own collectors.

L9 — the kill system. Wire containment_failed to an unconditional stop, and pair L2's denial signal with it. Both trigger types are needed: pure thresholds are pace-able, which is the boil-the-frog problem already solved once in L2.

Datasets:

Sahek
/

ames