feat: desktop — connexion compte central + environnement prod/dev (#230)
CI / lint (push) Failing after 29s
CI / test (push) Skipped
CI / build (push) Skipped
CI / e2e (push) Skipped
CI / security (push) Failing after 16s

Liaison d'appareil sur og/og-dev, validation du jeton draco et ouverture de la session de l'admin local. Sélecteur prod/dev (Configuration + premier lancement), admin local par défaut admin/chab30, sans impact sur le web Docker. Inclut BUG-126 (runtime python-embed/_pth + copie de backend/frontend + signature updater opt-in) et BUG-127 (retour /liaison même hôte).
This commit is contained in:
2026-11-20 07:19:08 -05:00
parent 5794595d88
commit f77b0e6574
34 changed files with 1789 additions and 119 deletions
+290
View File
@@ -0,0 +1,290 @@
# 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:<port>`` ; 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