diff --git a/backend/routers/liaison.py b/backend/routers/liaison.py new file mode 100644 index 0000000..4c4a296 --- /dev/null +++ b/backend/routers/liaison.py @@ -0,0 +1,218 @@ +# backend/routers/liaison.py +# Liaison d'appareil (#75) — flux « code d'appareil » émettant un +# jeton draco pour les clients natifs (TikTak Desktop d'abord). +# +# Protocole (miroir d'agent-commun, Fusion #45) : +# 1. l'app démarre une liaison : POST /api/v1/liaison (sans auth) +# -> code utilisateur XXXX-XXXX (10 min) + code d'appareil +# secret + URL de la page d'approbation ; +# 2. l'humain approuve (ou refuse) sur GET /liaison?code=... +# — session native ObsiGate exigée, jamais un jeton +# d'appareil ; la réponse d'approbation ne contient JAMAIS +# le jeton ; +# 3. l'app sonde : POST /api/v1/liaison/sonder -> en_attente / +# approuvee (+ jeton, livré UNE fois) / refusee / expiree / +# livree ; 404 si demande inconnue ou mauvais code ; +# 4. l'utilisateur gère ses appareils : GET /api/v1/appareils, +# POST /api/v1/appareils/{id}/revoquer (session exigée). +# +# Un jeton d'appareil présenté comme cookie draco authentifie +# comme une session draco (c'est un JWS draco standard), mais +# les endpoints de gestion et de décision le refusent avec 403 +# (garde ``_exiger_session_native``, patron ``_exiger_session`` +# d'agent-commun) ; présenté en ``Authorization: Bearer``, il +# est rejeté dès ``get_current_user`` (401) car ce n'est pas un +# jeton natif. + +from __future__ import annotations + +from pathlib import Path + +from fastapi import APIRouter, Depends, HTTPException, Request +from fastapi.responses import FileResponse +from pydantic import BaseModel, Field + +from backend import draco_appareils +from backend.auth.middleware import require_auth + +router = APIRouter(tags=["Liaison d'appareil"]) + +FRONTEND_DIR = Path(__file__).resolve().parent.parent.parent / "frontend" + + +def _exiger_session_native(user: dict) -> dict: + """Réserve une action aux sessions (native ou draco navigateur) : + un jeton d'appareil — porteur du claim ``appareil`` — ne gère + PAS les appareils et ne décide PAS des liaisons. Un jeton volé + ne peut donc ni frapper d'autres jetons ni couper ceux des + autres.""" + if user.get("_draco_appareil"): + raise HTTPException( + status_code=403, + detail="Un jeton d'appareil ne peut pas gérer les " + "appareils ni décider une liaison.") + return user + + +# ── Modèles ───────────────────────────────────────────────────────────── + +class LiaisonDemarrerIn(BaseModel): + """Demande de liaison d'une application sans identifiant.""" + + nom: str = Field(default="", description="Nom de l'appareil (hostname)") + type: str = Field(default="desktop", + description="Type d'appareil : desktop, terminal, tiktak") + + +class LiaisonDemarrerOut(BaseModel): + demande_id: str + code_utilisateur: str + code_appareil: str + expire_le: float + expire_dans_s: int + type: str + url_liaison: str + url_liaison_absolue: str + + +class LiaisonSonderIn(BaseModel): + demande_id: str + code_appareil: str + + +class LiaisonCodeIn(BaseModel): + code: str + + +class AppareilOut(BaseModel): + id: str + nom: str + portee: str + type: str + cree_le: float | None = None + derniere_utilisation: float | None = None + expire_le: int | None = None + revoque: bool = False + revoque_le: float | None = None + + +class LiaisonSonderOut(BaseModel): + statut: str + jeton: str | None = None + appareil: AppareilOut | None = None + + +class LiaisonEnAttenteOut(BaseModel): + code_utilisateur: str + nom: str + type: str + cree_le: float | None = None + expire_le: float | None = None + + +# ── Page d'approbation ────────────────────────────────────────────────── + +@router.get("/liaison", include_in_schema=False) +async def liaison_page(): + """Page publique d'approbation d'une liaison (``?code=XXXX-XXXX``, + saisie manuelle possible). La page elle-même n'exige rien : c'est + son JavaScript qui vérifie la session (``/api/auth/me``) puis + appelle les endpoints de décision.""" + page = FRONTEND_DIR / "liaison.html" + if not page.exists(): + raise HTTPException(status_code=404, detail="Page introuvable") + return FileResponse(str(page), media_type="text/html") + + +# ── Liaison ───────────────────────────────────────────────────────────── + +@router.post("/api/v1/liaison", status_code=201, + response_model=LiaisonDemarrerOut) +async def liaison_demarrer(body: LiaisonDemarrerIn, request: Request): + """Démarre une liaison d'appareil — SANS authentification : c'est + l'application qui demande (elle n'a encore aucun identifiant). + Elle reçoit le code utilisateur court à montrer à l'humain, un + code d'appareil secret pour sonder la décision, et l'URL de la + page d'approbation à ouvrir.""" + try: + res = draco_appareils.demarrer_liaison(body.nom, body.type) + except draco_appareils.ErreurLiaison as exc: + raise HTTPException(status_code=exc.statut, detail=exc.message) + res["url_liaison"] = "/liaison?code=" + res["code_utilisateur"] + base = str(request.base_url).rstrip("/") + res["url_liaison_absolue"] = base + res["url_liaison"] if base else "" + return res + + +@router.post("/api/v1/liaison/sonder", response_model=LiaisonSonderOut, + response_model_exclude_none=True) +async def liaison_sonder(body: LiaisonSonderIn): + """Le sondage de l'application : ``en_attente``, ``approuvee`` + (avec le jeton d'appareil, livré UNE fois), ``refusee``, + ``expiree`` ou ``livree`` (déjà consommée). Demande inconnue et + mauvais code d'appareil sont indiscernables (404) : sonder + n'apprend rien à qui n'a pas le code.""" + res = draco_appareils.sonder_liaison(body.demande_id, body.code_appareil) + if res is None: + raise HTTPException(status_code=404, + detail="Demande de liaison inconnue.") + return res + + +@router.get("/api/v1/liaison/en-attente") +async def liaisons_en_attente(user: dict = Depends(require_auth)): + """Les demandes de liaison en attente de décision — lues par la + page /liaison. Session exigée : un jeton d'appareil ne voit pas + les demandes.""" + _exiger_session_native(user) + return {"liaisons": draco_appareils.liaisons_en_attente()} + + +@router.post("/api/v1/liaison/approuver") +async def liaison_approuver(body: LiaisonCodeIn, + user: dict = Depends(require_auth)): + """Approuve une demande (session seulement) : l'appareil est créé + pour cet utilisateur ; son jeton attend la délivrance unique par + le sondage de l'application. La réponse ne contient JAMAIS le + jeton.""" + _exiger_session_native(user) + try: + appareil = draco_appareils.approuver_liaison(body.code, user) + except draco_appareils.ErreurLiaison as exc: + raise HTTPException(status_code=exc.statut, detail=exc.message) + return {"appareil": appareil} + + +@router.post("/api/v1/liaison/refuser") +async def liaison_refuser(body: LiaisonCodeIn, + user: dict = Depends(require_auth)): + """Refuse une demande en attente (session seulement).""" + _exiger_session_native(user) + ok = draco_appareils.refuser_liaison(body.code) + return {"refusee": ok} + + +# ── Appareils ─────────────────────────────────────────────────────────── + +@router.get("/api/v1/appareils") +async def appareils_lister(user: dict = Depends(require_auth)): + """Les appareils liés de l'utilisateur. Session seulement ; + aucune donnée d'authentification ne sort d'ici.""" + _exiger_session_native(user) + sub = str(user.get("id") or user.get("username") or "") + return {"appareils": draco_appareils.lister_appareils(sub)} + + +@router.post("/api/v1/appareils/{appareil_id}/revoquer") +async def appareils_revoquer(appareil_id: str, + user: dict = Depends(require_auth)): + """Révoque un appareil (session seulement) : l'accès est coupé + dès l'appel suivant du jeton, la liste de révocation draco + étant relue par les consommateurs à chaque validation.""" + _exiger_session_native(user) + sub = str(user.get("id") or user.get("username") or "") + ok = draco_appareils.revoquer_appareil(appareil_id, sub) + if not ok: + raise HTTPException(status_code=404, + detail="Appareil inconnu ou déjà révoqué.") + return {"revoque": True}