Hashing

A hash function takes input of any size and produces a fixed-size output called a digest. The same input always produces the same digest.

Crucially, hashing is a one-way operation. You cannot mathematically reverse a digest back into the original input. This is what makes hashes different from both encoding and encryption.

A cryptographic hash function should be:

• Deterministic: same input gives same output.
• Fast to compute (for general hashing) but ideally slow for password hashing.
• Preimage resistant: given a digest, you cannot find the input.
• Collision resistant: hard to find two inputs with the same digest.
• Avalanche effect: one bit change flips about half the output bits.

MD5 produces a 128-bit (32 hex character) digest. It is fast and historically common, but it is cryptographically broken: practical collision attacks exist.

Never use MD5 for security. You will still encounter it for file checksums and in legacy systems, which makes it a frequent target during assessments.

The SHA (Secure Hash Algorithm) family is more robust:

• SHA-1: 160-bit. Now considered broken (collision attack 'SHADOW HAMMER' / SHAttered). Avoid.
• SHA-2: includes SHA-256 and SHA-512. Widely used and currently secure.
• SHA-3: a newer design based on Keccak, an alternative to SHA-2.

Encryption is reversible with a key. Hashing is not reversible at all. This is exactly why hashing is used to store passwords: the server never needs the original.

When you log in, the server hashes what you typed and compares it to the stored hash. If they match, you are authenticated. The plaintext password is never stored.

Because hashing is deterministic, the digest of 'password' is the same for every user. Attackers precompute huge lookup tables of digest-to-plaintext called rainbow tables.

If two users share the same password, their stored hashes are identical, leaking that fact. Plain fast hashes like MD5 or SHA-256 alone are unsuitable for passwords.

A salt is a unique random value added to each password before hashing. This means:

• Identical passwords produce different hashes.
• Precomputed rainbow tables become useless.

The salt is stored alongside the hash; it is not secret. Its job is to make every hash unique, forcing attackers to crack each one individually.

bcrypt is designed specifically for password storage. It is intentionally slow and includes a configurable cost factor (work factor) that makes it slower as hardware improves.

A bcrypt hash embeds the algorithm, cost, and salt in one string. Slowness is a feature: it limits how fast attackers can guess.

Besides bcrypt, modern password hashing options include:

• scrypt: memory-hard, resists GPU and ASIC attacks.
• Argon2: winner of the Password Hashing Competition, tunable for time and memory. The recommended modern choice.
• PBKDF2: applies a fast hash many thousands of iterations; acceptable but weaker than the above.

Hashes are also used for integrity, not just passwords. An HMAC (Hash-based Message Authentication Code) combines a hash with a secret key to verify both integrity and authenticity of a message.

File checksums (often SHA-256) let you verify a download was not tampered with. As a hacker, mismatched checksums can reveal modified or malicious files.

As a hacker you constantly meet hashes:

• /etc/shadow on Linux stores salted password hashes, prefixed like $6$ (SHA-512) or $2b$ (bcrypt).
• Windows stores NTLM hashes in the SAM database.
• Web apps store hashed passwords in their user tables.

Recognizing the prefix instantly tells you the algorithm and your cracking strategy.

Pick the most secure choice for storing user passwords.

You now understand hashing:

• Hashing is a one-way, fixed-size, deterministic transformation, different from encoding and encryption.
• MD5 and SHA-1 are broken; use SHA-256 for general integrity.
• For passwords use slow, salted algorithms: bcrypt, scrypt, or Argon2.
• Salts defeat rainbow tables; HMAC adds keyed integrity.

Next you will explore symmetric and asymmetric encryption with AES and RSA.