Hash Generator
Generate MD5, SHA-1, SHA-256 and SHA-512 hashes instantly — for passwords, files and data integrity. Free, client-side, nothing sent to any server.
Hash Generator Tool
ASCII mode keeps only the low 7 bits of every character, so anything outside ASCII (accents, CJK, emoji) is hashed as different bytes from the ones you typed. Use UTF-8 unless you are reproducing a legacy system that does the same thing.
Your input contains characters outside ASCII. In ASCII mode they are masked to their low 7 bits before hashing — these digests are not the digests of the text you typed. Switch to UTF-8 for that.
How to Use the Hash Generator
Type your text or switch to File mode to drop a file
In Text mode, type or paste any text — hashes generate automatically as you type. In File mode, drag and drop any file onto the drop zone, or click to select. All processing is local to your browser. Size is not unlimited, though: the file is read into memory in full, and because MD5 is computed for every input it also builds a whole-file JavaScript string on the main thread. Everyday files are instant; files in the hundreds of megabytes can freeze the tab or exhaust memory. The SHA digests come from Web Crypto and are the cheap part — MD5 is the constraint.
All four hash formats generate automatically
MD5, SHA-1, SHA-256, and SHA-512 are computed simultaneously. SHA-1, SHA-256, and SHA-512 use the browser's native Web Crypto API. MD5 uses a built-in implementation since Web Crypto intentionally omits it (MD5 is cryptographically broken). You can also select UTF-8 or ASCII encoding for text input.
Copy any hash format with one click
Each hash row has its own Copy button. You can also expand the HMAC-SHA-256 section to generate a keyed-hash message authentication code — useful for verifying API webhook payloads. Enter your secret key and the HMAC result appears immediately.
Use the Compare section to verify a known hash against your input
Paste a known hash into the Compare / Verify section. On Any of the four the tool does not inspect the hash at all — it has already computed MD5, SHA-1, SHA-256 and SHA-512 for your input, and it compares your pasted string against each of those four in turn (case-insensitively), reporting the first that matches. Pick a specific algorithm from the dropdown to compare against that one only. A green check mark names the algorithm that matched; a red cross means none of them did.
Cryptographic Hash Functions — The Building Blocks of Digital Security
What Is a Hash Function and Why Developers Use Them Daily
A cryptographic hash function takes an input of any length and produces a fixed-length output string — the hash or digest. Three properties make hash functions foundational to modern software: they are deterministic (the same input always produces the same output), one-way (it is computationally infeasible to recover the input from the output), and avalanche-sensitive (a single bit change in the input produces a completely different output). That last property — the avalanche effect — is what makes them suitable for integrity checking: even a tiny tamper with a file produces a radically different hash.
In daily development, hash functions appear everywhere. Git identifies every commit, tree, blob, and tag by a hash of its contents — two commits with different content will always have different identifiers. Package managers like npm, pip, and Homebrew verify downloaded packages against published SHA-256 checksums before installation. Content delivery networks use hashes as cache keys. Blockchain mining is fundamentally a hash-finding race. Digital signatures hash the message before encrypting to keep signature sizes manageable. HMAC (Hash-based Message Authentication Code) uses a hash function with a shared secret to let two parties verify that an API request wasn't tampered with in transit.
MD5 vs SHA-256: Why One Is Broken and One Is Still Safe
MD5 was designed in 1991 by Ronald Rivest of MIT and specified in RFC 1321. By 2004, practical collision attacks were demonstrated — meaning two different inputs could be engineered to produce the same MD5 hash. In 2008, security researchers used MD5 collisions to forge a rogue certificate authority certificate, compromising the entire web PKI. MD5 must never be used for any security purpose today — not for passwords, not for digital signatures, not for certificate fingerprints. RFC 6151 (2011), co-authored by NIST, puts it plainly: "MD5 is no longer acceptable where collision resistance is required such as digital signatures", and advises that new protocol designs should not employ HMAC-MD5 either. Its only legitimate remaining use is as a fast, non-security checksum for verifying file transfer integrity in trusted contexts, where collision attacks are not a concern.
SHA-1 followed a similar trajectory. Theoretical weaknesses were found in 2005. In 2017, researchers from CWI Amsterdam and Google produced the SHAttered attack — the first known SHA-1 collision, two different PDF files with the same SHA-1 hash. Their paper puts the cost at 263.1 calls to SHA-1's compression function, "approximately 6,500 CPU years and 100 GPU years". In 2020, Leurent and Peyrin went further with SHA-1 is a Shambles, the first chosen-prefix collision, at a complexity of 263.4 — chosen-prefix is the variant that lets an attacker start from two meaningful, arbitrary documents rather than a crafted pair. SHA-1 had already been "officially deprecated by NIST in 2011", as the SHAttered paper's own abstract notes; on 15 December 2022 NIST announced SHA-1's retirement, saying it will stop using SHA-1 in its last remaining specified protocols by 31 December 2030. Today SHA-256 and SHA-512 — both part of the SHA-2 family — remain secure. SHA-3 (the Keccak algorithm) was selected by NIST in 2012 as an alternative family with a completely different internal structure, offering a hedge against potential future weaknesses in SHA-2.
Breaking SHA-1 in 2017 cost 263.1 compression-function calls — "approximately 6,500 CPU years and 100 GPU years", per the SHAttered paper (Stevens, Bursztein, Karpman, Albertini & Markov, CRYPTO 2017). GPUs have only got cheaper since.
One critical distinction: SHA-256 is a general-purpose hash function, designed to be fast. For password storage, fast is actually dangerous — it makes brute-force attacks easy, and adding a salt does not fix it: a salt stops one precomputed table from covering every account, but the attacker still gets billions of guesses per second against each account individually. NIST SP 800-63B-4 §3.1.1.2 requires that passwords "SHALL be salted and hashed using a suitable password hashing scheme" — a scheme that takes a password, a salt and a cost factor, with the cost set as high as performance allows and raised over time. RFC 9106 §4 names Argon2id as its "FIRST RECOMMENDED" option; bcrypt, scrypt and PBKDF2 are the other established choices. Never store passwords as bare SHA-256 hashes; RECATOOLS itself uses bcrypt with cost 12.
File Integrity Checking in Practice
File integrity verification through hashes is a cornerstone of secure software supply
chains. When a Linux distribution publishes a new release, it also publishes a
SHA256SUMS file containing the expected hash of each ISO image. After
downloading, you compute the hash locally and compare — any corruption or tampering
during download produces a mismatch. Drop the ISO into File mode above, paste the
published hash into Compare / Verify, and you have done the check the release notes
asked for.
The same discipline applies to third-party libraries. Package managers verify integrity against their own lock files and registry metadata, which tells you the artefact has not changed since you first resolved it — not that the artefact was ever the one the maintainer published. Comparing a release's SHA-256 against the checksum on the project's own site or signed release page is a separate, independent check, and it is the one that catches a compromised registry account.
HMAC-SHA-256 is widely used for API webhook signature verification. GitHub and Stripe, among many others, use HMAC-SHA-256 to sign webhook payloads — your server recomputes the HMAC of the incoming request body using the shared secret and compares it to the signature in the request header. A mismatch means the webhook was not sent by the legitimate provider or was tampered with in transit. The HMAC section in this tool lets you compute and verify these signatures without a programming environment.
10 Facts About Hashing
MD5 was designed in 1991 by Ronald Rivest (RFC 1321) — by 2004 practical collision attacks were demonstrated, and RFC 6151 (2011) declared it unacceptable wherever collision resistance is required.
Git uses SHA-1 hashes for commit IDs — a 40-character hex string that uniquely identifies every commit, tree, blob and tag in the repository.
The SHA-256 hash of an empty string is e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 — a well-known test value.
Bitcoin uses double SHA-256 (SHA-256 applied twice) for its Proof of Work algorithm — chosen because MD5 and SHA-1 were already compromised.
bcrypt was designed specifically for password hashing — it is intentionally slow (adjustable work factor) to resist brute-force attacks, unlike SHA-256.
The 2017 SHAttered attack produced the first known SHA-1 collision — two PDFs, one hash — at a cost the paper puts at 263.1 compression-function calls, "approximately 6,500 CPU years and 100 GPU years".
The SHA-3 standard (Keccak algorithm) was selected by NIST in 2012 after a 5-year public competition — using a completely different "sponge construction" from SHA-2.
SHA-1 was "officially deprecated by NIST in 2011" (SHAttered paper, abstract). On 15 December 2022 NIST announced its retirement — the last NIST-specified protocols drop it by 31 December 2030.
A rainbow table attack pre-computes hashes for millions of passwords. A salt kills the pre-computed table but not the attack — SHA-256 is still fast enough to guess in bulk. What defeats offline guessing is a deliberately slow, memory-hard KDF: Argon2id (RFC 9106 §4's "FIRST RECOMMENDED" option), bcrypt, scrypt or PBKDF2.
Content Delivery Networks use SHA-256 hashes as cache keys — ensuring the same file at different URLs gets the correct cached version.
Frequently Asked Questions
-
MD5 (Message Digest Algorithm 5) is a hash function designed in 1991 that produces a 128-bit (32 hexadecimal character) digest from any input. It was originally used for digital signatures and password storage. MD5 hashes update automatically in this tool as you type, making it easy to compute checksums for data verification purposes. Note that MD5 is no longer considered cryptographically secure for security applications.
-
No — not for any security purpose. MD5 collision attacks have been practical since 2004, meaning two different inputs can be engineered to produce the same MD5 hash. This breaks any system that relies on MD5 for authenticity. MD5 is still widely used as a fast, non-security checksum for detecting accidental file corruption (where malicious collision engineering is not a concern). Never use MD5 for passwords, digital signatures, certificates, or API authentication. Use SHA-256 or above for any security-sensitive hashing.
-
SHA-256 is the current standard for general-purpose cryptographic hashing. It is used for: verifying file integrity (software downloads, package managers), digital signatures (code signing, TLS certificates), blockchain (Bitcoin's proof-of-work), HMAC-SHA-256 for API authentication, and as the basis for most modern security protocols. It is also the replacement of choice as SHA-1 is withdrawn — NIST announced SHA-1's retirement on 15 December 2022 and will stop using it in its last remaining specified protocols by 31 December 2030.
-
Both are part of the SHA-2 family and are currently secure. SHA-256 produces a 256-bit (64 hex character) digest; SHA-512 produces a 512-bit (128 hex character) digest. SHA-512 has a larger security margin against future brute-force attacks, and is actually faster than SHA-256 on 64-bit processors because its internal word size is 64-bit (vs SHA-256's 32-bit). For most applications, SHA-256 is sufficient. SHA-512 is preferred for very long-term archival signatures or high-security environments where the extra margin is worth the storage overhead.
-
Not through mathematical reversal — a cryptographic hash function is designed to be a one-way function. However, short or common inputs can be "reversed" through lookup tables (rainbow tables) that pre-compute hashes for millions of known inputs. This is why weak passwords stored as unsalted hashes (especially MD5) can be cracked instantly from online databases. A unique salt per password retires the pre-computed table, but it does not slow the attacker down — SHA-256 is fast by design, so they simply guess against each salt in turn. Only a deliberately slow, memory-hard password hashing scheme — Argon2id (RFC 9106 §4's first recommendation), bcrypt, scrypt or PBKDF2 — makes that guessing uneconomic.
-
HMAC (Hash-based Message Authentication Code) combines a hash function with a shared secret key to produce a code that verifies both the integrity and authenticity of a message. Unlike a plain hash, an HMAC cannot be forged without knowledge of the secret key. You need HMAC when you want to verify that a message hasn't been tampered with and was sent by a party who knows the shared secret. Common uses: API webhook signature verification (GitHub, Stripe and Shopify all use HMAC-SHA-256), JWT signing, request signing between services, and secure session tokens.
-
Download the file and note the SHA-256 hash published on the official download page. Switch to File mode in this tool, drop the downloaded file onto the drop zone, then copy the SHA-256 result. Paste the published hash into the Compare / Verify section and select SHA-256. A green check mark confirms the file is intact and matches the official release. A mismatch means the file was corrupted during download or may have been tampered with — delete it and download again from a trusted source.
-
SHA-256 is designed to be extremely fast — it can compute billions of hashes per second on modern GPU hardware. This is great for file integrity checking but terrible for passwords. An attacker who obtains a SHA-256 password hash can try billions of password guesses per second until they find a match. Password hashing requires intentionally slow algorithms: bcrypt (adjustable cost factor), scrypt, or Argon2. These algorithms are calibrated to take hundreds of milliseconds to compute a single hash — fast enough for legitimate logins, slow enough to make bulk cracking impractical. RECATOOLS uses bcrypt with cost=12 for all user passwords.
-
No. All hashing is performed entirely in your browser: SHA-1, SHA-256, SHA-512 and HMAC-SHA-256 through the Web Crypto API (
window.crypto.subtle), and MD5 through a self-contained JavaScript implementation bundled with the page, because Web Crypto deliberately does not offer MD5. Your text and files never leave your device. You can verify this by opening your browser's developer tools Network tab while using the tool — you will see zero data requests related to your input. This makes the tool safe to use with confidential documents, API keys, or sensitive data you need to hash locally. -
A hash collision occurs when two different inputs produce the same hash output. Because hash functions compress arbitrary-length input to a fixed-length output, collisions must theoretically exist (infinitely many inputs, finite outputs). A secure hash function makes it computationally infeasible to find a collision — meaning you cannot deliberately engineer two different files with the same hash in any reasonable timeframe. MD5 and SHA-1 have both been demonstrated to have practical collision attacks. SHA-256 and SHA-512 have no known practical collision attacks and are considered collision-resistant for current hardware.
Related News
You may be interested in these recent stories from our newsroom.
-
One Generated Prompt Beat Up to 63 Per Cent of a Top Conference's LLM Techniques
A University of Virginia team reproduced 35 ICSE 2026 techniques and outperformed 37 to 63 per cent of them with a single prompt to a newer...
-
The Sixth Exploited Langflow Flaw This Year Is Not a Vulnerability Story
VulnCheck has recorded 360 attacks on a Langflow flaw fixed in January. It is the sixth separately identified Langflow vulnerability exploit...
-
Broadcom Already Maintains Spring and RabbitMQ. Now It Will Sell You Clean Builds.
A reproducible build proves the binary matches the source. It says nothing about whether the source is safe, which is where the damaging inc...
Pick up where you left off
Stored only in this browser — never sent to our servers.