# 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": ""`` 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