# backend/routers/desktop_sso.py # Desktop (Tauri) — connexion avec un compte central dracodev (#230). # # L'application desktop sert son propre backend sur http://127.0.0.1 : le # cookie ``draco_session`` du site central (Domain=.dracodev.net) ne lui # parvient jamais. Ce module fait le pont **côté serveur desktop** : # # 1. POST /api/desktop/sso/start -> démarre une liaison d'appareil sur le # site central choisi (og / og-dev) via le flux existant # ``POST {central}/api/v1/liaison`` ; # 2. l'utilisateur approuve la liaison dans son navigateur (page publique # ``/liaison`` du central) ; # 3. POST /api/desktop/sso/poll -> sonde la liaison, récupère le jeton # draco (livré une seule fois), le valide auprès du central # (``GET {central}/api/auth/me`` avec le cookie draco) puis ouvre la # session de **l'admin local par défaut** (décision : le compte central # prouve l'identité, le desktop reste mono-utilisateur). # # Inerte hors desktop : toutes les routes répondent 404 tant que # ``OBSIGATE_DESKTOP_SSO`` n'est pas activé (le shell Tauri le pose sur le # backend embarqué ; l'application web Docker ne le définit jamais). Le # comportement de l'application web est donc inchangé. from __future__ import annotations import os import socket from urllib.parse import urlparse import httpx from fastapi import APIRouter, HTTPException, Request, Response from pydantic import BaseModel, Field from backend import draco_config router = APIRouter(prefix="/api/desktop/sso", tags=["Desktop SSO"], include_in_schema=False) ENV_FLAG = "OBSIGATE_DESKTOP_SSO" CENTRAL_TIMEOUT_SECONDS = 10.0 #: Hôtes centraux autorisés : les deux environnements proposés par le #: sélecteur desktop. Toute autre valeur est refusée (pas de SSRF arbitraire). CENTRAL_HOSTS = {"og.dracodev.net", "og-dev.dracodev.net"} def enabled() -> bool: """Vrai lorsque le backend tourne dans le shell desktop.""" return os.environ.get(ENV_FLAG, "").lower() in ("1", "true", "yes", "on") def _require_enabled() -> None: if not enabled(): raise HTTPException(status_code=404, detail="Not Found") def _require_loopback_origin(request: Request) -> None: """Refuse une requête navigateur d'une origine non locale. Le backend n'écoute que sur 127.0.0.1, mais une page web ouverte dans le navigateur pourrait émettre un POST vers localhost. Les requêtes du webview desktop portent ``Origin: http://127.0.0.1:`` ; toute autre origine est rejetée (une requête sans Origin — curl, test — reste permise). """ origin = (request.headers.get("origin") or "").strip() if not origin: return parsed = urlparse(origin) host = (parsed.hostname or "").lower() if parsed.scheme not in ("http", "https") or host not in ( "127.0.0.1", "localhost", "::1", ): raise HTTPException(status_code=403, detail="Origine non autorisée.") def central_url() -> str: """Base du site central choisi (prod/dev), validée. Priorité ``DRACO_OBSIGATE_URL`` puis la résolution d'écosystème de :mod:`backend.draco_config` (qui dérive ``-dev`` depuis l'agent). Seuls les deux hôtes centraux officiels sont acceptés. """ url = (os.environ.get("DRACO_OBSIGATE_URL", "").strip() or draco_config.app_url("obsigate")).rstrip("/") parsed = urlparse(url) host = (parsed.hostname or "").lower() if parsed.scheme != "https" or host not in CENTRAL_HOSTS: raise HTTPException( status_code=503, detail="Site central non configuré pour ObsiGate Desktop.", ) return url def _device_name() -> str: try: host = socket.gethostname().strip() except OSError: host = "" return f"ObsiGate Desktop ({host})" if host else "ObsiGate Desktop" def _central_post(path: str, payload: dict) -> dict: """POST JSON vers le central, erreurs traduites en HTTPException.""" try: with httpx.Client(timeout=CENTRAL_TIMEOUT_SECONDS) as client: resp = client.post(central_url() + path, json=payload) except httpx.HTTPError as exc: raise HTTPException( status_code=502, detail="Site central injoignable — vérifiez l'environnement choisi " "et votre connexion.", ) from exc if resp.status_code >= 400: detail = "" try: detail = str(resp.json().get("detail", "")) except (ValueError, AttributeError): detail = "" raise HTTPException( status_code=resp.status_code if 400 <= resp.status_code < 500 else 502, detail=detail or "Le site central a refusé la demande.", ) try: return resp.json() except ValueError as exc: raise HTTPException( status_code=502, detail="Réponse invalide du site central.", ) from exc def _central_me(token: str) -> dict: """Valide le jeton draco auprès du central (cookie ``draco_session``). Le jeton n'est jamais journalisé : il sert uniquement à cette requête serveur-à-serveur. Un jeton révoqué, expiré, ou dont le rôle Hub est « aucun » est refusé par le central (401/403), message relayé tel quel. """ try: with httpx.Client(timeout=CENTRAL_TIMEOUT_SECONDS) as client: resp = client.get( central_url() + "/api/auth/me", cookies={"draco_session": token}, ) except httpx.HTTPError as exc: raise HTTPException( status_code=502, detail="Impossible de vérifier le compte central (site injoignable).", ) from exc if resp.status_code in (401, 403): detail = "" try: detail = str(resp.json().get("detail", "")) except (ValueError, AttributeError): detail = "" raise HTTPException( status_code=resp.status_code, detail=detail or "Compte central refusé.", ) if resp.status_code != 200: raise HTTPException( status_code=502, detail="Le site central n'a pas pu valider le compte.", ) try: return resp.json() except ValueError as exc: raise HTTPException( status_code=502, detail="Réponse invalide du site central.", ) from exc def _local_admin() -> dict: """Compte admin local par défaut (décision #230). Priorité à ``OBSIGATE_ADMIN_USER`` s'il désigne un admin actif, puis ``admin``, puis le premier admin actif. Aucun compte créé ici : la connexion centralisée **ouvre** l'admin local existant. """ from backend.auth.user_store import get_all_users, get_user preferred = os.environ.get("OBSIGATE_ADMIN_USER", "admin") candidate = get_user(preferred) if candidate and candidate.get("role") == "admin" and candidate.get("active"): return candidate admins = [u for u in get_all_users() if u.get("role") == "admin" and u.get("active")] if not admins: raise HTTPException( status_code=500, detail="Aucun compte administrateur local actif : connectez-vous " "d'abord avec le mot de passe admin, ou créez un admin.", ) for admin in admins: if admin.get("username") == "admin": return get_user("admin") # type: ignore[return-value] return get_user(admins[0]["username"]) # type: ignore[return-value] class PollIn(BaseModel): """Sondage d'une demande de liaison + activation de la session locale.""" demande_id: str = Field(min_length=1) code_appareil: str = Field(min_length=1) remember_me: bool = True @router.get("/status") async def desktop_sso_status() -> dict: """État du pont pour l'interface (desktop uniquement).""" _require_enabled() try: url = central_url() except HTTPException: url = "" return { "enabled": True, "environment": os.environ.get("OBSIGATE_DESKTOP_ENV", "prod"), "central_url": url, } @router.post("/start") async def desktop_sso_start(request: Request) -> dict: """Démarre une liaison d'appareil sur le site central choisi.""" _require_enabled() _require_loopback_origin(request) result = _central_post( "/api/v1/liaison", {"nom": _device_name(), "type": "desktop"}, ) # Le central construit ``url_liaison_absolue`` depuis ``request.base_url`` : # derrière un reverse proxy qui ne transmet pas X-Forwarded-Proto, il peut # renvoyer ``http://og...``. On reconstruit toujours l'URL depuis le site # central configuré (https) et le chemin relatif — l'ouverture navigateur # exige https://*.dracodev.net. rel = result.get("url_liaison") if isinstance(rel, str) and rel.startswith("/"): result["url_liaison_absolue"] = central_url() + rel return result @router.post("/poll") async def desktop_sso_poll(body: PollIn, request: Request, response: Response) -> dict: """Sonde la liaison ; si approuvée, ouvre la session de l'admin local. Retourne ``{"statut": "en_attente"}`` tant que l'utilisateur n'a pas approuvé, puis la même charge que ``POST /api/auth/login`` (jeton local + cookie refresh) avec ``statut = "approuvee"``. """ _require_enabled() _require_loopback_origin(request) result = _central_post( "/api/v1/liaison/sonder", {"demande_id": body.demande_id, "code_appareil": body.code_appareil}, ) statut = str(result.get("statut", "")) if statut != "approuvee": return {"statut": statut} token = result.get("jeton") if not token: raise HTTPException( status_code=502, detail="Le site central n'a pas renvoyé de jeton de session.", ) central_user = _central_me(str(token)) admin = _local_admin() # Émission des jetons natifs locaux : mêmes cookies/format que /api/auth/login. from backend.auth.router import _issue_tokens payload = _issue_tokens( admin, admin["username"], bool(body.remember_me), response, request, ) payload["statut"] = "approuvee" payload["central_user"] = { "username": central_user.get("username"), "display_name": central_user.get("display_name"), "role": central_user.get("role"), } return payload