feat(bezpieczeństwo): sesje logowania zamiast HTTP Basic (LOG-34)

Basic nie miał wylogowania i nie dało się tego obejść: przeglądarka zapamiętuje
hasło i dosyła je SAMA przy każdym żądaniu, więc serwer nie ma czego zapomnieć.
Poprzednia próba (LOG-32) opierała się na nakłonieniu przeglądarki, żeby porzuciła
zapamiętane dane — zachowaniu powszechnym, ale nigdzie nie zapisanym. Teraz to
serwer decyduje, czy dana przeglądarka jest w środku, i może to cofnąć.

TRZY POZIOMY UNIEWAŻNIENIA, celowo rozdzielone, bo każdy kosztuje co innego:
  1. wylogowanie = skasowanie ciasteczka. Natychmiastowe, bez magazynu.
  2. zmiana hasła albo skasowanie konta = odcisk poświadczenia wpisany
     w ciasteczko przestaje pasować. Dzieje się SAMO, bez pamiętania o tym.
     Bez tego odebranie komuś dostępu nie odbierałoby dostępu aż do wygaśnięcia.
  3. „zamknij sesje" z ekranu kont = licznik pokolenia. Jedyny wymagający zapisu,
     więc jedyny opcjonalny: gdy licznika nie ma, poziomy 1 i 2 nadal działają.

KONTO ADMINISTRACYJNE ODSEPAROWANE. Sprawdzane pierwsze i BEZ DOTYKANIA pliku
kont, co daje dwie rzeczy naraz: konto z pliku o tym samym loginie nie przesłoni
administratora, a administrator zaloguje się także wtedy, gdy plik jest uszkodzony
— czyli w jedynej sytuacji, w której ktoś MUSI wejść, żeby to naprawić. Trzymanie
jego stanu w tym samym pliku dawałoby zakleszczenie: nie da się naprawić, bo nie
da się wejść. Jego odpowiednikiem „wyloguj zewsząd" jest zmiana APP_PASSWORD.

KLUCZ WYMAGANY, FAIL-CLOSED. Usługa z kontami, ale bez klucza podpisu, nie
odróżniłaby ważnej sesji od podrobionej, więc nie wstaje — i lepiej przy starcie
niż przy pierwszym logowaniu człowieka. Losowanie klucza byłoby wygodne, ale
wylogowywałoby wszystkich przy każdym restarcie poda: wygląda jak awaria i uczy
ludzi ignorować ekran logowania.

Ciasteczko HttpOnly (jeden wstrzyknięty skrypt inaczej wynosi sesję) i
SameSite=Strict (obca strona nie zadziała w imieniu zalogowanego). Wylogowanie
POST-em, nie odsyłaczem: pod adresem GET wystarczyłby obrazek na obcej stronie.
Adres powrotu po zalogowaniu przechodzi przez sito — bez tego `?dokad=https://obcy`
zamieniłby nasz ekran logowania w narzędzie do wyłudzania haseł.

Kres bezczynności 8 h i twardy 30 dni. Znacznik aktywności odświeżany z progiem,
inaczej Set-Cookie leciałby przy każdym obrazku i arkuszu stylów.

Zdarzenia logowania w dzienniku (PRE-17). Nieudane próby są tam ważniejsze od
udanych: pojedyncza nic nie znaczy, ale seria pod jednym adresem to jedyny
widoczny ślad zgadywania haseł. Test pilnuje, że hasło tam nie trafia.

Sprawdzone w przeglądarce: po zalogowaniu ciasteczko jest NIEWIDOCZNE dla
JavaScriptu, a po wylogowaniu wejście na chronioną stronę ląduje na ekranie
logowania — czyli dokładnie to, czego Basic nie potrafił.

Testy: 21 na rdzeń podpisywania (w tym podrabianie ładunku, podpisu i klucza,
ciasteczko z przyszłości, śmieci na wejściu), reszta przepisana z Basic na sesje.
Prezentacja 338 zielonych.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

services/presentation/tests/test_accounts_audit.py

@@ -5,7 +5,6 @@ krytyczne i CICHE, gdy się zepsują: (1) odebranie dostępu jednej osobie musi
 faktycznie działać, (2) dziennik musi mówić KTO i ILE, ale NIGDY nie powielać
 treści baz (byłby wtedy kolejnym nośnikiem wycieku).
 """
-import base64
 import logging
 
 import pytest
@@ -13,9 +12,13 @@ import pytest
 from app import security
 
 
-def _basic(user: str, password: str) -> dict:
-    raw = base64.b64encode(f"{user}:{password}".encode()).decode()
-    return {"Authorization": f"Basic {raw}"}
+def _kto(user: str, password: str) -> str | None:
+    """Login, gdy poświadczenia pasują; None przy odmowie.
+
+    Po przejściu na sesje (LOG-34) sprawdzanie hasła robi `verify`, a nie
+    parsowanie nagłówka Basic — samego nagłówka nie ma już w ogóle."""
+    who = security.verify(user, password)
+    return who.login if who else None
 
 
 @pytest.fixture(autouse=True)
@@ -57,29 +60,29 @@ def test_named_accounts_are_parsed(monkeypatch):
 
 def test_login_with_hashed_password(monkeypatch):
     monkeypatch.setenv("APP_USERS", f"alicja:{security.hash_password('tajne')}")
-    assert security.authenticate(_basic("alicja", "tajne")["Authorization"]) == "alicja"
-    assert security.authenticate(_basic("alicja", "złe")["Authorization"]) is None
+    assert _kto("alicja", "tajne") == "alicja"
+    assert _kto("alicja", "złe") is None
 
 
 def test_unknown_user_is_denied(monkeypatch):
     monkeypatch.setenv("APP_USERS", "alicja:tajne")
-    assert security.authenticate(_basic("obcy", "tajne")["Authorization"]) is None
+    assert _kto("obcy", "tajne") is None
 
 
 def test_revoking_one_account_leaves_others_untouched(monkeypatch):
     """Sedno PRE-17: odcinamy jedną osobę BEZ zmiany hasła pozostałym."""
     monkeypatch.setenv("APP_USERS", "alicja:tajne,bartek:inne")
-    assert security.authenticate(_basic("bartek", "inne")["Authorization"]) == "bartek"
+    assert _kto("bartek", "inne") == "bartek"
     monkeypatch.setenv("APP_USERS", "alicja:tajne")          # usunięto wpis Bartka
-    assert security.authenticate(_basic("bartek", "inne")["Authorization"]) is None
-    assert security.authenticate(_basic("alicja", "tajne")["Authorization"]) == "alicja"
+    assert _kto("bartek", "inne") is None
+    assert _kto("alicja", "tajne") == "alicja"
 
 
 def test_shared_password_still_works_alone(monkeypatch):
     """Zgodność wstecz — dotychczasowe wdrożenie nie może paść po aktualizacji."""
     monkeypatch.setenv("APP_USER", "astrololo")
     monkeypatch.setenv("APP_PASSWORD", "wspolne")
-    assert security.authenticate(_basic("astrololo", "wspolne")["Authorization"]) == "astrololo"
+    assert _kto("astrololo", "wspolne") == "astrololo"
 
 
 def test_named_accounts_disable_the_shared_password(monkeypatch):
@@ -88,7 +91,7 @@ def test_named_accounts_disable_the_shared_password(monkeypatch):
     monkeypatch.setenv("APP_USERS", "alicja:tajne")
     monkeypatch.setenv("APP_USER", "astrololo")
     monkeypatch.setenv("APP_PASSWORD", "wspolne")
-    assert security.authenticate(_basic("astrololo", "wspolne")["Authorization"]) is None
+    assert _kto("astrololo", "wspolne") is None
 
 
 def test_no_accounts_means_auth_disabled(monkeypatch):
@@ -97,28 +100,82 @@ def test_no_accounts_means_auth_disabled(monkeypatch):
 
 # ── dziennik audytowy ──
 
-def _client():
+def _client(monkeypatch):
+    # Klucz MUSI być w środowisku ZANIM zaimportujemy app.main: security.install
+    # biegnie przy imporcie i bez klucza celowo nie pozwala usłudze wstać.
+    monkeypatch.setenv("SESSION_SECRET", "t" * 64)
+    monkeypatch.setenv("COOKIES_INSECURE", "1")
+
     from starlette.testclient import TestClient
 
     from app.main import app
 
-    return TestClient(app)
+    return TestClient(app, follow_redirects=False)
+
+
+class _dziennik:
+    """Przechwytuje wpisy audytowe.
+
+    `caplog` podpina się pod korzeń, a dziennik audytowy ma celowo
+    `propagate=False` — żeby wpisy nie dublowały się w logach usługi. Trzeba więc
+    podpiąć uchwyt WPROST pod niego, inaczej test widzi pustkę i wygląda to na
+    brak wpisów zamiast na brak podsłuchu."""
+
+    def __init__(self, caplog):
+        self.caplog = caplog
+
+    def __enter__(self):
+        security._setup_audit_logging()
+        security.audit_log.setLevel(logging.INFO)
+        security.audit_log.addHandler(self.caplog.handler)
+        return self
+
+    def __exit__(self, *a):
+        security.audit_log.removeHandler(self.caplog.handler)
+
+    @property
+    def tekst(self) -> str:
+        return "\n".join(r.getMessage() for r in self.caplog.records)
+
+
+def _sesja(user: str) -> dict:
+    from app import session
+
+    return {"Cookie": f"{session.COOKIE}={security.issue_session(user)}"}
 
 
 def test_audit_logs_who_and_how_many(monkeypatch, caplog):
     monkeypatch.setenv("APP_USERS", "alicja:tajne")
-    with caplog.at_level(logging.INFO, logger="astrololo.audit"):
-        _client().get("/synastry", headers=_basic("alicja", "tajne"))
-    entry = "\n".join(r.getMessage() for r in caplog.records)
+    c = _client(monkeypatch)
+    with _dziennik(caplog) as d:
+        c.get("/synastry", headers=_sesja("alicja"))
+    entry = d.tekst
     assert "user=alicja" in entry and "path=/synastry" in entry and "status=200" in entry
 
 
-def test_audit_marks_failed_login_without_naming_the_account(monkeypatch, caplog):
+def test_audit_marks_a_request_without_a_session(monkeypatch, caplog):
+    """Odesłanie na ekran logowania też zostawia ślad — bez tego seria prób
+    dobicia się do chronionej ścieżki byłaby w dzienniku niewidoczna."""
     monkeypatch.setenv("APP_USERS", "alicja:tajne")
-    with caplog.at_level(logging.INFO, logger="astrololo.audit"):
-        _client().get("/synastry", headers=_basic("alicja", "złe"))
-    entry = "\n".join(r.getMessage() for r in caplog.records)
-    assert "status=401" in entry and "user=-" in entry
+    c = _client(monkeypatch)
+    with _dziennik(caplog) as d:
+        c.get("/synastry")
+    entry = d.tekst
+    assert "status=303" in entry and "user=-" in entry
+
+
+def test_failed_login_is_logged_without_saying_which_account_exists(monkeypatch, caplog):
+    """Nieudane próby są w dzienniku ważniejsze od udanych: pojedyncza nic nie
+    znaczy, ale seria pod jednym adresem to jedyny widoczny ślad zgadywania
+    haseł. Hasło ani jego fragment NIE mogą tam trafić."""
+    monkeypatch.setenv("APP_USERS", f"alicja:{security.hash_password('tajne')}")
+    c = _client(monkeypatch)
+    with _dziennik(caplog) as d:
+        r = c.post("/logowanie", data={"login": "alicja", "haslo": "zgaduje-haslo"})
+    assert r.status_code == 401
+    entry = d.tekst
+    assert "logowanie-odmowa" in entry
+    assert "zgaduje-haslo" not in entry, "hasło trafiło do dziennika"
 
 
 def test_audit_logger_actually_emits(monkeypatch):