269 lines
12 KiB
Python
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()
|