forked from mtusi2026/mtusi2026lab7
364 lines
12 KiB
Python
364 lines
12 KiB
Python
import asyncio
|
|
import hashlib
|
|
from datetime import datetime
|
|
|
|
from httpx import AsyncClient
|
|
|
|
from app.main import create_app
|
|
from conftest import close_app, make_client
|
|
from helpers import (
|
|
PASSWORD,
|
|
assert_request_id,
|
|
basic_header,
|
|
bearer,
|
|
create_user,
|
|
login,
|
|
register,
|
|
)
|
|
|
|
|
|
async def test_login_returns_opaque_bearer_session(client: AsyncClient):
|
|
user = await register(client)
|
|
|
|
response = await client.post(
|
|
"/api/v1/auth/sessions",
|
|
headers=basic_header(user["username"], user["password"]),
|
|
)
|
|
|
|
assert response.status_code == 201
|
|
body = response.json()
|
|
assert set(body) == {"token", "token_type", "expires_at", "user"}
|
|
assert body["token_type"] == "Bearer"
|
|
assert len(body["token"]) >= 43
|
|
assert body["token"] not in (user["id"], user["username"])
|
|
assert body["user"]["id"] == user["id"]
|
|
assert body["expires_at"].endswith("Z")
|
|
assert datetime.fromisoformat(body["expires_at"])
|
|
assert_request_id(response)
|
|
|
|
|
|
async def test_each_login_issues_a_different_token(client: AsyncClient):
|
|
user = await register(client)
|
|
first = await login(client, user)
|
|
second = await login(client, user)
|
|
|
|
assert first["token"] != second["token"]
|
|
|
|
|
|
async def test_password_with_colon_works(client: AsyncClient):
|
|
user = await register(client, password="pass:with:colons-123")
|
|
|
|
assert (await login(client, user))["token"]
|
|
|
|
|
|
async def test_unicode_password_works(client: AsyncClient):
|
|
user = await register(client, password="Пароль-с-юникодом-🔑-123")
|
|
|
|
assert (await login(client, user))["token"]
|
|
|
|
|
|
async def test_wrong_password_and_unknown_user_look_identical(client: AsyncClient):
|
|
user = await register(client)
|
|
|
|
wrong_password = await client.post(
|
|
"/api/v1/auth/sessions",
|
|
headers=basic_header(user["username"], "wrong-password-123"),
|
|
)
|
|
unknown_user = await client.post(
|
|
"/api/v1/auth/sessions",
|
|
headers=basic_header("no_such_user", "wrong-password-123"),
|
|
)
|
|
|
|
for response in (wrong_password, unknown_user):
|
|
assert response.status_code == 401
|
|
assert response.json()["error"]["code"] == "unauthorized"
|
|
assert response.headers["WWW-Authenticate"].startswith(
|
|
'Basic realm="messenger"'
|
|
)
|
|
assert_request_id(response)
|
|
assert (
|
|
wrong_password.json()["error"]["message"]
|
|
== unknown_user.json()["error"]["message"]
|
|
)
|
|
|
|
|
|
async def test_login_requires_basic_scheme(client: AsyncClient):
|
|
user = await register(client)
|
|
session = await login(client, user)
|
|
|
|
for headers in ({}, bearer(session), {"Authorization": "Basic !!!not-base64"}):
|
|
response = await client.post("/api/v1/auth/sessions", headers=headers)
|
|
assert response.status_code == 401
|
|
assert response.headers["WWW-Authenticate"].startswith("Basic")
|
|
|
|
|
|
async def test_business_endpoints_require_bearer(client: AsyncClient):
|
|
user = await register(client)
|
|
|
|
for headers in (
|
|
{},
|
|
basic_header(user["username"], user["password"]),
|
|
{"Authorization": "Bearer "},
|
|
{"Authorization": "Bearer unknown-token-value"},
|
|
{"X-User-Id": user["id"]},
|
|
):
|
|
response = await client.get("/api/v1/users/me", headers=headers)
|
|
assert response.status_code == 401, headers
|
|
assert response.json()["error"]["code"] == "unauthorized"
|
|
assert response.headers["WWW-Authenticate"].startswith(
|
|
'Bearer realm="messenger"'
|
|
)
|
|
assert_request_id(response)
|
|
|
|
|
|
async def test_x_user_id_cannot_override_bearer_identity(client: AsyncClient):
|
|
alice = await create_user(client)
|
|
eve = await create_user(client)
|
|
|
|
response = await client.get(
|
|
"/api/v1/users/me",
|
|
headers={**bearer(alice), "X-User-Id": eve["id"]},
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
assert response.json()["id"] == alice["id"]
|
|
|
|
|
|
async def test_logout_revokes_only_current_session(client: AsyncClient):
|
|
user = await register(client)
|
|
first = await login(client, user)
|
|
second = await login(client, user)
|
|
|
|
assert (
|
|
await client.delete("/api/v1/auth/sessions/current", headers=bearer(first))
|
|
).status_code == 204
|
|
|
|
assert (
|
|
await client.get("/api/v1/users/me", headers=bearer(first))
|
|
).status_code == 401
|
|
assert (
|
|
await client.get("/api/v1/users/me", headers=bearer(second))
|
|
).status_code == 200
|
|
|
|
|
|
async def test_logout_twice_returns_401(client: AsyncClient):
|
|
session = await create_user(client)
|
|
|
|
first = await client.delete(
|
|
"/api/v1/auth/sessions/current", headers=bearer(session)
|
|
)
|
|
again = await client.delete(
|
|
"/api/v1/auth/sessions/current", headers=bearer(session)
|
|
)
|
|
|
|
assert first.status_code == 204
|
|
assert first.content == b""
|
|
assert again.status_code == 401
|
|
|
|
|
|
async def test_session_expires_after_ttl(make_settings):
|
|
app = create_app(make_settings(session_ttl_seconds=2))
|
|
async with make_client(app) as client:
|
|
session = await create_user(client)
|
|
assert (
|
|
await client.get("/api/v1/users/me", headers=bearer(session))
|
|
).status_code == 200
|
|
|
|
await asyncio.sleep(3)
|
|
|
|
response = await client.get("/api/v1/users/me", headers=bearer(session))
|
|
assert response.status_code == 401
|
|
assert response.headers["WWW-Authenticate"].startswith("Bearer")
|
|
await close_app(app)
|
|
|
|
|
|
async def test_token_is_stored_only_as_sha256_key(client: AsyncClient, redis_client):
|
|
session = await create_user(client)
|
|
|
|
keys = [key async for key in redis_client.scan_iter("session:*")]
|
|
token_hash = hashlib.sha256(session["token"].encode()).hexdigest()
|
|
|
|
assert keys == [f"session:{token_hash}"]
|
|
assert await redis_client.get(keys[0]) == session["id"]
|
|
assert all(session["token"] not in key for key in keys)
|
|
|
|
|
|
async def test_password_is_not_stored_in_plaintext(client: AsyncClient, db_engine):
|
|
from sqlalchemy import text
|
|
|
|
await register(client, username="hash_check")
|
|
|
|
async with db_engine.connect() as connection:
|
|
result = await connection.execute(
|
|
text("SELECT password_hash FROM users WHERE username = 'hash_check'")
|
|
)
|
|
stored = result.scalar_one()
|
|
|
|
assert PASSWORD not in stored
|
|
assert stored.startswith("$argon2id$")
|
|
|
|
|
|
async def test_login_rejects_out_of_range_password_like_wrong_password(
|
|
client: AsyncClient,
|
|
):
|
|
user = await register(client)
|
|
reference = await client.post(
|
|
"/api/v1/auth/sessions",
|
|
headers=basic_header(user["username"], "wrong-password-123"),
|
|
)
|
|
|
|
for password in ("x" * 11, "x" * 129, ""):
|
|
response = await client.post(
|
|
"/api/v1/auth/sessions",
|
|
headers=basic_header(user["username"], password),
|
|
)
|
|
assert response.status_code == 401
|
|
assert (
|
|
response.json()["error"]["message"] == reference.json()["error"]["message"]
|
|
)
|
|
assert (
|
|
response.headers["WWW-Authenticate"]
|
|
== reference.headers["WWW-Authenticate"]
|
|
)
|
|
|
|
|
|
async def test_malformed_basic_credentials_return_401(client: AsyncClient):
|
|
import base64
|
|
|
|
def raw(value: bytes) -> dict[str, str]:
|
|
return {"Authorization": "Basic " + base64.b64encode(value).decode()}
|
|
|
|
for headers in (
|
|
raw(b"no-colon-here"),
|
|
raw(b":password-without-user"),
|
|
raw(b"\xff\xfe:invalid-utf8"),
|
|
{"Authorization": "Basic"},
|
|
{"Authorization": "Digest abc"},
|
|
):
|
|
response = await client.post("/api/v1/auth/sessions", headers=headers)
|
|
assert response.status_code == 401, headers
|
|
assert response.headers["WWW-Authenticate"].startswith("Basic")
|
|
|
|
|
|
async def test_unknown_user_takes_comparable_time_to_wrong_password(
|
|
client: AsyncClient,
|
|
):
|
|
import statistics
|
|
import time
|
|
|
|
user = await register(client)
|
|
|
|
async def measure(username: str) -> float:
|
|
samples = []
|
|
for _ in range(5):
|
|
started = time.perf_counter()
|
|
await client.post(
|
|
"/api/v1/auth/sessions",
|
|
headers=basic_header(username, "wrong-password-123"),
|
|
)
|
|
samples.append(time.perf_counter() - started)
|
|
return statistics.median(samples)
|
|
|
|
wrong_password = await measure(user["username"])
|
|
unknown_user = await measure("no_such_user")
|
|
|
|
assert unknown_user > wrong_password * 0.5
|
|
|
|
|
|
async def test_invalid_basic_username_returns_401_not_500(client: AsyncClient):
|
|
user = await register(client)
|
|
reference = await client.post(
|
|
"/api/v1/auth/sessions",
|
|
headers=basic_header(user["username"], "wrong-password-123"),
|
|
)
|
|
|
|
for username in ("bad\u0000name", "UPPER", "no", "x" * 33, "имя", "a b c"):
|
|
response = await client.post(
|
|
"/api/v1/auth/sessions",
|
|
headers=basic_header(username, "wrong-password-123"),
|
|
)
|
|
assert response.status_code == 401, username
|
|
assert (
|
|
response.json()["error"]["message"] == reference.json()["error"]["message"]
|
|
)
|
|
assert (
|
|
response.headers["WWW-Authenticate"]
|
|
== reference.headers["WWW-Authenticate"]
|
|
)
|
|
|
|
|
|
async def test_whitespace_only_password_at_login_returns_401(client: AsyncClient):
|
|
user = await register(client)
|
|
|
|
response = await client.post(
|
|
"/api/v1/auth/sessions", headers=basic_header(user["username"], " " * 12)
|
|
)
|
|
|
|
assert response.status_code == 401
|
|
assert response.headers["WWW-Authenticate"].startswith("Basic")
|
|
|
|
|
|
async def test_login_rehashes_only_after_success(client, db_engine):
|
|
from argon2 import PasswordHasher
|
|
from sqlalchemy import text
|
|
|
|
user = await register(client)
|
|
previous = await asyncio.to_thread(
|
|
PasswordHasher(memory_cost=8192, time_cost=2, parallelism=1).hash, user["password"]
|
|
)
|
|
async with db_engine.begin() as connection:
|
|
await connection.execute(
|
|
text("UPDATE users SET password_hash=:hash WHERE username=:name"),
|
|
{"hash": previous, "name": user["username"]},
|
|
)
|
|
|
|
async def read_hash():
|
|
async with db_engine.connect() as connection:
|
|
return await connection.scalar(
|
|
text("SELECT password_hash FROM users WHERE username=:name"),
|
|
{"name": user["username"]},
|
|
)
|
|
|
|
bad = await client.post("/api/v1/auth/sessions",
|
|
headers=basic_header(user["username"], "wrong-password"))
|
|
assert bad.status_code == 401
|
|
assert await read_hash() == previous
|
|
await login(client, user)
|
|
updated = await read_hash()
|
|
assert updated != previous
|
|
assert updated.startswith("$argon2id$v=19$m=19456,t=2,p=1$")
|
|
await login(client, user)
|
|
assert await read_hash() == updated
|
|
|
|
|
|
async def test_login_capacity_rejects_before_password_verification(client, monkeypatch):
|
|
from app.domain.auth import security
|
|
|
|
limit = 10
|
|
all_inside = asyncio.Event()
|
|
release = asyncio.Event()
|
|
entered = 0
|
|
|
|
async def wait_for_release(_password):
|
|
nonlocal entered
|
|
entered += 1
|
|
if entered == limit:
|
|
all_inside.set()
|
|
await release.wait()
|
|
|
|
monkeypatch.setattr(security, "dummy_verify_password", wait_for_release)
|
|
headers = basic_header("missing_user", "synthetic-password")
|
|
pending = [
|
|
asyncio.create_task(client.post("/api/v1/auth/sessions", headers=headers))
|
|
for _ in range(limit)
|
|
]
|
|
try:
|
|
await asyncio.wait_for(all_inside.wait(), timeout=5)
|
|
response = await client.post("/api/v1/auth/sessions", headers=headers)
|
|
assert response.status_code == 429
|
|
assert response.headers["Retry-After"] == "1"
|
|
assert entered == limit
|
|
finally:
|
|
release.set()
|
|
assert all(response.status_code == 401 for response in await asyncio.gather(*pending))
|