Public verification infrastructure
Certificate specification
GENYOUINE certificate specification (v1)
Status: stable. This document describes the exact bytes GENYOUINE signs and how anyone can check a certificate without our code, our website, or our cooperation. It is deliberately complete: a competent stranger should be able to write an independent verifier from this page alone.
Publishing how a lock is checked never helps anyone forge a key. What this removes is the sentence “you have to trust GENYOUINE’s website.”
What recomputation proves, and what it does not. Checking a certificate the way this document describes proves that the payload has not changed since it was signed, and that it was signed by the holder of the key named in it. It does not prove the signer was honest: if GENYOUINE signed a false certificate and handed you the video and the certificate together, your recomputation comes back VALID. Recomputation catches a lying checker, never a lying signer. Who holds the signing key, and what stops its abuse, is a separate matter (key custody).
1. The signed object
A certificate is a JSON object with exactly four top-level members:
{
"version": 1,
"alg": "Ed25519",
"payload": { ...six fields... },
"signature": "base64…"
}version— must be the integer1. Any other value: reject.alg— must be the string"Ed25519". Any other value: reject.payload— the six signed fields (section 2). These are the only bytes that are signed.version,alg, andsignatureare envelope, not message.signature— base64 (standard alphabet, with=padding) of the 64-byte Ed25519 signature over the canonical payload bytes (sections 3–4).
The certificate does not carry the public key. A verifier resolves the key itself, by payload.keyId, against a keystore it trusts independently (section 5). A certificate that carried its own key would be self-authenticating, which is worthless.
2. The payload — six fields, frozen
The payload is a JSON object with exactly these six members, no more and no fewer. Every value is a non-empty string.
- videoHash
- SHA-256 of the final recorded video bytesFormat: 64 lowercase hex characters
- sourceHash
- SHA-256 of the artifact snapshot the recording reacted toFormat: 64 lowercase hex characters
- timestamp
- the instant the server signed itFormat: ISO-8601 UTC, e.g. 2026-07-03T18:12:04.000Z
- sessionId
- GENYOUINE’s internal recording-session idFormat: non-empty string
- inviteId
- the invite the recording came throughFormat: non-empty string
- keyId
- names the key that signed this payloadFormat: non-empty string
Validation gate (reject before verifying — fail closed). A payload that fails any of these is not “unknown”, it is INVALID:
- It is a plain JSON object (not null, not an array).
- Its set of keys is exactly
videoHash, sourceHash, timestamp, sessionId, inviteId, keyId— a missing field, an extra field, or a duplicate all fail. - Every value is a string of length ≥ 1.
videoHashandsourceHasheach match^[0-9a-f]{64}$(lowercase hex).timestampmatches^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{1,3})?Z$and parses to a real instant. The trailingZ(UTC) is required; the milliseconds (.+ 1–3 digits) are optional.
The exact same gate runs before signing, so a payload that cannot verify can never be produced.
3. Canonicalization — the exact bytes
A signature is over bytes, so producer and verifier must serialize the payload to the identical byte string. GENYOUINE uses one deterministic serializer on both sides. The rule, canonicalize(value):
- If
valueisnull, a number, a boolean, or a string →JSON.stringify(value). - If
valueis an array →"[" + canonicalize(each element), joined by "," + "]". - If
valueis an object → sort its own keys by code-unit order (JavaScript’s defaultArray.prototype.sorton strings, i.e. UTF-16 code-unit comparison), then"{" + for each key: JSON.stringify(key) + ":" + canonicalize(value[key]), joined by "," + "}".
For a v1 payload this reduces to: a JSON object with the six keys in ascending order, no insignificant whitespace, standard JSON string escaping. Because all six keys are ASCII, the ordering is simply alphabetical:
inviteId, keyId, sessionId, sourceHash, timestamp, videoHash
Notes that matter for byte-identical output:
- No whitespace anywhere — no spaces after
:or,, no newlines. - String escaping is standard JSON (
JSON.stringifysemantics):",\, and the C0 control characters are escaped; everything else, including all non-ASCII characters, is emitted as literal UTF-8 (no\uXXXXescapes). - The signed message bytes are the UTF-8 encoding of this canonical string.
Two cross-boundary fixtures every implementation must reproduce byte-for-byte (these are asserted in GENYOUINE’s own test suite):
plain ascii
payload = {
"videoHash": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
"sourceHash": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
"timestamp": "2026-07-03T12:00:00.000Z",
"sessionId": "sess_1",
"inviteId": "inv_1",
"keyId": "key-test"
}canonical =
{"inviteId":"inv_1","keyId":"key-test","sessionId":"sess_1","sourceHash":"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb","timestamp":"2026-07-03T12:00:00.000Z","videoHash":"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}unicode values stay literal utf-8 (no \u escapes)
payload = {
"videoHash": "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
"sourceHash": "fedcba9876543210fedcba9876543210fedcba9876543210fedcba9876543210",
"timestamp": "2026-12-31T23:59:59Z",
"sessionId": "café-Ω-👍",
"inviteId": "inv_ünïcode",
"keyId": "key-Ω"
}canonical =
{"inviteId":"inv_ünïcode","keyId":"key-Ω","sessionId":"café-Ω-👍","sourceHash":"fedcba9876543210fedcba9876543210fedcba9876543210fedcba9876543210","timestamp":"2026-12-31T23:59:59Z","videoHash":"0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"}4. Signature — computing and checking
- Algorithm: Ed25519 (RFC 8032), pure EdDSA over the canonical UTF-8 bytes — no pre-hash, no context string. In WebCrypto:
{ name: "Ed25519" }. In Node:crypto.sign(null, message, privateKey). - Signing (server, for reference):
message = utf8(canonicalize(payload));signature = Ed25519_sign(privateKey, message); storebase64(signature). - Checking (anyone):
- Parse and run the validation gate (section 2). Fail → INVALID.
message = utf8(canonicalize(payload)).- Resolve
payload.keyIdin your trusted keystore (section 5). Not present → INVALID (never “unknown” — an unrecognized signer is a failed check). - The resolved key must be
kty:"OKP",crv:"Ed25519", with a base64urlx. Anything else → INVALID. Never let the certificate or the JWK choose the algorithm — hardcode Ed25519. signature = base64_decode(cert.signature)(64 bytes).- Return
Ed25519_verify(key, signature, message).
- Fail closed, always. Any error — a parse failure, a missing crypto implementation, a malformed signature, an unknown keyId — is INVALID, never a pass. An error is not a verification.
4a. Binding the actual video
The signature proves the certificate is intact and authentically signed. To prove a specific video file is the one this certificate is about, also compute SHA-256(video bytes) as lowercase hex and compare it to payload.videoHash. Match → the file belongs to the certificate. Mismatch → the file is not the certified recording, whatever the signature says. The offline verifier does both: it will only print VALID when the signature checks and the supplied video’s hash matches.
4b. What this document does not cover
Revocation. GENYOUINE can declare a certificate void (a key leak, a signing bug, a court order). Revocation is not part of the signed payload — a valid signature says nothing about whether the certificate was later revoked. A revoked certificate can still be validly signed. Revocation status lives with GENYOUINE and is shown on the online certificate page (/p/<slug>); an offline check cannot see it. Always confirm revocation status online.
The claims of the recording. The signature shows the file matches what was signed, when it was signed, and the source it is bound to. “One continuous take” is a statement on the signed record. It does not prove the statements in the video are true. Each certificate page says what the check does not show.
5. Keys
Verification is keystore-driven: you decide which keyIds you trust and pin their public keys, delivered independently of any certificate. GENYOUINE publishes every key it has ever used — current and retired, with dates — at /keys. The offline verifier pins these keys directly in the page.
A public key is published as a JWK:
{ "kty": "OKP", "crv": "Ed25519", "x": "<base64url 32-byte public key>" }Retiring a key does not un-verify old certificates: a retired key stays in the keystore so certificates it signed keep verifying forever. A keyId you do not recognize must fail as INVALID.
6. Worked example — the demo certificate
The public sample certificate (served at /p/demo) is a real, signed object. Its JSON:
{
"version": 1,
"alg": "Ed25519",
"payload": {
"videoHash": "f2bff5cfb54447a773a987231f15e185ebb4d905b64235c7d10a3647fec50b75",
"sourceHash": "e66aa774f70a8bcceedea31344c2f1639cb0a9b253c4111f80041b1b07788feb",
"sessionId": "sess_demo_0001",
"inviteId": "demo",
"timestamp": "2026-07-03T18:12:04.000Z",
"keyId": "key-demo-2026"
},
"signature": "NM/Q5MMWJ7cSQnFSV8GtA/Tyjbc8zyGohVwB9/Q4xxjFdx/IDtLTCc331EbBdQE9nCuG3bbqz5PbQFwvM6IIDA=="
}Step 1 — canonicalize the payload. Sorting the six keys ascending and emitting no whitespace gives exactly this 270-byte ASCII string:
{"inviteId":"demo","keyId":"key-demo-2026","sessionId":"sess_demo_0001","sourceHash":"e66aa774f70a8bcceedea31344c2f1639cb0a9b253c4111f80041b1b07788feb","timestamp":"2026-07-03T18:12:04.000Z","videoHash":"f2bff5cfb54447a773a987231f15e185ebb4d905b64235c7d10a3647fec50b75"}Step 2 — resolve the key. keyId is key-demo-2026. Its published public key (also on /keys):
{ "kty": "OKP", "crv": "Ed25519", "x": "mJVakgs4XIERfULotigPnXzTtHuYwYsh06lBEq6n1QQ" }Step 3 — verify. Base64-decode the signature to 64 bytes, and run Ed25519_verify(key, signature, utf8(canonical_string)). The result is true.
Step 4 (optional) — bind the video. The demo has no downloadable video (it is a sample), so videoHash cannot be matched to a file here. For a real certificate, SHA-256(video) == payload.videoHash completes the check.
You can reproduce Step 3 in ten lines with any Ed25519 library, or open the offline verifier, paste this JSON, and press Verify — with your network off.