import base64 import binascii import hashlib import logging import secrets from dataclasses import dataclass from datetime import datetime, timedelta, timezone from uuid import UUID import redis from argon2 import PasswordHasher from argon2.exceptions import InvalidHashError, VerificationError from redis.backoff import NoBackoff from redis.retry import Retry import settings import telemetry from errors import BASIC_CHALLENGE, unauthorized, unavailable log = logging.getLogger("messenger.auth") hasher = PasswordHasher(time_cost=3, memory_cost=12 * 1024, parallelism=1) DUMMY_HASH = hasher.hash("there-is-no-such-user") PASSWORD_MIN_LENGTH = 12 PASSWORD_MAX_LENGTH = 128 def hash_password(password: str) -> str: # Argon2id нагружает CPU обработчика (а не БД): в трассе это отдельный спан. with telemetry.internal_span("argon2id hash"): return hasher.hash(password) def password_matches(password_hash: str | None, password: str) -> bool: with telemetry.internal_span("argon2id verify"): try: hasher.verify(password_hash or DUMMY_HASH, password) except (VerificationError, InvalidHashError): return False return password_hash is not None def parse_basic(header: str | None) -> tuple[str, str] | None: """'Basic base64(username:password)' -> (username, password) или None. Пароль может содержать двоеточие, поэтому делим по первому двоеточию (RFC 7617). """ scheme, _, value = (header or "").strip().partition(" ") if scheme.lower() != "basic" or not value or len(value) > 1024: return None try: decoded = base64.b64decode(value.strip(), validate=True).decode("utf-8") except (binascii.Error, UnicodeDecodeError): return None username, colon, password = decoded.partition(":") if not colon or not username or not username.isascii(): return None return username, password def parse_bearer(header: str | None) -> str | None: scheme, _, value = (header or "").strip().partition(" ") value = value.strip() if scheme.lower() != "bearer" or not value or len(value) > 512 or " " in value: return None return value KEY_PREFIX = "session:" # Атрибуты спанов Redis: система и операция. Ключ (session:) и значения не пишутся. REDIS_ATTRS = {"db.system.name": "redis", "server.address": "redis"} _redis = redis.Redis( connection_pool=redis.BlockingConnectionPool.from_url( settings.REDIS_URL or "redis://localhost:6379/0", max_connections=settings.REDIS_POOL_MAX, timeout=settings.REDIS_TIMEOUT_MS / 1000, socket_timeout=settings.REDIS_TIMEOUT_MS / 1000, socket_connect_timeout=settings.REDIS_TIMEOUT_MS / 1000, retry=Retry(NoBackoff(), 0), decode_responses=True, ) ) @dataclass(frozen=True) class Session: user_id: UUID key: str def session_key(token: str) -> str: return KEY_PREFIX + hashlib.sha256(token.encode("utf-8")).hexdigest() def create_session(user_id: UUID) -> tuple[str, datetime]: """Новая сессия: случайный токен и абсолютное время истечения.""" token = secrets.token_urlsafe(32) expires_at = datetime.now(timezone.utc) + timedelta(seconds=settings.SESSION_TTL_SECONDS) try: with telemetry.client_span("redis SET", REDIS_ATTRS | {"db.operation.name": "SET"}): _redis.set(session_key(token), str(user_id), pxat=int(expires_at.timestamp() * 1000)) except redis.RedisError as exc: log.warning("Redis is unavailable on login: %s", type(exc).__name__, extra={"event": "redis.unavailable", "error.type": type(exc).__name__}) raise unavailable() from None return token, expires_at def check_bearer(header: str | None) -> Session: token = parse_bearer(header) if token is None: raise unauthorized("Bearer token is required") key = session_key(token) try: with telemetry.client_span("redis GET", REDIS_ATTRS | {"db.operation.name": "GET"}): user_id = _redis.get(key) except redis.RedisError as exc: log.warning("Redis is unavailable: %s", type(exc).__name__, extra={"event": "redis.unavailable", "error.type": type(exc).__name__}) raise unavailable() from None if user_id is None: raise unauthorized("Session is invalid or expired") return Session(UUID(user_id), key) def delete_session(session: Session) -> None: try: with telemetry.client_span("redis DEL", REDIS_ATTRS | {"db.operation.name": "DEL"}): _redis.delete(session.key) except redis.RedisError: raise unavailable() from None def ping_redis() -> None: try: _redis.ping() except redis.RedisError: raise unavailable() from None def login_failed(): return unauthorized("Invalid username or password", BASIC_CHALLENGE) def close() -> None: _redis.close() _redis.connection_pool.disconnect()