Multi-Factor Authentication with TOTP — Time-Based One-Time Passwords Deep Dive

import hmac, hashlib, struct, time, base64
from flask import Flask, request, jsonify

app = Flask(__name__)

def generate_totp_secret():
    """Generate a random base32-encoded secret for TOTP."""
    import secrets
    random_bytes = secrets.token_bytes(20)  # 160 bits
    return base64.b32encode(random_bytes).decode()

def totp(secret, time_step=30, digits=6):
    """Generate a TOTP code using HMAC-SHA1."""
    # Get current time counter
    counter = int(time.time() / time_step)

    # Pack counter as 8-byte big-endian
    counter_bytes = struct.pack(">Q", counter)

    # Decode base32 secret
    key = base64.b32decode(secret)

    # Compute HMAC-SHA1
    h = hmac.new(key, counter_bytes, hashlib.sha1).digest()

    # Dynamic truncation
    offset = h[-1] & 0x0F
    truncated = struct.unpack(">I", h[offset:offset+4])[0] & 0x7FFFFFFF

    # Return last 6 digits
    return f"{truncated % 10**digits:0{digits}d}"

def verify_totp(secret, code, window=1, digits=6):
    """Verify a TOTP code with time drift window."""
    current = int(time.time() / 30)

    for i in range(-window, window + 1):
        counter = current + i
        counter_bytes = struct.pack(">Q", counter)
        key = base64.b32decode(secret)

        h = hmac.new(key, counter_bytes, hashlib.sha1).digest()
        offset = h[-1] & 0x0F
        truncated = struct.unpack(">I", h[offset:offset+4])[0] & 0x7FFFFFFF
        expected = f"{truncated % 10**digits:0{digits}d}"

        if hmac.compare_digest(code, expected):
            return True

    return False

import qrcode
import io
import base64 as b64

# User secrets store
totp_secrets = {}

@app.route("/api/mfa/totp/setup", methods=["POST"])
def setup_totp():
    """Generate TOTP secret and provisioning URI."""
    user_id = request.json.get("user_id")

    secret = generate_totp_secret()
    totp_secrets[user_id] = secret

    # Generate provisioning URI (standard format for authenticator apps)
    provisioning_uri = (
        f"otpauth://totp/Durga:{user_id}?"
        f"secret={secret}&issuer=Durga&algorithm=SHA1&digits=6&period=30"
    )

    # Generate QR code as base64 PNG
    qr = qrcode.QRCode(box_size=8, border=2)
    qr.add_data(provisioning_uri)
    qr.make(fit=True)
    img = qr.make_image()
    buffer = io.BytesIO()
    img.save(buffer, format="PNG")
    qr_b64 = b64.b64encode(buffer.getvalue()).decode()

    return jsonify({
        "secret": secret,
        "provisioning_uri": provisioning_uri,
        "qr_code_base64": qr_b64,
        "backup_codes": generate_backup_codes(user_id),
        "message": "Scan QR code with authenticator app"
    })

@app.route("/api/mfa/totp/verify", methods=["POST"])
def verify_totp_code():
    """Verify a TOTP code."""
    user_id = request.json.get("user_id")
    code = request.json.get("code", "")
    secret = totp_secrets.get(user_id)

    if not secret:
        return jsonify({"error": "TOTP not configured"}), 400

    if verify_totp(secret, code):
        return jsonify({"verified": True})
    else:
        return jsonify({"verified": False}), 401

import secrets, hashlib

# Backup codes per user
user_backup_codes = {}

def generate_backup_codes(user_id, count=8):
    """Generate one-time backup codes."""
    codes = []
    hashed_codes = []

    for _ in range(count):
        code = f"{secrets.randbelow(10**8):08d}"
        codes.append(code)
        hashed_codes.append(hashlib.sha256(code.encode()).hexdigest())

    user_backup_codes[user_id] = {
        "hashes": hashed_codes,
        "used": set()
    }

    return codes  # Return plain codes once — user must save them

@app.route("/api/mfa/totp/verify", methods=["POST"])
def verify_mfa():
    """Verify TOTP code or backup code."""
    user_id = request.json.get("user_id")
    code = request.json.get("code", "")

    # Try TOTP first
    secret = totp_secrets.get(user_id)
    if secret and verify_totp(secret, code):
        return jsonify({"verified": True, "method": "totp"})

    # Try backup code
    codes = user_backup_codes.get(user_id)
    if codes:
        code_hash = hashlib.sha256(code.encode()).hexdigest()
        if code_hash in codes["hashes"] and code_hash not in codes["used"]:
            codes["used"].add(code_hash)
            return jsonify({
                "verified": True,
                "method": "backup",
                "remaining_codes": len(codes["hashes"]) - len(codes["used"])
            })

    return jsonify({"verified": False}), 401