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).
291 lines
10 KiB
Python
291 lines
10 KiB
Python
# 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
|