From 55a41713131a5524ee2ad57e47c0f33f6ab57224 Mon Sep 17 00:00:00 2001 From: bruno Date: Mon, 16 Nov 2026 17:28:05 -0500 Subject: [PATCH] =?UTF-8?q?feat:=20liaison=20d'appareil=20=E2=80=94=20flux?= =?UTF-8?q?=20code=20d'appareil=20=C3=A9mettant=20un=20jeton=20draco=20(#7?= =?UTF-8?q?5,=202.87.0)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- backend/draco_appareils.py | 448 +++++++++++++++++++++++++++++++++++++ 1 file changed, 448 insertions(+) create mode 100644 backend/draco_appareils.py diff --git a/backend/draco_appareils.py b/backend/draco_appareils.py new file mode 100644 index 0000000..f8b3984 --- /dev/null +++ b/backend/draco_appareils.py @@ -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": ""`` 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