What a Hash Does Not Reveal

The whole privacy claim of hash-based timestamping rests on one property: a hash tells you nothing about the thing it came from. That is true, it is worth understanding rather than taking on faith, and it has exactly one caveat.

What a hash is

SHA-256 takes any input, of any length, and produces a fixed 256-bit output — 64 hexadecimal characters. The same input always produces the same output. A one-bit change produces a completely different one.

It is a one-way function: easy to compute forwards, infeasible to reverse. It is not encryption. There is no key, and nothing to decrypt.

"hello"  → 2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824
"hello!" → ce06092fb948d9ffac7d1a376e404b26b7575bef38f9c1b4e7b3fc0d8e4e93e5

Two inputs one character apart, two entirely unrelated outputs. That is by design, and it is why a hash leaks nothing about content.

What publishing a hash does not reveal

Everything, essentially:

• The contents. No text, no images, no data.
• The file type. A PDF, a photograph and a spreadsheet all produce a 64-character string.
• The size. A one-byte file and a ten-gigabyte file hash to the same length.
• The filename, author, dates or any metadata, unless they are inside the file.
• Whether it resembles anything else. Similar files produce completely unrelated hashes. There is no partial matching.

That last property is what makes it safe to publish. A hash cannot be compared against another hash to see whether the files are similar — only whether they are identical.

The one caveat

There is a real exception, and it deserves stating plainly rather than being buried.

If a document has very few possible values, someone can guess and check. Hash every candidate and compare.

Say you timestamp a document whose entire content is a number between 1 and 1,000. An attacker hashes all thousand and finds yours instantly. The same applies to a short phrase from a predictable set, a date, a single name, or a template with one variable field.

This is not a weakness in SHA-256 — it is doing exactly what it should. The problem is that the input space was small enough to search.

When it matters: timestamping very short, highly predictable content.

When it does not: any real document. A contract, a manuscript, a CAD file, a photograph, a spreadsheet — the space of possible files is astronomically large, and guessing is not a strategy.

The fix, if you need one: include something unpredictable. Real documents already do, because they contain unique text, timestamps or data. If you genuinely need to commit to a tiny value, add a random string and keep it with the document — the hash then covers something unguessable.

Why this matters for timestamping

Because it is the property everything else rests on.

Your file is hashed in your browser. The 64-character result is transmitted, and it is what appears on a public ledger permanently. If that string revealed anything about the document, publishing it would be a disclosure — and the whole product would be unusable for the confidential material it is meant for.

It does not. Which is why a pre-patent design, a manuscript, a deal document under NDA or a trade secret can be timestamped with nothing leaving your machine. See how to prove a trade secret without disclosing it.

You can verify the mechanism rather than trusting it: the free SHA-256 hash generator runs entirely in your browser, and works with your connection turned off.

The other side of the same property

Because a hash reveals nothing, it also proves nothing on its own.

A hash without the file is a meaningless string. To use a timestamp you must produce the original file and demonstrate it hashes to the recorded value. Lose the file and the record proves that something existed, and nothing more.

That is the trade-off at the centre of the design: complete privacy, at the cost of needing to keep the file. It is a good trade, and it is not a free one.