Hash Generator

A cryptographic hash function takes an input of any size and produces a fixed-length output — 256 bits for SHA-256, regardless of whether the input was one character or one gigabyte — with two properties that make it useful: the same input always produces exactly the same output, and even a single-bit change to the input produces a completely different, unpredictable output rather than a slightly different one. This is what makes a hash useful for verification: comparing two hashes tells you with overwhelming confidence whether two pieces of data are identical, without needing to compare the data itself byte by byte.

What a hash function explicitly does not do is compress or represent the data in a way that could be reversed — it is a one-way function by design. There is no operation that takes a SHA-256 output and reconstructs the original input, which is fundamentally different from encoding schemes like Base64 that are trivially reversible.

A cryptographic hash is considered "broken" specifically when someone demonstrates a way to find two different inputs that produce the same output — a collision — faster than brute force would predict. Practical collision attacks against MD5 have existed since 2004, and a real, practical collision against SHA-1 was demonstrated in 2017, which is why neither should be trusted anywhere an adversary might deliberately try to forge matching data, such as digital signatures or certificate validation.

They remain in wide use anyway for a narrower, non-adversarial purpose: verifying that a downloaded file matches a checksum the publisher listed, or detecting accidental corruption during a transfer. Nobody is trying to deliberately construct a colliding file in that scenario, and both algorithms remain entirely reliable at catching accidental differences — the vulnerability is specifically about deliberate, engineered collisions, not everyday integrity checking.

SHA-256 and its relatives are deliberately fast — that speed is a feature for verifying downloads, where you want the checksum computed instantly, and a serious liability for password storage, where speed is exactly what an attacker wants. Modern consumer hardware can compute billions of SHA-256 hashes per second, which means a stolen database of raw SHA-256 password hashes can be brute-forced or checked against precomputed tables at enormous speed. Purpose-built password hashing algorithms like bcrypt, scrypt and Argon2 are deliberately slow and computationally expensive per attempt, specifically to make that same brute-force attack impractically slow even with significant computing power thrown at it — a fundamentally different design goal from a general-purpose checksum function.