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/app/security.py

@@ -45,7 +45,7 @@ from collections import deque
 from dataclasses import dataclass
 
 from fastapi import Request
-from fastapi.responses import HTMLResponse, JSONResponse
+from fastapi.responses import HTMLResponse, JSONResponse, RedirectResponse
 
 log = logging.getLogger("astrololo.security")
 
@@ -114,6 +114,15 @@ def rate_limit_per_min() -> int:
     return int(os.getenv("RATE_LIMIT_PER_MIN", "120"))
 
 
+def cookies_secure() -> bool:
+    """Czy ciasteczko sesji ma być wyłącznie dla https.
+
+    Domyślnie TAK. Wyłączamy jedynie w pracy lokalnej po http — inaczej
+    przeglądarka po prostu nie zapamięta ciasteczka i logowanie „nie działa"
+    bez żadnego komunikatu, co jest wyjątkowo mylącą awarią."""
+    return os.getenv("COOKIES_INSECURE", "").strip().lower() not in {"1", "true", "yes", "on"}
+
+
 def trust_proxy() -> bool:
     return os.getenv("TRUST_PROXY", "").strip().lower() in {"1", "true", "yes", "on"}
 
@@ -122,7 +131,9 @@ def trust_proxy() -> bool:
 # odpowiedzieć 401 CELOWO, zamiast dostać 200 od zalogowanej sesji. Bez tego
 # wylogowanie byłoby niemożliwe — przeglądarka dosyła zapamiętane dane przy każdym
 # żądaniu, więc handler i tak widziałby zalogowaną osobę.
-PUBLIC_PATHS = frozenset({"/health", "/wyloguj"})
+# /logowanie MUSI stać poza bramką — inaczej żeby się zalogować, trzeba by być
+# zalogowanym. /wyloguj też: ma działać także wtedy, gdy sesja już wygasła.
+PUBLIC_PATHS = frozenset({"/health", "/logowanie", "/wyloguj"})
 PUBLIC_PREFIXES = ("/static/",)
 
 _hits: dict[str, deque[float]] = {}
@@ -146,53 +157,99 @@ class Principal:
 
 
 def _admin_permissions() -> frozenset[str]:
-    """Administrator widzi wszystko — z definicji, bez wpisywania listy ręcznie.
+    """Administrator widzi wszystko — z definicji, bez wypisywania listy ręcznie.
 
-    Liczone z katalogu, więc dopisanie nowej funkcji NIE wymaga pamiętania
-    o koncie administracyjnym. Przeciwnie byłoby cichą pułapką: nowa funkcja
-    byłaby niewidoczna dla jedynej osoby, która ma ją komu nadać."""
+    Liczone z katalogu, więc dopisanie funkcji NIE wymaga pamiętania o koncie
+    administracyjnym. Przeciwnie byłoby cichą pułapką: nowa funkcja byłaby
+    niewidoczna dla jedynej osoby, która ma ją komu nadać."""
     from app import features
 
     return frozenset(features.GRANTABLE) | {features.ADMIN}
 
 
-def principal(header: str | None) -> Principal | None:
-    """Nagłówek Basic → kto to jest i co mu wolno; None, gdy dane nie pasują.
+def _admin_spec(login: str) -> str | None:
+    """Sekret konta administracyjnego z KONFIGURACJI ŚRODOWISKA albo None.
 
-    Kolejność: najpierw konta z KONFIGURACJI ŚRODOWISKA (administracyjne, pełne
-    uprawnienia), potem konta zarządzane z ekranu. Nie odwrotnie — inaczej
-    założenie w pliku konta o loginie administratora przesłoniłoby konto
-    administracyjne i odebrało mu uprawnienia.
+    Sprawdzane ZAWSZE PIERWSZE i bez dotykania pliku kont — to jest cała
+    separacja konta administracyjnego (LOG-34):
 
-    Nieznany login i złe hasło traktujemy tak samo: odmowa nie mówi, które konto
-    istnieje."""
-    if not header or not header.lower().startswith("basic "):
-        return None
-    try:
-        raw = base64.b64decode(header.split(" ", 1)[1]).decode("utf-8")
-        user, _, password = raw.partition(":")
-    except (binascii.Error, UnicodeDecodeError, IndexError):
-        return None
+      * konto z pliku o tym samym loginie nie przesłoni administratora, bo do
+        pliku w ogóle nie zaglądamy, gdy login pasuje do konfiguracji,
+      * administrator zaloguje się nawet wtedy, gdy plik kont jest uszkodzony
+        albo nieczytelny — 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ść.
+    """
+    return accounts().get(login)
 
-    spec = accounts().get(user)
+
+def verify(login: str, password: str) -> Principal | None:
+    """Sprawdza login i hasło. None = odmowa, bez podawania powodu.
+
+    Nieznany login i złe hasło dają ten sam wynik: rozróżnienie mówiłoby, które
+    konta istnieją, a to informacja warta czegoś dla zgadującego."""
+    spec = _admin_spec(login)
     if spec is not None:
-        return (Principal(user, _admin_permissions(), True)
-                if _secret_matches(spec, password) else None)
+        return Principal(login, _admin_permissions(), True) if _secret_matches(spec, password) else None
 
     from app import accounts as store
 
-    managed = store.secret_of(user)
-    if managed is None:
+    try:
+        zapisany = store.secret_of(login)
+    except store.AccountsUnavailable:
+        # Magazyn kont niedostępny — konta zarządzane nie mogą się zalogować,
+        # ale administrator (wyżej) już przeszedł, więc jest kto to naprawi.
         return None
-    if not _secret_matches(managed, password):
+    if zapisany is None or not _secret_matches(zapisany, password):
         return None
-    return Principal(user, store.permissions_of(user), False)
+    return Principal(login, store.permissions_of(login), False)
 
 
-def authenticate(header: str | None) -> str | None:
-    """Sam LOGIN — do dziennika audytowego (PRE-17) i zgodności wstecz."""
-    who = principal(header)
-    return who.login if who else None
+def issue_session(login: str) -> str:
+    """Zawartość ciasteczka dla właśnie zalogowanego konta.
+
+    W ciasteczku ląduje ODCISK poświadczenia, dzięki czemu zmiana hasła albo
+    skasowanie konta unieważnia jego sesje same z siebie — bez pamiętania o tym
+    i bez żadnego magazynu sesji."""
+    from app import accounts as store
+    from app import session
+
+    spec = _admin_spec(login)
+    if spec is not None:
+        return session.issue(login, session.fingerprint(spec), 0)
+    return session.issue(login, session.fingerprint(store.secret_of(login) or ""),
+                         store.session_version(login))
+
+
+def principal(request: Request) -> Principal | None:
+    """Ciasteczko → kto to jest i co mu wolno. None = nie wpuszczać."""
+    from app import session
+
+    dane = session.read(request.cookies.get(session.COOKIE))
+    if dane is None:
+        return None
+    login = dane["login"]
+
+    spec = _admin_spec(login)
+    if spec is not None:
+        # Zmiana APP_PASSWORD ubija sesje administratora — to jest jego
+        # odpowiednik „wyloguj mnie ze wszystkich urządzeń".
+        if session.fingerprint(spec) != dane["odcisk"]:
+            return None
+        return Principal(login, _admin_permissions(), True)
+
+    from app import accounts as store
+
+    try:
+        zapisany = store.secret_of(login)
+        wersja = store.session_version(login)
+    except store.AccountsUnavailable:
+        return None
+    if zapisany is None or session.fingerprint(zapisany) != dane["odcisk"]:
+        return None
+    if wersja != dane["wersja"]:
+        return None
+    return Principal(login, store.permissions_of(login), False)
 
 
 def client_ip(request: Request) -> str:
@@ -270,6 +327,22 @@ def audit_records(request: Request, count: int) -> None:
         pass
 
 
+def audit_login(request: Request, login: str, udane: bool) -> None:
+    """Zdarzenie logowania w dzienniku (PRE-17).
+
+    Nieudane próby są tu ważniejsze od udanych: pojedyncza nic nie znaczy, ale
+    seria pod jednym adresem to jedyny widoczny ślad zgadywania haseł. Logujemy
+    LOGIN, nigdy hasła ani jego fragmentu — dziennik to kolejny nośnik wycieku."""
+    audit_log.info("AUDYT zdarzenie=%s user=%s ip=%s",
+                   "logowanie-ok" if udane else "logowanie-odmowa",
+                   login or "-", client_ip(request))
+
+
+def audit_logout(request: Request) -> None:
+    audit_log.info("AUDYT zdarzenie=wylogowanie user=%s ip=%s",
+                   getattr(request.state, "user", "") or "-", client_ip(request))
+
+
 def _audit(request: Request, user: str, status: int, ms: float) -> None:
     records = getattr(request.state, "audit_records", None)
     audit_log.info(
@@ -280,8 +353,20 @@ def _audit(request: Request, user: str, status: int, ms: float) -> None:
 
 
 def install(app) -> None:
-    """Podpina ochronę pod wszystkie ścieżki poza /health i /static."""
+    """Podpina ochronę pod wszystkie ścieżki poza publicznymi."""
+    from app import session
+
     _setup_audit_logging()
+
+    # FAIL-CLOSED. Usługa z kontami, ale bez klucza podpisu, nie umiałaby odróżnić
+    # ważnej sesji od podrobionej. Lepiej, żeby nie wstała, niż żeby wpuszczała —
+    # i lepiej teraz, przy starcie, niż przy pierwszym logowaniu człowieka.
+    if auth_enabled() and not session.available():
+        raise session.SessionError(
+            "Konta są skonfigurowane, ale brakuje SESSION_SECRET — bez klucza "
+            "podpisu sesje nie działają, a logowanie nie miałoby czym się bronić. "
+            "Wygeneruj: openssl rand -hex 32")
+
     if not auth_enabled():
         log.warning(
             "UWAGA: brak kont (APP_USERS / APP_PASSWORD) — aplikacja jest OTWARTA "
@@ -311,16 +396,27 @@ def install(app) -> None:
 
         from app import features
 
-        user, who = "", None
+        user, who, odswiez = "", None, None
         if auth_enabled():
-            who = principal(request.headers.get("authorization"))
+            who = principal(request)
             if who is None:
-                _audit(request, "-", 401, (time.monotonic() - started) * 1000)
-                return HTMLResponse(
-                    "<h1>401 — wymagane logowanie</h1>", status_code=401,
-                    headers={"WWW-Authenticate": 'Basic realm="astrololo"'},
-                )
+                _audit(request, "-", 303, (time.monotonic() - started) * 1000)
+                # Przekierowanie na ekran logowania, nie 401: 401 z Basic otwierało
+                # okienko systemowe, którego nie da się ani opisać, ani z niego wyjść.
+                # Zapamiętujemy, dokąd ktoś zmierzał — po zalogowaniu wraca na miejsce.
+                from urllib.parse import quote
+
+                cel = request.url.path
+                dokad = f"?dokad={quote(cel, safe='/')}" if request.method == "GET" and cel != "/" else ""
+                return RedirectResponse(f"/logowanie{dokad}", status_code=303)
             user = who.login
+            # Ruch przedłuża sesję, ale ciasteczko odsyłamy tylko wtedy, gdy
+            # znacznik zdążył się zestarzeć — inaczej Set-Cookie leciałby przy
+            # każdym obrazku i arkuszu stylów.
+            from app import session as _s
+
+            dane = _s.read(request.cookies.get(_s.COOKIE))
+            odswiez = _s.refresh(dane) if dane else None
         else:
             # Bez kont ochrona jest wyłączona (dev), więc widać wszystko — inaczej
             # deweloper zobaczyłby pustą aplikację i szukałby błędu tam, gdzie go nie ma.
@@ -336,5 +432,10 @@ def install(app) -> None:
             _audit(request, user, 404, (time.monotonic() - started) * 1000)
             return HTMLResponse("<h1>404 — nie znaleziono</h1>", status_code=404)
         response = await call_next(request)
+        if odswiez:
+            from app import session as _s
+
+            response.set_cookie(_s.COOKIE, odswiez, max_age=_s.max_age(),
+                                **_s.cookie_params(secure=cookies_secure()))
         _audit(request, user, response.status_code, (time.monotonic() - started) * 1000)
         return response