RIPEMD-160: The Hash Function That Shortens Bitcoin Addresses

2.1 Overview of the RIPEMD-160 Algorithm

RIPEMD-160 processes data in 512-bit chunks (64 bytes). It uses a unique parallel processing design with two independent lines of 5 registers each (10 registers total).

2.2 MD5 Initial Values (The Starting Point)

RIPEMD-160 uses the same initial values as MD5 for compatibility. These values are the fractional parts of the square roots of 2, 3, 5, and 7, converted to 32-bit integers.

2.3 The Two Parallel Lines (Left and Right)

RIPEMD-160 processes data on two independent lines simultaneously:

2.4 Step 1: Input Padding

The input message must be padded to a multiple of 512 bits (same as SHA-256, but with different endianness).

2.5 Step 2: Message Decomposition

The padded message is split into 512-bit chunks. Each chunk is divided into 16 words of 32 bits each.

2.6 Step 3: The 5 Boolean Functions

Each round uses a different Boolean function. These functions are applied to three 32-bit inputs and produce one 32-bit output.

2.7 Step 4: Round Constants K[r]

Five constants, one for each round, derived from the cube roots of small integers:

2.8 Step 5: Rotation Amounts s[j]

Each of the 80 steps uses a specific rotation amount. The left and right lines use different rotation schedules.

2.9 Step 6: Message Word Order (Permutations)

The 16 message words are permuted differently for each round. This ensures each word affects the hash in multiple ways.

2.10 Step 7: The Round Function (Per-Step)

Each step updates the registers on both lines independently:

2.11 Step 8: The 5 Rounds (80 Steps Total)

Each round consists of 16 steps with:

• A specific Boolean function (F1 through F5)
• A specific constant (K[0] through K[4])
• A specific rotation schedule
• A specific word permutation

2.12 Step 9: Combining Left and Right Results

After all 80 steps, the results from both lines are added to the initial values:

2.13 Why Parallel Design Is More Secure

2.14 Complete Example: Hash of "abc" (Step by Step)

Let's walk through the entire RIPEMD-160 algorithm using the message "abc" — the classic test vector. This example shows every step from the original ASCII characters to the final 160-bit hash.

Step 2.14.1: Original Message (ASCII to Binary)

The message "abc" consists of three ASCII characters. Let's convert each to binary:

Step 2.14.2: Padding (to 512 bits)

Rule 1: Append a '1' bit

Rule 2: Append zeros until length ≡ 448 (mod 512)

Current length: 25 bits. We need 448 bits. Zeros to add: 448 - 25 = 423 zeros

Rule 3: Append original length as 64-bit integer (little-endian!)

Original length = 24 bits = 0x18 in hex

Final padded message (512 bits / 64 bytes):

Step 2.14.3: Message Decomposition (16 words of 32 bits)

The 512-bit block is split into 16 words (X[0] to X[15]), each 32 bits (4 bytes):

Step 2.14.4: Initialize Working Variables (10 registers)

The initial values for both left and right lines (from MD5):

Step 2.14.5: Round Constants Used

Step 2.14.6: Round 1 — First Few Steps (Left Line)

Round 1 uses: Function F1 (XOR), Constant K[0] = 0x00000000, Rotation schedule for steps 0-15

Step 2.14.7: After All 80 Steps (Both Lines)

After processing all 5 rounds (80 steps) on both the left and right lines, we have final values for all 10 registers.

Step 2.14.8: Combining Left and Right Results

The final hash is computed by adding the initial values, left line results, and right line results:

Step 2.14.9: The Final 160-bit Hash

After all calculations, the RIPEMD-160 hash of "abc" is:

import hashlib

# Compute RIPEMD-160 hash of "abc"
hash_result = hashlib.new('ripemd160', b"abc").hexdigest()
print(f"RIPEMD-160('abc') = {hash_result}")
# Output: 8eb208f7e05d987a9b044a8e98c6b087f15a0bfc

Step 2.14.10: Comparison — RIPEMD-160 vs SHA-1

Both produce 40-character hashes, but they are completely different:

3.1 Installation (No external dependencies needed)

The code below uses only Python's built-in libraries. RIPEMD-160 is available in Python's hashlib module.

3.2 Simple Hash Example

import hashlib

# Basic RIPEMD-160 hash
message = b"Hello, Bitcoin!"
hash_result = hashlib.new('ripemd160', message).hexdigest()
print(f"RIPEMD-160: {hash_result}")

# Bitcoin's HASH160 (SHA-256 then RIPEMD-160)
def hash160(data):
    sha256_hash = hashlib.sha256(data).digest()
    return hashlib.new('ripemd160', sha256_hash).hexdigest()

bitcoin_hash = hash160(b"Hello, Bitcoin!")
print(f"HASH160: {bitcoin_hash}")

3.3 Complete Implementation

#!/usr/bin/env python3
"""
RIPEMD-160 Implementation in Python
Uses hashlib (built-in) for simplicity
"""

import hashlib
import struct

def ripemd160(data):
    """RIPEMD-160 hash function"""
    if isinstance(data, str):
        data = data.encode('utf-8')
    return hashlib.new('ripemd160', data).hexdigest()

def hash160(data):
    """Bitcoin's HASH160: SHA-256 then RIPEMD-160"""
    if isinstance(data, str):
        data = data.encode('utf-8')
    
    # Step 1: SHA-256
    sha256_hash = hashlib.sha256(data).digest()
    
    # Step 2: RIPEMD-160
    return hashlib.new('ripemd160', sha256_hash).hexdigest()

def public_key_to_address(public_key_hex, version_byte='00'):
    """
    Convert a public key to a Bitcoin address
    This demonstrates the complete address generation process
    """
    # Step 1: SHA-256
    sha256_hash = hashlib.sha256(bytes.fromhex(public_key_hex)).digest()
    
    # Step 2: RIPEMD-160 (HASH160)
    ripemd160_hash = hashlib.new('ripemd160', sha256_hash).digest()
    
    # Step 3: Add version byte
    versioned = bytes.fromhex(version_byte) + ripemd160_hash
    
    # Step 4: Double SHA-256 for checksum
    checksum = hashlib.sha256(hashlib.sha256(versioned).digest()).digest()[:4]
    
    # Step 5: Base58Check encode (simplified)
    import base58
    return base58.b58encode(versioned + checksum).decode()

if __name__ == '__main__':
    # Test vectors
    test_cases = [
        ("", "9c1185a5c5e9fc54612808977ee8f548b2258d31"),
        ("a", "0bdc9d2d256b3ee9daae347be6f4dc835a467ffe"),
        ("abc", "8eb208f7e05d987a9b044a8e98c6b087f15a0bfc"),
        ("message digest", "5d0689ef49d2fae572b881b123a85ffa21595f36"),
    ]
    
    print("Test Vectors:")
    for message, expected in test_cases:
        result = ripemd160(message)
        print(f"  RIPEMD-160('{message}') = {result}")
        print(f"    Expected: {expected}")
        print(f"    Match: {result == expected}\n")
    
    # Demonstrate HASH160
    print("Bitcoin HASH160 Example:")
    test_data = b"Hello Bitcoin"
    print(f"  Input: {test_data.decode()}")
    print(f"  SHA-256: {hashlib.sha256(test_data).hexdigest()}")
    print(f"  HASH160: {hash160(test_data)}")

3.4 Test Vectors for Verification

3.5 Running the Code