How to use this hash generator
Type into the text box and every digest updates live — or flip to the File tab and drop in a file of any size; it's read straight into memory and hashed locally. The five outputs appear side by side: MD5, SHA-1, SHA-256, SHA-512, and SHA-3 (the Keccak-based standard published in 2015).
Copy any digest individually, or grab all five with one click. The uppercase toggle is purely cosmetic — hex is case-insensitive — but some tools expect one style, and arguing with a build script at 1am is nobody's idea of fun. The stats line shows exactly how many characters and UTF-8 bytes are being hashed, which matters the moment your input contains emoji or accented letters.
What hashing actually is
A hash function takes any input — one character or a 40 GB disk image — and squeezes it into a fixed-size fingerprint called a digest. MD5 always outputs 128 bits, SHA-256 always 256, SHA-512 always 512. Three properties make the whole thing work:
- Deterministic — the same input always produces the same digest, on every machine, forever.
- One-way — you can't turn a digest back into the input. There's no "un-MD5."
- Avalanche effect — flip one bit of the input and roughly half the output bits flip.
Hello, Stackblip!andHello, Stackblip?produce digests that share nothing visually.
That combination is why hashes are the internet's integrity mechanism. Download an ISO and compare its SHA-256 against the published value: a single corrupted byte — or a tampered file — produces a completely different digest, and you know instantly.
Don't confuse hashing with encryption (two-way, reversible with a key) or with a checksum like CRC32 (detects accidental damage, but trivially forgeable on purpose). A cryptographic hash sits in between: designed so that finding two inputs with the same digest — a collision — is computationally infeasible. At least, until it isn't. which brings us to the broken ones.
The family history in one breath: MD5 (Ron Rivest, 1991), SHA-1 (NSA, 1995), the SHA-2 family including SHA-256 and SHA-512 (2001), and SHA-3 — born from a public NIST competition won by the Keccak design in 2012, standardized in 2015. SHA-3 isn't an upgrade that replaces SHA-2; it's a structurally different sponge construction, kept around so the world has a fallback if SHA-2 ever weakens.
Reading a digest
Digests are raw bytes, conventionally displayed as hexadecimal — two hex characters per byte. That's why MD5 is always 32 hex chars (128 bits ÷ 4), SHA-1 is 40, SHA-256 is 64, SHA-512 is 128, and SHA-3-256 is 64. The empty string is the classic hash hello-world — every correct implementation must produce exactly these:
MD5 (32 hex chars · 128-bit) d41d8cd98f00b204e9800998ecf8427e SHA-1 (40 · 160-bit) da39a3ee5e6b4b0d3255bfef95601890afd80709 SHA-256 (64 · 256-bit) e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 SHA-3 (64 · 256-bit · Keccak) a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a SHA-512 (128 · 512-bit) cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce 47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e
If a library ever disagrees with these on empty input, stop using that library. These vectors are how you sanity-check any hash implementation — including this page: clear the text box and compare.
Where developers actually use these
- Download integrity — compare the SHA-256 of a downloaded ISO or release tarball against the published value. One corrupted byte, one malicious mirror, caught instantly.
- Git commit IDs — every commit hash you've ever copied is a SHA-1 of the commit's contents. Git is migrating to SHA-256 precisely because of the attacks below.
- Deduplication & backups — rsync-style tools hash blocks and skip anything unchanged. MD5's speed is a feature here, not a flaw.
- Cache keys & ETags — hash the input, use the digest as a compact, collision-safe identifier for expensive computations.
- Merkle trees & blockchains — hashes of hashes, all the way up to a single root that anchors the whole structure.
- Digital fingerprinting — virus scanners, certificate pinning, and license systems all key off digests.
Which ones are broken — and what "broken" means
A hash breaks when attackers can manufacture collisions: two different inputs sharing one digest. The timeline is worth memorizing:
- MD5 — broken since 2004. Collisions became trivial; by 2008 researchers forged a rogue certificate authority using an MD5 collision. Never use it for signatures, certificates, or anything an adversary can touch.
- SHA-1 — broken since 2017. Google's SHAttered project produced two different PDFs with the same SHA-1; by 2020 chosen-prefix collisions were cheap enough for ordinary attackers. Browsers and Git moved off it for good reason.
- SHA-256 / SHA-512 / SHA-3 — no practical attacks today. These are what you should reach for by default.
Two more notes that save people real trouble. First,
none of these belong in a password database — they're
deliberately fast, which is exactly what a brute-forcer wants.
Passwords need slow, salted, memory-hard functions: bcrypt, scrypt,
or Argon2. Second, SHA-2 has a structural quirk called the
length-extension attack: knowing
SHA256(secret + message) lets an attacker extend the
message without knowing the secret. It's why HMAC exists, and one of
the reasons SHA-3's sponge design matters.
"Broken" doesn't mean "useless," though. For checksums, dedup, and cache keys — jobs where no attacker is crafting inputs — MD5 and SHA-1 remain fast, universal, and perfectly fine. This tool labels them honestly and lets you decide.
Frequently asked questions
Is hashing the same as encryption?
No. Encryption is two-way — data encrypted with a key can be decrypted back. Hashing is one-way: a digest can never be turned back into the original input. That's exactly why hashes verify integrity instead of carrying secrets.
Can a hash be reversed to reveal the input?
Not by computation — but short or common inputs can be looked up in precomputed rainbow tables. That's why passwords need salted, deliberately slow hashes like bcrypt or Argon2, not the fast digests on this page.
Which algorithm should I use?
SHA-256 is the safe default for almost everything today. SHA-512 and SHA-3 are equally solid. MD5 and SHA-1 are fine for non-security jobs like file checksums and deduplication — never for signatures, certificates, or passwords.
Why are MD5 and SHA-1 still used if they're broken?
They're fast, universally supported, and their weaknesses only matter when an attacker can craft collisions — irrelevant for checksums, cache keys, or dedup. Billions of systems still rely on them for exactly those jobs.
Does uppercase vs lowercase change the hash?
No. Digests are byte values rendered as hexadecimal, and hex is case-insensitive — 3F and 3f are the same byte. The toggle is purely a display preference for whatever system you're pasting into.
Does my file leave the browser?
Never. Files are read with your browser's FileReader API directly into memory and hashed locally. Open the network tab while dropping a file — you'll see zero requests.