> For the complete documentation index, see [llms.txt](https://alham-rizvi.gitbook.io/alhamrizvi/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://alham-rizvi.gitbook.io/alhamrizvi/cryptography/hashing/03.-properties.md). # Hash Properties When people say “a cryptographic hash function is secure,” they are referring to a set of properties. These are not random rules. Each one exists to prevent a specific type of attack. If even one of these properties weakens, the entire system using that hash can break. ## 1. Preimage Resistance Start with this situation: You are given a hash value: ``` h = H(m) ``` Your goal is to find the original message `m`. Preimage resistance means: > Given only `h`, it should be computationally infeasible to find any `m` such that `H(m) = h`. *** ### Intuition Imagine someone gives you: ``` 5d41402abc4b2a76b9719d911017c592 ``` There should be no direct way to recover: ``` hello ``` Not because it is “hidden,” but because the transformation destroys information. *** ### Why this exists If preimage resistance fails: * Password hashes can be reversed instantly * API keys, tokens, and secrets become useless * Entire authentication systems collapse ### Important clarification You never actually “reverse” a hash in practice. What you do is: ``` guess → hash → compare ``` So breaking preimage resistance is not about reversing the function, but about making guessing efficient. *** ## 2. Second Preimage Resistance Now assume you already know a message: ``` m1 ``` You compute: ``` h = H(m1) ``` Second preimage resistance means: > It should be infeasible to find a different message `m2 ≠ m1` such that: > > ``` > H(m1) = H(m2) > ``` *** ### Intuition You upload a file. The system stores its hash. An attacker should not be able to create a different file that has the same hash, because then: * They could replace your file * The system would not detect the change *** ### Real-world importance This protects: * File integrity checks * Software downloads * Backup verification * Signed documents *** ### Difference from preimage * Preimage: given hash → find message * Second preimage: given message → find another message with same hash This distinction becomes important in attacks. *** ## 3. Collision Resistance This is stronger and more dangerous when broken. Collision resistance means: > It should be infeasible to find *any* two different messages: > > ``` > m1 ≠ m2 > ``` > > such that: > > ``` > H(m1) = H(m2) > ``` *** ### Key difference * In second preimage, one message is fixed * In collision, attacker controls both messages This gives attackers much more freedom. *** ### Why collisions must exist Hash functions map: ``` infinite inputs → fixed-size outputs ``` For example: * Infinite possible strings * Only 2^256 possible SHA-256 outputs So mathematically: ``` collisions are guaranteed to exist ``` Security depends on making them extremely hard to find. *** ### Real-world failure * MD5 collisions are practical * SHA-1 collisions are practical This allowed real attacks like: * forging certificates * creating two different files with the same signature *** ## 4. Avalanche Effect This property is about unpredictability. It means: > A small change in input should completely change the output. *** ### Example ``` hello → hash1 hello1 → completely different hash ``` Not slightly different. Completely unrelated. *** ### Why this matters Without this property: * Attackers could predict how changes affect hashes * They could gradually “adjust” inputs to reach a target hash Avalanche effect ensures: * no visible pattern * no partial information leakage *** ## 5. Deterministic Behavior This one is simple but essential. > The same input must always produce the same output. *** ### Why it matters Without this: * You cannot verify passwords * You cannot check file integrity * Systems become inconsistent *** ### Important note Hashing itself is deterministic, but systems may add randomness using: * salts * nonces This is done outside the hash function. *** ## 6. Fixed Output Length No matter how large or small the input is: ``` output length is constant ``` *** ### Example * SHA-256 always produces 256 bits * Even if input is 1 byte or 1 GB *** ### Why this matters * Makes storage predictable * Prevents leaking input size * Standardizes security level *** ## 7. Fast Computation Hash functions are designed to be fast. *** ### Why this is useful * Quick verification * Efficient systems * Real-time applications *** ### Why this is also dangerous Fast hashing makes brute force easier. That’s why password systems do not use plain hashes like SHA-256. They use: * bcrypt * scrypt * argon2 These are intentionally slow. *** ## Putting All Properties Together Each property defends against a different class of attack: * Preimage resistance → prevents reversing hashes * Second preimage → prevents replacing known data * Collision resistance → prevents forging pairs * Avalanche effect → prevents prediction * Deterministic → ensures consistency * Fixed length → standardizes output * Fast computation → enables usage (but needs control) *** ## The Core Insight A hash function compresses information: ``` large input space → fixed output space ``` Because of this: * Information is lost * Multiple inputs map to the same output * Reversal is impossible in general Security comes from making it computationally infeasible to exploit these facts. *** ## CTF Perspective When you see a hash, you should not think: “Can I reverse this?” You should think: * What type of hash is this? * Is it weak (MD5, SHA-1)? * Is there a salt? * Is the input small? * Can I guess it? * Is there a structural weakness (length extension, collisions)? Hashing is not about hiding data. It is about: * representing data uniquely * verifying data efficiently * making recovery computationally impractical Once you internalize this, the next topics—like attacks and real exploitation—start making sense instead of feeling random. --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter: ``` GET https://alham-rizvi.gitbook.io/alhamrizvi/cryptography/hashing/03.-properties.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.