A hash is a short, fixed-length string of characters produced by running some content through a mathematical function. Agreebase uses SHA-256, which always produces the same 64-character result for the same input, and produces a completely different result if even one character of the input changes.
Why this is useful
If you have a document and someone hands you a hash claiming to represent it, you can run the same document through SHA-256 yourself and compare the result. If the two hashes match, you know, to an overwhelming degree of certainty, that you're holding the exact same content, character for character, that produced that hash. That's the whole basis for how Agreebase lets you verify a record independently: it publishes a hash, and anyone holding the original content can check it without needing to trust Agreebase's word for it.
Why sharing a hash is safe
A hash is not an encrypted or reversible representation of its input; there is no operation that takes a SHA-256 hash and recovers the text or file that produced it. Going from content to hash is a one-way street. This means Agreebase can publish a hash of your private agreement text on a public, permanent blockchain without exposing the text itself: the hash proves that specific content existed and was sealed at a specific time, while the content stays with the parties who already have it.
This is genuinely two things at once, which can feel contradictory at first: the hash is public and permanently visible to anyone, and the content it represents stays private. Both are true because knowing a hash gives you nothing to work with in reverse; it's a fingerprint, not a copy.
Collisions and guessing
Two different technical concerns sometimes get raised about hashing, and SHA-256 is designed so that neither is a practical risk:
- Reversal: computing the original input from the hash alone. There is no known way to do this for SHA-256 short of trying inputs one at a time, and the space of possible inputs is astronomically large.
- Collision: finding two different inputs that produce the same hash. No collision has ever been found for SHA-256, and finding one is currently believed to be computationally infeasible.
The one real caveat is specific to short or predictable inputs, not to hashing itself: if the content behind a hash is something a guesser could plausibly type out and hash themselves (a short phrase, a common number, a single word), they could eventually stumble on a match by trying candidates; not by reversing the hash, but by guessing the input and checking it. This is why Privacy and publication advises keeping genuinely sensitive or low-entropy content off chain even in hash-only form, and why a hash is a proof of identity, not a vault.
In short
It's safe to share a hash with anyone. Doing so doesn't let them reconstruct what it represents, doesn't weaken your original content in any way, and is exactly how someone else can confirm they're looking at the same thing you are. See Verification hashes for the exact normalization and hashing steps Agreebase uses.