GLOSSARY.md

# Glossary

The vocabulary is the contribution, so it is worth twenty minutes. Terms are
ordered so each builds on the ones above it.

---

### Authority principal

The identity that is permitted to perform canonical state mutation. Not "root" —
the whole point is to separate *the thing allowed to change canonical state* from
*the Unix superuser*. Chosen against nine stated criteria in `authority_principal.py`
and §5 of the paper.

### Agent principal

The identity the autonomous agent actually runs as. On the evaluated host: uid
1000. Everything in this project is a question about what this principal can
reach.

### Root-equivalent path

A path by which the agent principal can obtain the authority of uid 0, whether or
not any security boundary is violated. **Membership of the `docker` group is
root-equivalent** even though every permission check passes — the rootful Docker
daemon will run a container as uid 0 with the host filesystem mounted, on request,
for anyone who can write to its socket.

This is the definition that makes the verdict blocked. A narrower definition —
"root-equivalence means a boundary was crossed" — would have returned a clean
result on the same host, which is exactly the failure mode being argued against.

### Authority-equivalent path

The same idea one level down: a path to the *authority principal* rather than to
uid 0. Reaching the authority principal is sufficient to mutate canonical state,
so it blocks for the same reason. Zero were measured on this host.

### Surface

A category of privilege-granting mechanism, enumerated by a distinct collection
method. Seven are covered here, and the count per surface is a property of the
host, not of the method:

| Surface | Paths found | Discovered by |
|---|---|---|
| `setuid` | 35 | `find -perm -4000` |
| `filecaps` | 11 | `getcap` — **invisible to the setuid scan** |
| `container_runtimes` | 4 | socket probes |
| `groups` | 2 | group membership |
| `polkit` | 2 | policy enumeration |
| `systemd` | 2 | unit and transient-unit probes |
| `sudo` | 1 | `sudo -l` |

Finding 1 in the paper is precisely that surface #2 was missing for three
revisions: `find -perm -4000` cannot discover file capabilities, so 11 privileged
binaries were absent from the authority model with nothing reporting an error.
Coverage is derived from the surfaces actually present in the inventory, never
declared.

### Terminal state / classification

Every enumerated path must carry exactly one terminal state. There is no default
and no implicit "fine":

| Classification | Meaning | Blocks? |
|---|---|---|
| `NON_ROOT_EQUIVALENT` | measured, cannot reach root | no |
| `NOT_PRESENT` | measured, does not exist here | no |
| `PRESENT_NON_ESCALATING` | exists, measured non-escalating | no |
| `ROOT_EQUIVALENT` | measured, reaches uid 0 | **yes** |
| `AUTHORITY_EQUIVALENT` | measured, reaches the authority principal | **yes** |
| `REQUIRES_OPERATOR_EVIDENCE` | undecidable without privileged reads | **yes** |
| `UNKNOWN` | not resolved | **yes** |

A path with no classification, or one the model does not recognise, is itself a
blocker — it is treated as evidence-integrity failure rather than ignored.

### Derived vs declared

An inventory publishes summary lists about itself ("here are my root paths"). It
also contains per-path classifications. **Derived** means computed from the
per-path classifications; **declared** means read from the summary.

The verifier derives, then unions with the declared set. Union rather than
replacement, so derivation can only ever *add* a blocker — which is what makes the
change safe by construction. If the two disagree, that disagreement is itself a
blocker, because one of the two is lying.

Finding 4 was that four consumers still read the declared summary. The control
case `NEGATIVE_summary_edited_to_hide_root` exists to keep that fixed: it edits a
summary to conceal a root path and asserts the gate still blocks.

### Measured absence vs unresolved possibility vs proven impossibility

The three-valued core:

- **Measured absence** — we looked, with a method capable of seeing it, and it is
  not there. Compatible with a positive verdict.
- **Unresolved possibility** — we could not settle it. **Blocks unconditionally.**
- **Proven impossibility** — it cannot exist. Compatible with a positive verdict.

The failure this prevents is collapsing the middle value into the first:

> **Absence of observation is not equivalent to measured absence.**

### UNDETERMINED

A fourth value, about *existence* rather than *reachability*: the question of
whether a path exists at all could not be settled. Distinct from `UNKNOWN`, which
says the path exists but its terminal state is unresolved. Both block.

### Admissibility / measurement context

An inventory is **admissible** only if the process that produced it can prove it
measured the host as the agent identity. `privilege_context.py` computes a context
fingerprint — uid maps, namespace membership, filesystem visibility — and the
predicate fails closed.

Every inventory is bound to the context it was measured in. An inventory without
its context is not evidence, because the same collector run inside a sandbox on an
unchanged host reports zero root-equivalent paths. That clean result is true of
the sandbox and false of the host. This is Finding 3.

### Coverage

The set of surfaces an inventory actually measured, **derived** from its contents
and compared against the seven required. Never declared. A missing surface is not
a smaller answer, it is an unresolved one, and it blocks.

### Operator evidence

The 18 paths that cannot be resolved without privileged reads the agent does not
have — `sudoers` contents, polkit rules, unit files. `OPERATOR_EVIDENCE_CHECKLIST.json`
is the list of reads a human with root must perform. Until they are performed the
verdict stays blocked, because unresolved is not a pass.

### Precedence

When several block conditions hold at once, the reported reason is the most
specific one, in this order:

```text
BLOCKED_ROOT_EQUIVALENCE
BLOCKED_AUTHORITY_EQUIVALENCE
BLOCKED_PRIVILEGE_UNCERTAIN
VERIFIED_EXCLUSIVE_AUTHORITY
```

Within `BLOCKED_PRIVILEGE_UNCERTAIN` there is a second ladder, and its order
encodes the principle that a fact about the *evidence* outranks a fact about the
*host* — if the evidence is untrustworthy, nothing derived from it means anything:

```text
_INVENTORY_NOT_HOST_MEASURED     the inventory describes a sandbox, not the host
_INCOMPLETE_SURFACE_COVERAGE     a required surface was never measured
_EVIDENCE_INTEGRITY              declared and derived disagree, or a path has no terminal state
_UNKNOWN_PATHS                   the host has a path we could not resolve
_OPERATOR_EVIDENCE_REQUIRED      a human with root must read something
_GRAPH_CLOSURE_NOT_COMPUTED      closure was never established
```

The first three are statements about the measurement. The last three are
statements about the machine.

### Specific reason

Not merely which class blocked, but which mechanism did. `BLOCKED_ROOT_EQUIVALENCE`
is the class; `BLOCKED_ROOT_EQUIVALENCE_DOCKER` is the verdict, and it names what a
human would have to change.

### Append-only manifest

Integrity policy: a manifest is never regenerated. When a sealed file changes, a
new manifest supersedes that entry and records the superseded digest, so the link
from digest to run survives. The cost is that no single manifest verifies clean.
See [VERIFYING.md](VERIFYING.md).

### Positive control / negative control

A **positive control** must produce a pass; if it stops passing, the gate has
become vacuous and blocks everything, which is not safety. A **negative control**
must block, *and for the stated reason* — blocking for the wrong reason counts as
a failure. 15 cases: 1 positive, 14 negative.

### Anti-vacuity

The guard against a theorem that is true only because nothing ever satisfies its
premise. The Theorem 1 enumeration reports `2646 cases enumerated, 5 reached
VERIFIED`: the second number is the proof that the safety property is non-trivial,
because some inputs do reach a positive verdict.