Files
mtusi2026lab7/auth.py
T

269 lines
12 KiB
Python

"""Пароли (Argon2id), сессии и ограничение частоты входа (lab7).
Пароли: argon2-cffi, Argon2id, параметры из settings (не ниже m=19 MiB, t=2, p=1; выбор — по замеру,
REPORT.md). В БД хранится строка $argon2id$v=19$m=...,t=...,p=...$<salt>$<hash>: соль и параметры
вместе с хешем. При успешном входе hash со старыми параметрами пересчитывается (rehash) и сохраняется.
Бюджет CPU/RAM: Argon2id намеренно дорог, поэтому поток запросов входа/регистрации — готовый DoS.
- одновременно в реплике не больше ARGON2_MAX_CONCURRENCY хешей (память N x m, CPU N ядер);
ожидание слота не дольше ARGON2_QUEUE_SECONDS, иначе 503 + Retry-After (нет растущей очереди);
- ДО хеширования — общий для всех реплик счётчик в Redis (фиксированное окно): попыток на username
и на IP клиента; превышение -> 429 + Retry-After, хеш не считается вовсе.
- несуществующий пользователь проверяется против DUMMY_HASH с теми же параметрами: время ответа
не выдаёт, есть ли такой username.
Сессии: случайный токен 256 бит; в Redis хранится только SHA-256 токена (session:<hex>) -> user_id
с абсолютным временем истечения. Redis — TLS + клиентский сертификат + ACL-пользователь api, у которого
есть доступ только к ключам session:* и ratelimit:* и только к нужным командам; пароль ACL-пользователя
берётся из OpenBao на каждое новое соединение (ротация без рестарта).
"""
import base64
import binascii
import hashlib
import logging
import secrets
import ssl
import threading
from dataclasses import dataclass
from datetime import datetime, timedelta, timezone
from uuid import UUID
import redis
from argon2 import PasswordHasher, Type
from argon2.exceptions import InvalidHashError, VerificationError
from redis.backoff import NoBackoff
from redis.credentials import CredentialProvider
from redis.retry import Retry
import settings
import telemetry
from errors import BASIC_CHALLENGE, busy, rate_limited, unauthorized, unavailable
from secretstore import store
log = logging.getLogger("messenger.auth")
hasher = PasswordHasher(time_cost=settings.ARGON2_ITERATIONS, memory_cost=settings.ARGON2_MEMORY_KIB,
parallelism=settings.ARGON2_PARALLELISM, hash_len=32, salt_len=16, type=Type.ID)
DUMMY_HASH = hasher.hash("there-is-no-such-user")
PASSWORD_MIN_LENGTH = 12
PASSWORD_MAX_LENGTH = 128
_hash_slots = threading.BoundedSemaphore(settings.ARGON2_MAX_CONCURRENCY)
HASH_REJECTED = telemetry.meter.create_counter(
"messenger.auth.hash_rejected", unit="{request}",
description="Password hashing requests rejected because the per-replica Argon2id budget was exhausted")
RATE_LIMITED = telemetry.meter.create_counter(
"messenger.auth.rate_limited", unit="{request}", description="Login/registration attempts answered with 429")
REHASHED = telemetry.meter.create_counter(
"messenger.auth.rehashed", unit="{user}", description="Password hashes upgraded to current Argon2id parameters")
class _HashSlot:
"""Слот бюджета хеширования; занят — ждём не дольше ARGON2_QUEUE_SECONDS, иначе 503."""
def __enter__(self):
if not _hash_slots.acquire(timeout=settings.ARGON2_QUEUE_SECONDS):
HASH_REJECTED.add(1)
log.warning("Argon2id budget exhausted", extra={"event": "auth.hash_budget_exhausted"})
raise busy(1)
return self
def __exit__(self, *exc):
_hash_slots.release()
return False
def hash_password(password: str) -> str:
# Argon2id нагружает CPU обработчика (а не БД): в трассе это отдельный спан.
with _HashSlot(), telemetry.internal_span("argon2id hash"):
return hasher.hash(password)
def password_matches(password_hash: str | None, password: str) -> bool:
with _HashSlot(), 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 needs_rehash(password_hash: str) -> bool:
try:
return hasher.check_needs_rehash(password_hash)
except InvalidHashError:
return False
def rehash(password: str) -> str:
return hash_password(password)
def hash_parameters(password_hash: str) -> dict:
"""Параметры из строки хеша (для тестов/отчёта): {"type": "argon2id", "m": ..., "t": ..., "p": ...}."""
parts = password_hash.split("$")
params = dict(item.split("=") for item in parts[3].split(","))
return {"type": parts[1], "m": int(params["m"]), "t": int(params["t"]), "p": int(params["p"]),
"salt_bytes": len(base64.b64decode(parts[4] + "=" * (-len(parts[4]) % 4)))}
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:"
RATE_PREFIX = "ratelimit:"
# Атрибуты спанов Redis: система и операция. Ключ (session:<SHA-256 токена>) и значения не пишутся.
REDIS_ATTRS = {"db.system.name": "redis", "server.address": "redis"}
class _RedisCredentials(CredentialProvider):
"""ACL-пользователь и его пароль — текущая версия из OpenBao на каждое новое соединение."""
def get_credentials(self):
return settings.REDIS_USER, store.get("redis_password")
_redis = redis.Redis(
connection_pool=redis.BlockingConnectionPool(
connection_class=redis.SSLConnection,
host=settings.REDIS_HOST,
port=settings.REDIS_PORT,
db=0,
credential_provider=_RedisCredentials(),
ssl_ca_certs=settings.TLS_CA_FILE,
ssl_certfile=settings.TLS_CERT_FILE,
ssl_keyfile=settings.TLS_KEY_FILE,
ssl_cert_reqs=ssl.CERT_REQUIRED,
ssl_check_hostname=True,
ssl_min_version=ssl.TLSVersion.TLSv1_2,
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,
lib_name=None, # без CLIENT SETINFO: ACL-пользователю api эта команда не нужна и не выдана
lib_version=None,
)
)
@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 _redis_failed(exc: Exception, where: str):
log.warning("Redis is unavailable (%s): %s", where, type(exc).__name__,
extra={"event": "redis.unavailable", "error.type": type(exc).__name__})
return unavailable()
def check_rate(kind: str, subject: str, limit: int, fail_open: bool = False) -> None:
"""Общий для реплик счётчик попыток (фиксированное окно). Превышение -> 429 + Retry-After.
В ключе — SHA-256 субъекта (username/IP), а не сам субъект: Redis не хранит имена и адреса.
fail_open: при недоступном Redis пропустить (регистрация с lab2 работает без Redis; от перегрузки
её по-прежнему защищает бюджет Argon2id реплики). Вход без Redis невозможен и так (сессии в Redis).
"""
key = RATE_PREFIX + kind + ":" + hashlib.sha256(subject.encode("utf-8")).hexdigest()[:32]
window_ms = settings.LOGIN_RATE_WINDOW_SECONDS * 1000
try:
with telemetry.client_span("redis INCR", REDIS_ATTRS | {"db.operation.name": "INCR"}):
pipe = _redis.pipeline(transaction=True)
pipe.incr(key)
pipe.pexpire(key, window_ms, nx=True)
pipe.pttl(key)
count, _, ttl_ms = pipe.execute()
except redis.RedisError as exc:
if fail_open:
log.warning("Rate limit skipped, Redis is unavailable: %s", type(exc).__name__,
extra={"event": "auth.rate_limit_skipped", "error.type": type(exc).__name__})
return
raise _redis_failed(exc, "rate limit") from None
if count > limit:
RATE_LIMITED.add(1, {"messenger.rate_limit": kind})
log.info("Rate limited: %s", kind, extra={"event": "auth.rate_limited", "messenger.rate_limit": kind})
raise rate_limited(-(-max(ttl_ms, 1000) // 1000))
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:
raise _redis_failed(exc, "login") 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:
raise _redis_failed(exc, "session") 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 as exc:
raise _redis_failed(exc, "logout") 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()