💡 The Hash Function Definition

Mathematical Notation:

H: {0,1}* → {0,1}^n

Translation: Hash function H takes any input (arbitrary bit string) and produces fixed-length output (n bits)

For SHA-256: H(input) → 256-bit output (64 hexadecimal characters)

For Keccak-256: H(input) → 256-bit output (64 hexadecimal characters)

Key Property: The function is deterministic (same input always produces same output) but one-way (computationally infeasible to reverse).

🔑 The Five Pillars of Cryptographic Hashing

1. Determinism (Repeatability)

Property: The same input always produces the same output, guaranteed.

Mathematical Statement: ∀ input x: H(x) = H(x) (always)

Blockchain Use: Enables independent verification—anyone can compute the hash and confirm it matches. No random elements, no timestamps, no external dependencies.

Example: SHA-256(“Bitcoin”) will always equal b4056df6691f8dc72e56302ddad345d65fead3ead9299609a826e2344eb63aa4 on any computer, at any time, forever.

2. Pre-Image Resistance (One-Way Property)

Property: Given hash output H(x), it is computationally infeasible to find input x.

Mathematical Statement: Given h, finding x such that H(x) = h requires ~2^n operations (for n-bit hash)

Security Level (SHA-256): 2^256 ≈ 1.16 × 10^77 operations—would take billions of years with all of Earth’s computing power

Blockchain Use: Allows public posting of hashes without revealing the underlying data. Merkle roots, commitment schemes, and address derivation depend on this.

3. Second Pre-Image Resistance (Weak Collision Resistance)

Property: Given input x and its hash H(x), it is computationally infeasible to find a different input x’ where H(x’) = H(x).

Mathematical Statement: Given x, finding x’ ≠ x where H(x’) = H(x) requires ~2^n operations

Attack Scenario: If you could find x’ matching H(x), you could substitute transaction x’ for x while maintaining the same hash—forging blockchain history.

Blockchain Use: Ensures signed transactions cannot be maliciously replaced with different transactions having the same hash.

4. Collision Resistance (Strong Collision Resistance)

Property: It is computationally infeasible to find any two different inputs x and x’ where H(x) = H(x’).

Mathematical Statement: Finding any pair (x, x’) where x ≠ x’ and H(x) = H(x’) requires ~2^(n/2) operations (Birthday Paradox)

Security Level (SHA-256): 2^128 ≈ 3.4 × 10^38 operations—still computationally impossible with current technology

Blockchain Use: Critical for block integrity. If collisions were feasible, attackers could create alternate transaction histories with identical Merkle roots.

5. Avalanche Effect (Diffusion)

Property: A small change in input produces a large, unpredictable change in output. Ideally, flipping one input bit changes ~50% of output bits.

Mathematical Statement: For random input changes, Hamming distance between outputs ≈ n/2 bits (for n-bit hash)

Security Implication: Prevents statistical analysis. Can’t infer input structure from output patterns.

Blockchain Use: Makes mining unpredictable—can’t optimize nonce selection. Ensures Merkle tree changes cascade completely with any leaf modification.

⚙️ SHA-256 Processing Steps

1. Message Padding:
   • Append ‘1’ bit, then ‘0’ bits until length ≡ 448 (mod 512)
   • Append 64-bit representation of original message length
   • Result: Message length is multiple of 512 bits
2. Initialize Hash Values (H0-H7):
   • Eight 32-bit words initialized to fractional parts of square roots of first 8 primes
   • H0 = 0x6a09e667, H1 = 0xbb67ae85, … (constants prevent backdoors)
3. Process Message Blocks:
   • For each 512-bit block, perform 64 rounds of transformation
   • Each round uses bitwise operations (AND, XOR, NOT, rotate, shift)
   • Round constants derived from cube roots of first 64 primes (nothing-up-my-sleeve numbers)
4. Compression Function:
   • Eight working variables (a, b, c, d, e, f, g, h) undergo 64 rounds of mixing
   • Each round: non-linear functions, modular addition, bitwise operations
   • Final values added back to hash state (Davies-Meyer)
5. Concatenate Final Hash:
   • After all blocks processed, concatenate H0 || H1 || … || H7
   • Result: 256-bit (32-byte) hash digest

🧽 The Sponge Metaphor

Analogy: Imagine a sponge that absorbs water (input) and can be squeezed to release water (output). The sponge has two zones: absorbing zone and squeezing zone.

Keccak Sponge Phases:

1. Absorbing Phase:
   • Input message split into r-bit blocks (rate)
   • Each block XORed into state, then permutation applied
   • Capacity c bits remain untouched (security margin)
   • For Keccak-256: r = 1088 bits, c = 512 bits (r + c = 1600)
2. Permutation (Keccak-f):
   • 24 rounds of transformations on 1600-bit state
   • Each round: θ (theta), ρ (rho), π (pi), χ (chi), ι (iota) operations
   • Operations work on 5×5 array of 64-bit lanes
3. Squeezing Phase:
   • Extract r bits from state as output
   • If more output needed, apply permutation and extract again
   • For Keccak-256: extract 256 bits once

Security: Capacity c determines security level. c/2 bits of security against all attacks. Keccak-256 has 512-bit capacity → 256-bit security.

⛓️ The Blockchain Data Structure

Mechanism: Each block contains hash of previous block’s header in its own header.

Block_N = { ..., prev_hash: H(Block_N-1_header), ... }

Immutability Property: Changing any data in Block_N-1 changes its hash → invalidates Block_N’s prev_hash → invalidates Block_N+1’s prev_hash → cascades to tip of chain.

Security: To alter history at Block_N, attacker must recompute all subsequent blocks (N+1, N+2, …, current) faster than honest network—requires >51% hash power.

Example: Bitcoin block 500,000 contains hash of block 499,999. Any change to block 499,999 would require re-mining 250,000+ subsequent blocks—impossible without controlling entire network.

⛏️ Mining Algorithm

Goal: Find nonce such that H(block_header || nonce) < target

Target Adjustment: Difficulty adjusted every 2016 blocks (~2 weeks) to maintain 10-minute average

Current Difficulty: ~62 trillion (target = 0x00000000000000000000xxxx…)

Hash Requirements: ~19-20 leading zero bits (1 in 2^75 hashes succeed)

Critical Property: Solution verification is instant (single hash), but finding solution requires 2^75 attempts on average. Asymmetry enables decentralized consensus.

₿ Bitcoin Address Derivation Process

1. Generate Private Key: 256-bit random number
2. Derive Public Key: PubKey = PrivKey × G (elliptic curve point multiplication on secp256k1)
3. SHA-256 Hash: hash1 = SHA-256(PubKey)
4. RIPEMD-160 Hash: hash2 = RIPEMD-160(hash1) → 160-bit (20-byte) hash
5. Add Version Byte: versioned_hash = 0x00 || hash2 (mainnet P2PKH)
6. Checksum: checksum = first 4 bytes of SHA-256(SHA-256(versioned_hash))
7. Final Address: address = Base58(versioned_hash || checksum)

Example:

Private Key: E9873D79C6D87DC0FB6A5778633389F4453213303DA61F20BD67FC233AA33262
Public Key: 04F0C2AA5CC4DC7B79E1A4D15D1B3F1A1A8D8F7C... (65 bytes)
Address: 1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa (Satoshi's address)

⟠ Ethereum Address Derivation Process

1. Generate Private Key: 256-bit random number
2. Derive Public Key: PubKey = PrivKey × G (secp256k1, same as Bitcoin)
3. Keccak-256 Hash: hash = Keccak-256(PubKey) — Note: 64-byte uncompressed public key, exclude 0x04 prefix
4. Take Last 20 Bytes: address = last 20 bytes of hash
5. Add Checksum (EIP-55): Mixed-case hex encoding based on Keccak-256(address)
6. Prefix: Add 0x prefix → final address: 0x…

Example:

Private Key: 0x4c0883a69102937d6231471b5dbb6204fe512961708279f8b4d3a9f3d9f9c5d2
Public Key: 0x04F0C2AA5CC4DC7B79E1A4D15D1B3F1A... (128 hex chars)
Keccak-256(PubKey): 0x...d5b32ef8e9ae8c9e58e7a5f4c8b9c3d2e1f0a9b8c7d6e5f4a3b2c1d0e9f8a7b6
Address: 0xd5b32ef8e9ae8c9e58e7a5f4c8b9c3d2e1f0a9b8 (last 20 bytes)

🌍 Practical Consequences

• No Central Authority Can Alter History: Even blockchain creators cannot retroactively change records
• Verifiable Audit Trail: Anyone can independently verify entire transaction history from genesis
• Settlement Finality: After sufficient confirmations (6 for Bitcoin), reversal is economically impossible
• Legal Implications: Immutable records can serve as evidence, but errors/fraud cannot be corrected
• Double-Spend Prevention: Cannot create conflicting transaction histories due to cryptographic linking