SHA-256: The Cryptographic Hash Function That Secures Bitcoin

import hashlib

# Single SHA-256
message = b"Hello, Bitcoin!"
single_hash = hashlib.sha256(message).hexdigest()
print(f"Single SHA-256: {single_hash}")

# Double SHA-256 (Bitcoin standard)
double_hash = hashlib.sha256(hashlib.sha256(message).digest()).hexdigest()
print(f"Double SHA-256: {double_hash}")

# Demonstrating the avalanche effect
msg1 = b"Bitcoin"
msg2 = b"bitcoin"  # Only 'B' vs 'b' changed

hash1 = hashlib.sha256(msg1).hexdigest()
hash2 = hashlib.sha256(msg2).hexdigest()
print(f"\n'Bitcoin' → {hash1[:32]}...")
print(f"'bitcoin' → {hash2[:32]}...")

#!/usr/bin/env python3
"""
Complete Pure Python SHA-256 Implementation
No external dependencies — uses only built-in libraries
"""

import struct

# Initial hash values (first 32 bits of fractional parts of √primes)
H = [
    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
    0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
]

# Round constants (first 32 bits of fractional parts of ∛primes)
K = [
    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1,
    0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
    0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786,
    0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147,
    0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
    0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b,
    0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a,
    0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
    0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
]

def rotr(x, n):
    """Rotate right (circular right shift)"""
    return ((x >> n) | (x << (32 - n))) & 0xFFFFFFFF

def shr(x, n):
    """Shift right (zeros enter from left)"""
    return (x >> n) & 0xFFFFFFFF

def pad_message(message):
    """Pad message to 512-bit chunks"""
    ml = len(message) * 8
    message += b'\x80'
    
    while (len(message) * 8) % 512 != 448:
        message += b'\x00'
    
    message += struct.pack('>Q', ml)
    return message

def sha256(message):
    """Pure Python SHA-256 implementation"""
    if isinstance(message, str):
        message = message.encode('utf-8')
    
    message = pad_message(message)
    h = H.copy()
    
    for i in range(0, len(message), 64):
        chunk = message[i:i+64]
        w = list(struct.unpack('>16L', chunk))
        
        # Message schedule: expand to 64 words
        for t in range(16, 64):
            s0 = rotr(w[t-15], 7) ^ rotr(w[t-15], 18) ^ shr(w[t-15], 3)
            s1 = rotr(w[t-2], 17) ^ rotr(w[t-2], 19) ^ shr(w[t-2], 10)
            w.append((w[t-16] + s0 + w[t-7] + s1) & 0xFFFFFFFF)
        
        # Initialize working variables
        a, b, c, d, e, f, g, hh = h
        
        # Compression function (64 rounds)
        for t in range(64):
            s1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25)
            ch = (e & f) ^ ((~e) & g)
            temp1 = (hh + s1 + ch + K[t] + w[t]) & 0xFFFFFFFF
            
            s0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)
            maj = (a & b) ^ (a & c) ^ (b & c)
            temp2 = (s0 + maj) & 0xFFFFFFFF
            
            # The great shuffle
            hh, g, f = g, f, e
            e = (d + temp1) & 0xFFFFFFFF
            d, c, b = c, b, a
            a = (temp1 + temp2) & 0xFFFFFFFF
        
        # Feed-forward: add to the hash
        h = [
            (h[0] + a) & 0xFFFFFFFF,
            (h[1] + b) & 0xFFFFFFFF,
            (h[2] + c) & 0xFFFFFFFF,
            (h[3] + d) & 0xFFFFFFFF,
            (h[4] + e) & 0xFFFFFFFF,
            (h[5] + f) & 0xFFFFFFFF,
            (h[6] + g) & 0xFFFFFFFF,
            (h[7] + hh) & 0xFFFFFFFF
        ]
    
    return ''.join(f'{x:08x}' for x in h)

if __name__ == '__main__':
    # Test the implementation
    import hashlib
    test = b"Hello, Bitcoin!"
    print(f"Input: {test.decode()}")
    print(f"SHA-256: {sha256(test)}")
    
    # Compare with hashlib
    expected = hashlib.sha256(test).hexdigest()
    print(f"Expected: {expected}")
    print(f"Match: {sha256(test) == expected}")