diff --git a/.claude/rules/auth.md b/.claude/rules/auth.md index c169e2e6..742fa940 100644 --- a/.claude/rules/auth.md +++ b/.claude/rules/auth.md @@ -25,6 +25,14 @@ paths: - Хэширование и проверка занимают десятки миллисекунд CPU. В event loop их не вызывать: `await anyio.to_thread.run_sync(...)`, иначе один вход останавливает все запросы процесса. +- Всё это — `src/infra/password.py`: профиль + `RFC_9106_LOW_MEMORY` (t=3, m=64 MiB, p=4) назван явно, а не взят + умолчанием библиотеки; свой `CapacityLimiter` на + `[auth] kdf_concurrency` (4), а не общий пул anyio на 40 потоков: + 40 × 64 MiB = 2,5 GiB (design change `session-auth`, решение 3). +- Регистрация хэширует пароль до обращения к БД. Вход читает хэш и + закрывает транзакцию (`commit()`) до проверки пароля: соединение пула + не ждёт KDF и очередь лимита; сессия вставляется второй транзакцией. - Пароль хэшируется целиком как UTF-8, без обрезки и нормализации. Хэш не выходит за пределы repo и сервиса входа: в `UserFullDTO` и в ответе API его нет (`dto.md`). @@ -35,10 +43,17 @@ paths: ## Basic на входе - Разбор свой, `HTTPBasic` FastAPI не годится (`api-contract.md`, - «FastAPI»). Схема `Basic` без учёта регистра → base64 строго - (`b64decode(..., validate=True)`) → UTF-8 → `partition(":")` по - **первому** двоеточию: в username двоеточия не бывает, в пароле оно - допустимо. Любой сбой разбора — тот же 401, что и неверный пароль. + «FastAPI»). Схему `basicAuth` объявляет + `HTTPBase(scheme="basic", scheme_name="basicAuth", auto_error=False)` + (импорт из `fastapi.security.http`: из `fastapi.security` его нет): он + отдаёт схему и credentials как есть. Дальше схема `Basic` без учёта + регистра → base64 строго (`b64decode(..., validate=True)`) → UTF-8 → + `partition(":")` по **первому** двоеточию: в username двоеточия не + бывает, в пароле оно допустимо. Любой сбой разбора — тот же 401, что и + неверный пароль. +- Username не по шаблону и пароль вне 12–128 code points отсекаются при + разборе: тот же 401 без запроса к БД и KDF. Формат публичный, о + пользователях такой отказ ничего не говорит. - JSON-тело на входе не читается. - 401 входа — с `WWW-Authenticate: Basic realm="messenger", charset="UTF-8"`. @@ -54,26 +69,34 @@ paths: - `expires_at = utcnow() + TTL` фиксируется при создании и хранится. Ни использование, ни рестарт срок не продлевают. На каждом запросе проверяется: сессия есть, не отозвана, `expires_at` в будущем. -- TTL — `[auth] session_ttl_seconds`; контрактное имя - `SESSION_TTL_SECONDS` приходит мостом (`settings.md`). По умолчанию - 3600, в обычном smoke не меньше 300, в тесте истечения — 2. +- TTL — `[auth] session_ttl_seconds` в `config.toml`; контрактное имя + `SESSION_TTL_SECONDS` сопоставлено с ним в `REPORT.md`, мостом не + заводится (`settings.md`). Разовая подмена — + `AUTH__SESSION_TTL_SECONDS` в окружении. По умолчанию 3600, в обычном + smoke не меньше 300, в тесте истечения — 2. - `DELETE /auth/sessions/current` отзывает только текущую сессию, дальше этот токен получает 401. -- Сессии в Postgres — таблица с id, `user_id` (внешний ключ), SHA-256 - токена (уникальный индекс), `created_at` и `expires_at` - (`timestamptz`). Отзыв — удаление строки или отметка времени отзыва. -- Хранилище сессий — PostgreSQL или Redis/Valkey, выбор фиксирует - design change. Любой вариант обязан: пережить рестарт (Redis/Valkey — - только с persistence, одного TTL мало, `docker.md`), соблюдать срок и - отзыв, при недоступности отвечать ограниченной ошибкой и никогда не +- Сессии — в PostgreSQL, без кэша: отзыв мгновенный (design change + `session-auth`). Таблица `sessions`: id, `user_id` (внешний ключ), + SHA-256 токена (`bytea`, уникальный индекс, `CHECK` на 32 байта), + `created_at` и `expires_at` (`timestamptz`). Отзыв — удаление строки. + Проверка токена — один `SELECT` по `token_hash` с `JOIN` на + пользователя; `now` для `expires_at > now` передаёт сервис, срок + сравнивается по часам приложения. +- Redis/Valkey сессии не хранит: он — кэш состава чатов + (`membership-cache`). Любое хранилище сессий обязано пережить рестарт, + соблюдать срок и отзыв, при недоступности отвечать 503 и никогда не пропускать запрос как анонимный или доверенный. ## Текущий пользователь -- `get_current_user` (`src/api/dependencies.py`): - `HTTPBearer(scheme_name="bearerAuth", auto_error=False)` → токен или - `None` → сервис сессий → `UserFullDTO`. Иначе доменное исключение → - 401 с `WWW-Authenticate: Bearer realm="messenger"`. +- `get_current_session` (`src/api/dependencies.py`): + `HTTPBearer(scheme_name="bearerAuth", bearerFormat="opaque session + token", auto_error=False)` — как в контракте → токен или `None` → + `SessionService.authenticate` → `CurrentSessionDTO` (id сессии и + `UserFullDTO`). Иначе `Unauthenticated` → 401 с `WWW-Authenticate: + Bearer realm="messenger"`. `get_current_user` берёт пользователя из + неё, logout — id сессии. - `X-User-Id` не читается нигде. Basic на бизнес-ручке для `HTTPBearer` — чужая схема: он отдаёт `None`, и получается тот же 401 с вызовом Bearer. @@ -87,4 +110,6 @@ paths: Никогда не логируются пароль, токен, его хэш и заголовок `Authorization`. Создание и отзыв сессии — `info` с `user_id` и id -сессии, неудачный вход — `warning` без пароля (`logging.md`). +сессии, неудачный вход — `warning` без username и пароля +(`logging.md`). Параметры SQL в журнал не попадают: engine создан с +`hide_parameters=True` (`infra.md`). diff --git a/.claude/rules/settings.md b/.claude/rules/settings.md index 75bb5332..0a6d8015 100644 --- a/.claude/rules/settings.md +++ b/.claude/rules/settings.md @@ -29,10 +29,11 @@ console и docker — `.claude/rules/run-modes.md`. Здесь — откуда `settings.database.password` так же, как `[database] password` из TOML. Переменную без префикса секции (`APP_PORT`, `POSTGRES_PASSWORD`) приложение не видит: она для compose. -- Имена переменных, которые задаёт контракт (`SESSION_TTL_SECONDS`), - тоже не выносятся из секций. Поле остаётся в секции - (`[auth] session_ttl_seconds`), а контрактное имя приходит мостом - (раздел «Мосты» ниже). +- Имена из контракта и skeleton (`SESSION_TTL_SECONDS`, `APP_HOST`) + буквально не заводятся, если значение читает только приложение. Поле + живёт в секции (`[auth] session_ttl_seconds` в `config.toml`), а + соответствие имени описано в `REPORT.md`. Мост — только для значения, + которое читает ещё контейнер зависимости (раздел «Мосты» ниже). - `extra="ignore"`: опечатка в ключе молча оставит дефолт. После правки проверить конкретное поле: `uv run python -c "from src.config import settings; print(settings.app.port)"`. Полный дамп настроек не печатать: @@ -100,6 +101,13 @@ compose полю секции: `docker run --env-file .env` раскрывать `${...}` не умеет и передаст строку буквально, поэтому стенд запускается только через compose. +Окружение не перекрывает мост по исходному имени. python-dotenv +подставляет `${VAR}` сначала из самого `.env` и лишь потом из окружения, +поэтому `POSTGRES_OUT_PORT=5545 uv run ...` оставит в `DATABASE__PORT` +значение из файла (проверено на таком же мосте срока сессии, change +`session-auth`). Разовая подмена — +только по имени поля: `DATABASE__PORT=5545`. + ## Консоль и docker из одного `.env` Переключение консоль ↔ docker не требует правки файлов и @@ -116,14 +124,15 @@ compose полю секции: Адрес и порт Postgres в compose — только переменные `.env`, литерал — лишь адрес публикации `127.0.0.1` (`docker.md`). -Контрактное `SESSION_TTL_SECONDS` устроено так же: переменная под этим -именем в `.env` и мост `AUTH__SESSION_TTL_SECONDS=${SESSION_TTL_SECONDS}` -в `.env` и в `environment` сервиса compose. - `.env.example` skeleton lab2 предлагает «логические» имена: `APP_HOST`, `APP_PORT`, `APP_ENV`, `SESSION_TTL_SECONDS`, `DATABASE_URL_FILE`, -`SESSION_STORE`, `CACHE_URL_FILE`. Из них контрактное только -`SESSION_TTL_SECONDS`, остальные — предложения. В нашей схеме пароль +`SESSION_STORE`, `CACHE_URL_FILE`; шапка шаблона просит сопоставить их +с реальными в `REPORT.md`. `SESSION_TTL_SECONDS` называют ещё контракт и +рубрика, но ни одна публичная проверка его не читает. Срок сессии читает +только приложение, поэтому это `[auth] session_ttl_seconds` в +`config.toml`, а короткий срок для проверки истечения — +`AUTH__SESSION_TTL_SECONDS=2` в окружении. Мост с контрактным именем +ничего бы не дал: по абзацу выше окружение его не перекрывает. Пароль Postgres приходит мостом из `POSTGRES_PASSWORD`, а не строкой подключения в файле (`*_URL_FILE`). Соответствие переменных реальной конфигурации описать в `REPORT.md` (раздел «Архитектура и решения»). diff --git a/.claude/skills/run-mtusi-messenger/SKILL.md b/.claude/skills/run-mtusi-messenger/SKILL.md index bb072a73..ac1a0398 100644 --- a/.claude/skills/run-mtusi-messenger/SKILL.md +++ b/.claude/skills/run-mtusi-messenger/SKILL.md @@ -15,10 +15,11 @@ FastAPI/uvicorn, данные в PostgreSQL из compose. Агент управ Все пути — от корня репозитория. Проверено на macOS (arm64), uv 0.12, Python 3.12 из `.python-version`, Docker Desktop 29.8. -До change `session-auth` API идентифицирует по `X-User-Id`, поэтому -публичный smoke лабы 2 падает на регистрации с `password` (400), а в -`student-tests` падает `test_security_scheme_in_openapi`: схемы `devUser` -нет в контракте lab2. Это ожидаемо (AGENTS.md, «Переходное состояние»). +Аутентификация лабы 2: регистрация с `password`, вход +`POST /api/v1/auth/sessions` по `Authorization: Basic`, дальше — +`Authorization: Bearer `. `X-User-Id` доступа не даёт. Пароль — +Argon2id, около 30 мс на регистрацию и вход, поэтому `flow` и +`student-tests` идут дольше, чем на лабе 1. ## Setup @@ -44,12 +45,14 @@ python3 $D all # start → flow → tests/smoke.py → student-tests → st ```bash python3 $D start # make upgrade, затем фон; ждёт /health/ready до 30 с python3 $D status # listeners: [pid reloader, pid worker], ready: True -python3 $D flow # ~35 проверок: регистрация, 409, /me, 401, чат, 5 сообщений, - # пагинация limit=2 по курсору, чужой → 404, 400-е, X-Request-Id -python3 $D req POST /api/v1/users --data '{"username":"zoe_demo","display_name":"Зоя"}' -python3 $D req GET /api/v1/users/me --user +python3 $D flow # ~50 проверок: регистрация с паролем, вход, 409, неверный пароль, + # 401 с WWW-Authenticate, X-User-Id игнорируется, чат, 5 сообщений, + # пагинация limit=2 по курсору, чужой → 404, 400-е, logout +python3 $D req POST /api/v1/users --data '{"username":"zoe_demo","display_name":"Зоя","password":"Zoe-password-1"}' +python3 $D req POST /api/v1/auth/sessions --basic zoe_demo:Zoe-password-1 +python3 $D req GET /api/v1/users/me --token python3 $D smoke # публичный tests/smoke.py против этого порта -python3 $D student # make student_test BASE_URL=http://localhost: — 80 тестов, ~1,5 с +python3 $D student # make student_test BASE_URL=http://localhost: — 99 тестов, ~11 с python3 $D stop ``` @@ -57,8 +60,8 @@ python3 $D stop |---|---| | `start` | `make upgrade`, затем `APP__RUN_MODE=console APP__PORT= uv run python -m src` в своей группе процессов | | `status` | кто слушает порт, отвечает ли `/health/ready`; код 1, если никого | -| `flow` | сквозной сценарий; `[FAIL]` в строке и код 1 при провале; в конце печатает id alice/bob/eve/chat | -| `req METHOD PATH [--user UUID] [--data JSON]` | один запрос: статус, `x-request-id`, тело; код 2 при статусе ≥ 400 | +| `flow` | сквозной сценарий; `[FAIL]` в строке и код 1 при провале; в конце печатает id alice/bob/eve/chat и синтетический токен alice | +| `req METHOD PATH [--token T \| --basic USER:PASS] [--data JSON]` | один запрос: статус, `x-request-id`, `www-authenticate` у 401, тело; код 2 при статусе ≥ 400 | | `smoke` | `tests/smoke.py --base-url http://localhost:` | | `student` | `make student_test BASE_URL=http://localhost:` (pytest по `student-tests/`); код 1, если каталога нет | | `stop` | SIGTERM всей группе; ждёт, пока порт освободится. Чужой сервер и контейнер не трогает | @@ -82,7 +85,8 @@ make run_docker APP_OUT_PORT=18090 # build + up -d: postgres → migrat docker compose ps -a --format '{{.Name}} {{.Ports}} {{.Status}}' python3 $D --port 18090 flow # те же проверки против контейнера docker compose logs --no-log-prefix api | tail -5 # JSON-строки, без -f -scripts/restart.sh # рестарт API и Postgres: данные и X-User-Id остаются +scripts/restart.sh # рестарт API и Postgres: данные и токены остаются +make test-persistence ACTION_SCRIPT=scripts/restart.sh # то же публичной проверкой make down # удалить контейнеры, volume с данными остаётся make wipe_data # удалить и данные: только после ввода yes ``` @@ -103,17 +107,20 @@ make upgrade APP__LOG_LEVEL=WARNING uv run python - <<'EOF' import asyncio import uuid -from src.core.services import UserService +from src.core.services import SessionService, UserService from src.infra.db.session import engine, session_factory async def main(): async with session_factory() as db_session: - users = UserService(db_session=db_session) - user = await users.register( - username=f"alice_{uuid.uuid4().hex[:6]}", + username = f"alice_{uuid.uuid4().hex[:6]}" + await UserService(db_session=db_session).register( + username=username, display_name="Alice", + password="Alice-password-1", ) - print(await users.identify(raw_user_id=str(user.id))) + sessions = SessionService(db_session=db_session) + issued = await sessions.login(username=username, password="Alice-password-1") + print(await sessions.authenticate(token=issued.token)) await engine.dispose() asyncio.run(main()) @@ -123,8 +130,9 @@ EOF `ChatService` и `MessageService` создаются так же (`db_session=...`), все методы keyword-only, commit делает сам сервис. Ошибки — доменные исключения из `src.core.exceptions` (базовый `DomainError`), не -HTTP-коды: `identify(raw_user_id="not-a-uuid")` бросает `Unidentified`. -Созданное так остаётся в рабочей базе. +HTTP-коды: `authenticate(token="x")` бросает `Unauthenticated`, неверный +пароль в `login` — `InvalidCredentials`. Созданное так остаётся в рабочей +базе. ## Run (human path) @@ -143,11 +151,9 @@ python3 $D all # живой сервер + flow + s make lint # ruff; затрагивает и driver.py ``` -Ожидаемо до `session-auth`: `PASS: offline skeleton structure...`, -`FAILED: none` у `flow`, smoke — `FAIL: POST /api/v1/users: expected -[201], received 400`, student — `1 failed, 79 passed` -(`test_security_scheme_in_openapi`), `All checks passed!`. Поэтому -`all` и `test_isolated` пока выходят с ненулевым кодом. +Ожидаемо: `PASS: offline skeleton structure...`, `FAILED: none` у +`flow`, smoke — `PASS: lab2 public API scenario...`, student — все +прошли, `All checks passed!`; `all` и `test_isolated` — код 0. ## Gotchas @@ -161,7 +167,7 @@ make lint # ruff; затрагивает и dr стенд — `make wipe_data`. - **Правка файла в `src/` перезапускает worker** (`WatchFiles detected changes ... Reloading...`), задевает и `make run_dev` на 8080. Данные - в Postgres остаются, прежние `X-User-Id` работают. + и сессии в Postgres остаются, прежние токены работают. - **`lsof` на порт показывает два PID** — reloader и worker делят один сокет. Убивать по `lsof -t | xargs kill` бессмысленно: reloader поднимет worker снова. Драйвер шлёт SIGTERM группе процессов; SIGTERM @@ -183,8 +189,14 @@ make lint # ruff; затрагивает и dr контейнера показывает один PID — процесс Docker Desktop, а не uvicorn. - **`make logs` висит** (`logs -f`) — агенту нужен `docker compose logs --no-log-prefix api` без `-f`. -- **`req` без `--user` на защищённом пути даёт 401 `unauthorized`** — это - не сломанный сервер, а контракт: идентификация раньше доступа. +- **`req` без `--token` на защищённом пути даёт 401 `unauthorized`** с + `www-authenticate: Bearer realm="messenger"` — это не сломанный + сервер, а контракт: аутентификация раньше доступа. Токен — из ответа + `req POST /api/v1/auth/sessions --basic USER:PASS` или последняя строка + `flow`. +- **Короткий срок сессии для проверки истечения** — окружением + `AUTH__SESSION_TTL_SECONDS=2 python3 $D start`: окружение важнее + `.env` и `config.toml`. ## Troubleshooting diff --git a/.claude/skills/run-mtusi-messenger/driver.py b/.claude/skills/run-mtusi-messenger/driver.py index 941b35b3..4b6ba10e 100644 --- a/.claude/skills/run-mtusi-messenger/driver.py +++ b/.claude/skills/run-mtusi-messenger/driver.py @@ -11,7 +11,8 @@ /health/ready; лог и pid — /tmp/mtusi-api-.{log,pid} status кто слушает порт и что отвечает /health/ready flow сквозной сценарий по HTTP с проверками; код выхода 1 при провале - req один запрос: req METHOD PATH [--user UUID] [--data JSON] + req один запрос: req METHOD PATH [--token T | --basic USER:PASS] + [--data JSON] smoke публичный tests/smoke.py против этого порта student собственные тесты student-tests/ (make student_test) против этого порта @@ -26,6 +27,7 @@ student работают с любым сервером на порту, в то """ import argparse +import base64 import contextlib import json import os @@ -42,6 +44,9 @@ ROOT = Path(__file__).resolve().parents[3] DEFAULT_PORT = 18080 USERS = "/api/v1/users" CHATS = "/api/v1/chats" +SESSIONS = "/api/v1/auth/sessions" +BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"' +BEARER_CHALLENGE = 'Bearer realm="messenger"' def paths(port: int) -> tuple[Path, Path]: @@ -55,12 +60,20 @@ def base_url(port: int) -> str: return f"http://127.0.0.1:{port}" +def basic(username: str, password: str) -> str: + """Значение `Authorization: Basic` из username и пароля в UTF-8.""" + raw = f"{username}:{password}".encode() + return "Basic " + base64.b64encode(raw).decode("ascii") + + def call( port: int, method: str, path: str, *, - user: str | None = None, + token: str | None = None, + authorization: str | None = None, + extra: dict[str, str] | None = None, body: object = None, raw: bytes | None = None, ) -> tuple[int, dict[str, str], object]: @@ -70,8 +83,11 @@ def call( data = json.dumps(body).encode() if data is not None: headers["Content-Type"] = "application/json" - if user is not None: - headers["X-User-Id"] = user + if token is not None: + headers["Authorization"] = f"Bearer {token}" + if authorization is not None: + headers["Authorization"] = authorization + headers.update(extra or {}) request = urllib.request.Request( base_url(port) + path, data=data, @@ -189,14 +205,21 @@ def cmd_status(port: int) -> int: def cmd_req(port: int, args: argparse.Namespace) -> int: body = json.loads(args.data) if args.data is not None else None + authorization = None + if args.basic is not None: + username, _, password = args.basic.partition(":") + authorization = basic(username, password) status, hdrs, payload = call( port, args.method.upper(), args.path, - user=args.user, + token=args.token, + authorization=authorization, body=body, ) print(status, "x-request-id:", hdrs.get("x-request-id")) + if "www-authenticate" in hdrs: + print("www-authenticate:", hdrs["www-authenticate"]) print(json.dumps(payload, ensure_ascii=False, indent=2)) return 0 if status < 400 else 2 @@ -218,9 +241,11 @@ class Flow: method: str, path: str, status: int, + challenge: str | None = None, **kwargs: object, ) -> object: - """Запрос + проверка статуса, X-Request-Id и формата ошибки.""" + """Запрос + проверка статуса, X-Request-Id, формата ошибки и, + если задан, `WWW-Authenticate`.""" got, hdrs, payload = call(self.port, method, path, **kwargs) request_id = hdrs.get("x-request-id") ok = got == status and bool(request_id) @@ -231,6 +256,9 @@ class Flow: error = payload.get("error", {}) ok = ok and error.get("request_id") == request_id detail = f"{got} {error.get('code')}" + if challenge is not None: + ok = ok and hdrs.get("www-authenticate") == challenge + detail += f" {hdrs.get('www-authenticate')}" shown = path if len(path) <= 60 else path[:57] + "..." self.check(f"{method} {shown} -> {status} ({label})", ok, detail) return payload @@ -242,42 +270,104 @@ def cmd_flow(port: int) -> int: flow.expect("live", "GET", "/health/live", 200) flow.expect("ready", "GET", "/health/ready", 200) - ids = {} + me_path = f"{USERS}/me" + ids, tokens, logins = {}, {}, {} for name in ("alice", "bob", "eve"): - body = {"username": f"{name}_{tag}", "display_name": f"{name} ✨"} - ids[name] = flow.expect("register", "POST", USERS, 201, body=body)[ - "id" - ] - alice, bob, eve = ids["alice"], ids["bob"], ids["eve"] - dup = {"username": f"alice_{tag}", "display_name": "again"} + username, password = f"{name}_{tag}", f"Pw-{name}-{uuid.uuid4().hex}" + body = { + "username": username, + "display_name": f"{name} ✨", + "password": password, + } + user = flow.expect("register", "POST", USERS, 201, body=body) + flow.check("no password in User", "password" not in user) + session = flow.expect( + "login", + "POST", + SESSIONS, + 201, + authorization=basic(username, password), + ) + ids[name], tokens[name] = user["id"], session["token"] + logins[name] = (username, password) + alice, bob, eve = tokens["alice"], tokens["bob"], tokens["eve"] + dup = { + "username": f"alice_{tag}", + "display_name": "again", + "password": "Another-password-1", + } flow.expect("duplicate username", "POST", USERS, 409, body=dup) - me = flow.expect("me", "GET", f"{USERS}/me", 200, user=alice) - flow.check("me.id == alice", me.get("id") == alice) - flow.expect("no X-User-Id", "GET", f"{USERS}/me", 401) - stranger = str(uuid.uuid4()) - flow.expect("unknown user", "GET", f"{USERS}/me", 401, user=stranger) + no_password = {"username": f"nopw_{tag}", "display_name": "x"} + flow.expect("no password", "POST", USERS, 400, body=no_password) - body = {"title": "Проект 🚀", "member_ids": [alice, bob]} - chat = flow.expect("new chat", "POST", CHATS, 201, user=alice, body=body) + username, password = logins["alice"] + wrong = basic(username, "Wrong-password-1") + flow.expect( + "wrong password", + "POST", + SESSIONS, + 401, + challenge=BASIC_CHALLENGE, + authorization=wrong, + ) + me = flow.expect("me", "GET", me_path, 200, token=alice) + flow.check("me.id == alice", me.get("id") == ids["alice"]) + flow.expect("no token", "GET", me_path, 401, challenge=BEARER_CHALLENGE) + flow.expect( + "Basic on business endpoint", + "GET", + me_path, + 401, + challenge=BEARER_CHALLENGE, + authorization=basic(username, password), + ) + flow.expect( + "only X-User-Id", + "GET", + me_path, + 401, + challenge=BEARER_CHALLENGE, + extra={"X-User-Id": ids["alice"]}, + ) + spoofed = flow.expect( + "X-User-Id ignored", + "GET", + me_path, + 200, + token=alice, + extra={"X-User-Id": ids["eve"]}, + ) + flow.check("still alice", spoofed.get("id") == ids["alice"]) + flow.expect( + "unknown token", + "GET", + me_path, + 401, + challenge=BEARER_CHALLENGE, + token=uuid.uuid4().hex * 2, + ) + + body = {"title": "Проект 🚀", "member_ids": [ids["alice"], ids["bob"]]} + chat = flow.expect("new chat", "POST", CHATS, 201, token=alice, body=body) chat_path = f"{CHATS}/{chat['id']}" msgs = f"{chat_path}/messages" - body = {"title": "x", "member_ids": [alice]} - flow.expect("not a member", "POST", CHATS, 400, user=eve, body=body) + body = {"title": "x", "member_ids": [ids["alice"]]} + flow.expect("not a member", "POST", CHATS, 400, token=eve, body=body) texts = ["привет", "hi 👋", "третье", "четвёртое", "пятое"] for index, text in enumerate(texts): sender = alice if index % 2 == 0 else bob body = {"text": text} - flow.expect("send", "POST", msgs, 201, user=sender, body=body) + flow.expect("send", "POST", msgs, 201, token=sender, body=body) blank = {"text": " "} - flow.expect("blank text", "POST", msgs, 400, user=alice, body=blank) - spoof = {"text": "x", "sender_id": alice} - flow.expect("sender_id", "POST", msgs, 400, user=alice, body=spoof) + flow.expect("blank text", "POST", msgs, 400, token=alice, body=blank) + spoof = {"text": "x", "sender_id": ids["alice"]} + flow.expect("sender_id", "POST", msgs, 400, token=alice, body=spoof) seen, cursor, pages = [], None, 0 while pages < 10: query = "?limit=2" + (f"&cursor={cursor}" if cursor else "") - page = flow.expect("page", "GET", msgs + query, 200, user=bob) + page = flow.expect("page", "GET", msgs + query, 200, token=bob) seen += [item["text"] for item in page["items"]] cursor, pages = page["next_cursor"], pages + 1 if cursor is None: @@ -285,21 +375,36 @@ def cmd_flow(port: int) -> int: flow.check("history order via cursor", seen == texts, f"{pages} pages") flow.check("created_at ends with Z", chat["created_at"].endswith("Z")) - flow.expect("outsider reads chat", "GET", chat_path, 404, user=eve) - flow.expect("outsider reads history", "GET", msgs, 404, user=eve) + flow.expect("outsider reads chat", "GET", chat_path, 404, token=eve) + flow.expect("outsider reads history", "GET", msgs, 404, token=eve) hi = {"text": "hi"} - flow.expect("outsider posts", "POST", msgs, 404, user=eve, body=hi) - flow.expect("no header beats 404", "GET", chat_path, 401) - flow.expect("limit=0", "GET", msgs + "?limit=0", 400, user=alice) - flow.expect("bad cursor", "GET", msgs + "?cursor=zzz", 400, user=alice) - flow.expect("chat_id not uuid", "GET", f"{CHATS}/nope", 400, user=alice) + flow.expect("outsider posts", "POST", msgs, 404, token=eve, body=hi) + flow.expect("no token beats 404", "GET", chat_path, 401) + flow.expect("limit=0", "GET", msgs + "?limit=0", 400, token=alice) + flow.expect("bad cursor", "GET", msgs + "?cursor=zzz", 400, token=alice) + flow.expect("chat_id not uuid", "GET", f"{CHATS}/nope", 400, token=alice) flow.expect("malformed json", "POST", USERS, 400, raw=b"{not json") flow.expect("unknown path", "GET", "/nope", 404) - chats = flow.expect("list chats", "GET", CHATS, 200, user=bob) + chats = flow.expect("list chats", "GET", CHATS, 200, token=bob) listed = [item["id"] for item in chats["items"]] flow.check("bob sees the chat", chat["id"] in listed) - print(f"\nalice={alice}\nbob={bob}\neve={eve}\nchat={chat['id']}") + flow.expect("logout", "DELETE", f"{SESSIONS}/current", 204, token=eve) + flow.expect( + "token after logout", + "GET", + me_path, + 401, + challenge=BEARER_CHALLENGE, + token=eve, + ) + + print( + f"\nalice={ids['alice']}\nbob={ids['bob']}\neve={ids['eve']}" + f"\nchat={chat['id']}" + # синтетический токен локального стенда: для `req --token` + f"\nalice_token={alice}", + ) print("FAILED:", flow.failures or "none") return 1 if flow.failures else 0 @@ -335,7 +440,9 @@ def main() -> int: req = sub.add_parser("req") req.add_argument("method") req.add_argument("path") - req.add_argument("--user") + auth = req.add_mutually_exclusive_group() + auth.add_argument("--token", help="Bearer-токен сессии") + auth.add_argument("--basic", help="USER:PASS для POST /auth/sessions") req.add_argument("--data") args = parser.parse_args() port = args.port diff --git a/AGENTS.md b/AGENTS.md index a1dd5ebd..67085103 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -78,30 +78,25 @@ stdout). ## Переходное состояние -Код перенесён из лабы 1 (commit `7b775a2`), хранилище уже переведено -на PostgreSQL (change `postgres-storage`). Этот файл и `.claude/rules/` -описывают целевое состояние лабы 2, поэтому в остальном код с ними пока -расходится: +Код перенесён из лабы 1 (commit `7b775a2`), хранилище переведено на +PostgreSQL (change `postgres-storage`), вход и Bearer-сессии — change +`session-auth`. Этот файл и `.claude/rules/` описывают целевое +состояние лабы 2, поэтому в остальном код с ними пока расходится: -- `get_current_user` читает `X-User-Id`, регистрации с паролем, входа и - logout нет — change `session-auth`. До него публичный smoke лабы 2 не - проходит, а `test_security_scheme_in_openapi` падает: он сверяет - схему `devUser` с контрактом lab2, где её нет. `make test_isolated` - поэтому ещё не зелёный; -- `student-tests/` идентифицируются `X-User-Id`, `bench/` поднимает - стенд без Postgres, `inproc.py` ссылается на удалённый `MemoryStore` - (`bench.md`); -- `openspec/specs/` `identification` и `users` описывают поведение - лабы 1; +- `bench/` поднимает стенд без Postgres, его сценарии k6 ходят с + `X-User-Id`, а `inproc.py` ссылается на удалённый `MemoryStore` — + change `bench-postgres` (`bench.md`); +- Redis/Valkey ещё нет — change `membership-cache`; - сценарии основных спеков, которые выполнятся только после следующих - changes, — внести в их `tasks.md`: в `session-auth` — «Успешный - прогон» (`student-tests`), «Штатный запуск» и «Запуск по отчёту» - (`container-run`: `make student_test` проходит целиком); в - `failure-checks` — автоматическая проверка «Сбой при добавлении - участников», «БД остановлена», «БД вернулась», «Соединения - исчерпаны» (`data-storage`) и «Хранилище не готово» (`health`), пока - это исключения в `spec_coverage.py` с ручным evidence; -- `REPORT.md` заполнен только по хранению. + changes, — внести в их `tasks.md`: в `failure-checks` — + автоматическая проверка «Сбой при добавлении участников», «БД + остановлена», «БД вернулась», «Соединения исчерпаны» + (`data-storage`), «Хранилище не готово» (`health`), «Истёкший токен», + «Срок не продлевается», «БД остановлена при запросе с токеном» + (`sessions`); пока это исключения в `spec_coverage.py` с ручным + evidence; +- `REPORT.md` заполнен по хранению и сессиям; Redis/Valkey, EXPLAIN и + трек 2 — следующие changes. Правила лабы 1 — `git show 7b775a2:.claude/rules/<файл>`. Закрытый пункт убрать отсюда, закрытый переход — удалить раздел. @@ -284,8 +279,8 @@ src/ routers/health.py # /health/live, /health/ready: вне версии, без идентификации routers/v1/.py # ручки под /api/v1, сборка в routers/v1/__init__.py schemas/.py # pydantic-модели запросов и ответов = схемы контракта - dependencies.py # текущий пользователь, фабрики сервисов, параметры пагинации - errors.py # доменное исключение → статус + code, формат ошибки контракта + dependencies.py # сессия БД, фабрики сервисов, разбор Basic, текущая сессия по Bearer, пагинация + errors.py # доменное исключение → статус + code (+ WWW-Authenticate), формат ошибки контракта middlewares/ # X-Request-Id и access-лог; с лабы 3 — X-Instance-Id core/ repos/.py # атомарный доступ к хранилищу, модульные функции @@ -293,6 +288,7 @@ src/ exceptions/.py # доменные исключения, реэкспорт в __init__.py infra/ logger.py # structlog, get_logger(), contextvar-ы request_id / user_id + password.py # Argon2id в потоке со своим лимитом, фиктивный хэш для неизвестного username db/engine.py # фабрики engine и сессий, BoundedCloseConnection, ping db/session.py # глобалы engine и session_factory процесса API db/errors.py # is_db_unavailable: какие ошибки драйвера — 503 diff --git a/config_example.toml b/config_example.toml index 062badb4..09d28898 100644 --- a/config_example.toml +++ b/config_example.toml @@ -23,3 +23,11 @@ connect_timeout_seconds = 3 statement_timeout_ms = 5000 # секунды на всю работу запроса с БД: зависший сервер, обрыв сети request_timeout_seconds = 6 + +[auth] +# секунды жизни сессии с момента входа (контрактное имя +# SESSION_TTL_SECONDS); короткий срок для проверки истечения — окружением +# AUTH__SESSION_TTL_SECONDS=2 +session_ttl_seconds = 3600 +# сколько хэшей пароля Argon2id считается одновременно: 64 MiB на каждый +kdf_concurrency = 4 diff --git a/migrations/versions/2026_10_01_1729-42bc3b9be38f_added_sessions_and_password_hashes.py b/migrations/versions/2026_10_01_1729-42bc3b9be38f_added_sessions_and_password_hashes.py new file mode 100644 index 00000000..13e5b8cb --- /dev/null +++ b/migrations/versions/2026_10_01_1729-42bc3b9be38f_added_sessions_and_password_hashes.py @@ -0,0 +1,86 @@ +"""added sessions and password hashes + +Revision ID: 42bc3b9be38f +Revises: 16c279725564 +Create Date: 2026-10-01 17:29:25.874192 + +""" + +import logging +from collections.abc import Sequence + +import sqlalchemy as sa +from alembic import op + +# revision identifiers, used by Alembic. +revision: str = "42bc3b9be38f" +down_revision: str | Sequence[str] | None = "16c279725564" +branch_labels: str | Sequence[str] | None = None +depends_on: str | Sequence[str] | None = None + +# журнал alembic уже в JSON (src/infra/logger.py); src ревизия не +# импортирует: применённая ревизия не меняется вместе с кодом +logger = logging.getLogger("alembic.runtime.migration") + + +def upgrade() -> None: + # у пользователей лабы 1 нет пароля: войти они не смогут, а хэш + # теперь обязателен. Данные стенда синтетические — они удаляются + # вместе с чатами, участниками и сообщениями (design change + # session-auth, решение 7) + if op.get_context().as_sql: + op.execute("TRUNCATE users, chats CASCADE") + else: + users = op.get_bind().scalar(sa.text("SELECT count(*) FROM users")) + if users: + op.execute("TRUNCATE users, chats CASCADE") + logger.warning( + "Deleted lab 1 data without passwords: %d users " + "with their chats and messages", + users, + ) + + op.add_column( + "users", + sa.Column("password_hash", sa.Text(), nullable=False), + ) + # CHECK записаны литералами, а не константами src + op.create_check_constraint( + op.f("ck_users_password_hash_argon2id"), + "users", + "password_hash LIKE '$argon2id$%'", + ) + op.create_table( + "sessions", + sa.Column("id", sa.Uuid(), nullable=False), + sa.Column("user_id", sa.Uuid(), nullable=False), + sa.Column("token_hash", sa.LargeBinary(), nullable=False), + sa.Column("expires_at", sa.DateTime(timezone=True), nullable=False), + sa.Column("created_at", sa.DateTime(timezone=True), nullable=False), + sa.CheckConstraint( + "expires_at > created_at", + name=op.f("ck_sessions_expires_after_created"), + ), + sa.CheckConstraint( + "octet_length(token_hash) = 32", + name=op.f("ck_sessions_token_hash_length"), + ), + sa.ForeignKeyConstraint( + ["user_id"], + ["users.id"], + name=op.f("fk_sessions_user_id_users"), + ), + sa.PrimaryKeyConstraint("id", name=op.f("pk_sessions")), + sa.UniqueConstraint("token_hash", name=op.f("uq_sessions_token_hash")), + ) + + +def downgrade() -> None: + # удалённые upgrade данные лабы 1 не возвращаются + op.drop_table("sessions") + op.drop_constraint( + op.f("ck_users_password_hash_argon2id"), + "users", + type_="check", + ) + op.drop_column("users", "password_hash") diff --git a/openspec/changes/session-auth/.openspec.yaml b/openspec/changes/session-auth/.openspec.yaml new file mode 100644 index 00000000..480ad4de --- /dev/null +++ b/openspec/changes/session-auth/.openspec.yaml @@ -0,0 +1,2 @@ +schema: spec-driven +created: 2026-10-01 diff --git a/openspec/changes/session-auth/design.md b/openspec/changes/session-auth/design.md new file mode 100644 index 00000000..14424d89 --- /dev/null +++ b/openspec/changes/session-auth/design.md @@ -0,0 +1,249 @@ +# Design + +## Context + +Мотивация — `proposal.md`, раздел Why. Требования — `specs/`. Как +реализовывать пароль, Basic, токен и `get_current_user`, уже записано в +`.claude/rules/auth.md`; здесь — решения, которые правило оставляет +change, и проверки на текущих версиях. + +Сейчас `get_current_user` читает `X-User-Id` через `APIKeyHeader` +(`devUser`), `UserService.identify` ищет пользователя по UUID, а 401 даёт +`Unidentified` без `WWW-Authenticate`. Хранилище — PostgreSQL +(`postgres-storage`): одна `AsyncSession` на запрос, commit в сервисе, +ошибки БД → 503 в `get_db_session` с общим сроком запроса 6 с. В +explore перед `postgres-storage` решено: сессии — PostgreSQL без кэша, +отзыв мгновенный, Redis/Valkey — кэш состава чатов (`membership-cache`). + +Проверено на версиях этого change: + +- FastAPI 0.141.1: `HTTPBase(scheme="basic", ...)` с `auto_error=False` + отдаёт `scheme` и `credentials` как есть, не проверяя схему и не + декодируя base64; `HTTPBearer(auto_error=False)` на чужую схему + отдаёт `None`. +- argon2-cffi 25.1.0: `PasswordHasher()` — профиль + `RFC_9106_LOW_MEMORY` (Argon2id, t=3, m=64 MiB, p=4, соль 16 байт). + Хэш — 97 символов `$argon2id$v=19$m=65536,t=3,p=4$...`, хэширование и + проверка — около 30 мс на M3 Pro. Пароль из 128 кириллических + символов (256 байт) сравнивается целиком. +- pydantic-settings (python-dotenv) подставляет `${VAR}` в мосте `.env` + сначала из самого файла: при `SESSION_TTL_SECONDS=3600` в `.env` и + `SESSION_TTL_SECONDS=2` в окружении мост + `AUTH__SESSION_TTL_SECONDS=${SESSION_TTL_SECONDS}` даёт 3600. + +## Goals / Non-Goals + +**Goals:** + +- Публичный smoke лабы 2, `make test-persistence + ACTION_SCRIPT=scripts/restart.sh` и `make test_isolated` проходят + целиком; `student-tests` — все, включая переписанный + `test_security_scheme_in_openapi`. +- Один запрос с токеном — один `SELECT` в PostgreSQL: проверка сессии и + загрузка пользователя вместе. +- Время входа не выдаёт, существует ли username. + +**Non-Goals:** + +- Автоматические тесты истечения (TTL 2 с) и недоступности БД — особый + стенд, механизм выбирает `failure-checks` (`student-tests.md`). Здесь + поведение реализуется и проверяется вручную с записью в `evidence/`. +- Чистка истёкших сессий, `check_needs_rehash`, ограничение частоты + входа, «выйти со всех устройств». +- `bench/` на Bearer — `bench-postgres`. + +## Decisions + +### 1. Таблица `sessions` и отзыв удалением + +``` +users sessions + id uuid PK <----+ id uuid PK + username text UQ +---- user_id uuid FK -> users, NOT NULL + display_name text token_hash bytea UQ, CHECK octet_length = 32 + password_hash text NOT NULL created_at timestamptz + CHECK LIKE '$argon2id$%' expires_at timestamptz, CHECK > created_at + created_at timestamptz +``` + +- `token_hash` — SHA-256 токена (32 байта, `bytea`), поиск — по + уникальному индексу. Токен у клиента, в БД его нет (`auth.md`). +- Отзыв — `DELETE ... WHERE id = :session_id`. Отзыв мгновенный, следы + в журнале (`info` с `id` сессии). Истёкшие строки остаются: их не + читает ни один запрос, рост таблицы — по числу входов. +- `CHECK password_hash LIKE '$argon2id$%'` — защита в глубину: открытый + пароль или быстрый хэш не запишется даже при ошибке в сервисе. +- Индекса по `sessions.user_id` нет: ни один запрос не ищет сессии по + пользователю, а пользователи не удаляются. + +*Альтернатива:* `revoked_at` вместо удаления. Отвергнута: проверка +сессии получила бы ещё одно условие, а историю отзывов никто не читает — +она есть в журнале. + +### 2. Проверка токена — один запрос с часами приложения + +`SELECT sessions.id, users.* FROM sessions JOIN users ON ... WHERE +token_hash = :hash AND expires_at > :now`. `now` передаёт сервис +(`utcnow()`): `created_at` и `expires_at` тоже ставит приложение, и срок +сравнивается по одним часам. Нет строки — `Unauthenticated` (401 +Bearer). Ошибка БД уходит в `get_db_session` и даёт 503, а не 401: +недоступность хранилища не делает токен недействительным (спек +`sessions`). + +### 3. Пароль: Argon2id в потоке с ограничением + +- `src/infra/password.py`: `PasswordHasher.from_parameters( + profiles.RFC_9106_LOW_MEMORY)` — профиль назван явно, а не взят + умолчанием библиотеки; async `hash_password`, `verify_password`. +- KDF — `anyio.to_thread.run_sync(..., limiter=...)` с отдельным + `CapacityLimiter` на `[auth] kdf_concurrency` (по умолчанию 4). Без + него вход шёл бы через общий пул потоков anyio на 40: 40 × 64 MiB = + 2,5 GiB памяти, ВМ Docker — 7 GiB. С лимитом пик — 256 MiB, остальные + ждут в очереди. +- Неизвестный username проверяется против фиктивного хэша, + посчитанного один раз при первом входе. Время ответа тогда то же, что + у неверного пароля (`auth.md`); замер — в evidence. +- Регистрация хэширует пароль до обращения к БД. Вход читает хэш, затем + `commit()` — сессия БД возвращает соединение в пул, — проверяет пароль + и вставляет сессию новой транзакцией. Соединение пула не держится + 30 мс KDF и время ожидания лимита. Между чтением и вставкой ничего не + может измениться: пароли и пользователи не меняются и не удаляются. + +*Альтернативы:* bcrypt — режет пароль на 72 байтах, а пароль до 128 +code points в UTF-8 занимает до 512 байт; scrypt — допустим, но lab7 +требует Argon2id. `asyncio.to_thread` без лимита — память выше. + +### 4. Разбор Basic — в слое API + +- Зависимость входа: `HTTPBase(scheme="basic", scheme_name="basicAuth", + auto_error=False)` объявляет схему в `/openapi.json` и отдаёт сырые + credentials. Свой разбор (`auth.md`): схема `basic` без учёта регистра + → `b64decode(..., validate=True)` → UTF-8 → `partition(":")`. Любой + сбой — `InvalidCredentials`. +- До БД отсекаются значения, которые не могут быть верными: username не + по шаблону, пароль вне 12–128 code points. Это тот же 401, без KDF и + без запроса к БД. Существования пользователя такой ответ не выдаёт, а + пароль в мегабайт не доходит до KDF. +- `HTTPBasic` FastAPI не годится: декодирует ASCII и на пароле не из + ASCII сам отвечает 401 мимо формата контракта (`api-contract.md`). + +### 5. Bearer, текущая сессия и ошибки + +- `get_current_session`: `HTTPBearer(scheme_name="bearerAuth", + auto_error=False)` → токен или `None` → `SessionService.authenticate` + → `CurrentSessionDTO(id, user)`. `get_current_user` берёт `user` из + неё; `current_user_id` ставится после успеха. `X-User-Id` не читает + никто, константа и `APIKeyHeader` удаляются. +- Исключения: `InvalidCredentials` (вход) и `Unauthenticated` (Bearer) + вместо `Unidentified`. Таблица `errors.py` получает к статусу и `code` + ещё и заголовки: `WWW-Authenticate: Basic realm="messenger", + charset="UTF-8"` и `Bearer realm="messenger"`. Сообщения одинаковые + для всех причин внутри каждого исключения. +- `DELETE /auth/sessions/current` зависит от `get_current_session` и + удаляет её по `id`. Два одновременных выхода одним токеном оба + получат 204: проверка прошла у обоих, второй `DELETE` удалит 0 строк. + +### 6. Настройки + +- `[auth] session_ttl_seconds: int > 0`, по умолчанию 3600; + `[auth] kdf_concurrency: int > 0`, по умолчанию 4. Оба — в + `config_example.toml`: их читает только приложение (`settings.md`, + «Что где хранится»). В `.env` и compose срока нет. +- Короткий срок для проверки истечения — `AUTH__SESSION_TTL_SECONDS=2` + в окружении: в консоли перед `make run_dev` или `uv run`, у + контейнера — `-e` при `docker compose run`, как `run_isolated.py` + подменяет `DATABASE__NAME`. Окружение важнее `.env` и `config.toml`. + Для рабочего стенда в docker — правка смонтированного `config.toml` и + `docker compose restart api`. +- Контрактное имя `SESSION_TTL_SECONDS` — строкой в таблице + соответствия `REPORT.md`, как `APP_HOST` и `DATABASE_URL_FILE`: шапка + `.env.example` skeleton называет эти имена логическими и просит + сопоставить их с реальными в отчёте. Ни одна публичная проверка + `SESSION_TTL_SECONDS` не читает. + +*Альтернатива:* `SESSION_TTL_SECONDS` в `.env` и мост +`AUTH__SESSION_TTL_SECONDS=${SESSION_TTL_SECONDS:-3600}` в `.env` и в +`x-app-env` compose. Отвергнута: значение по умолчанию в трёх местах +ради одного имени, а в консоли `SESSION_TTL_SECONDS=2` из окружения мост +не перекрывает (Context), так что контрактное имя работало бы только +правкой `.env`. + +### 7. Миграция: очистка лабы 1, затем обязательный хэш + +Одна ревизия поверх `16c279725564`: + +1. `SELECT count(*) FROM users`; если больше нуля — `TRUNCATE users, + chats CASCADE` (уходят и `chat_members`, `messages`) и `warning` в + журнал `migrate` с числом удалённых пользователей. Логгер — stdlib + `logging.getLogger("alembic...")`: его уже форматирует + `src/infra/logger.py`, а ревизия не импортирует `src` + (`migrations.md`). +2. `password_hash text NOT NULL` с `CHECK`, таблица `sessions` с + ограничениями из решения 1. +3. `downgrade` — удалить `sessions` и колонку; удалённые данные не + возвращаются. + +Решение пользователя (вопрос при `/opsx:propose`): у пользователей +лабы 1 нет пароля, войти они не смогут, данные синтетические. Повторный +прогон — no-op: alembic не применяет ревизию дважды. + +*Альтернативы:* nullable-колонка и отказ во входе без хэша — в схеме +навсегда `NULL` и ветка в коде входа; `NOT NULL` с отказом миграции на +непустой базе — ручной `make wipe_data` у оператора. + +### 8. `student-tests` + +- `Actor` хранит `user`, пароль и токен; `headers()` → + `Authorization: Bearer`. `Api.register` регистрирует с паролем и + сразу входит; `Api.login` — отдельный вход; `Actor.unregistered()` — + случайный токен, которого нет на сервере. +- Тела регистрации в тестах `users`, гонок и рубрики — с паролем через + один хелпер: без него `test_duplicate_username` получил бы 400 вместо + 409. +- `test_identification.py` переписывается по дельте спека; + `test_sessions.py` — новый. Сценарии, которые не проверить по HTTP на + обычном стенде (истечение, рестарт, недоступность БД, содержимое + таблиц), — исключения в `spec_coverage.py` со ссылкой на evidence и + `failure-checks`. + +### 9. Evidence + +Снимается с закоммиченного кода (`bench.md`, «Измеренное состояние — +commit»): + +| Файл | Что | +|---|---| +| `evidence/tests/test-isolated.md` | `make test_isolated`: smoke и весь набор против образа, код 0 | +| `evidence/storage/test-persistence.md` | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` и `StartedAt` до и после | +| `evidence/auth/passwords-and-tokens.md` | `psql`: хэш Argon2id, токена нет в БД, `token_hash` 32 байта; журнал без пароля, токена и `Authorization`; время входа — неверный пароль и неизвестный username | +| `evidence/auth/expiry.md` | сервис с `AUTH__SESSION_TTL_SECONDS=2`: токен работает, через 3 с — 401, запросы срок не продлевают; отказ БД при запросе с токеном — 503 | +| `evidence/migrations/drop-lab1-data.md` | миграция на рабочей базе с данными лабы 1: число удалённых в журнале, повтор — no-op | + +## Risks / Trade-offs + +- [Миграция необратимо удаляет данные лабы 1] → Решение пользователя; + данные синтетические; удаление видно в журнале и в `REPORT.md` + (спек `db-migrations`). +- [Очередь KDF за лимитом съедает срок запроса 6 с, и вход получает 503 + с записью «Database is unavailable»] → При 4 потоках и 30 мс на хэш + это больше 700 входов одновременно: для учебного стенда недостижимо. + Лимит и срок — настройки. +- [Истёкшие сессии копятся] → Их не читают; таблица растёт на одну + строку за вход. Чистка — фоновая задача с лабы 5. +- [Вход держит две транзакции] → Если БД упадёт между ними, клиент + получит 503 и повторит вход; сессия либо создана целиком, либо нет. +- [Каждый запрос с токеном — `SELECT` в PostgreSQL] → Так отзыв + мгновенный без инвалидации кэша (решение explore). Цену покажет + `bench-postgres`; кэш сессий в `membership-cache` не входит. +- [Swagger UI кодирует Basic через `btoa`, пароль не из ASCII из `/docs` + не войдёт] → Ограничение браузерного UI, не API; проверка — по HTTP в + тестах. + +## Migration Plan + +Порядок: зависимость и настройки → миграция и модели → infra пароля → +repo и сервисы → API (зависимости, роутер, ошибки) → `student-tests` → +скилл, правила, `AGENTS.md` → commit → evidence → `REPORT.md`. Рабочий +стенд после `make run_docker` проходит миграцию с очисткой. Откат: +`git revert` коммитов change, `alembic downgrade 16c279725564` (данные +лабы 1 не вернутся) или `make wipe_data`. diff --git a/openspec/changes/session-auth/proposal.md b/openspec/changes/session-auth/proposal.md new file mode 100644 index 00000000..43815466 --- /dev/null +++ b/openspec/changes/session-auth/proposal.md @@ -0,0 +1,105 @@ +# Proposal + +## Why + +Переход API 1 → 2 (`COURSE.md`): регистрация требует `password`, вход +идёт по Basic, бизнес-запросы — по Bearer-сессии, а `X-User-Id` доступа +больше не даёт. Сейчас любой клиент выдаёт себя за другого заголовком. +Поэтому не проходят ни публичный smoke лабы 2, ни `make +test-persistence`, ни зелёный `make test_isolated` — это обязательный +минимум «3» (`README.md`). Хранилище уже в PostgreSQL (`postgres-storage`), +теперь можно строить на нём сессии. + +## What Changes + +- **BREAKING (API):** `POST /api/v1/users` требует `password` (12–128 + code points, не только из пробелов). Пароль хэшируется Argon2id и + никогда не возвращается. +- Новый `POST /api/v1/auth/sessions`: вход по `Authorization: Basic`, + без тела. Ответ — 201 `Session`: непрозрачный токен (256 бит), + `token_type`, `expires_at`, `user`. Неверный пароль, неизвестный + пользователь и битый Basic дают одинаковый 401 с + `WWW-Authenticate: Basic realm="messenger", charset="UTF-8"`. +- Новый `DELETE /api/v1/auth/sessions/current`: отзыв текущей сессии, + 204. Дальше этот токен получает 401. +- **BREAKING (API):** защищённые эндпоинты принимают только + `Authorization: Bearer `. Нет токена, он неизвестен, истёк или + отозван, пришёл Basic — 401 с `WWW-Authenticate: Bearer + realm="messenger"`. `X-User-Id` игнорируется везде. +- Сессии хранятся в PostgreSQL: SHA-256 токена, срок `expires_at`, + фиксированный при входе. Срок задаёт `[auth] session_ttl_seconds` в + `config.toml` (по умолчанию 3600), разовая подмена — окружением + `AUTH__SESSION_TTL_SECONDS`; контрактное имя `SESSION_TTL_SECONDS` + сопоставлено в `REPORT.md`. Действующие сессии переживают рестарт, + рестарт срок не продлевает. Отзыв мгновенный: каждый запрос проверяет + сессию в БД. +- **BREAKING (данные):** миграция удаляет пользователей, чаты, участников + и сообщения лабы 1 — у них нет пароля, войти они не смогут — и делает + хэш пароля обязательным. Число удалённых пользователей пишется в журнал + миграции. Данные стенда синтетические. +- `/openapi.json` и `/docs` объявляют схемы `bearerAuth` и `basicAuth` + из контракта вместо `devUser`. +- `student-tests` идентифицируются Bearer-токеном. Добавлены проверки + входа, неверного пароля, logout, отказа Basic и `X-User-Id` на + бизнес-ручках. +- Становятся зелёными публичный smoke, `make test-persistence + ACTION_SCRIPT=scripts/restart.sh` и `make test_isolated`. Их выводы и + ручная проверка истечения сессии при TTL 2 с сохраняются в + `evidence/`. + +Вне этого change: Redis/Valkey (`membership-cache`), автоматическая +проверка истечения на особом стенде с коротким TTL и проверки отказов +(`failure-checks`), перевод `bench/` на Bearer (`bench-postgres`), +ограничение частоты входа (429), чистка истёкших сессий. + +## Capabilities + +### New Capabilities + +- `sessions`: вход по Basic, токен и его хранение, срок жизни, отзыв, + сохранность сессий после рестарта. + +### Modified Capabilities + +- `identification`: Bearer вместо `X-User-Id` на защищённых эндпоинтах, + 401 с вызовом `Bearer`, `X-User-Id` игнорируется, схемы `bearerAuth` и + `basicAuth` в документации API. +- `users`: регистрация с паролем, хэш пароля через KDF, `User` без + пароля, текущий пользователь по токену. +- `health`: health не требует аутентификации и игнорирует + `Authorization` и `X-User-Id`. +- `data-storage`: сценарии с `X-User-Id` переходят на токен, сессии тоже + хранятся в PostgreSQL и переживают рестарт. +- `container-run`: рестарт hook-ом проверяется прежним токеном, + `make test-persistence` проходит. +- `service-configuration`: срок сессии — параметр `config.toml` с + разовой подменой окружением, одинаково в консоли и docker. +- `service-logging`: в журнале нет паролей, токенов, их хэшей и + заголовка `Authorization`; `user_id` берётся из сессии. +- `student-tests`: обязательные проверки лабы 2 — неверный пароль и + logout. +- `db-migrations`: миграция, которая удаляет данные, обязана сообщать об + этом в журнале. + +## Impact + +- Код: `src/core/services/session.py`, `src/core/repos/session.py`, + `src/api/routers/v1/session.py`, `src/api/schemas/session.py`, модель + `src/infra/db/models/session.py`, хэширование пароля в + `src/infra/`; правки `user` во всех слоях, `src/api/dependencies.py` + (Bearer вместо `X-User-Id`), `src/api/errors.py` (`WWW-Authenticate`), + `src/core/exceptions/`, `src/config/settings.py` (`[auth]`), + `src/utils/constants.py`. +- Миграция: `password_hash` в `users`, таблица `sessions`, очистка + данных лабы 1. +- Зависимости: `argon2-cffi`; `uv.lock`. +- Конфигурация: `config_example.toml` (секция `[auth]`); `.env.example` + и `docker-compose.yml` не меняются. +- Тесты: `student-tests/api_client.py` (токен в `Actor`, регистрация с + паролем и входом), новый `test_sessions.py`, переписанный + `test_identification.py`, тела регистрации в `test_users.py`, + `test_race.py`, `test_rubric.py`, `spec_coverage.py`. +- Инструменты и документы: скилл `run-mtusi-messenger` (вход и Bearer в + `driver.py`), `AGENTS.md` («Переходное состояние»), `.claude/rules/` + (`auth.md` — выбранные решения), `REPORT.md` (KDF, сессии, + доказательства уровня «3»), `evidence/`. diff --git a/openspec/changes/session-auth/specs/container-run/spec.md b/openspec/changes/session-auth/specs/container-run/spec.md new file mode 100644 index 00000000..9f90d88f --- /dev/null +++ b/openspec/changes/session-auth/specs/container-run/spec.md @@ -0,0 +1,27 @@ +# Spec Delta + +## MODIFIED Requirements + +### Requirement: Данные переживают рестарт стенда + +Данные PostgreSQL SHALL храниться в именованном volume. Скрипт +`scripts/restart.sh` SHALL перезапускать API и все используемые +хранилища, сохраняя volume, схему и данные: без удаления volume, +очистки и повторного наполнения. Скрипт SHALL быть исполняемым, +завершаться с кодом 0 только после перезапуска, укладываться в 90 с и +MUST NOT печатать секреты. Публичная проверка `make test-persistence +ACTION_SCRIPT=scripts/restart.sh` SHALL проходить. + +#### Scenario: Рестарт hook-ом + +- **WHEN** пользователь вошёл, отправил сообщение, затем выполнен + `scripts/restart.sh` +- **THEN** контейнеры API и Postgres перезапущены (новое время старта в + `docker inspect`), а после готовности запрос с прежним токеном + получает 200 и видит своё сообщение + +#### Scenario: Публичная проверка сохранности + +- **WHEN** на запущенном стенде выполняется `make test-persistence + ACTION_SCRIPT=scripts/restart.sh` +- **THEN** команда завершается с кодом 0 и печатает `PASS` diff --git a/openspec/changes/session-auth/specs/data-storage/spec.md b/openspec/changes/session-auth/specs/data-storage/spec.md new file mode 100644 index 00000000..bdf7ab58 --- /dev/null +++ b/openspec/changes/session-auth/specs/data-storage/spec.md @@ -0,0 +1,31 @@ +# Spec Delta + +## MODIFIED Requirements + +### Requirement: Хранение в PostgreSQL + +Пользователи, чаты, участники чатов, сообщения и сессии SHALL храниться +в PostgreSQL, он — источник истины. Сервис MUST NOT хранить эти данные +в памяти процесса, файлах или SQLite. Подтверждённая запись (ответ 201 +или 204) SHALL быть зафиксирована в БД до ответа и видна следующему +запросу. + +#### Scenario: Созданное видно сразу + +- **WHEN** клиент зарегистрировался и следующим запросом входит с теми + же username и паролем +- **THEN** вход успешен, и `GET /api/v1/users/me` с выданным токеном + возвращает этого пользователя + +### Requirement: Данные переживают рестарт + +После перезапуска сервиса и PostgreSQL с сохранённым volume все ранее +подтверждённые пользователи, чаты, участники и сообщения SHALL быть +доступны в прежнем виде. + +#### Scenario: Прежний пользователь после рестарта + +- **WHEN** стенд перезапущен `scripts/restart.sh`, и клиент использует + токен, полученный до рестарта +- **THEN** ответ 200, а история чата этого пользователя содержит те же + сообщения в том же порядке diff --git a/openspec/changes/session-auth/specs/db-migrations/spec.md b/openspec/changes/session-auth/specs/db-migrations/spec.md new file mode 100644 index 00000000..406005f4 --- /dev/null +++ b/openspec/changes/session-auth/specs/db-migrations/spec.md @@ -0,0 +1,23 @@ +# Spec Delta + +## ADDED Requirements + +### Requirement: Миграция, удаляющая данные + +Миграция MUST NOT удалять данные, которые можно привести к новой схеме. +Миграция, которая удаляет данные, SHALL записывать в журнал сервиса миграций, +сколько строк удалено, а её повторный запуск MUST NOT ничего удалять. +Об удалении SHALL предупреждать `REPORT.md`. + +#### Scenario: Пользователи без пароля + +- **WHEN** миграция, которая делает хэш пароля обязательным, применяется + к базе с пользователями лабы 1 +- **THEN** пользователи, их чаты, участники и сообщения удалены, в + журнале `migrate` есть число удалённых пользователей, а схема требует + хэш пароля у каждого пользователя + +#### Scenario: Пустая база + +- **WHEN** та же миграция применяется к пустой базе или повторно +- **THEN** ничего не удаляется, и команда завершается с кодом 0 diff --git a/openspec/changes/session-auth/specs/health/spec.md b/openspec/changes/session-auth/specs/health/spec.md new file mode 100644 index 00000000..2db276a5 --- /dev/null +++ b/openspec/changes/session-auth/specs/health/spec.md @@ -0,0 +1,21 @@ +# Spec Delta + +## MODIFIED Requirements + +### Requirement: Health вне версии API и без идентификации + +Эндпоинты health SHALL находиться вне префикса `/api/v1`, MUST NOT +требовать аутентификации и SHALL игнорировать заголовки +`Authorization` и `X-User-Id`. + +#### Scenario: Неизвестный X-User-Id + +- **WHEN** клиент запрашивает health с `X-User-Id` несуществующего + пользователя +- **THEN** ответ 200, а не 401 + +#### Scenario: Неизвестный токен + +- **WHEN** клиент запрашивает health с Bearer-токеном, которого сервис + не выдавал +- **THEN** ответ 200, а не 401 diff --git a/openspec/changes/session-auth/specs/identification/spec.md b/openspec/changes/session-auth/specs/identification/spec.md new file mode 100644 index 00000000..c0c5327e --- /dev/null +++ b/openspec/changes/session-auth/specs/identification/spec.md @@ -0,0 +1,127 @@ +# Spec Delta + +## ADDED Requirements + +### Requirement: Защищённые эндпоинты требуют Bearer + +Все эндпоинты, кроме `POST /api/v1/users`, `POST /api/v1/auth/sessions` +и health, SHALL требовать заголовок `Authorization: Bearer ` с +токеном действующей сессии (capability `sessions`). Владелец сессии +SHALL считаться текущим пользователем запроса. + +#### Scenario: Действующий токен + +- **WHEN** пользователь вызывает `GET /api/v1/users/me` со своим токеном +- **THEN** ответ 200 с этим пользователем + +### Requirement: Отказ в аутентификации — 401 + +Сервис SHALL отвечать 401 с `code` `unauthorized` и заголовком +`WWW-Authenticate: Bearer realm="messenger"`, когда на защищённом +эндпоинте нет заголовка `Authorization`, схема не `Bearer` (в том числе +верный `Basic`), токен пустой, неизвестен, истёк или отозван. Эти случаи +MUST давать одинаковый ответ и MUST NOT давать 400 или 403. + +#### Scenario: Нет заголовка + +- **WHEN** клиент вызывает `GET /api/v1/users/me` без `Authorization` +- **THEN** ответ 401 с `code` `unauthorized` и `WWW-Authenticate` схемы + `Bearer` + +#### Scenario: Неизвестный токен + +- **WHEN** клиент вызывает `GET /api/v1/users/me` с Bearer-токеном, + которого сервис не выдавал +- **THEN** ответ 401 с `WWW-Authenticate` схемы `Bearer` + +#### Scenario: Basic на бизнес-эндпоинте + +- **WHEN** клиент вызывает `GET /api/v1/users/me` с верными username и + паролем в `Authorization: Basic` +- **THEN** ответ 401 с `WWW-Authenticate` схемы `Bearer` + +### Requirement: X-User-Id не даёт доступа + +Заголовок `X-User-Id` SHALL игнорироваться: он MUST NOT давать доступ +без Bearer-токена и MUST NOT менять текущего пользователя при +действующем токене. + +#### Scenario: Только X-User-Id + +- **WHEN** клиент вызывает `GET /api/v1/users/me` только с `X-User-Id` + существующего пользователя +- **THEN** ответ 401 + +#### Scenario: X-User-Id не меняет владельца + +- **WHEN** клиент вызывает `GET /api/v1/users/me` с токеном alice и + `X-User-Id` eve +- **THEN** ответ 200 с пользователем alice + +## MODIFIED Requirements + +### Requirement: Идентификация раньше доступа и валидации + +Аутентификация SHALL проверяться раньше доступа к конкретному ресурсу и +раньше проверки пути, query и полей тела. Исключение, согласованное с +преподавателем 2026-09-26: тело, которое не разбирается как JSON, +отклоняется с 400 до аутентификации. + +#### Scenario: Чужой чат без заголовка + +- **WHEN** клиент без Bearer-токена запрашивает существующий чат +- **THEN** ответ 401, а не 404 + +#### Scenario: Невалидное поле без заголовка + +- **WHEN** клиент без Bearer-токена отправляет сообщение с + `{"text": ""}` +- **THEN** ответ 401, а не 400 + +#### Scenario: Битый JSON без заголовка + +- **WHEN** клиент без Bearer-токена отправляет тело `{bad` +- **THEN** ответ 400 с `code` `invalid_request` + +### Requirement: Схема идентификации в документации API + +Документация, которую отдаёт сервис (`/openapi.json` и `/docs`), SHALL +объявлять схемы безопасности `bearerAuth` и `basicAuth` так же, как +`contracts/openapi.json`, и MUST NOT объявлять `devUser`. Защищённые +операции SHALL ссылаться на `bearerAuth`, `POST /api/v1/auth/sessions` — +на `basicAuth`, а `POST /api/v1/users` и health MUST NOT ссылаться ни на +одну схему. Объявление схем MUST NOT менять ответы: без заголовка +по-прежнему 401 в формате контракта, а не ошибка FastAPI. + +#### Scenario: Кнопка Authorize в Swagger + +- **WHEN** разработчик открывает `/docs` +- **THEN** кнопка Authorize предлагает Basic для входа и Bearer для + остальных запросов, и введённый токен уходит заголовком + `Authorization: Bearer` в защищённые запросы + +#### Scenario: Схема в openapi.json + +- **WHEN** клиент запрашивает `/openapi.json` +- **THEN** `components.securitySchemes.bearerAuth` и `basicAuth` + совпадают с контрактом, `devUser` нет, у `GET /api/v1/users/me` + `security` равно `[{"bearerAuth": []}]`, у + `POST /api/v1/auth/sessions` — `[{"basicAuth": []}]`, а у + `POST /api/v1/users` `security` нет + +## REMOVED Requirements + +### Requirement: Защищённые эндпоинты требуют X-User-Id + +**Reason**: переход API 1 → 2 (`COURSE.md`): `X-User-Id` заменяется +Bearer-сессией. +**Migration**: требование «Защищённые эндпоинты требуют Bearer»; +сценарий «Корректный заголовок» переходит в «Действующий токен». + +### Requirement: Отказ в идентификации — 401 + +**Reason**: заголовка `X-User-Id` больше нет; отказ теперь касается +Bearer-токена и несёт `WWW-Authenticate`. +**Migration**: требование «Отказ в аутентификации — 401»; сценарии «Не +UUID» и «Неизвестный пользователь» переходят в «Неизвестный токен», «Нет +заголовка» остаётся с проверкой `WWW-Authenticate`. diff --git a/openspec/changes/session-auth/specs/service-configuration/spec.md b/openspec/changes/session-auth/specs/service-configuration/spec.md new file mode 100644 index 00000000..3dff5291 --- /dev/null +++ b/openspec/changes/session-auth/specs/service-configuration/spec.md @@ -0,0 +1,37 @@ +# Spec Delta + +## ADDED Requirements + +### Requirement: Срок жизни сессии + +Срок жизни сессии SHALL задаваться параметром приложения +`[auth] session_ttl_seconds` в `config.toml` и одинаково действовать в +консоли и в docker. Без параметра срок SHALL быть 3600 с. Разовая +подмена SHALL работать через окружение `AUTH__SESSION_TTL_SECONDS` без +правки файлов. Значение SHALL быть целым положительным числом секунд, +иначе сервис MUST NOT стартовать (требование «Некорректное значение +останавливает запуск»). Соответствие контрактному имени +`SESSION_TTL_SECONDS` SHALL быть описано в `REPORT.md`. + +#### Scenario: Срок из config.toml + +- **WHEN** в `config.toml` задано `[auth] session_ttl_seconds = 600`, и + сервис запущен через `make run_dev` или `make run_docker` +- **THEN** `expires_at` новой сессии на 600 с позже момента входа + +#### Scenario: Срок по умолчанию + +- **WHEN** параметр в `config.toml` не задан +- **THEN** `expires_at` новой сессии на 3600 с позже момента входа + +#### Scenario: Короткий срок из окружения + +- **WHEN** сервис запущен с `AUTH__SESSION_TTL_SECONDS=2` в окружении, + а файлы не менялись +- **THEN** `expires_at` новой сессии на 2 с позже момента входа + +#### Scenario: Срок не число + +- **WHEN** сервис запускается с `AUTH__SESSION_TTL_SECONDS=abc` или + `0` +- **THEN** сервис не стартует, в журнале — ошибка проверки настроек diff --git a/openspec/changes/session-auth/specs/service-logging/spec.md b/openspec/changes/session-auth/specs/service-logging/spec.md new file mode 100644 index 00000000..4625135c --- /dev/null +++ b/openspec/changes/session-auth/specs/service-logging/spec.md @@ -0,0 +1,26 @@ +# Spec Delta + +## MODIFIED Requirements + +### Requirement: Без содержимого сообщений и личных данных + +Записи MUST NOT содержать текст сообщений, `display_name`, названия +чатов, значения `username`, тела запросов и ответов. Записи MUST NOT +содержать пароли, токены сессий, их хэши, значение заголовка +`Authorization` и параметры SQL-запросов. Для сообщений допускаются +идентификаторы и длина текста, для сессий — `id` сессии и `user_id`. + +#### Scenario: Отправка сообщения + +- **WHEN** участник отправляет сообщение с текстом T +- **THEN** ни одна запись журнала не содержит T, а запись о создании + сообщения содержит его `id`, `chat_id` и длину текста + +#### Scenario: Вход и выход + +- **WHEN** пользователь регистрируется с паролем P, входит, получает + токен T и выходит, а затем кто-то пытается войти с неверным паролем +- **THEN** ни одна запись журнала не содержит P, T, хэш T и значение + `Authorization`; записи о создании и отзыве сессии содержат `user_id` + и `id` сессии, а неудачный вход записан с уровнем `warning` без + username и пароля diff --git a/openspec/changes/session-auth/specs/sessions/spec.md b/openspec/changes/session-auth/specs/sessions/spec.md new file mode 100644 index 00000000..88eb80b5 --- /dev/null +++ b/openspec/changes/session-auth/specs/sessions/spec.md @@ -0,0 +1,158 @@ +# Spec Delta + +## Purpose + +Как пользователь получает и теряет право на запросы с лабы 2: вход по +паролю через Basic с выдачей непрозрачного токена, хранение сессий, +срок жизни и отзыв, сохранность действующих сессий после рестарта. + +## ADDED Requirements + +### Requirement: Вход по Basic + +`POST /api/v1/auth/sessions` SHALL принимать только заголовок +`Authorization: Basic `; тело запроса MUST +NOT читаться и не влияет на ответ. Схема `Basic` распознаётся без учёта +регистра, credentials декодируются как UTF-8, username и пароль делятся +по первому двоеточию: двоеточие в пароле допустимо. При верной паре +сервис SHALL создать новую сессию и ответить 201 с объектом `Session`: +`token`, `token_type` `Bearer`, `expires_at` в RFC 3339 UTC с `Z` и +`user` — тот же объект `User`, что при регистрации. + +#### Scenario: Успешный вход + +- **WHEN** зарегистрированный пользователь входит со своими username и + паролем +- **THEN** ответ 201 `Session`, `token_type` равен `Bearer`, `user` + совпадает с ответом на регистрацию, `expires_at` в будущем + +#### Scenario: Двоеточие и не-ASCII в пароле + +- **WHEN** пароль содержит `:` и кириллицу, и пользователь входит с ним +- **THEN** ответ 201 + +#### Scenario: Несколько сессий + +- **WHEN** пользователь входит дважды +- **THEN** токены разные, и оба принимаются защищёнными эндпоинтами + +### Requirement: Токен непрозрачный + +Токен SHALL быть случайным значением не короче 32 символов с энтропией +не менее 256 бит. Токен MUST NOT содержать и кодировать `username`, +`id` пользователя или срок. Сервис MUST NOT хранить токен в открытом +виде: по данным хранилища нельзя восстановить действующий токен. + +#### Scenario: Токен не выводится из данных пользователя + +- **WHEN** пользователь получил токен +- **THEN** токен не содержит его `username` и `id`, а у двух входов + одного пользователя токены не совпадают + +#### Scenario: Токена нет в хранилище + +- **WHEN** выдан токен T +- **THEN** ни одна строка таблиц PostgreSQL не содержит T + +### Requirement: Отказ во входе + +Неверный пароль, неизвестный username, отсутствие заголовка, другая +схема вместо `Basic`, битый base64, credentials не в UTF-8 и +credentials без двоеточия SHALL давать одинаковый ответ 401 с `code` +`unauthorized`, одинаковым `message` и заголовком +`WWW-Authenticate: Basic realm="messenger", charset="UTF-8"`. Сессия при +этом MUST NOT создаваться. Время ответа для неизвестного username MUST +NOT заметно отличаться от ответа на неверный пароль: проверка пароля +выполняется в обоих случаях. + +#### Scenario: Неверный пароль + +- **WHEN** пользователь входит со своим username и чужим паролем +- **THEN** ответ 401 с `WWW-Authenticate` схемы `Basic` + +#### Scenario: Неизвестный пользователь + +- **WHEN** вход выполняется с username, которого нет +- **THEN** ответ совпадает с ответом на неверный пароль: тот же статус, + `code`, `message` и `WWW-Authenticate` + +#### Scenario: Битый Basic + +- **WHEN** заголовок `Authorization` равен `Basic !!!`, `Basic` с + base64 без двоеточия или `Bearer <токен>` +- **THEN** ответ 401 с `WWW-Authenticate` схемы `Basic` + +### Requirement: Срок жизни сессии + +Срок сессии SHALL фиксироваться при входе: `expires_at` равен моменту +входа плюс настроенный срок жизни (контрактное имя +`SESSION_TTL_SECONDS`, capability `service-configuration`). +Использование токена и рестарт сервиса MUST NOT продлевать срок. После +`expires_at` токен SHALL получать 401 с `WWW-Authenticate: Bearer +realm="messenger"`. + +#### Scenario: Истёкший токен + +- **WHEN** срок жизни сессии равен 2 с, пользователь вошёл и через 3 с + запрашивает `GET /api/v1/users/me` +- **THEN** ответ 401 с `WWW-Authenticate` схемы `Bearer` + +#### Scenario: Срок не продлевается + +- **WHEN** срок жизни сессии равен 2 с, и пользователь каждые 0,5 с + успешно запрашивает `GET /api/v1/users/me` +- **THEN** запрос через 3 с после входа получает 401 + +### Requirement: Отзыв текущей сессии + +`DELETE /api/v1/auth/sessions/current` с действующим Bearer-токеном +SHALL отзывать сессию этого токена и отвечать 204 без тела. Отзыв SHALL +действовать сразу: следующий запрос с этим токеном к любому защищённому +эндпоинту получает 401. Другие сессии того же пользователя MUST NOT +затрагиваться. Без действующего токена эндпоинт SHALL отвечать 401 с +`WWW-Authenticate: Bearer realm="messenger"`. + +#### Scenario: Выход + +- **WHEN** пользователь вызывает `DELETE /api/v1/auth/sessions/current` + своим токеном, затем `GET /api/v1/users/me` тем же токеном +- **THEN** первый ответ 204 без тела, второй — 401 + +#### Scenario: Повторный выход + +- **WHEN** пользователь второй раз вызывает + `DELETE /api/v1/auth/sessions/current` отозванным токеном +- **THEN** ответ 401 с `WWW-Authenticate` схемы `Bearer` + +#### Scenario: Другая сессия остаётся + +- **WHEN** пользователь вошёл дважды и отозвал первую сессию +- **THEN** второй токен по-прежнему получает 200 + +### Requirement: Сессии переживают рестарт + +Сессии SHALL храниться в PostgreSQL. После перезапуска API и PostgreSQL +с сохранённым volume действующий токен SHALL работать до своего +`expires_at`, а отозванный — оставаться отозванным. + +#### Scenario: Прежний токен после рестарта + +- **WHEN** пользователь вошёл, отправил сообщение, затем выполнен + `scripts/restart.sh` +- **THEN** тот же токен без повторного входа получает 200 и видит своё + сообщение + +### Requirement: Недоступность хранилища сессий + +Если PostgreSQL недоступен, вход и запрос с токеном SHALL получать 503 +`unavailable`. Запрос MUST NOT обрабатываться как анонимный или как +запрос от последнего известного владельца токена, и сервис MUST NOT +отвечать 401 вместо 503: недоступность хранилища не означает, что токен +недействителен. + +#### Scenario: БД остановлена при запросе с токеном + +- **WHEN** PostgreSQL остановлен, и клиент с действующим токеном + запрашивает `GET /api/v1/users/me` +- **THEN** ответ 503 `unavailable`, а после возврата PostgreSQL тот же + токен получает 200 diff --git a/openspec/changes/session-auth/specs/student-tests/spec.md b/openspec/changes/session-auth/specs/student-tests/spec.md new file mode 100644 index 00000000..b877c0f6 --- /dev/null +++ b/openspec/changes/session-auth/specs/student-tests/spec.md @@ -0,0 +1,53 @@ +# Spec Delta + +## MODIFIED Requirements + +### Requirement: Обязательные сценарии рубрики + +Набор SHALL содержать отдельные тесты для сценариев уровня «4»: +неверный JSON, чужой чат, пустое сообщение, дубликат `username`, обход +нескольких страниц истории, а с лабы 2 — неверный пароль и logout. + +#### Scenario: Неверный JSON + +- **WHEN** тест отправляет тело `{bad` в эндпоинт, ожидающий JSON +- **THEN** проверяется ответ 400 с `code` `invalid_request` + +#### Scenario: Чужой чат + +- **WHEN** пользователь, не состоящий в чате, читает чат, читает + историю и пишет в чат +- **THEN** проверяется, что все три запроса получают 404 `not_found` + +#### Scenario: Пустое сообщение + +- **WHEN** участник отправляет сообщение с `text` пустым и из пробелов +- **THEN** проверяется ответ 400 `invalid_request`, и сообщение не + появляется в истории + +#### Scenario: Дубликат username + +- **WHEN** регистрируется `username`, который уже занят +- **THEN** проверяется ответ 409 `conflict` + +#### Scenario: Обход нескольких страниц + +- **WHEN** история содержит больше сообщений, чем помещается на одну + страницу, и тест обходит её по `next_cursor`, в том числе меняя + `limit` между страницами +- **THEN** проверяется, что каждое сообщение встречается ровно один раз + в порядке `(created_at, id)`, а последняя страница имеет + `next_cursor` null + +#### Scenario: Неверный пароль в рубрике + +- **WHEN** зарегистрированный пользователь входит с неверным паролем +- **THEN** проверяется ответ 401 с `WWW-Authenticate` схемы `Basic`, и + выданного токена в ответе нет + +#### Scenario: Logout в рубрике + +- **WHEN** пользователь выходит, а затем повторяет запрос прежним + токеном +- **THEN** проверяется ответ 204 на выход и 401 с `WWW-Authenticate` + схемы `Bearer` на повтор diff --git a/openspec/changes/session-auth/specs/users/spec.md b/openspec/changes/session-auth/specs/users/spec.md new file mode 100644 index 00000000..a70788dd --- /dev/null +++ b/openspec/changes/session-auth/specs/users/spec.md @@ -0,0 +1,74 @@ +# Spec Delta + +## ADDED Requirements + +### Requirement: Формат пароля + +`password` SHALL содержать от 12 до 128 Unicode code points и MUST NOT +состоять только из пробельных символов. Допустимы любые символы +Unicode, в том числе `:`. Значение SHALL использоваться без изменений: +без обрезки, нормализации и усечения по байтам. Иначе сервис SHALL +отвечать 400 `invalid_request`. + +#### Scenario: Нет пароля + +- **WHEN** тело регистрации не содержит `password` +- **THEN** ответ 400 + +#### Scenario: Граница длины пароля + +- **WHEN** `password` из 11 code points, затем из 12, из 128 и из 129 +- **THEN** первый и последний запросы дают 400, остальные — 201 + +#### Scenario: Пароль из пробелов + +- **WHEN** `password` из 12 пробелов +- **THEN** ответ 400 + +#### Scenario: Длинный пароль в UTF-8 целиком + +- **WHEN** пользователь зарегистрировался с паролем из 128 кириллических + символов, затем входит с паролем, где изменён только последний символ +- **THEN** вход отклонён 401: пароль сравнивается целиком, а не по + первым байтам + +### Requirement: Пароль хранится только хэшем + +Сервис SHALL хранить пароль только как результат библиотечного password +KDF с солью. Пароль MUST NOT храниться в открытом виде или как быстрый +хэш (SHA-256 и подобные) и MUST NOT попадать в ответы API и журнал. + +#### Scenario: Хэш в БД + +- **WHEN** пользователь зарегистрирован с паролем P +- **THEN** в его строке в PostgreSQL нет P, а хранимое значение — строка + KDF с параметрами и солью; у двух пользователей с одинаковым паролем + хранимые значения разные + +## MODIFIED Requirements + +### Requirement: Регистрация пользователя + +`POST /api/v1/users` SHALL быть публичным и принимать тело +`{"username": ..., "display_name": ..., "password": ...}`. При успехе +сервис SHALL отвечать 201 с объектом `User`: `id`, `username`, +`display_name`, `created_at`, без других полей: пароля и его хэша в +ответе нет. `id` и `created_at` назначает сервер. + +#### Scenario: Успешная регистрация + +- **WHEN** клиент отправляет `{"username": "alice", "display_name": + "Алиса", "password": ...}` с допустимым паролем +- **THEN** ответ 201, `username` и `display_name` совпадают с + отправленными, `id` — новый UUID, полей кроме четырёх полей `User` нет + +### Requirement: Текущий пользователь + +`GET /api/v1/users/me` SHALL возвращать 200 с объектом `User` владельца +сессии, чей токен передан (capability `identification`). + +#### Scenario: Совпадает с регистрацией + +- **WHEN** пользователь запрашивает `GET /api/v1/users/me` со своим + токеном +- **THEN** тело ответа равно телу ответа на его регистрацию diff --git a/openspec/changes/session-auth/tasks.md b/openspec/changes/session-auth/tasks.md new file mode 100644 index 00000000..175a8601 --- /dev/null +++ b/openspec/changes/session-auth/tasks.md @@ -0,0 +1,144 @@ +# Tasks + +Как строить — `design.md` (дальше «решение N»), что должно получиться — +дельты в `specs/`. Перед первым файлом слоя прочитать его правило: +`auth.md`, `migrations.md`, `infra.md`, `repo-layer.md`, +`service-layer.md`, `dto.md`, `api-layer.md`, `api-contract.md`, +`settings.md`, `student-tests.md`. Evidence снимается с закоммиченного +кода, коммит — только после подтверждения пользователя (`bench.md`, +«Измеренное состояние — commit»). + +## 1. Зависимость и настройки + +- [x] 1.1 `uv add argon2-cffi` в основную группу. Проверка: + `uv lock --check` проходит, `uv run python -c "import argon2; + print(argon2.profiles.RFC_9106_LOW_MEMORY)"` печатает t=3, + m=65536, p=4. +- [x] 1.2 Секция `Auth` в `src/config/settings.py`: + `session_ttl_seconds` и `kdf_concurrency` (решение 6), оба в + `config_example.toml` и рабочем `config.toml`; `.env.example` и + compose не трогаются. Проверка: `uv run python -c "from src.config + import settings; print(settings.auth.session_ttl_seconds)"` — 3600 без + строки в `config.toml`, 600 при `session_ttl_seconds = 600` в нём, 2 + при `AUTH__SESSION_TTL_SECONDS=2` в окружении поверх файла; + `AUTH__SESSION_TTL_SECONDS=abc` и `0` — ошибка проверки настроек. + +## 2. Схема + +- [x] 2.1 Модель `Session` (`src/infra/db/models/session.py`), + `password_hash` в `User` с `CHECK` (решение 1). Проверка: + `Base.metadata.sorted_tables` — пять таблиц, у ограничений есть + имена. +- [x] 2.2 Ревизия по решению 7: очистка лабы 1 с `warning` и числом + пользователей, колонка, таблица; `downgrade` зеркалит `upgrade`. + Проверка: на базе с данными лабы 1 `make upgrade` пишет число + удалённых пользователей, повторный `make upgrade` ничего не пишет и не + удаляет; `alembic downgrade 16c279725564` и снова `upgrade head` + проходят; `alembic check` — «No new upgrade operations detected». + +## 3. Пароль, repo и сервисы + +- [x] 3.1 `src/infra/password.py` (решение 3): профиль явно, + `CapacityLimiter`, фиктивный хэш. Проверка: разовым скриптом верный + пароль проходит, изменённый в последнем из 128 кириллических символов + — нет; 20 одновременных хэшей при `kdf_concurrency=4` идут не больше + чем по 4. +- [x] 3.2 DTO (`dto.md`): `UserFullDTO` без хэша, отдельный DTO + учётных данных для входа, `SessionDTO`, `CurrentSessionDTO`. Repo + `user`: вставка с хэшем, учётные данные по username. Repo `session`: + вставка, проверка токена одним `SELECT` с `JOIN` (решение 2), + удаление по `id`. Проверка: `make lint`; `EXPLAIN` проверки токена + идёт по уникальному индексу `token_hash`. +- [x] 3.3 `UserService.register` с паролем (хэш до БД), без + `identify`; `SessionService`: `login` (две транзакции, решение 3), + `authenticate`, `revoke`; исключения `InvalidCredentials` и + `Unauthenticated` вместо `Unidentified`; логи по спеку + `service-logging`. Проверка: `grep -rn "Unidentified\|X-User-Id\| + USER_ID_HEADER" src` пусто, `make lint` чистый. + +## 4. API + +- [x] 4.1 `dependencies.py` (решения 4, 5): разбор Basic с ранним + отсевом, `get_current_session` на `HTTPBearer`, `get_current_user` из + неё; `errors.py` — `WWW-Authenticate` по типу исключения. Проверка: на + `make run_dev` `GET /api/v1/users/me` без заголовка, с Basic и с + неизвестным Bearer — 401 с `Bearer realm="messenger"`. +- [x] 4.2 `CreateUser` с `password` (12–128, не только пробелы, + `StrictStr`); роутер `session.py`: `POST /auth/sessions` 201 `Session`, + `DELETE /auth/sessions/current` 204. Проверка: `make test` против + `make run_dev` — `PASS`. +- [x] 4.3 Документация API: `/openapi.json` объявляет `bearerAuth` и + `basicAuth` как контракт, без `devUser` (спек `identification`). + Проверка: `security` у `GET /api/v1/users/me`, + `POST /api/v1/auth/sessions` и `POST /api/v1/users` — как в сценарии + «Схема в openapi.json»; в `/docs` вход и запрос через Authorize + работают с паролем из ASCII. + +## 5. Собственные тесты + +- [x] 5.1 `api_client.py` (решение 8): токен в `Actor`, `register` с + паролем и входом, `login`, `unregistered()` со случайным токеном, хелпер + тела регистрации; тела регистрации в `test_users.py`, `test_race.py`, + `test_rubric.py` — через него. Проверка: `make student_test` против + `make run_dev` — тесты поведения лабы 1 проходят без правки + ожиданий. +- [x] 5.2 `test_identification.py` по дельте `identification`, + `test_sessions.py` по `sessions`, тесты сценариев `users` («Нет + пароля», «Граница длины пароля», «Пароль из пробелов», «Длинный + пароль в UTF-8 целиком»), `health` («Неизвестный токен») и рубрики + `student-tests` («Неверный пароль в рубрике», «Logout в рубрике»). + Проверка: против `make run_dev` все проходят. Тесты отказов (401) + проверены на ложную зелень: временная поломка в + `SessionService.authenticate` (принять любой токен) роняет их, после + отката правки они снова зелёные. +- [x] 5.3 `/opsx:sync` и в том же шаге `spec_coverage.py`: `sessions` — + в список отслеживаемых capability; исключения для сценариев, которые + не проверить на обычном стенде: «Истёкший токен», «Срок не + продлевается», «Прежний токен после рестарта», «БД остановлена при + запросе с токеном», «Токена нет в хранилище» (`sessions`), «Хэш в БД» + (`users`) — со ссылкой на evidence и `failure-checks`; текст + исключения «Прежний пользователь после рестарта» — про токен; + «Кнопка Authorize в Swagger» — про `bearerAuth` и `basicAuth` вместо + `devUser`. Спеки `service-configuration`, `container-run` и + `db-migrations` проверяются evidence, в сверку не входят. Purpose + основного спека `identification` переписать руками: в нём «с лабы 2 + её заменяет Bearer». Проверка: `make student_test` — все тесты + прошли, в том числе `test_coverage.py`; `openspec validate --specs` + без ошибок. + +## 6. Инструменты и документы + +- [ ] 6.1 Скилл `run-mtusi-messenger`: `driver.py` регистрирует с + паролем, входит и ходит с Bearer, `req --token` вместо `--user`; + `SKILL.md` без `X-User-Id` и известных падений. Проверка: `python3 + .claude/skills/run-mtusi-messenger/driver.py all` — `FAILED: none`, + smoke `PASS`, student — все прошли. +- [x] 6.2 `auth.md` — выбранные решения (сессии в PostgreSQL, отзыв + удалением, лимит KDF, `HTTPBase` для `basicAuth`); `AGENTS.md` — + «Переходное состояние» без пунктов про `X-User-Id`, `devUser`, + `identification`/`users` и закрытых сценариев `session-auth`, карта + кода (`session.py` во всех слоях, `infra/password.py`). Проверка: + `grep -rn "X-User-Id" AGENTS.md .claude` — только история лабы 1 и + правило, что он игнорируется. +- [x] 6.3 Финальная проверка кода: `make lint`, `make check`, + `openspec validate session-auth --strict`, `make test_isolated` — + код 0. Затем показать изменения, предложить сообщение и после + подтверждения пользователя закоммитить. + +## 7. Evidence и отчёт + +- [ ] 7.1 Evidence по таблице решения 9 с закоммиченного кода. Проверка: + в каждом файле дата, commit, стенд; паролей, токенов и + `Authorization` в файлах нет; `drop-lab1-data.md` снят на рабочей + базе до её очистки. +- [ ] 7.2 `REPORT.md`: Argon2id и его параметры, сессии и их хранение, + `SESSION_TTL_SECONDS` и `SESSION_STORE=postgres` в таблице + соответствия, сценарий защиты (миграции → вход → сообщение → + `make test-persistence` → logout), строки доказательств уровня «3» и + logout/неверного пароля уровня «4» со ссылками на evidence, + предупреждение об очистке данных лабы 1, удаление закрытых TODO. + Проверка: у каждой строки таблицы доказательств есть команда, + наблюдение и файл. +- [ ] 7.3 `make lint`, `make check`, `openspec validate session-auth + --strict`, `graphify update .`; показать изменения и после + подтверждения пользователя закоммитить evidence и отчёт. diff --git a/openspec/specs/container-run/spec.md b/openspec/specs/container-run/spec.md index fb65dccd..ce05c80d 100644 --- a/openspec/specs/container-run/spec.md +++ b/openspec/specs/container-run/spec.md @@ -124,16 +124,23 @@ compose, и приложению, SHALL передаваться через `env хранилища, сохраняя volume, схему и данные: без удаления volume, очистки и повторного наполнения. Скрипт SHALL быть исполняемым, завершаться с кодом 0 только после перезапуска, укладываться в 90 с и -MUST NOT печатать секреты. +MUST NOT печатать секреты. Публичная проверка `make test-persistence +ACTION_SCRIPT=scripts/restart.sh` SHALL проходить. #### Scenario: Рестарт hook-ом -- **WHEN** пользователь создан, отправил сообщение, затем выполнен +- **WHEN** пользователь вошёл, отправил сообщение, затем выполнен `scripts/restart.sh` - **THEN** контейнеры API и Postgres перезапущены (новое время старта в - `docker inspect`), а после готовности запрос с прежним `X-User-Id` + `docker inspect`), а после готовности запрос с прежним токеном получает 200 и видит своё сообщение +#### Scenario: Публичная проверка сохранности + +- **WHEN** на запущенном стенде выполняется `make test-persistence + ACTION_SCRIPT=scripts/restart.sh` +- **THEN** команда завершается с кодом 0 и печатает `PASS` + ### Requirement: Удаление учебных данных `make stop` и `make down` MUST NOT удалять volume с данными. Удаление diff --git a/openspec/specs/data-storage/spec.md b/openspec/specs/data-storage/spec.md index 1f4922c2..1b50a7d8 100644 --- a/openspec/specs/data-storage/spec.md +++ b/openspec/specs/data-storage/spec.md @@ -11,16 +11,18 @@ PostgreSQL как источник истины, сохранность посл ### Requirement: Хранение в PostgreSQL -Пользователи, чаты, участники чатов и сообщения SHALL храниться в -PostgreSQL, он — источник истины. Сервис MUST NOT хранить эти данные в -памяти процесса, файлах или SQLite. Подтверждённая запись (ответ 201) -SHALL быть зафиксирована в БД до ответа и видна следующему чтению. +Пользователи, чаты, участники чатов, сообщения и сессии SHALL храниться +в PostgreSQL, он — источник истины. Сервис MUST NOT хранить эти данные +в памяти процесса, файлах или SQLite. Подтверждённая запись (ответ 201 +или 204) SHALL быть зафиксирована в БД до ответа и видна следующему +запросу. #### Scenario: Созданное видно сразу -- **WHEN** клиент создал пользователя и следующим запросом использует - его `id` в `X-User-Id` -- **THEN** пользователь найден +- **WHEN** клиент зарегистрировался и следующим запросом входит с теми + же username и паролем +- **THEN** вход успешен, и `GET /api/v1/users/me` с выданным токеном + возвращает этого пользователя ### Requirement: Данные переживают рестарт @@ -31,7 +33,7 @@ SHALL быть зафиксирована в БД до ответа и видн #### Scenario: Прежний пользователь после рестарта - **WHEN** стенд перезапущен `scripts/restart.sh`, и клиент использует - `X-User-Id`, созданный до рестарта + токен, полученный до рестарта - **THEN** ответ 200, а история чата этого пользователя содержит те же сообщения в том же порядке diff --git a/openspec/specs/db-migrations/spec.md b/openspec/specs/db-migrations/spec.md index cc40b6a2..420f5560 100644 --- a/openspec/specs/db-migrations/spec.md +++ b/openspec/specs/db-migrations/spec.md @@ -67,3 +67,23 @@ `make run_dev` - **THEN** Postgres запущен, миграции применены, сервис отвечает на `http://127.0.0.1:8080/health/ready` кодом 200 + +### Requirement: Миграция, удаляющая данные + +Миграция MUST NOT удалять данные, которые можно привести к новой схеме. +Миграция, которая удаляет данные, SHALL записывать в журнал сервиса миграций, +сколько строк удалено, а её повторный запуск MUST NOT ничего удалять. +Об удалении SHALL предупреждать `REPORT.md`. + +#### Scenario: Пользователи без пароля + +- **WHEN** миграция, которая делает хэш пароля обязательным, применяется + к базе с пользователями лабы 1 +- **THEN** пользователи, их чаты, участники и сообщения удалены, в + журнале `migrate` есть число удалённых пользователей, а схема требует + хэш пароля у каждого пользователя + +#### Scenario: Пустая база + +- **WHEN** та же миграция применяется к пустой базе или повторно +- **THEN** ничего не удаляется, и команда завершается с кодом 0 diff --git a/openspec/specs/health/spec.md b/openspec/specs/health/spec.md index b13c4bae..0c035491 100644 --- a/openspec/specs/health/spec.md +++ b/openspec/specs/health/spec.md @@ -42,11 +42,18 @@ MUST NOT зависеть от состояния хранилища. ### Requirement: Health вне версии API и без идентификации -Эндпоинты health SHALL находиться вне префикса `/api/v1` и SHALL -игнорировать `X-User-Id`. +Эндпоинты health SHALL находиться вне префикса `/api/v1`, MUST NOT +требовать аутентификации и SHALL игнорировать заголовки +`Authorization` и `X-User-Id`. #### Scenario: Неизвестный X-User-Id - **WHEN** клиент запрашивает health с `X-User-Id` несуществующего пользователя - **THEN** ответ 200, а не 401 + +#### Scenario: Неизвестный токен + +- **WHEN** клиент запрашивает health с Bearer-токеном, которого сервис + не выдавал +- **THEN** ответ 200, а не 401 diff --git a/openspec/specs/identification/spec.md b/openspec/specs/identification/spec.md index 5dc99594..871512f2 100644 --- a/openspec/specs/identification/spec.md +++ b/openspec/specs/identification/spec.md @@ -2,86 +2,114 @@ ## Purpose -Выбор текущего пользователя на лабе 1 через заголовок `X-User-Id` и -порядок проверок «идентификация → доступ к ресурсу». Это учебная -идентификация, а не аутентификация: любой клиент может выдать себя за -другого. С лабы 2 её заменяет Bearer-сессия. +Как сервис определяет текущего пользователя запроса с лабы 2: по +Bearer-токену действующей сессии (capability `sessions`), с ответом 401 +и вызовом `Bearer` при отказе и порядком проверок «аутентификация → +доступ к ресурсу». Заголовок `X-User-Id` лабы 1 доступа больше не даёт. ## Requirements -### Requirement: Защищённые эндпоинты требуют X-User-Id +### Requirement: Защищённые эндпоинты требуют Bearer -Все эндпоинты, кроме `POST /api/v1/users` и health, SHALL требовать -заголовок `X-User-Id` с UUID существующего пользователя. Этот -пользователь SHALL считаться текущим для запроса. +Все эндпоинты, кроме `POST /api/v1/users`, `POST /api/v1/auth/sessions` +и health, SHALL требовать заголовок `Authorization: Bearer ` с +токеном действующей сессии (capability `sessions`). Владелец сессии +SHALL считаться текущим пользователем запроса. -#### Scenario: Корректный заголовок +#### Scenario: Действующий токен -- **WHEN** клиент вызывает `GET /api/v1/users/me` с `X-User-Id` - существующего пользователя +- **WHEN** пользователь вызывает `GET /api/v1/users/me` со своим токеном - **THEN** ответ 200 с этим пользователем -### Requirement: Отказ в идентификации — 401 +### Requirement: Отказ в аутентификации — 401 -Сервис SHALL отвечать 401 с `code` `unauthorized`, когда заголовок -`X-User-Id` отсутствует, не является UUID или указывает на -несуществующего пользователя. Эти три случая MUST давать одинаковый -ответ и MUST NOT давать 400. +Сервис SHALL отвечать 401 с `code` `unauthorized` и заголовком +`WWW-Authenticate: Bearer realm="messenger"`, когда на защищённом +эндпоинте нет заголовка `Authorization`, схема не `Bearer` (в том числе +верный `Basic`), токен пустой, неизвестен, истёк или отозван. Эти случаи +MUST давать одинаковый ответ и MUST NOT давать 400 или 403. #### Scenario: Нет заголовка -- **WHEN** клиент вызывает `GET /api/v1/users/me` без `X-User-Id` -- **THEN** ответ 401 с `code` `unauthorized` +- **WHEN** клиент вызывает `GET /api/v1/users/me` без `Authorization` +- **THEN** ответ 401 с `code` `unauthorized` и `WWW-Authenticate` схемы + `Bearer` -#### Scenario: Не UUID +#### Scenario: Неизвестный токен -- **WHEN** `X-User-Id` равен `not-a-uuid` -- **THEN** ответ 401 с `code` `unauthorized` +- **WHEN** клиент вызывает `GET /api/v1/users/me` с Bearer-токеном, + которого сервис не выдавал +- **THEN** ответ 401 с `WWW-Authenticate` схемы `Bearer` -#### Scenario: Неизвестный пользователь +#### Scenario: Basic на бизнес-эндпоинте -- **WHEN** `X-User-Id` — корректный UUID, но такого пользователя нет -- **THEN** ответ 401 с `code` `unauthorized` +- **WHEN** клиент вызывает `GET /api/v1/users/me` с верными username и + паролем в `Authorization: Basic` +- **THEN** ответ 401 с `WWW-Authenticate` схемы `Bearer` + +### Requirement: X-User-Id не даёт доступа + +Заголовок `X-User-Id` SHALL игнорироваться: он MUST NOT давать доступ +без Bearer-токена и MUST NOT менять текущего пользователя при +действующем токене. + +#### Scenario: Только X-User-Id + +- **WHEN** клиент вызывает `GET /api/v1/users/me` только с `X-User-Id` + существующего пользователя +- **THEN** ответ 401 + +#### Scenario: X-User-Id не меняет владельца + +- **WHEN** клиент вызывает `GET /api/v1/users/me` с токеном alice и + `X-User-Id` eve +- **THEN** ответ 200 с пользователем alice ### Requirement: Идентификация раньше доступа и валидации -Идентификация SHALL проверяться раньше доступа к конкретному ресурсу и +Аутентификация SHALL проверяться раньше доступа к конкретному ресурсу и раньше проверки пути, query и полей тела. Исключение, согласованное с преподавателем 2026-09-26: тело, которое не разбирается как JSON, -отклоняется с 400 до идентификации. +отклоняется с 400 до аутентификации. #### Scenario: Чужой чат без заголовка -- **WHEN** клиент без `X-User-Id` запрашивает существующий чат +- **WHEN** клиент без Bearer-токена запрашивает существующий чат - **THEN** ответ 401, а не 404 #### Scenario: Невалидное поле без заголовка -- **WHEN** клиент без `X-User-Id` отправляет сообщение с `{"text": ""}` +- **WHEN** клиент без Bearer-токена отправляет сообщение с + `{"text": ""}` - **THEN** ответ 401, а не 400 #### Scenario: Битый JSON без заголовка -- **WHEN** клиент без `X-User-Id` отправляет тело `{bad` +- **WHEN** клиент без Bearer-токена отправляет тело `{bad` - **THEN** ответ 400 с `code` `invalid_request` ### Requirement: Схема идентификации в документации API Документация, которую отдаёт сервис (`/openapi.json` и `/docs`), SHALL -объявлять схему `devUser` так же, как `contracts/openapi.json`: `apiKey` -в заголовке `X-User-Id`. Защищённые операции SHALL ссылаться на неё, -публичные (`POST /api/v1/users`, health) MUST NOT. Объявление схемы -MUST NOT менять ответы: без заголовка по-прежнему 401, а не 400 или 403. +объявлять схемы безопасности `bearerAuth` и `basicAuth` так же, как +`contracts/openapi.json`, и MUST NOT объявлять `devUser`. Защищённые +операции SHALL ссылаться на `bearerAuth`, `POST /api/v1/auth/sessions` — +на `basicAuth`, а `POST /api/v1/users` и health MUST NOT ссылаться ни на +одну схему. Объявление схем MUST NOT менять ответы: без заголовка +по-прежнему 401 в формате контракта, а не ошибка FastAPI. #### Scenario: Кнопка Authorize в Swagger - **WHEN** разработчик открывает `/docs` -- **THEN** доступна кнопка Authorize с полем `X-User-Id`, и введённое - значение уходит заголовком в защищённые запросы +- **THEN** кнопка Authorize предлагает Basic для входа и Bearer для + остальных запросов, и введённый токен уходит заголовком + `Authorization: Bearer` в защищённые запросы #### Scenario: Схема в openapi.json - **WHEN** клиент запрашивает `/openapi.json` -- **THEN** `components.securitySchemes.devUser` совпадает с контрактом, - у `GET /api/v1/users/me` `security` равно `[{"devUser": []}]`, а у +- **THEN** `components.securitySchemes.bearerAuth` и `basicAuth` + совпадают с контрактом, `devUser` нет, у `GET /api/v1/users/me` + `security` равно `[{"bearerAuth": []}]`, у + `POST /api/v1/auth/sessions` — `[{"basicAuth": []}]`, а у `POST /api/v1/users` `security` нет diff --git a/openspec/specs/service-configuration/spec.md b/openspec/specs/service-configuration/spec.md index 25246146..0e1f769c 100644 --- a/openspec/specs/service-configuration/spec.md +++ b/openspec/specs/service-configuration/spec.md @@ -119,3 +119,37 @@ docker — по адресу и порту Postgres внутри сети compos `make run_docker`, а файлы конфигурации между запусками не менялись - **THEN** оба запуска доходят до `/health/ready` 200 и видят одни и те же данные + +### Requirement: Срок жизни сессии + +Срок жизни сессии SHALL задаваться параметром приложения +`[auth] session_ttl_seconds` в `config.toml` и одинаково действовать в +консоли и в docker. Без параметра срок SHALL быть 3600 с. Разовая +подмена SHALL работать через окружение `AUTH__SESSION_TTL_SECONDS` без +правки файлов. Значение SHALL быть целым положительным числом секунд, +иначе сервис MUST NOT стартовать (требование «Некорректное значение +останавливает запуск»). Соответствие контрактному имени +`SESSION_TTL_SECONDS` SHALL быть описано в `REPORT.md`. + +#### Scenario: Срок из config.toml + +- **WHEN** в `config.toml` задано `[auth] session_ttl_seconds = 600`, и + сервис запущен через `make run_dev` или `make run_docker` +- **THEN** `expires_at` новой сессии на 600 с позже момента входа + +#### Scenario: Срок по умолчанию + +- **WHEN** параметр в `config.toml` не задан +- **THEN** `expires_at` новой сессии на 3600 с позже момента входа + +#### Scenario: Короткий срок из окружения + +- **WHEN** сервис запущен с `AUTH__SESSION_TTL_SECONDS=2` в окружении, + а файлы не менялись +- **THEN** `expires_at` новой сессии на 2 с позже момента входа + +#### Scenario: Срок не число + +- **WHEN** сервис запускается с `AUTH__SESSION_TTL_SECONDS=abc` или + `0` +- **THEN** сервис не стартует, в журнале — ошибка проверки настроек diff --git a/openspec/specs/service-logging/spec.md b/openspec/specs/service-logging/spec.md index 4fb83944..a62d810b 100644 --- a/openspec/specs/service-logging/spec.md +++ b/openspec/specs/service-logging/spec.md @@ -57,8 +57,10 @@ ### Requirement: Без содержимого сообщений и личных данных Записи MUST NOT содержать текст сообщений, `display_name`, названия -чатов, значения `username`, тела запросов и ответов. Для сообщений -допускаются идентификаторы и длина текста. +чатов, значения `username`, тела запросов и ответов. Записи MUST NOT +содержать пароли, токены сессий, их хэши, значение заголовка +`Authorization` и параметры SQL-запросов. Для сообщений допускаются +идентификаторы и длина текста, для сессий — `id` сессии и `user_id`. #### Scenario: Отправка сообщения @@ -66,6 +68,15 @@ - **THEN** ни одна запись журнала не содержит T, а запись о создании сообщения содержит его `id`, `chat_id` и длину текста +#### Scenario: Вход и выход + +- **WHEN** пользователь регистрируется с паролем P, входит, получает + токен T и выходит, а затем кто-то пытается войти с неверным паролем +- **THEN** ни одна запись журнала не содержит P, T, хэш T и значение + `Authorization`; записи о создании и отзыве сессии содержат `user_id` + и `id` сессии, а неудачный вход записан с уровнем `warning` без + username и пароля + ### Requirement: Непредвиденные ошибки в журнале Непредвиденное исключение SHALL записываться с уровнем `error`, diff --git a/openspec/specs/sessions/spec.md b/openspec/specs/sessions/spec.md new file mode 100644 index 00000000..97431705 --- /dev/null +++ b/openspec/specs/sessions/spec.md @@ -0,0 +1,158 @@ +# sessions Specification + +## Purpose + +Как пользователь получает и теряет право на запросы с лабы 2: вход по +паролю через Basic с выдачей непрозрачного токена, хранение сессий, +срок жизни и отзыв, сохранность действующих сессий после рестарта. + +## Requirements + +### Requirement: Вход по Basic + +`POST /api/v1/auth/sessions` SHALL принимать только заголовок +`Authorization: Basic `; тело запроса MUST +NOT читаться и не влияет на ответ. Схема `Basic` распознаётся без учёта +регистра, credentials декодируются как UTF-8, username и пароль делятся +по первому двоеточию: двоеточие в пароле допустимо. При верной паре +сервис SHALL создать новую сессию и ответить 201 с объектом `Session`: +`token`, `token_type` `Bearer`, `expires_at` в RFC 3339 UTC с `Z` и +`user` — тот же объект `User`, что при регистрации. + +#### Scenario: Успешный вход + +- **WHEN** зарегистрированный пользователь входит со своими username и + паролем +- **THEN** ответ 201 `Session`, `token_type` равен `Bearer`, `user` + совпадает с ответом на регистрацию, `expires_at` в будущем + +#### Scenario: Двоеточие и не-ASCII в пароле + +- **WHEN** пароль содержит `:` и кириллицу, и пользователь входит с ним +- **THEN** ответ 201 + +#### Scenario: Несколько сессий + +- **WHEN** пользователь входит дважды +- **THEN** токены разные, и оба принимаются защищёнными эндпоинтами + +### Requirement: Токен непрозрачный + +Токен SHALL быть случайным значением не короче 32 символов с энтропией +не менее 256 бит. Токен MUST NOT содержать и кодировать `username`, +`id` пользователя или срок. Сервис MUST NOT хранить токен в открытом +виде: по данным хранилища нельзя восстановить действующий токен. + +#### Scenario: Токен не выводится из данных пользователя + +- **WHEN** пользователь получил токен +- **THEN** токен не содержит его `username` и `id`, а у двух входов + одного пользователя токены не совпадают + +#### Scenario: Токена нет в хранилище + +- **WHEN** выдан токен T +- **THEN** ни одна строка таблиц PostgreSQL не содержит T + +### Requirement: Отказ во входе + +Неверный пароль, неизвестный username, отсутствие заголовка, другая +схема вместо `Basic`, битый base64, credentials не в UTF-8 и +credentials без двоеточия SHALL давать одинаковый ответ 401 с `code` +`unauthorized`, одинаковым `message` и заголовком +`WWW-Authenticate: Basic realm="messenger", charset="UTF-8"`. Сессия при +этом MUST NOT создаваться. Время ответа для неизвестного username MUST +NOT заметно отличаться от ответа на неверный пароль: проверка пароля +выполняется в обоих случаях. + +#### Scenario: Неверный пароль + +- **WHEN** пользователь входит со своим username и чужим паролем +- **THEN** ответ 401 с `WWW-Authenticate` схемы `Basic` + +#### Scenario: Неизвестный пользователь + +- **WHEN** вход выполняется с username, которого нет +- **THEN** ответ совпадает с ответом на неверный пароль: тот же статус, + `code`, `message` и `WWW-Authenticate` + +#### Scenario: Битый Basic + +- **WHEN** заголовок `Authorization` равен `Basic !!!`, `Basic` с + base64 без двоеточия или `Bearer <токен>` +- **THEN** ответ 401 с `WWW-Authenticate` схемы `Basic` + +### Requirement: Срок жизни сессии + +Срок сессии SHALL фиксироваться при входе: `expires_at` равен моменту +входа плюс настроенный срок жизни (контрактное имя +`SESSION_TTL_SECONDS`, capability `service-configuration`). +Использование токена и рестарт сервиса MUST NOT продлевать срок. После +`expires_at` токен SHALL получать 401 с `WWW-Authenticate: Bearer +realm="messenger"`. + +#### Scenario: Истёкший токен + +- **WHEN** срок жизни сессии равен 2 с, пользователь вошёл и через 3 с + запрашивает `GET /api/v1/users/me` +- **THEN** ответ 401 с `WWW-Authenticate` схемы `Bearer` + +#### Scenario: Срок не продлевается + +- **WHEN** срок жизни сессии равен 2 с, и пользователь каждые 0,5 с + успешно запрашивает `GET /api/v1/users/me` +- **THEN** запрос через 3 с после входа получает 401 + +### Requirement: Отзыв текущей сессии + +`DELETE /api/v1/auth/sessions/current` с действующим Bearer-токеном +SHALL отзывать сессию этого токена и отвечать 204 без тела. Отзыв SHALL +действовать сразу: следующий запрос с этим токеном к любому защищённому +эндпоинту получает 401. Другие сессии того же пользователя MUST NOT +затрагиваться. Без действующего токена эндпоинт SHALL отвечать 401 с +`WWW-Authenticate: Bearer realm="messenger"`. + +#### Scenario: Выход + +- **WHEN** пользователь вызывает `DELETE /api/v1/auth/sessions/current` + своим токеном, затем `GET /api/v1/users/me` тем же токеном +- **THEN** первый ответ 204 без тела, второй — 401 + +#### Scenario: Повторный выход + +- **WHEN** пользователь второй раз вызывает + `DELETE /api/v1/auth/sessions/current` отозванным токеном +- **THEN** ответ 401 с `WWW-Authenticate` схемы `Bearer` + +#### Scenario: Другая сессия остаётся + +- **WHEN** пользователь вошёл дважды и отозвал первую сессию +- **THEN** второй токен по-прежнему получает 200 + +### Requirement: Сессии переживают рестарт + +Сессии SHALL храниться в PostgreSQL. После перезапуска API и PostgreSQL +с сохранённым volume действующий токен SHALL работать до своего +`expires_at`, а отозванный — оставаться отозванным. + +#### Scenario: Прежний токен после рестарта + +- **WHEN** пользователь вошёл, отправил сообщение, затем выполнен + `scripts/restart.sh` +- **THEN** тот же токен без повторного входа получает 200 и видит своё + сообщение + +### Requirement: Недоступность хранилища сессий + +Если PostgreSQL недоступен, вход и запрос с токеном SHALL получать 503 +`unavailable`. Запрос MUST NOT обрабатываться как анонимный или как +запрос от последнего известного владельца токена, и сервис MUST NOT +отвечать 401 вместо 503: недоступность хранилища не означает, что токен +недействителен. + +#### Scenario: БД остановлена при запросе с токеном + +- **WHEN** PostgreSQL остановлен, и клиент с действующим токеном + запрашивает `GET /api/v1/users/me` +- **THEN** ответ 503 `unavailable`, а после возврата PostgreSQL тот же + токен получает 200 diff --git a/openspec/specs/student-tests/spec.md b/openspec/specs/student-tests/spec.md index a67f5765..b32cbf30 100644 --- a/openspec/specs/student-tests/spec.md +++ b/openspec/specs/student-tests/spec.md @@ -63,8 +63,8 @@ SHALL проходить против сервера, запущенного н ### Requirement: Обязательные сценарии рубрики Набор SHALL содержать отдельные тесты для сценариев уровня «4»: -неверный JSON, чужой чат, пустое сообщение, дубликат `username` и обход -нескольких страниц истории. +неверный JSON, чужой чат, пустое сообщение, дубликат `username`, обход +нескольких страниц истории, а с лабы 2 — неверный пароль и logout. #### Scenario: Неверный JSON @@ -97,6 +97,19 @@ SHALL проходить против сервера, запущенного н в порядке `(created_at, id)`, а последняя страница имеет `next_cursor` null +#### Scenario: Неверный пароль в рубрике + +- **WHEN** зарегистрированный пользователь входит с неверным паролем +- **THEN** проверяется ответ 401 с `WWW-Authenticate` схемы `Basic`, и + выданного токена в ответе нет + +#### Scenario: Logout в рубрике + +- **WHEN** пользователь выходит, а затем повторяет запрос прежним + токеном +- **THEN** проверяется ответ 204 на выход и 401 с `WWW-Authenticate` + схемы `Bearer` на повтор + ### Requirement: Тест гонок Набор SHALL содержать тест гонок с реальной параллельностью: запросы diff --git a/openspec/specs/users/spec.md b/openspec/specs/users/spec.md index b755bc4c..5333a1a4 100644 --- a/openspec/specs/users/spec.md +++ b/openspec/specs/users/spec.md @@ -10,15 +10,17 @@ ### Requirement: Регистрация пользователя `POST /api/v1/users` SHALL быть публичным и принимать тело -`{"username": ..., "display_name": ...}`. При успехе сервис SHALL -отвечать 201 с объектом `User`: `id`, `username`, `display_name`, -`created_at`, без других полей. `id` и `created_at` назначает сервер. +`{"username": ..., "display_name": ..., "password": ...}`. При успехе +сервис SHALL отвечать 201 с объектом `User`: `id`, `username`, +`display_name`, `created_at`, без других полей: пароля и его хэша в +ответе нет. `id` и `created_at` назначает сервер. #### Scenario: Успешная регистрация -- **WHEN** клиент отправляет `{"username": "alice", "display_name": "Алиса"}` +- **WHEN** клиент отправляет `{"username": "alice", "display_name": + "Алиса", "password": ...}` с допустимым паролем - **THEN** ответ 201, `username` и `display_name` совпадают с - отправленными, `id` — новый UUID + отправленными, `id` — новый UUID, полей кроме четырёх полей `User` нет ### Requirement: Формат username @@ -56,6 +58,49 @@ NOT состоять только из пробельных символов. З - **WHEN** `display_name` равен `" "` - **THEN** ответ 400 +### Requirement: Формат пароля + +`password` SHALL содержать от 12 до 128 Unicode code points и MUST NOT +состоять только из пробельных символов. Допустимы любые символы +Unicode, в том числе `:`. Значение SHALL использоваться без изменений: +без обрезки, нормализации и усечения по байтам. Иначе сервис SHALL +отвечать 400 `invalid_request`. + +#### Scenario: Нет пароля + +- **WHEN** тело регистрации не содержит `password` +- **THEN** ответ 400 + +#### Scenario: Граница длины пароля + +- **WHEN** `password` из 11 code points, затем из 12, из 128 и из 129 +- **THEN** первый и последний запросы дают 400, остальные — 201 + +#### Scenario: Пароль из пробелов + +- **WHEN** `password` из 12 пробелов +- **THEN** ответ 400 + +#### Scenario: Длинный пароль в UTF-8 целиком + +- **WHEN** пользователь зарегистрировался с паролем из 128 кириллических + символов, затем входит с паролем, где изменён только последний символ +- **THEN** вход отклонён 401: пароль сравнивается целиком, а не по + первым байтам + +### Requirement: Пароль хранится только хэшем + +Сервис SHALL хранить пароль только как результат библиотечного password +KDF с солью. Пароль MUST NOT храниться в открытом виде или как быстрый +хэш (SHA-256 и подобные) и MUST NOT попадать в ответы API и журнал. + +#### Scenario: Хэш в БД + +- **WHEN** пользователь зарегистрирован с паролем P +- **THEN** в его строке в PostgreSQL нет P, а хранимое значение — строка + KDF с параметрами и солью; у двух пользователей с одинаковым паролем + хранимые значения разные + ### Requirement: Уникальность username `username` SHALL быть уникальным. Повторная регистрация занятого @@ -75,10 +120,11 @@ NOT состоять только из пробельных символов. З ### Requirement: Текущий пользователь -`GET /api/v1/users/me` SHALL возвращать 200 с объектом `User` текущего -пользователя (capability `identification`). +`GET /api/v1/users/me` SHALL возвращать 200 с объектом `User` владельца +сессии, чей токен передан (capability `identification`). #### Scenario: Совпадает с регистрацией -- **WHEN** пользователь запрашивает `GET /api/v1/users/me` со своим `X-User-Id` +- **WHEN** пользователь запрашивает `GET /api/v1/users/me` со своим + токеном - **THEN** тело ответа равно телу ответа на его регистрацию diff --git a/pyproject.toml b/pyproject.toml index 5b8ce36c..63532855 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -16,6 +16,8 @@ dependencies = [ "asyncpg>=0.31.0,<0.32", # в основной группе: сервис миграций работает в runtime-образе (--no-dev) "alembic>=1.20.0,<2", + # Argon2id для паролей: bcrypt режет пароль на 72 байтах, lab7 — Argon2id + "argon2-cffi>=25.1.0,<26", ] [project.optional-dependencies] diff --git a/src/api/dependencies.py b/src/api/dependencies.py index fcf5efb5..a909a9b4 100644 --- a/src/api/dependencies.py +++ b/src/api/dependencies.py @@ -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)] diff --git a/src/api/errors.py b/src/api/errors.py index 83a27656..5a55fbd6 100644 --- a/src/api/errors.py +++ b/src/api/errors.py @@ -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, ) diff --git a/src/api/routers/v1/__init__.py b/src/api/routers/v1/__init__.py index ec2fd30f..8e02a304 100644 --- a/src/api/routers/v1/__init__.py +++ b/src/api/routers/v1/__init__.py @@ -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) diff --git a/src/api/routers/v1/session.py b/src/api/routers/v1/session.py new file mode 100644 index 00000000..ae2e15fb --- /dev/null +++ b/src/api/routers/v1/session.py @@ -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) diff --git a/src/api/routers/v1/user.py b/src/api/routers/v1/user.py index 4db23ad1..6e1112f6 100644 --- a/src/api/routers/v1/user.py +++ b/src/api/routers/v1/user.py @@ -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) diff --git a/src/api/schemas/__init__.py b/src/api/schemas/__init__.py index 1cc4d29f..cec9a6e1 100644 --- a/src/api/schemas/__init__.py +++ b/src/api/schemas/__init__.py @@ -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", ] diff --git a/src/api/schemas/session.py b/src/api/schemas/session.py new file mode 100644 index 00000000..ca16f57e --- /dev/null +++ b/src/api/schemas/session.py @@ -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 diff --git a/src/api/schemas/user.py b/src/api/schemas/user.py index 3ea571f3..4ae3ee23 100644 --- a/src/api/schemas/user.py +++ b/src/api/schemas/user.py @@ -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): diff --git a/src/config/settings.py b/src/config/settings.py index d9c9314d..d923ffba 100644 --- a/src/config/settings.py +++ b/src/config/settings.py @@ -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( diff --git a/src/core/exceptions/__init__.py b/src/core/exceptions/__init__.py index 584aa7d9..ed143375 100644 --- a/src/core/exceptions/__init__.py +++ b/src/core/exceptions/__init__.py @@ -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", ] diff --git a/src/core/exceptions/session.py b/src/core/exceptions/session.py new file mode 100644 index 00000000..14153440 --- /dev/null +++ b/src/core/exceptions/session.py @@ -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" diff --git a/src/core/exceptions/user.py b/src/core/exceptions/user.py index 91c31b8a..5a42a7bb 100644 --- a/src/core/exceptions/user.py +++ b/src/core/exceptions/user.py @@ -1,12 +1,6 @@ from .base import DomainError -class Unidentified(DomainError): - """Нет X-User-Id, он не UUID или такого пользователя нет.""" - - default_message = "User identification required" - - class UsernameTaken(DomainError): """username уже занят.""" diff --git a/src/core/repos/session.py b/src/core/repos/session.py new file mode 100644 index 00000000..d520dbf4 --- /dev/null +++ b/src/core/repos/session.py @@ -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 diff --git a/src/core/repos/user.py b/src/core/repos/user.py index 833824ff..fe68d1ac 100644 --- a/src/core/repos/user.py +++ b/src/core/repos/user.py @@ -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( diff --git a/src/core/services/__init__.py b/src/core/services/__init__.py index 0d03e194..e25f760e 100644 --- a/src/core/services/__init__.py +++ b/src/core/services/__init__.py @@ -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", ] diff --git a/src/core/services/session.py b/src/core/services/session.py new file mode 100644 index 00000000..a9879952 --- /dev/null +++ b/src/core/services/session.py @@ -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) diff --git a/src/core/services/user.py b/src/core/services/user.py index 83864893..0ab7e6c0 100644 --- a/src/core/services/user.py +++ b/src/core/services/user.py @@ -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 diff --git a/src/infra/db/models/__init__.py b/src/infra/db/models/__init__.py index d08d6230..3a444ee9 100644 --- a/src/infra/db/models/__init__.py +++ b/src/infra/db/models/__init__.py @@ -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", ] diff --git a/src/infra/db/models/session.py b/src/infra/db/models/session.py new file mode 100644 index 00000000..b4acab74 --- /dev/null +++ b/src/infra/db/models/session.py @@ -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)) diff --git a/src/infra/db/models/user.py b/src/infra/db/models/user.py index 4b142ed9..d300631b 100644 --- a/src/infra/db/models/user.py +++ b/src/infra/db/models/user.py @@ -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) diff --git a/src/infra/password.py b/src/infra/password.py new file mode 100644 index 00000000..b4c2f7bd --- /dev/null +++ b/src/infra/password.py @@ -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 diff --git a/src/schemas/dataclasses/__init__.py b/src/schemas/dataclasses/__init__.py index 4948a5fb..21199b00 100644 --- a/src/schemas/dataclasses/__init__.py +++ b/src/schemas/dataclasses/__init__.py @@ -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", ] diff --git a/src/schemas/dataclasses/session.py b/src/schemas/dataclasses/session.py new file mode 100644 index 00000000..903202c3 --- /dev/null +++ b/src/schemas/dataclasses/session.py @@ -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 diff --git a/src/schemas/dataclasses/user.py b/src/schemas/dataclasses/user.py index d200a2f7..f1b65eb8 100644 --- a/src/schemas/dataclasses/user.py +++ b/src/schemas/dataclasses/user.py @@ -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 diff --git a/src/utils/constants.py b/src/utils/constants.py index 5637bbaf..51d2a0f3 100644 --- a/src/utils/constants.py +++ b/src/utils/constants.py @@ -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 diff --git a/student-tests/api_client.py b/student-tests/api_client.py index d4979d88..f9a9031e 100644 --- a/student-tests/api_client.py +++ b/student-tests/api_client.py @@ -1,5 +1,8 @@ """HTTP-клиент набора: запросы к API и идентификация в одном месте.""" +import base64 +import dataclasses +import secrets import uuid from collections.abc import Callable, Sequence from dataclasses import dataclass @@ -11,6 +14,7 @@ import httpx from contract import assert_ok API = "/api/v1" +SESSIONS = f"{API}/auth/sessions" # защита от бесконечного обхода, если next_cursor никогда не станет null MAX_PAGES = 1000 @@ -20,6 +24,34 @@ def unique_username() -> str: return f"t_{uuid.uuid4().hex[:12]}" +def unique_password() -> str: + """Синтетический пароль из 12–128 символов, свой у каждого вызова.""" + return f"pw-{uuid.uuid4().hex}" + + +def registration( + username: str, + display_name: Any = "Test user", + password: Any = None, +) -> dict[str, Any]: + """Тело `POST /users`; пароль по умолчанию — новый синтетический.""" + return { + "username": username, + "display_name": display_name, + "password": unique_password() if password is None else password, + } + + +def basic_auth(username: str, password: str) -> dict[str, str]: + """`Authorization: Basic` из username и пароля в UTF-8.""" + raw = f"{username}:{password}".encode() + return {"Authorization": "Basic " + base64.b64encode(raw).decode("ascii")} + + +def bearer_auth(token: str) -> dict[str, str]: + return {"Authorization": f"Bearer {token}"} + + def order_key(item: dict[str, Any]) -> tuple[datetime, int]: """Порядок списков API: `(created_at, id)`, id сравнивается как UUID.""" created_at = datetime.fromisoformat(item["created_at"]) @@ -28,22 +60,36 @@ def order_key(item: dict[str, Any]) -> tuple[datetime, int]: @dataclass(frozen=True) class Actor: - """Зарегистрированный пользователь и то, как он себя называет.""" + """Пользователь, его пароль и токен текущей сессии.""" user: dict[str, Any] + password: str + token: str @classmethod def unregistered(cls) -> "Actor": - """Пользователь, которого нет на сервере.""" - return cls(user={"id": str(uuid.uuid4())}) + """Пользователь, которого нет на сервере, с невыданным токеном.""" + return cls( + user={"id": str(uuid.uuid4()), "username": unique_username()}, + password=unique_password(), + token=secrets.token_urlsafe(32), + ) @property def id(self) -> str: return self.user["id"] + @property + def username(self) -> str: + return self.user["username"] + + def with_token(self, token: str) -> "Actor": + """Тот же пользователь с другой сессией.""" + return dataclasses.replace(self, token=token) + def headers(self) -> dict[str, str]: - """Идентификация: лаба 1 — `X-User-Id`, с лабы 2 — Bearer.""" - return {"X-User-Id": self.id} + """Идентификация: с лабы 2 — Bearer-токен сессии.""" + return bearer_auth(self.token) class Api: @@ -79,16 +125,38 @@ class Api: *, username: str | None = None, display_name: str = "Test user", + password: str | None = None, ) -> Actor: + """Регистрация и сразу вход: у пользователя есть токен.""" + password = password or unique_password() resp = self.request( "POST", f"{API}/users", - json={ - "username": username or unique_username(), - "display_name": display_name, - }, + json=registration( + username or unique_username(), + display_name, + password, + ), ) - return Actor(assert_ok(resp, 201, "User")) + user = assert_ok(resp, 201, "User") + return self.login(user, password) + + def login_response(self, username: str, password: str) -> httpx.Response: + return self.request( + "POST", + SESSIONS, + headers=basic_auth(username, password), + ) + + def login(self, user: dict[str, Any], password: str) -> Actor: + """Новая сессия пользователя; ответ проверяется по схеме `Session`.""" + resp = self.login_response(user["username"], password) + session = assert_ok(resp, 201, "Session") + assert session["user"] == user, "session user differs from user" + return Actor(user=user, password=password, token=session["token"]) + + def logout(self, actor: Actor) -> httpx.Response: + return self.request("DELETE", f"{SESSIONS}/current", actor=actor) def create_chat( self, diff --git a/student-tests/contract.py b/student-tests/contract.py index e6b58632..32d454fe 100644 --- a/student-tests/contract.py +++ b/student-tests/contract.py @@ -23,6 +23,10 @@ UUID_RE = re.compile( # RFC 3339 в UTC: шесть знаков долей секунды и суффикс Z CREATED_AT_RE = re.compile(r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{6}Z$") ID_KEYS = frozenset({"id", "chat_id", "sender_id"}) +TIME_KEYS = frozenset({"created_at", "expires_at"}) +# WWW-Authenticate у 401 (contracts/README.md): вход и остальные запросы +BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"' +BEARER_CHALLENGE = 'Bearer realm="messenger"' # признаки внутренностей сервиса в error.message LEAK_RE = re.compile(r"Traceback|File \"|\.py\b|/app/|/src/|Error\(") @@ -82,7 +86,7 @@ def check_formats(value: Any, path: str = "") -> None: elif key == "member_ids": for number, member in enumerate(item): assert_uuid(member, f"{where}/{number}") - elif key == "created_at": + elif key in TIME_KEYS: assert_created_at(item, where) else: check_formats(item, where) @@ -135,6 +139,19 @@ def assert_error(resp: httpx.Response, status: int) -> dict[str, Any]: return error +def assert_unauthorized( + resp: httpx.Response, + challenge: str, +) -> dict[str, Any]: + """401 в формате контракта с заданным `WWW-Authenticate`.""" + error = assert_error(resp, 401) + assert resp.headers.get("WWW-Authenticate") == challenge, describe( + resp, + f"expected WWW-Authenticate {challenge}", + ) + return error + + def json_body(resp: httpx.Response) -> Any: """JSON-тело в UTF-8 и непустой `X-Request-Id`.""" request_id = resp.headers.get("X-Request-Id", "") diff --git a/student-tests/spec_coverage.py b/student-tests/spec_coverage.py index c876fa83..93998b7e 100644 --- a/student-tests/spec_coverage.py +++ b/student-tests/spec_coverage.py @@ -13,6 +13,7 @@ SPECS_DIR = Path(__file__).resolve().parents[1] / "openspec" / "specs" CAPABILITIES = ( "api-conventions", "identification", + "sessions", "users", "chats", "messages", @@ -48,8 +49,9 @@ EXCLUDED: dict[Scenario, Exclusion] = { ), ("data-storage", "Прежний пользователь после рестарта"): Exclusion( reason="нужен рестарт стенда, тесты сервер не трогают", - check="evidence/storage/restart.md: после scripts/restart.sh " - "прежний X-User-Id получает 200, данные и порядок те же", + check="make test-persistence ACTION_SCRIPT=scripts/restart.sh: " + "прежний токен читает те же данные — " + "evidence/storage/test-persistence.md", ), ("data-storage", "Сбой при добавлении участников"): Exclusion( reason="нужен сбой БД посреди транзакции: штатным запросом его " @@ -80,8 +82,39 @@ EXCLUDED: dict[Scenario, Exclusion] = { ), ("identification", "Кнопка Authorize в Swagger"): Exclusion( reason="это интерфейс /docs в браузере", - check="схему devUser, из которой строится кнопка, проверяет " - "тест сценария «Схема в openapi.json»; кнопку — вручную", + check="схемы bearerAuth и basicAuth, из которых строится кнопка, " + "проверяет тест сценария «Схема в openapi.json»; кнопку — вручную", + ), + ("sessions", "Токена нет в хранилище"): Exclusion( + reason="нужен доступ к таблицам PostgreSQL, а тесты ходят по HTTP", + check="поиск выданного токена по всем таблицам через psql — " + "evidence/auth/passwords-and-tokens.md", + ), + ("sessions", "Истёкший токен"): Exclusion( + reason="нужен сервис со сроком сессии 2 с, а обычный стенд — с 3600 с", + check="AUTH__SESSION_TTL_SECONDS=2 — evidence/auth/expiry.md; " + "автоматическая проверка — change failure-checks", + ), + ("sessions", "Срок не продлевается"): Exclusion( + reason="нужен сервис со сроком сессии 2 с", + check="запросы каждые 0,5 с при сроке 2 с — " + "evidence/auth/expiry.md; автоматическая проверка — change " + "failure-checks", + ), + ("sessions", "Прежний токен после рестарта"): Exclusion( + reason="нужен рестарт стенда, тесты сервер не трогают", + check="make test-persistence ACTION_SCRIPT=scripts/restart.sh — " + "evidence/storage/test-persistence.md", + ), + ("sessions", "БД остановлена при запросе с токеном"): Exclusion( + reason="нужно остановить Postgres, тесты стенд не трогают", + check="evidence/auth/expiry.md; автоматическая проверка — " + "change failure-checks", + ), + ("users", "Хэш в БД"): Exclusion( + reason="нужен доступ к таблице users, а тесты ходят по HTTP", + check="строки users через psql: префикс $argon2id$ и разные " + "хэши одинаковых паролей — evidence/auth/passwords-and-tokens.md", ), } diff --git a/student-tests/test_api_conventions.py b/student-tests/test_api_conventions.py index 148740cb..a134aaad 100644 --- a/student-tests/test_api_conventions.py +++ b/student-tests/test_api_conventions.py @@ -5,7 +5,7 @@ from typing import Any import pytest -from api_client import API, Actor, Api, unique_username +from api_client import API, Actor, Api, registration, unique_username from contract import ( assert_created_at, assert_error, @@ -93,7 +93,7 @@ def test_error_request_id_matches_header( resp = api.request( "POST", f"{API}/users", - json={"username": alice.user["username"], "display_name": "Alice"}, + json=registration(alice.username, "Alice"), ) assert_error(resp, 409) @@ -103,7 +103,7 @@ def test_no_fastapi_detail(api: Api, alice: Actor) -> None: validation = api.request( "POST", f"{API}/users", - json={"username": "ab", "display_name": "x"}, + json=registration("ab", "x"), ) not_found = api.request("GET", f"{API}/unknown", actor=alice) for resp, status in ((validation, 400), (not_found, 404)): @@ -126,11 +126,7 @@ def test_extra_field(api: Api, alice: Actor) -> None: resp = api.request( "POST", f"{API}/users", - json={ - "username": unique_username(), - "display_name": "Extra", - "is_admin": True, - }, + json={**registration(unique_username(), "Extra"), "is_admin": True}, ) assert_error(resp, 400) resp = api.request( @@ -148,7 +144,7 @@ def test_wrong_type_is_not_coerced(api: Api) -> None: resp = api.request( "POST", f"{API}/users", - json={"username": username, "display_name": 123}, + json=registration(username, 123), ) assert_error(resp, 400) # пользователь не создан: то же имя свободно diff --git a/student-tests/test_health.py b/student-tests/test_health.py index 8dc8bffb..7b251390 100644 --- a/student-tests/test_health.py +++ b/student-tests/test_health.py @@ -1,4 +1,4 @@ -"""Спек `health`: live и ready без идентификации, вне `/api/v1`.""" +"""Спек `health`: live и ready без аутентификации, вне `/api/v1`.""" import pytest @@ -21,7 +21,15 @@ def test_ready(api: Api) -> None: @pytest.mark.spec("health", "Неизвестный X-User-Id") -def test_unknown_user_is_ignored(api: Api) -> None: +def test_unknown_user_id_is_ignored(api: Api) -> None: + ghost = Actor.unregistered() + for path in HEALTH: + resp = api.request("GET", path, headers={"X-User-Id": ghost.id}) + assert assert_ok(resp, 200, "Health") == {"status": "ok"} + + +@pytest.mark.spec("health", "Неизвестный токен") +def test_unknown_token_is_ignored(api: Api) -> None: ghost = Actor.unregistered() for path in HEALTH: resp = api.request("GET", path, actor=ghost) diff --git a/student-tests/test_identification.py b/student-tests/test_identification.py index dc294709..19c0370a 100644 --- a/student-tests/test_identification.py +++ b/student-tests/test_identification.py @@ -1,51 +1,81 @@ -"""Спек `identification`: заголовок `X-User-Id` лабы 1. +"""Спек `identification`: Bearer на защищённых эндпоинтах с лабы 2. -Единственный модуль, который собирает заголовок сам, а не через -`Actor.headers()`: проверяется именно заголовок. На лабе 2 модуль -переписывается вместе со спеком. +Единственный модуль, который собирает `Authorization` и `X-User-Id` +сам, а не через `Actor.headers()`: проверяются именно заголовки. """ -import uuid +import secrets from typing import Any import pytest -from api_client import API, Actor, Api -from contract import assert_error, assert_ok, contract +from api_client import API, Actor, Api, basic_auth, bearer_auth +from contract import ( + BEARER_CHALLENGE, + assert_error, + assert_ok, + assert_unauthorized, + contract, +) ME = f"{API}/users/me" -@pytest.mark.spec("identification", "Корректный заголовок") -def test_valid_header(api: Api, alice: Actor) -> None: - resp = api.request("GET", ME, headers={"X-User-Id": alice.id}) +@pytest.mark.spec("identification", "Действующий токен") +def test_valid_token(api: Api, alice: Actor) -> None: + resp = api.request("GET", ME, headers=bearer_auth(alice.token)) assert assert_ok(resp, 200, "User") == alice.user @pytest.mark.spec("identification", "Нет заголовка") def test_no_header(api: Api) -> None: - assert_error(api.request("GET", ME), 401) + assert_unauthorized(api.request("GET", ME), BEARER_CHALLENGE) -@pytest.mark.spec("identification", "Не UUID") -def test_not_uuid(api: Api) -> None: - resp = api.request("GET", ME, headers={"X-User-Id": "not-a-uuid"}) - assert_error(resp, 401) +@pytest.mark.spec("identification", "Неизвестный токен") +def test_unknown_token(api: Api) -> None: + for token in (secrets.token_urlsafe(32), "x"): + resp = api.request("GET", ME, headers=bearer_auth(token)) + assert_unauthorized(resp, BEARER_CHALLENGE) + # схема без токена — тот же ответ + resp = api.request("GET", ME, headers={"Authorization": "Bearer"}) + assert_unauthorized(resp, BEARER_CHALLENGE) -@pytest.mark.spec("identification", "Неизвестный пользователь") -def test_unknown_user(api: Api) -> None: - resp = api.request("GET", ME, headers={"X-User-Id": str(uuid.uuid4())}) - assert_error(resp, 401) +@pytest.mark.spec("identification", "Basic на бизнес-эндпоинте") +def test_basic_on_business_endpoint(api: Api, alice: Actor) -> None: + resp = api.request( + "GET", + ME, + headers=basic_auth(alice.username, alice.password), + ) + assert_unauthorized(resp, BEARER_CHALLENGE) + + +@pytest.mark.spec("identification", "Только X-User-Id") +def test_only_user_id_header(api: Api, alice: Actor) -> None: + resp = api.request("GET", ME, headers={"X-User-Id": alice.id}) + assert_unauthorized(resp, BEARER_CHALLENGE) + + +@pytest.mark.spec("identification", "X-User-Id не меняет владельца") +def test_user_id_header_ignored(api: Api, alice: Actor, eve: Actor) -> None: + resp = api.request( + "GET", + ME, + headers={**bearer_auth(alice.token), "X-User-Id": eve.id}, + ) + assert assert_ok(resp, 200, "User") == alice.user @pytest.mark.spec("identification", "Чужой чат без заголовка") -def test_chat_without_header(api: Api, chat: dict[str, Any]) -> None: - assert_error(api.request("GET", f"{API}/chats/{chat['id']}"), 401) +def test_chat_without_token(api: Api, chat: dict[str, Any]) -> None: + resp = api.request("GET", f"{API}/chats/{chat['id']}") + assert_unauthorized(resp, BEARER_CHALLENGE) @pytest.mark.spec("identification", "Невалидное поле без заголовка") -def test_invalid_field_without_header( +def test_invalid_field_without_token( api: Api, alice: Actor, chat: dict[str, Any], @@ -55,16 +85,16 @@ def test_invalid_field_without_header( f"{API}/chats/{chat['id']}/messages", json={"text": ""}, ) - assert_error(resp, 401) + assert_unauthorized(resp, BEARER_CHALLENGE) assert api.all_messages(alice, chat["id"]) == [] @pytest.mark.spec("identification", "Битый JSON без заголовка") -def test_malformed_json_without_header( +def test_malformed_json_without_token( api: Api, chat: dict[str, Any], ) -> None: - # согласованное расхождение: битый JSON отклоняется до идентификации + # согласованное расхождение: битый JSON отклоняется до аутентификации resp = api.request( "POST", f"{API}/chats/{chat['id']}/messages", @@ -75,12 +105,19 @@ def test_malformed_json_without_header( @pytest.mark.spec("identification", "Схема в openapi.json") -def test_security_scheme_in_openapi(api: Api) -> None: +def test_security_schemes_in_openapi(api: Api) -> None: resp = api.request("GET", "/openapi.json") assert resp.status_code == 200 served = resp.json() - expected = contract()["components"]["securitySchemes"]["devUser"] + schemes = served["components"]["securitySchemes"] + expected = contract()["components"]["securitySchemes"] - assert served["components"]["securitySchemes"]["devUser"] == expected - assert served["paths"][ME]["get"]["security"] == [{"devUser": []}] - assert not served["paths"][f"{API}/users"]["post"].get("security") + assert schemes["bearerAuth"] == expected["bearerAuth"] + assert schemes["basicAuth"] == expected["basicAuth"] + assert "devUser" not in schemes + paths = served["paths"] + assert paths[ME]["get"]["security"] == [{"bearerAuth": []}] + assert paths[f"{API}/auth/sessions"]["post"]["security"] == [ + {"basicAuth": []}, + ] + assert not paths[f"{API}/users"]["post"].get("security") diff --git a/student-tests/test_race.py b/student-tests/test_race.py index e3b0c498..81624eac 100644 --- a/student-tests/test_race.py +++ b/student-tests/test_race.py @@ -9,7 +9,7 @@ from concurrent.futures import ThreadPoolExecutor import httpx import pytest -from api_client import API, Api, order_key, unique_username +from api_client import API, Api, order_key, registration, unique_username from contract import assert_error, assert_ok CLIENTS = 10 @@ -113,7 +113,7 @@ def test_same_username_at_once(base_url: str) -> None: resp = own.request( "POST", f"{API}/users", - json={"username": username, "display_name": f"Racer {number}"}, + json=registration(username, f"Racer {number}"), ) return resp, start, time.monotonic() diff --git a/student-tests/test_rubric.py b/student-tests/test_rubric.py index 9172fa91..82f754de 100644 --- a/student-tests/test_rubric.py +++ b/student-tests/test_rubric.py @@ -5,8 +5,13 @@ from typing import Any import pytest -from api_client import API, Actor, Api, order_key -from contract import assert_error +from api_client import API, Actor, Api, order_key, registration +from contract import ( + BASIC_CHALLENGE, + BEARER_CHALLENGE, + assert_error, + assert_unauthorized, +) @pytest.mark.spec("api-conventions", "Битый JSON") @@ -75,14 +80,27 @@ def test_duplicate_username(api: Api, alice: Actor) -> None: resp = api.request( "POST", f"{API}/users", - json={ - "username": alice.user["username"], - "display_name": "Другая Алиса", - }, + json=registration(alice.username, "Другая Алиса"), ) assert_error(resp, 409) +@pytest.mark.spec("sessions", "Неверный пароль") +def test_wrong_password(api: Api, alice: Actor) -> None: + resp = api.login_response(alice.username, alice.password + "-wrong") + assert_unauthorized(resp, BASIC_CHALLENGE) + assert "token" not in resp.json() + + +@pytest.mark.spec("sessions", "Выход") +def test_logout(api: Api, alice: Actor) -> None: + resp = api.logout(alice) + assert resp.status_code == 204, resp.text + assert resp.content == b"" + after = api.request("GET", f"{API}/users/me", actor=alice) + assert_unauthorized(after, BEARER_CHALLENGE) + + def test_history_walk_across_pages( api: Api, alice: Actor, diff --git a/student-tests/test_sessions.py b/student-tests/test_sessions.py new file mode 100644 index 00000000..26cd5376 --- /dev/null +++ b/student-tests/test_sessions.py @@ -0,0 +1,162 @@ +"""Спек `sessions`: вход по Basic, токен, отказ во входе, отзыв. + +Истечение, рестарт и недоступность БД требуют особого стенда — это +исключения в `spec_coverage.py`. Неверный пароль и выход — в +`test_rubric.py` (обязательные сценарии уровня «4»). +""" + +import base64 +from datetime import UTC, datetime + +import pytest + +from api_client import ( + API, + SESSIONS, + Actor, + Api, + bearer_auth, + unique_username, +) +from contract import ( + BASIC_CHALLENGE, + BEARER_CHALLENGE, + assert_ok, + assert_unauthorized, +) + +ME = f"{API}/users/me" + + +def basic_header(raw: bytes) -> dict[str, str]: + """`Authorization: Basic` из произвольных байтов, в том числе битых.""" + return {"Authorization": "Basic " + base64.b64encode(raw).decode("ascii")} + + +@pytest.mark.spec("sessions", "Успешный вход") +def test_login(api: Api, alice: Actor) -> None: + resp = api.login_response(alice.username, alice.password) + session = assert_ok(resp, 201, "Session") + + assert session["token_type"] == "Bearer" + assert session["user"] == alice.user + expires_at = datetime.fromisoformat(session["expires_at"]) + assert expires_at > datetime.now(UTC) + me = api.request("GET", ME, headers=bearer_auth(session["token"])) + assert assert_ok(me, 200, "User") == alice.user + + +@pytest.mark.spec("sessions", "Успешный вход") +def test_login_ignores_body(api: Api, alice: Actor, eve: Actor) -> None: + # тело не читается: вход определяет только Basic + resp = api.request( + "POST", + SESSIONS, + headers=basic_header(f"{alice.username}:{alice.password}".encode()), + json={"username": eve.username, "password": eve.password}, + ) + assert assert_ok(resp, 201, "Session")["user"] == alice.user + + +@pytest.mark.spec("sessions", "Двоеточие и не-ASCII в пароле") +def test_password_with_colon_and_cyrillic(api: Api) -> None: + password = "Пароль:с:двоеточиями-1" + actor = api.register(password=password) + resp = api.request("GET", ME, actor=actor) + assert assert_ok(resp, 200, "User") == actor.user + + +@pytest.mark.spec("sessions", "Несколько сессий") +def test_two_sessions(api: Api, alice: Actor) -> None: + second = api.login(alice.user, alice.password) + + assert second.token != alice.token + for actor in (alice, second): + resp = api.request("GET", ME, actor=actor) + assert assert_ok(resp, 200, "User") == alice.user + + +@pytest.mark.spec("sessions", "Токен не выводится из данных пользователя") +def test_token_is_opaque(api: Api, alice: Actor) -> None: + second = api.login(alice.user, alice.password) + for token in (alice.token, second.token): + assert len(token) >= 32 + for value in (alice.username, alice.id, alice.id.replace("-", "")): + assert value not in token + assert alice.token != second.token + + +@pytest.mark.spec("sessions", "Неизвестный пользователь") +def test_unknown_user_same_as_wrong_password(api: Api, alice: Actor) -> None: + wrong = assert_unauthorized( + api.login_response(alice.username, "Wrong-password-1"), + BASIC_CHALLENGE, + ) + unknown = assert_unauthorized( + api.login_response(unique_username(), "Wrong-password-1"), + BASIC_CHALLENGE, + ) + assert (unknown["code"], unknown["message"]) == ( + wrong["code"], + wrong["message"], + ) + + +@pytest.mark.spec("sessions", "Битый Basic") +def test_broken_basic(api: Api, alice: Actor) -> None: + headers = ( + {"Authorization": "Basic !!!"}, + basic_header(b"no-colon-here"), + basic_header(b"\xff\xfe:not-utf-8-password"), + {"Authorization": "Basic"}, + bearer_auth(alice.token), + {}, + ) + for header in headers: + resp = api.request("POST", SESSIONS, headers=header) + assert_unauthorized(resp, BASIC_CHALLENGE) + + +@pytest.mark.spec("sessions", "Повторный выход") +def test_logout_twice(api: Api, alice: Actor) -> None: + assert api.logout(alice).status_code == 204 + assert_unauthorized(api.logout(alice), BEARER_CHALLENGE) + # без токена выход тоже 401 с вызовом Bearer + resp = api.request("DELETE", f"{SESSIONS}/current") + assert_unauthorized(resp, BEARER_CHALLENGE) + + +@pytest.mark.spec("sessions", "Другая сессия остаётся") +def test_other_session_survives_logout(api: Api, alice: Actor) -> None: + second = api.login(alice.user, alice.password) + assert api.logout(alice).status_code == 204 + + assert_unauthorized(api.request("GET", ME, actor=alice), BEARER_CHALLENGE) + resp = api.request("GET", ME, actor=second) + assert assert_ok(resp, 200, "User") == alice.user + + +def test_revoked_token_rejected_everywhere( + api: Api, + alice: Actor, + bob: Actor, +) -> None: + """Отозванный токен не проходит ни на одном защищённом эндпоинте.""" + chat = api.create_chat(alice, bob) + assert api.logout(alice).status_code == 204 + for method, path in ( + ("GET", ME), + ("GET", f"{API}/chats"), + ("GET", f"{API}/chats/{chat['id']}"), + ("GET", f"{API}/chats/{chat['id']}/messages"), + ): + resp = api.request(method, path, actor=alice) + assert_unauthorized(resp, BEARER_CHALLENGE) + resp = api.request( + "POST", + f"{API}/chats/{chat['id']}/messages", + actor=alice, + json={"text": "после выхода"}, + ) + assert_unauthorized(resp, BEARER_CHALLENGE) + assert api.all_messages(bob, chat["id"]) == [] diff --git a/student-tests/test_users.py b/student-tests/test_users.py index aec7e3df..5d861a30 100644 --- a/student-tests/test_users.py +++ b/student-tests/test_users.py @@ -3,19 +3,25 @@ import httpx import pytest -from api_client import API, Actor, Api, unique_username -from contract import assert_error, assert_ok +from api_client import API, Actor, Api, registration, unique_username +from contract import ( + BASIC_CHALLENGE, + assert_error, + assert_ok, + assert_unauthorized, +) def register_raw( api: Api, username: str, display_name: str = "User", + password: str | None = None, ) -> httpx.Response: return api.request( "POST", f"{API}/users", - json={"username": username, "display_name": display_name}, + json=registration(username, display_name, password), ) @@ -69,3 +75,42 @@ def test_display_name_blank(api: Api) -> None: def test_me_equals_registration(api: Api, alice: Actor) -> None: resp = api.request("GET", f"{API}/users/me", actor=alice) assert assert_ok(resp, 200, "User") == alice.user + + +@pytest.mark.spec("users", "Нет пароля") +def test_password_missing(api: Api) -> None: + resp = api.request( + "POST", + f"{API}/users", + json={"username": unique_username(), "display_name": "User"}, + ) + assert_error(resp, 400) + + +@pytest.mark.spec("users", "Граница длины пароля") +def test_password_length(api: Api) -> None: + # длина — в code points: «ж» занимает два байта UTF-8 + for length, status in ((11, 400), (12, 201), (128, 201), (129, 400)): + resp = register_raw(api, unique_username(), password="ж" * length) + if status == 201: + assert_ok(resp, 201, "User") + else: + assert_error(resp, status) + + +@pytest.mark.spec("users", "Пароль из пробелов") +def test_password_blank(api: Api) -> None: + assert_error(register_raw(api, unique_username(), password=" " * 12), 400) + # значимые пробелы по краям допустимы и не обрезаются + actor = api.register(password=" spaced-pass ") + assert api.login(actor.user, " spaced-pass ").user == actor.user + + +@pytest.mark.spec("users", "Длинный пароль в UTF-8 целиком") +def test_long_password_compared_whole(api: Api) -> None: + password = "ж" * 128 + actor = api.register(password=password) + changed = password[:-1] + "з" + resp = api.login_response(actor.username, changed) + assert_unauthorized(resp, BASIC_CHALLENGE) + assert api.login(actor.user, password).user == actor.user diff --git a/uv.lock b/uv.lock index c35a9703..b9618549 100644 --- a/uv.lock +++ b/uv.lock @@ -56,6 +56,39 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/12/b8/4bd346e22b28902df4d651910f5242c28d84e4a5c2435ca5c3f797ed7e2e/anyio-4.15.1-py3-none-any.whl", hash = "sha256:6152fdbbf9a77fdec97731721bebf7c4c44f7c29b424b0065826173efc7ed101", size = 132079, upload-time = "2026-09-05T10:42:37.923Z" }, ] +[[package]] +name = "argon2-cffi" +version = "25.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "argon2-cffi-bindings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0e/89/ce5af8a7d472a67cc819d5d998aa8c82c5d860608c4db9f46f1162d7dab9/argon2_cffi-25.1.0.tar.gz", hash = "sha256:694ae5cc8a42f4c4e2bf2ca0e64e51e23a040c6a517a85074683d3959e1346c1", size = 45706, upload-time = "2025-06-03T06:55:32.073Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4f/d3/a8b22fa575b297cd6e3e3b0155c7e25db170edf1c74783d6a31a2490b8d9/argon2_cffi-25.1.0-py3-none-any.whl", hash = "sha256:fdc8b074db390fccb6eb4a3604ae7231f219aa669a2652e0f20e16ba513d5741", size = 14657, upload-time = "2025-06-03T06:55:30.804Z" }, +] + +[[package]] +name = "argon2-cffi-bindings" +version = "26.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0b/43/bb8b6e8708d49a5ab36781333af092d9f483b198a2710d01281204640055/argon2_cffi_bindings-26.1.0.tar.gz", hash = "sha256:63505c71542a44b68b1e38060450fb006404170da375feb31af153e7f9c6205d", size = 1790807, upload-time = "2026-08-20T07:44:22.492Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/d2/0ae991f1b2181e5be49007c574710a800ad36c2978683addb3e67c474e55/argon2_cffi_bindings-26.1.0-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:21ca0396fe5ec995dd54431c32698189666f9224810acfa752e50d2bd94d9df2", size = 25521, upload-time = "2026-08-20T07:32:43.019Z" }, + { url = "https://files.pythonhosted.org/packages/7e/e4/ad91d8297638aa2258aad4501c306aca99480dfe76ccd638173fa3702db9/argon2_cffi_bindings-26.1.0-cp310-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:78de2d65e0b9ea7ce9d1b1c3e87297b2d7305a02c266ee2a2d6910daddd7ee69", size = 27177, upload-time = "2026-08-20T07:32:44.158Z" }, + { url = "https://files.pythonhosted.org/packages/6f/86/5363df11b86d02cf3662208e7406496327649cc90eb365bf6f4e8a54a41f/argon2_cffi_bindings-26.1.0-cp310-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:27f1821903e2ceadcb88ec2b45ef190897b7682449c772f4d9b53e42c520cf29", size = 26597, upload-time = "2026-08-20T07:32:45.172Z" }, + { url = "https://files.pythonhosted.org/packages/f4/b5/a14dcc592652347dad23ee93b278a4da5d2a25c9ed3ebd10d68eea823a4f/argon2_cffi_bindings-26.1.0-cp310-abi3-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d88e5f7e60f28ae0b0cc6b2f16c43e87cd642a196a86f85e0d8bb6fe016fc16d", size = 27403, upload-time = "2026-08-20T07:32:46.13Z" }, + { url = "https://files.pythonhosted.org/packages/b3/81/b4a20d4902af7f796390bf9245ff83c5217dfa7367efa1d14986956c482b/argon2_cffi_bindings-26.1.0-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:34b7d9c24a4165a2c61cc8ae11d44d48c9ce2830fb536cb7914e11fdd9962728", size = 27132, upload-time = "2026-08-20T07:32:47.13Z" }, + { url = "https://files.pythonhosted.org/packages/7e/1b/c8de358af07b1c490e0fcb863ef98e46ddb486e45567aca5a60bd68d9daa/argon2_cffi_bindings-26.1.0-cp310-abi3-musllinux_1_2_riscv64.whl", hash = "sha256:224865cbbcb7a2bd1356741dff12b0134df726b6d44bb7b500df8e303cbd9e81", size = 27588, upload-time = "2026-08-20T07:32:48.087Z" }, + { url = "https://files.pythonhosted.org/packages/48/2f/7ee62a6e79f9309f9d9982d301b22a00010adb580c05c8109b94d7b33de0/argon2_cffi_bindings-26.1.0-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:ffff613aaa9ce6236766e2fc6dc560bb5abde7a2e2416e3db1f9ae395a2b4dd4", size = 26785, upload-time = "2026-08-20T07:32:48.977Z" }, + { url = "https://files.pythonhosted.org/packages/e9/10/960d0ee93d4897741bcaf4799c697dae2d81499f66fd1ed042a7dd54c1f4/argon2_cffi_bindings-26.1.0-cp310-abi3-win32.whl", hash = "sha256:a86c069c91a747a2c4e5c51473590aeb48172fff9b2130d23729a42d98665ecb", size = 23898, upload-time = "2026-08-20T07:32:50.114Z" }, + { url = "https://files.pythonhosted.org/packages/6d/3a/0cc14a05810e6add9bce5e87693334baa2222de5f647fa31781885b6573f/argon2_cffi_bindings-26.1.0-cp310-abi3-win_amd64.whl", hash = "sha256:2c36ff87b5dfaa477d0bd51e9d7f6abdae7c8955d2983c97419085d842154b3e", size = 25730, upload-time = "2026-08-20T07:32:51.091Z" }, + { url = "https://files.pythonhosted.org/packages/4e/db/d83cf2af140547f0b9cdaece05b2dc2dcbf991be4667331d073eff771435/argon2_cffi_bindings-26.1.0-cp310-abi3-win_arm64.whl", hash = "sha256:f9c4420a7a864fe1b86ce35befc95b8e39fb852493b81cf798671ddc265de638", size = 24478, upload-time = "2026-08-20T07:32:52.111Z" }, +] + [[package]] name = "asyncpg" version = "0.31.0" @@ -112,6 +145,29 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/0b/a7/71ac2cff56fec219ed242bb11b8efb69fcc4bec75db06fb7bfe35de520e6/certifi-2026.7.22-py3-none-any.whl", hash = "sha256:62f22742b58a1a33014a2b6b706588a8d7e2a88ae7bd1a6ebe8c992928483775", size = 136983, upload-time = "2026-07-22T03:35:11.276Z" }, ] +[[package]] +name = "cffi" +version = "2.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pycparser", marker = "implementation_name != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9e/ef/008a1939e372c06329a3fce4279c02f328488f3526744906eeec3da7ad5f/cffi-2.1.1.tar.gz", hash = "sha256:dd31f52ea1086513bb9df30f8fcee9b8918323ae067a3d5b78bc826a000712be", size = 530807, upload-time = "2026-08-03T21:21:18.939Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/10/69/43965eccfdead3b9220015fd1320e117be8c6ed01a62ffab76eeb752f5d5/cffi-2.1.1-cp312-cp312-macosx_10_15_x86_64.whl", hash = "sha256:c8c69575568085ba0b1b10c0249d779a214aea6f6522e949a0fc9fb0fcb449d0", size = 184821, upload-time = "2026-08-03T21:19:44.887Z" }, + { url = "https://files.pythonhosted.org/packages/54/7d/16e5a096677b5e313ca80cd5e5170efa3ea44624a82bb111925522da64b1/cffi-2.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f81b3b8f3d4e343550fa4baa0e479bba9f2d29ce9c2e9b51d1ce1718d7442fcf", size = 184719, upload-time = "2026-08-03T21:19:46.129Z" }, + { url = "https://files.pythonhosted.org/packages/56/e6/8941622732edec876dd17d0453dce07317ae96db34f2ec1436c9d3785986/cffi-2.1.1-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:811bd1e21d32de12efca32393a0ab3f5133b54fce9bd44b8bd77ab07da14bf6a", size = 214799, upload-time = "2026-08-03T21:19:47.218Z" }, + { url = "https://files.pythonhosted.org/packages/44/de/f98430906df1545ffde0d543dd124a7a439bc2cd32b36b9c53f805df7333/cffi-2.1.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:68e62fe11f30d5ca8289242866f0a5291402d8529ca2178ab8afc5c9694ae890", size = 222389, upload-time = "2026-08-03T21:19:48.331Z" }, + { url = "https://files.pythonhosted.org/packages/6a/5b/717f1526b9957b34456313c31645c5b82b8fb5c3fe9e4752999be7128bfc/cffi-2.1.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:4a7c934f7360e8cd64fe9efadcbd10c7c6364f531e432b9a4bf5ccbc9e0e8b50", size = 210249, upload-time = "2026-08-03T21:19:49.543Z" }, + { url = "https://files.pythonhosted.org/packages/64/b3/f8aa4f3e34986c7e4ec45072d1b1b9dd295b6b18007b45518d79726dd725/cffi-2.1.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:3143d81e29e1e20a9ce10901ec369012947876596f75a222235965f2b7ae832e", size = 208775, upload-time = "2026-08-03T21:19:50.918Z" }, + { url = "https://files.pythonhosted.org/packages/b1/db/dceb9dd5b231e1da801793f8acc9f3c52a7e1afe40bb1aae37e02b0faad5/cffi-2.1.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c1453022f490d2459a11819d83ad1d586e9ff65a12ac3e705ffebd46d3685dcf", size = 221822, upload-time = "2026-08-03T21:19:52.054Z" }, + { url = "https://files.pythonhosted.org/packages/a0/d2/6cd24ae3be000a634109c247d1475d62e5616d0dc78c82770942ec384248/cffi-2.1.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:208f941bb9d18e768138677f0a6d2ce01f590df56043dda1df1535ac57c88517", size = 225232, upload-time = "2026-08-03T21:19:53.109Z" }, + { url = "https://files.pythonhosted.org/packages/cb/52/3fa190537004dd7f0ab860a6dc7c0175b8667f68d1e618a46f5498d30250/cffi-2.1.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:210019b6c7cf07f081b4c54635c8cf744377001350e29cc0f81c4377b4797735", size = 223597, upload-time = "2026-08-03T21:19:54.515Z" }, + { url = "https://files.pythonhosted.org/packages/80/fb/0bb75b7039588c074b37ae99f40d9bfddf990ecb2fbc346ebccd2e56b9be/cffi-2.1.1-cp312-cp312-win32.whl", hash = "sha256:046bfc24911b37851ee1b51aab8bffe713d89c68c6a057b09484ce9fd5f69b4e", size = 175292, upload-time = "2026-08-03T21:19:55.566Z" }, + { url = "https://files.pythonhosted.org/packages/d9/79/615cc094e2fb508cade7de88d3b4f6c4ec2bab695c97bce9153dc65aadf5/cffi-2.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:f53e442b08449d42821fa4a4fba000095af9f62742a500f978a9f557ec44339a", size = 185919, upload-time = "2026-08-03T21:19:56.89Z" }, + { url = "https://files.pythonhosted.org/packages/70/c6/d0ea84713fe46b243a436a18fcd47d639732747e21635c8a27191b06dc30/cffi-2.1.1-cp312-cp312-win_arm64.whl", hash = "sha256:7bde5e4cc5c10140859842b9d383af292b22639a4dffb725314baf45968cef80", size = 180093, upload-time = "2026-08-03T21:19:58.155Z" }, +] + [[package]] name = "cfgv" version = "3.5.0" @@ -556,6 +612,7 @@ version = "0.1.0" source = { editable = "." } dependencies = [ { name = "alembic" }, + { name = "argon2-cffi" }, { name = "asyncpg" }, { name = "fastapi", extra = ["all"] }, { name = "pydantic" }, @@ -583,6 +640,7 @@ dev = [ [package.metadata] requires-dist = [ { name = "alembic", specifier = ">=1.20.0,<2" }, + { name = "argon2-cffi", specifier = ">=25.1.0,<26" }, { name = "asyncpg", specifier = ">=0.31.0,<0.32" }, { name = "fastapi", extras = ["all"], specifier = ">=0.137.2,<1.0.0" }, { name = "pydantic", specifier = ">=2.6.3,<3.0.0" }, @@ -712,6 +770,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/45/e2/bbb7129c9e7999a6b8ee9cca3b66486c25c423ab5a75f34071798b74ce94/pre_commit-4.6.2-py2.py3-none-any.whl", hash = "sha256:e2dde9a75d3bce11bd3831c26d134df00a2803c1d818be6a0383c3dcda25dc4e", size = 226202, upload-time = "2026-08-10T22:07:16.942Z" }, ] +[[package]] +name = "pycparser" +version = "3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", size = 103492, upload-time = "2026-01-21T14:26:51.89Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172, upload-time = "2026-01-21T14:26:50.693Z" }, +] + [[package]] name = "pydantic" version = "2.13.5"