From 8faf08d8eb27bcddca29682a3f06cecc3e904488 Mon Sep 17 00:00:00 2001 From: David Date: Mon, 9 Nov 2026 00:25:42 +0300 Subject: [PATCH] =?UTF-8?q?=D0=97=D0=B0=D1=84=D0=B8=D0=BA=D1=81=D0=B8?= =?UTF-8?q?=D1=80=D0=BE=D0=B2=D0=B0=D1=82=D1=8C=20=D0=BF=D1=80=D0=BE=D0=B2?= =?UTF-8?q?=D0=B5=D1=80=D0=BA=D0=B8=20=D1=83=D1=80=D0=BE=D0=B2=D0=BD=D1=8F?= =?UTF-8?q?=204=20=D0=B8=20=D0=BE=D1=82=D1=87=D1=91=D1=82.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Негативные загрузки, приватный bucket, очистка orphan и пик памяти при десяти одновременных upload лежат рядом с командами, которыми это воспроизводится. --- .github/pull_request_template.md | 28 +-- Makefile | 4 + REPORT.md | 87 +++++++-- evidence/grade4-api.txt | Bin 0 -> 1660 bytes evidence/grade4-infra.json | 17 ++ scripts/grade4_checks.py | 304 +++++++++++++++++++++++++++++++ scripts/grade4_infra.py | 231 +++++++++++++++++++++++ 7 files changed, 643 insertions(+), 28 deletions(-) create mode 100644 evidence/grade4-api.txt create mode 100644 evidence/grade4-infra.json create mode 100644 scripts/grade4_checks.py create mode 100644 scripts/grade4_infra.py diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md index 1bec5472..878aaa81 100644 --- a/.github/pull_request_template.md +++ b/.github/pull_request_template.md @@ -1,18 +1,18 @@ ## Лабораторная 4 -Автор / группа: TODO -Целевая оценка (3/4/5): TODO -Трек 5, если заявлен: TODO +Автор / группа: Булацев, БПИ2301 +Целевая оценка (3/4/5): 4 +Трек 5, если заявлен: нет -Что реализовано и что перенесено: TODO -Команды запуска из чистого clone: TODO -Результаты проверок и ссылка на REPORT.md: TODO -Ограничения / известные ошибки: TODO -Источники и использование ИИ: TODO +Что реализовано и что перенесено: стенд lab3 (Postgres, Redis, HAProxy, две реплики API, идемпотентность) и вложения lab4 в SeaweedFS. Метаданные в Postgres, байты в приватном bucket, ключ назначает сервер. +Команды запуска из чистого clone: `cp .env.example .env`, затем `docker compose --env-file .env up -d --build --scale api=2`. Подробности в REPORT.md. +Результаты проверок и ссылка на REPORT.md: smoke, persistence и failover прошли; негативные загрузки и orphan/память — в `evidence/`. См. REPORT.md. +Ограничения / известные ошибки: один Docker-хост; трек 5 не делался; образ MinIO на Docker Hub недоступен, используется SeaweedFS 3.85. +Источники и использование ИИ: контракт репозитория, документация SeaweedFS, boto3, Pillow. Код и прогон проверок — с помощью Cursor. -- [ ] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами. -- [ ] Контракт и публичные тесты не ослаблены. -- [ ] make check и make test выполнены; приложен реальный вывод. -- [ ] Сценарии отказов/безопасности своего уровня воспроизведены. -- [ ] Все секреты и приватные ключи находятся вне Git; отчёт не содержит tokens. -- [ ] README задания сохранён, REPORT.md содержит инструкцию именно моего решения. +- [x] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами. +- [x] Контракт и публичные тесты не ослаблены. +- [x] make check и make test выполнены; приложен реальный вывод. +- [x] Сценарии отказов/безопасности своего уровня воспроизведены. +- [x] Все секреты и приватные ключи находятся вне Git; отчёт не содержит tokens. +- [x] README задания сохранён, REPORT.md содержит инструкцию именно моего решения. diff --git a/Makefile b/Makefile index 5d86d171..89192443 100644 --- a/Makefile +++ b/Makefile @@ -28,3 +28,7 @@ test-persistence: test-failover: @test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable stop-one hook"; exit 2) $(PYTHON) tests/resilience.py --mode failover --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS) + +grade4: + $(PYTHON) scripts/grade4_checks.py + $(PYTHON) scripts/grade4_infra.py diff --git a/REPORT.md b/REPORT.md index 9ad2b84f..c6216d77 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,96 @@ # Отчёт — лабораторная 4 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор, группа: Булацев, БПИ2301 +- Целевая оценка; выбранный трек 5, если нужен: 4. Трек 5 не заявляется. +- Commit/PR: локальные коммиты после переноса lab3; PR не публиковался в этой сессии +- Использованные источники, библиотеки и помощь ИИ: контракт репозитория, документация SeaweedFS S3, boto3, Pillow. Реализация и прогон проверок сделаны с помощью Cursor. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Нужны Docker Compose v2 и Python 3.9+ на хосте. Образы закреплены: `python:3.12.8-slim-bookworm`, `postgres:16.6-alpine`, `redis:7.4.2-alpine`, `haproxy:2.8.14-alpine`, `chrislusf/seaweedfs:3.85` (`sha256:49312939c00c01e5ee6afbd7d728b18027821d3764c35a797a72acd4fdf3296a`). + +```sh +cp .env.example .env +# заменить синтетические пароли и S3-ключи в локальном .env; файл не коммитить +docker compose --env-file .env up -d --build --scale api=2 +``` + +`migrate` применяет SQL один раз. `s3-init` создаёт bucket, если его ещё нет, и при повторе только проверяет его. Порт снаружи один: `127.0.0.1:8080` у HAProxy. Реплики API, Postgres, Redis и SeaweedFS наружу не опубликованы. + +Готовность: `GET http://127.0.0.1:8080/health/ready` отвечает 200, когда доступны Postgres, Redis и bucket. Недоступный S3 даёт 503. + +```sh +python -X utf8 scripts/check_contract.py +python -X utf8 tests/smoke.py --base-url http://127.0.0.1:8080 +python -X utf8 tests/resilience.py --mode persistence --action-script scripts/restart.sh --base-url http://127.0.0.1:8080 +python -X utf8 tests/resilience.py --mode failover --action-script scripts/stop-one.sh --base-url http://127.0.0.1:8080 +python -X utf8 scripts/grade4_checks.py +python -X utf8 scripts/grade4_infra.py +``` + +Остановка без удаления данных: `docker compose --env-file .env stop`. Полное удаление учебных volumes: `docker compose --env-file .env down -v`. + +На Windows `*.sh` запускались через Git Bash: оболочка не умеет стартовать shell-скрипт как Win32-процесс. Сами `scripts/restart.sh` и `scripts/stop-one.sh` не менялись под Windows. ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab3, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +Клиент ходит только в HAProxy. Две реплики API без публичных портов читают общие Postgres, Redis и SeaweedFS. Из lab3 перенесены сессии в Redis с AOF, идемпотентность POST сообщения, drain по SIGTERM и миграции отдельным контейнером. В этой работе добавлены байты вложений. + +Источник истины для пользователей, чатов, сообщений и метаданных вложений — Postgres. Байты лежат в приватном bucket `messenger-attachments`, ключ назначает сервер: `originals/`. Имя файла только отображается. Публичный API не отдаёт ключ, адрес хранилища и credentials. + +`201` возвращается после PUT и COMMIT метаданных со `status=ready`. Если COMMIT не прошёл, процесс удаляет объект. Намерение пишется в `blob_writes` до PUT. Строки со `committed=false` старше `ORPHAN_GRACE_SECONDS` (120) снимает фоновый обход: свежий незаконченный upload не трогается, привязанный к сообщению объект не удаляется, потому что у него `committed=true`. Обрыв клиента до конца тела не создаёт объект: в bucket пишется уже проверенный буфер. + +Лимит 10 MiB смотрится по `Content-Length` до чтения тела и повторно по фактическому потоку. Число пикселей берётся из заголовка PNG/JPEG до `Pillow.verify()`. MIME сверяется с сигнатурой, а не с заявленным `Content-Type` в одиночку. + +`/health/ready` зависит от Postgres, Redis и `HeadBucket`. Сессии по-прежнему в Redis (`SESSION_STORE=redis`), не в Postgres. + +| Роль | Сервис | Образ | Проверка | Volume | Порт | +| --- | --- | --- | --- | --- | --- | +| api | api ×2 | сборка `mtusi-messenger:lab4` | `/health/ready` | нет | только внутри сети | +| postgres | postgres | `postgres:16.6-alpine` | `pg_isready` | `pg_data` | не опубликован | +| redis | redis | `redis:7.4.2-alpine` | `redis-cli ping` | `redis_data` | не опубликован | +| load_balancer | lb | `haproxy:2.8.14-alpine` | backend `/health/ready` | нет | `127.0.0.1:8080` | +| s3 | s3 | `chrislusf/seaweedfs:3.85` | master status и ответ порта 9000 | `s3_data` | не опубликован | + +Образ `minio/minio` в этом окружении с Docker Hub не скачивается, поэтому взято одно из разрешённых хранилищ — SeaweedFS. UI filer выключен. Анонимная identity без прав. Ключ API может читать, писать и администрировать только свой bucket; создание другого bucket отвечает `AccessDenied`. ## Доказательства критериев +Стенд: 12th Gen Intel Core i5-12450H, 16 ГБ RAM. Лимиты контейнера API: 0.50 CPU и 256 МиБ. + | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +| Публичный smoke | `python -X utf8 tests/smoke.py --base-url http://127.0.0.1:8080` | PASS, SHA-256 вложения совпал, посторонний получил 404 | вывод команды | +| Сохранность lab3 и пустой `attachment_ids` | тот же smoke и `scripts/grade4_checks.py` | текстовый POST остаётся 201, в истории `attachment_ids: []` | `evidence/grade4-api.txt` | +| Оригинал PNG и JPEG | `scripts/grade4_checks.py` | 201 ready, скачивание побайтно, без `Location` | `evidence/grade4-api.txt` | +| Опасное имя, подмена MIME, обрезка, пиксели, >10 МиБ | `scripts/grade4_checks.py` | 400 / 415 / 413, ни одного 500 | `evidence/grade4-api.txt` | +| Чужой чат и чужое вложение | `scripts/grade4_checks.py` | 404 и для метаданных, и для байтов | `evidence/grade4-api.txt` | +| Restart с volumes | `tests/resilience.py --mode persistence` через `scripts/restart.sh` | PASS: сессия, сообщение и исходный файл на месте | вывод команды | +| Остановка загрузившей реплики | `tests/resilience.py --mode failover` через `scripts/stop-one.sh` | 2 реплики до отказа; запись вернулась за 3.583 с; 105 успешных POST, 1 ошибка переходного периода; файл скачался снова | вывод команды | +| Приватный bucket вне API | `scripts/grade4_infra.py` | анонимный GET bucket — 403; порт 9000 не опубликован | `evidence/grade4-infra.json` | +| Ограниченные ключи | тот же скрипт | `create_bucket` другого имени — `AccessDenied` | `evidence/grade4-infra.json` | +| Компенсация orphan | тот же скрипт, grace 120 с | старый незакоммиченный объект удалён, свежий оставлен | `evidence/grade4-infra.json` | +| Память 10 загрузок | тот же скрипт, docker stats | 10×230778 байт, все 201, пик API 61.7 МиБ при лимите 256 | `evidence/grade4-infra.json` | -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +`Content-Length: 10485761` при коротком теле отвечает 413 до дочитывания заявленного размера. ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +Гипотеза уровня 4: десять одновременных загрузок около 230 КиБ не поднимают RSS реплики к лимиту 256 МиБ, потому что тело ограничено 10 МиБ и не декодируется целиком до проверки пикселей. Один прогон, без прогрева отдельной фазой. Это не профиль RPS сообщений. | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| `scripts/restart.sh` (postgres, redis, s3, api), volumes сохранены | те же сессия, сообщение и байты | PASS публичного persistence | готовность вернулась в пределах ожидания теста (90 с) | +| `scripts/stop-one.sh` одной реплики | другая реплика принимает POST и отдаёт тот же файл | recovery 3.583 с, дублей нет, вложение совпало | остановленная реплика сама не поднималась | +| Незакоммиченный объект старше grace | объект исчезает, свежий нет | удалена 1 старая запись, свежая осталась | без потери ready-вложений | +| Анонимный S3 GET | отказ | 403 | — | ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +Один Docker-хост. Отказ машины гасит и API, и Postgres, и SeaweedFS. Несколько реплик API этого не лечат. + +Скачивание и загрузка держат в памяти процесса не больше лимита 10 МиБ плюс проверку Pillow. Это граница, а не потоковая отдача клиенту минуя буфер. Эксперимент памяти сделан на файлах ~226 КиБ, не на десяти одновременных файлах по 10 МиБ. + +Окно между PUT и COMMIT закрывается немедленным удалением при ошибке и обходом раз в 30 с. Объект, умерший внутри grace 120 с, временно занимает место. Прямой presigned upload и отдельный reconciler всего bucket не делались: это трек 5. + +Случайный ключ и закрытый bucket не заменяют проверку участника чата: скачивание идёт через API и для постороннего даёт 404, даже если он угадает UUID. diff --git a/evidence/grade4-api.txt b/evidence/grade4-api.txt new file mode 100644 index 0000000000000000000000000000000000000000..68a4692681fd4e5ea339ed9f01deba6f88a0951d GIT binary patch literal 1660 zcmb7_Z%)EM5XI-SiFeow7(wv>`rX9D6O{6=(o)hEh0CkIw+lhawy7b;?K1Dp%$qmm z=lji`?VXRa%I3DT%xY^mRoo<&^PKYJ?7>Dhwp+WgGa|RrBQ^tKui2-drvsS#;;vce z_Bp8DzPQwDk$4>({jX4>>8SKFwj^$KRIeW=jrX3l;8gQT(6USEt!?<$+0M4iq$GCM zQIFUPbPW@n5&H%95;JPe@dH-PehB{pN906rs6n|L{F(3C(L>H{jRMXl_@$kv51Ufy z2A+!lIryMn1z*Z-=qAQ_Qf6ugA6J8&5uf^6<~(Opa>kZsuo@aPvR> zJ<|(53cAJdn(~^zup3gd@mb|LRUpNsnH&(yf7xN?<4a@6_hF;8muvX-JMs%0 Cqyvip literal 0 HcmV?d00001 diff --git a/evidence/grade4-infra.json b/evidence/grade4-infra.json new file mode 100644 index 00000000..5537af22 --- /dev/null +++ b/evidence/grade4-infra.json @@ -0,0 +1,17 @@ +{ + "anonymous_bucket_status": "403", + "second_bucket": "AccessDenied", + "sweep": { + "deleted": 1, + "old_removed": true, + "fresh_kept": true + }, + "s3_port_published": false, + "memory": { + "uploads": 10, + "bytes_each": 230778, + "success": 10, + "peak_api_mib": 61.7, + "samples": 8 + } +} diff --git a/scripts/grade4_checks.py b/scripts/grade4_checks.py new file mode 100644 index 00000000..5789b101 --- /dev/null +++ b/scripts/grade4_checks.py @@ -0,0 +1,304 @@ +#!/usr/bin/env python3 +"""Negative attachment cases. Prints statuses only, never tokens.""" + +import base64 +import hashlib +import json +import socket +import struct +import uuid +import urllib.error +import urllib.request +import zlib +from pathlib import Path + +BASE = "http://127.0.0.1:8080" +ROOT = Path(__file__).resolve().parents[1] +JPEG = base64.b64decode( + "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAYEBQYFBAYGBQYHBwYIChAKCgkJChQODwwQFxQYGBcUFhYaHSUfGhsjHBYWICwgIyYnKSopGR8tMC0oMCUoKSj/2wBDAQcHBwoIChMKChMoGhYaKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCj/wAARCAAIAAgDASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD5soooroMD/9k=" +) + + +def header_only_png(width: int, height: int) -> bytes: + signature = b"\x89PNG\r\n\x1a\n" + + def chunk(kind: bytes, data: bytes) -> bytes: + return struct.pack(">I", len(data)) + kind + data + struct.pack(">I", zlib.crc32(kind + data) & 0xFFFFFFFF) + + ihdr = struct.pack(">IIBBBBB", width, height, 8, 2, 0, 0, 0) + return signature + chunk(b"IHDR", ihdr) + chunk(b"IEND", b"") + + +def png(width: int, height: int) -> bytes: + signature = b"\x89PNG\r\n\x1a\n" + + def chunk(kind: bytes, data: bytes) -> bytes: + return struct.pack(">I", len(data)) + kind + data + struct.pack(">I", zlib.crc32(kind + data) & 0xFFFFFFFF) + + ihdr = struct.pack(">IIBBBBB", width, height, 8, 2, 0, 0, 0) + raw = b"".join(b"\x00" + (b"\x10\x20\x30" * width) for _ in range(height)) + return signature + chunk(b"IHDR", ihdr) + chunk(b"IDAT", zlib.compress(raw)) + chunk(b"IEND", b"") + + +class Api: + def __init__(self) -> None: + self.opener = urllib.request.build_opener(urllib.request.ProxyHandler({})) + + def call(self, method, path, body=None, token=None, headers=None, raw=None, content_type=None): + hdrs = {} + data = raw + if body is not None: + data = json.dumps(body).encode("utf-8") + hdrs["Content-Type"] = "application/json" + if content_type: + hdrs["Content-Type"] = content_type + if token: + hdrs["Authorization"] = "Bearer " + token + if headers: + hdrs.update(headers) + request = urllib.request.Request(BASE + path, data=data, headers=hdrs, method=method) + try: + response = self.opener.open(request, timeout=30) + except urllib.error.HTTPError as error: + response = error + with response: + payload = response.read() + parsed = None + if payload and response.headers.get_content_type() == "application/json": + parsed = json.loads(payload) + return response.status, response.headers, parsed, payload + + +def expect(status, got, label): + if got == 500: + raise SystemExit("FAIL %s returned 500" % label) + if got != status: + raise SystemExit("FAIL %s expected %s got %s" % (label, status, got)) + print("PASS", label, got) + + +def user(api: Api, label: str): + username = "g4_" + label + "_" + uuid.uuid4().hex[:10] + password = "T3st-" + uuid.uuid4().hex + status, _, body, _ = api.call( + "POST", + "/api/v1/users", + {"username": username, "display_name": "Grade " + label, "password": password}, + ) + expect(201, status, "register " + label) + basic = base64.b64encode((username + ":" + password).encode()).decode() + status, _, session, _ = api.call("POST", "/api/v1/auth/sessions", headers={"Authorization": "Basic " + basic}) + expect(201, status, "login " + label) + return body["id"], session["token"] + + +def declared_length(token, chat_id): + request = ( + "POST /api/v1/chats/%s/attachments?filename=big.png HTTP/1.1\r\n" + "Host: 127.0.0.1:8080\r\n" + "Authorization: Bearer %s\r\n" + "Content-Type: image/png\r\n" + "Content-Length: 10485761\r\n" + "Connection: close\r\n\r\n" % (chat_id, token) + ).encode() + b"\x89PNG" + sock = socket.create_connection(("127.0.0.1", 8080), timeout=5) + try: + sock.sendall(request) + data = b"" + while b"\r\n" not in data: + chunk = sock.recv(256) + if not chunk: + break + data += chunk + finally: + sock.close() + line = data.split(b"\r\n", 1)[0].decode("latin1", "replace") + code = int(line.split()[1]) + expect(413, code, "content-length above 10MiB before body is read") + + +def main(): + api = Api() + alice, alice_token = user(api, "alice") + bob, bob_token = user(api, "bob") + eve, eve_token = user(api, "eve") + status, _, chat, _ = api.call( + "POST", + "/api/v1/chats", + {"title": "grade4", "member_ids": [alice, bob]}, + token=alice_token, + ) + expect(201, status, "create chat") + chat_id = chat["id"] + status, _, other, _ = api.call( + "POST", + "/api/v1/chats", + {"title": "other", "member_ids": [alice, eve]}, + token=alice_token, + ) + expect(201, status, "create other chat") + + status, _, message, _ = api.call( + "POST", + "/api/v1/chats/%s/messages" % chat_id, + {"text": "только текст"}, + token=alice_token, + headers={"Idempotency-Key": uuid.uuid4().hex}, + ) + expect(201, status, "text message") + if message["attachment_ids"] != []: + raise SystemExit("FAIL text message lost empty attachment_ids") + + good = png(32, 32) + status, _, attachment, _ = api.call( + "POST", + "/api/v1/chats/%s/attachments?filename=ok.png" % chat_id, + token=alice_token, + raw=good, + content_type="image/png", + ) + expect(201, status, "png upload") + if attachment["sha256"] != hashlib.sha256(good).hexdigest() or attachment["status"] != "ready": + raise SystemExit("FAIL png metadata") + status, headers, _, downloaded = api.call( + "GET", + "/api/v1/attachments/%s/content" % attachment["id"], + token=bob_token, + ) + expect(200, status, "member download") + if downloaded != good or headers.get_content_type() != "image/png": + raise SystemExit("FAIL download bytes") + if headers.get("Location"): + raise SystemExit("FAIL download redirected") + + status, _, jpeg_meta, _ = api.call( + "POST", + "/api/v1/chats/%s/attachments?filename=ok.jpg" % chat_id, + token=alice_token, + raw=JPEG, + content_type="image/jpeg", + ) + expect(201, status, "jpeg upload") + if jpeg_meta["content_type"] != "image/jpeg" or jpeg_meta["sha256"] != hashlib.sha256(JPEG).hexdigest(): + raise SystemExit("FAIL jpeg metadata") + + status, _, _, _ = api.call( + "POST", + "/api/v1/chats/%s/attachments?filename=a/b.png" % chat_id, + token=alice_token, + raw=good, + content_type="image/png", + ) + expect(400, status, "filename with slash") + status, _, _, _ = api.call( + "POST", + "/api/v1/chats/%s/attachments?filename=%s" % (chat_id, "bad%0Aname.png"), + token=alice_token, + raw=good, + content_type="image/png", + ) + expect(400, status, "filename with control character") + + status, _, _, _ = api.call( + "POST", + "/api/v1/chats/%s/attachments?filename=lie.png" % chat_id, + token=alice_token, + raw=good, + content_type="image/jpeg", + ) + expect(415, status, "png bytes declared as jpeg") + status, _, _, _ = api.call( + "POST", + "/api/v1/chats/%s/attachments?filename=cut.png" % chat_id, + token=alice_token, + raw=b"\x89PNG\r\n\x1a\ntruncated", + content_type="image/png", + ) + expect(415, status, "truncated png") + status, _, _, _ = api.call( + "POST", + "/api/v1/chats/%s/attachments?filename=cut.jpg" % chat_id, + token=alice_token, + raw=JPEG[:-40], + content_type="image/jpeg", + ) + expect(415, status, "truncated jpeg") + status, _, _, _ = api.call( + "POST", + "/api/v1/chats/%s/attachments?filename=huge.png" % chat_id, + token=alice_token, + raw=header_only_png(10000, 5000), + content_type="image/png", + ) + expect(413, status, "pixel limit") + declared_length(alice_token, chat_id) + status, _, _, _ = api.call( + "POST", + "/api/v1/chats/%s/attachments?filename=big.png" % chat_id, + token=alice_token, + raw=b"\x89PNG" + b"\x00" * (10_485_760), + content_type="image/png", + ) + expect(413, status, "body above 10MiB") + + status, _, _, _ = api.call( + "POST", + "/api/v1/chats/%s/attachments?filename=nope.png" % chat_id, + token=eve_token, + raw=good, + content_type="image/png", + ) + expect(404, status, "outsider upload") + for suffix in ("", "/content"): + status, _, _, _ = api.call("GET", "/api/v1/attachments/%s%s" % (attachment["id"], suffix), token=eve_token) + expect(404, status, "outsider get " + (suffix or "metadata")) + + missing = str(uuid.uuid4()) + status, _, _, _ = api.call( + "POST", + "/api/v1/chats/%s/messages" % chat_id, + {"text": "", "attachment_ids": [missing]}, + token=alice_token, + headers={"Idempotency-Key": uuid.uuid4().hex}, + ) + expect(404, status, "unknown attachment id") + status, _, foreign, _ = api.call( + "POST", + "/api/v1/chats/%s/attachments?filename=other.png" % other["id"], + token=alice_token, + raw=good, + content_type="image/png", + ) + expect(201, status, "upload into other chat") + status, _, _, _ = api.call( + "POST", + "/api/v1/chats/%s/messages" % chat_id, + {"text": "", "attachment_ids": [foreign["id"]]}, + token=alice_token, + headers={"Idempotency-Key": uuid.uuid4().hex}, + ) + expect(404, status, "attachment from another chat") + ids = [str(uuid.uuid4()) for _ in range(11)] + status, _, _, _ = api.call( + "POST", + "/api/v1/chats/%s/messages" % chat_id, + {"text": "x", "attachment_ids": ids}, + token=alice_token, + headers={"Idempotency-Key": uuid.uuid4().hex}, + ) + expect(400, status, "more than 10 attachment ids") + status, _, linked, _ = api.call( + "POST", + "/api/v1/chats/%s/messages" % chat_id, + {"text": "", "attachment_ids": [attachment["id"]]}, + token=bob_token, + headers={"Idempotency-Key": uuid.uuid4().hex}, + ) + expect(201, status, "message with attachment") + if linked["attachment_ids"] != [attachment["id"]] or linked["text"] != "": + raise SystemExit("FAIL linked message") + print("PASS grade4 api checks") + + +if __name__ == "__main__": + main() diff --git a/scripts/grade4_infra.py b/scripts/grade4_infra.py new file mode 100644 index 00000000..2c403a34 --- /dev/null +++ b/scripts/grade4_infra.py @@ -0,0 +1,231 @@ +#!/usr/bin/env python3 +"""Private bucket, orphan grace, and a bounded concurrent-upload memory sample.""" + +import json +import subprocess +import threading +import time +import urllib.request +import uuid +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +OUT = ROOT / "evidence" / "grade4-infra.json" + + +def compose(*args, input_text=None): + result = subprocess.run( + ["docker", "compose", "--env-file", ".env", *args], + cwd=ROOT, + input=input_text, + text=True, + capture_output=True, + ) + if result.returncode != 0: + raise SystemExit(result.stderr[-500:] or result.stdout[-500:] or "compose failed") + return result.stdout + + +def anonymous_status(): + script = r""" +code=$(wget -S -O /dev/null http://127.0.0.1:9000/messenger-attachments/ 2>&1 | awk 'BEGIN{c=""} /^[[:space:]]*HTTP\//{c=$2} END{print c}') +printf '%s' "$code" +""" + output = compose("exec", "-T", "s3", "sh", "-c", script).strip() + if output != "403": + raise SystemExit("anonymous bucket status %s" % output) + return output + + +def other_bucket_denied(): + code = r""" +import os +import boto3 +from botocore.client import Config +from botocore.exceptions import ClientError +client = boto3.client( + "s3", + endpoint_url=os.environ["S3_ENDPOINT"], + aws_access_key_id=os.environ["S3_ACCESS_KEY_ID"], + aws_secret_access_key=os.environ["S3_SECRET_ACCESS_KEY"], + region_name=os.environ.get("S3_REGION", "us-east-1"), + config=Config(signature_version="s3v4", s3={"addressing_style": "path"}), +) +try: + client.create_bucket(Bucket="not-the-messenger-bucket") + print("allowed") +except ClientError as exc: + print(exc.response.get("Error", {}).get("Code", "denied")) +""" + output = compose("exec", "-T", "api", "python", "-c", code).strip() + if output == "allowed": + raise SystemExit("app credentials created a second bucket") + return output + + +def plant_and_sweep(): + code = r""" +import asyncio +from datetime import datetime, timedelta, timezone +from app import config, db, s3 + +async def main(): + await db.connect() + old_key = "originals/orphan-evidence" + fresh_key = "originals/fresh-evidence" + payload = b"not-a-real-image" + await s3.put_bytes(old_key, payload, "application/octet-stream") + await s3.put_bytes(fresh_key, payload, "application/octet-stream") + old = datetime.now(timezone.utc) - timedelta(seconds=config.ORPHAN_GRACE_SECONDS + 60) + fresh = datetime.now(timezone.utc) + async with db.require().acquire() as conn: + await conn.execute("DELETE FROM blob_writes WHERE object_key = ANY($1::text[])", [old_key, fresh_key]) + await conn.execute( + "INSERT INTO blob_writes (object_key, committed, created_at) VALUES ($1, FALSE, $2), ($3, FALSE, $4)", + old_key, old, fresh_key, fresh, + ) + from app.attachments import sweep_orphans + deleted = await sweep_orphans() + async def exists(key): + try: + await s3.get_bytes(key) + return True + except Exception: + return False + print("%s %s %s" % (deleted, int(await exists(old_key)), int(await exists(fresh_key)))) + await s3.delete_key(fresh_key) + async with db.require().acquire() as conn: + await conn.execute("DELETE FROM blob_writes WHERE object_key = $1 AND NOT committed", fresh_key) + await db.close() + +asyncio.run(main()) +""" + output = compose("exec", "-T", "api", "python", "-c", code).strip().split() + deleted, old_exists, fresh_exists = int(output[0]), int(output[1]), int(output[2]) + if deleted < 1 or old_exists != 0 or fresh_exists != 1: + raise SystemExit("sweep result deleted=%s old=%s fresh=%s" % (deleted, old_exists, fresh_exists)) + return {"deleted": deleted, "old_removed": True, "fresh_kept": True} + + +def memory_sample(): + import base64 + + username = "mem_" + uuid.uuid4().hex[:10] + password = "T3st-" + uuid.uuid4().hex + body = json.dumps({"username": username, "display_name": "Mem", "password": password}).encode() + + def call(method, path, data=None, headers=None): + request = urllib.request.Request("http://127.0.0.1:8080" + path, data=data, headers=headers or {}, method=method) + try: + response = urllib.request.urlopen(request, timeout=60) + except urllib.error.HTTPError as error: + response = error + with response: + return response.status, response.read() + + status, raw = call("POST", "/api/v1/users", body, {"Content-Type": "application/json"}) + if status != 201: + raise SystemExit("memory user %s" % status) + user = json.loads(raw) + basic = base64.b64encode((username + ":" + password).encode()).decode() + status, raw = call("POST", "/api/v1/auth/sessions", headers={"Authorization": "Basic " + basic}) + if status != 201: + raise SystemExit("memory login %s" % status) + token = json.loads(raw)["token"] + status, raw = call( + "POST", + "/api/v1/chats", + json.dumps({"title": "mem", "member_ids": [user["id"]]}).encode(), + {"Content-Type": "application/json", "Authorization": "Bearer " + token}, + ) + if status != 201: + raise SystemExit("memory chat %s" % status) + chat_id = json.loads(raw)["id"] + import os + import struct + import zlib + + def png(): + signature = b"\x89PNG\r\n\x1a\n" + + def chunk(kind, data): + return struct.pack(">I", len(data)) + kind + data + struct.pack(">I", zlib.crc32(kind + data) & 0xFFFFFFFF) + + width, height = 320, 240 + ihdr = struct.pack(">IIBBBBB", width, height, 8, 2, 0, 0, 0) + raw_rows = b"".join(b"\x00" + os.urandom(width * 3) for _ in range(height)) + return signature + chunk(b"IHDR", ihdr) + chunk(b"IDAT", zlib.compress(raw_rows, 1)) + chunk(b"IEND", b"") + + blob = png() + codes = [] + + def upload(): + status, _ = call( + "POST", + "/api/v1/chats/%s/attachments?filename=m.png" % chat_id, + blob, + {"Content-Type": "image/png", "Authorization": "Bearer " + token}, + ) + codes.append(status) + + samples = [] + + def watch(): + end = time.monotonic() + 8 + while time.monotonic() < end: + stats = subprocess.run( + ["docker", "stats", "--no-stream", "--format", "{{.Name}} {{.MemUsage}}"], + capture_output=True, + text=True, + check=False, + ) + for line in stats.stdout.splitlines(): + if "mtusi2026lab4-api-" in line: + samples.append(line.strip()) + time.sleep(0.4) + + watcher = threading.Thread(target=watch) + watcher.start() + threads = [threading.Thread(target=upload) for _ in range(10)] + for thread in threads: + thread.start() + for thread in threads: + thread.join() + watcher.join() + if codes.count(201) != 10: + raise SystemExit("concurrent uploads %s" % codes) + + def mib(line): + value = line.split()[1] + number = float(value[:-3]) if value.lower().endswith("mib") else float(value[:-3]) / 1024 + return number + + peak = max(mib(line) for line in samples) if samples else 0 + return {"uploads": 10, "bytes_each": len(blob), "success": 10, "peak_api_mib": round(peak, 1), "samples": len(samples)} + + +def main(): + published = subprocess.run( + ["docker", "compose", "--env-file", ".env", "port", "s3", "9000"], + cwd=ROOT, + capture_output=True, + text=True, + ) + if published.returncode == 0 and published.stdout.strip(): + raise SystemExit("s3 port is published: " + published.stdout.strip()) + summary = { + "anonymous_bucket_status": anonymous_status(), + "second_bucket": other_bucket_denied(), + "sweep": plant_and_sweep(), + "s3_port_published": False, + "memory": memory_sample(), + } + OUT.parent.mkdir(exist_ok=True) + OUT.write_text(json.dumps(summary, indent=2) + "\n", encoding="utf-8") + print(json.dumps(summary, indent=2)) + + +if __name__ == "__main__": + import urllib.error + + main()