forked from mtusi2026/mtusi2026lab5
Скопировано из mtusi2026lab4 (ветка solution/bvt2302-bodanyuk, commit 17c33cd) через git archive: исходники, миграции, собственные тесты, Dockerfile, compose, конфигурации infra/, скрипты и bench/. README, COURSE, contracts/, tests/ и отчёт lab4 не копировались. Makefile и .env.example — версии lab4 (skeleton-часть совпадает с lab5, строки broker добавляются в следующих коммитах). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
200 lines
9.1 KiB
Python
200 lines
9.1 KiB
Python
"""Strict request validation according to contracts/openapi.json + contracts/README.md.
|
||
|
||
Written by hand instead of a schema library so that every rule is visible:
|
||
extra fields, wrong JSON types, whitespace-only strings and lengths counted in
|
||
Unicode code points all produce 400 invalid_request.
|
||
"""
|
||
from __future__ import annotations
|
||
|
||
import json
|
||
import re
|
||
import unicodedata
|
||
from typing import Any
|
||
from urllib.parse import parse_qsl
|
||
|
||
from .errors import InvalidRequest
|
||
|
||
USERNAME_RE = re.compile(r"[a-z0-9_]{3,32}")
|
||
# Canonical textual UUID (8-4-4-4-12 hex). Case-insensitive, normalised to lower case.
|
||
UUID_RE = re.compile(r"[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}")
|
||
LIMIT_RE = re.compile(r"[0-9]{1,3}")
|
||
# Idempotency-Key (contract, lab 3): ASCII [A-Za-z0-9._:-]{1,128}.
|
||
IDEMPOTENCY_KEY_RE = re.compile(r"[A-Za-z0-9._:-]{1,128}")
|
||
SURROGATES_RE = re.compile("[\ud800-\udfff]")
|
||
|
||
DEFAULT_LIMIT = 50
|
||
MAX_LIMIT = 100
|
||
|
||
|
||
def _reject_constant(name: str) -> Any:
|
||
# Python's json accepts NaN/Infinity, which are not valid JSON.
|
||
raise ValueError(f"invalid JSON constant {name}")
|
||
|
||
|
||
def _unique_keys(pairs: list[tuple[str, Any]]) -> dict[str, Any]:
|
||
# {"text":"a","text":"b"} is ambiguous (which one is meant?) -> 400, not "last one wins".
|
||
result = dict(pairs)
|
||
if len(result) != len(pairs):
|
||
raise ValueError("duplicate key in JSON object")
|
||
return result
|
||
|
||
|
||
def parse_json_object(body: bytes) -> dict[str, Any]:
|
||
"""Decode a UTF-8 JSON object or raise InvalidRequest (malformed JSON -> 400)."""
|
||
try:
|
||
text = body.decode("utf-8")
|
||
value = json.loads(text, parse_constant=_reject_constant, object_pairs_hook=_unique_keys)
|
||
except (UnicodeDecodeError, ValueError):
|
||
raise InvalidRequest("Тело запроса должно быть корректным JSON в UTF-8") from None
|
||
if not isinstance(value, dict):
|
||
raise InvalidRequest("Тело запроса должно быть JSON-объектом")
|
||
return value
|
||
|
||
|
||
def check_fields(data: dict[str, Any], required: set[str], optional: frozenset[str] = frozenset()) -> None:
|
||
extra = set(data) - required - optional
|
||
if extra:
|
||
raise InvalidRequest("Неизвестные поля: " + ", ".join(sorted(extra)))
|
||
missing = required - set(data)
|
||
if missing:
|
||
raise InvalidRequest("Отсутствуют обязательные поля: " + ", ".join(sorted(missing)))
|
||
|
||
|
||
def text_field(data: dict[str, Any], name: str, max_len: int, *, min_len: int = 1, allow_blank: bool = False) -> str:
|
||
value = data[name]
|
||
if not isinstance(value, str):
|
||
raise InvalidRequest(f"Поле {name} должно быть строкой")
|
||
if SURROGATES_RE.search(value):
|
||
# "\ud800" escapes decode to lone surrogates that cannot be encoded as UTF-8.
|
||
raise InvalidRequest(f"Поле {name} содержит недопустимые символы")
|
||
# len() of a Python str is the number of Unicode code points, as the contract requires.
|
||
if not min_len <= len(value) <= max_len:
|
||
raise InvalidRequest(f"Длина поля {name} должна быть от {min_len} до {max_len} символов")
|
||
if value.strip() == "" and not allow_blank:
|
||
raise InvalidRequest(f"Поле {name} не может состоять только из пробелов")
|
||
return value
|
||
|
||
|
||
def username_field(data: dict[str, Any]) -> str:
|
||
value = data["username"]
|
||
if not isinstance(value, str) or USERNAME_RE.fullmatch(value) is None:
|
||
raise InvalidRequest("username должен соответствовать [a-z0-9_]{3,32}")
|
||
return value
|
||
|
||
|
||
def password_field(data: dict[str, Any]) -> str:
|
||
"""12-128 Unicode code points, not whitespace-only; any other character (':' too) is allowed."""
|
||
value = data["password"]
|
||
if not isinstance(value, str):
|
||
raise InvalidRequest("Поле password должно быть строкой")
|
||
if SURROGATES_RE.search(value):
|
||
raise InvalidRequest("Поле password содержит недопустимые символы")
|
||
if not 12 <= len(value) <= 128:
|
||
raise InvalidRequest("Длина пароля должна быть от 12 до 128 символов")
|
||
if value.strip() == "":
|
||
raise InvalidRequest("Пароль не может состоять только из пробелов")
|
||
return value
|
||
|
||
|
||
def parse_uuid(value: Any, what: str = "UUID") -> str:
|
||
if not isinstance(value, str) or UUID_RE.fullmatch(value) is None:
|
||
raise InvalidRequest(f"Неверный {what}")
|
||
return value.lower()
|
||
|
||
|
||
def member_ids_field(data: dict[str, Any]) -> list[str]:
|
||
value = data["member_ids"]
|
||
if not isinstance(value, list):
|
||
raise InvalidRequest("member_ids должен быть массивом")
|
||
if not 1 <= len(value) <= 100:
|
||
raise InvalidRequest("member_ids должен содержать от 1 до 100 элементов")
|
||
ids = [parse_uuid(item, "UUID участника") for item in value]
|
||
if len(set(ids)) != len(ids):
|
||
raise InvalidRequest("member_ids содержит дубликаты")
|
||
return ids
|
||
|
||
|
||
def attachment_ids_field(data: dict[str, Any]) -> list[str]:
|
||
"""Optional `attachment_ids` (lab 4+): absent and [] are the same message (contracts/README.md);
|
||
null or any other non-array type is 400."""
|
||
value = data.get("attachment_ids", [])
|
||
if not isinstance(value, list):
|
||
raise InvalidRequest("attachment_ids должен быть массивом")
|
||
if len(value) > 10:
|
||
raise InvalidRequest("attachment_ids содержит больше 10 элементов")
|
||
ids = [parse_uuid(item, "UUID вложения") for item in value]
|
||
if len(set(ids)) != len(ids):
|
||
raise InvalidRequest("attachment_ids содержит дубликаты")
|
||
return ids
|
||
|
||
|
||
def idempotency_key(raw: str | None) -> str:
|
||
if raw is None or IDEMPOTENCY_KEY_RE.fullmatch(raw) is None:
|
||
raise InvalidRequest("Заголовок Idempotency-Key обязателен: [A-Za-z0-9._:-]{1,128}")
|
||
return raw
|
||
|
||
|
||
def single_query_param(query: list[tuple[str, str]], name: str) -> str | None:
|
||
values = [v for k, v in query if k == name]
|
||
if len(values) > 1:
|
||
raise InvalidRequest(f"Параметр {name} указан несколько раз")
|
||
return values[0] if values else None
|
||
|
||
|
||
def parse_limit(raw: str | None) -> int:
|
||
if raw is None:
|
||
return DEFAULT_LIMIT
|
||
if LIMIT_RE.fullmatch(raw) is None or not 1 <= int(raw) <= MAX_LIMIT:
|
||
raise InvalidRequest(f"limit должен быть целым числом от 1 до {MAX_LIMIT}")
|
||
return int(raw)
|
||
|
||
|
||
# Lab 4: the display name of an attachment. Never used as a path or an S3 key, but it is shown
|
||
# to other users, so characters that change how a name LOOKS are refused: control characters
|
||
# (C0, DEL, C1 such as U+0085), line/paragraph separators, unpaired surrogates and bidi controls
|
||
# ("photo<U+202E>gnp.exe" would display as "photoexe.png").
|
||
BIDI_CONTROLS = frozenset("\u061c\u200e\u200f\u202a\u202b\u202c\u202d\u202e\u2066\u2067\u2068\u2069")
|
||
FORBIDDEN_CATEGORIES = frozenset({"Cc", "Cs", "Zl", "Zp"})
|
||
|
||
|
||
def query_items(raw: bytes) -> list[tuple[str, str]]:
|
||
"""Strict query parsing: percent-encoded UTF-8 only (Starlette would replace bad bytes by U+FFFD)."""
|
||
try:
|
||
return parse_qsl(raw.decode("ascii"), keep_blank_values=True, encoding="utf-8", errors="strict")
|
||
except (UnicodeDecodeError, ValueError):
|
||
raise InvalidRequest("Параметры запроса должны быть в UTF-8 с percent-encoding") from None
|
||
|
||
|
||
def filename_param(query: list[tuple[str, str]]) -> str:
|
||
value = single_query_param(query, "filename")
|
||
if value is None:
|
||
raise InvalidRequest("Параметр filename обязателен")
|
||
if not 1 <= len(value) <= 255:
|
||
raise InvalidRequest("Длина filename должна быть от 1 до 255 символов")
|
||
if value.strip() == "" or value in {".", ".."}:
|
||
raise InvalidRequest("filename не может состоять только из пробелов или точек")
|
||
if "/" in value or "\\" in value:
|
||
raise InvalidRequest("filename не может содержать / или \\")
|
||
for char in value:
|
||
if unicodedata.category(char) in FORBIDDEN_CATEGORIES or char in BIDI_CONTROLS:
|
||
raise InvalidRequest("filename содержит управляющие символы")
|
||
return value
|
||
|
||
|
||
ATTACHMENT_VARIANTS = frozenset({"thumbnail", "crop", "optimized"}) # exist in the schema, not in lab 4
|
||
|
||
|
||
def variant_param(query: list[tuple[str, str]]) -> str:
|
||
"""`variant` of GET /attachments/{id}/content: only `original` exists in lab 4. A known variant
|
||
name is a missing variant of a ready object (404); anything else is an invalid value (400)."""
|
||
value = single_query_param(query, "variant")
|
||
if value is None or value == "original":
|
||
return "original"
|
||
if value in ATTACHMENT_VARIANTS:
|
||
raise NotFoundVariant()
|
||
raise InvalidRequest("variant должен быть original")
|
||
|
||
|
||
class NotFoundVariant(Exception):
|
||
"""Raised for a variant that lab 4 does not produce; mapped to 404 by the handler."""
|