Python hashlib Module: Hashing Files and Strings

import hashlib
 
# Hash a string
text = "Hello, World!"
hash_obj = hashlib.sha256(text.encode())
 
# Get the digest
print(hash_obj.hexdigest())
# 'dffd6021bb2bd5b0af676290809ec3a53191dd81c7f70a4b28688a362182986f'
 
print(hash_obj.digest())  # Raw bytes

# SHA-256 (recommended for most uses)
hashlib.sha256(data)
 
# SHA-512 (longer hash, more security margin)
hashlib.sha512(data)
 
# SHA-1 (legacy, avoid for security)
hashlib.sha1(data)
 
# MD5 (broken for security, fine for checksums)
hashlib.md5(data)
 
# List all available
print(hashlib.algorithms_available)

def file_hash(filepath: str, algorithm: str = 'sha256') -> str:
    """Calculate hash of a file."""
    h = hashlib.new(algorithm)
    
    with open(filepath, 'rb') as f:
        while chunk := f.read(8192):
            h.update(chunk)
    
    return h.hexdigest()
 
# Usage
checksum = file_hash('large_file.iso')
print(checksum)

def verify_checksum(filepath: str, expected: str, algorithm: str = 'sha256') -> bool:
    """Verify file matches expected checksum."""
    actual = file_hash(filepath, algorithm)
    return actual.lower() == expected.lower()
 
# Usage
if verify_checksum('download.zip', 'abc123...'):
    print("File integrity verified")
else:
    print("Checksum mismatch!")

h = hashlib.sha256()
h.update(b"Hello, ")
h.update(b"World!")
print(h.hexdigest())
# Same as sha256(b"Hello, World!")

import hashlib
 
def hash_stream(stream) -> str:
    """Hash data from any iterable."""
    h = hashlib.sha256()
    for chunk in stream:
        h.update(chunk)
    return h.hexdigest()

# BAD: vulnerable to rainbow tables
password_hash = hashlib.sha256(password.encode()).hexdigest()

import hashlib
import secrets
 
def hash_password(password: str) -> tuple[str, str]:
    """Hash password with PBKDF2 (stdlib option)."""
    salt = secrets.token_hex(16)
    key = hashlib.pbkdf2_hmac(
        'sha256',
        password.encode(),
        salt.encode(),
        iterations=100_000
    )
    return key.hex(), salt
 
def verify_password(password: str, key_hex: str, salt: str) -> bool:
    """Verify password against stored hash."""
    new_key = hashlib.pbkdf2_hmac(
        'sha256',
        password.encode(),
        salt.encode(),
        iterations=100_000
    )
    return secrets.compare_digest(new_key.hex(), key_hex)

import hmac
import hashlib
 
def sign_message(message: bytes, secret: bytes) -> str:
    """Create HMAC signature."""
    return hmac.new(secret, message, hashlib.sha256).hexdigest()
 
def verify_signature(message: bytes, signature: str, secret: bytes) -> bool:
    """Verify HMAC signature."""
    expected = sign_message(message, secret)
    return hmac.compare_digest(signature, expected)
 
# Usage
secret = b'my-secret-key'
message = b'{"user": "alice", "action": "transfer"}'
 
sig = sign_message(message, secret)
print(verify_signature(message, sig, secret))  # True

def content_address(data: bytes) -> str:
    """Generate content-based identifier."""
    return hashlib.sha256(data).hexdigest()[:16]
 
# Same content always gets same address
addr1 = content_address(b"Hello")
addr2 = content_address(b"Hello")
assert addr1 == addr2