Prove It v3 — Status Update
Date: 2026-11-18
Status: Private invited-tester pilot continues. No change to access or claims.
What Prove It does
Prove It v3 runs untrusted Python in an isolated sandbox and produces signed, independently verifiable execution receipts. The goal is to prove what code ran, under which restrictions, against which tests, and whether the evidence was altered afterward. Today it's an invited-tester pilot for trusted participants—not a production, certified, or government-approved system.
What we did this cycle
We completed an internal, reproducible security verification pass against the live pilot—actual host configuration, actual source, actual signed receipt, not a design review. The full report is internal, but here's the honest summary.
What checked out:
The web-to-runner boundary rejects shell-style job-ID injection. Job IDs are strictly validated at every layer, and the sudo path exposes exactly one fixed command.
The origin service listens only on loopback. It is not reachable on the LAN interface.
gVisor is configured with network denied (--network=none), and runsc and the Sentry binary are hash-allowlisted at runtime.
Pilot invitation tokens are salted-hashed, constant-time compared, expire after 14 days, and revoke immediately at the origin.
Receipts are richer than we'd assumed. A genuine receipt contains 11 DSSE envelopes binding policy, suite, claim catalog, run identity, nonce, timestamps, runner/engine digests, sandbox image, and chained evidence records—not just a result.
The offline verifier does real cryptographic work: strict DSSE parsing, signature validation over payload bytes, policy signature checks against a trust root, chain-field evaluation, and processing of all envelopes rather than just the final one.
What needs fixing—in priority order:
Pre-execution payload binding. The web tier writes solution.py and owns that directory; the root runner reads and executes from it without sealing the bytes first. Path validation prevents traversal, but not content mutation between validation and execution. A compromised web process could alter permitted content. The fix is to read once, validate against a signed admission manifest, seal into a root-owned directory, and execute only the sealed copy.
Signing-key separation. Signing keys are root-owned 0600 files on the same host as the runner, which runs as root. The web account can't read them, and signing doesn't happen inside the sandbox—both good—but runner or host compromise yields both issuer and collector keys. Signing needs to move to non-exportable KMS/HSM keys in a trust domain the runner cannot reach.
Verifier trust anchoring. The offline verifier is cryptographically substantive but bootstraps trust from a trust_root.json that ships in the same bundle as the receipt. Without an independently pinned trust root, witness verification, or an external timestamp/transparency proof, "independent verification" is not yet fully independent.
Runner hardening. systemd-analyze security scores the root runner 8.2 EXPOSED. It retains the full root capability set, host networking, devices, namespace creation, kernel module/tunable access, no syscall filter, and NoNewPrivileges=no. This is being addressed empirically in staging—the right profile depends on what runsc actually requires, and whether the runner needs to be root at all.
Immutable audit logging. Health checks exist, but there is no external alert route, immutable remote sink, hash-chained event log, or log-gap detection. This is the evidence base for everything above, so it's being built in parallel rather than after.
Key rotation and source provenance. No signed key-history manifest yet, so old receipts would become unverifiable after rotation. The inspected source is not a Git checkout, so live artifact hashes are a point-in-time inventory rather than a build-tied one. Both need to be fixed before receipts can serve as durable evidence.
Structural limit: the pilot runs on Ubuntu under WSL on a developer workstation. That's fine for a private pilot and unsuitable for anything else. It cannot provide measured boot, TPM-backed key custody, or an independently controlled host boundary.
What this means
The pilot stays open for trusted testers. The controls above justify continuing private testing. They do not justify CUI, export-controlled data, classified information, defense deployment, or any FedRAMP/CMMC/FIPS/IL claim—and we aren't making those claims.
We've defined phase gates internally so "done" is concrete:
Invited beta: payload binding, signing separation, and verifier trust anchoring closed, with a written claims boundary.
Broader commercial pilot: plus a materially reduced runner exposure profile, immutable external audit/alerting, safe key rotation, and signed build provenance.
Defense evaluation: plus complete receipt-schema enforcement, re-platforming off WSL, and independent testing.
None of those gates are close today. That's the honest position.
What comes next
In order: the signed admission-manifest format and root-side input sealing (with an adversarial mutation regression test), a staging runner profile built empirically against real runsc requirements, non-exportable signing moved off the execution host, and immutable remote audit logging in parallel. The receipt schema gets published and machine-tested alongside.
Three things cannot be self-attested no matter how thorough the internal work is: independent gVisor escape and adversarial testing, independent cryptographic review of the receipt and key hierarchy, and third-party reproduction of the verifier from source with artifact comparison. Those come after internal closure, and closing internal findings makes the system ready for them—it doesn't replace them.
A note on what this update is
This is an engineering status report, not an audit, certification, or compliance artifact. It was produced internally against the live pilot and is reproducible from the evidence inventory in the full report. Anyone reading it should treat the positive controls as verified within the inspected implementation and the gaps as verified findings—not as a security guarantee, and not as authorization for anything beyond continued private testing with trusted participants.
Questions, and offers to participate in adversarial testing when we get there, are welcome.






Comments
0 comments