Developer

Encoders, converters & dev utilities

12 tools
Developer · United States

Hash Generator

MD5, SHA-1/256/512, CRC32 & HMAC — hash text or files in your browser. Accurate, instant and free — for United States.

MD5 & SHA-1 are broken for security

Practical collisions exist for both MD5 and SHA-1 — they are fine as fast checksums (dedupe, detecting accidental corruption) but must never be used for integrity guarantees, signatures or anything security-sensitive. Prefer SHA-256 or SHA-512.

Never hash passwords with a fast hash

MD5, SHA-1 and even SHA-256 are designed to be fast, which lets an attacker try billions of guesses per second. To store passwords, use a deliberately slow, salted algorithm — bcrypt, scrypt or Argon2.

100% in-browser — nothing is uploaded

Text and files are hashed entirely in your browser using the native Web Crypto API (SHA/HMAC) and small client-side libraries (MD5/CRC32). Nothing — including files or HMAC secrets — is ever sent to a server.
SHA-256 digest
The SHA-256 digest appears here.

Hashing is not encryption

A hash is a one-wayfingerprint — you cannot reverse a digest back into the original data. That's different from Base64, which is fully reversible encoding, and from encryption, which is reversible with a key. Use hashes for checksums and fingerprints, encryption for confidentiality.
Fundamentals

What a hash is

A hash function turns any input — a string or a whole file — into a fixed-size digest. The same input always yields the same digest, the tiniest change flips it completely, and the function is one-way: you can't reverse a digest back into the original data.

MD5

128-bit · 32 hex

Fast checksum. Broken for security.

SHA-1

160-bit · 40 hex

Legacy. Collisions are practical — avoid for security.

SHA-256

256-bit · 64 hex

The modern default for integrity.

SHA-512

512-bit · 128 hex

Wider digest, same SHA-2 family.

One digest at a glance
Deterministic
same input → same digest
Avalanche
tiny change → new digest
One-way
not reversible
Fixed size
per algorithm
Security

MD5, SHA-1 and password hashing

A hash generator is only trustworthy if it's honest about what each algorithm is safe for. Two rules matter more than any other.

MD5 & SHA-1 are broken

for security

  • Practical collisions exist for both
  • Fine for accidental-corruption checksums
  • Never for integrity, signatures or trust
  • Use SHA-256 / SHA-512 instead

Don't hash passwords fast

use a slow KDF

  • Fast hashes → billions of guesses/sec
  • Use bcrypt, scrypt or Argon2
  • They add salt + a tunable work factor
  • Never store raw SHA-256 of a password

Broken for security ≠ useless

MD5 and SHA-1 still have legitimate uses as non-security checksums — deduplication, cache keys, catching a corrupted download. The failure mode is trusting them where an attacker could benefit from forging a match. When in doubt, reach for SHA-256.
Beyond plain hashes

HMAC, checksums and encryption

HMAC

keyed hash (RFC 2104)

Combines a message with a secret key — only key-holders can compute or verify it. HMAC-SHA256 is what signs an HS256 JWT.

CRC32

error-detection

A 32-bit checksum used in ZIP and PNG. Catches accidental corruption; offers no protection against deliberate tampering.

Hashing ≠ encryption

one-way vs two-way

A hash can't be reversed; encryption can, with a key. Base64 is neither — just reversible encoding.

Which one do I want?

Use a hash for a tamper-evident fingerprint or checksum, HMAC when both sides share a secret and you need authenticity, and encryption when you need to keep data confidential and recover it later.
FAQ

Frequently asked questions

A hash function maps any input — a string or a whole file — to a fixed-size fingerprint called a digest, shown here as lowercase hexadecimal. The same input always produces the same digest, a tiny change to the input produces a completely different digest, and the function is one-way: you cannot reverse a digest back into the original data. Digest sizes are fixed per algorithm: MD5 is 128 bits (32 hex chars), SHA-1 is 160 bits, SHA-256 is 256 bits (64 hex chars) and SHA-512 is 512 bits. Hashes are used for checksums (verifying a download was not corrupted), deduplication, and as building blocks in signatures and HMAC.

No. Both MD5 and SHA-1 are cryptographically broken — practical collisions exist (two different inputs with the same digest). They remain fine as non-security checksums (accidental corruption, deduplication, cache keys) but must never be used for integrity, signatures, or anything an attacker could forge. Use SHA-256 or SHA-512 instead.

No — not on its own. MD5, SHA-1 and SHA-256 are all designed to be fast, which is exactly wrong for password storage: an attacker who steals your database can try billions of guesses per second against a fast hash. Passwords should be protected with a deliberately slow, salted, memory-hard algorithm designed for the job — bcrypt, scrypt or Argon2. These add a per-user salt and a tunable work factor so each guess is expensive. Never store passwords as raw MD5/SHA-1/SHA-256 digests.

HMAC (Hash-based Message Authentication Code, RFC 2104) combines a message with a secret key to produce a keyed digest. Unlike a plain hash, only someone who knows the key can compute or verify the HMAC, so it proves both that the message is intact and that it came from a party holding the key. HMAC-SHA256 is the construction behind HS256 JSON Web Tokens. This tool computes HMAC-SHA256 in your browser using the native Web Crypto API; supply the message and the secret key.

CRC32 (Cyclic Redundancy Check, 32-bit) is an error-detection checksum, not a cryptographic hash. It is excellent at catching accidental corruption — a flipped bit during a file transfer or storage — and is used in formats like ZIP and PNG. But it is fast and has no cryptographic strength: it is trivial to craft a different input with the same CRC32, so it offers no protection against deliberate tampering. Use it for integrity against accidents, never against attackers.

No. Hashing is one-way — you cannot recover the input from the digest — so it is used for fingerprints, checksums and verification, not for keeping data confidential. Encryption is two-way: it scrambles data so it can be recovered later with the correct key. Base64, by contrast, is neither — it is reversible encoding with no secret at all. If you need confidentiality, encrypt; if you need a tamper-evident fingerprint, hash; if you just need to move binary data through a text channel, use Base64.

No. Everything is hashed entirely in your browser: the SHA family and HMAC use the native Web Crypto API, and MD5 and CRC32 run via small client-side libraries. Your text, files and HMAC secret keys never leave your device and are not logged or stored. Because it is a client-side tool, it works offline once loaded — which is exactly what you want when hashing a sensitive file or secret.

Sources

Method, standards & references

Method: input text is hashed as its UTF-8 bytes; files are hashed from their raw bytes (ArrayBuffer). SHA-1/256/512 and HMAC-SHA256 use the browser's native Web Crypto API (crypto.subtle); MD5 (RFC 1321) and CRC32 run via small client-side libraries. Digests are shown as lowercase hex, with an optional Base64 view. Verified against published test vectors — SHA-256("abc"), MD5("") and an HMAC-SHA256 vector. Nothing is sent to a server.

How we calculate this

Reviewed by Reckonist Editorial · Last reviewed 4 July 2026. Figures follow the methods and sources set out in our editorial standards.

This tool hashes text and files locally in your browser for checksums, fingerprints and HMAC. MD5 and SHA-1 are cryptographically broken and must not be used for security. Never store passwords as fast-hash digests — use bcrypt, scrypt or Argon2. Hashing is not encryption.

Keep going

Same-category tools follow this colour; a cross-category link keeps its own.