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>
228 lines
9.4 KiB
Python
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
|