# 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}