forked from mtusi2026/mtusi2026lab7
172 lines
9.8 KiB
Python
172 lines
9.8 KiB
Python
"""Собственные тесты лимитов входа и запросов (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()
|