Hash Generator
Type some text or drop in a file and instantly get its MD5, SHA-1, SHA-256, SHA-384, and SHA-512 hashes — all at once. Copy any digest with one tap and move on. Everything is computed in your browser, so nothing is ever uploaded.
What is the Hash Generator?
The Hash Generator is a free online tool that turns any text or file into a fixed-length fingerprint called a hash. Paste a string or drop in a file and it instantly computes five digests at once — MD5, SHA-1, SHA-256, SHA-384, and SHA-512 — so you can copy whichever one you need. A hash is a one-way checksum: the same input always produces the same output, but you can never reverse the hash back into the original data. That makes hashes ideal for verifying that a file downloaded correctly, comparing two values without revealing them, or matching a checksum a publisher gave you.
How to use it
- Choose a mode: type or paste into the text box, or switch to file mode and drop in (or pick) a file.
- As you type, every supported hash is computed live and shown in its own row. In file mode the file is read locally and hashed the moment you select it.
- Optionally flip the uppercase / lowercase toggle if the system you are comparing against expects a particular case.
- Click Copy next to any algorithm to put that single digest on your clipboard.
- That is it — you get every hash in one second and move on. Nothing is uploaded.
The method behind it
For SHA-1, SHA-256, SHA-384, and SHA-512 the tool calls the browser's built-in Web Crypto
API (crypto.subtle.digest), the same audited, native implementation your
operating system trusts, then renders the bytes as lowercase hexadecimal. MD5 is not part of
Web Crypto because it is no longer considered secure, so it ships as a tiny, dependency-free
JavaScript implementation of the standard MD5 algorithm that runs on the raw bytes — meaning
a file's MD5 here matches the value reported by command-line tools like md5sum.
Text is encoded as UTF-8 before hashing, and files are read with the FileReader API directly
from your disk. Because everything runs in the page, the result is computed locally and your
input never travels over the network.
Examples
Hashing a short string
Input: hello
- MD5:
5d41402abc4b2a76b9719d911017c592 - SHA-1:
aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d - SHA-256:
2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824
Detecting a one-character change
Input hello and input hellO look almost identical, yet their
SHA-256 digests share not a single character. This avalanche effect is why even a tiny edit
to a file is impossible to hide from a hash comparison.
Verifying a download
A project lists a SHA-256 checksum next to its installer. Drop the downloaded installer into file mode, read off the SHA-256, and confirm it matches. If even one byte was corrupted or tampered with in transit, the hashes will not match.
Common use cases
- Checksum verification — confirm a downloaded ISO, installer, or release archive matches the publisher's posted hash before you run it.
- File integrity — compare two copies of a file across machines by their SHA-256 rather than diffing the whole thing.
- Deduplication — spot identical files by hash even when their names differ.
- Caching and ETags — generate a stable content fingerprint for cache keys or cache-busting.
- Legacy systems — produce an MD5 or SHA-1 for older APIs and tools that still require those formats.
- Learning and debugging — see exactly how different algorithms transform the same input while studying cryptography.
Why use this one
Most hash tools either compute one algorithm at a time or quietly send your input to a backend. This one computes all five algorithms at once, in your browser, with one-click copy and a case toggle — and it hashes files locally too, so you can verify confidential downloads without uploading them anywhere. Everything runs client-side, so your text and files never touch a server, there is no signup, and there are no rate limits. It is fast because there is no round trip, and it works on mobile. When you are working with encoded data, pair it with the Base64 Encode / Decode tool; for generating identifiers and secrets, see the UUID Generator and the Password Generator.
A note on security
Not every hash is safe for every job. MD5 and SHA-1 are fast but cryptographically broken: attackers can craft two different inputs that share the same hash, so never use them for passwords, digital signatures, or anything an adversary could exploit. For security-sensitive work choose SHA-256 or stronger. MD5 and SHA-1 remain perfectly fine for non-adversarial checks like matching a legacy checksum or spotting accidental file corruption, which is why this tool still offers them alongside the modern algorithms.
Frequently asked questions
Is my text or file uploaded to a server?
No. Every hash is computed entirely inside your browser — text uses the native Web Crypto API and a bundled MD5 implementation, and files are read locally with the FileReader API. Nothing is sent to, stored on, or seen by any server, so it is safe to hash private data and confidential files.
Which hash should I use?
For security and integrity, use SHA-256 or stronger (SHA-384, SHA-512). MD5 and SHA-1 are fast but cryptographically broken, so use them only for non-security checks like comparing files or matching legacy checksums — never for passwords or signatures.
Why is MD5 considered unsafe?
MD5 is vulnerable to collision attacks: two different inputs can be made to produce the same hash, which lets attackers forge data. It is also extremely fast to brute-force. It remains useful for quick, non-adversarial integrity checks, but you should never rely on it for passwords, certificates, or anything security-sensitive.
Can I verify a download's checksum with this tool?
Yes. Switch to file mode, drop in the downloaded file, and compare the generated SHA-256 (or whatever the publisher lists) against the official checksum. Because the file is read locally and never uploaded, you can verify large or private files safely and offline.
Does the same input always give the same hash?
Yes. A hash function is deterministic — identical input always produces an identical digest, every time and on every device. Even a one-character change produces a completely different hash, which is exactly what makes hashes useful for detecting tampering.