feat: add password login and bearer sessions

- Argon2id password hashes, KDF in a thread with its own limit
- POST /auth/sessions with Basic, DELETE /auth/sessions/current
- Bearer sessions in PostgreSQL, X-User-Id ignored
- migration drops lab 1 data without passwords
- student-tests on tokens, sessions spec and synced specs

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-10-01 18:50:42 +03:00
co-authored by Claude Opus 5.5
parent ee2643d21e
commit ae4154eaf5
68 changed files with 2946 additions and 314 deletions
+106 -23
View File
@@ -1,17 +1,26 @@
"""Зависимости ручек: сессия БД, сервисы, текущий пользователь, страница."""
"""Зависимости ручек: сессия БД, сервисы, вход и текущая сессия, страница."""
import asyncio
import base64
import binascii
import re
from collections.abc import AsyncIterator
from dataclasses import dataclass
from typing import Annotated
from fastapi import Depends, Query, Security
from fastapi.security import APIKeyHeader
from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
from fastapi.security.http import HTTPBase
from sqlalchemy.ext.asyncio import AsyncSession
from src.config import settings
from src.core import exceptions
from src.core.services import ChatService, MessageService, UserService
from src.core.services import (
ChatService,
MessageService,
SessionService,
UserService,
)
from src.infra.db import is_db_unavailable, ping
from src.infra.db.session import engine, session_factory
from src.infra.logger import AbstractLogger, current_user_id, get_logger
@@ -20,8 +29,10 @@ from src.utils.constants import (
PAGE_LIMIT_DEFAULT,
PAGE_LIMIT_MAX,
PAGE_LIMIT_MIN,
PASSWORD_MAX_LENGTH,
PASSWORD_MIN_LENGTH,
READINESS_DB_TIMEOUT_SECONDS,
USER_ID_HEADER,
USERNAME_PATTERN,
)
logger: AbstractLogger = get_logger().bind(module="api_dependencies")
@@ -81,36 +92,108 @@ async def get_message_service(db_session: DbSessionDep) -> MessageService:
return MessageService(db_session=db_session)
async def get_session_service(db_session: DbSessionDep) -> SessionService:
return SessionService(db_session=db_session)
UserServiceDep = Annotated[UserService, Depends(get_user_service)]
ChatServiceDep = Annotated[ChatService, Depends(get_chat_service)]
MessageServiceDep = Annotated[MessageService, Depends(get_message_service)]
SessionServiceDep = Annotated[SessionService, Depends(get_session_service)]
# схема devUser из contracts/openapi.json: кнопка Authorize в /docs.
# auto_error=False — нет заголовка даёт None, а не ошибку FastAPI: 401 в
# формате контракта бросает сервис. Типизированный `Header()` не подходит:
# он уходит в валидацию и дал бы 400 вместо 401
user_id_scheme = APIKeyHeader(
name=USER_ID_HEADER,
scheme_name="devUser",
description=(
"Только учебная lab1: существующий UUID. Не является аутентификацией."
),
# схемы basicAuth и bearerAuth из contracts/openapi.json: объявлены в
# /openapi.json и дают кнопку Authorize в /docs. auto_error=False — нет
# заголовка или схема чужая даёт None, а 401 в формате контракта бросает
# сервис. HTTPBase отдаёт credentials как есть: HTTPBasic FastAPI
# декодирует ASCII и на пароле не из ASCII сам ответил бы 401
basic_scheme = HTTPBase(
scheme="basic",
scheme_name="basicAuth",
auto_error=False,
)
bearer_scheme = HTTPBearer(
scheme_name="bearerAuth",
bearerFormat="opaque session token",
auto_error=False,
)
async def get_current_user(
raw_user_id: Annotated[str | None, Security(user_id_scheme)],
users: UserServiceDep,
) -> dataclasses.UserFullDTO:
"""Текущий пользователь по X-User-Id; иначе 401.
@dataclass(frozen=True, slots=True)
class BasicCredentials:
username: str
password: str
С лабы 2 здесь будет Bearer-сессия (своя схема безопасности).
def parse_basic(
credentials: HTTPAuthorizationCredentials | None,
) -> BasicCredentials | None:
"""username и пароль из `Authorization: Basic`; None — разбор не удался.
base64 строго, UTF-8, разделитель — первое двоеточие: в username его
не бывает, в пароле оно допустимо. Значения, которые не могут быть
верными (формат username и длина пароля публичны), отсекаются здесь:
до БД и KDF не доходит ни мусор, ни пароль в мегабайт.
"""
user = await users.identify(raw_user_id=raw_user_id)
current_user_id.set(str(user.id))
return user
if credentials is None or credentials.scheme.lower() != "basic":
return None
try:
decoded = base64.b64decode(credentials.credentials, validate=True)
username, separator, password = decoded.decode().partition(":")
except (binascii.Error, UnicodeDecodeError):
return None
if not separator or not re.fullmatch(USERNAME_PATTERN, username):
return None
if not PASSWORD_MIN_LENGTH <= len(password) <= PASSWORD_MAX_LENGTH:
return None
return BasicCredentials(username=username, password=password)
async def get_basic_credentials(
credentials: Annotated[
HTTPAuthorizationCredentials | None,
Security(basic_scheme),
],
) -> BasicCredentials:
"""Учётные данные входа; любой сбой разбора — тот же 401, что и
неверный пароль."""
parsed = parse_basic(credentials)
if parsed is None:
raise exceptions.InvalidCredentials
return parsed
BasicCredentialsDep = Annotated[
BasicCredentials,
Depends(get_basic_credentials),
]
async def get_current_session(
credentials: Annotated[
HTTPAuthorizationCredentials | None,
Security(bearer_scheme),
],
sessions: SessionServiceDep,
) -> dataclasses.CurrentSessionDTO:
"""Действующая сессия по Bearer-токену; иначе 401."""
current = await sessions.authenticate(
token=credentials.credentials if credentials else None,
)
current_user_id.set(str(current.user.id))
return current
CurrentSession = Annotated[
dataclasses.CurrentSessionDTO,
Depends(get_current_session),
]
async def get_current_user(
current: CurrentSession,
) -> dataclasses.UserFullDTO:
return current.user
CurrentUser = Annotated[dataclasses.UserFullDTO, Depends(get_current_user)]
+13 -2
View File
@@ -15,10 +15,11 @@ from starlette.exceptions import HTTPException as StarletteHTTPException
from src.api.schemas import Error, ErrorBody, ErrorCode
from src.core import exceptions
from src.utils.constants import REQUEST_ID_HEADER
from src.utils.constants import AUTH_REALM, REQUEST_ID_HEADER
DOMAIN_ERRORS: dict[type[exceptions.DomainError], tuple[int, ErrorCode]] = {
exceptions.Unidentified: (401, ErrorCode.UNAUTHORIZED),
exceptions.InvalidCredentials: (401, ErrorCode.UNAUTHORIZED),
exceptions.Unauthenticated: (401, ErrorCode.UNAUTHORIZED),
exceptions.UsernameTaken: (409, ErrorCode.CONFLICT),
exceptions.ChatNotFound: (404, ErrorCode.NOT_FOUND),
exceptions.InvalidChatMembers: (400, ErrorCode.INVALID_REQUEST),
@@ -28,6 +29,14 @@ DOMAIN_ERRORS: dict[type[exceptions.DomainError], tuple[int, ErrorCode]] = {
exceptions.DomainError: (400, ErrorCode.INVALID_REQUEST),
}
# вызов в WWW-Authenticate у 401: какой схемой повторить запрос
CHALLENGES: dict[type[exceptions.DomainError], str] = {
exceptions.InvalidCredentials: (
f'Basic realm="{AUTH_REALM}", charset="UTF-8"'
),
exceptions.Unauthenticated: f'Bearer realm="{AUTH_REALM}"',
}
HTTP_ERRORS: dict[int, tuple[ErrorCode, str]] = {
404: (ErrorCode.NOT_FOUND, "Not found"),
405: (ErrorCode.INVALID_REQUEST, "Method not allowed"),
@@ -64,11 +73,13 @@ async def handle_domain_error(
status_code, code = next(
DOMAIN_ERRORS[cls] for cls in type(exc).__mro__ if cls in DOMAIN_ERRORS
)
challenge = CHALLENGES.get(type(exc))
return error_response(
request_id=_request_id(request),
status_code=status_code,
code=code,
message=str(exc),
headers={"WWW-Authenticate": challenge} if challenge else None,
)
+2
View File
@@ -10,10 +10,12 @@ from src.utils.constants import API_V1_PREFIX
from .chat import router as chat_router
from .message import router as message_router
from .session import router as session_router
from .user import router as user_router
v1_router = APIRouter(prefix=API_V1_PREFIX)
v1_router.include_router(user_router)
v1_router.include_router(session_router)
v1_router.include_router(chat_router)
v1_router.include_router(message_router)
+32
View File
@@ -0,0 +1,32 @@
from fastapi import APIRouter, Response
from src.api.dependencies import (
BasicCredentialsDep,
CurrentSession,
SessionServiceDep,
)
from src.api.schemas import Session
router = APIRouter(prefix="/auth/sessions", tags=["sessions"])
@router.post("", status_code=201, response_model=Session)
async def create_session(
credentials: BasicCredentialsDep,
sessions: SessionServiceDep,
) -> Session:
"""Вход по `Authorization: Basic`; тело запроса не читается."""
issued = await sessions.login(
username=credentials.username,
password=credentials.password,
)
return Session.model_validate(issued)
@router.delete("/current", status_code=204, response_class=Response)
async def revoke_current_session(
current: CurrentSession,
sessions: SessionServiceDep,
) -> Response:
await sessions.revoke(session_id=current.id)
return Response(status_code=204)
+1
View File
@@ -11,6 +11,7 @@ async def register_user(body: CreateUser, users: UserServiceDep) -> User:
user = await users.register(
username=body.username,
display_name=body.display_name,
password=body.password,
)
return User.model_validate(user)
+2
View File
@@ -1,6 +1,7 @@
from .chat import Chat, ChatPage, CreateChat
from .common import Error, ErrorBody, ErrorCode, Health
from .message import CreateMessage, Message, MessagePage
from .session import Session
from .user import CreateUser, User
__all__ = [
@@ -15,5 +16,6 @@ __all__ = [
"Health",
"Message",
"MessagePage",
"Session",
"User",
]
+15
View File
@@ -0,0 +1,15 @@
from typing import Literal
from pydantic import BaseModel, ConfigDict
from src.api.schemas.common import UtcDatetime
from src.api.schemas.user import User
class Session(BaseModel):
model_config = ConfigDict(from_attributes=True)
token: str
token_type: Literal["Bearer"] = "Bearer"
expires_at: UtcDatetime
user: User
+8
View File
@@ -6,6 +6,8 @@ from src.api.schemas.common import NonBlankStr, UtcDatetime
from src.utils.constants import (
DISPLAY_NAME_MAX_LENGTH,
DISPLAY_NAME_MIN_LENGTH,
PASSWORD_MAX_LENGTH,
PASSWORD_MIN_LENGTH,
USERNAME_PATTERN,
)
@@ -18,6 +20,12 @@ class CreateUser(BaseModel):
min_length=DISPLAY_NAME_MIN_LENGTH,
max_length=DISPLAY_NAME_MAX_LENGTH,
)
# длина в code points; значение не обрезается и не нормализуется
password: NonBlankStr = Field(
min_length=PASSWORD_MIN_LENGTH,
max_length=PASSWORD_MAX_LENGTH,
json_schema_extra={"writeOnly": True},
)
class User(BaseModel):
+15
View File
@@ -79,6 +79,20 @@ class Database(BaseModel):
)
class Auth(BaseModel):
"""Сессии и пароли; значения — из `config.toml`.
Контрактное `SESSION_TTL_SECONDS` сопоставлено с `session_ttl_seconds`
в `REPORT.md`; разовая подмена — окружением `AUTH__SESSION_TTL_SECONDS`.
"""
# секунды жизни сессии с момента входа
session_ttl_seconds: int = Field(default=3600, gt=0)
# сколько хэшей пароля считается одновременно: Argon2id берёт 64 MiB
# памяти на каждый
kdf_concurrency: int = Field(default=4, gt=0)
class Settings(BaseSettings):
model_config = SettingsConfigDict(
extra="ignore",
@@ -90,6 +104,7 @@ class Settings(BaseSettings):
app: App = App()
database: Database = Database()
auth: Auth = Auth()
@classmethod
def settings_customise_sources(
+4 -2
View File
@@ -2,14 +2,16 @@ from .base import DomainError
from .chat import ChatNotFound, InvalidChatMembers
from .pagination import InvalidCursor
from .service import ServiceUnavailable
from .user import Unidentified, UsernameTaken
from .session import InvalidCredentials, Unauthenticated
from .user import UsernameTaken
__all__ = [
"ChatNotFound",
"DomainError",
"InvalidChatMembers",
"InvalidCredentials",
"InvalidCursor",
"ServiceUnavailable",
"Unidentified",
"Unauthenticated",
"UsernameTaken",
]
+20
View File
@@ -0,0 +1,20 @@
from .base import DomainError
class InvalidCredentials(DomainError):
"""Вход отклонён: неверный пароль, неизвестный username или битый Basic.
Все причины — одно исключение и один ответ: по нему не узнать,
существует ли пользователь. API отвечает 401 с вызовом Basic.
"""
default_message = "Invalid username or password"
class Unauthenticated(DomainError):
"""Нет Bearer-токена, он неизвестен, истёк или отозван.
API отвечает 401 с вызовом Bearer.
"""
default_message = "Authentication required"
-6
View File
@@ -1,12 +1,6 @@
from .base import DomainError
class Unidentified(DomainError):
"""Нет X-User-Id, он не UUID или такого пользователя нет."""
default_message = "User identification required"
class UsernameTaken(DomainError):
"""username уже занят."""
+59
View File
@@ -0,0 +1,59 @@
from dataclasses import asdict
from datetime import datetime
from uuid import UUID
from sqlalchemy import delete, insert, select
from sqlalchemy.ext.asyncio import AsyncSession
from src.core.repos.user import USER_COLUMNS
from src.infra.db.models import Session, User
from src.schemas import dataclasses
async def insert_session(
db_session: AsyncSession,
*,
session: dataclasses.SessionFullDTO,
) -> dataclasses.SessionFullDTO:
await db_session.execute(insert(Session).values(**asdict(session)))
return session
async def get_current_session(
db_session: AsyncSession,
*,
token_hash: bytes,
now: datetime,
) -> dataclasses.CurrentSessionDTO | None:
"""Действующая сессия по хэшу токена вместе с владельцем.
Один запрос по уникальному индексу `token_hash`. Истёкшая сессия —
None; `now` передаёт сервис: срок сравнивается по часам приложения,
которые его и поставили.
"""
statement = (
select(Session.id.label("session_id"), *USER_COLUMNS)
.join(User, User.id == Session.user_id)
.where(Session.token_hash == token_hash, Session.expires_at > now)
)
row = (await db_session.execute(statement)).one_or_none()
if row is None:
return None
fields = dict(row._mapping)
session_id = fields.pop("session_id")
return dataclasses.CurrentSessionDTO(
id=session_id,
user=dataclasses.UserFullDTO(**fields),
)
async def delete_session(
db_session: AsyncSession,
*,
session_id: UUID,
) -> bool:
"""Отзыв; False — сессию уже удалил параллельный запрос."""
statement = (
delete(Session).where(Session.id == session_id).returning(Session.id)
)
return (await db_session.execute(statement)).one_or_none() is not None
+18 -8
View File
@@ -9,20 +9,23 @@ from sqlalchemy.ext.asyncio import AsyncSession
from src.infra.db.models import User
from src.schemas import dataclasses
_USER_COLUMNS = (User.id, User.username, User.display_name, User.created_at)
# колонки UserFullDTO: хэш пароля наружу уходит только из
# get_user_credentials
USER_COLUMNS = (User.id, User.username, User.display_name, User.created_at)
async def insert_user(
db_session: AsyncSession,
*,
user: dataclasses.UserFullDTO,
password_hash: str,
) -> dataclasses.UserFullDTO | None:
"""Вставка; занятый username — None (уникальность держит БД)."""
statement = (
pg_insert(User)
.values(**asdict(user))
.values(**asdict(user), password_hash=password_hash)
.on_conflict_do_nothing(index_elements=[User.username])
.returning(*_USER_COLUMNS)
.returning(*USER_COLUMNS)
)
row = (await db_session.execute(statement)).one_or_none()
if row is None:
@@ -30,16 +33,23 @@ async def insert_user(
return dataclasses.UserFullDTO(**row._mapping)
async def get_user(
async def get_user_credentials(
db_session: AsyncSession,
*,
user_id: UUID,
) -> dataclasses.UserFullDTO | None:
statement = select(*_USER_COLUMNS).where(User.id == user_id)
username: str,
) -> dataclasses.UserCredentialsDTO | None:
statement = select(*USER_COLUMNS, User.password_hash).where(
User.username == username,
)
row = (await db_session.execute(statement)).one_or_none()
if row is None:
return None
return dataclasses.UserFullDTO(**row._mapping)
fields = dict(row._mapping)
password_hash = fields.pop("password_hash")
return dataclasses.UserCredentialsDTO(
user=dataclasses.UserFullDTO(**fields),
password_hash=password_hash,
)
async def get_existing_user_ids(
+2
View File
@@ -1,9 +1,11 @@
from .chat import ChatService
from .message import MessageService
from .session import SessionService
from .user import UserService
__all__ = [
"ChatService",
"MessageService",
"SessionService",
"UserService",
]
+120
View File
@@ -0,0 +1,120 @@
import hashlib
import secrets
from datetime import timedelta
from uuid import UUID, uuid4
from sqlalchemy.ext.asyncio import AsyncSession
from src.config import settings
from src.core import exceptions
from src.core.repos import session as session_repo
from src.core.repos import user as user_repo
from src.infra.logger import AbstractLogger, get_logger
from src.infra.password import verify_password
from src.schemas import dataclasses
from src.utils.constants import SESSION_TOKEN_BYTES
from src.utils.utc import utcnow
logger: AbstractLogger = get_logger().bind(module="session_service")
def hash_token(token: str) -> bytes:
"""SHA-256 токена: в БД хранится он, а не токен.
Быстрого хэша хватает: у токена 256 бит случайности, перебирать
нечего. Медленный KDF нужен паролю, который выбирает человек.
"""
return hashlib.sha256(token.encode()).digest()
class SessionService:
def __init__(self, db_session: AsyncSession) -> None:
self.db_session = db_session
async def login(
self,
*,
username: str,
password: str,
) -> dataclasses.SessionTokenDTO:
"""Вход: проверка пароля и новая сессия.
Две транзакции: чтение хэша закрывается до KDF, чтобы соединение
пула не ждало хэш и очередь лимита (design change `session-auth`,
решение 3). Пароли и пользователи не меняются, поэтому между
транзакциями проверять нечего.
"""
log = logger.bind(method="login")
credentials = await user_repo.get_user_credentials(
db_session=self.db_session,
username=username,
)
await self.db_session.commit()
# неизвестный username проверяется против фиктивного хэша: время
# ответа то же, что у неверного пароля
valid = await verify_password(
password=password,
password_hash=credentials.password_hash if credentials else None,
)
if credentials is None or not valid:
# без username и пароля: по журналу не перебрать имена
log.warning("Login failed")
raise exceptions.InvalidCredentials
token = secrets.token_urlsafe(SESSION_TOKEN_BYTES)
now = utcnow()
session = await session_repo.insert_session(
db_session=self.db_session,
session=dataclasses.SessionFullDTO(
id=uuid4(),
user_id=credentials.user.id,
token_hash=hash_token(token),
expires_at=now
+ timedelta(seconds=settings.auth.session_ttl_seconds),
created_at=now,
),
)
await self.db_session.commit()
log.info(
"Created session",
user_id=session.user_id,
session_id=session.id,
ttl_seconds=settings.auth.session_ttl_seconds,
)
return dataclasses.SessionTokenDTO(
token=token,
expires_at=session.expires_at,
user=credentials.user,
)
async def authenticate(
self,
*,
token: str | None,
) -> dataclasses.CurrentSessionDTO:
"""Действующая сессия по Bearer-токену; иначе `Unauthenticated`.
Ошибка БД сюда не превращается: её переводит в 503
`get_db_session`, недоступность хранилища не делает токен
недействительным.
"""
if not token:
raise exceptions.Unauthenticated
current = await session_repo.get_current_session(
db_session=self.db_session,
token_hash=hash_token(token),
now=utcnow(),
)
if current is None:
raise exceptions.Unauthenticated
return current
async def revoke(self, *, session_id: UUID) -> None:
log = logger.bind(method="revoke", session_id=session_id)
deleted = await session_repo.delete_session(
db_session=self.db_session,
session_id=session_id,
)
await self.db_session.commit()
# False — параллельный выход тем же токеном уже удалил сессию
log.info("Revoked session", already_revoked=not deleted)
+6 -25
View File
@@ -1,10 +1,11 @@
from uuid import UUID, uuid4
from uuid import uuid4
from sqlalchemy.ext.asyncio import AsyncSession
from src.core import exceptions
from src.core.repos import user as user_repo
from src.infra.logger import AbstractLogger, get_logger
from src.infra.password import hash_password
from src.schemas import dataclasses
from src.utils.utc import utcnow
@@ -20,8 +21,11 @@ class UserService:
*,
username: str,
display_name: str,
password: str,
) -> dataclasses.UserFullDTO:
log = logger.bind(method="register")
# KDF до обращения к БД: соединение пула не ждёт хэш
password_hash = await hash_password(password)
user = dataclasses.UserFullDTO(
id=uuid4(),
username=username,
@@ -33,6 +37,7 @@ class UserService:
created = await user_repo.insert_user(
db_session=self.db_session,
user=user,
password_hash=password_hash,
)
if created is None:
log.info("Username is already taken")
@@ -40,27 +45,3 @@ class UserService:
await self.db_session.commit()
log.info("Created user", created_user_id=created.id)
return created
async def identify(
self,
*,
raw_user_id: str | None,
) -> dataclasses.UserFullDTO:
"""Текущий пользователь по значению X-User-Id.
Нет заголовка, не UUID или пользователя нет — одинаковое
`Unidentified`.
"""
if raw_user_id is None:
raise exceptions.Unidentified
try:
user_id = UUID(raw_user_id)
except ValueError:
raise exceptions.Unidentified from None
user = await user_repo.get_user(
db_session=self.db_session,
user_id=user_id,
)
if user is None:
raise exceptions.Unidentified
return user
+2
View File
@@ -4,6 +4,7 @@
from src.infra.db.models.base import Base
from src.infra.db.models.chat import Chat, ChatMember
from src.infra.db.models.message import Message
from src.infra.db.models.session import Session
from src.infra.db.models.user import User
__all__ = [
@@ -11,5 +12,6 @@ __all__ = [
"Chat",
"ChatMember",
"Message",
"Session",
"User",
]
+41
View File
@@ -0,0 +1,41 @@
from datetime import datetime
from uuid import UUID
from sqlalchemy import (
CheckConstraint,
DateTime,
ForeignKey,
LargeBinary,
UniqueConstraint,
)
from sqlalchemy.orm import Mapped, mapped_column
from src.infra.db.models.base import Base
from src.utils.constants import TOKEN_HASH_BYTES
class Session(Base):
"""Сессия входа.
Хранится SHA-256 токена, а не токен: по таблице действующий токен не
восстановить. `expires_at` фиксируется при входе. Отзыв — удаление
строки.
"""
__tablename__ = "sessions"
__table_args__ = (
UniqueConstraint("token_hash"),
CheckConstraint(
f"octet_length(token_hash) = {TOKEN_HASH_BYTES}",
name="token_hash_length",
),
CheckConstraint(
"expires_at > created_at",
name="expires_after_created",
),
)
id: Mapped[UUID] = mapped_column(primary_key=True)
user_id: Mapped[UUID] = mapped_column(ForeignKey("users.id"))
token_hash: Mapped[bytes] = mapped_column(LargeBinary)
expires_at: Mapped[datetime] = mapped_column(DateTime(timezone=True))
+7
View File
@@ -7,6 +7,7 @@ from src.infra.db.models.base import Base
from src.utils.constants import (
DISPLAY_NAME_MAX_LENGTH,
DISPLAY_NAME_MIN_LENGTH,
PASSWORD_HASH_PREFIX,
USERNAME_PATTERN,
)
@@ -25,8 +26,14 @@ class User(Base):
f"{DISPLAY_NAME_MIN_LENGTH} AND {DISPLAY_NAME_MAX_LENGTH}",
name="display_name_length",
),
# защита в глубину: открытый пароль или быстрый хэш не запишется
CheckConstraint(
f"password_hash LIKE '{PASSWORD_HASH_PREFIX}%'",
name="password_hash_argon2id",
),
)
id: Mapped[UUID] = mapped_column(primary_key=True)
username: Mapped[str] = mapped_column(Text)
display_name: Mapped[str] = mapped_column(Text)
password_hash: Mapped[str] = mapped_column(Text)
+67
View File
@@ -0,0 +1,67 @@
"""Хэширование паролей: Argon2id в потоке с отдельным лимитом.
Профиль RFC 9106 low-memory (t=3, m=64 MiB, p=4) назван явно, а не взят
умолчанием argon2-cffi: обновление библиотеки не меняет его молча. Один
хэш — около 30 мс CPU и 64 MiB памяти, поэтому он считается в потоке, а
не в event loop, и не больше `[auth] kdf_concurrency` одновременно
(design change `session-auth`, решение 3).
"""
import secrets
import anyio
from anyio import to_thread
from argon2 import PasswordHasher, profiles
from argon2.exceptions import VerifyMismatchError
from src.config import settings
_hasher = PasswordHasher.from_parameters(profiles.RFC_9106_LOW_MEMORY)
# свой лимит, а не общий пул anyio на 40 потоков: 40 × 64 MiB = 2,5 GiB.
# При отмене запроса место освобождается только после конца потока
_limiter = anyio.CapacityLimiter(settings.auth.kdf_concurrency)
# хэш для неизвестного username: считается при первом входе
_dummy_hash: str | None = None
async def hash_password(password: str) -> str:
"""Строка Argon2id с параметрами и солью; пароль — целиком, UTF-8."""
return await to_thread.run_sync(_hasher.hash, password, limiter=_limiter)
async def verify_password(*, password: str, password_hash: str | None) -> bool:
"""Подходит ли пароль к хэшу.
`password_hash` `None` — пользователя нет. Пароль всё равно
проверяется, против фиктивного хэша: время ответа не выдаёт,
существует ли username.
"""
if password_hash is None:
await to_thread.run_sync(
_matches,
await _get_dummy_hash(),
password,
limiter=_limiter,
)
return False
return await to_thread.run_sync(
_matches,
password_hash,
password,
limiter=_limiter,
)
def _matches(password_hash: str, password: str) -> bool:
# повреждённый хэш (InvalidHashError) — дефект, а не неверный пароль
try:
return _hasher.verify(password_hash, password)
except VerifyMismatchError:
return False
async def _get_dummy_hash() -> str:
global _dummy_hash
if _dummy_hash is None:
_dummy_hash = await hash_password(secrets.token_urlsafe(16))
return _dummy_hash
+6 -1
View File
@@ -1,11 +1,16 @@
from .chat import ChatFullDTO, ChatPageDTO
from .message import MessageFullDTO, MessagePageDTO
from .user import UserFullDTO
from .session import CurrentSessionDTO, SessionFullDTO, SessionTokenDTO
from .user import UserCredentialsDTO, UserFullDTO
__all__ = [
"ChatFullDTO",
"ChatPageDTO",
"CurrentSessionDTO",
"MessageFullDTO",
"MessagePageDTO",
"SessionFullDTO",
"SessionTokenDTO",
"UserCredentialsDTO",
"UserFullDTO",
]
+33
View File
@@ -0,0 +1,33 @@
from dataclasses import dataclass
from datetime import datetime
from uuid import UUID
from .user import UserFullDTO
@dataclass(frozen=True, slots=True)
class SessionFullDTO:
"""Строка сессии: SHA-256 токена, а не сам токен."""
id: UUID
user_id: UUID
token_hash: bytes
expires_at: datetime
created_at: datetime
@dataclass(frozen=True, slots=True)
class SessionTokenDTO:
"""Результат входа: токен существует только здесь и в ответе API."""
token: str
expires_at: datetime
user: UserFullDTO
@dataclass(frozen=True, slots=True)
class CurrentSessionDTO:
"""Действующая сессия запроса и её владелец."""
id: UUID
user: UserFullDTO
+10
View File
@@ -5,7 +5,17 @@ from uuid import UUID
@dataclass(frozen=True, slots=True)
class UserFullDTO:
"""Пользователь без хэша пароля: в таком виде он уходит в API."""
id: UUID
username: str
display_name: str
created_at: datetime
@dataclass(frozen=True, slots=True)
class UserCredentialsDTO:
"""Пользователь и хэш пароля — только для входа."""
user: UserFullDTO
password_hash: str
+12 -1
View File
@@ -12,12 +12,23 @@ HEALTH_PATHS = frozenset({HEALTH_LIVE_PATH, HEALTH_READY_PATH})
# заголовки
REQUEST_ID_HEADER = "X-Request-Id"
USER_ID_HEADER = "X-User-Id"
# пользователь
USERNAME_PATTERN = r"^[a-z0-9_]{3,32}$"
DISPLAY_NAME_MIN_LENGTH = 1
DISPLAY_NAME_MAX_LENGTH = 100
PASSWORD_MIN_LENGTH = 12
PASSWORD_MAX_LENGTH = 128
# начало хэша Argon2id: CHECK в БД не даёт записать пароль иначе
PASSWORD_HASH_PREFIX = "$argon2id$"
# сессия
# байты случайности токена: 256 бит, 43 символа base64url
SESSION_TOKEN_BYTES = 32
# в БД хранится SHA-256 токена, а не токен
TOKEN_HASH_BYTES = 32
# realm в WWW-Authenticate
AUTH_REALM = "messenger"
# чат
CHAT_TITLE_MIN_LENGTH = 1