"""The file underneath the door: what it holds, and what it refuses to hold. uv run pytest auth/tests/test_store.py -q """ from __future__ import annotations import sqlite3 from contextlib import closing from datetime import UTC, datetime, timedelta from pathlib import Path from auth import AuthStore from auth.store import _GRACE, _MAX_LOCK, _lockout from auth.tests import PASSWORD def rows(store: AuthStore, sql: str) -> list[tuple]: # `closing`, not `with conn:` alone -- that only commits, and a connection # left open is a file Windows will not let a temp dir delete. with closing(sqlite3.connect(store.path)) as conn: return [tuple(r) for r in conn.execute(sql)] # ------------------------------------------------------------- what is stored def test_the_password_is_not_in_the_file(store: AuthStore): """The point of the whole exercise.""" store.set_password(PASSWORD) assert PASSWORD.encode() not in store.path.read_bytes() assert store.check_password(PASSWORD) is True def test_a_session_token_is_not_in_the_file_either(store: AuthStore): token = store.open_session("pytest", 30) assert token.encode() not in store.path.read_bytes() assert store.touch(token) is not None def test_the_salt_differs_per_set(store: AuthStore): """Setting the same password twice must not produce the same row, or the file answers "did it change?" to anyone holding an old copy.""" store.set_password(PASSWORD) first = rows(store, "SELECT salt, hash FROM auth_credential") store.set_password(PASSWORD) assert rows(store, "SELECT salt, hash FROM auth_credential") != first assert store.check_password(PASSWORD) is True def test_the_tables_are_namespaced(store: AuthStore): """They share a file with the app's own tables and the job queue's, so a plain `sessions` is a name this package is not entitled to take.""" named = {name for (name,) in rows( store, "SELECT name FROM sqlite_master WHERE type='table'")} assert {"auth_credential", "auth_sessions", "auth_passkeys", "auth_challenges"} <= named assert not {n for n in named if not n.startswith(("auth_", "sqlite_"))} def test_a_database_with_no_password_refuses_without_raising(store: AuthStore): """And it still costs a derivation, so "is there a password here at all" is not a question the door answers by being quick about it.""" assert store.has_password() is False assert store.check_password(PASSWORD) is False # -------------------------------------------------------------- the lockout def test_five_wrong_answers_are_free_and_the_sixth_is_not(store: AuthStore): store.set_password(PASSWORD) for _ in range(_GRACE - 1): assert store.check_password("wrong") is False assert store.locked_for() == 0, "the grace ran out early" assert store.check_password("wrong") is False assert store.locked_for() > 0 def test_the_right_password_clears_it(store: AuthStore): """A lockout is a delay on guessing, not a second thing to recover from.""" store.set_password(PASSWORD) for _ in range(_GRACE): store.check_password("wrong") assert store.locked_for() > 0 assert store.check_password(PASSWORD) is True assert store.locked_for() == 0 def test_the_lockout_is_read_before_the_check_not_after(store: AuthStore): """The order the whole thing turns on: `locked_for` is a question about the file as it stands, so a caller can be told to wait *instead of* having a guess counted. Were it read after, every press while locked out would extend the lockout -- which punishes the owner hammering the button far harder than the attacker who is not watching. """ store.set_password(PASSWORD) for _ in range(_GRACE): store.check_password("wrong") waiting = store.locked_for() assert waiting > 0 # Asking twice does not move it. Nothing in `locked_for` writes. assert store.locked_for() == waiting assert rows(store, "SELECT failures FROM auth_credential") == [(_GRACE,)] def test_the_delay_doubles_and_then_stops(store: AuthStore): """Capped at the exponent, not only at the delay it produces: `2 ** steps` goes on growing after the cap has stopped mattering, and sixty wrong answers used to overflow the `timedelta` and raise out of `check_password` -- a 500 on every login attempt, from an attacker who only ever sent wrong passwords.""" assert _lockout(_GRACE) == timedelta(seconds=30) assert _lockout(_GRACE + 1) == timedelta(seconds=60) assert _lockout(_GRACE + 200) == _MAX_LOCK store.set_password(PASSWORD) for _ in range(60): assert store.check_password("wrong") is False assert 0 < store.locked_for() <= _MAX_LOCK.total_seconds() assert store.check_password(PASSWORD) is True # -------------------------------------------------------------- the sessions def test_a_session_is_live_until_it_is_not(store: AuthStore): token = store.open_session("pytest", 30) session = store.touch(token) assert session is not None and session.current is True assert [s.label for s in store.sessions()] == ["pytest"] def test_an_expired_session_is_not_a_session(store: AuthStore): """Expiry is enforced in the `WHERE`, not by the sweep: a row that has run out stops working the moment it does, whether or not anything purged it.""" token = store.open_session("pytest", 30) with closing(sqlite3.connect(store.path)) as conn, conn: conn.execute("UPDATE auth_sessions SET expires_at='2000-01-01T00:00:00+00:00'") assert store.touch(token) is None assert store.sessions() == [] assert store.purge() == 1 assert rows(store, "SELECT id FROM auth_sessions") == [] def test_revoking_one_session_leaves_the_others(store: AuthStore): mine = store.open_session("mine", 30) theirs = store.open_session("phone", 30) (row,) = [s for s in store.sessions(mine) if not s.current] assert store.close_by_id(row.id) is True assert store.close_by_id(row.id) is False, "a second revoke invented a row" assert store.touch(theirs) is None assert store.touch(mine) is not None def test_close_all_can_spare_the_caller(store: AuthStore): """The whole reason sessions are rows rather than signed tokens.""" mine = store.open_session("mine", 30) store.open_session("phone", 30) store.open_session("laptop", 30) assert store.close_all(keep=mine) == 2 assert [s.label for s in store.sessions(mine)] == ["mine"] assert store.close_all() == 1 assert store.sessions() == [] def test_the_current_session_is_flagged_and_only_that_one(store: AuthStore): mine = store.open_session("mine", 30) store.open_session("phone", 30) assert sum(s.current for s in store.sessions(mine)) == 1 assert sum(s.current for s in store.sessions()) == 0 def test_last_seen_is_not_written_on_every_touch(store: AuthStore): """This runs on every request there is. A timestamp nobody reads more precisely than "today" is not worth SQLite's write lock.""" token = store.open_session("pytest", 30) first = rows(store, "SELECT last_seen_at FROM auth_sessions") store.touch(token) assert rows(store, "SELECT last_seen_at FROM auth_sessions") == first old = (datetime.now(UTC) - timedelta(hours=1)).isoformat() with closing(sqlite3.connect(store.path)) as conn, conn: conn.execute("UPDATE auth_sessions SET last_seen_at=?", (old,)) store.touch(token) assert rows(store, "SELECT last_seen_at FROM auth_sessions") != [(old,)] # ------------------------------------------------------ passkeys, as rows def test_a_passkey_is_kept_renamed_and_revoked(store: AuthStore): key_id = store.add_passkey(b"cred-id", b"public-key", 3, "usb,nfc", "YubiKey") (key,) = store.passkeys() assert (key.label, key.transports) == ("YubiKey", ["usb", "nfc"]) assert store.passkey_ids() == [b"cred-id"] assert store.passkey_for(b"cred-id") == (key_id, b"public-key", 3) assert store.passkey_for(b"never seen") is None assert store.rename_passkey(key_id, "The one on my keyring") is True assert store.passkeys()[0].label == "The one on my keyring" store.record_passkey_use(key_id, 4) assert store.passkey_for(b"cred-id")[2] == 4 assert store.passkeys()[0].last_used_at assert store.delete_passkey(key_id) is True assert store.delete_passkey(key_id) is False assert store.passkeys() == [] def test_a_challenge_is_single_use_and_knows_what_it_was_for(store: AuthStore): store.remember_challenge(b"one", "register") assert store.take_challenge(b"one", "login") is False, "purposes are not pooled" assert store.take_challenge(b"one", "register") is True assert store.take_challenge(b"one", "register") is False, "it was spent" def test_an_abandoned_challenge_is_swept_by_the_next_one(store: AuthStore): """The endpoint that hands these out needs no session, so a ceremony nobody finished must not sit in the table until a restart.""" store.remember_challenge(b"abandoned", "login", seconds=-1) store.remember_challenge(b"fresh", "login") assert rows(store, "SELECT challenge FROM auth_challenges") == [(b"fresh",)] def test_the_store_makes_its_own_folder(tmp_path: Path): """`data/app.db` on a fresh clone: the directory is not there yet, and the first thing that opens the file is whatever runs first.""" store = AuthStore(tmp_path / "nowhere" / "yet" / "app.db") assert store.path.exists() assert store.has_password() is False