feat(astroklient-demo): sesje logowania zamiast HTTP Basic (LOG-34)

Demo idzie szeroko i do różnych osób, często na cudzych komputerach — więc
wyjście z aplikacji jest tu potrzebne bardziej niż w pełnej wersji, a Basic go
nie miał: przeglądarka zapamiętuje hasło i dosyła je sama przy każdym żądaniu.
Pierwszy klient zostawiał otwartą sesję drugiemu.

Ta sama konstrukcja co w pełnej aplikacji: własny ekran logowania, podpisane
ciasteczko (HMAC-SHA256), HttpOnly + SameSite=Strict, wylogowanie POST-em, kres
bezczynności i twardy, sito na adres powrotu, zdarzenia w dzienniku bez haseł.
Moduł session.py skopiowany, tak samo jak link_crypto — usługi są osobnymi
obrazami i nie importują się nawzajem.

DWIE RÓŻNICE WOBEC PEŁNEJ WERSJI, obie wynikające z tego, że demo nie ma
własnego wolumenu:

  * nazwa ciasteczka jest inna. Gdyby obie aplikacje stanęły kiedyś pod jedną
    domeną, ciasteczka o tej samej nazwie nadpisywałyby się i człowiek wypadałby
    z jednej, logując się do drugiej.
  * nie ma licznika pokolenia sesji, bo nie ma go gdzie zapisać. Zdalne
    unieważnienie robi się przez DEMO_USERS: usunięcie konta albo zmiana hasła
    NATYCHMIAST ubija jego otwarte sesje, bo odcisk poświadczenia w ciasteczku
    przestaje pasować. Osobny test tego pilnuje. Wylogowanie i tak działa
    natychmiast, bo polega na skasowaniu ciasteczka.

Klucz podpisu jest WŁASNY, nie ten z pełnej aplikacji: demo i produkcja nie mają
powodu uznawać nawzajem swoich sesji, a wspólny klucz znaczyłby, że sesja z demo
bywa ważna tam, gdzie nie powinna.

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

services/astroklient-demo/app/security.py

@@ -24,7 +24,7 @@ import time
 from collections import deque
 
 from fastapi import Request
-from fastapi.responses import HTMLResponse, JSONResponse
+from fastapi.responses import HTMLResponse, JSONResponse, RedirectResponse
 
 log = logging.getLogger("astroklient-demo.security")
 audit_log = logging.getLogger("astroklient-demo.audit")
@@ -32,7 +32,9 @@ audit_log = logging.getLogger("astroklient-demo.audit")
 _SCRYPT_N, _SCRYPT_R, _SCRYPT_P, _SCRYPT_LEN = 2**14, 8, 1, 32
 _HASH_PREFIX = "scrypt$"
 
-PUBLIC_PATHS = frozenset({"/health"})
+# /logowanie i /wyloguj poza bramką: inaczej żeby się zalogować, trzeba by być
+# zalogowanym, a wyjście nie działałoby po wygaśnięciu sesji.
+PUBLIC_PATHS = frozenset({"/health", "/logowanie", "/wyloguj"})
 PUBLIC_PREFIXES = ("/static/",)
 
 _hits: dict[str, deque[float]] = {}
@@ -92,20 +94,41 @@ def _secret_matches(spec: str, password: str) -> bool:
     return hmac.compare_digest(spec.encode("utf-8"), password.encode("utf-8"))
 
 
-def authenticate(header: str | None) -> str | None:
-    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
-    spec = accounts().get(user)
+def verify(login: str, password: str) -> str | None:
+    """Sprawdza login i hasło; zwraca login albo None.
+
+    Nieznany login i złe hasło traktujemy tak samo — odmowa nie mówi, które
+    konto istnieje, a przy demo rozdawanym szeroko to realna informacja."""
+    spec = accounts().get(login)
     if spec is None:
         return None
-    # Nieznany login i złe hasło traktujemy tak samo — odmowa nie mówi, które
-    # konto istnieje, a przy demo rozdawanym szeroko to realna informacja.
-    return user if _secret_matches(spec, password) else None
+    return login if _secret_matches(spec, password) else None
+
+
+def issue_session(login: str) -> str:
+    """Zawartość ciasteczka dla właśnie zalogowanego konta.
+
+    W ciasteczku ląduje ODCISK poświadczenia, więc zmiana hasła albo usunięcie
+    konta z DEMO_USERS unieważnia jego sesje samo z siebie. To jest tu jedyny
+    sposób zdalnego unieważnienia: demo nie ma gdzie trwale zapisywać stanu,
+    bo nie ma własnego wolumenu — a stan sesji na udziale z bazami klientów
+    byłby pomieszaniem dwóch zupełnie różnych rzeczy."""
+    from app import session
+
+    return session.issue(login, session.fingerprint(accounts().get(login) or ""), 0)
+
+
+def principal(request: Request) -> str | None:
+    """Ciasteczko → login zalogowanej osoby albo None."""
+    from app import session
+
+    dane = session.read(request.cookies.get(session.COOKIE))
+    if dane is None:
+        return None
+    spec = accounts().get(dane["login"])
+    if spec is None or session.fingerprint(spec) != dane["odcisk"]:
+        return None
+    return dane["login"]
 
 
 def client_ip(request: Request) -> str:
@@ -159,8 +182,39 @@ def audit_records(request: Request, count: int) -> None:
         pass
 
 
+def cookies_secure() -> bool:
+    """Ciasteczko tylko dla https. Wyłączane wyłącznie w pracy lokalnej po http —
+    inaczej przeglądarka po prostu go nie zapamięta i logowanie „nie działa"
+    bez żadnego komunikatu."""
+    return os.getenv("COOKIES_INSECURE", "").strip().lower() not in {"1", "true", "yes", "on"}
+
+
+def audit_login(request: Request, login: str, udane: bool) -> None:
+    """Zdarzenie logowania. Nieudane próby są ważniejsze od udanych: pojedyncza
+    nic nie znaczy, seria pod jednym adresem to ślad zgadywania haseł. Login tak,
+    hasło NIGDY."""
+    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 install(app) -> None:
+    from app import session
+
     _setup_audit_logging()
+
+    # Fail-closed: konta bez klucza podpisu to sesje nie do odróżnienia od
+    # podrobionych. Lepiej, żeby usługa nie wstała.
+    if auth_enabled() and not session.available():
+        raise session.SessionError(
+            "Konta demo są skonfigurowane, ale brakuje SESSION_SECRET — bez klucza "
+            "podpisu logowanie nie miałoby czym się bronić. openssl rand -hex 32")
+
     if not auth_enabled():
         log.warning(
             "UWAGA: brak kont (DEMO_USERS / DEMO_PASSWORD) — astroklient-demo stoi OTWARTY. "
@@ -178,16 +232,27 @@ def install(app) -> None:
             return JSONResponse({"detail": "Zbyt wiele żądań — spróbuj za chwilę."},
                                 status_code=429, headers={"Retry-After": "60"})
 
-        user = ""
+        user, odswiez = "", None
         if auth_enabled():
-            user = authenticate(request.headers.get("authorization")) or ""
+            user = principal(request) or ""
             if not user:
-                return HTMLResponse(
-                    "<h1>401 — wymagane logowanie</h1>", status_code=401,
-                    headers={"WWW-Authenticate": 'Basic realm="astroklient-demo"'})
+                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)
+            from app import session as _s
+
+            dane = _s.read(request.cookies.get(_s.COOKIE))
+            odswiez = _s.refresh(dane) if dane else None
         request.state.user = user
 
         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()))
         records = getattr(request.state, "audit_records", None)
         audit_log.info(
             "AUDYT user=%s ip=%s method=%s path=%s status=%s records=%s ms=%.0f",