Each issued diploma is hashed (a short fixed-length fingerprint of the student, degree and issue date). New certificates wait in a mempool until a batch fills, then get mined into a block: the block's own hash is computed from its certificate hashes plus the previous block's hash, chaining every block to the one before it. Once a block accumulates a few confirmations on top of it, it is final — rewriting it would mean re-mining every block after it, which grows exponentially expensive.
certHash = H(studentID, degree, issueDate)
blockHash = H(prevBlockHash, certHash₁…certHashₙ, nonce)
verify(copy): H(copy.fields) === registry.certHash ? valid : tampered
- Issue certificate — creates a new diploma record, hashes it, and drops it in the mempool for the next block.
- Tamper a copy — simulates someone editing a field (e.g. the grade) on an off-chain copy of an already-anchored diploma.
- Verify a copy — re-hashes the copy currently selected and compares it against the hash anchored on-chain; a tampered copy fails instantly because even a one-character change produces a completely different hash.
- Batch size / Mining speed — how many certificates a block holds and how fast blocks are mined, trading off confirmation latency against finality depth.
Real-world relevance: universities and credentialing bodies (MIT's Blockcerts, various national diploma registries) anchor only the certificate's hash on a public or permissioned ledger — the diploma itself stays with the graduate, but anyone can verify it was genuinely issued and has not been altered since, without contacting the university.