forked from mtusi2026/mtusi2026lab4
220 lines
9.4 KiB
Python
220 lines
9.4 KiB
Python
"""Разбор и проверка входных данных по contracts/openapi.json и contracts/README.md."""
|
|
import base64
|
|
import binascii
|
|
import hashlib
|
|
import json
|
|
import re
|
|
|
|
from .errors import bad_request
|
|
|
|
USERNAME = re.compile(r'[a-z0-9_]{3,32}')
|
|
UUID = 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.compile(r'[0-9]{1,3}')
|
|
# Idempotency-Key из контракта: ASCII-символы [A-Za-z0-9._:-], от 1 до 128.
|
|
IDEMPOTENCY_KEY = re.compile(r'[A-Za-z0-9._:-]{1,128}')
|
|
# token68 из RFC 7235 с разумным ограничением длины.
|
|
BEARER_TOKEN = re.compile(r'[A-Za-z0-9\-._~+/]{1,512}=*')
|
|
|
|
DEFAULT_LIMIT = 50
|
|
MAX_LIMIT = 100
|
|
MAX_NAME = 100
|
|
MAX_MEMBERS = 100
|
|
MAX_TEXT = 4000
|
|
MIN_PASSWORD = 12
|
|
MAX_PASSWORD = 128
|
|
|
|
|
|
def parse_uuid(value):
|
|
"""UUID в каноническом виде (нижний регистр) или None."""
|
|
if isinstance(value, str) and UUID.fullmatch(value):
|
|
return value.lower()
|
|
return None
|
|
|
|
|
|
def _load_object(raw, fields):
|
|
"""JSON-объект ровно с полями fields: лишние и отсутствующие поля — ошибка."""
|
|
try:
|
|
data = json.loads(raw.decode('utf-8'))
|
|
except (ValueError, RecursionError):
|
|
raise bad_request('Тело запроса должно быть корректным JSON в UTF-8')
|
|
if not isinstance(data, dict):
|
|
raise bad_request('Тело запроса должно быть JSON-объектом')
|
|
for field in fields:
|
|
if field not in data:
|
|
raise bad_request('Отсутствует обязательное поле ' + field)
|
|
if len(data) != len(fields):
|
|
raise bad_request('В запросе есть лишние поля')
|
|
return data
|
|
|
|
|
|
def _string(data, field, max_length, min_length=1):
|
|
"""Строка из min_length..max_length code points, не только из пробельных символов."""
|
|
value = data[field]
|
|
if not isinstance(value, str):
|
|
raise bad_request('Поле %s должно быть строкой' % field)
|
|
if not value.strip():
|
|
raise bad_request('Поле %s не должно быть пустым' % field)
|
|
if not min_length <= len(value) <= max_length:
|
|
raise bad_request('Поле %s: от %d до %d символов' % (field, min_length, max_length))
|
|
# NUL нельзя сохранить в тексте PostgreSQL; одиночный суррогат (\ud800) нельзя вернуть в UTF-8.
|
|
if '\x00' in value:
|
|
raise bad_request('Поле %s содержит недопустимые символы' % field)
|
|
try:
|
|
value.encode('utf-8')
|
|
except UnicodeEncodeError:
|
|
raise bad_request('Поле %s содержит недопустимые символы' % field)
|
|
return value
|
|
|
|
|
|
def parse_create_user(raw):
|
|
data = _load_object(raw, ('username', 'display_name', 'password'))
|
|
username = data['username']
|
|
if not isinstance(username, str) or not USERNAME.fullmatch(username):
|
|
raise bad_request('username: 3-32 символа из набора a-z, 0-9 и _')
|
|
display_name = _string(data, 'display_name', MAX_NAME)
|
|
password = _string(data, 'password', MAX_PASSWORD, MIN_PASSWORD)
|
|
return username, display_name, password
|
|
|
|
|
|
def parse_create_chat(raw):
|
|
data = _load_object(raw, ('title', 'member_ids'))
|
|
title = _string(data, 'title', MAX_NAME)
|
|
raw_ids = data['member_ids']
|
|
if not isinstance(raw_ids, list) or not 1 <= len(raw_ids) <= MAX_MEMBERS:
|
|
raise bad_request('member_ids: список из 1-%d UUID' % MAX_MEMBERS)
|
|
member_ids = [parse_uuid(item) for item in raw_ids]
|
|
if None in member_ids:
|
|
raise bad_request('member_ids должен содержать только UUID')
|
|
if len(set(member_ids)) != len(member_ids):
|
|
raise bad_request('member_ids не должен содержать повторов')
|
|
return title, member_ids
|
|
|
|
|
|
def parse_create_message(raw):
|
|
try:
|
|
data = json.loads(raw.decode('utf-8'))
|
|
except (ValueError, RecursionError):
|
|
raise bad_request('Тело запроса должно быть корректным JSON в UTF-8')
|
|
if not isinstance(data, dict) or 'text' not in data or set(data) - {'text', 'attachment_ids'}:
|
|
raise bad_request('Нужен text и необязательный attachment_ids')
|
|
text = data['text']
|
|
if not isinstance(text, str) or len(text) > MAX_TEXT or '\x00' in text:
|
|
raise bad_request('text: строка до 4000 символов')
|
|
try:
|
|
text.encode('utf-8')
|
|
except UnicodeEncodeError:
|
|
raise bad_request('Недопустимые символы text')
|
|
ids = data.get('attachment_ids', [])
|
|
if not isinstance(ids, list) or len(ids) > 10:
|
|
raise bad_request('attachment_ids: список до 10 UUID')
|
|
ids = [parse_uuid(value) for value in ids]
|
|
if None in ids or len(set(ids)) != len(ids):
|
|
raise bad_request('attachment_ids: уникальные UUID')
|
|
if not text.strip() and not ids:
|
|
raise bad_request('Нужен непустой текст или вложение')
|
|
return text, ids
|
|
|
|
|
|
def parse_idempotency_key(header):
|
|
"""Значение заголовка Idempotency-Key; без него или в неверном формате — 400."""
|
|
if header is None:
|
|
raise bad_request('Нужен заголовок Idempotency-Key')
|
|
if not IDEMPOTENCY_KEY.fullmatch(header):
|
|
raise bad_request('Idempotency-Key: от 1 до 128 символов из набора A-Z, a-z, 0-9 и ._:-')
|
|
return header
|
|
|
|
|
|
def request_fingerprint(text, attachment_ids=()):
|
|
"""sha256 разобранного тела: порядок ключей и пробелы в JSON не влияют на сравнение повторов."""
|
|
canonical = json.dumps({'text': text, 'attachment_ids': list(attachment_ids)},
|
|
ensure_ascii=False, sort_keys=True, separators=(',', ':'))
|
|
return hashlib.sha256(canonical.encode('utf-8')).hexdigest()
|
|
|
|
|
|
def _credentials(header, scheme):
|
|
"""Значение после схемы авторизации (схема без учёта регистра) или None."""
|
|
if not header:
|
|
return None
|
|
name, _, value = header.strip().partition(' ')
|
|
if name.lower() != scheme:
|
|
return None
|
|
return value.strip()
|
|
|
|
|
|
def parse_basic(header):
|
|
"""(username, password) из Authorization: Basic base64(username:password) или None.
|
|
|
|
Пароль в UTF-8 и может содержать двоеточие: делим по первому. Всё, что не может быть
|
|
правильной парой логин/пароль, возвращает None — дальше это обычный ответ 401.
|
|
"""
|
|
value = _credentials(header, 'basic')
|
|
if not value:
|
|
return None
|
|
try:
|
|
decoded = base64.b64decode(value, validate=True).decode('utf-8')
|
|
except (binascii.Error, ValueError):
|
|
return None
|
|
username, separator, password = decoded.partition(':')
|
|
if not separator or not USERNAME.fullmatch(username):
|
|
return None
|
|
if not MIN_PASSWORD <= len(password) <= MAX_PASSWORD:
|
|
return None
|
|
return username, password
|
|
|
|
|
|
def parse_bearer(header):
|
|
"""Токен из Authorization: Bearer <token> или None."""
|
|
value = _credentials(header, 'bearer')
|
|
if not value or not BEARER_TOKEN.fullmatch(value):
|
|
return None
|
|
return value
|
|
|
|
|
|
def _single(query, name):
|
|
"""Значение параметра запроса; None, если параметра нет."""
|
|
values = query.get(name)
|
|
if values is None:
|
|
return None
|
|
if len(values) != 1:
|
|
raise bad_request('Параметр %s указан несколько раз' % name)
|
|
return values[0]
|
|
|
|
|
|
def parse_limit(query):
|
|
value = _single(query, 'limit')
|
|
if value is None:
|
|
return DEFAULT_LIMIT
|
|
if not LIMIT.fullmatch(value) or not 1 <= int(value) <= MAX_LIMIT:
|
|
raise bad_request('limit должен быть целым числом от 1 до %d' % MAX_LIMIT)
|
|
return int(value)
|
|
|
|
|
|
def encode_cursor(scope, key):
|
|
"""Непрозрачный для клиента cursor: область действия и ключ (created_at, id) последней записи."""
|
|
if key is None:
|
|
return None
|
|
raw = '%s|%d|%s' % (scope, key[0], key[1])
|
|
return base64.urlsafe_b64encode(raw.encode('ascii')).decode('ascii').rstrip('=')
|
|
|
|
|
|
def parse_cursor(query, scope):
|
|
"""Ключ (created_at в мкс, id), после которого продолжать; None без cursor.
|
|
|
|
scope привязывает cursor к ресурсу: cursor от другого чата — 400.
|
|
"""
|
|
value = _single(query, 'cursor')
|
|
if value is None:
|
|
return None
|
|
try:
|
|
padded = value + '=' * (-len(value) % 4)
|
|
raw = base64.b64decode(padded, altchars=b'-_', validate=True).decode('ascii')
|
|
cursor_scope, micros, entry_id = raw.split('|')
|
|
if cursor_scope != scope or not micros.isdigit() or parse_uuid(entry_id) != entry_id:
|
|
raise ValueError
|
|
# Ограничение длины защищает от чисел, которые не влезут в дату PostgreSQL.
|
|
if len(micros) > 17:
|
|
raise ValueError
|
|
return int(micros), entry_id
|
|
except ValueError:
|
|
raise bad_request('Некорректный cursor')
|