The protocol
BitGraph is a protocol that produces portable cryptographic proof when a file is committed through an authorized execution boundary. The proof does not assert a time. It asserts a place: this exact file, in this exact form, at one position in a sequence, reserved before the file's hash was known and never occupied by anything else.
The core idea
Most systems produce artifacts first and try to prove things about them later, attaching signatures, metadata, timestamps, or ledger entries after the fact.
BitGraph inverts this. Valid proof can only exist if the file was committed through the authorized commit path. The proof is not added to the file. It is caused by the act of committing through that path.
If proof exists, the authorized commit path was traversed.
How it works
Authorization, cryptographic binding, and commit happen as one indivisible operation:
- 1. Allocate - The enclave pre-allocates a causal slot (nonce + counter) before the artifact hash is known. The place exists before the file that will occupy it.
- 2. Bind - The artifact's SHA-256 digest is bound to the pre-allocated slot, combined with the monotonic counter, and signed with Ed25519 inside the TEE.
- 3. Commit - The slot is consumed and the proof is produced. Fail-closed: if any step fails, no proof exists. The proof includes the signed slot record as causal evidence.
What you get
A BitGraph proof is a JSON object (schema version bitgraph/1) containing:
- artifact - SHA-256 digest of the committed bytes
- commit - fresh nonce, monotonic counter, slot binding (slotCounter, slotHashB64), epoch identity, optional chain link
- signer - Ed25519 public key and signature over the canonical signed body
- environment - enforcement tier, platform measurement (PCR0), hardware attestation
- slotAllocation - the pre-allocated causal slot record, independently signed by the enclave
- agency - optional actor-bound proof via device biometrics (passkey/WebAuthn)
- attribution - optional signed creator metadata (name, title, message)
- timestamps - optional and advisory only. A proof's place comes from its slot and counter. External time bounds come from periodic Ethereum anchors of the counter chain, never from this field.
Key properties
- Portable — a self-contained JSON object. Any verifier can check it offline with only the public key and the original bytes.
- Atomic — fail-closed. Either a complete, valid proof is produced, or nothing is.
- Causal — every proof is bound to a pre-allocated slot created before the artifact hash was known.
- Ordered — one place in a sequence, fixed by a monotonic counter within its epoch. Counter, epoch, and chain link establish sequencing.
- Measured — binds to a specific execution environment via its platform measurement. Production is AWS Nitro, where that measurement is PCR0; the schema names no platform, so another TEE’s would fit it.
- Verifiable — Ed25519 signature, SHA-256 digest, canonical serialization. Standard cryptographic primitives.
Enforcement tiers
| Tier | Key Location | Boundary | Use Case |
|---|---|---|---|
measured-tee | TEE memory | Hardware enclave | Production, highest assurance |
hw-key | HSM / Secure Enclave | Software | Key custody |
stub | Process memory | Software | Development, testing |
bitgraph.ing issues measured-tee proofs only. If the enclave is unreachable, no proof is produced. The other tiers exist for local development and for integrations that keep keys in an HSM.
enforcement is signed, but it is self-reported. A verifier that needs enclave guarantees pins measurement to a known enclave image and validates the attestation, which a software tier cannot produce. See Verification for the algorithm.
Structural properties
The commit path satisfies these structural properties:
Every authenticated artifact corresponds to exactly one authorized commit. State that did not traverse the commit path cannot acquire a valid proof, regardless of how it was constructed elsewhere.
The set of authenticated artifacts is exactly the set produced by authorized commits. There is no second route into the authenticated set.
Authorization, binding, and commit are a single indivisible transition. There is no observable intermediate state in which authorization holds but binding has not occurred, or in which binding holds but commit has not.
Each authorization event produces a distinct proof. No two commits collide, and the same bytes committed twice occupy two different places.