Files
mtusi2026lab7/student-tests/test_limits.py
T
2026-11-08 00:33:25 +03:00

172 lines
9.8 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""Собственные тесты лимитов входа и запросов (lab7, README уровни 3–4).
Запуск: make limits-test (входит и в make student-test)
1. Перебор пароля одного аккаунта: после LOGIN_FAILURES_PER_USER (10) неудачных входов следующий вход
получает 429 rate_limited с Retry-After — даже с ВЕРНЫМ паролем. Попытки расходятся по разным
репликам (X-Instance-Id), а лимит всё равно срабатывает: счётчик общий (Valkey, rl:*), а не на реплику.
Лимит привязан к username: соседний аккаунт входит как обычно (нет «глобальной блокировки»).
2. Тело JSON больше MAX_JSON_BODY_BYTES (64 КиБ) -> 413 payload_too_large: и с Content-Length, и
chunked (без Content-Length, сервер считает байты сам). Отказ раньше проверки токена.
3. Rehash: hash пароля со старыми (слабее текущих) параметрами Argon2id пересчитывается при успешном входе.
"""
import json
import subprocess
import unittest
import uuid
from filegen import psql
from helpers import ROOT, Client, basic, login
from stand import api_containers
PASSWORD = "Limits-password-123"
FAILURES_PER_USER = 10 # LOGIN_FAILURES_PER_USER из .env.example
FAILURE_WINDOW = 300 # LOGIN_FAILURE_WINDOW_SECONDS
MAX_JSON_BODY = 65536 # MAX_JSON_BODY_BYTES
# Старые параметры: заведомо слабее текущих (m=19456 КиБ, t=2). Hash строится в контейнере api,
# там есть argon2-cffi; код (с тестовым паролем) идёт через stdin, а не аргументом командной строки.
WEAK_HASH = """
from argon2 import PasswordHasher
print(PasswordHasher(time_cost=1, memory_cost=8192, parallelism=1).hash({password!r}))
"""
def weak_hash(password):
code = WEAK_HASH.format(password=password)
result = subprocess.run(["docker", "compose", "exec", "-T", "api", "python", "-"], cwd=ROOT,
input=code.encode("utf-8"), capture_output=True)
if result.returncode != 0:
raise AssertionError("cannot build a weak hash in the api container")
return result.stdout.decode().strip()
def stored_hash(user_id):
return psql(f"SELECT password_hash FROM users WHERE id = '{uuid.UUID(user_id)}'")
class LimitsTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.api = Client()
def register(self):
body = {"username": "l_" + uuid.uuid4().hex[:12], "display_name": "Limits", "password": PASSWORD}
user = self.api.call("POST", "/api/v1/users", 201, body=body, schema="User")["json"]
return body, user
# ---------- 1. частота входа ----------
def test_login_failures_lead_to_429_with_retry_after_across_replicas(self):
body, _ = self.register()
instances = set()
for _ in range(FAILURES_PER_USER):
response = self.api.call("POST", "/api/v1/auth/sessions", 401,
headers={"Authorization": basic(body["username"], "Wrong-password-000")})
instances.add(response["headers"]["X-Instance-Id"])
replicas = len(api_containers())
if replicas > 1:
# Без общего счётчика 10 неудач, разбросанных по репликам, не дали бы 429.
self.assertGreater(len(instances), 1, "попытки не разошлись по репликам: проверка общего счётчика пуста")
print(f"\n {FAILURES_PER_USER} wrong passwords -> 401, served by {len(instances)} of {replicas} replicas")
for password in ("Wrong-password-000", body["password"]): # и неверный, и ВЕРНЫЙ пароль
limited = self.api.call("POST", "/api/v1/auth/sessions", 429,
headers={"Authorization": basic(body["username"], password)})
self.assertEqual(limited["json"]["error"]["code"], "rate_limited")
retry_after = limited["headers"].get("Retry-After")
self.assertIsNotNone(retry_after, "429 без Retry-After")
self.assertTrue(retry_after.isdigit(), f"Retry-After должен быть числом секунд: {retry_after!r}")
self.assertTrue(1 <= int(retry_after) <= FAILURE_WINDOW, f"Retry-After вне окна: {retry_after}")
print(f" next login (even with the right password) -> 429 rate_limited, Retry-After: {retry_after} s")
def test_limit_is_per_username(self):
victim, _ = self.register()
neighbour, _ = self.register()
for _ in range(FAILURES_PER_USER):
login(self.api, victim["username"], "Wrong-password-000", expected=401)
login(self.api, victim["username"], victim["password"], expected=429)
session = login(self.api, neighbour["username"], neighbour["password"]) # соседа лимит не задел
self.assertTrue(session["token"])
def test_success_resets_failure_counter(self):
body, _ = self.register()
for _ in range(FAILURES_PER_USER - 1):
login(self.api, body["username"], "Wrong-password-000", expected=401)
login(self.api, body["username"], body["password"]) # успех сбрасывает счётчик
for _ in range(FAILURES_PER_USER - 1):
login(self.api, body["username"], "Wrong-password-000", expected=401)
login(self.api, body["username"], body["password"]) # снова 9 < 10: вход проходит
# ---------- 2. размер запроса ----------
def big_body(self, size=MAX_JSON_BODY + 1024):
filler = "x" * size
return json.dumps({"username": "big_" + uuid.uuid4().hex[:8], "display_name": filler,
"password": PASSWORD}).encode()
def test_body_over_limit_with_content_length_is_413(self):
raw = self.big_body()
response = self.api.call("POST", "/api/v1/users", 413, raw=raw,
headers={"Content-Type": "application/json", "Content-Length": str(len(raw))})
self.assertEqual(response["json"]["error"]["code"], "payload_too_large")
print(f"\n POST /users, Content-Length {len(raw)} -> 413 payload_too_large")
def test_body_over_limit_chunked_is_413(self):
raw = self.big_body()
chunks = iter([raw[i:i + 8192] for i in range(0, len(raw), 8192)]) # итератор -> Transfer-Encoding: chunked
response = self.api.call("POST", "/api/v1/users", 413, raw=chunks, headers={"Content-Type": "application/json"})
self.assertEqual(response["json"]["error"]["code"], "payload_too_large")
print(f"\n POST /users, chunked {len(raw)} bytes without Content-Length -> 413 payload_too_large")
def test_big_body_rejected_before_authentication(self):
# Без токена: 413, а не 401 — тело отклонено по размеру ещё до проверки Bearer.
raw = json.dumps({"text": "x" * (MAX_JSON_BODY + 1)}).encode()
path = f"/api/v1/chats/{uuid.uuid4()}/messages"
response = self.api.call("POST", path, 413, raw=raw,
headers={"Content-Type": "application/json", "Idempotency-Key": uuid.uuid4().hex})
self.assertEqual(response["json"]["error"]["code"], "payload_too_large")
def test_body_under_limit_is_accepted(self):
# Граница: тело чуть меньше лимита — не 413 (display_name слишком длинный -> обычная 400 валидации).
raw = self.big_body(size=MAX_JSON_BODY - 1024)
self.assertLessEqual(len(raw), MAX_JSON_BODY)
self.api.call("POST", "/api/v1/users", 400, raw=raw, headers={"Content-Type": "application/json"})
# ---------- 3. rehash ----------
def test_old_hash_is_rehashed_on_login(self):
body, user = self.register()
current = stored_hash(user["id"])
self.assertIn("m=19456,t=2", current) # текущие параметры (ARGON2_MEMORY_KIB, ARGON2_ITERATIONS)
old = weak_hash(body["password"])
self.assertIn("m=8192,t=1", old)
psql(f"UPDATE users SET password_hash = '{old}' WHERE id = '{uuid.UUID(user['id'])}'")
self.assertEqual(stored_hash(user["id"]), old)
login(self.api, body["username"], body["password"]) # старый hash всё ещё проверяется
new = stored_hash(user["id"])
self.assertNotEqual(new, old, "hash не пересчитан при входе")
self.assertTrue(new.startswith("$argon2id$"))
self.assertIn("m=19456,t=2", new)
print(f"\n stored hash params: {_params(old)} -> after login {_params(new)}")
login(self.api, body["username"], body["password"]) # новый hash принимает тот же пароль
self.assertEqual(stored_hash(user["id"]), new, "hash с текущими параметрами пересчитывать не нужно")
def test_wrong_password_does_not_rehash(self):
body, user = self.register()
old = weak_hash(body["password"])
psql(f"UPDATE users SET password_hash = '{old}' WHERE id = '{uuid.UUID(user['id'])}'")
login(self.api, body["username"], "Wrong-password-000", expected=401)
self.assertEqual(stored_hash(user["id"]), old, "без верного пароля пересчитывать нечего")
def _params(password_hash):
return password_hash.split("$")[3] # $argon2id$v=19$m=...,t=...,p=...$соль$hash
if __name__ == "__main__":
unittest.main()