Cryptographic Hash

A 160-bit hash function, RIPEMD-160 is primarily used in conjunction with SHA-256 in Bitcoin to create shorter, more manageable public key hashes (P2PKH addresses). The standard Bitcoin address creation process is: RIPEMD-160(SHA-256(public key)). It provides an additional layer of hashing for:

• Reduced address size compared to a raw SHA-256 hash.
• Defense mechanism against potential future breaks in a single hash algorithm.

MurmurHash is a fast, general-purpose non-cryptographic hash function. It is not secure against malicious attackers but is optimized for speed and distribution. In blockchain contexts, it is used for:

• Internal data structures like hash tables and bloom filters.
• Deterministic data shuffling where collision resistance is sufficient but cryptographic security is not required.
• A reminder that not all "hashing" in a codebase implies cryptographic security.

The security of a blockchain relies on these core cryptographic properties of its hash function:

• Collision Resistance: Infeasible to find two different inputs that produce the same hash. A break would invalidate blockchain integrity.
• Preimage Resistance: Given a hash output h, it's infeasible to find any input m such that hash(m) = h. Protects against reversing commitments.
• Second Preimage Resistance: Given input m1, it's infeasible to find a different input m2 with the same hash. Directly protects blockchain blocks and transactions.

Every block in a blockchain contains the cryptographic hash of its predecessor, creating an immutable, tamper-evident chain. The Merkle Tree root hash within a block cryptographically commits to all transactions, allowing nodes to efficiently verify that a specific transaction is included without downloading the entire block. Any alteration to a past block's data changes its hash, breaking the chain and signaling fraud.

In Proof-of-Work (PoW) blockchains like Bitcoin, miners compete to find a nonce value that, when hashed with the block header, produces an output below a specific target (the difficulty). This process, called hashing power, secures the network by making block creation computationally expensive. The SHA-256 hash function's properties ensure the solution is hard to find but easy for others to verify.

Cryptocurrency addresses are derived from public keys using hash functions. For example, a Bitcoin address is created by applying SHA-256, then RIPEMD-160 to the public key, and finally encoding with Base58Check. This process:

• Creates a compact, human-readable identifier.
• Adds a checksum via hashing to prevent typos.
• Provides a layer of abstraction, enhancing privacy before the public key is revealed in a transaction.

Hashes enable commitment schemes where data can be verified without full disclosure. A common pattern is to publish only the hash of data on-chain (e.g., in a smart contract), while the actual data is stored off-chain. Later, users can prove they possess the data by presenting it; the contract re-computes its hash and verifies it matches the on-chain commitment. This is fundamental for layer-2 scaling solutions and verifiable randomness.

Ethereum uses a Patricia Merkle Trie to represent its global state. The root hash of this trie is stored in the block header. Any change to an account's balance, contract code, or storage slot changes the state root. Light clients can trustlessly verify specific state information (e.g., an account's ETH balance) by requesting a Merkle proof—a path of hashes from the data to the known, trusted state root hash.

Hash functions generate deterministic, unique identifiers for on-chain objects. Examples include:

• Transaction ID (TXID): The hash of a transaction's serialized data.
• Block Hash: The hash of the block header.
• Contract Address: In Ethereum, a new contract's address is derived from the creator's address and their transaction nonce, often via keccak256 hashing.
• Content Addressing: Systems like IPFS use hashes (CIDs) to uniquely identify files, a concept integrated into some blockchain storage solutions.

A hash function's ability to prevent two different inputs from producing the same output. A collision attack occurs when an adversary finds any two inputs x and y where x ≠ y but H(x) = H(y). This can break digital signatures and data integrity. The birthday paradox dictates that collisions are found in roughly 2^(n/2) attempts for an n-bit hash, making longer outputs (e.g., SHA-256's 256 bits) essential. The discovery of practical collisions in older functions like MD5 and SHA-1 led to their deprecation.

Two foundational security properties:

• Preimage Resistance (One-Way): Given an output hash h, it should be computationally infeasible to find any input x such that H(x) = h. This protects passwords and commitment schemes.
• Second Preimage Resistance: Given a specific input x1, it should be infeasible to find a different input x2 with the same hash (H(x1) = H(x2)). This is crucial for ensuring a blockchain block or transaction cannot be replaced with a malicious alternative while keeping the same hash pointer. Breaking second preimage resistance is generally considered more feasible than breaking collision resistance for a given hash function.

A vulnerability specific to the Merkle–Damgård construction (used in SHA-256, MD5). An attacker who knows H(message) and the length of the original message can compute H(message || padding || extension) without knowing the original message content. This breaks naive implementations of HMAC and certain authentication schemes. Modern protocols use HMAC correctly or employ hash functions like SHA-3 (Keccak), which uses a sponge construction immune to this attack.

Quantum algorithms pose a future threat to hash functions. Grover's algorithm provides a quadratic speedup for searching unstructured databases. This effectively halves the cryptographic strength of a hash function, reducing the security of a 256-bit hash to 128 bits of classical security. While still formidable, this necessitates the migration to longer hash outputs (e.g., SHA-384, SHA-512) or post-quantum cryptographic hash functions in the quantum era. It primarily threatens preimage resistance.

Flaws arise not from the hash function's design, but from its implementation:

• Timing Attacks: Variations in computation time can leak information about the input data.
• Fault Injection: Introducing hardware glitches (e.g., voltage spikes) to cause incorrect hash computations, potentially enabling signature forgeries.
• Resource Exhaustion (DoS): Crafting inputs that cause excessive computation (e.g., triggering many iterations in a password hash like bcrypt) to deny service. Secure, constant-time implementations and rigorous code audits are critical mitigations.

Cryptographic hash functions have a lifecycle. As computational power increases and new cryptanalysis techniques emerge, functions become vulnerable. MD5 (broken for collisions) and SHA-1 (theoretical breaks made practical) are canonical examples of deprecated hashes. Blockchain systems face a significant migration challenge: a hash function baked into a consensus protocol or a smart contract's immutable logic cannot be easily upgraded without a hard fork. This underscores the importance of selecting future-proof, well-vetted algorithms like SHA-256 or SHA-3 at inception.

A data structure that uses cryptographic hashes to efficiently and securely verify the contents of large datasets. It aggregates transaction data in a blockchain block into a single root hash.

• How it works: Leaf nodes are hashes of individual data blocks (e.g., transactions). Parent nodes are hashes of their children, culminating in a single Merkle Root.
• Benefit: Allows for light clients to verify transaction inclusion without downloading the entire blockchain.

A cryptographic scheme for verifying the authenticity and integrity of a message, software, or digital document. It proves a piece of data was created by a known sender and was not altered in transit.

• Components: Created using a private key to sign a hash of the message. Verified by anyone with the corresponding public key.
• Blockchain Role: Used to authorize transactions (e.g., an ECDSA signature on a Bitcoin transaction) and prove ownership of assets.

A cryptographic system that uses pairs of keys: a public key, which may be disseminated widely, and a private key, which is kept secret. It enables secure communication and digital identities.

• Core Functions: Encryption (data encrypted with public key, decrypted with private key) and Digital Signatures.
• Blockchain Identity: A user's wallet address is typically derived from their public key, forming the basis for pseudonymous on-chain identity.

"Number used once" – a random or semi-random number that is used only one time in a cryptographic communication. Its primary purpose is to ensure old communications cannot be reused in replay attacks.

• In Proof-of-Work: Miners repeatedly change a nonce in a block header to generate a hash that meets the network's difficulty target.
• In Accounts: Used in transaction protocols (like Ethereum's transaction nonce) to ensure order and uniqueness, preventing double-spending.