forked from mtusi2026/mtusi2026lab7
лр7: Docker-прогон, evidence, исправления
This commit is contained in:
@@ -0,0 +1,268 @@
|
||||
"""Пароли (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()
|
||||
Reference in New Issue
Block a user