Generate a hash
MD5, SHA-1, SHA-256, SHA-384 and SHA-512, for text or for a file of any size. Useful for verifying a download matches its published checksum. Nothing is stored.
- Never stored
- No queue, no waiting
- No signup, no watermark
Text is hashed as UTF-8. Drop a file to verify a download instead.
How it works
Paste text or drop a file
Text is hashed as UTF-8. A file is read and hashed here; it is never stored.
Read every hash at once
All five algorithms are computed together, so you do not have to know in advance which one you need.
Compare with an expected value
Paste the checksum you were given and it is matched for you — character-by-character comparison by eye is where mistakes happen.
What a hash proves, and what it does not
A hash is a fixed-length fingerprint of any amount of data, and it has two properties worth stating precisely. It is one-way — there is no operation that turns a hash back into the data, because almost all of the information is gone. And it is sensitive: change one bit of the input and roughly half the bits of the output change. That is what makes it useful for confirming that a file downloaded intact, or that two files are the same without comparing them byte by byte.
MD5 and SHA-1 are broken and are here anyway, for a reason. Both have practical collision attacks — MD5 since 2004, SHA-1 demonstrated with a real pair of PDFs in 2017 — which means someone can construct two different files with the same hash. So neither proves anything against an adversary. Both remain perfectly good at catching accidental corruption, and a great deal of real software still publishes MD5 checksums, so checking one against a download is a legitimate thing to need. Use SHA-256 for anything where somebody might be trying to fool you.
Never hash a password with any of these. This is the most consequential thing on the page. Hashes are designed to be fast, and fast is exactly wrong for passwords: a modern graphics card computes billions of SHA-256 hashes a second, so a stolen database of hashed passwords is cracked in hours. Password storage needs a deliberately slow function with a per-user salt — argon2, bcrypt or scrypt — which are built to cost time and memory on purpose. A plain SHA-256 of a password is a vulnerability, not a protection, whatever it looks like in a database column.
Comparing a hash you calculated against one published on the same page you downloaded from proves less than it seems: anyone who could replace the file could replace the number beside it. A checksum is worth most when it comes from somewhere else — a signed release, a separate channel, a value you recorded earlier yourself.
When you want something else
At the command line this is one word: shasum -a 256 file on macOS and Linux, certutil -hashfile file SHA256 on Windows, and md5sum or sha1sum where an older checksum is what is published. They stream the file rather than loading it, so there is no size limit — which is the real difference for anything above a few hundred megabytes, where a page holding the whole file in memory will simply fail.
For verifying that a release is genuine rather than merely intact, a hash is the wrong tool by itself. GPG signatures — gpg --verify file.sig file — prove who produced the file, which is the question a checksum cannot answer. Most serious projects publish both, and the signature is the one that matters.
Frequently asked questions
Is my file stored anywhere?
No. The file is hashed with the same built-in cryptography that handles HTTPS. Nothing is stored, so there is no size cap and no waiting on a connection.
Is there a size limit?
Available memory, not a fixed size cap. The browser's cryptography has no way to hash a file in pieces — it needs the whole file in memory at once — so a very large file (a DVD image, say) may fail on a machine that cannot hold it. Files up to a few hundred megabytes are fine on a normal computer. If a large one fails, that is the limit you have hit, and the page says so rather than hanging.
Which hash should I use?
SHA-256 for anything new. It is the modern default, it is what software checksums, container digests and blockchain systems use, and it has no known weaknesses. Use MD5 or SHA-1 only when something else requires them — matching an old published checksum, a legacy system, or Git, which identifies objects by SHA-1. Use SHA-512 when you specifically want a longer digest; on 64-bit machines it is often faster than SHA-256, not slower.
Can I use this to hash a password?
You can, but you should not store the result. This is the single most common mistake in this area, so it is worth being direct: MD5, SHA-1 and SHA-256 are all wrong for passwords, and SHA-256 being cryptographically strong does not help. The problem is that these functions are FAST by design — a modern graphics card computes billions of SHA-256 hashes per second, so a stolen database of SHA-256 password hashes is cracked at enormous speed. Passwords need a deliberately slow, salted function built for the job: bcrypt, scrypt or Argon2. Every serious framework has one built in.
Why is MD5 marked broken?
Because anyone can now construct two different files with the same MD5 hash, on ordinary hardware, in seconds. That has been true since 2004 and it has been demonstrated with real, working consequences — two PDFs showing different contracts, two executables where one is malware. So MD5 cannot prove a file is the file you expected; a deliberate forgery can match. It is still perfectly reasonable for detecting accidental corruption, like a bad download or a truncated copy, which is what most published MD5 checksums are actually for. It must never be used for security.
Why is SHA-1 marked broken?
For the same reason, more recently. In 2017 Google and CWI produced two different PDFs with the same SHA-1 hash, and by 2020 the attack was cheap enough to forge signatures with. Browsers stopped accepting SHA-1 certificates years ago, and Git is migrating away from it. If you are choosing an algorithm today, choose SHA-256.
How do I verify a download?
Drop the downloaded file in, then paste the checksum from the site you got it from into the comparison box. If they match, the file arrived intact and is the file that was published. If they do not, delete it and download again. Two cautions: get the checksum from the official source rather than from wherever you got the file, and remember that a checksum only proves the file matches what that page published — if the page itself was compromised, both will match.
Are the hashes computed correctly?
SHA-1, SHA-256, SHA-384 and SHA-512 come from the browser's own Web Crypto implementation, the same code that handles HTTPS. MD5 is not in Web Crypto — deliberately, because it is broken — so it is implemented here directly from RFC 1321 and checked against that document's own published test vectors.
Good to know: MD5 and SHA-1 are here because real files and old systems still use them, not because they are safe — both are broken for anything security-related and only useful as checksums. Web Crypto has no incremental digest, so the whole file is held in memory: very large files will fail rather than stream.
Put this tool on your website
Free for any blog, class page or help article. Paste one snippet and your visitors can use it right on your page.