Your file stays with you.
Only the file’s 32-byte SHA-256 reaches the enclave, and only the proof leaves it.
Loading…
Technology
A BitGraph is an attested record made inside an AWS Nitro enclave running a published, reproducible build.
In one atomic operation, the enclave records a fresh hardware-generated nonce at count N and binds your data’s SHA-256 digest at count N+1. The two records are signed into one proof, attested by the hardware and linked to the previous proof.
The result is a self-contained JSON proof that anyone can verify offline. Your content stays with you; only its 32-byte digest reaches BitGraph.
What it establishes
That is the whole of the mechanism: order, from attested hardware. It needs no clock and no blockchain. Everything else a record can carry, a time, an identity, a public witness, is a trust layer bound on top of that position. The hardware’s own signed time comes with every attestation, and it can be checked; it is not what the proof rests on.
The mechanism
Why the nonce: it is what makes the position its own. Because it is drawn after the digest arrives, a position cannot be reserved in advance and filled later, and every proof carries a value no one could have known before it existed. Work made from one BitGraph’s published nonce could not have existed before that BitGraph, which is how two BitGraphs bracket work between them.
Atomic by construction
Every step that can fail (the random draw, the signature, the attestation) comes before the counter moves. If any fails, nothing is released, the counter stays where it was, and the drawn nonce is discarded without ever leaving the enclave. Requests are serialized inside the enclave, so two binds cannot interleave.
Tested on the unmodified enclave code with injected faults in the RNG, the signer and the attestation: server/commit-service/src/enclave/__tests__/bind-failure.test.ts.
The sequence
Every proof after an epoch’s first carries prevB64, the SHA-256 of the whole previous proof. Within an epoch the counts climb by two per BitGraph, nonce then content. Given a run of proofs, the verifier checks that each is atomic, that counts are consecutive and that each links to the one before; a missing proof shows as a gap (verifyStretch). Anything bound between BitGraph A and BitGraph B was bound after A and before B (verifyBetween).
The enclave’s key and counter live only in its memory, so each start is a new epoch: a new key, a counter from zero, and an epochId signed into every proof. Epochs are independent sequences. On bitgraph.ing an epoch runs for one UTC day and ends with a closing BitGraph inside its own line.
The measured enclave
Each proof carries an AWS Nitro attestation document, signed by AWS’s hardware (ES384, certificate chain to the AWS Nitro root). It states the enclave image’s measurement, PCR0, and carries as its user data the SHA-256 of the exact signed body of that proof. The signing key is generated inside the enclave at start and never exported; it is tied to the hardware through that per-proof attestation.
The current image, v13, measures:
adaad0bef62292d35197ae8db19e40685229f1a1e6070a7c77a148c4ada88ee66a1ca50819eebc2017c6716a49f2692f
It is reproducible: two independent builds from the enclave-v13 branch produced this PCR0. (The image file itself differs build to build because its header holds a build time; the measurement does not.) By default the verifier accepts only published images.
Trust layers
A BitGraph establishes a position in an enclave’s sequence. A trust layer is anything that says more about that position: when it happened, who stood behind it, that the public saw it. The rule for every layer is the same. It must be cryptographically bound to the position, in one direction or both: the layer’s own record bound inside the BitGraph (so the BitGraph came after it), or the BitGraph’s hash carried inside the layer (so the BitGraph existed by it). A layer placed beside a BitGraph, with neither bond, says nothing about it.
The enclave adds no clock of its own. The time in a proof is the attestation’s timestamp, set and signed by the AWS Nitro Secure Module: the first layer, from the hardware itself. A timestamp authority, a certificate, a transparency log or a Content Credential can be bound the same way, by whoever already issues it.
Inside an epoch the order needs nothing outside the enclave. Each BitGraph comes after the one before it, by construction, and the time in each proof is the hardware’s. An epoch is one run, from its first BitGraph to its last:
BitGraph writes nothing to any blockchain and reads nothing from one. Anyone who wants an outside anchor can add their own afterward: an RFC 3161 timestamp authority, a transparency log, or a blockchain. That is optional and is not part of BitGraph.
Only the file’s 32-byte SHA-256 reaches the enclave, and only the proof leaves it.
The time on a proof is the attestation’s timestamp, signed by AWS for that exact proof.
Check the hardware attestation, signatures and counted sequence offline, with no service and no network.
Collections
Many items are recorded at once as an RFC 6962 Merkle tree over their SHA-256s (leaf = SHA-256(0x00 ‖ digest), node = SHA-256(0x01 ‖ left ‖ right)). One BitGraph binds a short text naming the root and the count. Each item then proves its own inclusion with a path of sibling hashes, without the others being disclosed. The format allows up to 1,000,000 items in a tree.
Measured 2026-10-28 on the current flow, in Node on an 8-core Apple M3 laptop: one million files hashed in 1.9 s, the tree built in 2.4 s, and the root bound 6.1 s after the drop. Open the result as BitGraph #34, or download the run’s files: timings, corpus seed, root text and proof file. Reproduce it with website/scripts/bench-million.mjs.
Without disclosure
Each proof holds two signed records: the slot at count N, with the nonce, epoch and key and no field from the content; and the binding at count N+1, which names the digest. The slot record is signed on its own. So a holder can withhold the binding and the content entirely and still show the slot: an auditor checks its signature under the same key as an attested proof from that epoch, and learns that the measured enclave established that position, without learning what was bound there.
Built into the proof format today. The check uses the verifier’s existing signature and canonical-encoding steps; it is not yet a one-line command.
The proof
{
"version": "bitgraph/1",
"artifact": { "hashAlg": "sha256", "digestB64": "…" },
"commit": {
"nonceB64": "…", "counter": "16", "slotCounter": "15", "slotHashB64": "…",
"epochId": "…", "atomic": true, "prevB64": "…", "chainId": "bitgraph:main"
},
"signer": { "publicKeyB64": "…", "signatureB64": "…" },
"environment": { "enforcement": "measured-tee", "measurement": "<PCR0>",
"attestation": { "format": "aws-nitro", "reportB64": "…" } },
"slotAllocation": { "version": "bitgraph/slot/1", "nonceB64": "…", "counter": "15", … }
}The signature covers a canonical serialization of the body. A collection member also carries its inclusion path, as unsigned metadata that is checked, not trusted. See a real proof, or verify it.
Verification
The verifier is MIT-licensed. It needs the data, the proof, and nothing of BitGraph’s running:
npx @mikeargento/bitgraph-sdk verify <file> --proof <file>.bitgraph.json --pcr0 adaad0bef62292d35197ae8db19e40685229f1a1e6070a7c77a148c4ada88ee66a1ca50819eebc2017c6716a49f2692f
A key anyone can generate can sign a body that passes a signature check alone. It fails the attested check, because no AWS document covers it. The verifier’s own test does exactly this: packages/verify/src/__tests__/attested.test.ts.
Threat model
| Party | Cannot | Can |
|---|---|---|
| The host operator (BitGraph included) | Forge a proof that passes the attested check; see or choose a nonce; reuse a count; insert or reorder proofs inside a sequence without breaking the counts and hash links; change a proof’s attested time by releasing it late. | Choose the order in which it submits digests; delay or refuse submissions; withhold released proofs (gaps then show to anyone holding the neighbors); restart the enclave to begin a new epoch. |
| A client | Get a position without binding a digest; get its digest bound at a count of its choosing. | Bind any 32-byte digest, including one of content it does not own. Binding says nothing about authorship. |
| Someone holding a proof | Edit any signed field, swap the digest, the counter, the previous-proof link or the measurement, without the check failing. | Withhold it, or show it out of context. A proof shows its own position, not what else was bound. |
| A stolen enclave key | Pass the attested check. Keys are per epoch and live only in enclave memory. | Sign bodies that pass a signature-only check. Always verify with attestation. |
What you trust
enclave-v13 branch and its measurement reproduces, so what it does can be read and rebuilt rather than taken on trust.Not trusted: BitGraph’s website, its servers, its storage, or its word. A proof that checks offline against the published measurement checks whether or not BitGraph is still running.
Comparisons
These systems provide different kinds of evidence and can be used together. Each attaches something to content that already exists: a signature, a token, a log entry, a block. What BitGraph adds is the place itself. Each count comes with a nonce nobody could predict, drawn at the moment the place is taken, so no place in line can be prepared for, reserved, or reused.
| System | What it establishes | What you trust | How BitGraph fits |
|---|---|---|---|
| Digital signature | These bytes were signed with a particular private key. | The key’s security and any claimed link between that key and an identity. | BitGraph adds a counted position enforced by measured enclave code, with hardware attestation bound to each proof. |
| Timestamp authority (RFC 3161) | A TSA issued a signed token associating a digest with a stated time. | The TSA’s signing key, time source and operating practices. | BitGraph provides counted, chained records and carries Nitro’s signed attestation time. A TSA token can be bound as additional time evidence. |
| Transparency log (CT, Sigstore’s Rekor, SCITT) | An entry is included in a signed log state. Consistency proofs allow checks of append-only growth. | The log’s signing key, consistency checks, and the monitors or witnesses used to detect conflicting views. | BitGraph enforces each binding inside an attested enclave. Its proofs can also be published in a transparency log. |
| Blockchain anchoring | A digest, directly or through a batch commitment, is linked to a commitment included in a particular block. | The chain’s consensus, finality and rules for interpreting block time. | Finished proofs can be anchored this way too, afterward and optionally. What BitGraph adds is the position: a counted place in line, bound with a fresh hardware nonce, with no chain needed. |
| Content Credentials (C2PA) | A signer signed assertions cryptographically bound to an asset. | The signer, certificate trust chain and any timestamp authority used. | BitGraph can bind the asset and its manifest to a counted position, adding independently verifiable recording evidence. |
| Remote attestation | A platform signed evidence identifying measured software and associated attested data. | The platform’s security and the hardware vendor’s attestation root. | BitGraph uses attestation for a specific recording protocol: atomic binding, fresh nonces, consecutive counts and linked proofs. |
All comparisons assume sound cryptography and correct verification. BitGraph’s own trust assumptions include AWS Nitro, the accepted enclave build and the cryptography used in its proofs.
Next
The evaluation guide walks through making a BitGraph, verifying it offline, and watching each kind of tampering fail.