Files
WolfandClaude Opus 5.5 9d666d0937 Bring in pipeline, auth, deploy and docs from the boilerplate
roledesk is built on the boilerplate from here on: pipeline 2.0 (queue and
scheduler), auth (one password, sessions, passkeys), the deploy kit and its
docs, plus the coupling and packaging tests. Downstream copies, unedited.

Refreshed from boilerplate/d56949f7d0f6c0bfe5745478e09007bfad67ae87

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-23 12:29:16 +02:00

228 lines
9.4 KiB
Python

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