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 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: return hasher.hash(password) def password_matches(password_hash: str | None, password: str) -> bool: 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 = 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: _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__) 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: user_id = _redis.get(key) except redis.RedisError as exc: log.warning("Redis is unavailable: %s", 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: _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()