"""Argon2id passwords and opaque sessions. Cache hits never authorize a request.""" import base64 import binascii import hashlib import re import secrets from contextlib import contextmanager from dataclasses import dataclass from threading import BoundedSemaphore from argon2 import PasswordHasher from argon2.exceptions import InvalidHashError, VerificationError from argon2.profiles import RFC_9106_LOW_MEMORY from messenger.cache import SessionCache from messenger.domain import DomainError, User from messenger.repository import PostgresRepository def unauthorized(scheme: str = "Bearer") -> DomainError: challenge = scheme + ' realm="messenger"' if scheme == "Basic": challenge += ', charset="UTF-8"' return DomainError( 401, "unauthorized", "Требуется действительная идентификация", {"WWW-Authenticate": challenge}, ) def basic_credentials(header: str | None) -> tuple[str, str]: try: if header is None or len(header) > 2048: raise ValueError scheme, encoded = header.split(" ", 1) if scheme.lower() != "basic": raise ValueError raw = base64.b64decode(encoded, validate=True).decode("utf-8") username, password = raw.split(":", 1) if not re.fullmatch(r"[a-z0-9_]{3,32}", username): raise ValueError if not 12 <= len(password) <= 128 or not password.strip(): raise ValueError return username, password except ValueError, UnicodeError, binascii.Error: raise unauthorized("Basic") from None def bearer_digest(header: str | None) -> bytes: if header: parts = header.split(" ") if len(parts) == 2 and parts[0].lower() == "bearer": if re.fullmatch(r"[A-Za-z0-9_-]{43}", parts[1]): return hashlib.sha256(parts[1].encode()).digest() raise unauthorized() @dataclass(frozen=True) class Identity: user: User token_hash: bytes @dataclass(frozen=True) class Session: token: str token_type: str expires_at: str user: User class AuthService: def __init__(self, repository: PostgresRepository, cache: SessionCache, ttl: int): self.repository, self.cache, self.ttl = repository, cache, ttl self.hasher = PasswordHasher.from_parameters(RFC_9106_LOW_MEMORY) self.kdf_slots = BoundedSemaphore(2) self.dummy_hash = self.hasher.hash(secrets.token_urlsafe(32)) @contextmanager def kdf(self): if not self.kdf_slots.acquire(timeout=0.5): raise DomainError(503, "unavailable", "Обработка пароля временно занята") try: yield finally: self.kdf_slots.release() def register(self, username: str, display_name: str, password: str) -> User: with self.kdf(): encoded = self.hasher.hash(password) return self.repository.add_user(username, display_name, encoded) def login(self, username: str, password: str) -> Session: credentials = self.repository.credentials(username) encoded = credentials[1] if credentials else self.dummy_hash try: with self.kdf(): self.hasher.verify(encoded, password) except VerificationError, InvalidHashError: raise unauthorized("Basic") from None if credentials is None: raise unauthorized("Basic") token = secrets.token_urlsafe(32) digest = hashlib.sha256(token.encode()).digest() user = credentials[0] expires = self.repository.create_session(digest, user.id, self.ttl) return Session(token, "Bearer", expires, user) def identify(self, digest: bytes) -> Identity: session = self.repository.active_session(digest) if session is None: raise unauthorized() user_id = str(session["user_id"]) user = self.cache.get(digest, user_id) if user is None: user = self.repository.get_user(user_id) if user is None: raise unauthorized() ttl = int((session["expires_at"] - session["checked_at"]).total_seconds()) self.cache.put(digest, user, ttl) return Identity(user, digest) def logout(self, identity: Identity): self.repository.revoke_session(identity.token_hash) self.cache.delete(identity.token_hash)