Hash Generator & Checksum
Get MD5, SHA-1, SHA-256, SHA-384 and SHA-512 for text and files at once. Verify a downloaded file against its official checksum to make sure it wasn't tampered with. All local, nothing leaves your browser.
- Algorithms
- MD5 · SHA-1/256/384/512
- Engine
- Web Crypto API
- Privacy
- 100% local
- Input
- Text / file
Drop a file here, or click to browse
File bytes are read locally to compute checksums — nothing is uploaded. Works with installers, disk images and archives.
FEATURES
All five hashes on one page
From quick fingerprints to secure signatures — every hash developers, ops and download verification need.
Five algorithms
MD5, SHA-1, SHA-256, SHA-384 and SHA-512 shown together with output bit lengths — no more switching between tools.
Real-time computing
Text hashes as you type, no button to press. Results in monospace — click a row to copy.
File integrity check
Drop in an installer, disk image or archive and compare it with the official checksum to confirm an untampered download.
Local, zero upload
SHA family uses the browser's built-in Web Crypto API. Text and files never leave your machine — sensitive content is fine.
UTF-8 consistent
Text is hashed as UTF-8 bytes, so results match md5sum, PHP md5() and Python hashlib exactly.
One-click copy
Copy each hash individually, or all of them in standard checksum format ready to paste into a terminal.
What you should know about hashes
The idea is simple, but using the wrong one for the wrong job is a real security mistake.
What exactly are MD5 and SHA-1?
MD5 (Message-Digest Algorithm 5) was designed by Ronald Rivest at MIT and published in 1992 as RFC 1321, producing a fixed 128-bit (32 hex character) digest as the successor to MD4. SHA-1 was designed by the U.S. National Security Agency and published in 1995 as the federal standard FIPS 180-1, producing 160 bits. Both became the most widely deployed hash algorithms over the following two decades — used for file checksums, password storage, digital signatures and Git commit IDs. Note that they still produce correct digests today; "insecure" means their collision resistance is broken, not that their output is wrong.
Are hashing, encryption and encoding the same thing?
No — they solve different problems. Encoding (such as Base64 or URL encoding) is a reversible format transform anyone can undo, offering no security. Encryption is reversible with a key: plaintext becomes ciphertext and the right key decrypts it. Hashing is one-way, has no key, and the original cannot be recovered from the digest — it is used for fingerprints, integrity checks and signatures. Two common misconceptions: treating Base64 as "encryption", and saying a password was "encrypted with MD5" — that is hashing, and an unsafe way to store passwords at that.
Why can't a hash be reversed back to the original?
A hash is a one-way function: input of any length is compressed into a fixed-length digest, folding away most of the information. Just as you can't reconstruct a sentence from its word count, the original can't be derived from the digest. Secure algorithms are specifically designed to make such reversal computationally infeasible.
Are MD5 and SHA-1 still usable?
For checking whether a file was accidentally corrupted in transit — yes, any stray byte change virtually always changes the MD5. But never for security: practical collision attacks exist for both (researchers can craft two different files with the same MD5 under their control). Use SHA-256 or above for passwords, signatures and certificates.
Why does my hash differ from another tool for the same text?
Three usual suspects: ① different character encoding (this tool always uses UTF-8; older tools may use GBK or Latin-1); ② a trailing newline — command-line echo adds one by default (use echo -n); ③ a stray space or invisible character when copying. Hashes are sensitive to every single byte, so one byte off changes the result completely.
Why can't passwords be stored as plain MD5/SHA-256?
Regular hashes are fast. With a leaked hash table, attackers can try billions of guesses per second, and rainbow tables reverse-lookup common passwords instantly. Passwords need deliberately slow memory-hard algorithms (bcrypt, scrypt, Argon2) with a unique salt per password, making brute force prohibitively expensive.
How do I verify a downloaded file's integrity?
Find the checksum published on the official site (usually SHA-256), drag the downloaded file into the "File checksum" tab here, and paste the official value into the box above the results. The tool detects the algorithm from the value's length and turns the matching row green when the file's bytes are exactly what the publisher released; red means corruption or a man-in-the-middle replacement — do not run the file.
Which of the five algorithms to use
Choose by scenario. Newer algorithms produce longer digests, resist attack better and cost slightly more to compute.
| Algorithm | Introduced | Output length | Security | Typical use |
|---|---|---|---|---|
| MD5 | 1992 | 128 bits (32 chars) | Broken; collisions practical | Non-security fingerprints, dedup, legacy compatibility |
| SHA-1 | 1995 | 160 bits (40 chars) | Collisions practical since 2017 | Git history IDs and other legacy systems; not for new security use |
| SHA-256 | 2001 | 256 bits (64 chars) | Secure today | File checksums, signatures, TLS certificates, blockchains — the universal default |
| SHA-384 | 2001 | 384 bits (96 chars) | Secure | Truncated SHA-512 for compliance regimes requiring 384 bits |
| SHA-512 | 2001 | 512 bits (128 chars) | Secure | High-assurance signatures; often faster than SHA-256 on 64-bit CPUs |
"Secure" means no practical public collision attack to date. For password storage use bcrypt/Argon2 regardless of hash choice.
Checksums: how to actually verify a downloaded file
What that MD5 or SHA-256 string on a download page is for, how to compare it, and what to compare it with — all in one section.
Why verify at all
The file on your disk is not necessarily the file on the server. Ten seconds of checksum comparison guards against three kinds of trouble:
Large files over resumable downloads and flaky networks pick up stray bytes surprisingly often; troubleshooting a broken installer takes far longer than ten seconds.
Many downloads actually come from mirrors or CDNs, where sync lag or cache glitches can hand you an outdated release — or half a file.
When a download source is breached or a public network is hijacked, files can be backdoored. In 2016 the Linux Mint site was hacked and its download links swapped for a backdoored ISO — the project's first response was urging everyone to check the checksum.
What is a checksum
The publisher hashes the file on their server and posts the result on the download page; after downloading, you hash it again locally. If the two strings match character for character, the file's bytes are exactly what the publisher released — neither corrupted nor swapped. The check is sensitive to every byte: change a single byte and the value changes completely. Broadly, checksums also include simpler schemes like CRC32 that only catch accidental corruption, whereas cryptographic hashes such as MD5/SHA additionally resist deliberate forgery.
Verify a file in three steps
-
1
Get the official checksum
On the download page, find the published MD5 / SHA-256 value (often labeled "checksum" or shipped as a .sha256 companion file) and copy the whole string.
-
2
Drop the file and paste
Switch to the "File checksum" tab above, drop in the downloaded file, and paste the checksum into the box above the results.
-
3
Read the verdict by color
The tool detects the algorithm from the value's length: green means the file matches the official release exactly and is safe to use; red means it may be corrupted or tampered with — do not run it.
Reading the checksums on official sites
Download pages write checksums in many styles, but all boil down to two elements: the hash value and the file name. These three shapes are the most common — when pasting, take just the hash part (this tool ignores spaces and line breaks automatically):
# 1. Single line: just the value
a0570aa01532917be820a37994710cf09b6eba198bf9543c27be938c5f09e60a
# 2. sha256sum format: value + two spaces + filename (a SHA256SUMS manifest is many such lines)
a0570aa01532917be820a37994710cf09b6eba198bf9543c27be938c5f09e60a ubuntu-24.04.iso
# 3. BSD format: Algorithm (filename) = value
SHA256 (ubuntu-24.04.iso) = a0570aa01532917be820a37994710cf09b6eba198bf9543c27be938c5f09e60aMD5 or SHA-256
Verify whatever the official site provides, but if you get to choose: MD5 is entirely adequate against accidental corruption in transit (any stray change virtually always changes the MD5). Against deliberate tampering — security software, certificates, signed packages — you need SHA-256 or stronger, because practical collision attacks let attackers craft two different files with the same MD5. That story is told in the "security history" below.
Verifying from the command line instead
On Linux and macOS, the checksum tools accept -c to verify an entire manifest automatically — no manual comparison needed. Windows' built-in commands only compute the value, which you then compare with the official string yourself.
| Environment | Verify command |
|---|---|
| Linux | sha256sum -c SHA256SUMS (checks every file listed in the manifest) |
| macOS | shasum -a 256 -c checksum.txt |
| Quick single-value check | echo "official-value filename" | sha256sum -c - (prints OK on success) |
| Windows | Compute with Get-FileHash <file> -Algorithm SHA256, then compare with the official value |
A brief security history: how MD5 was broken
MD5 didn't fail overnight — from the first crack in academia to forged certificates in the wild, it took two decades.
-
1992
MD5 is published
Ronald Rivest released MD5 in RFC 1321. Fast, simple to implement and always producing a 128-bit digest, it quickly became the de facto standard for file checksums and password storage — and was considered cryptographically secure.
-
2004
Wang Xiaoyun's team reveals full MD5 collisions
At CRYPTO 2004, a team led by Chinese mathematician Wang Xiaoyun demonstrated a full collision attack on MD5 — constructing two files with different contents but the same hash (initially in about an hour on an IBM P690 supercomputer; later improvements brought it down to seconds on ordinary hardware). MD5's promised collision resistance was gone; the standing ovation that followed became one of the most famous moments in cryptography.
-
2008
Forged certificates hit the real internet
Marc Stevens, Alexander Sotirov and others used a chosen-prefix collision to forge an intermediate CA certificate trusted by browsers: certificates with different prefixes carried the same signature. An attacker could now issue "valid" HTTPS certificates for any fake site. Certificate authorities stopped issuing MD5 certificates shortly after.
-
2012
Flame malware attacks Windows via MD5
The state-sponsored Flame malware used an MD5 collision to make Microsoft's terminal-server licensing authority sign a forged code-signing certificate, letting it spread across the Middle East disguised as a Microsoft-signed update. It was the first real-world attack using an MD5 collision; Microsoft revoked the certificate in an emergency patch.
-
2017
SHAttered: SHA-1 falls
Google and the Dutch CWI institute (Marc Stevens et al.) published two different PDF files with an identical SHA-1 hash — at a cost of roughly 6,500 CPU years and 110 GPU years. Browsers removed trust in SHA-1 certificates soon after, and Git platforms accelerated their migration away from it. The 160-bit era was over.
Important nuance: a collision attack does not "crack" the hash of any existing file — it constructs two specific files that hash to the same value. But for signatures and certificates, that is already enough for fatal forgery.
Hashing from the command line
When a browser isn't handy, every OS ships a built-in command (SHA-256 shown).
| Environment | Command |
|---|---|
| Linux / macOS | sha256sum filename (on macOS: shasum -a 256 filename) |
| Windows PowerShell | Get-FileHash filename -Algorithm SHA256 |
| Windows CMD | certutil -hashfile filename SHA256 |
Hashing in code
Minimal examples in four common languages when you're writing scripts or integrating APIs.
async function sha256Hex(data) {
const bytes = typeof data === "string"
? new TextEncoder().encode(data)
: new Uint8Array(data);
const digest = await crypto.subtle.digest("SHA-256", bytes);
return [...new Uint8Array(digest)]
.map((b) => b.toString(16).padStart(2, "0"))
.join("");
}
// Text
console.log(await sha256Hex("hello"));
// Files: digest accepts an ArrayBuffer directly
const buf = await file.arrayBuffer();
console.log(await sha256Hex(buf));
The browser's native Web Crypto only supports the SHA family and requires HTTPS or localhost; MD5 needs a third-party library.
echo hash('sha256', 'hello'); // 64 hex characters
echo md5('hello'); // same as hash('md5', 'hello')
// Streamed: hashes the file without loading it into memory
echo hash_file('sha256', 'setup.exe');
hash() and hash_file() support md5, sha1, sha256, sha512 and more; file hashing is streamed, so it uses little memory.
import hashlib
print(hashlib.sha256(b"hello").hexdigest())
print(hashlib.md5(b"hello").hexdigest())
# Large files: streamed, low memory (Python 3.11+)
with open("setup.exe", "rb") as f:
print(hashlib.file_digest(f, "sha256").hexdigest())
The hashlib standard library needs no install; use file_digest() for streaming hashes of large files (Python 3.11+).
use sha2::{Digest, Sha256};
use md5::Md5;
// Text
println!("{:x}", Sha256::digest(b"hello"));
println!("{:x}", Md5::digest(b"hello"));
// Large files: streamed, low memory
let mut file = std::fs::File::open("setup.exe")?;
let mut hasher = Sha256::new();
std::io::copy(&mut file, &mut hasher)?;
println!("{:x}", hasher.finalize());
Hashing isn't in the standard library; add the RustCrypto sha2 and md-5 crates in Cargo.toml. With the std feature enabled, io::copy streams files into the hasher.
FAQ
Are my text and files uploaded?
No. Everything is computed inside your browser: the SHA family calls the built-in Web Crypto API, and MD5 runs in page JavaScript. The tool keeps working with the network unplugged — try it with a sensitive file.
Why does empty text still have a hash?
Hash algorithms define a unique fixed output even for zero bytes. The MD5 of an empty string is d41d8cd98f00b204e9800998ecf8427e and its SHA-256 starts with e3b0c442. This tool simply hides results when input is empty so you don't copy them by mistake.
Can it hash files of any size?
It depends on available browser memory — installers and disk images of a few hundred MB are typically fine. Files are read into memory in one pass, so for multi-GB files prefer command-line tools (sha256sum, certutil).
Why are hashes different lengths?
Length is determined by the algorithm: MD5 is 32 hex characters, SHA-1 is 40, SHA-256 is 64 and SHA-512 is 128. Two hex characters per byte — and the length is independent of input size: a one-byte file and a multi-GB file both yield 64 characters with SHA-256.
Can I use it to build API signatures?
Yes. Many open platforms sign requests by hashing "parameters + secret" with MD5 or SHA-256. This tool is great for checking a signature value while debugging; in production, compute hashes in your server-side language library and never embed the secret in frontend code.
How do I compare a checksum with this tool?
Switch to the "File checksum" tab, drop in the file, and paste the checksum from the official site into the box above the results. The tool auto-detects the algorithm by length (32 chars MD5, 40 SHA-1, 64 SHA-256, 96 SHA-384, 128 SHA-512): the matching row turns green with a "Passed" note when they agree, and red when they don't. Letter case, surrounding spaces and line breaks are ignored automatically.
Related tools
Other encoding, crypto and password tools.
Base64 Encode / Decode
Convert between binary and text — handy for Data URIs and HTTP basic auth debugging.
Password Generator
Generate strong random passwords — passwords should be random and unique, not "encrypted" with a hash.
Password Strength Checker
Check whether a password is long and random enough, and whether it has appeared in known breaches.