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")