diff --git a/.env.example b/.env.example index 714c8076..c5e5ee74 100644 --- a/.env.example +++ b/.env.example @@ -1,11 +1,6 @@ -# Copy to .env for your LOCAL synthetic test environment; never commit .env. -# These are logical interface suggestions; map actual framework names in REPORT.md. -APP_HOST=0.0.0.0 -APP_PORT=8080 -APP_ENV=lab +# scripts/setup.sh creates .env and local secret files without printing credentials. +HOST_PORT=8082 SESSION_TTL_SECONDS=3600 -# Choose credentials locally. File paths contain no secret values. -DATABASE_URL_FILE=/run/secrets/database_url -# Optional on 3, required use on 4 in lab2; Redis OR Valkey: -SESSION_STORE=postgres -CACHE_URL_FILE=/run/secrets/cache_url +# compose.yaml binds APP_HOST=0.0.0.0 and APP_PORT=8080 inside the API container. +# DATABASE_URL_FILE=/run/secrets/database_url (Compose secret) +# PostgreSQL stores all state including sessions; Redis/Valkey is not used on 3. diff --git a/.github/workflows/contracts.yml b/.github/workflows/contracts.yml index 11cf289f..e0086d27 100644 --- a/.github/workflows/contracts.yml +++ b/.github/workflows/contracts.yml @@ -13,4 +13,15 @@ jobs: - run: python -m pip install -r requirements-dev.txt - run: make check validate PYTHON=python # This job validates the skeleton, not a student solution. -# Add build, readiness and make test in a separate application job. + application: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - run: scripts/setup.sh + - run: docker compose up -d --build --wait + - run: make test BASE_URL=http://localhost:8082 + - run: python3 student-tests/check.py --base-url http://localhost:8082 + - run: docker compose exec -T api python - < student-tests/db_check.py + - run: make test-persistence ACTION_SCRIPT=scripts/restart.sh BASE_URL=http://localhost:8082 + - if: always() + run: docker compose down diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..baa703c1 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,10 @@ +FROM python:3.13.7-slim-bookworm +WORKDIR /app +ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 +COPY requirements.txt . +RUN pip install --no-cache-dir -r requirements.txt +COPY src/ src/ +COPY migrations/ migrations/ +USER 10001:10001 +EXPOSE 8080 +CMD ["python", "src/server.py"] diff --git a/REPORT.md b/REPORT.md index e42f2b05..fe6bff6f 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,125 @@ # Отчёт — лабораторная 2 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор: Владислав Гавриленко, БПИ2303. +- Целевая оценка: **3**, трек 5 не заявлен. +- Ветка: `solution/bpi2303-gavrilenko` в [форке Gitea](https://gitea.privcloud.tech/sxdees/mtusi2026lab2). +- MR: [ЛР 2 — БПИ2303 — Гавриленко — на 3, #174](https://gitea.privcloud.tech/mtusi2026/mtusi2026lab2/pulls/174). +- Основа: [собственная lab1](https://gitflic.ru/project/sxdees/mtusi2026lab1-fork1), commit `714ead4d671b20814c011a3c7e6cbdf15687b0a9`. + Перенесены HTTP Handler, APIError/require, проверка JSON/строк/UUID, формат ошибок, логирование и student-tests/check.py. + Словари, общая блокировка и курсоры в памяти заменены SQL-транзакциями и keyset SQL. +- Источники: контракт текущего skeleton; [Psycopg 3 transactions](https://www.psycopg.org/psycopg3/docs/basic/transactions.html), + [Python hashlib.scrypt](https://docs.python.org/3/library/hashlib.html#hashlib.scrypt), + [PostgreSQL transactions](https://www.postgresql.org/docs/17/tutorial-transactions.html). + Зависимость приложения — `psycopg[binary]==3.2.10`; HTTP, JSON, UUID, secrets и KDF — стандартная библиотека Python. + Реализация, проверки и отчёт подготовлены с помощью Codex; чужие решения не переносились. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Нужны Git, Docker Engine с Compose v2 (поддержка `up --wait`), Python 3.9+ для проверок. +Образы: `python:3.13.7-slim-bookworm`, `postgres:17.6-alpine3.22`. + +```sh +git clone -b solution/bpi2303-gavrilenko https://gitea.privcloud.tech/sxdees/mtusi2026lab2.git +cd mtusi2026lab2 +scripts/setup.sh +docker compose config --quiet +docker compose up -d --build --wait +make check +make test BASE_URL=http://localhost:8082 +python3 student-tests/check.py --base-url http://localhost:8082 +docker compose exec -T api python - < student-tests/db_check.py +make test-persistence ACTION_SCRIPT=scripts/restart.sh BASE_URL=http://localhost:8082 +``` + +`setup.sh` создаёт случайный пароль PostgreSQL, DSN и `.env`; существующие файлы не перезаписывает. +Каталог `secrets/` закрыт правами 0700; файл DSN читается непривилегированным UID 10001 внутри API через read-only mount. +Секреты не включены в образ и Git. PostgreSQL не публикует порт на host, API доступен только на `127.0.0.1`. +`HOST_PORT=8082` выбран, чтобы одновременно сохранить запущенную lab1 на 8080. +При смене HOST_PORT передайте соответствующий BASE_URL проверкам. +`SESSION_TTL_SECONDS` по умолчанию 3600; для smoke/persistence использовать не менее 300. +APP_HOST/APP_PORT и DATABASE_URL_FILE установлены в compose.yaml; APP_ENV, SESSION_STORE, CACHE_URL_FILE не нужны: Redis не используется. + +Миграции выполняются автоматически перед HTTP-сервером. Отдельный повторный запуск: + +```sh +docker compose exec api python src/db.py +``` + +Проверка короткого TTL с восстановлением обычного режима: + +```sh +SESSION_TTL_SECONDS=2 docker compose up -d --wait api +python3 student-tests/expiry.py --base-url http://localhost:8082 +docker compose up -d --wait api +``` + +Безопасная остановка: `docker compose down` — именованный volume сохраняется. +Повторный запуск: `docker compose up -d --wait`. +**Намеренное удаление учебных данных:** `docker compose down -v` — необратимо удаляет БД этого проекта; для обычного рестарта не применять. +Не удалять secrets при сохранённом volume: новый пароль сам не изменит пароль внутри существующей БД. ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +Клиент → один Python ThreadingHTTPServer → PostgreSQL в именованном volume `gavrilenko-lab2_postgres_data`. +БД — источник истины для пользователей, чатов, участников, сообщений, сессий и версий миграций. +Схема и транзакционные границы описаны до запросов в [infra/schema.md](infra/schema.md). +PK/FK и UNIQUE username поддерживаются БД. Составной FK сообщения запрещает отправителя, не состоящего в чате. +Один HTTP-запрос — одно соединение и транзакция; COMMIT завершается до отправки успешного ответа. +Создание чата вместе с участниками атомарно. Миграции под advisory lock применяются один раз, при ошибке старта HTTP не запускается. + +Переход lab1 → lab2: регистрация требует password; Basic только для создания сессии; защищённые endpoint требуют Bearer. +X-User-Id не используется и не переопределяет текущего пользователя. Password KDF: scrypt N=16384, r=8, p=1, 16 случайных байт соли, digest 64 байта; +сравнение constant-time через hmac.compare_digest. Весь диапазон 12–128 Unicode code points поддерживается без усечения. +Токен имеет 256 бит случайности, сервер хранит только SHA-256 токена, user_id и абсолютный expires_at. +SHA-256 применяется к высокоэнтропийному токену, а не к паролю. Logout удаляет сессию; expiry проверяется часами БД при каждом запросе. +Перезапуск не продлевает TTL. User не содержит пароль/хеш/токен; ошибки и логи не содержат SQL и credentials. + +История выбирается `WHERE chat_id = ... AND (created_at,id) > (...) ORDER BY created_at,id LIMIT limit+1`. +Курсор — base64url JSON с областью списка, временем и UUID последней записи; проверяются формат, область и существование записи. +Курсор не является правом доступа: членство проверяется независимо. Индекс `(chat_id,created_at,id)` поддерживает keyset. +Список чатов ограничен текущим участником и также использует keyset. Читаем напрямую из PostgreSQL, кэша нет: +подтверждённая запись видна следующему чтению. Между страницами нет snapshot; при переводе часов назад новая запись может оказаться до курсора. + +`/health/live` проверяет процесс без обращения к БД; `/health/ready` требует PostgreSQL. +Таймаут соединения 3 с, SQL 5 с; недоступность БД возвращает 503 в общем формате. ## Доказательства критериев -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | -| --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +Реальный вывод: [evidence/checks.txt](evidence/checks.txt), [evidence/restart.txt](evidence/restart.txt), +[evidence/expiry.txt](evidence/expiry.txt), [evidence/postman.txt](evidence/postman.txt). -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +| Критерий уровня 3 | Команда/сценарий | Наблюдаемый результат | +| --- | --- | --- | +| Контракт сохранён | `make check` | PASS; contracts/ и публичные tests/ не менялись | +| Минимум lab1 с новым auth | `make test BASE_URL=http://localhost:8082` | PASS: пользователи, чат, сообщения, Unicode, членство, keyset, ошибки | +| Basic/Bearer, logout, X-User-Id | публичный smoke | неверный пароль/Basic вместо Bearer/X-User-Id без токена → 401; после logout → 401 | +| Схема с нуля и единый запуск | `scripts/setup.sh`, `docker compose up -d --build --wait` | API и PostgreSQL healthy на новом именованном volume | +| Уникальность username | smoke и student-tests/check.py | повторная регистрация → 409 | +| FK и атомарная транзакция | `docker compose exec -T api python - < student-tests/db_check.py` | FK отклоняет неизвестного участника; вставка чата откатывается | +| Повторные миграции | тот же db_check.py дважды вызывает migrate | версии и количества записей не меняются | +| KDF и валидация | check.py и db_check.py | пароль 128 code points с emoji и двоеточием работает; 11/129 → 400; БД содержит соль/digest | +| Expiry | TTL=2 + student-tests/expiry.py | сначала 200; спустя 3 с чтение и logout → 401 | +| Сохранность и прежняя сессия | `make test-persistence ACTION_SCRIPT=scripts/restart.sh BASE_URL=http://localhost:8082` | PASS: прежний токен читает прежнее сообщение без повторного входа | +| Полный restart | inspect до/после в restart.txt | StartedAt обоих контейнеров изменился, имя PostgreSQL volume сохранилось | +| Независимая проверка ready | Postman CLI request с тремя assertions | HTTP 200, JSON status=ok, X-Request-Id; 3 passed | -## Эксперименты и отказы +Добавлен отдельный application job в GitHub workflow: Compose, smoke, собственные проверки, persistence. +CI в Gitea ожидает одобрения сопровождающего для первого вклада из форка; удалённое выполнение не подтверждено. Локальные результаты приведены отдельно. -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +## Эксперимент перезапуска и ограничения -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | -| --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +Локальный учебный стенд: macOS arm64, OrbStack Docker 29.8.2; конфигурация VM — 11 CPU, 9 GiB RAM, отдельных cgroup-лимитов нет. +Функциональные проверки используют синтетические данные; нагрузка, RPS/latency и треки 4/5 не заявлены. +Гипотеза: подтверждённые данные и сессии переживают остановку всех используемых процессов при сохранении volume. +Hook останавливает API и БД, затем запускает БД и API с ожиданием healthy; не удаляет volumes, не делает seed. +Эксперимент прошёл, точные отметки времени приведены в restart.txt. Потери подтверждённого сообщения не обнаружено. -## Ограничения и следующие шаги +Проверена штатная остановка/перезапуск, а не аварийное отключение питания, повреждение диска или потеря host. +Используются штатные fsync/synchronous_commit PostgreSQL; гарантия durability зависит также от диска и файловой системы. +При первом запуске Docker сообщил о заполненном внутреннем диске; после освобождения части кэша сборки стенд поднят. +Другие лабораторные и их volumes не удалялись. -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +Один API и одна БД, без HA, backup/restore, Redis, connection pool, защиты от перебора и нагрузочного исследования. +Сессии после expiry недействительны, но просроченные строки не очищаются автоматически; для длительной эксплуатации нужен регламент очистки. +HTTP без TLS допустим здесь только на loopback с синтетическими данными. `http.server` и соединение на каждый запрос — учебные упрощения. +Получение оценки требует защиты и объяснения реализации; smoke сам оценку не выставляет. diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..2506cded --- /dev/null +++ b/compose.yaml @@ -0,0 +1,45 @@ +name: gavrilenko-lab2 +services: + db: + image: postgres:17.6-alpine3.22 + environment: + POSTGRES_USER: messenger + POSTGRES_DB: messenger + POSTGRES_PASSWORD_FILE: /run/secrets/db_password + secrets: + - db_password + volumes: + - postgres_data:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"] + interval: 2s + timeout: 3s + retries: 30 + restart: unless-stopped + api: + build: . + environment: + APP_HOST: 0.0.0.0 + APP_PORT: 8080 + DATABASE_URL_FILE: /run/secrets/database_url + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + secrets: + - database_url + ports: + - "127.0.0.1:${HOST_PORT:-8082}:8080" + depends_on: + db: + condition: service_healthy + healthcheck: + test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8080/health/ready', timeout=3)"] + interval: 2s + timeout: 4s + retries: 30 + restart: unless-stopped +secrets: + db_password: + file: ./secrets/db_password + database_url: + file: ./secrets/database_url +volumes: + postgres_data: diff --git a/evidence/checks.txt b/evidence/checks.txt new file mode 100644 index 00000000..a3d8cb58 --- /dev/null +++ b/evidence/checks.txt @@ -0,0 +1,8 @@ +python3 scripts/check_contract.py +PASS: offline skeleton structure, local refs and Python syntax; application NOT tested. +python3 tests/smoke.py --base-url "http://localhost:8082" +PASS: lab2 public API scenario; infrastructure and grading evidence remain separate. +PASS: validation, access, Unicode, pagination and cursor scope +PASS: malformed JSON and duplicate username +PASS: Unicode/colon passwords, length boundaries, invalid chat creation +PASS: repeated migrations preserve row counts; scrypt/token digests; FK and transaction rollback diff --git a/evidence/expiry.txt b/evidence/expiry.txt new file mode 100644 index 00000000..86703fb1 --- /dev/null +++ b/evidence/expiry.txt @@ -0,0 +1,23 @@ + Container gavrilenko-lab2-db-1 Running + Container gavrilenko-lab2-api-1 Recreate + Container gavrilenko-lab2-api-1 Recreated + Container gavrilenko-lab2-db-1 Waiting + Container gavrilenko-lab2-db-1 Healthy + Container gavrilenko-lab2-api-1 Starting + Container gavrilenko-lab2-api-1 Started + Container gavrilenko-lab2-db-1 Waiting + Container gavrilenko-lab2-api-1 Waiting + Container gavrilenko-lab2-db-1 Healthy + Container gavrilenko-lab2-api-1 Healthy +PASS: session expires with TTL=2; expired token cannot read or logout + Container gavrilenko-lab2-db-1 Running + Container gavrilenko-lab2-api-1 Recreate + Container gavrilenko-lab2-api-1 Recreated + Container gavrilenko-lab2-db-1 Waiting + Container gavrilenko-lab2-db-1 Healthy + Container gavrilenko-lab2-api-1 Starting + Container gavrilenko-lab2-api-1 Started + Container gavrilenko-lab2-db-1 Waiting + Container gavrilenko-lab2-api-1 Waiting + Container gavrilenko-lab2-db-1 Healthy + Container gavrilenko-lab2-api-1 Healthy diff --git a/evidence/postman.txt b/evidence/postman.txt new file mode 100644 index 00000000..1fbed4b3 --- /dev/null +++ b/evidence/postman.txt @@ -0,0 +1,18 @@ + +→ GET http://localhost:8082/health/ready + 200 OK ★ 25ms time ★ 0B↑ 16B↓ size ★ 7↑ 5↓ headers ★ 0 cookies + ┌ ↓ application/json; charset=utf-8 ★ json ★ json ★ utf-8 ★ 16B + │ {"status": "ok"} + └ + + ┌ ✓ tests ★ 3 passed + │ ✓ ready status + │ ✓ body + │ ✓ request ID + └ + +A new version of Postman CLI is available (v1.88.0). Refer https://go.pstmn.io/cli-release-notes for changelogs. +To update your Postman CLI, run: + +postman update + diff --git a/evidence/restart.txt b/evidence/restart.txt new file mode 100644 index 00000000..8f7f3b4e --- /dev/null +++ b/evidence/restart.txt @@ -0,0 +1,7 @@ +/gavrilenko-lab2-api-1 started=2026-11-12T22:25:25.398171052Z volumes= +/gavrilenko-lab2-db-1 started=2026-11-12T22:25:22.742407962Z volumes=gavrilenko-lab2_postgres_data +python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://localhost:8082" +Executing explicit persistence hook; hook output suppressed to avoid leaking secrets. +PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence. +/gavrilenko-lab2-api-1 started=2026-11-12T22:26:00.761156584Z volumes= +/gavrilenko-lab2-db-1 started=2026-11-12T22:25:58.053128425Z volumes=gavrilenko-lab2_postgres_data diff --git a/infra/schema.md b/infra/schema.md new file mode 100644 index 00000000..709200df --- /dev/null +++ b/infra/schema.md @@ -0,0 +1,19 @@ +# Схема до реализации запросов + +PostgreSQL — единственный источник истины. UUID назначает API, время — БД (timestamptz). + +- users: PK id, UNIQUE username, display_name, created_at, соль и scrypt digest пароля. +- chats: PK id, title, created_at. +- chat_members: составной PK (chat_id, user_id), FK на chats/users; индекс (user_id, chat_id) для списка чатов. +- messages: PK id, FK chat_id, составной FK (chat_id, sender_id) на членство, + text, created_at; индекс (chat_id, created_at, id) для keyset истории. +- sessions: PK SHA-256 случайного 256-битного токена, FK user_id, expires_at. + Сам токен хранится только у клиента. Пароль хешируется scrypt, не SHA-256. +- schema_migrations: PK имени применённого SQL-файла. + +Каждый запрос использует отдельную транзакцию. Успешный ответ отправляется после +COMMIT. Создание чата и всех участников — одна транзакция; ошибка откатывает всё. +Регистрация опирается на UNIQUE БД, отзыв сессии — DELETE. Expiry проверяется +по часам БД при каждом защищённом запросе, рестарт не меняет expires_at. +Миграции выполняются при старте под транзакционной advisory lock, повторный +запуск пропускает записанные версии. Ошибка миграции останавливает API. diff --git a/migrations/001_initial.sql b/migrations/001_initial.sql new file mode 100644 index 00000000..2cd7a084 --- /dev/null +++ b/migrations/001_initial.sql @@ -0,0 +1,33 @@ +CREATE TABLE users ( + id uuid PRIMARY KEY, + username varchar(32) NOT NULL UNIQUE CHECK (username ~ '^[a-z0-9_]{3,32}$'), + display_name varchar(100) NOT NULL CHECK (length(btrim(display_name)) > 0), + password_salt bytea NOT NULL, + password_hash bytea NOT NULL, + created_at timestamptz NOT NULL DEFAULT clock_timestamp() +); +CREATE TABLE chats ( + id uuid PRIMARY KEY, + title varchar(100) NOT NULL CHECK (length(btrim(title)) > 0), + created_at timestamptz NOT NULL DEFAULT clock_timestamp() +); +CREATE TABLE chat_members ( + chat_id uuid NOT NULL REFERENCES chats(id), + user_id uuid NOT NULL REFERENCES users(id), + PRIMARY KEY (chat_id, user_id) +); +CREATE INDEX chat_members_user ON chat_members(user_id, chat_id); +CREATE TABLE messages ( + id uuid PRIMARY KEY, + chat_id uuid NOT NULL REFERENCES chats(id), + sender_id uuid NOT NULL, + text varchar(4000) NOT NULL CHECK (length(btrim(text)) > 0), + created_at timestamptz NOT NULL DEFAULT clock_timestamp(), + FOREIGN KEY (chat_id, sender_id) REFERENCES chat_members(chat_id, user_id) +); +CREATE INDEX messages_history ON messages(chat_id, created_at, id); +CREATE TABLE sessions ( + token_hash bytea PRIMARY KEY, + user_id uuid NOT NULL REFERENCES users(id), + expires_at timestamptz NOT NULL +); diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..c4d28e07 --- /dev/null +++ b/requirements.txt @@ -0,0 +1 @@ +psycopg[binary]==3.2.10 diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..8911db43 --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,6 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +# Stop the API first; bring back PostgreSQL with its existing named volume. +docker compose stop api db +docker compose up -d --wait db api diff --git a/scripts/setup.sh b/scripts/setup.sh new file mode 100755 index 00000000..33fddf73 --- /dev/null +++ b/scripts/setup.sh @@ -0,0 +1,25 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +python3 - <<'PY' +import os +import secrets +from pathlib import Path + +os.umask(0o077) +root = Path('secrets') +root.mkdir(exist_ok=True) +password_file = root / 'db_password' +if not password_file.exists(): + password_file.write_text(secrets.token_hex(32)) +password = password_file.read_text().strip() +url = root / 'database_url' +if not url.exists(): + from urllib.parse import quote + url.write_text('postgresql://messenger:' + quote(password, safe='') + '@db:5432/messenger') +# Private parent directory protects files on the host; API UID must read its mount. +url.chmod(0o644) +if not Path('.env').exists(): + Path('.env').write_text('HOST_PORT=8082\nSESSION_TTL_SECONDS=3600\n') +print('Local secrets and .env ready (existing files preserved)') +PY diff --git a/src/db.py b/src/db.py new file mode 100644 index 00000000..18b50ad5 --- /dev/null +++ b/src/db.py @@ -0,0 +1,28 @@ +"""One transaction per connection; versioned migrations run before serving HTTP.""" +import os +from pathlib import Path + +import psycopg +from psycopg.rows import dict_row + + +def connect(): + # shortcut: one connection per request; add a bounded pool before load testing. + dsn = Path(os.environ['DATABASE_URL_FILE']).read_text().strip() + return psycopg.connect(dsn, connect_timeout=3, row_factory=dict_row, + options='-c statement_timeout=5000 -c timezone=UTC') + + +def migrate(): + with connect() as db: + db.execute('SELECT pg_advisory_xact_lock(2303002)') + db.execute('CREATE TABLE IF NOT EXISTS schema_migrations (version text PRIMARY KEY)') + for path in sorted((Path(__file__).resolve().parents[1] / 'migrations').glob('*.sql')): + if not db.execute('SELECT 1 FROM schema_migrations WHERE version=%s', (path.name,)).fetchone(): + db.execute(path.read_text()) + db.execute('INSERT INTO schema_migrations VALUES (%s)', (path.name,)) + + +if __name__ == '__main__': + migrate() + print('Migrations applied') diff --git a/src/server.py b/src/server.py new file mode 100644 index 00000000..0639ff87 --- /dev/null +++ b/src/server.py @@ -0,0 +1,236 @@ +"""Lab 1 HTTP API with PostgreSQL persistence and expiring Bearer sessions.""" +import base64 +import binascii +import hashlib +import hmac +import json +import os +import re +import secrets +import uuid +from datetime import datetime, timezone +from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer +from urllib.parse import parse_qs, urlsplit + +import psycopg +from db import connect, migrate + +USER_FIELDS = 'id, username, display_name, created_at' +SESSION_TTL = int(os.getenv('SESSION_TTL_SECONDS', '3600')) +if SESSION_TTL <= 0: + raise ValueError('SESSION_TTL_SECONDS must be positive') + + +class APIError(Exception): + def __init__(self, status, code): + self.status, self.code = status, code + + +def require(condition, status=400, code='invalid_request'): + if not condition: + raise APIError(status, code) + + +def identifier(value): + try: + return str(uuid.UUID(value)) + except (ValueError, TypeError, AttributeError): + raise APIError(400, 'invalid_request') + + +def text(value, maximum): + require(isinstance(value, str) and 0 < len(value) <= maximum and bool(value.strip())) + try: + value.encode('utf-8') + except UnicodeEncodeError: + raise APIError(400, 'invalid_request') + require('\x00' not in value) + + +def password_hash(password, salt): + return hashlib.scrypt(password.encode('utf-8'), salt=salt, n=16384, r=8, p=1, dklen=64) + + +def serial(value): + if isinstance(value, datetime): + return value.astimezone(timezone.utc).isoformat(timespec='microseconds').replace('+00:00', 'Z') + if isinstance(value, uuid.UUID): + return str(value) + raise TypeError('Unsupported JSON value') + + +class Handler(BaseHTTPRequestHandler): + def setup(self): + super().setup() + self.connection.settimeout(5) + + def body(self, fields): + require(self.headers.get_content_type() == 'application/json', 415, 'unsupported_media_type') + require('Transfer-Encoding' not in self.headers) + try: + length = int(self.headers.get('Content-Length', '0')) + require(0 < length <= 65536) + value = json.loads(self.rfile.read(length).decode('utf-8')) + except (ValueError, UnicodeDecodeError): + raise APIError(400, 'invalid_request') + require(type(value) is dict and set(value) == set(fields)) + return value + + def credentials(self, scheme): + parts = self.headers.get('Authorization', '').split() + require(len(parts) == 2 and parts[0].lower() == scheme.lower(), 401, 'unauthorized') + return parts[1] + + def chat(self, db, chat_id): + row = db.execute('SELECT * FROM chats WHERE id=%s', (chat_id,)).fetchone() + members = db.execute('SELECT user_id FROM chat_members WHERE chat_id=%s ORDER BY user_id', (chat_id,)).fetchall() + row['member_ids'] = [x['user_id'] for x in members] + return row + + def page(self, db, table, scope, query, where, params): + require(set(query) <= {'limit', 'cursor'} and all(len(v) == 1 for v in query.values())) + raw = query.get('limit', ['50'])[0] + require(re.fullmatch(r'[0-9]{1,3}', raw) is not None) + limit = int(raw) + require(1 <= limit <= 100) + if 'cursor' in query: + try: + cursor = json.loads(base64.b64decode(query['cursor'][0], altchars=b'-_', validate=True)) + require(type(cursor) is list and len(cursor) == 3 and cursor[0] == scope) + stamp = datetime.fromisoformat(cursor[1].replace('Z', '+00:00')) + require(stamp.tzinfo is not None) + last_id = identifier(cursor[2]) + except (ValueError, TypeError, AttributeError, UnicodeError, binascii.Error): + raise APIError(400, 'invalid_request') + require(db.execute(f'SELECT 1 FROM {table} WHERE {where} AND created_at=%s AND id=%s', + (*params, stamp, last_id)).fetchone() is not None) + where += ' AND (created_at, id) > (%s, %s)' + params = (*params, stamp, last_id) + # table and where are internal constants; every client value is a parameter. + rows = db.execute(f'SELECT * FROM {table} WHERE {where} ORDER BY created_at, id LIMIT %s', + (*params, limit + 1)).fetchall() + selected = rows[:limit] + cursor = None + if len(rows) > limit: + last = selected[-1] + cursor = base64.urlsafe_b64encode(json.dumps([scope, last['created_at'], last['id']], default=serial).encode()).decode() + if table == 'chats': + selected = [self.chat(db, row['id']) for row in selected] + return {'items': selected, 'next_cursor': cursor} + + def dispatch(self, db, path, query): + if self.command == 'GET' and path == '/health/ready': + db.execute('SELECT 1') + return 200, {'status': 'ok'} + if self.command == 'POST' and path == '/api/v1/users': + body = self.body(('username', 'display_name', 'password')) + require(isinstance(body['username'], str) and re.fullmatch(r'[a-z0-9_]{3,32}', body['username']) is not None) + text(body['display_name'], 100) + text(body['password'], 128) + require(len(body['password']) >= 12) + salt = secrets.token_bytes(16) + user = db.execute(f'INSERT INTO users (id, username, display_name, password_salt, password_hash) VALUES (%s,%s,%s,%s,%s) RETURNING {USER_FIELDS}', + (uuid.uuid4(), body['username'], body['display_name'], salt, password_hash(body['password'], salt))).fetchone() + return 201, user + if self.command == 'POST' and path == '/api/v1/auth/sessions': + credential = self.credentials('Basic') + try: + username, password = base64.b64decode(credential, validate=True).decode('utf-8').split(':', 1) + require(re.fullmatch(r'[a-z0-9_]{3,32}', username) is not None and 12 <= len(password) <= 128, 401, 'unauthorized') + except (ValueError, UnicodeError, binascii.Error): + raise APIError(401, 'unauthorized') + require(self.headers.get('Content-Length', '0') == '0' and 'Transfer-Encoding' not in self.headers) + user = db.execute('SELECT * FROM users WHERE username=%s', (username,)).fetchone() + # Run the same KDF for unknown users to avoid the cheap username timing oracle. + digest = password_hash(password, user['password_salt'] if user else bytes(16)) + require(user is not None and hmac.compare_digest(digest, user['password_hash']), 401, 'unauthorized') + token = secrets.token_urlsafe(32) + session = db.execute("INSERT INTO sessions VALUES (%s,%s,clock_timestamp() + %s * interval '1 second') RETURNING expires_at", + (hashlib.sha256(token.encode()).digest(), user['id'], SESSION_TTL)).fetchone() + return 201, dict(session, token=token, token_type='Bearer', user={k: user[k] for k in ('id', 'username', 'display_name', 'created_at')}) + token = self.credentials('Bearer') + token_digest = hashlib.sha256(token.encode()).digest() + # shortcut: expired rows remain; add scheduled cleanup for a long-lived deployment. + actor = db.execute('SELECT user_id FROM sessions WHERE token_hash=%s AND expires_at > clock_timestamp()', (token_digest,)).fetchone() + require(actor is not None, 401, 'unauthorized') + actor = actor['user_id'] + if self.command == 'DELETE' and path == '/api/v1/auth/sessions/current': + db.execute('DELETE FROM sessions WHERE token_hash=%s', (token_digest,)) + return 204, None + if self.command == 'GET' and path == '/api/v1/users/me': + return 200, db.execute(f'SELECT {USER_FIELDS} FROM users WHERE id=%s', (actor,)).fetchone() + if path == '/api/v1/chats': + if self.command == 'POST': + body = self.body(('title', 'member_ids')) + text(body['title'], 100) + members = body['member_ids'] + require(type(members) is list and 1 <= len(members) <= 100) + members = [identifier(x) for x in members] + require(len(set(members)) == len(members) and str(actor) in members) + existing = db.execute('SELECT id FROM users WHERE id = ANY(%s::uuid[])', (members,)).fetchall() + require(len(existing) == len(members)) + chat_id = uuid.uuid4() + db.execute('INSERT INTO chats (id, title) VALUES (%s,%s)', (chat_id, body['title'])) + with db.cursor() as cur: + cur.executemany('INSERT INTO chat_members VALUES (%s,%s)', [(chat_id, member) for member in members]) + return 201, self.chat(db, chat_id) + if self.command == 'GET': + return 200, self.page(db, 'chats', 'chats:' + str(actor), query, + 'id IN (SELECT chat_id FROM chat_members WHERE user_id=%s)', (actor,)) + match = re.fullmatch(r'/api/v1/chats/([^/]+)(/messages)?', path) + if match: + chat_id = identifier(match[1]) + require(db.execute('SELECT 1 FROM chat_members WHERE chat_id=%s AND user_id=%s', (chat_id, actor)).fetchone() is not None, 404, 'not_found') + if not match[2] and self.command == 'GET': + return 200, self.chat(db, chat_id) + if match[2]: + if self.command == 'GET': + return 200, self.page(db, 'messages', 'messages:' + chat_id, query, 'chat_id=%s', (chat_id,)) + if self.command == 'POST': + body = self.body(('text',)) + text(body['text'], 4000) + return 201, db.execute('INSERT INTO messages (id,chat_id,sender_id,text) VALUES (%s,%s,%s,%s) RETURNING *', + (uuid.uuid4(), chat_id, actor, body['text'])).fetchone() + raise APIError(404, 'not_found') + + def handle_request(self): + request_id = uuid.uuid4().hex + path = urlsplit(self.path) + try: + if self.command == 'GET' and path.path == '/health/live': + status, body = 200, {'status': 'ok'} + else: + with connect() as db: + status, body = self.dispatch(db, path.path, parse_qs(path.query, keep_blank_values=True)) + except psycopg.errors.UniqueViolation: + status, body = 409, 'conflict' + except (psycopg.OperationalError, psycopg.errors.QueryCanceled): + status, body = 503, 'unavailable' + except APIError as exc: + status, body = exc.status, exc.code + except Exception: + status, body = 500, 'internal_error' + if status >= 400: + body = {'error': {'code': body, 'message': body, 'request_id': request_id}} + payload = b'' if status == 204 else json.dumps(body, ensure_ascii=False, default=serial).encode('utf-8') + self.send_response(status) + if status != 204: + self.send_header('Content-Type', 'application/json; charset=utf-8') + if status == 401: + challenge = 'Basic realm="messenger", charset="UTF-8"' if path.path == '/api/v1/auth/sessions' else 'Bearer realm="messenger"' + self.send_header('WWW-Authenticate', challenge) + self.send_header('Content-Length', str(len(payload))) + self.send_header('X-Request-Id', request_id) + self.end_headers() + self.wfile.write(payload) + + do_GET = do_POST = do_DELETE = do_PUT = do_PATCH = handle_request + + def log_message(self, format, *args): + # Paths may contain cursors; log only method and response status. + print(self.command, args[1] if len(args) > 1 else '', flush=True) + + +if __name__ == '__main__': + migrate() + ThreadingHTTPServer((os.getenv('APP_HOST', '0.0.0.0'), int(os.getenv('APP_PORT', '8080'))), Handler).serve_forever() diff --git a/student-tests/check.py b/student-tests/check.py new file mode 100644 index 00000000..7659f696 --- /dev/null +++ b/student-tests/check.py @@ -0,0 +1,49 @@ +"""Additional checks against a running lab2 server.""" +import sys +import uuid +from pathlib import Path +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'tests')) +from client import Client, arguments + +args = arguments('Additional validation checks') +c = Client(args.base_url, args.ca_file) +a, b, eve, chat = c.bootstrap() +path = '/api/v1/chats/' + chat['id'] + '/messages' +c.call('POST', '/api/v1/users', 400, body={'username': 'BAD', 'display_name': 'X'}) +c.call('POST', '/api/v1/users', 400, body={'username': 'valid_name', 'display_name': ' '}) +c.call('POST', '/api/v1/users', 400, body=dict(a['registration'], extra=True)) +c.call('POST', path, 400, actor=a, body={'text': ' '}) +c.call('POST', path, 400, actor=a, body={'text': 'ok', 'sender_id': b['id']}) +c.call('GET', path, 404, actor=eve) +c.call('GET', path + '?cursor=bad', 400, actor=a) +c.call('GET', path + '?limit=1.5', 400, actor=a) +c.call('GET', '/api/v1/users/me', 401, headers={'X-User-Id': str(uuid.uuid4())}) +for i in range(5): + c.message(a, chat, 'Юникод 👋 ' + str(i)) +p = c.call('GET', path + '?limit=2', actor=b, schema='MessagePage')['json'] +other = c.call('POST', '/api/v1/chats', 201, actor=a, body={'title': 'other', 'member_ids': [a['id']]}, schema='Chat')['json'] +c.call('GET', '/api/v1/chats/' + other['id'] + '/messages?cursor=' + p['next_cursor'], 400, actor=a) +items = p['items'] +while p['next_cursor']: + p = c.call('GET', path + '?limit=2&cursor=' + p['next_cursor'], actor=b, schema='MessagePage')['json'] + items += p['items'] +assert len(items) == len({x['id'] for x in items}) == 5 +print('PASS: validation, access, Unicode, pagination and cursor scope') +c.call('POST', '/api/v1/users', 400, raw=b'{', headers={'Content-Type': 'application/json'}) +c.call('POST', '/api/v1/users', 409, body=a['registration']) +print('PASS: malformed JSON and duplicate username') +import base64 +# All 128 Unicode code points, including colon, must survive KDF without truncation. +registration = {'username': 'unicode_' + uuid.uuid4().hex[:12], 'display_name': 'Unicode', 'password': ':' + '🔐' * 127} +u = c.call('POST', '/api/v1/users', 201, body=registration, schema='User')['json'] +credential = base64.b64encode((u['username'] + ':' + registration['password']).encode()).decode() +session = c.call('POST', '/api/v1/auth/sessions', 201, headers={'Authorization': 'Basic ' + credential}, schema='Session')['json'] +assert session['user'] == u +c.call('POST', '/api/v1/users', 400, body=dict(registration, password='a' * 11)) +c.call('POST', '/api/v1/users', 400, body=dict(registration, password='a' * 129)) +# Creating a chat with a missing participant must leave no visible chat behind. +before = c.call('GET', '/api/v1/chats?limit=100', actor=a, schema='ChatPage')['json'] +for members in ([a['id'], str(uuid.uuid4())], [a['id'], a['id']], [b['id']]): + c.call('POST', '/api/v1/chats', 400, actor=a, body={'title': 'invalid', 'member_ids': members}) +assert c.call('GET', '/api/v1/chats?limit=100', actor=a, schema='ChatPage')['json'] == before +print('PASS: Unicode/colon passwords, length boundaries, invalid chat creation') diff --git a/student-tests/db_check.py b/student-tests/db_check.py new file mode 100644 index 00000000..53e1be32 --- /dev/null +++ b/student-tests/db_check.py @@ -0,0 +1,35 @@ +"""Run inside API container: migrations, constraints, rollback and password storage.""" +import sys +import uuid +sys.path.insert(0, '/app/src') +import psycopg +from db import connect, migrate + + +def counts(): + with connect() as db: + return {name: db.execute('SELECT count(*) AS n FROM ' + name).fetchone()['n'] + for name in ('users', 'chats', 'chat_members', 'messages', 'sessions', 'schema_migrations')} + + +before = counts() +migrate() +migrate() +assert counts() == before +with connect() as db: + assert db.execute('SELECT count(*) AS n FROM users').fetchone()['n'] > 0 + assert db.execute('SELECT 1 FROM users WHERE octet_length(password_salt) != 16 OR octet_length(password_hash) != 64').fetchone() is None + assert db.execute('SELECT 1 FROM sessions WHERE octet_length(token_hash) != 32').fetchone() is None +chat_id = uuid.uuid4() +try: + with connect() as db: + db.execute('INSERT INTO chats (id,title) VALUES (%s,%s)', (chat_id, 'rollback check')) + db.execute('INSERT INTO chat_members VALUES (%s,%s)', (chat_id, uuid.uuid4())) +except psycopg.errors.ForeignKeyViolation: + pass +else: + raise AssertionError('Foreign key did not reject missing member') +with connect() as db: + assert db.execute('SELECT 1 FROM chats WHERE id=%s', (chat_id,)).fetchone() is None +assert counts() == before +print('PASS: repeated migrations preserve row counts; scrypt/token digests; FK and transaction rollback') diff --git a/student-tests/expiry.py b/student-tests/expiry.py new file mode 100644 index 00000000..7807137c --- /dev/null +++ b/student-tests/expiry.py @@ -0,0 +1,15 @@ +"""Run against an API started with SESSION_TTL_SECONDS=2; tokens never printed.""" +import sys +import time +from pathlib import Path +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'tests')) +from client import Client, arguments + +args = arguments('Short-TTL session expiry') +c = Client(args.base_url, args.ca_file) +a = c.user('expiry') +c.call('GET', '/api/v1/users/me', actor=a, schema='User') +time.sleep(3) +c.call('GET', '/api/v1/users/me', 401, actor=a) +c.call('DELETE', '/api/v1/auth/sessions/current', 401, actor=a) +print('PASS: session expires with TTL=2; expired token cannot read or logout')