lab7 completed

This commit is contained in:
2026-11-20 20:37:41 +03:00
parent 20afc2c790
commit 4b21efc2cc
43 changed files with 2277 additions and 144 deletions
+5 -20
View File
@@ -1,20 +1,5 @@
.git
.github
.env
.env.*
!.env.example
secrets
certs
volumes
data
backups
*.key
*.pem
*.p12
*.pfx
*.jks
.venv
__pycache__
node_modules
evidence
.DS_Store
**
!app/
!app/*.py
!requirements.txt
!Dockerfile
+1 -40
View File
@@ -1,41 +1,2 @@
# 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
# Optional. Use at least 300 for smoke and persistence.
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
API_REPLICAS=2
IDEMPOTENCY_TTL_SECONDS=86400
S3_ENDPOINT=https://s3:9000
S3_REGION=us-east-1
S3_BUCKET=messenger-attachments
S3_ACCESS_KEY_ID_FILE=/run/secrets/s3_access_key_id
S3_SECRET_ACCESS_KEY_FILE=/run/secrets/s3_secret_access_key
MAX_UPLOAD_BYTES=10485760
MAX_IMAGE_PIXELS=40000000
BROKER_URL_FILE=/run/secrets/broker_url
WORKER_CONCURRENCY=2
JOB_MAX_ATTEMPTS=5
JOB_TIMEOUT_SECONDS=60
STAGING_RETENTION_SECONDS=86400
OTEL_SERVICE_NAME=messenger-api
# Worker must set a distinct service.name.
OTEL_EXPORTER_OTLP_ENDPOINT=https://otel-collector:4318
OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf
OTEL_RESOURCE_ATTRIBUTES=deployment.environment.name=lab
# TLS and OpenBao: actual paths/ports depend on your implemented trust matrix.
PUBLIC_BASE_URL=https://localhost:8443
TLS_CA_FILE=/run/secrets/ca.crt
TLS_CERT_FILE=/run/secrets/service.crt
TLS_KEY_FILE=/run/secrets/service.key
BAO_ADDR=https://openbao:8200
BAO_CACERT=/run/secrets/bao-ca.crt
# No root token here. Bootstrap operator -> short-lived service auth -> scoped token.
ARGON2_MEMORY_KIB=19456
ARGON2_ITERATIONS=2
ARGON2_PARALLELISM=1
+9 -14
View File
@@ -1,18 +1,13 @@
## Лабораторная 7
Автор / группа: TODO
Целевая оценка (3/4/5): TODO
Трек 5, если заявлен: TODO
Целевая оценка — 3.
Что реализовано и что перенесено: TODO
Команды запуска из чистого clone: TODO
Результаты проверок и ссылка на REPORT.md: TODO
Ограничения / известные ошибки: TODO
Источники и использование ИИ: TODO
Перенесён REST API мессенджера и pipeline вложений из lab6. Добавлены TLS/mTLS, Argon2id, ограничения входа, роли зависимостей и persistent OpenBao. Запуск, схема доверия и команды проверки задокументированы в [REPORT.md](../REPORT.md).
- [ ] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами.
- [ ] Контракт и публичные тесты не ослаблены.
- [ ] make check и make test выполнены; приложен реальный вывод.
- [ ] Сценарии отказов/безопасности своего уровня воспроизведены.
- [ ] Все секреты и приватные ключи находятся вне Git; отчёт не содержит tokens.
- [ ] README задания сохранён, REPORT.md содержит инструкцию именно моего решения.
- [x] Публичный контракт и тесты сохранены.
- [x] make check, make validate и Compose config выполнены.
- [x] Подготовлены сценарии ACL, mTLS, OpenBao, перезапуска и последовательного отказа реплик.
- [ ] Проверки полного стенда выполнены. В сессии Docker socket возвращал permission denied.
- [x] Закрытые ключи и значения секретов исключены из Git и контекста сборки.
Источники и помощь при реализации перечислены в отчёте.
+2
View File
@@ -30,3 +30,5 @@ coverage/
.vscode/
# Keep small, sanitized evidence summaries in evidence/ under version control.
# Inspect git diff --cached: ignore rules are not a secret scanner.
/lab7-secrets-*/
+9
View File
@@ -0,0 +1,9 @@
FROM python:3.12.10-slim
ENV PYTHONUNBUFFERED=1 PYTHONDONTWRITEBYTECODE=1
WORKDIR /srv
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt && useradd --uid 10001 --create-home messenger
COPY app app
USER messenger
ENTRYPOINT ["python", "-m", "app.credentials"]
CMD ["uvicorn", "app.api:app", "--host", "127.0.0.1", "--port", "8080", "--no-access-log", "--no-proxy-headers", "--limit-concurrency", "48"]
+69 -23
View File
@@ -1,37 +1,83 @@
# Отчёт — лабораторная 7
# Лабораторная 7. Безопасность, mTLS и OpenBao
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
Автор, группа: Дыханова Алина БВТ2301
Целевая оценка: 3
Использованные источники, библиотеки и помощь ИИ: Использована собственная реализация мессенджера из lab6.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Нужны Docker Compose v2, OpenSSL, Python 3.9+ на хосте, curl и Make. Образы закреплены тегами в `compose.yaml`. Основные версии — Python 3.12.10, PostgreSQL 17.5, SeaweedFS 3.85, RabbitMQ 4.1.0, HAProxy 3.0.11, OpenBao 2.3.1, Collector 0.128.0, Prometheus 3.4.0, Loki 3.5.0, Tempo 2.7.2 и Grafana 12.0.1.
## Архитектура и решения
Первое развёртывание:
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab6, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
```sh
python3 scripts/bootstrap.py
docker compose config --quiet
docker compose up -d openbao
docker compose exec openbao bao operator init -key-shares=3 -key-threshold=2
python3 scripts/bao-operator.py unseal
python3 scripts/bao-operator.py configure
scripts/start.sh
curl --fail --retry 10 --retry-delay 2 --retry-connrefused \
--cacert secrets/ca/ca.crt https://localhost:8443/health/ready
```
## Доказательства критериев
`bao operator init` выводит закрытые данные непосредственно оператору. Выполняйте эту команду в приватном терминале. Сохраните доли unseal отдельно в защищённых операторских хранилищах, а начальный root token — в хранилище оператора. `unseal` принимает доли без эха, `configure` так же принимает операторский токен. Не добавляйте к командам `set -x`, логирование или перенаправление вывода в отчёт. В приложении нет root token и unseal keys.
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
Bootstrap создаёт локальный каталог `secrets/` с режимом 0700. Отдельно монтируются только файлы, необходимые каждому процессу. CA private key и JSON для наполнения OpenBao остаются на хосте. `scripts/bootstrap.py` повторно использует существующий набор файлов, если есть маркер выпуска. `.env.example` задаёт единственную необязательную настройку `SESSION_TTL_SECONDS`. Для публичных persistence-тестов оставьте 3600 секунд.
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
PostgreSQL создаёт схему и роли при первом создании volume. `s3-init` создаёт приватный бакет, RabbitMQ импортирует definitions с durable queue. API и worker получают настройки в OpenBao через cert auth перед запуском. Приложение проверяет серверные имена зависимостей по CA. Grafana доступна через проверенный HTTPS по `https://localhost:3443`. Имя пользователя `admin`, начальный пароль хранится в защищённом локальном файле `secrets/values/grafana`.
## Эксперименты и отказы
Команда `docker compose stop` оставляет данные и контейнеры. После запуска остановленного OpenBao снова подайте две доли, затем запускайте приложение. Для удаления контейнеров с сохранением volumes используйте `docker compose down`. `docker compose down -v` предназначена для намеренного удаления всех данных учебного стенда. Локальная PKI при этом сохраняется. Установленный экземпляр lab6 использует отдельные volumes.
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
## Архитектура
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
HAProxy принимает проверяемый HTTPS и выбирает готовую API-реплику по round robin. Между LB и каждой репликой отдельное mTLS-соединение. Входной sidecar проверяет цепочку client cert и разрешённую роль CN=lb. Сетевой интерфейс приложения слушает loopback своего namespace. Порты для прямого подключения к API, брокеру, S3 и телеметрии на хост не публикуются. Входы OpenBao и Grafana привязаны к loopback хоста.
## Ограничения и следующие шаги
PostgreSQL хранит пользователей, хеши сессий, чаты, сообщения, метаданные и outbox. Сообщение и запись идемпотентности сохраняются в одной транзакции. При загрузке API сначала записывает staging-объект в S3, затем фиксирует метаданные и outbox. Relay с publisher confirms публикует durable job. Worker обрабатывает задачи с at-least-once delivery и повторно использует детерминированные ключи объектов. RabbitMQ доступен по TLS только с отдельными producer/consumer credentials. Рестарт API сохраняет общие сессии. Сбой между записью staging и коммитом может оставить объект без метаданных.
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
Используется Argon2id с 19 MiB, t=2, p=1 и 16-байтной солью. PHC-строка хранит алгоритм, параметры, соль и hash. Сессии хранят SHA-256 от непрозрачного 256-битного токена. Ограничение login держится в PostgreSQL и учитывает обе реплики. На IP источника от LB выдаётся 30 попыток в минуту с 429 и Retry-After при превышении. Для upload действует 10 MiB, для остальных ручек 64 KiB. API и worker работают под UID 10001 с удалёнными capabilities, ограничениями CPU, памяти и PID.
## Проверки на работающем стенде
Команды запускаются из корня после readiness:
```sh
export CA_FILE="$PWD/secrets/ca/ca.crt"
make test
make test-security
docker compose --profile audit run --rm --no-deps security-probe
RESTART_OPENBAO=1 make test-persistence ACTION_SCRIPT=scripts/restart.sh
make test-failover ACTION_SCRIPT=scripts/stop-one.sh
docker compose start api1 api2
python3 scripts/failover-both.py
make load
python3 scripts/probe_external.py
```
При проверке полного рестарта OpenBao попросит две доли в терминале. Перед и после теста снимите `docker compose ps -a` и timestamps контейнеров командами `docker inspect --format '{{.Name}} {{.State.StartedAt}}' $(docker compose ps -aq)`. Проверку rate limit лучше запускать последней, следующий login из того же IP может получить 429 до конца окна. Для второго направления отказа `failover-both.py` по очереди оставляет на линии каждую реплику и проверяет старую сессию, файл и запись нового сообщения.
Метрики в Grafana — `http_requests_total`, `http_duration_seconds_bucket`, `worker_jobs_total`, `worker_job_duration_seconds_bucket`. Логи ищутся по `service_name` и событиям `http.request` / `job.completed`. Трассы HTTP и worker доступны в Tempo. Заголовок `X-Trace-Id` позволяет сопоставить ответ с трассой. Проверка dashboard требует выполнить smoke и дождаться скрейпа. Для нагрузки сохраните вывод, сведения о CPU/RAM через `docker stats --no-stream` и размер набора данных. Без фактического запуска численных показателей RPS и задержек стенда нет.
## Фактические результаты
| Критерий | Команда | Наблюдение |
| --- | --- | --- |
| Контракт | `make check`, `make validate` | PASS для offline-проверок |
| Манифест | `docker compose --profile audit config --quiet` | Конфигурация разрешается без ошибок |
| Выпуск CA и leaf | `python3 scripts/bootstrap.py`, `openssl verify` | Leaf localhost/API и клиент LB прошли проверку. Клиент от чужого CA отклонён при проверке цепочки offline |
| Argon2id | `python3 scripts/bench_argon2.py` | Apple M4, 10 ядер, 24 GB, Python 3.14.4 на хосте. 100 хеширований и 100 проверок после прогрева. p50/p95 хеша 15.54/17.14 мс, проверки 14.30/15.51 мс. При этих задержках выбран минимальный профиль задания. [Измерения](evidence/argon2.txt) |
| TLS smoke | `make test CA_FILE=…` | PASS. Сценарий включает загрузку, обработку и скачивание вложения по HTTPS |
| Доверие внешнему CA | `make test-security CA_FILE=…` | PASS. Доверенный HTTPS работает, недоверенный CA отклонён |
| Внутреннее mTLS, OpenBao и полномочия | `security-probe` | PASS. Обе реплики принимают сертификат LB и отклоняют соединения без сертификата, с чужим CA или с неверной ролью. Прямой порт API недоступен. Роли API и worker читают только собственные секреты и не могут менять политики. Подтверждены TLS к PostgreSQL, запрет удаления в S3 и отказ при отправке телеметрии без аутентификации |
| ACL, expiry, rate limit и лимит тела | `python3 scripts/probe_external.py` | PASS. TLS отклоняет адрес вне SAN. Посторонний не может прочитать или привязать вложение даже с подменой заголовка пользователя. Превышение лимита тела даёт 413. Выход и истечение сессии дают 401 при следующем запросе. Лимит входа возвращает 429 с Retry-After |
| Сохранность после перезапуска | `RESTART_OPENBAO=1 make test-persistence ACTION_SCRIPT=scripts/restart.sh` | PASS. После перезапуска и разблокировки OpenBao ранее подтверждённые данные и действующая сессия сохранились. Отдельные отметки времени запуска контейнеров пока не приложены |
| Отказ реплик | `make test-failover`, `python3 scripts/failover-both.py` | Основной тест PASS: до отказа отвечали 2 реплики, 87 успешных записей, 2 неуспешные попытки, первый успешный ответ после отказа через 3,465 с. Подтверждённые данные и сессия сохранились. Двусторонняя проверка PASS: после остановки api1 серия ответов готовности от api2 подтверждена за 5,97 с, после остановки api2 серия ответов от api1 подтверждена за 5,99 с. В обоих случаях оставшаяся реплика обслужила существующую сессию, сохранила историю, приняла новое сообщение и вернула исходный файл |
| Нагрузка | `make load` | Closed-loop POST сообщений, 4 параллельных клиента, 30,012 с. 6726 успешных запросов, 0 ошибок, 224,109 RPS. Задержки успешных запросов p50/p95/p99: 16,548/24,734/44,248 мс. CPU/RAM и исходный размер набора данных в этом прогоне не измерены |
| Телеметрия | Grafana | HTTPS endpoint `/api/health` сообщил `database: ok`. |
## Ограничения
Сообщения и файлы сохраняются в одноузловых PostgreSQL и S3. Потеря Docker-хоста входит в ограничения однохостового стенда. Приложение удерживает выданные credentials в памяти и переаутентифицируется при старте. Продление или автоматический отзыв уже полученных рабочих паролей не реализованы. OpenBao после перезапуска требует unseal оператором. Протоколы, identities и тесты перечислены в [матрице](contracts/trust-matrix.md) и [модели угроз](security/THREAT_MODEL.md).
Источники: [OpenBao Cert Auth](https://openbao.org/docs/auth/cert/), [RabbitMQ Definitions](https://www.rabbitmq.com/docs/definitions), [OWASP Password Storage](https://cheatsheetseries.owasp.org/cheatsheets/Password_Storage_Cheat_Sheet.html). Использован код lab6.
View File
+387
View File
@@ -0,0 +1,387 @@
import asyncio
import base64
import binascii
import hashlib
import hmac
import json
import re
import secrets
import time
from threading import BoundedSemaphore
import uuid
from argon2 import PasswordHasher
from argon2.exceptions import VerifyMismatchError
from contextlib import asynccontextmanager
from datetime import datetime, timedelta, timezone
from urllib.parse import parse_qs
import psycopg
from psycopg.types.json import Jsonb
from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse, Response
from starlette.concurrency import run_in_threadpool
from anyio import to_thread
from opentelemetry import propagate, trace
from opentelemetry.trace import SpanKind, Status, StatusCode
from app.common import (db, get, put, now, config, s3, bucket, sha,
inspect_image, InvalidImage, ImageTooLarge)
from app.telemetry import setup, INSTANCE
tracer, meter, logger, providers = setup('messenger-api')
requests_count = meter.create_counter('http_requests', unit='{request}')
http_duration = meter.create_histogram('http_duration', unit='s')
class APIError(Exception):
def __init__(self, status, code, retry_after=None):
self.status, self.code = status, code
self.retry_after = retry_after
def require(condition, status=400, code='invalid_request'):
if not condition:
raise APIError(status, code)
def uid(value):
try:
return str(uuid.UUID(value))
except (ValueError, TypeError, AttributeError):
raise APIError(400, 'invalid_request') from None
def text(value, maximum, minimum=1):
require(isinstance(value, str) and minimum <= len(value) <= maximum)
require(bool(value.strip()) or minimum == 0)
return value
def fields(body, required, optional=()):
require(isinstance(body, dict) and set(required) <= body.keys() and not body.keys()-set(required)-set(optional))
def ids(value, maximum, minimum=0):
require(isinstance(value, list) and minimum <= len(value) <= maximum)
result = [uid(x) for x in value]
require(len(result) == len(set(result)))
return result
def public_user(conn, user_id):
return get(conn, 'user', user_id)
def authenticate(conn, headers):
auth = headers.get('authorization', '')
require(auth.startswith('Bearer ') and bool(auth[7:]), 401, 'unauthorized')
row = conn.execute('SELECT user_id FROM sessions WHERE token_hash=%s AND expires_at>now()', (sha(auth[7:].encode()),)).fetchone()
require(row is not None, 401, 'unauthorized')
return row['user_id']
def chat_access(conn, chat_id, actor):
chat = get(conn, 'chat', uid(chat_id))
require(chat is not None and actor in chat['member_ids'], 404, 'not_found')
return chat
def attachment_access(conn, attachment_id, actor):
att = get(conn, 'attachment', uid(attachment_id))
require(att is not None, 404, 'not_found')
chat_access(conn, att['chat_id'], actor)
return att
def page(conn, kind, scope, query, actor):
raw_limit = query.get('limit', ['50'])
require(len(raw_limit) == 1 and re.fullmatch(r'[0-9]+', raw_limit[0]) is not None)
limit = int(raw_limit[0])
require(1 <= limit <= 100)
resource = scope if kind == 'message' else 'chats:'+actor
boundary = None
if 'cursor' in query:
try:
require(len(query['cursor']) == 1)
cursor = json.loads(base64.urlsafe_b64decode(query['cursor'][0].encode()+b'==='))
require(isinstance(cursor, list) and len(cursor) == 3 and cursor[0] == resource)
uid(cursor[2])
require(isinstance(cursor[1], str) and cursor[1].endswith('Z'))
datetime.fromisoformat(cursor[1].replace('Z', '+00:00'))
boundary = cursor[1:]
except (ValueError, TypeError, binascii.Error, UnicodeError):
raise APIError(400, 'invalid_request') from None
if kind == 'message':
condition, params = "data->>'chat_id'=%s", [scope]
else:
condition, params = "data->'member_ids' ? %s", [actor]
if boundary:
condition += " AND (data->>'created_at',id)>(%s,%s)"
params.extend(boundary)
rows = conn.execute("SELECT data FROM objects WHERE kind=%s AND "+condition+" ORDER BY data->>'created_at',id LIMIT %s",
[kind]+params+[limit+1]).fetchall()
items = [r['data'] for r in rows[:limit]]
next_cursor = None
if len(rows)>limit:
next_cursor = base64.urlsafe_b64encode(json.dumps([resource, items[-1]['created_at'], items[-1]['id']]).encode()).decode()
return {'items': items, 'next_cursor': next_cursor}
def dispatch(method, path, params, query, headers, raw):
if path == '/health/live':
return 200, {'status': 'ok'}
if path == '/health/ready':
with db() as conn:
conn.execute('SELECT 1')
s3().head_bucket(Bucket=bucket())
# Durable DB outbox accepts uploads while RabbitMQ/worker are unavailable.
return 200, {'status': 'ok'}
if path == '/api/v1/auth/sessions' and method == 'POST':
# The LB overwrites this header, and no other TLS client can reach the API.
key = headers.get('x-lab-client-ip', 'unknown')
with db() as conn:
attempts = conn.execute(
"""INSERT INTO login_limits(client, started, attempts) VALUES (%s, now(), 1)
ON CONFLICT(client) DO UPDATE SET
attempts = CASE WHEN login_limits.started <= now() - interval '1 minute'
THEN 1 ELSE least(login_limits.attempts + 1, 31) END,
started = CASE WHEN login_limits.started <= now() - interval '1 minute'
THEN now() ELSE login_limits.started END
RETURNING attempts, greatest(1, ceil(extract(epoch FROM
started + interval '1 minute' - now())))::int AS retry_after""",
(key,)).fetchone()
if attempts['attempts'] > 30:
raise APIError(429, 'rate_limited', attempts['retry_after'])
with db() as conn:
if path == '/api/v1/auth/sessions' and method == 'POST':
require(not raw, 400)
try:
auth = headers.get('authorization', '')
require(auth.startswith('Basic '), 401, 'unauthorized')
username, password = base64.b64decode(auth[6:], validate=True).decode('utf-8').split(':', 1)
except (ValueError, UnicodeError, binascii.Error):
raise APIError(401, 'unauthorized') from None
row = conn.execute('SELECT * FROM usernames WHERE username=%s', (username,)).fetchone()
encoded = row['password_hash'] if row else DUMMY_HASH
valid = False
if 12 <= len(password) <= 128:
if encoded.startswith('$argon2id$'):
try:
valid = HASHER.verify(encoded, password)
except VerifyMismatchError:
pass
else:
# Lab6 accounts remain usable after an explicit data migration.
salt, expected = encoded.split(':')
computed = hashlib.scrypt(password.encode(), salt=bytes.fromhex(salt), n=16384, r=8, p=1).hex()
valid = hmac.compare_digest(computed, expected)
if valid:
conn.execute('UPDATE usernames SET password_hash=%s WHERE username=%s AND password_hash=%s',
(HASHER.hash(password), username, encoded))
require(row is not None and valid, 401, 'unauthorized')
token = secrets.token_urlsafe(32)
expires = datetime.now(timezone.utc)+timedelta(seconds=int(config('SESSION_TTL_SECONDS', '3600')))
conn.execute('INSERT INTO sessions VALUES(%s,%s,%s)', (sha(token.encode()), row['user_id'], expires))
return 201, {'token': token, 'token_type': 'Bearer', 'expires_at': expires.isoformat().replace('+00:00','Z'),
'user': public_user(conn, row['user_id'])}
# Authentication precedes validation of resource identifiers / body.
actor = None if path == '/api/v1/users' and method == 'POST' else authenticate(conn, headers)
body = None
if method == 'POST' and not path.endswith('/attachments'):
try:
require(headers.get('content-type', '').split(';')[0] == 'application/json')
body = json.loads(raw)
except (ValueError, UnicodeError):
raise APIError(400, 'invalid_request') from None
if path == '/api/v1/users' and method == 'POST':
fields(body, ('username','display_name','password'))
username = text(body['username'], 32, 3)
require(re.fullmatch('[a-z0-9_]{3,32}', username) is not None)
display = text(body['display_name'], 100)
password = text(body['password'], 128, 12)
hashed = HASHER.hash(password)
user = {'id': str(uuid.uuid4()), 'username': username, 'display_name': display, 'created_at': now()}
conn.execute('INSERT INTO usernames VALUES(%s,%s,%s)', (username, user['id'], hashed))
put(conn, 'user', user)
return 201, user
if path == '/api/v1/users/me':
return 200, public_user(conn, actor)
if path == '/api/v1/auth/sessions/current':
conn.execute('DELETE FROM sessions WHERE token_hash=%s', (sha(headers['authorization'][7:].encode()),))
return 204, None
if path == '/api/v1/chats':
if method == 'GET':
return 200, page(conn, 'chat', None, query, actor)
fields(body, ('title','member_ids'))
members = ids(body['member_ids'], 100, 1)
require(actor in members and all(public_user(conn, x) for x in members))
chat = {'id': str(uuid.uuid4()), 'title': text(body['title'], 100), 'member_ids': members, 'created_at': now()}
put(conn, 'chat', chat)
return 201, chat
if 'chat_id' in params:
chat = chat_access(conn, params['chat_id'], actor)
if path == '/api/v1/chats/{chat_id}':
return 200, chat
if path.endswith('/messages'):
if method == 'GET':
return 200, page(conn, 'message', chat['id'], query, actor)
fields(body, ('text',), ('attachment_ids',))
message_text = text(body['text'], 4000, 0)
attachments = ids(body.get('attachment_ids', []), 10)
require(message_text.strip() or attachments)
key = headers.get('idempotency-key', '')
require(re.fullmatch(r'[A-Za-z0-9._:-]{1,128}', key) is not None)
payload = {'text': message_text, 'attachment_ids': attachments}
scope = actor+':POST:'+chat['id']+':'+key
# Cross-replica serialization. Hash collision merely serializes unrelated keys.
conn.execute('SELECT pg_advisory_xact_lock(hashtextextended(%s,0))', (scope,))
old = conn.execute("SELECT * FROM idempotency WHERE scope=%s AND created_at>now()-interval '24 hours'", (scope,)).fetchone()
if old:
require(old['payload'] == payload, 409, 'conflict')
return 201, old['response']
for aid in attachments:
att = attachment_access(conn, aid, actor)
require(att['chat_id'] == chat['id'], 404, 'not_found')
require(att['status'] != 'failed', 409, 'conflict')
message = {'id': str(uuid.uuid4()), 'chat_id': chat['id'], 'sender_id': actor,
**payload, 'created_at': now()}
put(conn, 'message', message)
conn.execute('DELETE FROM idempotency WHERE scope=%s', (scope,))
conn.execute('INSERT INTO idempotency(scope,payload,response) VALUES(%s,%s,%s)', (scope, Jsonb(payload), Jsonb(message)))
return 201, message
if path.endswith('/attachments'):
filename = query.get('filename', [''])[0]
text(filename, 255)
require(not any(x in filename for x in ('/', '\\')) and all(ord(x)>=32 and ord(x)!=127 for x in filename))
content_type = headers.get('content-type', '').split(';')[0]
require(content_type in ('image/png','image/jpeg'), 415, 'unsupported_media_type')
require(bool(raw), 415, 'unsupported_media_type')
with IMAGE_SLOTS:
inspect_image(raw, content_type)
aid, stamp = str(uuid.uuid4()), now()
att = {'id': aid, 'chat_id': chat['id'], 'owner_id': actor, 'filename': filename,
'content_type': content_type, 'size_bytes': len(raw), 'sha256': sha(raw),
'status': 'queued', 'variants': [], 'error_code': None, 'created_at': stamp, 'updated_at': stamp}
with tracer.start_as_current_span('s3.stage', record_exception=False, set_status_on_exception=False):
s3().put_object(Bucket=bucket(), Key='staging/'+aid, Body=raw, ContentType=content_type)
put(conn, 'attachment', att)
job = {'schema_version': 1, 'job_id': str(uuid.uuid4()), 'type': 'attachment.process.v1',
'attachment_id': aid, 'pipeline_version': 1, 'attempt': 1, 'created_at': stamp}
propagate.inject(job)
conn.execute('INSERT INTO outbox(id,payload) VALUES(%s,%s)', (job['job_id'], Jsonb(job)))
return 202, att
if 'attachment_id' in params:
att = attachment_access(conn, params['attachment_id'], actor)
if not path.endswith('/content'):
return 200, att
require(att['status'] == 'ready', 409, 'conflict')
variant = query.get('variant', ['original'])[0]
meta = att if variant == 'original' else next((v for v in att['variants'] if v['name']==variant), None)
require(meta is not None, 404, 'not_found')
with tracer.start_as_current_span('s3.download', record_exception=False, set_status_on_exception=False):
data = s3().get_object(Bucket=bucket(), Key='final/'+att['id']+'/'+variant)['Body'].read()
return 200, (data, meta['content_type'])
raise APIError(404, 'not_found')
UPLOAD_SLOTS = asyncio.Semaphore(4)
IMAGE_SLOTS = BoundedSemaphore(1)
HASHER = PasswordHasher(memory_cost=19456, time_cost=2, parallelism=1)
DUMMY_HASH = HASHER.hash('nonexistent-password')
@asynccontextmanager
async def lifespan(app):
to_thread.current_default_thread_limiter().total_tokens = 8
yield
for provider in providers:
provider.shutdown()
app = FastAPI(lifespan=lifespan, docs_url=None, redoc_url=None, openapi_url=None)
async def endpoint(request: Request):
if request.scope['route'].path.endswith('/attachments'):
async with UPLOAD_SLOTS:
return await dispatch_request(request, int(config('MAX_UPLOAD_BYTES', '10485760')))
return await dispatch_request(request, 65536)
async def dispatch_request(request, limit):
length = request.headers.get('content-length')
if length and length.isdecimal() and int(length) > limit:
raise APIError(413, 'payload_too_large')
raw = bytearray()
async for chunk in request.stream():
if len(raw) + len(chunk) > limit:
raise APIError(413, 'payload_too_large')
raw.extend(chunk)
code, result = await run_in_threadpool(dispatch, request.method, request.scope['route'].path,
request.path_params, parse_qs(request.url.query, keep_blank_values=True), request.headers, bytes(raw))
if code == 204:
return Response(status_code=204)
if isinstance(result, tuple):
return Response(result[0], media_type=result[1], status_code=code)
return JSONResponse(result, status_code=code)
for path, methods in [('/health/live',['GET']),('/health/ready',['GET']),('/api/v1/users',['POST']),
('/api/v1/users/me',['GET']),('/api/v1/auth/sessions',['POST']),('/api/v1/auth/sessions/current',['DELETE']),
('/api/v1/chats',['GET','POST']),('/api/v1/chats/{chat_id}',['GET']),
('/api/v1/chats/{chat_id}/messages',['GET','POST']),('/api/v1/chats/{chat_id}/attachments',['POST']),
('/api/v1/attachments/{attachment_id}',['GET']),('/api/v1/attachments/{attachment_id}/content',['GET'])]:
app.add_api_route(path, endpoint, methods=methods)
def error_response(request, status, code):
response = JSONResponse({'error': {'code': code, 'message': code.replace('_',' '),
'request_id': request.state.request_id}}, status_code=status)
if status == 401:
scheme = 'Basic' if request.url.path == '/api/v1/auth/sessions' else 'Bearer'
response.headers['WWW-Authenticate'] = scheme+' realm="messenger"'+(', charset="UTF-8"' if scheme=='Basic' else '')
return response
@app.exception_handler(APIError)
async def api_error(request, exc):
response = error_response(request, exc.status, exc.code)
if exc.retry_after is not None:
response.headers['Retry-After'] = str(exc.retry_after)
return response
@app.middleware('http')
async def observe(request, call_next):
request.state.request_id = uuid.uuid4().hex
started = time.monotonic()
with tracer.start_as_current_span('HTTP', context=propagate.extract(dict(request.headers)), kind=SpanKind.SERVER,
record_exception=False, set_status_on_exception=False) as span:
try:
response = await call_next(request)
except psycopg.errors.UniqueViolation:
response = error_response(request, 409, 'conflict')
except ImageTooLarge:
response = error_response(request, 413, 'payload_too_large')
except InvalidImage:
response = error_response(request, 415, 'unsupported_media_type')
except Exception as exc:
from botocore.exceptions import BotoCoreError, ClientError
unavailable = isinstance(exc, (psycopg.Error, BotoCoreError, ClientError))
response = error_response(request, 503 if unavailable else 500, 'unavailable' if unavailable else 'internal_error')
route = getattr(request.scope.get('route'), 'path', 'unmatched')
# Method is allowlisted too, to avoid attacker-controlled metric cardinality.
method = request.method if request.method in ('GET','POST','DELETE','HEAD','OPTIONS','PUT','PATCH') else 'OTHER'
labels = {'method': method, 'route': route, 'status_class': str(response.status_code//100)+'xx'}
elapsed = time.monotonic()-started
requests_count.add(1, labels)
http_duration.record(elapsed, labels)
span.update_name(method+' '+route)
span.set_attributes({**labels, 'http.response.status_code': response.status_code, 'request_id': request.state.request_id})
if response.status_code>=500:
span.set_status(Status(StatusCode.ERROR))
logger.log(40 if response.status_code>=500 else 20, 'http.request', extra={
'event': 'http.request', 'request_id': request.state.request_id, **labels,
'status_code': response.status_code, 'duration_seconds': elapsed})
response.headers['X-Request-Id'] = request.state.request_id
response.headers['X-Instance-Id'] = INSTANCE
response.headers['X-Trace-Id'] = format(span.get_span_context().trace_id, '032x')
return response
+100
View File
@@ -0,0 +1,100 @@
import hashlib
import io
import json
import os
import warnings
from contextlib import contextmanager
from datetime import datetime, timezone
from pathlib import Path
import boto3
from botocore.config import Config
import psycopg
from psycopg.rows import dict_row
from psycopg.types.json import Jsonb
from PIL import Image, ImageOps, UnidentifiedImageError
def config(name, default=None):
filename = os.getenv(name+'_FILE')
return Path(filename).read_text().strip() if filename else os.getenv(name, default)
def now():
return datetime.now(timezone.utc).isoformat(timespec='microseconds').replace('+00:00', 'Z')
@contextmanager
def db():
with psycopg.connect(config('DATABASE_URL'), row_factory=dict_row, connect_timeout=3,
options='-c statement_timeout=10000') as conn:
yield conn
def get(conn, kind, oid, lock=False):
row = conn.execute('SELECT data FROM objects WHERE kind=%s AND id=%s'+(' FOR UPDATE' if lock else ''), (kind, oid)).fetchone()
return row['data'] if row else None
def put(conn, kind, value):
conn.execute('INSERT INTO objects(kind,id,data) VALUES(%s,%s,%s) ON CONFLICT(kind,id) DO UPDATE SET data=excluded.data',
(kind, value['id'], Jsonb(value)))
def sha(data):
return hashlib.sha256(data).hexdigest()
def s3():
return boto3.client('s3', endpoint_url=config('S3_ENDPOINT', 'https://s3:9443'),
aws_access_key_id=config('S3_ACCESS_KEY_ID'), aws_secret_access_key=config('S3_SECRET_ACCESS_KEY'),
verify=config('LAB_CA'), region_name=config('S3_REGION', 'us-east-1'), config=Config(
connect_timeout=3, read_timeout=10, retries={'max_attempts': 2},
request_checksum_calculation='when_required', response_checksum_validation='when_required',
s3={'addressing_style': 'path'}))
def bucket():
return config('S3_BUCKET', 'messenger-attachments')
class InvalidImage(Exception):
pass
class ImageTooLarge(Exception):
pass
def inspect_image(data, content_type=None):
try:
with warnings.catch_warnings():
warnings.simplefilter('error', Image.DecompressionBombWarning)
with Image.open(io.BytesIO(data)) as image:
if image.width * image.height > int(config('MAX_IMAGE_PIXELS', '40000000')):
raise ImageTooLarge()
mime = {'PNG': 'image/png', 'JPEG': 'image/jpeg'}.get(image.format)
if not mime or (content_type and mime != content_type):
raise InvalidImage()
image.verify()
with Image.open(io.BytesIO(data)) as image:
image.load()
return mime
except (Image.DecompressionBombError, Image.DecompressionBombWarning):
raise ImageTooLarge() from None
except (UnidentifiedImageError, OSError, ValueError, SyntaxError):
raise InvalidImage() from None
def thumbnail(data):
with Image.open(io.BytesIO(data)) as image:
image = ImageOps.exif_transpose(image).convert('RGBA')
scale = min(1, 256/image.width, 256/image.height)
size = (max(1, int(image.width*scale)), max(1, int(image.height*scale)))
image = image.resize(size, Image.Resampling.LANCZOS)
canvas = Image.new('RGB', size, 'white')
canvas.paste(image, mask=image.getchannel('A'))
output = io.BytesIO()
canvas.save(output, format='JPEG', quality=85)
result = output.getvalue()
return result, {'name': 'thumbnail', 'content_type': 'image/jpeg',
'width': size[0], 'height': size[1], 'size_bytes': len(result), 'sha256': sha(result)}
+45
View File
@@ -0,0 +1,45 @@
"""Read role-scoped runtime settings from OpenBao before starting the service."""
import json
import os
import ssl
import sys
from urllib.request import Request, urlopen
def bao_request(path, context, payload=None, token=None):
headers = {}
if token:
headers['X-Vault-Token'] = token
if payload is not None:
headers['Content-Type'] = 'application/json'
request = Request(os.environ['BAO_ADDR'] + '/v1/' + path,
json.dumps(payload).encode() if payload is not None else None, headers)
with urlopen(request, context=context, timeout=5) as response:
return json.load(response) if response.status != 204 else None
def service_context():
context = ssl.create_default_context(cafile=os.environ['LAB_CA'])
context.load_cert_chain('/run/identity/client.crt', '/run/identity/client.key')
return context
def login(context, role):
return bao_request('auth/cert/login', context, {'name': role})['auth']['client_token']
def main():
role = os.environ.get('BAO_ROLE')
if role:
try:
context = service_context()
token = login(context, role)
settings = bao_request('secret/data/' + role, context, token=token)['data']['data']
except Exception:
raise SystemExit('OpenBao startup authentication or KV read failed') from None
os.environ.update(settings)
os.execvp(sys.argv[1], sys.argv[1:])
if __name__ == '__main__':
main()
+31
View File
@@ -0,0 +1,31 @@
"""Bounded, authenticated S3 bucket bootstrap, without MinIO client images."""
import time
from botocore.exceptions import ClientError
from app.common import s3, bucket
def main():
for attempt in range(60):
try:
client = s3()
try:
client.head_bucket(Bucket=bucket())
except ClientError as exc:
if exc.response['Error']['Code'] not in ('404', 'NoSuchBucket', 'NotFound'):
raise
client.create_bucket(Bucket=bucket())
print('S3 bucket ready')
return
except Exception as exc:
if attempt == 59:
detail = type(exc).__name__
if isinstance(exc, ClientError):
status = exc.response.get('ResponseMetadata', {}).get('HTTPStatusCode')
if isinstance(status, int):
detail += f', HTTP {status}'
raise SystemExit(f'S3 bootstrap failed ({detail})') from None
time.sleep(2)
if __name__ == '__main__':
main()
+44
View File
@@ -0,0 +1,44 @@
"""Explicit allowlist instrumentation: never export bodies, headers or exception text."""
import logging
import base64
import os
import socket
import uuid
from opentelemetry import metrics, trace
from opentelemetry.sdk.resources import Resource
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.sdk.metrics import MeterProvider
from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
from opentelemetry.exporter.otlp.proto.http.metric_exporter import OTLPMetricExporter
from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter
INSTANCE = os.getenv('INSTANCE_ID', socket.gethostname() + '-' + uuid.uuid4().hex[:8])
def setup(service):
resource = Resource.create({'service.name': service, 'service.version': '1.0.0',
'service.instance.id': INSTANCE, 'deployment.environment.name': 'lab'})
endpoint = os.getenv('OTEL_EXPORTER_OTLP_ENDPOINT', 'https://otel-collector:9443').rstrip('/')
identity = os.environ.get('BAO_ROLE', 'api')
password = os.environ.get('OTEL_PASSWORD', '')
authorization = base64.b64encode(f'{identity}:{password}'.encode()).decode()
options = {'certificate_file': os.environ.get('LAB_CA'),
'headers': {'Authorization': 'Basic ' + authorization}, 'timeout': 3}
tp = TracerProvider(resource=resource)
tp.add_span_processor(BatchSpanProcessor(OTLPSpanExporter(endpoint=endpoint+'/v1/traces', **options), max_queue_size=2048))
trace.set_tracer_provider(tp)
mp = MeterProvider(resource=resource, metric_readers=[PeriodicExportingMetricReader(
OTLPMetricExporter(endpoint=endpoint+'/v1/metrics', **options), export_interval_millis=5000)])
metrics.set_meter_provider(mp)
lp = LoggerProvider(resource=resource)
lp.add_log_record_processor(BatchLogRecordProcessor(OTLPLogExporter(endpoint=endpoint+'/v1/logs', **options), max_queue_size=2048))
logger = logging.getLogger(service)
logger.setLevel(logging.INFO)
logger.addHandler(LoggingHandler(logger_provider=lp))
# Only this application logger is exported; SDK/boto/SQL logs cannot leak secrets.
logger.propagate = False
meter = metrics.get_meter(service)
return trace.get_tracer(service), meter, logger, (tp, mp, lp)
+136
View File
@@ -0,0 +1,136 @@
"""DB outbox relay + durable RabbitMQ consumer; redeliveries are idempotent."""
import json
import ssl
import threading
import time
import pika
from opentelemetry import propagate
from opentelemetry.trace import SpanKind, Status, StatusCode
from psycopg.types.json import Jsonb
from app.common import db, get, config, s3, bucket, thumbnail, now
from app.telemetry import setup
tracer, meter, logger, providers = setup('messenger-worker')
count = meter.create_counter('worker_jobs', unit='{job}')
duration = meter.create_histogram('worker_job_duration', unit='s')
QUEUE = 'attachments'
def connection(identity):
params = pika.URLParameters(config('BROKER_' + identity + '_URL'))
params.ssl_options = pika.SSLOptions(ssl.create_default_context(cafile=config('LAB_CA')), 'broker')
params.heartbeat = 120
params.blocked_connection_timeout = 10
params.socket_timeout = 5
conn = pika.BlockingConnection(params)
channel = conn.channel()
if identity == 'PRODUCER':
channel.confirm_delivery()
return conn, channel
def relay():
while True:
try:
conn, channel = connection('PRODUCER')
try:
while True:
with db() as database:
row = database.execute('SELECT id,payload FROM outbox WHERE NOT sent LIMIT 1 FOR UPDATE SKIP LOCKED').fetchone()
if row:
channel.basic_publish(exchange='', routing_key=QUEUE, body=json.dumps(row['payload']),
properties=pika.BasicProperties(delivery_mode=2, content_type='application/json'), mandatory=True)
database.execute('UPDATE outbox SET sent=true WHERE id=%s', (row['id'],))
conn.process_data_events(time_limit=0.1)
if not row:
time.sleep(0.3)
finally:
if conn.is_open:
conn.close()
except Exception:
logger.warning('outbox.retry', extra={'event': 'outbox.retry'})
time.sleep(2)
def update_attachment(database, attachment):
database.execute("UPDATE objects SET data=%s WHERE kind='attachment' AND id=%s",
(Jsonb(attachment), attachment['id']))
def process(job):
# Lock serializes deliveries, including multiple worker processes.
# If killed, transaction rolls back; deterministic S3 keys are safe to overwrite.
with db() as database:
att = get(database, 'attachment', job['attachment_id'], lock=True)
if not att or att['status'] in ('ready','failed'):
return
att['status'] = 'processing'
update_attachment(database, att)
with tracer.start_as_current_span('s3.read_staging', record_exception=False, set_status_on_exception=False):
raw = s3().get_object(Bucket=bucket(), Key='staging/'+att['id'])['Body'].read()
with tracer.start_as_current_span('image.thumbnail', record_exception=False, set_status_on_exception=False):
thumb, meta = thumbnail(raw)
with tracer.start_as_current_span('s3.publish', record_exception=False, set_status_on_exception=False):
client = s3()
for name, data, mime in [('original', raw, att['content_type']), ('thumbnail', thumb, 'image/jpeg')]:
client.put_object(Bucket=bucket(), Key='final/'+att['id']+'/'+name, Body=data, ContentType=mime)
att.update(status='ready', variants=[meta], updated_at=now(), error_code=None)
with tracer.start_as_current_span('db.ready', record_exception=False, set_status_on_exception=False):
update_attachment(database, att)
def consume(channel, method, properties, body):
job = json.loads(body)
start = time.monotonic()
outcome = 'success'
with tracer.start_as_current_span('attachment.process', context=propagate.extract(job), kind=SpanKind.CONSUMER,
record_exception=False, set_status_on_exception=False) as span:
try:
process(job)
except Exception:
outcome = 'error'
span.set_status(Status(StatusCode.ERROR))
if job['attempt'] < int(config('JOB_MAX_ATTEMPTS', '5')):
job['attempt'] += 1
# Transactional retry intent is saved before acknowledging this delivery.
with db() as database:
database.execute('INSERT INTO outbox(id,payload) VALUES(%s,%s) ON CONFLICT(id) DO UPDATE SET payload=excluded.payload,sent=false',
(job['job_id'], Jsonb(job)))
else:
with db() as database:
att = get(database, 'attachment', job['attachment_id'], lock=True)
if att and att['status'] != 'ready':
att.update(status='failed', error_code='retry_exhausted', updated_at=now())
update_attachment(database, att)
time.sleep(min(job['attempt'], 5))
finally:
labels = {'job_type': 'attachment.process.v1', 'outcome': outcome}
count.add(1, labels)
elapsed = time.monotonic()-start
duration.record(elapsed, labels)
span.set_attributes(labels)
logger.log(40 if outcome=='error' else 20, 'job.completed', extra={
'event': 'job.completed', 'job_id': job['job_id'], 'attempt': job['attempt'],
'duration_seconds': elapsed, **labels})
channel.basic_ack(method.delivery_tag)
def main():
threading.Thread(target=relay, daemon=True).start()
while True:
try:
conn, channel = connection('CONSUMER')
try:
channel.basic_qos(prefetch_count=1)
channel.basic_consume(queue=QUEUE, on_message_callback=consume)
channel.start_consuming()
finally:
if conn.is_open:
conn.close()
except Exception:
logger.warning('consumer.retry', extra={'event': 'consumer.retry'})
time.sleep(2)
if __name__ == '__main__':
main()
+338
View File
@@ -0,0 +1,338 @@
name: mtusi2026lab7
x-app: &app
build: .
restart: unless-stopped
user: '10001:10001'
cap_drop: [ALL]
security_opt: [no-new-privileges:true]
read_only: true
tmpfs: [/tmp]
pids_limit: 100
cpus: 1.0
mem_limit: 512m
x-environment: &environment
LAB_CA: /run/ca/ca.crt
BAO_ADDR: https://openbao:8200
S3_ENDPOINT: https://s3:9443
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
x-proxy: &proxy
image: haproxy:3.0.11-alpine
user: '65534:65534'
entrypoint: [haproxy]
command: [-W, -db, -f, /run/proxy.cfg]
restart: unless-stopped
networks: [backend]
cap_drop: [ALL]
security_opt: [no-new-privileges:true]
read_only: true
mem_limit: 96m
services:
lb:
<<: *proxy
networks: [edge, backend]
ports: ['127.0.0.1:8443:8443']
volumes:
- ./secrets/proxy/lb.cfg:/run/proxy.cfg:ro
- ./secrets/tls/lb/server.pem:/run/tls/server.pem:ro
- ./secrets/identity/lb/client.pem:/run/identity/client.pem:ro
- ./secrets/ca/ca.crt:/run/ca/ca.crt:ro
api-edge1:
<<: *proxy
networks:
backend:
aliases: [api1]
volumes:
- ./secrets/proxy/api1.cfg:/run/proxy.cfg:ro
- ./secrets/tls/api1/server.pem:/run/tls/server.pem:ro
- ./secrets/ca/ca.crt:/run/ca/ca.crt:ro
api-edge2:
<<: *proxy
networks:
backend:
aliases: [api2]
volumes:
- ./secrets/proxy/api2.cfg:/run/proxy.cfg:ro
- ./secrets/tls/api2/server.pem:/run/tls/server.pem:ro
- ./secrets/ca/ca.crt:/run/ca/ca.crt:ro
api1:
<<: *app
network_mode: service:api-edge1
environment:
<<: *environment
BAO_ROLE: api
INSTANCE_ID: api1
volumes: &api-mounts
- ./secrets/identity/api/client.crt:/run/identity/client.crt:ro
- ./secrets/identity/api/client.key:/run/identity/client.key:ro
- ./secrets/ca/ca.crt:/run/ca/ca.crt:ro
depends_on: &api-deps
postgres: {condition: service_healthy}
openbao: {condition: service_healthy}
s3-init: {condition: service_completed_successfully}
api2:
<<: *app
network_mode: service:api-edge2
environment:
<<: *environment
BAO_ROLE: api
INSTANCE_ID: api2
volumes: *api-mounts
depends_on: *api-deps
worker:
<<: *app
networks: [backend]
environment:
<<: *environment
BAO_ROLE: worker
volumes:
- ./secrets/identity/worker/client.crt:/run/identity/client.crt:ro
- ./secrets/identity/worker/client.key:/run/identity/client.key:ro
- ./secrets/ca/ca.crt:/run/ca/ca.crt:ro
command: [python, -m, app.worker]
mem_limit: 768m
depends_on:
<<: *api-deps
rabbitmq: {condition: service_healthy}
postgres:
image: postgres:17.5-alpine
networks: [backend]
entrypoint: [/bin/sh, /opt/pg-entrypoint.sh]
command:
- postgres
- -c
- ssl=on
- -c
- ssl_cert_file=/run/pg-tls/server.crt
- -c
- ssl_key_file=/run/pg-tls/server.key
- -c
- hba_file=/opt/pg_hba.conf
environment:
POSTGRES_DB: messenger
POSTGRES_USER: db_operator
POSTGRES_PASSWORD_FILE: /run/postgres/admin-password
PGSSLMODE: verify-full
PGSSLROOTCERT: /run/ca/ca.crt
volumes:
- pg:/var/lib/postgresql/data
- ./secrets/ca/ca.crt:/run/ca/ca.crt:ro
- ./secrets/tls/postgres/server.key:/run/pg-source/server.key:ro
- ./secrets/tls/postgres/server.crt:/run/pg-source/server.crt:ro
- ./secrets/values/pg-admin:/run/postgres/admin-password:ro
- ./secrets/values/pg-api:/run/postgres/api-password:ro
- ./secrets/values/pg-worker:/run/postgres/worker-password:ro
- ./infra/postgres/entrypoint.sh:/opt/pg-entrypoint.sh:ro
- ./infra/postgres/pg_hba.conf:/opt/pg_hba.conf:ro
- ./infra/postgres/schema.sql:/opt/schema.sql:ro
- ./infra/postgres/10-init.sh:/docker-entrypoint-initdb.d/10-init.sh:ro
healthcheck:
test: [CMD, pg_isready, -h, postgres, -U, api, -d, messenger]
interval: 3s
timeout: 3s
retries: 30
mem_limit: 512m
s3:
<<: *proxy
volumes:
- ./secrets/proxy/s3.cfg:/run/proxy.cfg:ro
- ./secrets/tls/s3/server.pem:/run/tls/server.pem:ro
seaweed:
image: chrislusf/seaweedfs:3.85
network_mode: service:s3
command: [server, '-dir=/data', '-ip=127.0.0.1', '-ip.bind=127.0.0.1', '-volume.max=16', '-s3', '-s3.port=9000', '-s3.config=/etc/seaweedfs/s3.json']
volumes:
- seaweed:/data
- ./secrets/s3/identities.json:/etc/seaweedfs/s3.json:ro
- ./infra/seaweedfs/filer.toml:/etc/seaweedfs/filer.toml:ro
restart: unless-stopped
mem_limit: 512m
s3-init:
<<: *app
restart: 'no'
networks: [backend]
depends_on: [seaweed]
env_file: ./secrets/s3/admin.env
environment:
LAB_CA: /run/ca/ca.crt
volumes:
- ./secrets/ca/ca.crt:/run/ca/ca.crt:ro
command: [python, -m, app.init_storage]
broker:
<<: *proxy
volumes:
- ./secrets/proxy/broker.cfg:/run/proxy.cfg:ro
- ./secrets/tls/broker/server.pem:/run/tls/server.pem:ro
rabbitmq:
image: rabbitmq:4.1.0-alpine
network_mode: service:broker
environment:
ERL_EPMD_ADDRESS: 127.0.0.1
RABBITMQ_NODENAME: rabbit@localhost
RABBITMQ_CONFIG_FILE: /etc/rabbitmq/rabbitmq.conf
volumes:
- rabbitmq:/var/lib/rabbitmq
- ./infra/rabbitmq.conf:/etc/rabbitmq/rabbitmq.conf:ro
- ./secrets/broker/definitions.json:/etc/rabbitmq/definitions.json:ro
healthcheck:
test: [CMD, rabbitmq-diagnostics, -q, check_running]
interval: 5s
timeout: 5s
retries: 30
mem_limit: 512m
bao-volume:
image: openbao/openbao:2.3.1
user: '0:0'
network_mode: none
entrypoint: [/bin/sh, -ec]
command: ['chown 100:1000 /openbao/data && chmod 700 /openbao/data']
volumes: [bao_recovery:/openbao/data]
mem_limit: 64m
openbao:
image: openbao/openbao:2.3.1
user: '100:1000'
depends_on:
bao-volume: {condition: service_completed_successfully}
entrypoint: [bao]
command: [server, -config=/opt/bao.hcl]
networks: [edge, backend]
ports: ['127.0.0.1:8200:8200']
cap_drop: [ALL]
security_opt: [no-new-privileges:true]
read_only: true
mem_limit: 192m
environment:
BAO_ADDR: https://localhost:8200
BAO_CACERT: /run/ca/ca.crt
volumes:
- bao_recovery:/openbao/data
- ./infra/openbao/server.hcl:/opt/bao.hcl:ro
- ./secrets/ca/ca.crt:/run/ca/ca.crt:ro
- ./secrets/tls/openbao/server.crt:/run/bao-tls/server.crt:ro
- ./secrets/tls/openbao/server.key:/run/bao-tls/server.key:ro
healthcheck:
test: [CMD, bao, status]
interval: 3s
timeout: 3s
retries: 20
otel-collector:
<<: *proxy
volumes:
- ./secrets/proxy/otel-collector.cfg:/run/proxy.cfg:ro
- ./secrets/tls/otel-collector/server.pem:/run/tls/server.pem:ro
collector:
image: otel/opentelemetry-collector-contrib:0.128.0
network_mode: service:otel-collector
command: ['--config=/etc/otelcol/config.yaml']
volumes:
- ./secrets/telemetry/collector.yaml:/etc/otelcol/config.yaml:ro
- ./secrets/ca/ca.crt:/run/ca/ca.crt:ro
restart: unless-stopped
mem_limit: 256m
prometheus:
<<: *proxy
volumes:
- ./secrets/proxy/prometheus.cfg:/run/proxy.cfg:ro
- ./secrets/tls/prometheus/server.pem:/run/tls/server.pem:ro
prometheus-db:
image: prom/prometheus:v3.4.0
network_mode: service:prometheus
command: ['--config.file=/opt/prometheus.yml', '--web.listen-address=127.0.0.1:9090', '--storage.tsdb.path=/prometheus', '--storage.tsdb.retention.time=7d']
volumes:
- ./infra/prometheus.yaml:/opt/prometheus.yml:ro
- ./secrets/ca/ca.crt:/run/ca/ca.crt:ro
- ./secrets/values/scrape:/run/scrape-password:ro
- prometheus:/prometheus
mem_limit: 512m
loki:
<<: *proxy
volumes:
- ./secrets/proxy/loki.cfg:/run/proxy.cfg:ro
- ./secrets/tls/loki/server.pem:/run/tls/server.pem:ro
loki-db:
image: grafana/loki:3.5.0
network_mode: service:loki
command: ['-config.file=/etc/loki/local.yaml']
volumes:
- ./infra/loki.yaml:/etc/loki/local.yaml:ro
- loki:/loki
mem_limit: 512m
tempo:
<<: *proxy
volumes:
- ./secrets/proxy/tempo.cfg:/run/proxy.cfg:ro
- ./secrets/tls/tempo/server.pem:/run/tls/server.pem:ro
tempo-db:
image: grafana/tempo:2.7.2
network_mode: service:tempo
command: ['-config.file=/etc/tempo.yaml']
volumes:
- ./infra/tempo.yaml:/etc/tempo.yaml:ro
- tempo:/var/tempo
mem_limit: 512m
grafana:
image: grafana/grafana:12.0.1
networks: [edge, backend]
ports: ['127.0.0.1:3443:3000']
environment:
GF_SERVER_PROTOCOL: https
GF_SERVER_ROOT_URL: https://localhost:3443/
GF_SERVER_CERT_FILE: /run/tls/server.crt
GF_SERVER_CERT_KEY: /run/tls/server.key
GF_SECURITY_ADMIN_USER: admin
GF_SECURITY_ADMIN_PASSWORD__FILE: /run/grafana-password
GF_SECURITY_COOKIE_SECURE: 'true'
GF_USERS_ALLOW_SIGN_UP: 'false'
volumes:
- grafana:/var/lib/grafana
- ./secrets/tls/grafana/server.crt:/run/tls/server.crt:ro
- ./secrets/tls/grafana/server.key:/run/tls/server.key:ro
- ./secrets/values/grafana:/run/grafana-password:ro
- ./secrets/telemetry/datasources.yaml:/etc/grafana/provisioning/datasources/sources.yaml:ro
- ./infra/grafana/provisioning/dashboards:/etc/grafana/provisioning/dashboards:ro
- ./infra/grafana/dashboards:/var/lib/grafana/dashboards:ro
mem_limit: 384m
security-probe:
<<: *app
profiles: [audit]
restart: 'no'
networks: [backend]
environment:
<<: *environment
PYTHONPATH: /srv
command: [python, /srv/scripts/probe_internal.py]
volumes:
- ./scripts/probe_internal.py:/srv/scripts/probe_internal.py:ro
- ./secrets/ca/ca.crt:/run/ca/ca.crt:ro
- ./secrets/identity/lb:/run/probe/lb:ro
- ./secrets/identity/api:/run/probe/api:ro
- ./secrets/identity/worker:/run/probe/worker:ro
- ./secrets/identity/foreign:/run/probe/foreign:ro
networks:
edge: {}
backend:
internal: true
volumes:
pg:
seaweed:
rabbitmq:
bao:
bao_recovery:
prometheus:
loki:
tempo:
grafana:
+18 -32
View File
@@ -1,37 +1,23 @@
# Матрица доверия — заполнить в решении lab7
# Матрица доверия lab7
Это обязательная матрица покрытия. Для каждой строки укажите реальный порт, endpoint, CA, service identity, проверку SAN/ACL, срок жизни credentials и команду положительного/отрицательного теста. TLS шифрует и подтверждает сервер; mTLS также проверяет клиента. При доверенном CA всё равно нужно ограничивать разрешённую identity. Plaintext hop допустим только внутри закрытого локального transport/proxy boundary, без опубликованного обхода; границу и rationale нужно доказать.
CA стенда — `secrets/ca/ca.crt`. Серверные и клиентские leaf-сертификаты действуют 30 дней, CA — 365 дней. Каждая TLS-цель имеет собственный DNS SAN. Внутренние порты доступны в сети Compose `backend`. Plaintext backend слушает loopback в том же сетевом namespace, что и его TLS proxy.
| Связь | Минимум на 3 | Дополнительно на 4 | Доказательство / конфиг |
| Связь | Endpoint и проверка | Идентичность и права | Проверка |
| --- | --- | --- | --- |
| Клиент → ingress/LB | TLS, CA + hostname, Bearer | Проверка expiry/revocation сессии и общего login rate limit | TODO |
| LB → API (все реплики) | mTLS + allowlist LB identity | Ротация leaf без обхода проверки | TODO |
| API/worker → PostgreSQL | TLS verify-full + раздельные ограниченные DB roles | Ротация credentials; mTLS — допустимое усиление | TODO |
| API/worker → S3 | TLS + разные scoped credentials/prefix rights | Проверка denied prefix и ротация | TODO |
| API/worker → broker | TLS + разные producer/consumer identities и ACL | mTLS + ограничение допустимых SAN/ролей | TODO |
| API/worker → Collector | TLS; сеть/аутентификация запрещает произвольный ingest | mTLS с раздельными identities | TODO |
| Collector → telemetry backends | TLS + scoped backend credentials или mTLS | Ротация и проверка least privilege | TODO |
| Grafana → data sources | TLS с проверкой сервера, ограниченная identity | Отрицательные проверки доступа | TODO |
| API/worker/agent → OpenBao | TLS + сервисный auth + scoped policy | Renewal/expiry/revocation | TODO |
| Оператор → OpenBao/Grafana/S3 admin | TLS + authentication, доступ локальный/через защищённый канал | Разделение operator/application roles | TODO |
| API → Redis/Valkey, если используется | TLS + ACL/пароль с минимальными правами | Ротация; mTLS по возможности | TODO |
| Replication/кластерные каналы, если добавлены | TLS/mTLS либо подтверждённый шифрованный transport | Проверка заявленной модели отказа | TODO |
| Клиент → LB | HTTPS `localhost:8443`, CA и SAN localhost | Basic только на создании сессии, Bearer для защищённых ресурсов, 3600 с по умолчанию | `make test`, `make test-security`, `scripts/probe_external.py` |
| LB → API 1/2 | HTTPS `api1:9443` и `api2:9443`, SNI + verifyhost для каждой | Обязательный cert от CA, проверка клиентской роли CN=lb, Uvicorn слушает `127.0.0.1:8080` | Audit probe проверяет допуск LB, TLS-отказ без cert и с чужим CA, 403 для CN=api, закрытый сетевой порт 8080 |
| API/worker → PostgreSQL | `postgres:5432`, PostgreSQL TLS, sslmode=verify-full, SCRAM | Разные DB роли. API обслуживает контракт и пишет outbox. Worker видит только строки вложений и меняет их data, обрабатывает outbox. Пароли статические из OpenBao | Audit проверяет pg_stat_ssl и отказ worker при чтении sessions |
| API/worker → SeaweedFS | HTTPS `s3:9443` → localhost:9000. Узлы SeaweedFS одного процесса используют loopback | Различные SigV4 identities внутри приватного bucket. Proxy допускает API HEAD bucket, PUT staging и GET final. Worker имеет GET staging и PUT final. Bootstrap identity умеет HEAD/PUT bucket | Smoke проверяет upload/download, audit проверяет отказ удаления |
| Relay/consumer → RabbitMQ | AMQPS `broker:5671` → localhost:5672 | Оба процесса выполняются в worker. Producer публикует через default exchange в vhost messenger, consumer читает durable attachments. Сетевого соединения API→broker нет. Из API задания идут транзакционно в PostgreSQL outbox | Smoke thumbnail, `infra/rabbitmq.conf` и сгенерированные RabbitMQ definitions |
| API/worker → Collector | HTTPS `otel-collector:9443` → localhost:4318 | Разные Basic identity для POST OTLP logs/traces/metrics. Значения из scoped KV | Audit проверяет отказ без учётных данных. Успешный ingest проверяется в Grafana |
| Prometheus → Collector | HTTPS `otel-collector:9444` → localhost:8889 | Отдельный scraper только GET /metrics | Prometheus `up{job="messenger"}`, конфиг `infra/prometheus.yaml` |
| Collector → Loki/Tempo | HTTPS `loki:9444` → localhost:3100, `tempo:9444` → localhost:4318 | Разные Basic credentials на POST OTLP по разрешённому пути | Запросы Loki/Tempo из Grafana после smoke |
| Grafana → Prometheus/Loki/Tempo | HTTPS `prometheus:9443`, `loki:9443`, `tempo:9443` → локальные API | Три разных Basic password; proxy допускает только GET/POST по query API пути | Provisioning и dashboard, запросы из Explore |
| API/worker → OpenBao | HTTPS `openbao:8200`, проверка CA и SAN | Разные закреплённые leaf certificates. Сертификат → токен 120 с с одной policy. API и worker читают только собственный KV | Audit проверяет правильную выдачу и запрет чужой роли, KV и записи policy |
| Оператор → OpenBao/Grafana | `localhost:8200` и `localhost:3443` HTTPS, CA + SAN | Операторский токен OpenBao и пароль администратора Grafana. Операторские действия S3 ограничены локальным запуском s3-init через HTTPS, UI SeaweedFS не опубликован | `bao status`, bootstrap, вход в Grafana |
| API → Redis/Valkey | Не используется | Сессии и rate limit в PostgreSQL | Сохранность сессии при рестарте |
| Replication / кластерные каналы | API stateless, backend-сервисы одноузловые | RabbitMQ EPMD/distribution ограничены loopback. Filer, volume и master SeaweedFS в одном namespace | Порты публикуются только у LB, Grafana и OpenBao |
Нет выбранного компонента — отметьте N/A с причиной, а не оставляйте пустую строку. Внутренний публичный health listener, если нужен, минимален и изолирован; через него нельзя обращаться к бизнес-API без mTLS. Отдельно задокументируйте scrape/health/bootstrap каналы: они тоже не должны создавать обход.
Readiness LB ходит на тот же backend mTLS frontend и проверяет, что API установило TLS-соединения с PostgreSQL и S3. PostgreSQL health использует pg_isready, RabbitMQ health — локальный rabbitmq-diagnostics. Проверки readiness нельзя использовать для обхода mTLS. Внутренние Basic credentials и пароли PostgreSQL/RabbitMQ/S3 создаются при bootstrap и действуют до смены оператором.
## Обязательные отрицательные проверки
1. HTTPS с правильным CA/hostname проходит; с пустым/чужим CA и неправильным hostname — ошибка верификации, не «сервер недоступен».
2. LB→API: без client cert, с cert чужого CA, с запрещённой identity от доверенного CA — отказ; с разрешённой LB identity — успех.
3. На 4 повторите набор для broker и Collector; ограничение на network policy не заменяет проверку identity.
4. Пользователь вне чата не читает metadata/content и не прикрепляет чужой файл; поддельный X-User-Id не меняет Bearer identity.
5. OpenBao app policy читает только свой secret/path; запись policy и чтение чужого path запрещены. Worker не получает admin credentials API/БД/S3.
6. На 4 отзовите secret/cert и дождитесь контролируемого эффекта с учётом действующих соединений, TLS resumption и cache/TTL. Покажите новое подключение, иначе тест отзыва может ничего не проверить.
## Bootstrap и эксплуатация
В репозитории только открытые конфиги, policy templates и scripts. CA private key, leaf keys, root token, unseal shares и SecretID не коммитятся, не запекаются в образ и не печатаются в отчёте. Для локального стенда оператор создаёт их вне Git и передаёт через files/secrets с ограниченными правами. Опишите, кто имеет доступ к CA/unseal, что нужно после рестарта OpenBao и как восстановить работу.
OpenBao не использует dev-mode. Выберите persistent storage и auth метод (например AppRole с короткоживущим SecretID/response wrapping, cert auth или иная обоснованная identity). Не подменяйте root token постоянной переменной BAO_TOKEN в приложении. Рабочие tokens имеют policy, TTL и renewal/re-auth сценарий. Статические KV secrets на 3 допустимы при реальном чтении через сервисную identity; динамические DB credentials — хорошее расширение, но не обязательное название технологии.
Разрешённый компромисс учебного стенда: ручной operator init/unseal, если он безопасно документирован и не нужен при каждом обычном рестарте API. Автоматическое хранение всех unseal shares рядом с OpenBao без защиты не считается решённым bootstrap.
Для полного рестарта нужно заново unseal OpenBao через операторский канал. Обновление токена происходит повторной аутентификацией при старте процесса. Плановая замена leaf key требует согласованно обновить mounts и роль OpenBao. Пошаговые команды находятся в [отчёте](../REPORT.md).
+4
View File
@@ -0,0 +1,4 @@
Python 3.14.4; arm64; argon2-cffi 25.1.0
Argon2id m=19456 KiB, t=2, p=1, salt=16 B; n=100 per operation
hash: p50=15.54 ms, p95=17.14 ms
verify: p50=14.30 ms, p95=15.51 ms
+169
View File
@@ -0,0 +1,169 @@
{
"uid": "messenger",
"title": "Messenger observability",
"schemaVersion": 41,
"version": 1,
"refresh": "5s",
"time": {
"from": "now-15m",
"to": "now"
},
"panels": [
{
"id": 1,
"title": "API requests / second",
"type": "timeseries",
"datasource": {
"uid": "prometheus",
"type": "prometheus"
},
"gridPos": {
"x": 0,
"y": 0,
"w": 12,
"h": 8
},
"targets": [
{
"expr": "sum by (service_instance_id) (rate(http_requests_total{route!~\"/health/.*\"}[1m]))",
"refId": "A",
"legendFormat": "{{outcome}} {{service_instance_id}}"
}
],
"fieldConfig": {
"defaults": {
"unit": "reqps"
}
}
},
{
"id": 2,
"title": "API 5xx / second",
"type": "timeseries",
"datasource": {
"uid": "prometheus",
"type": "prometheus"
},
"gridPos": {
"x": 12,
"y": 0,
"w": 12,
"h": 8
},
"targets": [
{
"expr": "sum(rate(http_requests_total{status_class=\"5xx\",route!~\"/health/.*\"}[1m]))",
"refId": "A",
"legendFormat": "{{outcome}} {{service_instance_id}}"
}
],
"fieldConfig": {
"defaults": {
"unit": "reqps"
}
}
},
{
"id": 3,
"title": "API p95 duration",
"type": "timeseries",
"datasource": {
"uid": "prometheus",
"type": "prometheus"
},
"gridPos": {
"x": 0,
"y": 8,
"w": 12,
"h": 8
},
"targets": [
{
"expr": "histogram_quantile(0.95, sum by (le) (rate(http_duration_seconds_bucket{route!~\"/health/.*\"}[1m])))",
"refId": "A",
"legendFormat": "{{outcome}} {{service_instance_id}}"
}
],
"fieldConfig": {
"defaults": {
"unit": "s"
}
}
},
{
"id": 4,
"title": "Worker jobs / second",
"type": "timeseries",
"datasource": {
"uid": "prometheus",
"type": "prometheus"
},
"gridPos": {
"x": 12,
"y": 8,
"w": 12,
"h": 8
},
"targets": [
{
"expr": "sum by (outcome) (rate(worker_jobs_total[1m]))",
"refId": "A",
"legendFormat": "{{outcome}} {{service_instance_id}}"
}
],
"fieldConfig": {
"defaults": {
"unit": "ops"
}
}
},
{
"id": 5,
"title": "Worker p95 duration",
"type": "timeseries",
"datasource": {
"uid": "prometheus",
"type": "prometheus"
},
"gridPos": {
"x": 0,
"y": 16,
"w": 12,
"h": 8
},
"targets": [
{
"expr": "histogram_quantile(0.95, sum by (le,outcome) (rate(worker_job_duration_seconds_bucket[1m])))",
"refId": "A",
"legendFormat": "{{outcome}} {{service_instance_id}}"
}
],
"fieldConfig": {
"defaults": {
"unit": "s"
}
}
},
{
"id": 6,
"title": "API and worker structured logs",
"type": "logs",
"datasource": {
"uid": "loki",
"type": "loki"
},
"gridPos": {
"x": 12,
"y": 16,
"w": 12,
"h": 8
},
"targets": [
{
"expr": "{service_name=~\"messenger-api|messenger-worker\"}",
"refId": "A"
}
]
}
]
}
+41
View File
@@ -0,0 +1,41 @@
apiVersion: 1
datasources:
- name: Prometheus
uid: prometheus
type: prometheus
access: proxy
url: https://prometheus:9443
basicAuth: true
basicAuthUser: grafana
jsonData:
tlsAuthWithCACert: true
secureJsonData:
basicAuthPassword: "@PROM_PASSWORD@"
tlsCACert: |
@TLS_CA@
- name: Loki
uid: loki
type: loki
access: proxy
url: https://loki:9443
basicAuth: true
basicAuthUser: grafana
jsonData:
tlsAuthWithCACert: true
secureJsonData:
basicAuthPassword: "@LOKI_PASSWORD@"
tlsCACert: |
@TLS_CA@
- name: Tempo
uid: tempo
type: tempo
access: proxy
url: https://tempo:9443
basicAuth: true
basicAuthUser: grafana
jsonData:
tlsAuthWithCACert: true
secureJsonData:
basicAuthPassword: "@TEMPO_PASSWORD@"
tlsCACert: |
@TLS_CA@
@@ -0,0 +1,6 @@
apiVersion: 1
providers:
- name: Messenger
type: file
options:
path: /var/lib/grafana/dashboards
+25
View File
@@ -0,0 +1,25 @@
auth_enabled: false
server:
http_listen_address: 127.0.0.1
grpc_listen_address: 127.0.0.1
http_listen_port: 3100
common:
path_prefix: /loki
replication_factor: 1
ring:
kvstore:
store: inmemory
schema_config:
configs:
- from: '2024-04-01'
store: tsdb
object_store: filesystem
schema: v13
index:
prefix: index_
period: 24h
storage_config:
filesystem:
directory: /loki/chunks
limits_config:
allow_structured_metadata: true
+3
View File
@@ -0,0 +1,3 @@
path "secret/data/api" {
capabilities = ["read"]
}
+15
View File
@@ -0,0 +1,15 @@
ui = false
disable_mlock = true
api_addr = "https://openbao:8200"
storage "file" {
path = "/openbao/data"
}
listener "tcp" {
address = "0.0.0.0:8200"
tls_cert_file = "/run/bao-tls/server.crt"
tls_key_file = "/run/bao-tls/server.key"
tls_client_ca_file = "/run/ca/ca.crt"
tls_min_version = "tls12"
tls_require_and_verify_client_cert = false
}
+3
View File
@@ -0,0 +1,3 @@
path "secret/data/worker" {
capabilities = ["read"]
}
+50
View File
@@ -0,0 +1,50 @@
receivers:
otlp:
protocols:
http:
endpoint: 127.0.0.1:4318
processors:
memory_limiter:
check_interval: 1s
limit_mib: 160
spike_limit_mib: 32
batch:
timeout: 2s
exporters:
prometheus:
endpoint: 127.0.0.1:8889
resource_to_telemetry_conversion:
enabled: true
otlphttp/loki:
endpoint: https://loki:9444/otlp
tls:
ca_file: /run/ca/ca.crt
headers:
Authorization: "Basic @LOKI_AUTH@"
sending_queue: {queue_size: 128}
retry_on_failure: {max_elapsed_time: 30s}
otlphttp/tempo:
endpoint: https://tempo:9444
tls:
ca_file: /run/ca/ca.crt
headers:
Authorization: "Basic @TEMPO_AUTH@"
sending_queue: {queue_size: 128}
retry_on_failure: {max_elapsed_time: 30s}
service:
telemetry:
metrics:
level: none
pipelines:
metrics:
receivers: [otlp]
processors: [memory_limiter, batch]
exporters: [prometheus]
logs:
receivers: [otlp]
processors: [memory_limiter, batch]
exporters: [otlphttp/loki]
traces:
receivers: [otlp]
processors: [memory_limiter, batch]
exporters: [otlphttp/tempo]
+10
View File
@@ -0,0 +1,10 @@
#!/bin/sh
set -eu
psql -v ON_ERROR_STOP=1 --username "$POSTGRES_USER" --dbname "$POSTGRES_DB" \
-v api_pw="$(cat /run/postgres/api-password)" \
-v worker_pw="$(cat /run/postgres/worker-password)" <<'SQL'
CREATE ROLE api LOGIN PASSWORD :'api_pw';
CREATE ROLE worker LOGIN PASSWORD :'worker_pw';
REVOKE CONNECT, TEMPORARY ON DATABASE messenger FROM PUBLIC;
SQL
psql -v ON_ERROR_STOP=1 --username "$POSTGRES_USER" --dbname "$POSTGRES_DB" -f /opt/schema.sql
+6
View File
@@ -0,0 +1,6 @@
#!/bin/sh
set -eu
install -d -o postgres -g postgres -m 700 /run/pg-tls
install -o postgres -g postgres -m 600 /run/pg-source/server.key /run/pg-tls/server.key
install -o postgres -g postgres -m 644 /run/pg-source/server.crt /run/pg-tls/server.crt
exec docker-entrypoint.sh "$@"
+2
View File
@@ -0,0 +1,2 @@
local all all trust
hostssl messenger api,worker all scram-sha-256
+30
View File
@@ -0,0 +1,30 @@
CREATE TABLE IF NOT EXISTS objects (
kind text NOT NULL, id text NOT NULL, data jsonb NOT NULL,
PRIMARY KEY(kind,id));
CREATE TABLE IF NOT EXISTS usernames (
username text PRIMARY KEY, user_id text NOT NULL, password_hash text NOT NULL);
CREATE TABLE IF NOT EXISTS sessions (
token_hash text PRIMARY KEY, user_id text NOT NULL, expires_at timestamptz NOT NULL);
CREATE TABLE IF NOT EXISTS idempotency (
scope text PRIMARY KEY, payload jsonb NOT NULL, response jsonb NOT NULL,
created_at timestamptz NOT NULL DEFAULT now());
CREATE TABLE IF NOT EXISTS outbox (
id text PRIMARY KEY, payload jsonb NOT NULL, sent boolean NOT NULL DEFAULT false);
CREATE TABLE IF NOT EXISTS login_limits (
client text PRIMARY KEY, started timestamptz NOT NULL, attempts integer NOT NULL
);
GRANT CONNECT ON DATABASE messenger TO api, worker;
GRANT USAGE ON SCHEMA public TO api, worker;
REVOKE CREATE ON SCHEMA public FROM PUBLIC;
GRANT SELECT, INSERT, UPDATE ON usernames TO api;
GRANT SELECT, INSERT, DELETE ON sessions TO api;
GRANT SELECT, INSERT, DELETE ON idempotency TO api;
GRANT SELECT, INSERT, UPDATE ON login_limits TO api;
ALTER TABLE objects ENABLE ROW LEVEL SECURITY;
CREATE POLICY api_objects ON objects TO api USING (true) WITH CHECK (true);
CREATE POLICY worker_attachments ON objects TO worker USING (kind = 'attachment')
WITH CHECK (kind = 'attachment');
GRANT SELECT, INSERT, UPDATE ON objects TO api;
GRANT SELECT, UPDATE (data) ON objects TO worker;
GRANT INSERT ON outbox TO api;
GRANT SELECT, INSERT, UPDATE ON outbox TO worker;
+13
View File
@@ -0,0 +1,13 @@
global:
scrape_interval: 5s
scrape_configs:
- job_name: messenger
scheme: https
tls_config:
ca_file: /run/ca/ca.crt
server_name: otel-collector
basic_auth:
username: scraper
password_file: /run/scrape-password
static_configs:
- targets: ['otel-collector:9444']
+4
View File
@@ -0,0 +1,4 @@
listeners.tcp.1 = 127.0.0.1:5672
distribution.listener.interface = 127.0.0.1
definitions.import_backend = local_filesystem
definitions.local.path = /etc/rabbitmq/definitions.json
+3
View File
@@ -0,0 +1,3 @@
[leveldb2]
enabled = true
dir = "/data/filer"
+22
View File
@@ -0,0 +1,22 @@
server:
http_listen_address: 127.0.0.1
grpc_listen_address: 127.0.0.1
http_listen_port: 3200
distributor:
receivers:
otlp:
protocols:
grpc:
endpoint: 127.0.0.1:4317
http:
endpoint: 127.0.0.1:4318
storage:
trace:
backend: local
wal:
path: /var/tempo/wal
local:
path: /var/tempo/blocks
compactor:
compaction:
block_retention: 168h
+9
View File
@@ -0,0 +1,9 @@
fastapi==0.115.12
uvicorn==0.34.2
psycopg[binary]==3.2.9
boto3==1.38.23
pika==1.3.2
Pillow==11.2.1
opentelemetry-sdk==1.33.1
opentelemetry-exporter-otlp-proto-http==1.33.1
argon2-cffi==25.1.0
+72
View File
@@ -0,0 +1,72 @@
#!/usr/bin/env python3
"""Initialize operator-controlled OpenBao configuration over verified HTTPS."""
import argparse
import getpass
import json
import os
from pathlib import Path
import ssl
import sys
from urllib.error import HTTPError
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT))
from app.credentials import bao_request
os.environ.setdefault('BAO_ADDR', 'https://localhost:8200')
CA = ROOT / 'secrets/ca/ca.crt'
def unseal(context):
while True:
status = bao_request('sys/seal-status', context)
if not status['initialized']:
raise SystemExit('Initialize OpenBao before submitting unseal shares.')
if not status['sealed']:
print('OpenBao is unsealed')
return
key = getpass.getpass(f'OpenBao share ({status["progress"]}/{status["t"]}): ')
bao_request('sys/unseal', context, {'key': key})
def configure(context):
token = getpass.getpass('OpenBao operator token: ')
def request(path, payload=None):
return bao_request(path, context, payload, token)
mounts = request('sys/mounts')
if 'secret/' not in (mounts.get('data') or mounts):
request('sys/mounts/secret', {'type': 'kv', 'options': {'version': '2'}})
methods = request('sys/auth')
if 'cert/' not in (methods.get('data') or methods):
request('sys/auth/cert', {'type': 'cert'})
for role in ('api', 'worker'):
request('sys/policies/acl/' + role,
{'policy': (ROOT / f'infra/openbao/{role}.hcl').read_text()})
request('auth/cert/certs/' + role, {
'certificate': (ROOT / f'secrets/identity/{role}/client.crt').read_text(),
'allowed_common_names': [role],
'token_policies': [role],
'token_no_default_policy': True,
'token_ttl': '120s',
'token_explicit_max_ttl': '300s',
})
request('secret/data/' + role,
{'data': json.loads((ROOT / f'secrets/operator/{role}.json').read_text())})
print('Configured two scoped certificate roles and KV paths')
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('action', choices=['unseal', 'configure'])
args = parser.parse_args()
context = ssl.create_default_context(cafile=str(CA))
try:
{'unseal': unseal, 'configure': configure}[args.action](context)
except HTTPError as exc:
raise SystemExit(f'OpenBao rejected the operation with HTTP {exc.code}') from None
if __name__ == '__main__':
main()
+24
View File
@@ -0,0 +1,24 @@
#!/usr/bin/env python3
"""Measure local Argon2id hash and verify latencies without user data."""
from importlib.metadata import version
import platform
from statistics import median, quantiles
from time import perf_counter
from argon2 import PasswordHasher
hasher = PasswordHasher(memory_cost=19456, time_cost=2, parallelism=1)
password = 'synthetic-benchmark-password'
encoded = hasher.hash(password)
print(f'Python {platform.python_version()}; {platform.machine()}; argon2-cffi {version("argon2-cffi")}')
print('Argon2id m=19456 KiB, t=2, p=1, salt=16 B; n=100 per operation')
for name, operation in [('hash', lambda: hasher.hash(password)),
('verify', lambda: hasher.verify(encoded, password))]:
for _ in range(5):
operation()
samples = []
for _ in range(100):
start = perf_counter()
operation()
samples.append((perf_counter() - start) * 1000)
print(f'{name}: p50={median(samples):.2f} ms, p95={quantiles(samples, n=100)[94]:.2f} ms')
+255
View File
@@ -0,0 +1,255 @@
"""Generate local credentials, certificates and runtime configurations once."""
import base64
import hashlib
import json
import os
from pathlib import Path
import secrets
import shutil
import subprocess
import tempfile
from urllib.parse import quote
ROOT = Path(__file__).resolve().parents[1]
BUCKET = 'messenger-attachments'
PASSWORDS = {key: secrets.token_hex(24) for key in (
'pg-admin', 'pg-api', 'pg-worker', 's3-admin', 's3-api', 's3-worker',
'producer', 'consumer', 'otel-api', 'otel-worker', 'loki-write', 'tempo-write',
'grafana', 'loki-read', 'tempo-read', 'prom-read', 'scrape')}
S3_IDS = {'admin': 'messenger-bootstrap', 'api': 'messenger-api', 'worker': 'messenger-worker'}
def write(root, path, content):
file = root / path
file.parent.mkdir(parents=True, exist_ok=True)
file.write_text(content)
# The enclosing secrets directory is 0700 on the host. Exact read-only
# mounts also work with the image-specific UIDs inside Docker Desktop.
file.chmod(0o444)
def openssl(*args):
subprocess.run(['openssl', *map(str, args)], check=True, stdout=subprocess.DEVNULL)
def issue(root, ca, target, name, usage, names=()):
folder = root / target
folder.mkdir(parents=True, exist_ok=True)
key, crt = folder / f'{usage}.key', folder / f'{usage}.crt'
with tempfile.TemporaryDirectory() as temporary:
csr, config = Path(temporary) / 'leaf.csr', Path(temporary) / 'ext'
config.write_text(
'basicConstraints=critical,CA:FALSE\nkeyUsage=critical,digitalSignature\n'
'subjectKeyIdentifier=hash\nauthorityKeyIdentifier=keyid:always\n'
f'extendedKeyUsage={usage}Auth\n'
+ ('subjectAltName=' + ','.join('DNS:' + dns for dns in names) + '\n' if names else ''))
openssl('req', '-new', '-newkey', 'ec', '-pkeyopt', 'ec_paramgen_curve:P-256',
'-nodes', '-subj', '/CN=' + name, '-keyout', key, '-out', csr)
openssl('x509', '-req', '-in', csr, '-CA', root / f'operator/{ca}.crt',
'-CAkey', root / f'operator/{ca}.key', '-set_serial', '0x' + secrets.token_hex(16),
'-days', '30', '-sha256', '-extfile', config, '-out', crt)
key.chmod(0o444)
write(root, f'{target}/{usage}.pem', crt.read_text() + key.read_text())
def pki(root):
(root / 'operator').mkdir(mode=0o700)
for name in ('ca', 'foreign'):
openssl('req', '-x509', '-newkey', 'ec', '-pkeyopt', 'ec_paramgen_curve:P-256',
'-nodes', '-subj', '/CN=MTUSI lab7 ' + name, '-days', '365',
'-addext', 'basicConstraints=critical,CA:TRUE',
'-addext', 'keyUsage=critical,keyCertSign,cRLSign',
'-addext', 'subjectKeyIdentifier=hash',
'-keyout', root / f'operator/{name}.key', '-out', root / f'operator/{name}.crt')
write(root, 'ca/ca.crt', (root / 'operator/ca.crt').read_text())
for name in ('lb', 'api1', 'api2', 'postgres', 's3', 'broker', 'otel-collector',
'loki', 'tempo', 'prometheus', 'grafana', 'openbao'):
names = (name, 'localhost') if name in ('lb', 'grafana', 'openbao') else (name,)
issue(root, 'ca', 'tls/' + name, name, 'server', names)
for name in ('lb', 'api', 'worker'):
issue(root, 'ca', 'identity/' + name, name, 'client')
issue(root, 'foreign', 'identity/foreign', 'lb', 'client')
COMMON = '''global
maxconn 256
ssl-default-bind-options ssl-min-ver TLSv1.2
ssl-default-server-options ssl-min-ver TLSv1.2
defaults
mode http
timeout connect 2s
timeout client 35s
timeout server 35s
'''
def frontend(port, params=''):
return f'frontend tls\n bind :{port} ssl crt /run/tls/server.pem {params}\n'
def proxy(root, name, config):
write(root, f'proxy/{name}.cfg', COMMON + config)
def local_backend(port):
return f' default_backend local\nbackend local\n server local 127.0.0.1:{port}\n'
def telemetry_proxy(root, name, port, grants, rules):
users = ''.join(f'userlist {identity}\n user {identity} insecure-password {PASSWORDS[key]}\n'
for identity, key in grants.items())
proxy(root, name, users + 'frontend tls\n' + ''.join(
f' bind :{public} ssl crt /run/tls/server.pem\n' for public in rules)
+ ''.join(f' acl port{public} dst_port {public}\n' + statements
for public, statements in rules.items())
+ ' http-request deny deny_status 403\n'
+ ''.join(f'backend port{public}\n server local 127.0.0.1:{target}\n'
for public, target in port.items()))
def grant(public, identity, method, path, exact=False):
match = 'path' if exact else 'path_beg'
return (f' http-request allow if port{public} {{ http_auth({identity}) }} '
f'{{ method {method} }} {{ {match} {path} }}\n'
f' use_backend port{public} if port{public}\n')
def proxies(root):
proxy(root, 'lb', '''resolvers docker
nameserver embedded 127.0.0.11:53
timeout resolve 1s
timeout retry 1s
hold valid 5s
''' + frontend(8443) + ''' http-request set-header X-Lab-Client-IP %[src]
default_backend api
backend api
balance roundrobin
option httpchk GET /health/ready
http-check expect status 200
default-server inter 1s fall 2 rise 1 resolvers docker init-addr libc,none ssl verify required ca-file /run/ca/ca.crt crt /run/identity/client.pem
server api1 api1:9443 check verifyhost api1 sni str(api1) check-sni api1
server api2 api2:9443 check verifyhost api2 sni str(api2) check-sni api2
''')
for name in ('api1', 'api2'):
proxy(root, name, frontend(9443, 'verify required ca-file /run/ca/ca.crt') +
' http-request deny deny_status 403 unless { ssl_c_s_dn(CN) -m str lb }\n' +
local_backend(8080))
proxy(root, 'broker', frontend(5671) + ''' mode tcp
timeout client 150s
default_backend amqp
backend amqp
mode tcp
timeout server 150s
server local 127.0.0.1:5672
''')
proxy(root, 's3', frontend(9443) + f''' acl one_auth req.fhdr_cnt(authorization) eq 1
acl admin req.fhdr(authorization) -m beg "AWS4-HMAC-SHA256 Credential={S3_IDS['admin']}/"
acl api req.fhdr(authorization) -m beg "AWS4-HMAC-SHA256 Credential={S3_IDS['api']}/"
acl worker req.fhdr(authorization) -m beg "AWS4-HMAC-SHA256 Credential={S3_IDS['worker']}/"
acl bucket path /{BUCKET} /{BUCKET}/
acl staging path_reg ^/{BUCKET}/staging/[0-9a-f-]+$
acl final path_reg ^/{BUCKET}/final/[0-9a-f-]+/(original|thumbnail)$
acl query_present query -m found
http-request deny unless one_auth !query_present
http-request allow if admin bucket {{ method HEAD PUT }}
http-request allow if api bucket {{ method HEAD }}
http-request allow if api staging {{ method PUT }}
http-request allow if api final {{ method GET }}
http-request allow if worker staging {{ method GET }}
http-request allow if worker final {{ method PUT }}
http-request deny
''' + local_backend(9000))
telemetry_proxy(root, 'otel-collector', {9443: 4318, 9444: 8889},
{'api': 'otel-api', 'worker': 'otel-worker', 'scraper': 'scrape'},
{9443: ''' http-request allow if port9443 { http_auth(api) } { method POST } { path /v1/logs /v1/traces /v1/metrics }
http-request allow if port9443 { http_auth(worker) } { method POST } { path /v1/logs /v1/traces /v1/metrics }
use_backend port9443 if port9443
''', 9444: grant(9444, 'scraper', 'GET', '/metrics', exact=True)})
for name, internal, write_path, read_prefix in (
('loki', 3100, '/otlp/v1/logs', '/loki/api/v1/'),
('tempo', 3200, '/v1/traces', '/api/')):
ingest_port = 4318 if name == 'tempo' else internal
telemetry_proxy(root, name, {9443: internal, 9444: ingest_port},
{'grafana': name + '-read', 'collector': name + '-write'},
{9443: grant(9443, 'grafana', 'GET POST', read_prefix),
9444: grant(9444, 'collector', 'POST', write_path, exact=True)})
telemetry_proxy(root, 'prometheus', {9443: 9090}, {'grafana': 'prom-read'},
{9443: grant(9443, 'grafana', 'GET POST', '/api/v1/')})
def settings(root):
for name in ('pg-admin', 'pg-api', 'pg-worker', 'grafana', 'scrape'):
write(root, 'values/' + name, PASSWORDS[name] + '\n')
identities = []
for role, access in S3_IDS.items():
identities.append({'name': role, 'credentials': [
{'accessKey': access, 'secretKey': PASSWORDS['s3-' + role]}],
'actions': ['Admin'] if role == 'admin' else ['Read:' + BUCKET, 'Write:' + BUCKET, 'List:' + BUCKET]})
write(root, 's3/identities.json', json.dumps({'identities': identities}))
write(root, 's3/admin.env', f'S3_ACCESS_KEY_ID={S3_IDS["admin"]}\nS3_SECRET_ACCESS_KEY={PASSWORDS["s3-admin"]}\n')
for role in ('api', 'worker'):
database = f'postgresql://{role}:{PASSWORDS["pg-" + role]}@postgres:5432/messenger'
data = {'DATABASE_URL': database + '?sslmode=verify-full&sslrootcert=/run/ca/ca.crt',
'S3_ACCESS_KEY_ID': S3_IDS[role], 'S3_SECRET_ACCESS_KEY': PASSWORDS['s3-' + role],
'OTEL_PASSWORD': PASSWORDS['otel-' + role]}
if role == 'worker':
for identity in ('producer', 'consumer'):
data[f'BROKER_{identity.upper()}_URL'] = (
f'amqps://{identity}:{quote(PASSWORDS[identity])}@broker:5671/messenger')
write(root, f'operator/{role}.json', json.dumps(data))
def broker(root):
users = []
for name in ('producer', 'consumer'):
salt = secrets.token_bytes(4)
digest = hashlib.sha256(salt + PASSWORDS[name].encode()).digest()
users.append({'name': name, 'password_hash': base64.b64encode(salt + digest).decode(),
'hashing_algorithm': 'rabbit_password_hashing_sha256', 'tags': []})
manifest = {'users': users, 'vhosts': [{'name': 'messenger'}], 'permissions': [
{'user': 'producer', 'vhost': 'messenger', 'configure': '^$', 'write': '^amq\\.default$', 'read': '^$'},
{'user': 'consumer', 'vhost': 'messenger', 'configure': '^$', 'write': '^$', 'read': '^attachments$'}],
'queues': [{'name': 'attachments', 'vhost': 'messenger', 'durable': True,
'auto_delete': False, 'arguments': {}}]}
write(root, 'broker/definitions.json', json.dumps(manifest))
def telemetry(root):
config = (ROOT / 'infra/otel/collector.yaml').read_text()
for name in ('loki', 'tempo'):
header = base64.b64encode(f'collector:{PASSWORDS[name + "-write"]}'.encode()).decode()
config = config.replace(f'@{name.upper()}_AUTH@', header)
write(root, 'telemetry/collector.yaml', config)
config = (ROOT / 'infra/grafana/datasources.yaml').read_text()
for name, key in (('loki', 'loki-read'), ('tempo', 'tempo-read'), ('prom', 'prom-read')):
config = config.replace(f'@{name.upper()}_PASSWORD@', PASSWORDS[key])
config = config.replace('@TLS_CA@', '\n'.join(
' ' + line for line in (root / 'ca/ca.crt').read_text().splitlines()))
write(root, 'telemetry/datasources.yaml', config)
def main():
os.umask(0o077)
destination = ROOT / 'secrets'
if destination.exists():
if not (destination / '.ready').exists():
raise SystemExit('Existing secrets/ has no bootstrap marker. Inspect it before retrying.')
print('Using existing local runtime material')
return
temporary = Path(tempfile.mkdtemp(prefix='lab7-secrets-', dir=ROOT))
try:
pki(temporary)
settings(temporary)
broker(temporary)
telemetry(temporary)
proxies(temporary)
write(temporary, '.ready', 'lab7\n')
temporary.rename(destination)
finally:
if temporary.exists():
shutil.rmtree(temporary)
print('Created local runtime material in secrets/')
if __name__ == '__main__':
main()
+73
View File
@@ -0,0 +1,73 @@
"""Exercise both API replica failures against the same session, data and files."""
from pathlib import Path
import os
import subprocess
import sys
import time
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / 'tests'))
from client import Client, Failure, arguments, check, run
REPLICAS = {'api1', 'api2'}
def compose(*args):
subprocess.run(['docker', 'compose', *args], cwd=ROOT, check=True, timeout=40)
def wait(client, expected, timeout):
observed = set()
consecutive = 0
required = 5 if len(expected) == 1 else 1
start = time.monotonic()
while time.monotonic() - start < timeout:
try:
response = client.call('GET', '/health/ready', schema='Health')
replica = response['headers']['X-Instance-Id']
except Failure:
replica = None
if replica in expected:
observed.add(replica)
consecutive += 1
if observed == expected and consecutive >= required:
return time.monotonic() - start
else:
consecutive = 0
time.sleep(0.25)
raise Failure('expected replicas did not become ready')
def main():
args = arguments(__doc__)
client = Client(args.base_url, args.ca_file or os.environ.get('CA_FILE', str(ROOT / 'secrets/ca/ca.crt')),
timeout=2)
wait(client, REPLICAS, 45)
alice, _, _, chat = client.bootstrap()
first = client.message(alice, chat, 'Проверка сохранности')['json']
attachment, content = client.attachment(alice, chat)
client.wait_ready(alice, attachment)
for stopped in sorted(REPLICAS):
other = (REPLICAS - {stopped}).pop()
compose('stop', '-t', '2', stopped)
try:
elapsed = wait(client, {other}, 10)
for _ in range(5):
response = client.call('GET', '/api/v1/users/me', actor=alice, schema='User')
check(response['headers']['X-Instance-Id'] == other, 'unexpected replica while one is stopped')
message = client.message(alice, chat, 'Запись через оставшуюся реплику')['json']
history = client.call('GET', '/api/v1/chats/' + chat['id'] + '/messages', actor=alice,
schema='MessagePage')['json']['items']
check({first['id'], message['id']} <= {item['id'] for item in history}, 'message missing')
data = client.call('GET', '/api/v1/attachments/' + attachment['id'] + '/content',
actor=alice)['bytes']
check(data == content, 'original file changed')
print(f'PASS: {stopped} stopped, {other} serves existing session, messages and file. '
f'Readiness after stop returned in {elapsed:.2f}s')
finally:
compose('start', stopped)
wait(client, REPLICAS, 45)
if __name__ == '__main__':
run(main)
+81
View File
@@ -0,0 +1,81 @@
"""Run additional HTTPS ACL, expiry, size and login rate checks."""
import base64
import hashlib
import os
from pathlib import Path
import ssl
import subprocess
import sys
import urllib.error
import urllib.request
import uuid
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'tests'))
from client import Client, arguments, check, run
def expire(actor):
digest = hashlib.sha256(actor['token'].encode()).hexdigest()
sql = f"UPDATE sessions SET expires_at=now()-interval '1 second' WHERE token_hash='{digest}';\n"
result = subprocess.run(
['docker', 'compose', 'exec', '-T', 'postgres', 'psql', '-v', 'ON_ERROR_STOP=1',
'-U', 'db_operator', '-d', 'messenger'],
cwd=Path(__file__).resolve().parents[1], input=sql, text=True, capture_output=True)
check(result.returncode == 0 and 'UPDATE 1' in result.stdout, 'could not expire synthetic session')
def hostname(ca):
context = ssl.create_default_context(cafile=ca)
try:
with urllib.request.urlopen('https://127.0.0.1:8443/health/live', context=context, timeout=5):
pass
except urllib.error.URLError as exc:
check(isinstance(exc.reason, ssl.SSLCertVerificationError), 'wrong hostname failed for a non-TLS reason')
check(exc.reason.verify_code in (62, 64), 'certificate error was not a SAN/hostname mismatch')
else:
check(False, 'unexpected success using IP outside certificate SAN')
def main():
args = arguments(__doc__)
ca = args.ca_file or os.environ.get('CA_FILE', 'secrets/ca/ca.crt')
client = Client(args.base_url, ca)
client.call('GET', '/health/ready', schema='Health')
hostname(ca)
alice, _, eve, chat = client.bootstrap()
attachment, _ = client.attachment(alice, chat)
attachment = client.wait_ready(alice, attachment)
path = '/api/v1/attachments/' + attachment['id']
spoofed = {'X-User-Id': alice['id']}
client.call('GET', path, 404, actor=eve, headers=spoofed)
client.call('GET', path + '/content', 404, actor=eve, headers=spoofed)
own_chat = client.call('POST', '/api/v1/chats', 201, actor=eve,
body={'title': 'ACL probe', 'member_ids': [eve['id']]},
schema='Chat')['json']
client.call('POST', '/api/v1/chats/' + own_chat['id'] + '/messages', 404, actor=eve,
body={'text': '', 'attachment_ids': [attachment['id']]},
headers={'Idempotency-Key': uuid.uuid4().hex})
client.call('POST', '/api/v1/users', 413, raw=b' ' * 65537,
headers={'Content-Type': 'application/json'})
upload = '/api/v1/chats/' + chat['id'] + '/attachments?filename=oversize.png'
client.call('POST', upload, 413, actor=alice, raw=b'x' * (10 * 1024 * 1024 + 1),
headers={'Content-Type': 'image/png'})
client.call('DELETE', '/api/v1/auth/sessions/current', 204, actor=eve)
client.call('GET', '/api/v1/users/me', 401, actor=eve)
expire(alice)
client.call('GET', '/api/v1/users/me', 401, actor=alice)
authorization = 'Basic ' + base64.b64encode(b'unknown:synthetic-password').decode()
for _ in range(31):
response = client.call('POST', '/api/v1/auth/sessions', (401, 429),
headers={'Authorization': authorization})
if response['status'] == 429:
wait = int(response['headers'].get('Retry-After', '0'))
check(1 <= wait <= 60, 'invalid Retry-After')
break
else:
check(False, 'login limiter never returned 429')
print('PASS: hostname, attachment ACL/spoof, 413, logout, expired session, 429 and Retry-After')
if __name__ == '__main__':
run(main)
+117
View File
@@ -0,0 +1,117 @@
"""Operator probes run on the Docker backend network; never print credentials."""
from contextlib import contextmanager
import http.client
import os
from pathlib import Path
import socket
import ssl
from urllib.error import HTTPError
from botocore.exceptions import ClientError
import psycopg
from app.common import bucket, s3
from app.credentials import bao_request, login
def expect(condition, description):
if not condition:
raise SystemExit('FAIL: ' + description)
def context(identity=None):
tls = ssl.create_default_context(cafile=os.environ['LAB_CA'])
tls.maximum_version = ssl.TLSVersion.TLSv1_2
if identity:
path = Path('/run/probe') / identity
tls.load_cert_chain(path / 'client.crt', path / 'client.key')
return tls
def http_status(host, port, path, tls, method='GET', body=None):
connection = http.client.HTTPSConnection(host, port, context=tls, timeout=5)
try:
connection.request(method, path, body)
response = connection.getresponse()
response.read()
return response.status
finally:
connection.close()
def mtls():
for host in ('api1', 'api2'):
expect(http_status(host, 9443, '/health/ready', context('lb')) == 200, host + ' valid LB')
for identity in (None, 'foreign'):
try:
http_status(host, 9443, '/health/live', context(identity))
except ssl.SSLCertVerificationError:
raise SystemExit('FAIL: server identity could not be verified') from None
except ssl.SSLError:
continue
raise SystemExit('FAIL: missing or foreign client cert reached HTTP')
expect(http_status(host, 9443, '/health/live', context('api')) == 403,
host + ' wrong client identity')
try:
with socket.create_connection((host, 8080), timeout=3):
raise SystemExit('FAIL: direct API plaintext port is reachable')
except ConnectionRefusedError:
pass
print('PASS:', host, 'LB accepted, missing/foreign cert and wrong role denied, port 8080 closed')
@contextmanager
def denied(description, expected=(403,)):
try:
yield
except HTTPError as error:
expect(error.code in expected, description + ': unexpected status')
else:
raise SystemExit('FAIL: ' + description)
def secrets_access():
for role, foreign in [('api', 'worker'), ('worker', 'api')]:
with denied('wrong OpenBao certificate role', (400, 403)):
login(context(foreign), role)
tls = context(role)
token = login(tls, role)
result = bao_request('secret/data/' + role, tls, token=token)['data']['data']
with denied('OpenBao foreign path'):
bao_request('secret/data/' + foreign, tls, token=token)
with denied('OpenBao policy write'):
bao_request('sys/policies/acl/probe', tls, {'policy': ''}, token)
with psycopg.connect(result['DATABASE_URL']) as database:
encrypted = database.execute(
'SELECT ssl FROM pg_stat_ssl WHERE pid=pg_backend_pid()').fetchone()[0]
expect(encrypted, 'DB session encrypted')
if role == 'worker':
try:
database.execute('SELECT token_hash FROM sessions LIMIT 1')
except psycopg.errors.InsufficientPrivilege:
database.rollback()
else:
raise SystemExit('FAIL: worker read API sessions')
expected_prefix = 'final/' if role == 'api' else 'staging/'
try:
client = s3_with_role(result)
client.delete_object(Bucket=bucket(), Key=expected_prefix + '00000000-0000-0000-0000-000000000000')
except ClientError as exc:
expect(exc.response['ResponseMetadata']['HTTPStatusCode'] == 403, 'S3 delete rejected')
else:
raise SystemExit('FAIL: service can delete S3 object')
print('PASS: scoped OpenBao read for', role, '| foreign path/policy write denied | DB TLS | S3 delete denied')
expect(http_status('otel-collector', 9443, '/v1/traces', context(), 'POST', b'') == 403,
'unauthenticated telemetry ingest')
print('PASS: unauthenticated telemetry denied')
def s3_with_role(settings):
for variable in ('S3_ACCESS_KEY_ID', 'S3_SECRET_ACCESS_KEY'):
os.environ[variable] = settings[variable]
return s3()
if __name__ == '__main__':
mtls()
secrets_access()
+18
View File
@@ -0,0 +1,18 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
docker compose stop -t 2 api1 api2 worker
docker compose restart -t 5 postgres seaweed rabbitmq prometheus-db loki-db tempo-db grafana
# Unless the operator explicitly requests a seal/unseal exercise, OpenBao stays
# available for services to authenticate again during this business-data test.
if [ "${RESTART_OPENBAO:-0}" = 1 ]; then
docker compose restart -t 5 openbao
attempts=0
until curl --silent --cacert secrets/ca/ca.crt https://localhost:8200/v1/sys/seal-status >/dev/null; do
attempts=$((attempts+1))
[ "$attempts" -lt 15 ] || exit 1
sleep 1
done
python3 scripts/bao-operator.py unseal </dev/tty >/dev/tty 2>/dev/tty
fi
docker compose start api1 api2 worker
+6
View File
@@ -0,0 +1,6 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
python3 scripts/bootstrap.py
docker compose config --quiet
docker compose up -d --build
+7
View File
@@ -0,0 +1,7 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
case "${TARGET_INSTANCE_ID:-}" in
api1|api2) docker compose stop "$TARGET_INSTANCE_ID" ;;
*) exit 2 ;;
esac
+15 -15
View File
@@ -1,19 +1,19 @@
# Модель угроз — заполнить
# Модель угроз
## Активы и акторы
Стенд обрабатывает синтетические учётные записи, сообщения, вложения и телеметрию. Активы включают хеши паролей и сессий, содержимое чатов, исходные изображения, очередь заданий, закрытые ключи и токены OpenBao. Акторы — участник чата, посторонний пользователь, клиент без сессии, контейнер с сервисной identity и оператор Docker/OpenBao.
TODO: пользовательские credentials/сессии, сообщения/вложения, service identities, CA/secrets, telemetry. Акторы: участник чата, посторонний пользователь, внешний клиент, скомпрометированный сервис, оператор. Опишите доступ атакующего и границы учебного стенда.
Границы проходят между хостом и LB, LB и каждой API-репликой, приложением и зависимостями, оператором и административными интерфейсами. Доверенные участники — оператор хоста и процессы в одном сетевом namespace пары proxy/backend. Оператор Docker технически может читать монтируемые данные и память контейнеров. Компрометация хоста, ядра, CA и администратора OpenBao находится за границей этой модели.
## Границы доверия
| Угроза | Контроль | Воспроизведение |
| --- | --- | --- |
| Перехват логина, Bearer или содержимого | HTTPS с проверкой CA и SAN клиентом | Публичный TLS-тест и проверка IP вне SAN |
| Обход LB через прямой порт реплики | TLS требует клиентский сертификат. HAProxy допускает роль CN=lb. Uvicorn слушает только loopback | Внутренний probe проверяет обе реплики и порт 8080 |
| Чтение чужого чата или файла | Проверка членства при каждом доступе и привязка вложения к чату | Публичный smoke и внешний probe, в том числе подложный X-User-Id |
| Подбор паролей и утечка таблицы пользователей | Argon2id с индивидуальной солью и ограничение попыток по IP из доверенного LB | Замер Argon2id и внешний probe для 429/Retry-After |
| Повторное использование завершённой сессии | Непрозрачный токен, SHA-256 на стороне сервера, серверный expiry, удаление при logout | Внешний probe проверяет logout и перевод синтетической сессии в истёкшее состояние |
| Перегрузка oversized upload | Потоковый лимит 10 MiB для файла, 64 KiB для остальных endpoint, проверка формата и пикселей, лимит процессов и памяти | Публичный smoke и внешний probe проверяют 413/415 |
| Использование прав API из worker | Независимые DB/S3/OTel/OpenBao identities, RLS для вложений, отдельные права на очередь и S3-префиксы | Внутренний probe проверяет отказ чтения sessions, чужого KV, записи policy и удаления объекта |
| Подделка телеметрии посторонним сервисом | TLS и Basic ACL с отдельными identities на Collector/backends | Внутренний probe проверяет отказ записи без учётных данных |
| Утечка через Git, образы или SDK | Локально генерируемые файлы, allowlist build context, явная инструментализация только технических полей | git check-ignore, ревизия Dockerfile и app/telemetry.py |
TODO: схема и ссылка на заполненную contracts/trust-matrix.md; публичные/внутренние интерфейсы, процессы, секреты и их выдача.
| Угроза и конкретный путь | Нарушаемый инвариант | Контроль | Отрицательный тест | Остаточное ограничение |
| --- | --- | --- | --- | --- |
| TODO | TODO | TODO | TODO | TODO |
На 4 минимум 6 конкретных угроз. Не заменяйте сценарии словами «SQL injection», «безопасный Docker», «mTLS включён» без пути и проверки.
## Lifecycle и инциденты
TODO: bootstrap, expiry/renewal, revoke/rotation, компрометация identity, sealed OpenBao и восстановление. Указать владельца CA/unseal и способ защиты bootstrap credentials. Сопоставить scan findings с реальной применимостью и исправлением/остаточным риском.
Секреты зависимостей статичны в пределах учебного стенда. Токен OpenBao действует 120 секунд и используется при старте. До следующего рестарта service credentials находятся в памяти процесса и продолжают работать при кратковременной недоступности OpenBao. Оператор отвечает за отзы́в сертификата роли, замену рабочих credentials и рестарт приложения при компрометации. Контейнерный rate limiter использует IP источника на стороне LB. Docker Desktop может представлять несколько локальных клиентов общим IP.