# FAQ

Objections, in roughly the order people raise them. The strongest ones are near
the bottom and several of them are conceded.

---

### Just remove the user from the `docker` group. Why is this a paper?

Removing the group membership is the correct remediation, and the paper says so.
The paper is not about the fix; it is about the fact that **three earlier
revisions of this same verifier returned a clean result on this same host**.

The interesting question is not "is `docker` group membership root-equivalent" —
Docker documents that itself. It is: what property must a verifier have such that
it cannot report a clean result while that membership exists? Answer that and you
get the same guarantee for the mechanisms nobody has documented yet.

### Isn't a blocked verdict just a failure?

It is the deliverable. A verifier that only produces good news when the news is
good is doing its job; the failure mode being prevented is the *opposite* — a
clean result produced by not looking properly.

Concretely, three of the four findings in this paper would each have produced a
clean verdict on a host with a live root-equivalent path. The system reports
blocked because it now notices what it previously did not.

### No kernel exploit, no boundary crossed. So what was the vulnerability?

There wasn't one, and that is the point. The DAC check on the Docker socket
*passes*. Authority was delegated by configuration rather than bypassed.

This matters for anyone sandboxing agents, because the usual mitigations do not
touch it. No seccomp filter, capability drop, namespace or MAC policy applied to
the agent changes the outcome — the agent is *permitted* to ask a privileged
daemon to do privileged things, and it is asking politely.

### 18 unresolved paths sounds like the tool just gave up.

That is the honest reading, and it is half right. Those 18 cannot be resolved
without reads the agent principal does not have: `sudoers` contents, polkit rule
bodies, unit file internals. The design decision is what to do about it.

The options are to guess, to omit, or to block. The first two turn "I could not
check" into "there is nothing there," which is the exact failure the paper is
named after. So it blocks, and emits `OPERATOR_EVIDENCE_CHECKLIST.json` — the
list of reads a human with root must perform to convert each unresolved path into
a measured one.

### Can I reproduce the host numbers?

**No, and that is deliberate.** `privilege_resolution.py` refuses to write in any
context that cannot prove it measured the host as the agent identity. Run it on
your machine and it will report `admissible: False`, name its disqualifiers, and
leave the artifact untouched.

This is a real limitation for artifact evaluation and it is stated as one in §16.
It exists because the alternative is worse: the same collector run inside a
container on an **unchanged** host reports zero root-equivalent paths. That clean
result is true of the container and false of the host, and recording it as a
verdict is Finding 3.

What you *can* reproduce, on any machine, is every piece of reasoning over the
evidence: `reproduce_verdict.py`, the 83 tests, the 15 control cases, the whole
manifest chain. See [GETTING_STARTED.md](GETTING_STARTED.md).

### Why does `sha256sum -c` report failures?

Because the manifests are append-only and never regenerated. Run
`python3 check_manifest_chain.py` instead — it exits 0 only if every mismatch is a
recorded supersession. [VERIFYING.md](VERIFYING.md) has the full explanation,
including one genuine break in this package and how it was repaired.

### n = 1. Does anything here generalise?

The counts do not. Every number about the host — 57 paths, 35 setuid binaries, 2
root-equivalent carriers — is a property of one Fedora workstation at one moment
and should not be cited as typical of anything.

What is meant to generalise is the method: three-valued reasoning, deriving
classifications rather than reading declared summaries, binding every inventory to
its measurement context, and deriving coverage from contents. Whether it *does*
generalise is untested, and the paper says so rather than implying otherwise.

### Has anyone independently attacked this?

No. There has been no independent adversarial evaluation. The 14 negative controls
are attacks the authors thought of, which is a weaker thing — the whole history of
this project is that the authors kept not thinking of things for three revisions
at a time.

This is the limitation most likely to matter, and the reason the contact section
of the README asks for adversarial objections specifically.

### Four findings, all self-reported. Isn't that convenient?

It is worth being suspicious of. Each is checkable rather than asserted:

- Finding 1 — the surface coverage gate is in the code and its control case is
  `NEGATIVE_partial_surface_coverage`.
- Finding 2 — the repeatability condition is condition 18 in
  `verification_result.json`.
- Finding 3 — run any collector in a container and watch it refuse.
- Finding 4 — `NEGATIVE_summary_edited_to_hide_root` edits an inventory summary to
  conceal a root path and asserts the gate still blocks.

A fifth was found while preparing this public release, in the packaging rather
than the verifier, and is disclosed in [VERIFYING.md](VERIFYING.md).

### Theorem 1 was a "proof sketch" in an earlier draft. Is it still?

No. It is a proof plus an exhaustive machine-checked case analysis: every
reachable combination of path classifications and condition states is enumerated
and the safety property checked on each. Running the test suite prints:

```text
Theorem 1: 2646 cases enumerated, 5 reached VERIFIED
```

The second number is the anti-vacuity guard. A theorem that holds because the
verifier never returns `VERIFIED` would be worthless, so the enumeration asserts
that some inputs do reach a positive verdict.

### Why publish the host's privilege configuration?

Because redacting it would change every digest, force the manifests to be
resealed, and destroy the append-only history the paper is about. A paper on
evidence integrity that ships evidence which does not verify would refute itself.

The disclosure is bounded: no hostname, IP or MAC address appears anywhere in the
package. What is published is a configuration, not a locator, and its headline
fact is documented by Docker.

### Is the bibliography reliable?

Mostly. 9 of the 40 entries carry author/title/venue/year only and are marked
`% UNVERIFIED-METADATA` in `references.bib` — page numbers and DOIs are not
confirmed. They are cited for claims the text also supports directly. The
remaining 31 are complete.

### What would it take to reach a positive verdict on this host?

In order: remove the `docker` group membership (or move to a rootless daemon),
then have an operator work through the 18 checklist items, then resolve the one
`UNKNOWN` path. Conditions 06, 07, 12, 17 and 19 would each need to flip:

| | |
|---|---|
| 06 | no root-equivalent runtime path exists for the agent |
| 07 | no authority-equivalent uid transition exists |
| 12 | the broker code / control plane is not agent-replaceable |
| 17 | the privilege graph contains no unauthorized path to canonical mutation |
| 19 | no privilege path is left unresolved |

Note that 19 cannot be satisfied by measurement alone — it requires a human with
root. That is by design: the system cannot certify itself.

### Can I use this on my own agent deployment?

The model is reusable — it is pure, dependency-free and Apache-2.0. The
collectors are Linux-specific and tuned to one host layout, so treat them as a
worked example rather than a product. The seven-surface list is a floor, not a
ceiling; §16.1 names seven more that are known to be missing.

If you do run it, the useful output is not the verdict. It is the list of paths it
could not resolve.