feat(auth): Forward-Auth via JWT-Cookie (YunoHost yunohost.portal)

Discovery zeigte: YunoHost reicht den Usernamen nicht als Header durch, sondern im
signierten Cookie "yunohost.portal" (JWT, Claim "user"). Die Forward-Auth liest jetzt
die Identitaet aus Header ODER Cookie - nur von der Proxy-Quell-IP akzeptiert.
HS256-Signaturpruefung optional via TRUSTED_AUTH_JWT_SECRET (stdlib hmac, kein Dep).

- config: trusted_auth_cookie / _cookie_claim / _jwt_secret
- nginx-Vorlage + deploy/README: keine Identitaets-Header-Zeile mehr noetig; SSO-Schutz
  der Subdomain ist Pflicht (sonst Spoofing)
- Tests: Cookie-Extraktion, Signaturpruefung, Proxy-IP-Trust

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

app/auth.py

@@ -1,3 +1,8 @@
+import base64
+import hashlib
+import hmac
+import json
+
 from fastapi import Header, HTTPException, Request
 
 from app.config import settings, Settings
@@ -9,6 +14,51 @@ def _csv_set(value: str) -> set[str]:
     return {item.strip() for item in (value or "").split(",") if item.strip()}
 
 
+def _b64url_decode(data: str) -> bytes:
+    return base64.urlsafe_b64decode(data + "=" * (-len(data) % 4))
+
+
+def _cookie_value(cookie_header: str | None, name: str) -> str | None:
+    """Liest einen Cookie-Wert robust aus dem Cookie-Header (ohne SimpleCookie)."""
+    if not cookie_header or not name:
+        return None
+    for part in cookie_header.split(";"):
+        part = part.strip()
+        if part.startswith(name + "="):
+            return part[len(name) + 1:]
+    return None
+
+
+def _username_from_cookie(headers, cfg: Settings) -> str | None:
+    """Extrahiert den Usernamen aus einem JWT-Cookie (z. B. YunoHost 'yunohost.portal').
+
+    Mit gesetztem `trusted_auth_jwt_secret` wird die HS256-Signatur geprueft. Ohne
+    Secret wird die Payload ungeprueft gelesen - das ist nur sicher, weil (a) nur die
+    Proxy-Quell-IP akzeptiert wird und (b) das SSO unauthentifizierte Anfragen gar nicht
+    erst durchlaesst (also nur vom SSO validierte Cookies hier ankommen).
+    """
+    token = _cookie_value(headers.get("cookie"), cfg.trusted_auth_cookie)
+    if not token or token.count(".") != 2:
+        return None
+    header_b64, payload_b64, sig_b64 = token.split(".")
+    secret = cfg.trusted_auth_jwt_secret.strip()
+    if secret:
+        expected = hmac.new(
+            secret.encode(), f"{header_b64}.{payload_b64}".encode(), hashlib.sha256
+        ).digest()
+        try:
+            if not hmac.compare_digest(expected, _b64url_decode(sig_b64)):
+                return None
+        except (ValueError, TypeError):
+            return None
+    try:
+        payload = json.loads(_b64url_decode(payload_b64))
+    except (ValueError, TypeError):
+        return None
+    value = payload.get(cfg.trusted_auth_cookie_claim)
+    return value.strip() if isinstance(value, str) and value.strip() else None
+
+
 def is_admin_user(user: User | None, cfg: Settings = settings) -> bool:
     """True, wenn der Nutzer (per SSO-Identitaet) in ADMIN_USERS steht."""
     if user is None or not user.external_id:
@@ -29,17 +79,22 @@ def authenticate(headers, client_host: str, token: str | None,
     """
     store = get_store()
 
-    # 1. Forward-/Trusted-Header-Auth (nur von der Proxy-Quell-IP akzeptiert).
-    if cfg.trusted_auth_header:
+    # 1. Forward-Auth: Identitaet aus Header ODER (signiertem) Cookie - nur von der
+    #    Proxy-Quell-IP akzeptiert.
+    if cfg.trusted_auth_header or cfg.trusted_auth_cookie:
         ips = _csv_set(cfg.trusted_proxy_ips)
         if ips and client_host in ips:
-            external = (headers.get(cfg.trusted_auth_header) or "").strip()
+            external = None
+            if cfg.trusted_auth_header:
+                external = (headers.get(cfg.trusted_auth_header) or "").strip() or None
+            if not external and cfg.trusted_auth_cookie:
+                external = _username_from_cookie(headers, cfg)
             if not external:
-                return None  # SSO sollte den Header immer setzen -> 401
+                return None  # SSO sollte die Identitaet immer liefern -> 401
             user = store.get_or_create_user_by_external_id(external, display_name=external)
             user.is_admin = is_admin_user(user, cfg)
             return user
-        # Nicht von der Proxy-IP -> Header ignorieren, normale Auth unten.
+        # Nicht von der Proxy-IP -> ignorieren, normale Auth unten.
 
     # 2. Auth abgeschaltet (dev/Test).
     if not cfg.auth_enabled:

app/config.py

@@ -146,6 +146,12 @@ class Settings(BaseSettings):
     # Identitaet aus diesem Header gelesen (SSO-User) und ein interner Nutzer
     # automatisch angelegt. Sonst gilt die normale Token-/Anonymous-Auth.
     trusted_auth_header: str = ""
+    # Alternativ zur Header-Variante: Identitaet aus einem (signierten) JWT-Cookie lesen.
+    # YunoHost reicht den Usernamen nicht als Header durch, sondern im Cookie
+    # "yunohost.portal" (JWT, Claim "user"). Nur von der Proxy-IP akzeptiert.
+    trusted_auth_cookie: str = ""        # Cookie-Name (z. B. yunohost.portal)
+    trusted_auth_cookie_claim: str = "user"  # JWT-Claim mit dem Usernamen
+    trusted_auth_jwt_secret: str = ""    # optional: HS256-Secret -> Signatur pruefen
     trusted_proxy_ips: str = ""        # kommasepariert; IP(s) des Reverse-Proxys
     admin_users: str = ""             # kommaseparierte SSO-Usernamen mit Admin-Rechten
     sso_logout_url: str = ""          # Logout-Link fuers Frontend (SSO-Portal)