"""Password verification and short-lived, server-side account sessions.""" from __future__ import annotations import hashlib import hmac import json import secrets import threading import time from dataclasses import dataclass from typing import Protocol PASSWORD_ITERATIONS = 600_000 SESSION_LIFETIME_SECONDS = 8 * 60 * 60 def hash_password(password: str) -> str: if len(password) < 12: raise ValueError("Password must contain at least 12 characters") salt = secrets.token_bytes(16) digest = hashlib.pbkdf2_hmac( "sha256", password.encode("utf-8"), salt, PASSWORD_ITERATIONS ) return f"pbkdf2_sha256${PASSWORD_ITERATIONS}${salt.hex()}${digest.hex()}" def verify_password(password: str, encoded: str) -> bool: try: algorithm, iterations_raw, salt_raw, expected_raw = encoded.split("$") iterations = int(iterations_raw) if algorithm != "pbkdf2_sha256" or not 100_000 <= iterations <= 2_000_000: return False salt = bytes.fromhex(salt_raw) expected = bytes.fromhex(expected_raw) if len(salt) < 16 or len(expected) != 32: return False except (ValueError, TypeError): return False actual = hashlib.pbkdf2_hmac("sha256", password.encode("utf-8"), salt, iterations) return hmac.compare_digest(actual, expected) @dataclass(frozen=True) class Session: token: str username: str csrf_token: str expires_at: float # Immutable database primary key. The optional form is only for the # injected, database-free HTTP test harness. user_id: int | None = None class SessionStore: def __init__(self) -> None: self._sessions: dict[str, Session] = {} self._lock = threading.Lock() def issue(self, username: str, user_id: int | None = None) -> Session: session = Session( token=secrets.token_urlsafe(32), username=username, csrf_token=secrets.token_urlsafe(32), expires_at=time.time() + SESSION_LIFETIME_SECONDS, user_id=user_id, ) with self._lock: self._sessions[session.token] = session return session def get(self, token: str | None) -> Session | None: if not token: return None with self._lock: session = self._sessions.get(token) if session is None: return None if session.expires_at <= time.time(): self._sessions.pop(token, None) return None return session def revoke(self, token: str | None) -> None: if token: with self._lock: self._sessions.pop(token, None) class _SessionDatabase(Protocol): def get(self, record_type: str, record_key: str) -> str | None: ... def set(self, record_type: str, record_key: str, value: str) -> None: ... def delete(self, record_type: str, record_key: str) -> None: ... class DatabaseSessionStore: """Server-side sessions that survive a web-process restart. Only a SHA-256 fingerprint of the bearer token is used as the database record key. The immutable user ID, username, CSRF token and expiry are encrypted by the database store; the raw bearer token is never persisted. """ def __init__(self, database: _SessionDatabase) -> None: self._database = database @staticmethod def _key(token: str) -> str: return hashlib.sha256(token.encode("ascii")).hexdigest() def issue(self, username: str, user_id: int | None = None) -> Session: if isinstance(user_id, bool) or not isinstance(user_id, int) or user_id < 1: raise ValueError("Database sessions require a positive user ID") session = Session( token=secrets.token_urlsafe(32), username=username, csrf_token=secrets.token_urlsafe(32), expires_at=time.time() + SESSION_LIFETIME_SECONDS, user_id=user_id, ) payload = json.dumps({ "username": session.username, "user_id": session.user_id, "csrf_token": session.csrf_token, "expires_at": session.expires_at, }, separators=(",", ":")) self._database.set("session", self._key(session.token), payload) return session def get(self, token: str | None) -> Session | None: if not isinstance(token, str) or not token or len(token) > 256: return None try: key = self._key(token) except UnicodeEncodeError: return None raw = self._database.get("session", key) if raw is None: return None try: data = json.loads(raw) username = data["username"] user_id = data["user_id"] csrf_token = data["csrf_token"] expires_at = data["expires_at"] except (TypeError, ValueError, KeyError): return None if (not isinstance(username, str) or not isinstance(csrf_token, str) or isinstance(user_id, bool) or not isinstance(user_id, int) or user_id < 1 or isinstance(expires_at, bool) or not isinstance(expires_at, (int, float))): return None if expires_at <= time.time(): self._database.delete("session", key) return None return Session(token, username, csrf_token, float(expires_at), user_id) def revoke(self, token: str | None) -> None: if not isinstance(token, str) or not token or len(token) > 256: return try: key = self._key(token) except UnicodeEncodeError: return self._database.delete("session", key) class LoginLimiter: """Small in-memory limit for failed logins from one peer address.""" def __init__(self) -> None: self._failures: dict[str, list[float]] = {} self._lock = threading.Lock() def allowed(self, peer: str) -> bool: cutoff = time.time() - 15 * 60 with self._lock: recent = [attempt for attempt in self._failures.get(peer, []) if attempt > cutoff] self._failures[peer] = recent return len(recent) < 5 def failed(self, peer: str) -> None: with self._lock: self._failures.setdefault(peer, []).append(time.time()) def succeeded(self, peer: str) -> None: with self._lock: self._failures.pop(peer, None)