What is the difference between MD5 and SHA-256?

MD5 produces a 128-bit (32-character hex) digest and is fast to compute. It is considered cryptographically broken — collisions can be generated in seconds on commodity hardware — so it should never be used for security purposes. SHA-256 produces a 256-bit (64-character hex) digest and is significantly more secure. It is the standard choice for integrity verification, digital signatures, and other security-sensitive uses. Use SHA-256 or SHA-512 for new applications.

Can a hash be reversed?

No — that is the defining property of a one-way function. A hash function maps input of any size to a fixed-size digest, and the computation is designed to be infeasible to reverse. However, attackers can use precomputed rainbow tables (hash → input mappings) for common inputs like short passwords. This is why passwords need both a strong hash algorithm (bcrypt, Argon2) and a unique random salt per entry.

Why should I not use SHA-256 to hash passwords?

SHA-256 is designed to be fast — which is exactly what you do not want for password storage. An attacker with a GPU can compute billions of SHA-256 hashes per second, making brute-force attacks trivial. Password hashing algorithms like bcrypt, Argon2, and scrypt are deliberately slow and configurable. They include a work factor that lets you increase computation time as hardware gets faster. Always use one of these for passwords, never raw SHA.

What is a hash collision?

A collision occurs when two different inputs produce the same hash output. Since hash functions map arbitrary-length input to a fixed-size output, collisions are mathematically inevitable — but a good hash function makes finding one computationally infeasible. MD5 and SHA-1 have known practical collision attacks. SHA-256 has no known collisions. Collisions matter for security (digital signatures, certificates) but not for non-security uses like checksums for accidental corruption.

What is a Hash Function?

Hash functions explained: one-way digests, MD5 vs SHA-256, use cases, and why you should never hash passwords with SHA.

6 min read·Updated June 2026

A hash function takes an input of any size and produces a fixed-length output called a digest or hash. Change a single character in the input and the entire output changes completely — this is called the avalanche effect. Hash functions are one-way: you cannot reconstruct the original input from its hash.

They are fundamental to computer security — used to verify file integrity, store passwords, sign documents, deduplicate content, and power blockchain systems.

Four properties of a cryptographic hash function

Deterministic — the same input always produces the same output.
Fixed-length output — regardless of input size, the digest is always the same number of bits.
Avalanche effect — a tiny change in input completely changes the output. hello and hello! produce entirely different hashes.
Collision resistance — it should be computationally infeasible to find two different inputs that produce the same hash.

MD5, SHA-1, SHA-256, SHA-512 compared

Algorithm	Output size	Speed	Security	Common use
`MD5`	128 bit (32 hex)	Very fast	Broken	Non-security checksums, legacy systems
`SHA-1`	160 bit (40 hex)	Fast	Broken	Git commit IDs (transitioning to SHA-256)
`SHA-256`	256 bit (64 hex)	Fast	Secure	TLS certificates, JWT signatures (HS256), file integrity
`SHA-512`	512 bit (128 hex)	Slightly slower	Secure	High-security applications, 64-bit platforms where it is faster than SHA-256

Broken means that collisions (two inputs producing the same hash) can be computed in practice. MD5 collisions take seconds on modern hardware. Never use MD5 or SHA-1 for anything security-critical.

Use cases

File integrity and checksums

Download a file, compute its SHA-256 hash, compare it to the hash published by the author. If they match, the file was not tampered with in transit. Package managers (npm, pip, apt) do this automatically for every package they install.

Content deduplication

Git hashes every file and every commit. If two files have the same SHA-1 hash, Git considers them identical without comparing their content byte-by-byte. This makes repositories fast and space-efficient.

Digital signatures

To sign a document, you hash it first, then encrypt the hash with your private key. The recipient decrypts the hash with your public key and verifies it matches their own hash of the document. Signing the hash is much faster than signing the entire document.

Password storage

Storing raw passwords is catastrophic — if the database is compromised, every account is exposed. Instead, store the hash. When the user logs in, hash their input and compare it to the stored hash.

Important: never use MD5, SHA-1, or even raw SHA-256 to hash passwords. These algorithms are designed to be fast, which makes brute-force attacks trivial. Use a password hashing algorithm specifically designed to be slow and salt-aware: bcrypt, Argon2, or scrypt.

Hashes vs encryption

Hashing and encryption are fundamentally different:

	Hashing	Encryption
Reversible?	No — one-way only	Yes — with the key
Output size	Fixed	Variable (close to input size)
Requires a key?	No	Yes
Use case	Verification, fingerprinting	Protecting data in transit or at rest

Hashing is also distinct from Base64 encoding — Base64 is fully reversible and adds no security, it simply converts binary data to text.

Try it now

Hash Generator

Generate MD5, SHA-1, SHA-256, and SHA-512 hashes from any text — live, client-side.

→