forked from mtusi2026/mtusi2026lab5
140 lines
4.2 KiB
Python
140 lines
4.2 KiB
Python
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()
|