This commit is contained in:
+5
-20
@@ -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
@@ -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
|
||||
|
||||
@@ -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 и контекста сборки.
|
||||
|
||||
Источники и помощь при реализации перечислены в отчёте.
|
||||
|
||||
@@ -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-*/
|
||||
|
||||
@@ -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"]
|
||||
@@ -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.
|
||||
|
||||
+387
@@ -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
@@ -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)}
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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
@@ -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
@@ -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
@@ -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).
|
||||
|
||||
@@ -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
|
||||
@@ -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"
|
||||
}
|
||||
]
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -0,0 +1,3 @@
|
||||
path "secret/data/api" {
|
||||
capabilities = ["read"]
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -0,0 +1,3 @@
|
||||
path "secret/data/worker" {
|
||||
capabilities = ["read"]
|
||||
}
|
||||
@@ -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]
|
||||
Executable
+10
@@ -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
|
||||
@@ -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 "$@"
|
||||
@@ -0,0 +1,2 @@
|
||||
local all all trust
|
||||
hostssl messenger api,worker all scram-sha-256
|
||||
@@ -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;
|
||||
@@ -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']
|
||||
@@ -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
|
||||
@@ -0,0 +1,3 @@
|
||||
[leveldb2]
|
||||
enabled = true
|
||||
dir = "/data/filer"
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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()
|
||||
@@ -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')
|
||||
@@ -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()
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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()
|
||||
Executable
+18
@@ -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
|
||||
Executable
+6
@@ -0,0 +1,6 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
python3 scripts/bootstrap.py
|
||||
docker compose config --quiet
|
||||
docker compose up -d --build
|
||||
Executable
+7
@@ -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
@@ -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.
|
||||
|
||||
Reference in New Issue
Block a user