Merge branch 'main' into hub21-reglages-obsigate
CI / lint (pull_request) Successful in 1m16s
CI / security (pull_request) Failing after 18s
CI / test (pull_request) Successful in 3m48s
CI / build (pull_request) Successful in 13s
CI / e2e (pull_request) Failing after 15m6s

Résolution des conflits de version : la PR visait 2.85.2 depuis le
main 2.85.1, mais main est passé à 2.87.0 entre-temps. La livraison
HUB-21 (#229) devient 2.87.1 — VERSION, package.json, desktop
(Cargo.toml, Cargo.lock, tauri.conf.json), README FR/EN, CHANGELOG
(section [2.87.1] — 2026-11-17 au-dessus de [2.87.0]) et ROADMAP
resynchronisés. backend/main.py fusionné automatiquement (HUB-21 +
liaison d'appareil #75 cohabitent). Tests : hub_reglages, hub_roles,
version, barre, CSP, recherche verts ; suite complète verte ;
ruff et mypy propres.
This commit is contained in:
2026-11-17 17:16:57 -05:00
34 changed files with 2190 additions and 27 deletions
+18 -6
View File
@@ -375,12 +375,15 @@ async def refresh_token_endpoint(request: Request, response: Response):
}
@router.post("/logout")
async def logout(
request: Request,
response: Response,
):
"""Logout: revoke refresh and access tokens, then delete cookies."""
def apply_global_logout(request: Request, response: Response) -> None:
"""Déconnexion globale (Fusion ACC-3.1, #216) appliquée à ``response``.
Révoque les jetons natifs (refresh + access, BUG-027), révoque le
``jti`` du cookie partagé ``draco_session`` et efface les cookies.
Partagée entre ``POST /api/auth/logout`` (réponse JSON) et
``GET /sso/logout`` (redirection, BUG-122) : les deux entrées
terminent exactement la même session, celle de la suite entière.
"""
refresh_tok = request.cookies.get("refresh_token")
if refresh_tok:
payload = decode_token(refresh_tok)
@@ -421,6 +424,15 @@ async def logout(
response.delete_cookie("refresh_token", path="/api/auth/refresh")
response.delete_cookie("access_token", path="/")
response.delete_cookie("access_token", path="/api") # just in case
@router.post("/logout")
async def logout(
request: Request,
response: Response,
):
"""Logout: revoke refresh and access tokens, then delete cookies."""
apply_global_logout(request, response)
return {"message": "Deconnecte avec succes"}
+448
View File
@@ -0,0 +1,448 @@
# backend/draco_appareils.py
# Liaison d'appareil — flux « code d'appareil » (#75).
#
# Une application native (TikTak Desktop d'abord) ne peut pas obtenir
# le jeton central draco par le navigateur : ``draco_session`` est un
# cookie HttpOnly sur ``.dracodev.net`` et ``/sso/authorize`` refuse
# tout ``return_to`` hors ``*.dracodev.net``. Ce module émet donc, par
# ObsiGate elle-même, un jeton draco pour un appareil lié — en miroir
# de ``app/appareils.py`` d'agent-commun (Fusion #45, 0.50.0), dont
# il reprend le protocole :
#
# 1. l'application, qui n'a encore AUCUN identifiant, démarre une
# liaison : le service émet un code utilisateur court
# (``XXXX-XXXX``, 10 minutes) et un code d'appareil secret, que
# l'app garde pour sonder ;
# 2. l'app ouvre la page ``/liaison`` ; Bruno, connecté par sa
# session native ObsiGate, y voit la demande et l'APPROUVE (ou
# la refuse) — la décision exige une session, jamais un jeton
# d'appareil ;
# 3. l'app sonde : une fois approuvée, elle reçoit le jeton
# d'appareil — UNE fois : la délivrance est consommée à la
# première lecture ;
# 4. le jeton est un JWS draco standard (``draco_session``), de
# longue durée (10 ans, révocable) : il authentifie l'appareil
# auprès de toute application qui valide draco (TikTak en
# premier lieu). Il est RÉVOCABLE : la révocation pose
# ``revoque_le`` et révoque le jti draco, ce qui prend effet
# dès l'appel suivant (liste de révocation exposée par
# ``GET /api/sso/revocations``).
#
# Différences assumées avec agent-commun (documentées) :
# - le jeton n'est PAS opaque (``dka_``) : c'est un draco JWS,
# donc il est valable partout où draco est accepté — y compris
# chez ObsiGate elle-même comme session (mêmes gardes que la
# session navigateur : changement de mot de passe, rôle Hub) —
# et il porte le claim ``"appareil": "<id>"`` pour le
# distinguer. Les endpoints de gestion des appareils refusent
# expressément un jeton d'appareil (403) : un jeton volé ne
# peut ni gérer les appareils ni décider une liaison.
# - ObsiGate n'a pas de base de données : les demandes et les
# appareils vivent en JSON dans ``data/`` (même patron que
# ``draco_session.py`` : chargement paresseux, verrou, écriture
# atomique via fichier temporaire). Seule l'empreinte SHA-256
# du code d'appareil est stockée ; le jeton en clair ne
# transite que par la ligne de liaison, entre l'approbation et
# sa délivrance unique (la colonne est vidée à la délivrance,
# les lignes expirées sont purgées).
# - ``derniere_utilisation`` reste à ``None`` : l'émettrice ne
# voit jamais l'usage du jeton — seul le consommateur (TikTak)
# le voit. Le champ est conservé (à ``None``) pour la parité
# de forme avec agent-commun.
#
# Sécurité : jamais de secret en code/logs ; jamais de jeton
# dans une réponse d'approbation ni dans un journal.
from __future__ import annotations
import hashlib
import hmac
import json
import logging
import os
import secrets
import threading
import time
import uuid
from pathlib import Path
from backend import draco_session
logger = logging.getLogger("obsigate.draco_appareils")
LIAISONS_FILE = Path("data/draco_liaisons.json")
APPAREILS_FILE = Path("data/draco_appareils.json")
# Types d'appareils connus. « desktop » = un poste de travail
# (client historique) ; « terminal » = un poste DracoTerm/DracoSH
# (le jeton est celui DU POSTE, partagé par les deux programmes) ;
# « tiktak » = TikTak Desktop, type dédié pour ne pas l'ambiguïté
# avec un desktop générique dans la vue Appareils. Un type absent
# ou inconnu retombe sur le défaut, jamais en erreur : un client
# ancien ne casse pas la liaison.
TYPES_APPAREILS = ("desktop", "terminal", "tiktak")
TYPE_APPAREIL_DEFAUT = "desktop"
# Alphabet sans caractères ambigus (pas de I, L, O, 0, 1) : le
# code se lit et se recopie à la main sans hésitation.
ALPHABET_CODE = "ABCDEFGHJKMNPQRSTUVWXYZ23456789"
LIAISONS_MAX_EN_ATTENTE = 20
# Durée de vie du jeton d'appareil : longue durée comme ``dka_``
# (agent-commun), révocable — c'est le sens d'un appareil lié :
# un desktop ne doit pas se relier chaque jour. La révocation
# (liste ``/api/sso/revocations`` + ``revoque_le``) est le
# contrôle, pas l'expiration.
DEVICE_TOKEN_TTL_SECONDS = 10 * 365 * 24 * 3600 # 10 ans
_lock = threading.Lock()
_liaisons: dict[str, dict] | None = None # demande_id -> enregistrement
_appareils: dict[str, dict] | None = None # appareil_id -> enregistrement
def _expiration_min() -> float:
"""Durée de vie d'une demande de liaison (défaut 10 min)."""
try:
return float(os.environ.get("OBSIGATE_LIAISON_EXPIRATION_MIN", "10"))
except ValueError:
return 10.0
def _norm_type_appareil(valeur) -> str:
v = str(valeur or "").strip().lower()
return v if v in TYPES_APPAREILS else TYPE_APPAREIL_DEFAUT
class ErreurLiaison(Exception):
"""Refus propre d'une opération de liaison : message en
français + statut HTTP, traduits par la route."""
def __init__(self, message: str, statut: int = 400):
super().__init__(message)
self.message = message
self.statut = statut
def _hacher(valeur: str) -> str:
return hashlib.sha256(valeur.encode("utf-8")).hexdigest()
def _nouveau_code() -> str:
brut = "".join(secrets.choice(ALPHABET_CODE) for _ in range(8))
return f"{brut[:4]}-{brut[4:]}"
def _norm_code(code) -> str:
"""Normalise un code saisi ou reçu : majuscules, alphanumérique
seulement — « abcd-2345 », « ABCD 2345 » et « ABCD2345 » sont
le même code."""
return "".join(c for c in str(code or "").upper() if c.isalnum())
def _formater_code(code_norm: str) -> str:
return f"{code_norm[:4]}-{code_norm[4:]}" if len(code_norm) == 8 \
else code_norm
# ── Persistance JSON (patron draco_session.py) ─────────────────────────
def _charger(fichier: Path, cache: str) -> dict[str, dict]:
global _liaisons, _appareils
courant = _liaisons if cache == "liaisons" else _appareils
if courant is not None:
return courant
try:
data = json.loads(fichier.read_text(encoding="utf-8"))
store = {str(k): dict(v) for k, v in data.items()} \
if isinstance(data, dict) else {}
except (OSError, ValueError):
store = {}
if cache == "liaisons":
_liaisons = store
else:
_appareils = store
return store
def _sauver(fichier: Path, store: dict[str, dict]) -> None:
fichier.parent.mkdir(parents=True, exist_ok=True)
tmp = fichier.with_suffix(".tmp")
tmp.write_text(json.dumps(store), encoding="utf-8")
tmp.replace(fichier)
def _liaisons_store() -> dict[str, dict]:
return _charger(LIAISONS_FILE, "liaisons")
def _appareils_store() -> dict[str, dict]:
return _charger(APPAREILS_FILE, "appareils")
def _purger_expirees(maintenant: float) -> None:
store = _liaisons_store()
morts = [k for k, v in store.items()
if float(v.get("expire_le", 0)) < maintenant]
for k in morts:
row = store[k]
if row.get("statut") == "approuvee" and row.get("appareil_id"):
# Approuvée mais jamais délivrée : le jeton ne doit pas
# survivre à la demande — l'appareil est révoqué avec
# elle (son jti draco rejoint la liste de révocation).
appareils = _appareils_store()
cible = appareils.get(str(row["appareil_id"]))
if cible is not None and cible.get("revoque_le") is None:
cible["revoque_le"] = maintenant
if cible.get("jti"):
draco_session.revoke(
str(cible["jti"]),
int(cible.get("exp", maintenant)))
_sauver(APPAREILS_FILE, appareils)
del store[k]
if morts:
_sauver(LIAISONS_FILE, store)
# ── Liaison ────────────────────────────────────────────────────────────
def demarrer_liaison(nom: str, type_appareil: str = TYPE_APPAREIL_DEFAUT,
maintenant: float | None = None) -> dict:
"""Ouvre une demande de liaison (sans authentification : c'est
l'appareil qui demande). Retourne les éléments à montrer à
l'humain (code utilisateur) et à garder pour sonder (code
d'appareil, en clair ici seulement — son empreinte est stockée).
"""
maintenant = time.time() if maintenant is None else maintenant
with _lock:
_purger_expirees(maintenant)
store = _liaisons_store()
en_attente = [v for v in store.values()
if v.get("statut") == "en_attente"
and float(v.get("expire_le", 0)) >= maintenant]
if len(en_attente) >= LIAISONS_MAX_EN_ATTENTE:
raise ErreurLiaison(
"Trop de demandes de liaison en attente — réessayez dans "
"quelques minutes.", 429)
prises = {_norm_code(v["code_utilisateur"]) for v in en_attente}
code = _nouveau_code()
while _norm_code(code) in prises:
code = _nouveau_code()
code_appareil = secrets.token_urlsafe(24)
demande_id = uuid.uuid4().hex
expire_le = maintenant + _expiration_min() * 60.0
type_norm = _norm_type_appareil(type_appareil)
store[demande_id] = {
"id": demande_id,
"code_utilisateur": code,
"code_appareil_hash": _hacher(code_appareil),
"nom": (nom or "").strip()[:80],
"type": type_norm,
"statut": "en_attente",
"cree_le": maintenant,
"expire_le": expire_le,
"user_sub": "",
"appareil_id": None,
"jeton_livrable": None,
}
_sauver(LIAISONS_FILE, store)
return {"demande_id": demande_id, "code_utilisateur": code,
"code_appareil": code_appareil, "expire_le": expire_le,
"expire_dans_s": int(expire_le - maintenant),
"type": type_norm}
def _liaison_par_code(code) -> dict | None:
"""Retrouve une demande par son code utilisateur (comparaison
normalisée sur les demandes encore vivantes)."""
norm = _norm_code(code)
if len(norm) != 8:
return None
for row in _liaisons_store().values():
if row.get("statut") not in ("en_attente", "approuvee"):
continue
if _norm_code(row.get("code_utilisateur", "")) == norm:
return dict(row)
return None
def approuver_liaison(code, user: dict,
maintenant: float | None = None) -> dict:
"""Approuve une demande (session requise — vérifié par la
route) : crée l'appareil de l'utilisateur et dépose son jeton
draco dans la ligne, en attente de délivrance unique.
Retourne l'appareil public (jamais le jeton)."""
maintenant = time.time() if maintenant is None else maintenant
sub = str(user.get("id") or user.get("username") or "")
if not sub:
raise ErreurLiaison("Utilisateur introuvable.", 401)
with _lock:
liaison = _liaison_par_code(code)
if liaison is None or liaison.get("statut") != "en_attente":
raise ErreurLiaison(
"Code inconnu ou demande déjà traitée.", 404)
if float(liaison.get("expire_le", 0)) < maintenant:
store = _liaisons_store()
store[liaison["id"]]["statut"] = "expiree"
_sauver(LIAISONS_FILE, store)
raise ErreurLiaison(
"Ce code a expiré — relancez la liaison depuis "
"l'application.", 410)
appareil_id = uuid.uuid4().hex
token, jti, exp = draco_session.issue_token(
user, ttl_seconds=DEVICE_TOKEN_TTL_SECONDS,
extra_claims={"appareil": appareil_id})
appareils = _appareils_store()
appareils[appareil_id] = {
"id": appareil_id,
"user_sub": sub,
"nom": liaison.get("nom", ""),
"type": _norm_type_appareil(liaison.get("type")),
"jti": jti,
"exp": exp,
"cree_le": maintenant,
"derniere_utilisation": None,
"revoque_le": None,
}
_sauver(APPAREILS_FILE, appareils)
store = _liaisons_store()
store[liaison["id"]].update({
"statut": "approuvee",
"user_sub": sub,
"appareil_id": appareil_id,
"jeton_livrable": token,
})
# Dédoublonnage (vécu chez agent-commun le 2026-11-13) :
# relier un poste déjà lié sous le même nom créait un
# SOSIE. Une liaison approuvée REMPLACE les appareils
# actifs de même nom et de même type du même utilisateur :
# un poste = une ligne, un jeton vivant.
for autre in appareils.values():
if autre["id"] == appareil_id:
continue
if autre.get("user_sub") != sub:
continue
if autre.get("type") != _norm_type_appareil(liaison.get("type")):
continue
if autre.get("nom") != liaison.get("nom", ""):
continue
if autre.get("revoque_le") is not None:
continue
autre["revoque_le"] = maintenant
if autre.get("jti"):
draco_session.revoke(str(autre["jti"]),
int(autre.get("exp", maintenant)))
_sauver(APPAREILS_FILE, appareils)
_sauver(LIAISONS_FILE, store)
return _appareil_public(appareils[appareil_id])
def refuser_liaison(code, maintenant: float | None = None) -> bool:
"""Refuse une demande en attente. False si le code ne désigne
aucune demande en attente."""
maintenant = time.time() if maintenant is None else maintenant
with _lock:
liaison = _liaison_par_code(code)
if liaison is None or liaison.get("statut") != "en_attente":
return False
store = _liaisons_store()
store[liaison["id"]]["statut"] = "refusee"
_sauver(LIAISONS_FILE, store)
return True
def liaisons_en_attente(maintenant: float | None = None) -> list[dict]:
"""Les demandes qu'une session peut décider : code, nom
déclaré par l'app, échéance. Jamais le code d'appareil."""
maintenant = time.time() if maintenant is None else maintenant
rows = [dict(v) for v in _liaisons_store().values()
if v.get("statut") == "en_attente"
and float(v.get("expire_le", 0)) >= maintenant]
rows.sort(key=lambda r: r.get("cree_le", 0))
return [{"code_utilisateur": r["code_utilisateur"],
"nom": r.get("nom", ""), "type": r.get("type", "desktop"),
"cree_le": r.get("cree_le"),
"expire_le": r.get("expire_le")} for r in rows]
def sonder_liaison(demande_id: str, code_appareil: str,
maintenant: float | None = None) -> dict | None:
"""Le sondage de l'application : None si la demande est
inconnue ou si le code d'appareil ne correspond pas (les deux
cas sont indiscernables, volontairement). À l'approbation, le
jeton est livré UNE fois puis la ligne est vidée."""
maintenant = time.time() if maintenant is None else maintenant
with _lock:
row = _liaisons_store().get(str(demande_id or ""))
if row is None:
return None
if not hmac.compare_digest(str(row.get("code_appareil_hash", "")),
_hacher(code_appareil or "")):
return None
statut = row.get("statut")
if statut == "en_attente" \
and float(row.get("expire_le", 0)) < maintenant:
store = _liaisons_store()
store[row["id"]]["statut"] = "expiree"
_sauver(LIAISONS_FILE, store)
return {"statut": "expiree"}
if statut == "approuvee":
jeton = row.get("jeton_livrable")
store = _liaisons_store()
store[row["id"]]["statut"] = "livree"
store[row["id"]]["jeton_livrable"] = None
_sauver(LIAISONS_FILE, store)
appareil = _appareils_store().get(str(row.get("appareil_id") or ""))
return {"statut": "approuvee", "jeton": jeton,
"appareil": _appareil_public(appareil)}
return {"statut": statut}
# ── Appareils ──────────────────────────────────────────────────────────
def _appareil_public(row) -> dict:
"""La forme publique d'un appareil : identité et état —
jamais le jti ni quoi que ce soit qui authentifie."""
if row is None:
return {}
d = dict(row)
return {"id": d["id"], "nom": d.get("nom", ""),
"portee": "client",
"type": _norm_type_appareil(d.get("type")),
"cree_le": d.get("cree_le"),
"derniere_utilisation": d.get("derniere_utilisation"),
"expire_le": d.get("exp"),
"revoque": d.get("revoque_le") is not None,
"revoque_le": d.get("revoque_le")}
def lister_appareils(user_sub: str) -> list[dict]:
"""Les appareils de l'utilisateur, actifs d'abord puis les
révoqués (l'historique reste lisible)."""
rows = [v for v in _appareils_store().values()
if v.get("user_sub") == str(user_sub)]
rows.sort(key=lambda r: (r.get("revoque_le") is not None,
-(r.get("cree_le") or 0)))
return [_appareil_public(r) for r in rows]
def revoquer_appareil(appareil_id: str, user_sub: str,
maintenant: float | None = None) -> bool:
"""Révoque un appareil de l'utilisateur : pose ``revoque_le``
et révoque le jti draco — effet immédiat, la liste de
révocation étant relue par les consommateurs à chaque
validation. False si l'appareil est inconnu, à un autre
utilisateur, ou déjà révoqué."""
maintenant = time.time() if maintenant is None else maintenant
with _lock:
store = _appareils_store()
row = store.get(str(appareil_id or ""))
if row is None or row.get("user_sub") != str(user_sub):
return False
if row.get("revoque_le") is not None:
return False
row["revoque_le"] = maintenant
_sauver(APPAREILS_FILE, store)
if row.get("jti"):
draco_session.revoke(str(row["jti"]),
int(row.get("exp", maintenant)))
return True
+23 -3
View File
@@ -242,10 +242,18 @@ def revoke_one_for_user(sub: str, jti: str) -> bool:
# ── Émission / vérification ─────────────────────────────────────────────
def issue_token(user: dict) -> tuple[str, str, int]:
"""Émet un JWS pour l'utilisateur. Retourne (jeton, jti, exp)."""
def issue_token(user: dict, ttl_seconds: int = TOKEN_TTL_SECONDS,
extra_claims: dict | None = None) -> tuple[str, str, int]:
"""Émet un JWS pour l'utilisateur. Retourne (jeton, jti, exp).
``ttl_seconds`` permet une durée de vie différente de la
session navigateur (la liaison d'appareil, #75, émet des
jetons de longue durée) ; ``extra_claims`` ajoute des claims
non réservés (ex. ``{"appareil": "<id>"}`` pour un jeton
d'appareil — les claims réservés ``sub``/``name``/``iat``/
``exp``/``jti`` ne sont jamais écrasés)."""
now = int(time.time())
exp = now + TOKEN_TTL_SECONDS
exp = now + int(ttl_seconds)
jti = uuid.uuid4().hex
claims = {
"sub": str(user.get("id") or user.get("username") or ""),
@@ -254,6 +262,10 @@ def issue_token(user: dict) -> tuple[str, str, int]:
"exp": exp,
"jti": jti,
}
if extra_claims:
for key, value in extra_claims.items():
if key not in claims:
claims[key] = value
token = jwt.encode(claims, _secret(), algorithm=ALGORITHM)
_register_issued(str(claims["sub"]), jti, exp)
return token, jti, exp
@@ -345,6 +357,14 @@ def user_for_draco(request) -> dict | None:
user["_token_vaults"] = candidate.get("vaults", [])
user["_token_scope"] = "full"
user["_draco_sub"] = sub
# Liaison d'appareil (#75) : un jeton portant le claim
# ``appareil`` est un jeton d'appareil, pas une session
# navigateur — l'identifiant est joint au dict pour que
# les endpoints de gestion des appareils le refusent (403).
# Les autres gardes (mot de passe, rôle Hub) s'appliquent
# à l'identique : un jeton d'appareil est un jeton draco.
if claims.get("appareil"):
user["_draco_appareil"] = str(claims["appareil"])
# HUB-19 (#228) : rôle du registre du Hub pour ce porteur.
# Niveau connu « aucun » → pas de session établie par draco :
# le refus est consigné sur la requête pour que `require_auth`
+2
View File
@@ -562,6 +562,7 @@ from backend.routers.files_read import router as files_read_router
from backend.routers.files_write import router as files_write_router
from backend.routers.health import router as health_router
from backend.routers.history import router as history_router
from backend.routers.liaison import router as liaison_router
from backend.routers.notify import router as notify_router
from backend.routers.realtime import router as realtime_router
from backend.routers.scheduler import router as scheduler_router
@@ -580,6 +581,7 @@ app.include_router(health_router) # ROADMAP #85 T1 — System / health
app.include_router(history_router) # ROADMAP #85 T8 — History
app.include_router(external_refs_router) # Fusion #215 — Références croisées (ACC-1.3)
app.include_router(sso_router) # Fusion #216 — Émettrice SSO draco_session (ACC-3.1)
app.include_router(liaison_router) # #75 — Liaison d'appareil (jeton draco)
app.include_router(realtime_router) # ROADMAP #85 T9 — SSE + collab WS
app.include_router(search_router) # ROADMAP #85 T5 — Search
app.include_router(backups_router) # ROADMAP #85 T4 — Backups
+1
View File
@@ -30,6 +30,7 @@ TAGS_METADATA: list[dict[str, str]] = [
{"name": "Bookmarks", "description": "Recently opened files, bookmarks and saved searches."},
{"name": "ExternalRefs", "description": "Cross-application references from a note to Flowdeck, TikTak, Kanbante or ObsiGate objects (Fusion program, ACC-1.3)."},
{"name": "SSO", "description": "draco_session single sign-on emitter: authorize entry point and jti revocation list for the other dracodev apps (Fusion program, ACC-3.1)."},
{"name": "Liaison d'appareil", "description": "Device-code linking for native clients (TikTak Desktop first): start a link, approve it in the browser, poll for the long-lived draco token, list and revoke linked devices (#75)."},
{"name": "Backups", "description": "Automatic file backups, diffs, restore, compression and purge."},
{"name": "Export", "description": "Export notes or whole vaults to HTML, Markdown bundle or ePub."},
{"name": "Guide", "description": "Download the in-app user guide as Markdown or PDF (mirrors the help modal, FR/EN)."},
+218
View File
@@ -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}
+17
View File
@@ -11,6 +11,14 @@
# GET /api/sso/revocations : liste des jti révoqués, réservée aux
# autres applications (clé machine DRACO_SSO_MACHINE_KEY, en-tête
# X-Draco-Machine-Key) qui la mettent en cache 60 s (design §5.2).
#
# GET /sso/logout?return_to=<url> : symétrique de /sso/authorize —
# point d'entrée navigable de la déconnexion globale (BUG-122,
# fusion #141). Les autres applications y naviguent depuis leur menu
# compte ; la déconnexion exécutée est celle de POST /api/auth/logout
# (logique partagée : jetons natifs révoqués, jti draco révoqué,
# cookie effacé sur le domaine parent), puis redirection vers le
# return_to validé (même liste blanche ; repli « / »).
from __future__ import annotations
@@ -21,6 +29,7 @@ from fastapi import APIRouter, HTTPException, Request
from fastapi.responses import RedirectResponse
from backend import draco_session
from backend.auth.router import apply_global_logout
router = APIRouter(tags=["SSO"])
@@ -34,6 +43,14 @@ async def sso_authorize(return_to: str = ""):
return RedirectResponse(url="/", status_code=302)
@router.get("/sso/logout")
async def sso_logout(request: Request, return_to: str = ""):
target = draco_session.validate_return_to(return_to)
response = RedirectResponse(url=target or "/", status_code=302)
apply_global_logout(request, response)
return response
@router.get("/api/sso/revocations")
async def sso_revocations(request: Request):
machine_key = os.environ.get("DRACO_SSO_MACHINE_KEY", "")