Take auth/ whole from boilerplate 09e144d: the lockout claimed before the scrypt, APP_PASSWORD recovery closing every session, Starlette's cookie parser, the rightmost forwarded hop in the log, revoke_all on a password change, a 421 for a non-loopback Host on an open app, API tokens in auth_tokens behind Authorization: Bearer, and sockets closed with their credential

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
This commit is contained in:
WolfandClaude Fable 5.1 committed 2026-10-27 11:51:21 +01:00
1 parent 83e965dfeb
commit 244e57ac29
19 files changed
+2288 -214

No files matched your search

+170
View File
@@ -0,0 +1,170 @@
"""A socket whose credential ends is closed: by the route that ended it, or by
the sweep when it expired.
uv run pytest auth/tests/test_sockets.py -q
The door is checked at the handshake only, so before this a signed-out tab,
a revoked token or an expired session kept its socket streaming until the tab
reconnected. Every socket here is opened on the client the route is called
on: a client that is not entered runs its requests on an event loop of their
own, and the route's background task could not close a socket living there.
"""
from __future__ import annotations
import asyncio
import contextlib
import logging
import sqlite3
from contextlib import closing
from pathlib import Path
from typing import Any
import pytest
from fastapi.testclient import TestClient
from starlette.websockets import WebSocketDisconnect
import auth.middleware
from auth import AuthConfig, close_ended_sockets, sweep_ended_sockets
from auth.tests import PASSWORD
from auth.tests.harness import build
#: The cookie a login over plain http sets.
COOKIE = AuthConfig().cookie
LONG_AGO = "2000-01-01T00:00:00+00:00"
def closed_with(ws: Any) -> int:
"""Read frames until the server closes the socket; the close code.
Blocks on a socket the server left open, since the test client's receive
has no timeout, so each test asks the bus first, which does not block."""
for _ in range(50):
try:
ws.receive_json()
except WebSocketDisconnect as closed:
return closed.code
raise AssertionError("the socket stayed open")
def sweep_now(client: TestClient) -> int:
"""`close_ended_sockets` on the loop the client's sockets live on."""
assert client.portal is not None
return client.portal.call(close_ended_sockets, client.app)
def expire(client: TestClient, table: str) -> None:
with closing(sqlite3.connect(client.app.state.auth.path)) as conn, conn:
conn.execute(f"UPDATE {table} SET expires_at=?", (LONG_AGO,))
# --------------------------------------------------------------- the routes
def test_signing_out_closes_the_socket_the_session_opened(signed_in: TestClient):
with signed_in.websocket_connect("/ws/jobs") as ws:
assert ws.receive_json()["type"] == "jobs"
assert signed_in.post("/logout").status_code == 200
assert signed_in.app.state.bus.sockets == ()
assert closed_with(ws) == 1008
def test_revoking_a_token_closes_its_socket(signed_in: TestClient):
"""The cookie is taken out so the bearer header is what opens the socket;
with the cookie in, the session would be what it stands on."""
made = signed_in.post("/api/account/tokens",
json={"current": PASSWORD, "label": "cron"}).json()
here = signed_in.cookies[COOKIE]
signed_in.cookies.clear()
with signed_in.websocket_connect(
"/ws/jobs", headers={"authorization": f"Bearer {made['token']}"}) as ws:
assert ws.receive_json()["type"] == "jobs"
signed_in.cookies.set(COOKIE, here)
assert signed_in.delete(f"/api/account/tokens/{made['id']}").status_code == 200
assert signed_in.app.state.bus.sockets == ()
assert closed_with(ws) == 1008
def test_closing_the_others_closes_their_sockets_and_keeps_this_one(
signed_in: TestClient):
here = signed_in.cookies[COOKIE]
there = signed_in.app.state.auth.open_session("phone", 1)
def as_(token: str) -> None:
signed_in.cookies.clear()
signed_in.cookies.set(COOKIE, token)
as_(there)
with signed_in.websocket_connect("/ws/jobs") as theirs:
assert theirs.receive_json()["type"] == "jobs"
as_(here)
with signed_in.websocket_connect("/ws/jobs") as mine:
assert mine.receive_json()["type"] == "jobs"
closed = signed_in.post("/api/account/sessions/close")
assert closed.json() == {"signed_out": 1}
assert len(signed_in.app.state.bus.sockets) == 1, "this tab's is open"
assert closed_with(theirs) == 1008
# ---------------------------------------------------------------- expiry
def test_an_expired_session_loses_its_socket(signed_in: TestClient):
"""Expiry ends no request, so no route sees it; the sweep's call does."""
with signed_in.websocket_connect("/ws/jobs") as ws:
assert ws.receive_json()["type"] == "jobs"
assert sweep_now(signed_in) == 0, "a live session keeps its socket"
expire(signed_in, "auth_sessions")
assert sweep_now(signed_in) == 1
assert closed_with(ws) == 1008
def test_nothing_is_closed_on_an_unlocked_app_or_one_without_a_bus(
open_app: TestClient, signed_in: TestClient):
with open_app.websocket_connect("/ws/jobs", headers={"host": "127.0.0.1"}) as ws:
assert ws.receive_json()["type"] == "jobs"
assert sweep_now(open_app) == 0
del signed_in.app.state.bus
expire(signed_in, "auth_sessions")
assert sweep_now(signed_in) == 0
def test_the_sweep_runs_on_its_clock_and_survives_a_failure(
monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture):
calls: list[object] = []
async def counted(app: object) -> int:
calls.append(app)
if len(calls) == 1:
raise sqlite3.OperationalError("database is locked")
return 0
monkeypatch.setattr(auth.middleware, "close_ended_sockets", counted)
async def run() -> asyncio.Task[None]:
task = asyncio.create_task(sweep_ended_sockets("the app", every=0.01))
for _ in range(200):
if len(calls) >= 2:
break
await asyncio.sleep(0.01)
task.cancel()
with contextlib.suppress(asyncio.CancelledError):
await task
return task
with caplog.at_level(logging.WARNING):
task = asyncio.run(run())
assert len(calls) >= 2 and calls[0] == "the app"
assert "the socket sweep failed" in caplog.text
assert task.cancelled()
def test_a_locked_app_sweeps_while_it_is_up(tmp_path: Path):
app = build(tmp_path / "a.db", enabled="always")
assert app.state.auth_sweep is None
with TestClient(app):
sweep = app.state.auth_sweep
assert isinstance(sweep, asyncio.Task) and not sweep.done()
assert sweep.done() and sweep.cancelled()
def test_an_unlocked_app_has_no_sweep(open_app: TestClient):
assert open_app.app.state.auth_sweep is None