Generate MD5, SHA-1, SHA-256, and SHA-512 hashes from text instantly.
A hash function takes input data of any size and produces a fixed-length output called a hash or digest. Cryptographic hash functions are one-way functions—you can generate a hash from input data in milliseconds, but reversing the hash back to the original input is computationally impossible, even for a modest hash like 256 bits. This irreversibility is fundamental to cryptography. Hash functions are deterministic: hashing the same input always produces identical output. Even a single bit change in the input produces a completely different hash, a property called the avalanche effect. Hash functions are fast and produce small, unique outputs, making them ideal for many applications from password storage to blockchain technology to ensuring file integrity. Understanding hashing is essential for anyone working in security, web development, or data verification.
MD5 (Message Digest 5): Produces a 128-bit output, displayed as 32 hexadecimal characters. MD5 was designed in 1992 and was widely used for decades. However, it's cryptographically broken—researchers have found collisions (two different inputs producing the same hash), though finding collisions still requires significant computational effort. MD5 is fast to compute, making it useful for non-security applications like checksums, but it should never be used for security-critical purposes like password hashing or digital signatures.
SHA-1 (Secure Hash Algorithm 1): Produces a 160-bit output (40 hex characters). SHA-1 was considered the successor to MD5 and was used extensively in digital signatures and SSL certificates. However, collision attacks were demonstrated in 2017, showing SHA-1 is no longer cryptographically secure. Major browsers and certificate authorities discontinued SHA-1 support. Like MD5, it's useful for non-security checksums but should be avoided for security applications.
SHA-256 (Secure Hash Algorithm 256-bit): Produces a 256-bit output (64 hex characters). SHA-256 is part of the SHA-2 family and is currently secure with no known practical attacks. It's widely used in blockchain technology (Bitcoin uses SHA-256), digital signatures, TLS/SSL certificates, and password hashing. SHA-256 offers a good balance of security and performance for most applications. It's considered secure for new systems being designed today.
SHA-512 (Secure Hash Algorithm 512-bit): Produces a 512-bit output (128 hex characters). SHA-512 is even larger and more secure than SHA-256. It's often used in high-security applications, systems with extreme security requirements, and as a conservative choice when maximum security is prioritized over performance. The larger output size makes collisions even more astronomically unlikely. However, for most applications, SHA-256 provides sufficient security with slightly better performance.
Enter any text in the input field—it can be a password, a file name, a message, or any combination of characters. As you type, the tool automatically generates hashes for all four algorithms (MD5, SHA-1, SHA-256, and SHA-512) and displays them in separate output fields. Each hash is displayed in its hexadecimal format. Use the copy button on each hash to quickly copy it to your clipboard. Click "Clear" to reset all fields and start fresh. This tool is useful for verifying that hashes are generated correctly, comparing hash algorithms side-by-side, understanding how different algorithms produce different outputs, or generating hashes for specific purposes. The tool runs entirely in your browser—no data is sent to any server, keeping your input completely private.
File Integrity Verification: When downloading files from the internet, providers often publish hash checksums. After downloading, you can hash the file and compare it to the published hash. If the hashes match, the file is intact and hasn't been corrupted or tampered with. This is particularly important for security-critical files like operating system ISOs, cryptographic software, or security tools. A single bit change in a file produces a completely different hash, so this verification is extremely reliable.
Password Storage: Never store passwords in plaintext. Instead, hash passwords when users create accounts, then store only the hashes. When users log in, hash their entered password and compare it to the stored hash. If they match, the password is correct. Even if a database is breached, attackers see only hashes, not passwords. For password hashing specifically, use dedicated password hashing algorithms (bcrypt, scrypt, Argon2) rather than general-purpose hashes like SHA-256, because password algorithms include salt and are intentionally slow to resist brute-force attacks.
Digital Signatures and Authentication: Digital signatures use hashing combined with asymmetric cryptography. A message is hashed, then the hash is encrypted with a private key. Verifiers can decrypt with the public key and re-hash the message to confirm the signature. This proves the message originated from the signer and hasn't been modified. TLS/SSL certificates use this mechanism to verify server authenticity when you access HTTPS websites.
Blockchain and Distributed Ledgers: Blockchain technology fundamentally relies on hashing. Each block contains a hash of the previous block, creating an immutable chain. Bitcoin specifically uses SHA-256. Modifying any historical block changes its hash, which breaks all subsequent blocks, making tampering obvious. The cumulative hashing also provides the security through computational work—mining requires finding hash values that meet specific criteria, requiring massive computational effort.
Data Deduplication: Large systems identify duplicate data by hashing. Two files with identical content produce identical hashes, allowing systems to store only one copy while serving multiple references. Cloud storage services use this to save space. Database systems use hashing to quickly identify duplicate records. Any system managing large amounts of data can leverage hashing for efficient deduplication.
A hash collision occurs when two different inputs produce the same hash output. For cryptographic purposes, collisions should be computationally infeasible—it should take more time and energy to find a collision than makes any attack worthwhile. MD5 and SHA-1 have known collision attacks, meaning researchers can intentionally craft inputs that produce the same hash. These attacks don't mean the functions are broken for all purposes—they're broken specifically for cryptographic applications that depend on collision resistance. Non-cryptographic applications (simple checksums, hash tables) don't require collision resistance.
Hash Distribution: Good hash functions distribute outputs uniformly. If you hash 100 different inputs, the outputs should be scattered throughout the entire range of possible values, not clustered together. This property is crucial for hash tables (the data structure), where poor distribution leads to collisions and poor performance.
Preimage Resistance: Given a hash value, finding an input that produces that hash (a preimage) should be infeasible. This is what makes passwords secure—even knowing a password hash doesn't reveal the original password. A good hash function has no practical way to reverse the hashing process.
Second Preimage Resistance: Given an input and its hash, finding a different input producing the same hash should be infeasible. This prevents attackers from substituting one file for another while maintaining the same hash signature. SHA-256 offers excellent second preimage resistance.
Output Size and Birthday Attacks: The size of the hash output affects security. A 256-bit hash can theoretically be brute-forced by trying all 2^256 possible values—a number larger than atoms in the universe, making this practically impossible. However, birthday attacks work faster: finding two inputs with the same hash (any collision) requires approximately 2^(n/2) attempts for an n-bit hash. This is why the output size matters for security.
Q: Why can't I unhash a password?
A: Because cryptographic hash functions are deliberately designed as one-way functions. The mathematical transformation is easy in one direction (input to hash) but computationally impossible in reverse (hash to input). This is the entire point—no one, not even the system administrator, can recover your original password from the hash. If you forget your password, the system must let you set a new one rather than recovering the old one.
Q: Are MD5 and SHA-1 completely useless now?
A: Not useless, but not recommended for security purposes. They're still fine for non-security checksums (verifying file integrity in controlled, non-adversarial scenarios). They're also still used in legacy systems where replacement would be expensive. For new systems, always use SHA-256 or better. Many security standards now explicitly forbid MD5 and SHA-1 for security applications.
Q: What makes SHA-256 secure if MD5 isn't?
A: Primarily output size and algorithm design. SHA-256's 256-bit output provides tremendous collision resistance—it would take more energy than the sun produces to brute-force it. Additionally, SHA-256 uses a more robust algorithm with better mixing properties, making mathematical attacks harder. Research into weaknesses has been extensive, with no practical attacks discovered despite two decades of scrutiny.
Q: Should I use SHA-512 instead of SHA-256 for everything?
A: SHA-256 is sufficient for most applications. SHA-512 provides extra security margin but uses more computational resources and produces larger outputs. Use SHA-256 as default, reserve SHA-512 for high-security scenarios or when extreme paranoia is warranted. The difference in security between SHA-256 and SHA-512 is not practically meaningful for most applications.
Q: Is hashing the same as encryption?
A: No, they're fundamentally different. Encryption can be reversed with the right key—you encrypt data to keep it secret, then decrypt it to read it. Hashing cannot be reversed—you hash data for integrity verification or password storage. You never need to recover the original from a hash. Encryption is reversible; hashing is not.
Q: Do I need salt with these hash functions?
A: For password hashing, yes—always use salt. Salt is random data added to the password before hashing, ensuring two users with the same password have different hashes. This prevents rainbow table attacks. Use dedicated password hashing libraries (bcrypt, scrypt) that handle salting automatically. For other hashing purposes like file integrity verification, salt isn't needed.
Choose the Right Hash Function: Use SHA-256 or better for security purposes. Use MD5 or SHA-1 only for non-security checksums in controlled environments. Use bcrypt, scrypt, or Argon2 for passwords—never use general-purpose hashes. The right choice depends on the application, and getting it wrong has security consequences.
Don't Trust Hashes Over Insecure Channels: Hash verification only works if you can trust the hash value itself. Download hashes from the same source as files, over HTTPS, or from multiple independent sources. If the source providing both file and hash is compromised, both are compromised. Hash verification protects against accidental corruption and CDN errors, not malicious attackers with compromised sources.
Use Cryptographic Libraries: Don't implement cryptography yourself. Use well-tested libraries (crypto in Node.js, cryptography in Python, etc.). These libraries are audited by experts and updated when vulnerabilities are discovered. Homemade implementations are almost always weaker.
Test Hash Consistency: Hash the same data multiple times and verify results are identical. Hash slightly different data and verify results are completely different. Understanding how these functions behave helps you use them correctly in your applications.