Hash Function

A hash function is an algorithm that takes data of any size as input and transforms it into a fixed-size value, called a fingerprint or hash. This transformation is designed to be difficult to reverse: the original data generally cannot be recovered directly from the hash. Hash functions are used in computer science and cryptography, particularly to verify data integrity and protect passwords.

A hash is the fingerprint produced by a hash function.

A hash makes it possible to identify the original data with a high degree of probability without having to store the data itself. This allows a password to be verified without needing to know the password in plaintext.

Small changes in the input data lead to drastic changes in the resulting hash. This helps ensure data integrity and makes it possible to check whether data has been altered.

Hash functions process computer data in binary format and apply nonlinear, non-reversible operations with a strong avalanche effect (the result is very different even when the input data is very similar). The fingerprint is usually returned as hexadecimal characters.

Hashing is designed to be difficult to reverse. There is no decryption algorithm that directly recovers the original data, which is one reason why hash functions are used for password storage: the stored value is a verification hash rather than an encrypted password that can be decrypted.

Hash functions perform numerous operations to make the input data difficult to recover.

In theory, a brute-force attack can test all possible binary strings, but even a short 6-byte input message represents 281 trillion combinations. Even with fast processors capable of performing millions of hash calculations per second, testing every possibility to find an input matching a single hash can take days, months, or years.

However, users often reuse passwords and tend to favor certain characters and combinations. It is therefore possible to store likely strings and their corresponding hashes in a large dictionary. Rainbow tables are another technique: they use precomputed calculations and reduction chains to speed up certain searches for matches between hashes and possible inputs.

A hash collision occurs when two different inputs produce the same hash value. Since a hash has a fixed size while input data can have any length, collisions necessarily exist in theory.

Cryptographic hash functions are designed to make it extremely difficult to find two different inputs that produce the same hash. An exploitable collision can compromise certain cryptographic applications, including digital signatures. MD5 and SHA-1 are vulnerable to collision attacks and are no longer recommended for applications requiring collision resistance.

A dictionary attack, a brute-force attack, and a rainbow table are three different approaches for searching for an input that may produce a given hash.

A dictionary attack tests a list of words, common passwords, or likely combinations. It exploits the fact that users often choose predictable passwords.

A brute-force attack systematically tests every possible combination within a given search space. Its cost increases significantly with password length and complexity.

A rainbow table relies on precomputed calculations and reduction chains to speed up certain searches for matches between hashes and possible inputs. It requires prior computation and storage and is not simply an exhaustive list of every word and its hash.

A hash can take many forms, but the most common are hexadecimal strings: 32 characters from 0123456789abcdef for MD5, 40 for SHA-1, and 64 for SHA-256, etc.

The modular hash format used by some implementations of crypt() uses the $ symbol followed by fields that may indicate the algorithm used and its parameters.

dCode has a hash identifier.

Rainbow tables (huge databases of hash/password matches) continue to grow and accumulate passwords stolen from various websites. Combined with modern computing power, they can help recover short passwords in minutes or hours.

To counter this technique, it is recommended to add a salt (characters as a prefix or suffix) to the password. In this way, precomputed tables must be recalculated to account for the salt, which changes the resulting hashes. This is called salting, and the passwords are said to be salted.

Cost measures the resources required to calculate a hash. To make the creation of rainbow tables more difficult, the cost of certain password-hashing functions can be increased so that calculations take several milliseconds or even seconds, making attacks much more expensive.

bcrypt is a password-hashing algorithm with a configurable computational cost. Salt and cost parameters are built into the algorithm.

A secure password hash is calculated with a higher computational cost, making the process slower and more resource-intensive. This makes brute-force and dictionary attacks more difficult.

In contrast, a fast hash is calculated more quickly but may be more vulnerable to attacks when used for password storage. MD5 and SHA-1 also have cryptographic weaknesses and are no longer recommended for applications requiring collision resistance.

Dedicated password-hashing algorithms such as Argon2id, bcrypt, scrypt, or PBKDF2 are preferable for password storage.