Files
ObsiGate/backend/routers/liaison.py

219 lines
8.6 KiB
Python

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