Four different questions a cryptographic proof can answer
Consider a fictional public list of event tickets. A hash, a signature, a Merkle proof and a zero-knowledge proof each answer a different question about it. Follow the checks without turning a narrow mathematical result into a general certificate of trustworthiness.
Has this data changed?
A cryptographic hash maps the exact input bytes to a fixed-size digest for the chosen algorithm. The same bytes produce the same digest. A useful integrity check compares a freshly calculated digest with a value obtained through a trusted channel. A matching digest from the same untrusted page as the file adds little assurance about who supplied it.
Hashing is not encryption: there is no decryption key that turns a hash back into the original ticket list. It is also not automatic secrecy. If an input comes from a short, predictable set, someone can hash guesses and compare the results. Never treat a plain hash of a simple password or identifier as a way to hide it safely.
Who authorized this message?
A digital signature uses a private key to create a signature that can be checked with the corresponding public key and the signed message. The private key is kept secret; the verification key can be shared. For our ticket list, a valid signature helps establish that the holder of the relevant signing authority authorized the exact signed data.
That result depends on knowing whose public key you are checking. An attacker can sign an invented list with the attacker's own key. Signature verification also does not establish that a signed statement is honest, that a key was never stolen, or that a transaction is harmless. Authorization and truth are different questions.
Is this item in the committed list?
A Merkle tree combines hashes so that one root commits to a collection. To check a ticket's inclusion, a verifier can use the ticket data and a path of sibling hashes to recompute the root. This avoids receiving the entire list. The root still needs an appropriate source or authenticated commitment: an attacker can construct a different tree with a different root.
Can eligibility be checked without revealing the ticket?
A zero-knowledge proof can establish a specified statement while keeping a private witness hidden. A carefully designed ticket system might prove knowledge of an eligible ticket without publishing its identifier. The verifier checks the statement implemented by that proof system, not every fact anyone might associate with the event.
Privacy depends on the whole design, including public inputs and how proofs are used. Preventing the same ticket from entering twice requires additional rules; hiding the ticket alone does not solve reuse. Likewise, a membership proof cannot demonstrate that the person presenting it is kind, that an event will occur, or that a linked website is safe.
Choose the check that matches the question
Suppose a four-leaf teaching tree contains ticket records A, B, C and D. Checking B uses its own leaf hash, sibling A and the combined hash for C and D to recompute the root. Letters label hypothetical leaves; implementations specify encoding, ordering and hashing.
| Question | Relevant mechanism |
|---|---|
| Do these exact bytes match an expected digest? | Cryptographic hash comparison |
| Did the relevant key authorize this message? | Digital signature verification |
| Is this leaf part of the committed tree? | Merkle inclusion proof |
| Does the private witness satisfy the specified statement? | Zero-knowledge proof verification |
Check your understanding
Does a valid Merkle proof establish that a ticket issuer is legitimate?
No. It establishes inclusion relative to the root and tree rules being checked. You must separately establish the meaning and provenance of that root. The issuer's real-world legitimacy is outside the inclusion proof.
Check the primary sources
These references explain the rules behind the lesson. The examples above are fictional teaching scenarios written for this dictionary.