Lab 14: Security Hardening

Time: 60 minutes | Level: Architect | Docker: docker run -it --rm python:3.11-slim bash

Overview

Production Python services must handle secrets safely, use constant-time comparisons, implement proper cryptography, and protect against deserialization attacks. This lab covers the full security hardening spectrum.

Prerequisites

pip install cryptography

Step 1: secrets Module — Cryptographically Secure Randomness

import secrets
import string

# Never use random module for security-sensitive values!
# import random  # WRONG for secrets

# Token generation
print("=== Secure Token Generation ===")
print(f"token_bytes(16): {secrets.token_bytes(16).hex()}")
print(f"token_hex(16):   {secrets.token_hex(16)}")      # 32 hex chars
print(f"token_urlsafe(16): {secrets.token_urlsafe(16)}")  # URL-safe base64

# API key generation
def generate_api_key(prefix: str = "sk") -> str:
    """Generate a Stripe-style API key."""
    token = secrets.token_urlsafe(32)
    return f"{prefix}_{token}"

print(f"\nAPI key: {generate_api_key('sk')}")
print(f"API key: {generate_api_key('pk')}")

# Secure random password
def generate_password(length: int = 16) -> str:
    alphabet = string.ascii_letters + string.digits + "!@#$%^&*"
    while True:
        pwd = ''.join(secrets.choice(alphabet) for _ in range(length))
        # Ensure complexity requirements
        has_upper = any(c.isupper() for c in pwd)
        has_digit = any(c.isdigit() for c in pwd)
        has_special = any(c in "!@#$%^&*" for c in pwd)
        if has_upper and has_digit and has_special:
            return pwd

print(f"Password: {generate_password(20)}")

# Secure comparison token (for URL-safe tokens)
def generate_csrf_token() -> str:
    return secrets.token_urlsafe(32)

token = generate_csrf_token()
print(f"CSRF token (length={len(token)}): {token[:20]}...")

💡 secrets.token_urlsafe(n) generates n bytes of randomness encoded as URL-safe base64. The resulting string is approximately n * 4/3 characters long.

Step 2: hmac.compare_digest — Timing-Safe Comparison

import hmac
import hashlib
import time

# WRONG: normal == comparison is vulnerable to timing attacks
def unsafe_compare(token1: str, token2: str) -> bool:
    return token1 == token2  # Short-circuits on first mismatch!

# RIGHT: constant-time comparison
def safe_compare(token1: str, token2: str) -> bool:
    return hmac.compare_digest(
        token1.encode() if isinstance(token1, str) else token1,
        token2.encode() if isinstance(token2, str) else token2,
    )

# Demonstrate timing difference (conceptual)
valid_token = secrets.token_hex(32)
invalid_token = "a" * len(valid_token)  # Same length, all wrong

# In practice, an attacker measures microsecond differences to guess chars
print(f"safe_compare(valid, valid): {safe_compare(valid_token, valid_token)}")
print(f"safe_compare(valid, invalid): {safe_compare(valid_token, invalid_token)}")

# HMAC authentication
def sign_message(key: bytes, message: bytes) -> bytes:
    return hmac.new(key, message, hashlib.sha256).digest()

def verify_message(key: bytes, message: bytes, signature: bytes) -> bool:
    expected = sign_message(key, message)
    return hmac.compare_digest(expected, signature)

secret_key = secrets.token_bytes(32)
message = b"user_id=12345&action=login&ts=1700000000"
sig = sign_message(secret_key, message)

print(f"\nHMAC signature: {sig.hex()[:32]}...")
print(f"Verify (valid): {verify_message(secret_key, message, sig)}")
print(f"Verify (tampered): {verify_message(secret_key, b'tampered', sig)}")

Step 3: hashlib — sha3_256 and blake2b

import hashlib
import time

# Password hashing (for demo — use bcrypt/argon2 in production!)
def hash_password_demo(password: str, salt: bytes = None) -> tuple[str, str]:
    """SHA3-256 password hash (demo only — use argon2 in production!)."""
    if salt is None:
        salt = secrets.token_bytes(32)
    
    # Key stretching: iterate to slow down brute force
    key = password.encode() + salt
    for _ in range(100_000):
        key = hashlib.sha3_256(key).digest()
    
    return key.hex(), salt.hex()

# BLAKE2b — faster, modern alternative
def fast_hash(data: bytes) -> str:
    return hashlib.blake2b(data, digest_size=32).digest().hex()

# File integrity verification
def file_fingerprint(content: bytes) -> dict:
    return {
        'sha3_256': hashlib.sha3_256(content).hexdigest(),
        'blake2b': hashlib.blake2b(content, digest_size=32).hexdigest(),
        'sha256': hashlib.sha256(content).hexdigest(),
    }

print("=== Hash Functions ===")
data = b"The quick brown fox jumps over the lazy dog"
fps = file_fingerprint(data)
for algo, digest in fps.items():
    print(f"  {algo}: {digest}")

print(f"\nBLAKE2b speed test:")
large_data = secrets.token_bytes(1024 * 1024)  # 1 MB

start = time.perf_counter()
for _ in range(10):
    hashlib.blake2b(large_data).hexdigest()
blake2b_time = time.perf_counter() - start

start = time.perf_counter()
for _ in range(10):
    hashlib.sha3_256(large_data).hexdigest()
sha3_time = time.perf_counter() - start

print(f"  BLAKE2b: {blake2b_time*100:.2f}ms/MB")
print(f"  SHA3-256: {sha3_time*100:.2f}ms/MB")

Step 4: Fernet Symmetric Encryption

from cryptography.fernet import Fernet, MultiFernet
import base64

# Generate key
key = Fernet.generate_key()
f = Fernet(key)

# Encrypt/decrypt
plaintext = b"sensitive data: api_key=sk-123456"
ciphertext = f.encrypt(plaintext)
decrypted = f.decrypt(ciphertext)

print(f"=== Fernet Symmetric Encryption ===")
print(f"Key (first 20): {key[:20].decode()}...")
print(f"Ciphertext (first 40): {ciphertext[:40]}...")
print(f"Decrypted: {decrypted}")
print(f"Round-trip OK: {plaintext == decrypted}")

# Key rotation with MultiFernet
old_key = Fernet.generate_key()
new_key = Fernet.generate_key()

old_f = Fernet(old_key)
multi_f = MultiFernet([Fernet(new_key), Fernet(old_key)])

# Encrypt with old key
old_ciphertext = old_f.encrypt(b"encrypted before key rotation")

# Decrypt with MultiFernet (tries new key first, falls back to old)
decrypted = multi_f.decrypt(old_ciphertext)
print(f"\nKey rotation: {decrypted}")

# Rotate: re-encrypt with new key
rotated = multi_f.rotate(old_ciphertext)
print(f"Rotated ciphertext differs: {rotated != old_ciphertext}")

📸 Verified Output:

Fernet encrypt/decrypt: OK
  Ciphertext (first 40): b'gAAAAABpqzOyZLC3tvnfgTInUVLJdQ25QDsNW1n4'...
  Decrypted: b'sensitive data: api_key=sk-123456'
RSA sign/verify: OK (signature 256 bytes)
HMAC compare_digest: True
token_hex(16): 88bd0729691362f83a86e9a00d8572af

Step 5: RSA Asymmetric Encryption

from cryptography.hazmat.primitives.asymmetric import rsa, padding
from cryptography.hazmat.primitives import hashes, serialization

# Generate RSA key pair
private_key = rsa.generate_private_key(
    public_exponent=65537,
    key_size=2048,
)
public_key = private_key.public_key()

# Encrypt with public key, decrypt with private
message = b"Secret payload for server"
ciphertext = public_key.encrypt(
    message,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None,
    )
)
decrypted = private_key.decrypt(
    ciphertext,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None,
    )
)
print(f"=== RSA Encryption ===")
print(f"Ciphertext size: {len(ciphertext)} bytes")
print(f"Decrypted: {decrypted}")
print(f"Round-trip OK: {message == decrypted}")

# Sign and verify
signature = private_key.sign(
    b"Python Architect Lab 14",
    padding.PKCS1v15(),
    hashes.SHA256(),
)
print(f"\n=== RSA Signing ===")
print(f"Signature size: {len(signature)} bytes")

try:
    public_key.verify(
        signature,
        b"Python Architect Lab 14",
        padding.PKCS1v15(),
        hashes.SHA256(),
    )
    print("Signature valid: ✓")
except Exception as e:
    print(f"Signature invalid: {e}")

# Serialize keys
pem_private = private_key.private_bytes(
    encoding=serialization.Encoding.PEM,
    format=serialization.PrivateFormat.TraditionalOpenSSL,
    encryption_algorithm=serialization.BestAvailableEncryption(b"passphrase123"),
)
print(f"\nPrivate key PEM (first 50): {pem_private[:50]}")

Step 6: X25519 ECDH Key Exchange

from cryptography.hazmat.primitives.asymmetric.x25519 import X25519PrivateKey

# Generate key pairs for Alice and Bob
alice_private = X25519PrivateKey.generate()
alice_public  = alice_private.public_key()

bob_private = X25519PrivateKey.generate()
bob_public  = bob_private.public_key()

# ECDH: each party computes the same shared secret
alice_shared = alice_private.exchange(bob_public)
bob_shared   = bob_private.exchange(alice_public)

print("=== X25519 ECDH Key Exchange ===")
print(f"Alice shared secret (hex): {alice_shared.hex()[:32]}...")
print(f"Bob shared secret (hex):   {bob_shared.hex()[:32]}...")
print(f"Shared secrets match: {alice_shared == bob_shared}")

# Derive encryption key from shared secret
from cryptography.hazmat.primitives.kdf.hkdf import HKDF

def derive_key(shared_secret: bytes, salt: bytes = None, info: bytes = b"encryption") -> bytes:
    hkdf = HKDF(
        algorithm=hashes.SHA256(),
        length=32,
        salt=salt or secrets.token_bytes(16),
        info=info,
    )
    return hkdf.derive(shared_secret)

key_material = derive_key(alice_shared)
print(f"Derived AES key: {key_material.hex()}")

# Use derived key for Fernet
fernet_key = base64.urlsafe_b64encode(key_material)
f = Fernet(fernet_key)
encrypted = f.encrypt(b"Hello, this is encrypted with ECDH-derived key!")
decrypted = f.decrypt(encrypted)
print(f"ECDH + Fernet: {decrypted}")

Step 7: Safe Deserialization — Restricting Unpickler

import pickle
import io
import importlib

# DANGEROUS: Never unpickle untrusted data!
# os.system is callable in pickle exploits:
# payload = b"cos\nsystem\n(S'whoami'\ntR."  # malicious pickle

class RestrictedUnpickler(pickle.Unpickler):
    """Whitelist-based pickle restriction."""
    
    SAFE_CLASSES = {
        'builtins': {'list', 'dict', 'set', 'tuple', 'str', 'int', 'float', 'bool', 'bytes'},
        'datetime': {'datetime', 'date', 'timedelta'},
        '__main__': {'SafeData'},  # your safe classes
    }
    
    def find_class(self, module: str, name: str):
        allowed = self.SAFE_CLASSES.get(module, set())
        if name in allowed:
            mod = importlib.import_module(module)
            return getattr(mod, name)
        raise pickle.UnpicklingError(
            f"Blocked: {module}.{name} — not in whitelist"
        )

def safe_loads(data: bytes) -> object:
    return RestrictedUnpickler(io.BytesIO(data)).load()

# Safe data
safe_data = pickle.dumps({'users': [1, 2, 3], 'count': 3})
result = safe_loads(safe_data)
print(f"Safe unpickle: {result}")

# Attempt to unpickle dangerous class
import datetime
dt_data = pickle.dumps(datetime.datetime.now())
dt = safe_loads(dt_data)
print(f"Datetime unpickle: {dt}")

# Block unsafe imports
class EvilClass:
    pass

evil_data = pickle.dumps(EvilClass())
try:
    safe_loads(evil_data)
except pickle.UnpicklingError as e:
    print(f"Blocked: {e}")

Step 8: Capstone — Encrypted Configuration Manager

import os
import json
import secrets
import hmac
import hashlib
from cryptography.fernet import Fernet
from cryptography.hazmat.primitives.asymmetric import rsa, padding
from cryptography.hazmat.primitives import hashes

class SecureConfigManager:
    """
    Production-grade configuration manager with:
    - Fernet encryption for config values
    - HMAC integrity verification
    - Safe serialization
    - Key rotation support
    """
    
    def __init__(self, master_key: bytes = None):
        self._master_key = master_key or Fernet.generate_key()
        self._fernet = Fernet(self._master_key)
        self._hmac_key = hashlib.sha256(self._master_key).digest()
        self._config = {}
    
    def _sign(self, data: bytes) -> bytes:
        return hmac.new(self._hmac_key, data, hashlib.sha256).digest()
    
    def _verify(self, data: bytes, signature: bytes) -> bool:
        expected = self._sign(data)
        return hmac.compare_digest(expected, signature)
    
    def set_secret(self, key: str, value: str) -> None:
        """Store an encrypted secret."""
        ciphertext = self._fernet.encrypt(value.encode())
        self._config[key] = {
            'ciphertext': ciphertext.decode(),
            'sig': self._sign(ciphertext).hex(),
            'sensitive': True,
        }
    
    def set_plain(self, key: str, value) -> None:
        """Store a non-sensitive config value."""
        serialized = json.dumps(value).encode()
        self._config[key] = {
            'value': value,
            'sig': self._sign(serialized).hex(),
            'sensitive': False,
        }
    
    def get(self, key: str, default=None):
        """Retrieve and verify a config value."""
        if key not in self._config:
            return default
        
        entry = self._config[key]
        
        if entry['sensitive']:
            ciphertext = entry['ciphertext'].encode()
            sig = bytes.fromhex(entry['sig'])
            
            if not self._verify(ciphertext, sig):
                raise SecurityError(f"Config integrity violation: {key}")
            
            return self._fernet.decrypt(ciphertext).decode()
        else:
            value = entry['value']
            serialized = json.dumps(value).encode()
            sig = bytes.fromhex(entry['sig'])
            
            if not self._verify(serialized, sig):
                raise SecurityError(f"Config integrity violation: {key}")
            
            return value
    
    def rotate_key(self, new_key: bytes = None) -> 'SecureConfigManager':
        """Create new manager with rotated key, re-encrypting all secrets."""
        new_key = new_key or Fernet.generate_key()
        new_manager = SecureConfigManager(new_key)
        
        for key, entry in self._config.items():
            if entry['sensitive']:
                plaintext = self.get(key)
                new_manager.set_secret(key, plaintext)
            else:
                new_manager.set_plain(key, entry['value'])
        
        return new_manager
    
    def export_safe(self) -> dict:
        """Export config with secrets masked."""
        result = {}
        for key, entry in self._config.items():
            result[key] = '***ENCRYPTED***' if entry['sensitive'] else entry['value']
        return result

class SecurityError(Exception):
    pass

# Demo
print("=== SecureConfigManager Demo ===\n")

config = SecureConfigManager()

# Store various config values
config.set_secret("database_password", "super_secret_db_pass_2024!")
config.set_secret("api_key", "sk_live_abc123xyz789")
config.set_plain("debug", False)
config.set_plain("max_connections", 100)
config.set_plain("allowed_hosts", ["api.example.com", "admin.example.com"])

# Retrieve
print("Retrieved values:")
print(f"  database_password: {config.get('database_password')}")
print(f"  api_key: {config.get('api_key')}")
print(f"  debug: {config.get('debug')}")
print(f"  max_connections: {config.get('max_connections')}")

# Safe export (no secrets)
print(f"\nSafe export: {config.export_safe()}")

# Key rotation
print("\nRotating encryption key...")
new_config = config.rotate_key()
print(f"  After rotation: {new_config.get('database_password')}")
print(f"  All secrets still accessible: {new_config.get('api_key')}")

# Integrity check
print("\nIntegrity check: values match after rotation:", 
      config.get('database_password') == new_config.get('database_password'))

📸 Verified Output:

Fernet encrypt/decrypt: OK
  Ciphertext (first 40): b'gAAAAABpqzOyZLC3tvnfgTInUVLJdQ25QDsNW1n4'...
  Decrypted: b'sensitive data: api_key=sk-123456'
RSA sign/verify: OK (signature 256 bytes)
HMAC compare_digest: True
token_hex(16): 88bd0729691362f83a86e9a00d8572af
token_urlsafe(16): KvZyn1bMtdS9MPcEFVPKJQ

Summary

Concept	API	Use Case
Secure randomness	secrets.token_bytes/hex/urlsafe	API keys, tokens, passwords
Timing-safe compare	hmac.compare_digest	Token/signature verification
Modern hashing	hashlib.sha3_256, blake2b	File integrity, fingerprints
Symmetric encryption	cryptography.fernet.Fernet	Encrypt config, data at rest
Key rotation	MultiFernet	Zero-downtime key rotation
RSA signing	private_key.sign/verify	Message authentication
ECDH key exchange	X25519PrivateKey.exchange	End-to-end encryption
Safe unpickling	RestrictedUnpickler	Protect against pickle exploits
Encrypted config	Custom SecureConfigManager	Production secrets management