Manifest Sandbox
Paste a JSON manifest and watch a certificate get canonicalized, hashed, and Ed25519-signed in real time.
This is an educational demo of how CertifiedData verification works — not a production certification tool. Nothing is written to the registry or the transparency log.
Optional — paste a dataset sample (up to 100KB) to bind a real artifact_hash
If omitted, artifact_hash is the SHA-256 of an empty buffer. The sandbox is fine with this — it's teaching the mechanics, not producing a real artifact binding.
Runs entirely server-side in Next.js. No database, no registry write, no transparency log entry.
Concepts
What the sandbox is teaching you
What is being hashed
A certificate does not hash the manifest you paste directly. It hashes the canonical form — a byte-for-byte deterministic serialization of the manifest with keys sorted and whitespace stripped. Two JSON objects that look different on screen but encode the same data produce the same canonical bytes, and therefore the same SHA-256.
Why canonicalization matters
Without canonicalization, re-serializing a manifest with a different JSON library (different key order, different whitespace, different number precision) would produce a different hash — which would invalidate the signature. Canonicalization is the contract between the signer and the verifier: we agree on one exact representation of the data before either of us computes a hash.
How signatures prove integrity
The Ed25519 signature is computed over the canonical bytes of the certificate payload, not over the manifest itself. A verifier recomputes the canonical form, runs SHA-256, and checks the signature against the published public key. Any modification to the payload — even a single byte — produces a different hash and the signature verification fails.
Difference between v1 and v2
v1 is the teaching version — one dataset hash, basic metadata, a single signature. v2 adds separate hashes for the dataset artifact, the canonical manifest, and the schema shape. This means a verifier can tell you which part of the certified artifact has drifted — the raw data, the manifest metadata, or the schema itself. Production CertifiedData certificates use the v2 shape.
What each certificate mode proves
- ✓The exact manifest content existed at the recorded timestamp
- ✓The manifest was submitted to the sandbox (not CertifiedData's production issuer)
- ✓The dataset sample's SHA-256 is recorded in the certificate
- ✓The Ed25519 signature covers the whole payload — modification invalidates it
- +Separate artifact_hash, manifest_hash, and schema_hash — isolates which surface changed
- +Canonical manifest serialization (sorted keys, no whitespace) so verification is reproducible
- +algorithm_spec with name + version — pins the generation method in the certificate
- +hashing_methodology_version — the canonical hashing recipe itself is versioned and explicit
Ready for real certification?
Create an account to issue certificates that are recorded in the public registry, appended to the transparency log, and generate verifiable proof URLs that auditors can cite.
Sandbox certificates are not issued by CertifiedData. They are signed with a separate sandbox-only Ed25519 key and are not recorded in the public registry or transparency log.