The entry is in the seal, unchanged
Exactly this entry, with this app, this memory, this count and this time, was part of the hour's seal when it was made. Change one character and the fingerprint no longer leads to the root.
Verify
Your vault checks a log entry against its seal with one button. This page is the long way round: the same check, with every step in the open, with code you can run without trusting ours, and checkers for life certificates, proofs of a fact, agreements, identity statements and knowledge packs.
In this browser
Every step of the walk is shown under the result, so you can compare the numbers with your own run of the script below.
Proof of a real life
A vault can show that it has a long, continuous sealed history without showing anything in it. Open a certificate from its link, or drop the file here.
What it proves: whoever could open that vault signed in each of those hours, and the site sealed it then. It does not prove who that is, that they are one person, or anything about what is in the vault. While seals are not anchored, the site holds the list of roots.
Signed by a vault
Open a proof from its link, or drop any of these files here. The page tells them apart by their first line and checks each in this browser.
None of these says who a person is. A proof of an age rests on what the owner wrote in their own vault; zero-knowledge proofs, where nobody sees the date and a checker still computes the age, are on the roadmap.
The rules
Two hash rules and one line format. The same rules are implemented in the browser, on the server and in the SigilSeal contract, so one proof checks in all three.
leaf = SHA-256( 0x00 || data )
node = SHA-256( 0x01 || min(a, b) || max(a, b) )
data = "sigil-read-v1" \n id \n appId \n kind \n memoryId
\n count \n at \n salt (joined with newlines)
An unpaired node at the end of a level moves up unchanged.
The root of an hour is its seal.A complete check in plain Node.js, with no Sigil code in it. Paste your entry into e, set the address, and run it with node verify.mjs.
import { createHash } from "node:crypto";
const sha = (...parts) => createHash("sha256").update(Buffer.concat(parts)).digest();
const hex = (h) => Buffer.from(h.slice(2), "hex");
// 1. The fingerprint, from the entry you copied out of your read log.
const e = { id: "", appId: "", kind: "read", memoryId: "", count: 1, at: "", salt: "", hour: 0 };
const data = ["sigil-read-v1", e.id, e.appId, e.kind, e.memoryId ?? "", String(e.count), e.at, e.salt].join("\n");
let node = sha(Buffer.from([0]), Buffer.from(data, "utf8"));
const leaf = "0x" + node.toString("hex");
// 2. The proof and the published seal, from the public API.
const site = "https://<your Sigil site>";
const { proof } = await (await fetch(`${site}/api/seals/${e.hour}/proof?leaf=${leaf}`)).json();
const { seal } = await (await fetch(`${site}/api/seals/${e.hour}`)).json();
// 3. Walk up: pairs are sorted before hashing, so no left or right flags are needed.
for (const sibling of proof.map(hex)) {
const [lo, hi] = Buffer.compare(node, sibling) <= 0 ? [node, sibling] : [sibling, node];
node = sha(Buffer.from([1]), lo, hi);
}
console.log("0x" + node.toString("hex") === seal.root ? "verified" : "NOT verified");Exactly this entry, with this app, this memory, this count and this time, was part of the hour's seal when it was made. Change one character and the fingerprint no longer leads to the root.
A seal cannot show that a server wrote every request down, and while seals are local, Sigil holds the list of roots. Publishing roots on chain closes the second gap and is on the roadmap. Both limits are in the threat model.