forked from mtusi2026/mtusi2026lab3
128 lines
4.4 KiB
Python
128 lines
4.4 KiB
Python
"""Argon2id passwords and opaque sessions. Cache hits never authorize a request."""
|
|
|
|
import base64
|
|
import binascii
|
|
import hashlib
|
|
import re
|
|
import secrets
|
|
from contextlib import contextmanager
|
|
from dataclasses import dataclass
|
|
from threading import BoundedSemaphore
|
|
|
|
from argon2 import PasswordHasher
|
|
from argon2.exceptions import InvalidHashError, VerificationError
|
|
from argon2.profiles import RFC_9106_LOW_MEMORY
|
|
|
|
from messenger.cache import SessionCache
|
|
from messenger.domain import DomainError, User
|
|
from messenger.repository import PostgresRepository
|
|
|
|
|
|
def unauthorized(scheme: str = "Bearer") -> DomainError:
|
|
challenge = scheme + ' realm="messenger"'
|
|
if scheme == "Basic":
|
|
challenge += ', charset="UTF-8"'
|
|
return DomainError(
|
|
401,
|
|
"unauthorized",
|
|
"Требуется действительная идентификация",
|
|
{"WWW-Authenticate": challenge},
|
|
)
|
|
|
|
|
|
def basic_credentials(header: str | None) -> tuple[str, str]:
|
|
try:
|
|
if header is None or len(header) > 2048:
|
|
raise ValueError
|
|
scheme, encoded = header.split(" ", 1)
|
|
if scheme.lower() != "basic":
|
|
raise ValueError
|
|
raw = base64.b64decode(encoded, validate=True).decode("utf-8")
|
|
username, password = raw.split(":", 1)
|
|
if not re.fullmatch(r"[a-z0-9_]{3,32}", username):
|
|
raise ValueError
|
|
if not 12 <= len(password) <= 128 or not password.strip():
|
|
raise ValueError
|
|
return username, password
|
|
except ValueError, UnicodeError, binascii.Error:
|
|
raise unauthorized("Basic") from None
|
|
|
|
|
|
def bearer_digest(header: str | None) -> bytes:
|
|
if header:
|
|
parts = header.split(" ")
|
|
if len(parts) == 2 and parts[0].lower() == "bearer":
|
|
if re.fullmatch(r"[A-Za-z0-9_-]{43}", parts[1]):
|
|
return hashlib.sha256(parts[1].encode()).digest()
|
|
raise unauthorized()
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class Identity:
|
|
user: User
|
|
token_hash: bytes
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class Session:
|
|
token: str
|
|
token_type: str
|
|
expires_at: str
|
|
user: User
|
|
|
|
|
|
class AuthService:
|
|
def __init__(self, repository: PostgresRepository, cache: SessionCache, ttl: int):
|
|
self.repository, self.cache, self.ttl = repository, cache, ttl
|
|
self.hasher = PasswordHasher.from_parameters(RFC_9106_LOW_MEMORY)
|
|
self.kdf_slots = BoundedSemaphore(2)
|
|
self.dummy_hash = self.hasher.hash(secrets.token_urlsafe(32))
|
|
|
|
@contextmanager
|
|
def kdf(self):
|
|
if not self.kdf_slots.acquire(timeout=0.5):
|
|
raise DomainError(503, "unavailable", "Обработка пароля временно занята")
|
|
try:
|
|
yield
|
|
finally:
|
|
self.kdf_slots.release()
|
|
|
|
def register(self, username: str, display_name: str, password: str) -> User:
|
|
with self.kdf():
|
|
encoded = self.hasher.hash(password)
|
|
return self.repository.add_user(username, display_name, encoded)
|
|
|
|
def login(self, username: str, password: str) -> Session:
|
|
credentials = self.repository.credentials(username)
|
|
encoded = credentials[1] if credentials else self.dummy_hash
|
|
try:
|
|
with self.kdf():
|
|
self.hasher.verify(encoded, password)
|
|
except VerificationError, InvalidHashError:
|
|
raise unauthorized("Basic") from None
|
|
if credentials is None:
|
|
raise unauthorized("Basic")
|
|
token = secrets.token_urlsafe(32)
|
|
digest = hashlib.sha256(token.encode()).digest()
|
|
user = credentials[0]
|
|
expires = self.repository.create_session(digest, user.id, self.ttl)
|
|
return Session(token, "Bearer", expires, user)
|
|
|
|
def identify(self, digest: bytes) -> Identity:
|
|
session = self.repository.active_session(digest)
|
|
if session is None:
|
|
raise unauthorized()
|
|
user_id = str(session["user_id"])
|
|
user = self.cache.get(digest, user_id)
|
|
if user is None:
|
|
user = self.repository.get_user(user_id)
|
|
if user is None:
|
|
raise unauthorized()
|
|
ttl = int((session["expires_at"] - session["checked_at"]).total_seconds())
|
|
self.cache.put(digest, user, ttl)
|
|
return Identity(user, digest)
|
|
|
|
def logout(self, identity: Identity):
|
|
self.repository.revoke_session(identity.token_hash)
|
|
self.cache.delete(identity.token_hash)
|