219 lines
8.6 KiB
Python
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}
|