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:
+106
-23
@@ -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
@@ -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,
|
||||
)
|
||||
|
||||
|
||||
|
||||
@@ -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)
|
||||
|
||||
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
|
||||
|
||||
@@ -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",
|
||||
]
|
||||
|
||||
@@ -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
|
||||
@@ -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):
|
||||
|
||||
@@ -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(
|
||||
|
||||
@@ -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",
|
||||
]
|
||||
|
||||
@@ -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"
|
||||
@@ -1,12 +1,6 @@
|
||||
from .base import DomainError
|
||||
|
||||
|
||||
class Unidentified(DomainError):
|
||||
"""Нет X-User-Id, он не UUID или такого пользователя нет."""
|
||||
|
||||
default_message = "User identification required"
|
||||
|
||||
|
||||
class UsernameTaken(DomainError):
|
||||
"""username уже занят."""
|
||||
|
||||
|
||||
@@ -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
@@ -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(
|
||||
|
||||
@@ -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",
|
||||
]
|
||||
|
||||
@@ -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)
|
||||
@@ -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
|
||||
|
||||
@@ -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",
|
||||
]
|
||||
|
||||
@@ -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,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)
|
||||
|
||||
@@ -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
|
||||
@@ -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",
|
||||
]
|
||||
|
||||
@@ -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
|
||||
@@ -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
@@ -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
|
||||
|
||||
Reference in New Issue
Block a user