# The power-user verification stack — one verified extension, everything else checked

> **Status: TARGET ARCHITECTURE.** This composes shipped pieces (signed `/cert.json`, reproducible render build,
> readable egress-lock, the `mkseal`/`mkUnseal` sealing wire format) with designed-but-unbuilt ones
> ([the pinned bundle](./the-pinned-bundle.md)) and net-new ones (a verifier extension, transparency-log publishing +
> gossip, and switching the render into an attested enclave — [the attested tier](./the-attested-tier.md)). It is the
> honest answer to *"how does a user know they run a good app?"* for a user willing to run one extra tool. See also
> [verify it yourself](./verify.md) (what's checkable today) and [the attested client](./the-attested-client.md) (the
> native path).

## Who this is for

Not everyone. This is the **power-user** tier: someone who will install **Firefox** (Android or desktop) and one verifier
extension. That single willingness is what makes the strongest *web* verification possible — because a mobile web page
alone [cannot verify itself](./the-pinned-bundle.md), and [an operator serving its own app proves nothing](./trust-model.md).
The mainstream reach (open-a-link, any browser) keeps the existing model — accountable identity + server-side enforcement;
this is the additive apex for people who want to *check*, not trust.

## The property that makes it "perfect"

**One deliberate trust decision, verified out-of-band once — then everything is checked automatically, on the real
bytes, from browser chrome, with cheating detectable.** Witbitz is removed from the trust base: it vouches for nothing
about itself; any deviation is caught by a party it doesn't control.

## The five components

1. **A verifier extension** — open-source, reproducible, ideally authored by *someone other than Witbitz*. It ships with
   its trust anchors **pinned inside it** (not fetched from the app): Witbitz's signing pubkey, the AWS Nitro attestation
   root, the transparency-log keys. It runs in **Firefox**, and uses `webRequest.filterResponseData` to hash the **exact
   bytes the browser loaded** — the same fetch the page uses, not a separate one, which is what makes it split-view-proof.
   It lives in the toolbar, **outside the page**, so the page can't forge its verdict. (Chromium MV3 can't read response
   bodies → Firefox is required for the byte-level check.)
2. **The pinned-bundle client** — the shell content-pins its module closure; a signed manifest of every module hash is in
   `/cert.json`. Collapses the client to one anchorable shell. ([the pinned bundle](./the-pinned-bundle.md))
3. **The signed `/cert.json`** — `shellSha256`, `closureSha256`, `modules[]`, `lambdaCodeSha256`, `sourceSha256`,
   `gitCommit`, `egress`, and an `enclave` attestation block.
4. **Transparency logs** — every deployed build's hashes published to **≥2 independent** append-only logs; the extension
   checks **inclusion** and **gossips signed tree heads**, so a split-view (a good build to you, a bad one to someone
   else) is **detectable by any one honest observer**. (What makes a logged build "good" in the first place — for a
   *closed-source* app — is [the certified app](./the-certified-app.md): plural attested checkers audit the manifest
   against its privacy certificate.)
5. **The enclave (Nitro)** — the render runs in an attested enclave; the extension verifies `PCR0 == the reproduced
   measurement` and that it chains to the Nitro root, so the server is honest *by hardware*, unobservable in use.

## One-time setup — the only out-of-band act

Install Firefox; install the extension; **verify the extension itself once** — reproduce its published build, or check
its store signature. That is the single anchor the whole system hangs from. Because the extension is *not* Witbitz's, this
is not Witbitz vouching for Witbitz.

## Per-load flow (automatic, after setup)

1. The extension hashes the **shell + every module the browser actually loaded** (`filterResponseData`).
2. Verifies `/cert.json`'s signature against the **pinned** pubkey.
3. Loaded hashes **==** the signed manifest. (A swapped module → the pinned-bundle shell refuses to run it anyway.)
4. Those hashes are **in the transparency logs** (inclusion proof) and **no split-view** (gossiped tree heads reconcile).
5. Verifies the **enclave attestation** — Nitro root, `PCR0 ==` the reproduced measurement.
6. Confirms `connect-src` **==** the signed `egress`.
7. **Toolbar badge: green → good; red → stop.**

## Where trust bottoms out

All *outside* Witbitz:

| Root | For |
|---|---|
| **Mozilla** (runs the extension faithfully) | the verifier itself executing honestly |
| **The extension author + its reproducible build** (you checked once) | the anchor, ideally independent of Witbitz |
| **AWS Nitro hardware root** | the server is honest by hardware, unobservable in use |
| **Independent transparency logs** | split-view is detectable; one honest observer suffices |
| **Math** (signatures, hashes) | the whole chain |

Not zero-trust — **minimal trust, and every deviation detectable and attributable.**

## Honest residuals — even here

- A genuine **bug** in the honest code is orthogonal; receiver hardening (XSS-safe render, sandboxed widgets, validated
  tool inputs) still matters.
- Attestation protects the **key and the code**, **not** the fact that **plaintext reaches a model provider** — the
  strongest-privacy tier still needs **BYO / enclave-hosted model**. This is the likeliest overclaim; state it plainly.
- **iPhone:** until the EU's alternative-engine rules (DMA) give iOS a Firefox-grade extension API, iOS **web** can't do
  the byte-level check. An iOS power user's strong path today is the **native App Attest** app
  ([the attested client](./the-attested-client.md)); iOS **web** gets here when the engines open.

## Build list

| Piece | State |
|---|---|
| `/cert.json` + signature · reproducible render build · readable egress-lock · `mkseal`/`mkUnseal` sealing | ✅ **live** |
| Pinned-bundle loader + signed client manifest | 🟡 **designed** ([the pinned bundle](./the-pinned-bundle.md)) |
| The **verifier extension** (Firefox, `filterResponseData`, pinned roots) | ○ **new** |
| **Transparency-log** publishing + inclusion/gossip in the extension | ○ **new** |
| Render **inside an attested enclave** (operator provably blind in use) | ✅ **live · opt-in per Space** ([the attested tier](./the-attested-tier.md)) |
| (Strongest, mobile) **native Android attested app** (reproducible APK + Keystore attestation) | ○ **roadmap** ([the attested client](./the-attested-client.md)) |

## The one-line version

For a power user on **Android + Firefox** (or any desktop Firefox/Chrome): **one verified extension → continuous,
automatic, split-view-proof verification of the exact code the browser runs and the attested server behind it, with
Witbitz removed from the trust base.** iPhone gets there on **native** today and on **web** when the engines open.