diff --git a/CHANGELOG.md b/CHANGELOG.md index 2d32549..4840dd0 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,7 +6,7 @@ Format basé sur [Keep a Changelog](https://keepachangelog.com/fr/1.1.0/), et [Semantic Versioning](https://semver.org/spec/v2.0.0.html). > **En cours de développement** : les changements à venir sont listés dans la section -> [Unreleased](#unreleased). La dernière version livrée est **2.86.3**. +> [Unreleased](#unreleased). La dernière version livrée est **2.87.0**. --- @@ -14,6 +14,12 @@ et [Semantic Versioning](https://semver.org/spec/v2.0.0.html). --- +## [2.87.0] — 2026-11-16 + +- **#75 — Liaison d'appareil : flux « code d'appareil » émettant un jeton draco** (demande de Bruno, 2026-11-16 : faire fonctionner l'authentification TikTak Desktop avec le jeton central draco — option A) : une application native démarre une liaison (`POST /api/v1/liaison`, code `XXXX-XXXX`, 10 min), l'utilisateur approuve sur la page publique `GET /liaison?code=…` (session exigée, saisie manuelle possible, FR/EN), l'app sonde (`POST /api/v1/liaison/sonder`) et reçoit UNE fois un JWS draco de longue durée (10 ans, révocable, claim `"appareil"`) — valable auprès de toute application qui valide draco (TikTak en premier lieu). Gestion : `GET /api/v1/appareils`, `POST /api/v1/appareils/{id}/revoquer` (révocation immédiate via `revoked_list`) ; un jeton d'appareil ne peut ni gérer les appareils ni décider une liaison (403 en cookie, 401 en Bearer). Types `desktop` / `terminal` / `tiktak` ; dédoublonnage même nom+type ; gardes HUB-19 (rôle « aucun » → 403 explicite) et changement de mot de passe appliquées comme à la session draco. Nouveau module `backend/draco_appareils.py` (JSON `data/`, même patron que `draco_session.py`), `issue_token` accepte `ttl_seconds` + `extra_claims`. Fiche : `docs/features/liaison-appareil-draco.md`. Tests : `tests/test_draco_liaison.py` (13 tests) + flux complet vérifié contre un serveur réel. + +--- + ## [2.86.3] — 2026-11-08 - **BUG-125 — Aller-retour SSO : le pont de l'application sœur reçoit à nouveau le cookie `draco_session` quand les cookies ont disparu sous une session `sessionStorage` encore « valide »** (suite du chantier « entrée SSO », retest réel de Bruno le 2026-11-08 après le correctif BUG-123 et celui du retour sur le bon hôte) : le retour tombait bien sur l'application demanderesse, mais son pont ne voyait **aucun jeton** et déposait l'utilisateur devant le formulaire, sans message. Chaîne fautive : cookies `access_token` et `draco_session` absents alors que la session semble valide en `sessionStorage` → le chemin court d'`initAuth()` (restauration sans échange serveur, BUG-123) honore le `return_to` immédiatement — le middleware de renouvellement (`DracoRenewalMiddleware`) n'a aucune requête authentifiée à traverser, donc aucune occasion de réémettre le cookie draco manquant. Correctif (`frontend/js/auth.js`) : quand la page est l'arrivée d'un `/sso/authorize` (`return_to` présent), le chemin court est écarté et `initAuth()` passe par le refresh silencieux (cookie refresh, 7 j) suivi de `/api/auth/me` — la réponse traverse le middleware, qui réémet le cookie draco absent ou invalide **avant** que le retour soit honoré ; si le refresh échoue, l'écran de connexion s'affiche comme avant (le `return_to` reste dans l'URL, `saveToken` l'honorera après login frais). Hors arrivée `authorize`, le démarrage est inchangé. Garde : `tests/test_draco_barre.py` (`test_retour_sso_refresh_force_bug_125`) ; variante fautive reproduite puis vérifiée en navigateur réel dans la pile « conteneur dev réel » (requête du pont journalisée : sans cookie draco avant correctif, avec cookie et session ouverte après). Fiche : `docs/features/retour-sso-cookie-draco-bug-125.md`. diff --git a/README.fr.md b/README.fr.md index 5d27881..ee9a474 100644 --- a/README.fr.md +++ b/README.fr.md @@ -4,7 +4,7 @@ **Porte d'entrée web ultra-léger pour vos vaults Obsidian** — Accédez, naviguez et recherchez dans toutes vos notes Obsidian depuis n'importe quel appareil via une interface web moderne et responsive. -[![Version](https://img.shields.io/badge/Version-2.86.3-blue.svg)]() +[![Version](https://img.shields.io/badge/Version-2.87.0-blue.svg)]() [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Docker](https://img.shields.io/badge/Docker-Ready-blue.svg)](https://www.docker.com/) [![Python](https://img.shields.io/badge/Python-3.11+-green.svg)](https://www.python.org/) @@ -977,8 +977,8 @@ Ce projet est sous licence **MIT** — voir le fichier [LICENSE](LICENSE) pour l ## 📝 Changelog -Consultez le [CHANGELOG.md](./CHANGELOG.md) pour l'historique complet de toutes les versions (v1.0.0 → v2.86.3). +Consultez le [CHANGELOG.md](./CHANGELOG.md) pour l'historique complet de toutes les versions (v1.0.0 → v2.87.0). --- -*Projet : ObsiGate | Version : 2.86.3 | Dernière mise à jour : Septembre 2026* +*Projet : ObsiGate | Version : 2.87.0 | Dernière mise à jour : Septembre 2026* diff --git a/README.md b/README.md index 6e87491..4572efd 100644 --- a/README.md +++ b/README.md @@ -2,7 +2,7 @@ **Ultra-light web gateway for your Obsidian vaults** — Access, browse, and search all your Obsidian notes from any device via a modern, responsive web interface. -[![Version](https://img.shields.io/badge/Version-2.86.3-blue.svg)]() +[![Version](https://img.shields.io/badge/Version-2.87.0-blue.svg)]() [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Docker](https://img.shields.io/badge/Docker-Ready-blue.svg)](https://www.docker.com/) [![Python](https://img.shields.io/badge/Python-3.11+-green.svg)](https://www.python.org/) @@ -1152,8 +1152,8 @@ This project is licensed under the **MIT License** - see the [LICENSE](LICENSE) ## 📝 Changelog -See [CHANGELOG.md](./CHANGELOG.md) for the complete version history (v1.0.0 → v2.86.3). +See [CHANGELOG.md](./CHANGELOG.md) for the complete version history (v1.0.0 → v2.87.0). --- -*Project: ObsiGate | Version: 2.86.3 | Last updated: September 2026* +*Project: ObsiGate | Version: 2.87.0 | Last updated: September 2026* diff --git a/VERSION b/VERSION index d6d50b2..863f84e 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -2.86.3 +2.87.0 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 diff --git a/backend/draco_session.py b/backend/draco_session.py index 2293340..5eedcad 100644 --- a/backend/draco_session.py +++ b/backend/draco_session.py @@ -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": ""}`` 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` diff --git a/backend/main.py b/backend/main.py index 854b877..6bcb24d 100644 --- a/backend/main.py +++ b/backend/main.py @@ -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 diff --git a/backend/openapi_docs.py b/backend/openapi_docs.py index 15a4785..5991455 100644 --- a/backend/openapi_docs.py +++ b/backend/openapi_docs.py @@ -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)."}, diff --git a/backend/routers/liaison.py b/backend/routers/liaison.py new file mode 100644 index 0000000..4c4a296 --- /dev/null +++ b/backend/routers/liaison.py @@ -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} diff --git a/desktop/Cargo.lock b/desktop/Cargo.lock index bf426ce..c917c3c 100644 --- a/desktop/Cargo.lock +++ b/desktop/Cargo.lock @@ -2626,7 +2626,7 @@ dependencies = [ [[package]] name = "obsigate-desktop" -version = "2.86.3" +version = "2.87.0" dependencies = [ "chrono", "env_logger", diff --git a/desktop/Cargo.toml b/desktop/Cargo.toml index 691b54e..7c7076d 100644 --- a/desktop/Cargo.toml +++ b/desktop/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "obsigate-desktop" -version = "2.86.3" +version = "2.87.0" description = "ObsiGate Desktop — Porte d'entrée native pour vos vaults Obsidian" authors = ["Bruno Charest"] edition = "2021" diff --git a/desktop/tauri.conf.json b/desktop/tauri.conf.json index 3d9402f..bbfa3a3 100644 --- a/desktop/tauri.conf.json +++ b/desktop/tauri.conf.json @@ -1,7 +1,7 @@ { "$schema": "https://raw.githubusercontent.com/nicedoc/obsigate/main/desktop/tauri.conf.schema.json", "productName": "ObsiGate", - "version": "2.86.3", + "version": "2.87.0", "identifier": "com.obsigate.desktop", "build": { "frontendDist": "../frontend", diff --git a/docs/ROADMAP.md b/docs/ROADMAP.md index 97d2545..d19c054 100644 --- a/docs/ROADMAP.md +++ b/docs/ROADMAP.md @@ -1,6 +1,6 @@ # ObsiGate — Roadmap -> **Version :** 2.86.3 | **Dernière mise à jour :** 2026-11-08 +> **Version :** 2.87.0 | **Dernière mise à jour :** 2026-11-16 > **Ce fichier ne contient que le travail à venir** (🔵 En cours + ⚪ Backlog) et un index compact > vers les fonctionnalités livrées. > - **Méthode de livraison à appliquer pour toute tâche : [DELIVERY_WORKFLOW.md](./DELIVERY_WORKFLOW.md)** @@ -30,6 +30,18 @@ ## 🔵 En cours +### 229. Liaison d'appareil — flux « code d'appareil » émettant un jeton draco (#75) + +- **Effort :** ~0,5 jour | **Impact :** 🟡 | **Ouvert :** 2026-11-16 | **Statut :** ✅ livré en 2.87.0 (PR #76 en attente de fusion — voir CHANGELOG ; redéploiement Docker requis) +- **Fiche :** [features/liaison-appareil-draco.md](./features/liaison-appareil-draco.md) +- **Description :** brique serveur manquante de l'authentification TikTak Desktop (option A draco, audit `~/workspace/audit-appareils-lies/RAPPORT.md`) : une application native ne peut pas obtenir `draco_session` (cookie HttpOnly, `/sso/authorize` refuse les `return_to` hors `*.dracodev.net`). Nouveau flux en miroir d'agent-commun (Fusion #45) : `POST /api/v1/liaison` (code `XXXX-XXXX`, 10 min) → page publique `GET /liaison?code=…` (session exigée, FR/EN) → `POST /api/v1/liaison/sonder` → JWS draco de longue durée (10 ans, révocable, claim `"appareil"`). Gestion : `GET /api/v1/appareils`, `POST /api/v1/appareils/{id}/revoquer` ; jeton d'appareil refusé sur la gestion (403 cookie / 401 Bearer) ; types `desktop` / `terminal` / `tiktak` ; dédoublonnage même nom+type ; gardes HUB-19 et changement de mot de passe comme la session draco. +- **Sous-tâches :** + - [x] Module `backend/draco_appareils.py` (JSON `data/`, patron `draco_session.py`) + - [x] `issue_token` : `ttl_seconds` + `extra_claims` ; `_draco_appareil` dans `user_for_draco` + - [x] Routeur `backend/routers/liaison.py` + page `/liaison` (`frontend/liaison.html/js/css`) + - [x] Tests `tests/test_draco_liaison.py` (13 tests) + flux complet contre serveur réel + - [x] Fiche `docs/features/liaison-appareil-draco.md` + CHANGELOG + version 2.87.0 + ### 227. Hub HUB-22 — API machine des sessions draco (liste et révocation) - **Effort :** ~0,5 jour | **Impact :** 🟡 | **Ouvert :** 2026-11-06 | **Statut :** ✅ livré en 2.85.0 (PR #68 fusionnée et release publiée — voir CHANGELOG ; redéploiement Docker requis) diff --git a/docs/features/liaison-appareil-draco.md b/docs/features/liaison-appareil-draco.md new file mode 100644 index 0000000..35e78f5 --- /dev/null +++ b/docs/features/liaison-appareil-draco.md @@ -0,0 +1,113 @@ +# #75 — Liaison d'appareil : flux « code d'appareil » émettant un jeton draco + +**Carte :** issue Gitea #75 (demande de Bruno, 2026-11-16 : faire fonctionner +l'authentification TikTak Desktop avec le jeton central draco — option A +choisie après audit `~/workspace/audit-appareils-lies/RAPPORT.md`). +**Version :** 2.87.0. **Prérequis :** ACC-3.1 (#216) — ObsiGate émet +`draco_session` ; ACC-3.2 (ticktick-clone #213) — le backend TikTak +valide déjà draco (mapping `sub` → compte, provisionnement JIT HUB-15). + +## Constat + +Le backend TikTak accepte déjà draco, mais aucune application native ne +peut **obtenir** ce jeton : `draco_session` est un cookie HttpOnly sur +`.dracodev.net`, délivré par `Set-Cookie` au login navigateur, et +`GET /sso/authorize` refuse tout `return_to` hors `*.dracodev.net` (un +schéma `tiktak://` ou un loopback serait rejeté). Le flux équivalent +existe chez agent-commun (`app/appareils.py`, Fusion #45, 0.50.0) — même +UX (code `XXXX-XXXX`, page d'approbation, sondage) — mais il émet des +jetons `dka_` qui n'authentifient que contre agent-commun. + +## Livraison (cette PR, côté émettrice) + +| Méthode | Chemin | Effet | +|---|---|---| +| POST | `/api/v1/liaison` (201, sans auth) | Démarre une liaison `{nom, type}` → `{demande_id, code_utilisateur, code_appareil, expire_le, url_liaison}` | +| GET | `/liaison?code=XXXX-XXXX` | Page publique d'approbation (saisie manuelle possible) | +| GET | `/api/v1/liaison/en-attente` | Demandes en attente (session) | +| POST | `/api/v1/liaison/approuver` | Approuve (session) → `{appareil}` — **jamais le jeton** | +| POST | `/api/v1/liaison/refuser` | Refuse (session) → `{refusee}` | +| POST | `/api/v1/liaison/sonder` | `en_attente` / `approuvee` (+ `jeton`, livré UNE fois) / `refusee` / `expiree` / `livree` ; 404 si inconnue ou mauvais code | +| GET | `/api/v1/appareils` | Appareils liés de l'utilisateur (session) | +| POST | `/api/v1/appareils/{id}/revoquer` | Révoque (session) → `{revoque: true}` | + +- **Module** `backend/draco_appareils.py` (logique pure, sans FastAPI) : + demandes et appareils en JSON dans `data/` (`draco_liaisons.json`, + `draco_appareils.json` — même patron que `draco_session.py` : + chargement paresseux, verrou, écriture atomique). Seule l'empreinte + SHA-256 du code d'appareil est stockée ; le jeton en clair ne vit + que dans la ligne de liaison, entre l'approbation et sa délivrance + unique (colonne vidée à la délivrance, lignes expirées purgées — + une demande approuvée mais jamais délivrée voit son appareil + révoqué à la purge). +- **Jeton** : un JWS draco standard, émis par + `draco_session.issue_token` (nouveaux paramètres `ttl_seconds` et + `extra_claims`) — **longue durée, 10 ans, révocable** (décision : + c'est le sens d'un appareil lié ; la révocation est le contrôle, + pas l'expiration — comme `dka_`). Il porte le claim + `"appareil": ""` ; son `jti` est consigné dans le registre des + émissions (`draco_issued.json`) et sa révocation rejoint + `revoked_list` (donc `GET /api/sso/revocations`, HUB-13 + « révoquer toutes les sessions », HUB-22). +- **Code** : 8 caractères, alphabet sans ambiguïté, affiché + `XXXX-XXXX` ; expiration 10 min + (`OBSIGATE_LIAISON_EXPIRATION_MIN`) ; plafond 20 demandes en + attente (429 au-delà). +- **Types** : `desktop` / `terminal` (agent-commun) + `tiktak` + (type dédié pour TikTak Desktop, sinon ambigu avec un desktop + générique) ; type inconnu → `desktop`, jamais d'erreur. +- **Dédoublonnage** : une liaison approuvée révoque les appareils + actifs de même nom+type du même utilisateur (vécu agent-commun + 2026-11-13 : un poste = une ligne, un jeton vivant). +- **Rôles Hub (HUB-19)** : le jeton d'appareil est soumis aux mêmes + gardes que la session draco quand il est présenté chez ObsiGate — + changement de mot de passe (`iat`) et rôle Hub (« aucun » → refus + 403 explicite). `user_for_draco` joint `_draco_appareil` au dict + utilisateur quand le claim est présent. +- **Garde 403** : un jeton d'appareil ne peut ni gérer les appareils + ni décider une liaison (patron `_exiger_session` d'agent-commun) — + en cookie draco : 403 explicite ; en `Authorization: Bearer` : 401 + (ce n'est pas un jeton natif, rejet dès `get_current_user`). +- **Page** `GET /liaison` (`frontend/liaison.html` + `liaison.js` + + `liaison.css`, FR/EN, aucun script inline — CSP) : vérifie la + session (`/api/auth/me`), propose la connexion avec retour ici + (`/?return_to=…`), liste les demandes en attente ou recherche par + code, boutons Approuver / Refuser. +- **Écarts assumés vs agent-commun** : `derniere_utilisation` reste + à `null` (l'émettrice ne voit jamais l'usage du jeton — seul le + consommateur le voit) ; pas de journal d'audit ni d'événement + d'activité (ObsiGate n'a pas ces canaux) ; pas de vue « Appareils » + dans la console — la gestion se fait par l'API et la page + `/liaison` (une vue console est un travail séparé, si voulue). + +## Conséquence à connaître (documentée, pas un bug) + +Un jeton d'appareil est un **jeton draco à part entière** : présenté +comme cookie chez ObsiGate (ou chez tout consommateur draco), il +authentifie comme l'utilisateur, avec les mêmes gardes (mot de passe, +rôle Hub) — seule la gestion des appareils lui est interdite. Si un +appareil est perdu ou volé, il faut le révoquer (liste des appareils, +déconnexion globale, ou administration des comptes HUB-13) : la +révocation prend effet dès l'appel suivant. + +## Côté clients (travaux séparés, après celui-ci) + +- **TikTak Desktop** : écran « Lier cet appareil » (copie de + `faireLogin` de DracoSH : code, page `/liaison`, sondage 2 s, + stockage chiffré) ; le backend TikTak accepte déjà le jeton + (il reste à configurer `DRACO_SESSION_SECRET` dans son conteneur). +- **DracoSH / DracoTerm** : le même flux peut remplacer `dka_` si + voulu — les deux jetons coexistent, rien ne change côté + agent-commun. + +## Tests + +`tests/test_draco_liaison.py` (13 tests, TestClient sur la vraie +application) : flux complet (démarrer → approuver → sonder → jeton → +lister → révoquer → 401), page publique, types inconnus, dédoublonnage, +refus, sondage 404 indiscernable, expiration (410 / `expiree`), +double livraison, plafond (429), sans session (401), jeton d'appareil +refusé sur la gestion (403 cookie / 401 Bearer), rôle Hub « aucun » +(403 explicite), `issue_token` (ttl + claims, réservés non écrasés). +Vérification runtime en plus : flux complet contre un serveur réel +(uvicorn + curl, `~/workspace/obsigate-75/smoke.sh`). diff --git a/frontend/liaison.css b/frontend/liaison.css new file mode 100644 index 0000000..914fe58 --- /dev/null +++ b/frontend/liaison.css @@ -0,0 +1,87 @@ +/* Liaison d'appareil (#75) — page d'approbation /liaison. + Palette reprise de style.css (variables, aucune couleur en dur + hors des variables). */ +:root { + --bg-primary: #17181a; + --bg-secondary: #26272b; + --border: #33353a; + --text-primary: #eceeeb; + --text-secondary: #a6aba0; + --accent: #7c5cd6; + --accent-text: #b39df5; + --danger: #e8a08d; + --danger-bg: #40241f; + --success: #2ea36b; + --success-bg: #173d29; + --err: #cf4b32; +} + +* { box-sizing: border-box; } + +body { + margin: 0; + min-height: 100vh; + display: flex; + align-items: center; + justify-content: center; + background: var(--bg-primary); + color: var(--text-primary); + font-family: system-ui, -apple-system, "Segoe UI", sans-serif; + padding: 1rem; +} + +.card { + width: 100%; + max-width: 480px; + background: var(--bg-secondary); + border: 1px solid var(--border); + border-radius: 12px; + padding: 1.5rem; +} + +h1 { margin: 0 0 0.25rem; font-size: 1.25rem; } +h2 { margin: 0 0 0.5rem; font-size: 1rem; } +.subtitle { margin: 0 0 1rem; color: var(--text-secondary); } +.note { color: var(--text-secondary); font-size: 0.85rem; } +.bloc { margin-top: 1rem; } +.erreur { color: var(--err); } +.message { color: var(--success); } +.message.erreur { color: var(--err); } + +label { display: block; margin-bottom: 0.35rem; color: var(--text-secondary); font-size: 0.9rem; } +.ligne-code { display: flex; gap: 0.5rem; } +input { + flex: 1; + min-width: 0; + padding: 0.6rem 0.75rem; + font-size: 1.1rem; + letter-spacing: 0.15em; + text-transform: uppercase; + color: var(--text-primary); + background: var(--bg-primary); + border: 1px solid var(--border); + border-radius: 8px; +} + +.btn { + padding: 0.6rem 1rem; + border: 1px solid var(--border); + border-radius: 8px; + background: var(--bg-primary); + color: var(--text-primary); + cursor: pointer; + font-size: 0.95rem; +} +.btn.primary { background: var(--accent); border-color: var(--accent); color: #fff; } +.btn.danger { background: var(--danger-bg); border-color: var(--danger-bg); color: var(--danger); } +.btn:disabled { opacity: 0.5; cursor: default; } + +dl { margin: 0 0 1rem; } +dl div { display: flex; justify-content: space-between; padding: 0.35rem 0; border-bottom: 1px solid var(--border); } +dt { color: var(--text-secondary); } +dd { margin: 0; font-weight: 600; } +.actions { display: flex; gap: 0.5rem; } + +ul { margin: 0; padding-left: 1.1rem; } +li { margin: 0.35rem 0; } +li button { margin-left: 0.5rem; } diff --git a/frontend/liaison.html b/frontend/liaison.html new file mode 100644 index 0000000..b4fb857 --- /dev/null +++ b/frontend/liaison.html @@ -0,0 +1,51 @@ + + + + + +Liaison d'appareil — ObsiGate + + + +
+

Liaison d'appareil

+

Autorisez une application à se connecter à votre compte ObsiGate.

+ + + + + + + + + +

L'appareil approuvé reçoit un jeton de longue durée, révocable à tout moment depuis la liste de vos appareils liés. Le jeton n'est jamais affiché ici.

+
+ + + diff --git a/frontend/liaison.js b/frontend/liaison.js new file mode 100644 index 0000000..81425ad --- /dev/null +++ b/frontend/liaison.js @@ -0,0 +1,229 @@ +/* Liaison d'appareil (#75) — page d'approbation /liaison. + Aucun secret ici : la page ne voit jamais le jeton d'appareil, + seulement le code utilisateur et les décisions. Textes FR/EN. */ +(function () { + "use strict"; + + var I18N = { + fr: { + title: "Liaison d'appareil", + subtitle: "Autorisez une application à se connecter à votre compte ObsiGate.", + loginNeeded: "Vous devez être connecté à ObsiGate pour approuver une liaison.", + login: "Se connecter", + codeLabel: "Code affiché par l'application", + search: "Rechercher", + device: "Appareil", + type: "Type", + expires: "Expire", + approve: "Approuver", + refuse: "Refuser", + pendingTitle: "Demandes en attente", + note: "L'appareil approuvé reçoit un jeton de longue durée, révocable à tout moment depuis la liste de vos appareils liés. Le jeton n'est jamais affiché ici.", + unknownCode: "Code inconnu ou demande déjà traitée.", + approved: "Appareil lié : ", + refused: "Demande refusée.", + error: "Une erreur est survenue.", + noPending: "Aucune demande en attente.", + choose: "Choisir", + expiresIn: "expire dans ", + minutes: " min" + }, + en: { + title: "Device linking", + subtitle: "Authorize an application to connect to your ObsiGate account.", + loginNeeded: "You must be signed in to ObsiGate to approve a link.", + login: "Sign in", + codeLabel: "Code shown by the application", + search: "Search", + device: "Device", + type: "Type", + expires: "Expires", + approve: "Approve", + refuse: "Refuse", + pendingTitle: "Pending requests", + note: "The approved device receives a long-lived token, revocable at any time from your linked devices list. The token is never shown here.", + unknownCode: "Unknown code or request already handled.", + approved: "Device linked: ", + refused: "Request refused.", + error: "An error occurred.", + noPending: "No pending requests.", + choose: "Select", + expiresIn: "expires in ", + minutes: " min" + } + }; + + var lang = (navigator.language || "fr").toLowerCase().indexOf("fr") === 0 ? "fr" : "en"; + var T = I18N[lang]; + + function $(id) { return document.getElementById(id); } + function show(el) { el.hidden = false; } + function hide(el) { el.hidden = true; } + function norm(code) { return (code || "").toUpperCase().replace(/[^A-Z0-9]/g, ""); } + function format(code) { + var n = norm(code); + return n.length === 8 ? n.slice(0, 4) + "-" + n.slice(4) : code; + } + + document.querySelectorAll("[data-i18n]").forEach(function (el) { + var key = el.getAttribute("data-i18n"); + if (T[key]) el.textContent = T[key]; + }); + document.documentElement.lang = lang; + + var codeInput = $("code"); + var erreurCode = $("erreur-code"); + var message = $("message"); + var demandeCourante = null; + + function afficherErreur(texte) { + erreurCode.textContent = texte; + show(erreurCode); + } + function afficherMessage(texte, estErreur) { + message.textContent = texte; + message.classList.toggle("erreur", !!estErreur); + show(message); + } + + function afficherDemande(demande) { + demandeCourante = demande; + $("demande-nom").textContent = demande.nom || "—"; + $("demande-type").textContent = demande.type || "—"; + var reste = Math.max(0, Math.round((demande.expire_le * 1000 - Date.now()) / 60000)); + $("demande-expire").textContent = T.expiresIn + reste + T.minutes; + $("btn-approuver").disabled = false; + $("btn-refuser").disabled = false; + hide(message); + show($("bloc-demande")); + } + + function chargerDemandes() { + return fetch("/api/v1/liaison/en-attente", { credentials: "include" }) + .then(function (res) { + if (!res.ok) throw new Error("http " + res.status); + return res.json(); + }) + .then(function (data) { return data.liaisons || []; }); + } + + function rechercher(code) { + hide(erreurCode); + hide($("bloc-demande")); + var n = norm(code); + if (n.length !== 8) { afficherErreur(T.unknownCode); return; } + chargerDemandes().then(function (liaisons) { + var trouvee = null; + liaisons.forEach(function (l) { + if (norm(l.code_utilisateur) === n) trouvee = l; + }); + if (trouvee) { + afficherDemande(trouvee); + } else { + afficherErreur(T.unknownCode); + } + }).catch(function () { afficherErreur(T.error); }); + } + + function listerEnAttente() { + chargerDemandes().then(function (liaisons) { + var liste = $("liste-demandee"); + liste.innerHTML = ""; + if (!liaisons.length) { + var li = document.createElement("li"); + li.textContent = T.noPending; + liste.appendChild(li); + } else { + liaisons.forEach(function (l) { + var li = document.createElement("li"); + li.textContent = format(l.code_utilisateur) + " — " + (l.nom || "—") + " (" + (l.type || "—") + ") "; + var btn = document.createElement("button"); + btn.type = "button"; + btn.className = "btn"; + btn.textContent = T.choose; + btn.addEventListener("click", function () { + codeInput.value = format(l.code_utilisateur); + afficherDemande(l); + }); + li.appendChild(btn); + liste.appendChild(li); + }); + } + show($("bloc-liste")); + }).catch(function () { /* liste facultative : la saisie manuelle reste */ }); + } + + // 1. Session : sans session, proposer la connexion avec retour ici. + fetch("/api/auth/me", { credentials: "include" }) + .then(function (res) { + if (!res.ok) { + $("lien-connexion").href = "/?return_to=" + encodeURIComponent(location.href); + show($("etat-connexion")); + return; + } + show($("bloc-code")); + var params = new URLSearchParams(location.search); + var code = params.get("code") || ""; + if (code) { + codeInput.value = format(code); + rechercher(code); + } else { + listerEnAttente(); + } + }) + .catch(function () { + $("lien-connexion").href = "/?return_to=" + encodeURIComponent(location.href); + show($("etat-connexion")); + }); + + $("btn-chercher").addEventListener("click", function () { + rechercher(codeInput.value); + }); + codeInput.addEventListener("keydown", function (e) { + if (e.key === "Enter") { e.preventDefault(); rechercher(codeInput.value); } + }); + + $("btn-approuver").addEventListener("click", function () { + if (!demandeCourante) return; + $("btn-approuver").disabled = true; + $("btn-refuser").disabled = true; + fetch("/api/v1/liaison/approuver", { + method: "POST", + credentials: "include", + headers: { "Content-Type": "application/json" }, + body: JSON.stringify({ code: demandeCourante.code_utilisateur }) + }).then(function (res) { + if (!res.ok) throw new Error("http " + res.status); + return res.json(); + }).then(function (data) { + hide($("bloc-demande")); + afficherMessage(T.approved + (data.appareil && data.appareil.nom ? data.appareil.nom : ""), false); + }).catch(function () { + $("btn-approuver").disabled = false; + $("btn-refuser").disabled = false; + afficherMessage(T.error, true); + }); + }); + + $("btn-refuser").addEventListener("click", function () { + if (!demandeCourante) return; + $("btn-approuver").disabled = true; + $("btn-refuser").disabled = true; + fetch("/api/v1/liaison/refuser", { + method: "POST", + credentials: "include", + headers: { "Content-Type": "application/json" }, + body: JSON.stringify({ code: demandeCourante.code_utilisateur }) + }).then(function (res) { + if (!res.ok) throw new Error("http " + res.status); + return res.json(); + }).then(function () { + hide($("bloc-demande")); + afficherMessage(T.refused, false); + }).catch(function () { + $("btn-approuver").disabled = false; + $("btn-refuser").disabled = false; + afficherMessage(T.error, true); + }); + }); +})(); diff --git a/package.json b/package.json index d0670df..02623d0 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "obsigate", - "version": "2.86.3", + "version": "2.87.0", "description": "**Porte d'entrée web ultra-léger pour vos vaults Obsidian** — Accédez, naviguez et recherchez dans toutes vos notes Obsidian depuis n'importe quel appareil via une interface web moderne et responsive.", "main": "patch.js", "directories": { diff --git a/tests/test_draco_liaison.py b/tests/test_draco_liaison.py new file mode 100644 index 0000000..7a5fe54 --- /dev/null +++ b/tests/test_draco_liaison.py @@ -0,0 +1,344 @@ +# tests/test_draco_liaison.py +# Liaison d'appareil (#75) — flux « code d'appareil » émettant un +# jeton draco : démarrer -> approuver -> sonder -> jeton -> lister +# -> révoquer. Cas nominaux + refus / expiration / mauvais code / +# double livraison / révocation effective / jeton d'appareil refusé +# sur la gestion des appareils. Vérification runtime sur la vraie +# application (TestClient), pas de conclusion statique seule. + +import asyncio +import json +import os +import shutil +import tempfile +import time +from pathlib import Path + +import pytest +from fastapi.testclient import TestClient + +from backend import draco_appareils, draco_session, hub_roles +from backend.auth.password import hash_password + + +@pytest.fixture +def client_liaison(tmp_path, monkeypatch): + """Application réelle, données isolées, admin connecté, secret draco.""" + tmp = Path(tempfile.mkdtemp()) + data_dir = tmp / "data" + data_dir.mkdir() + users = { + "version": 1, + "users": { + "admin": { + "id": "admin-1", + "username": "admin", + "display_name": "Admin", + "password_hash": hash_password("chab30"), + "role": "admin", + "vaults": ["*"], + "active": True, + "created_at": "2026-01-01T00:00:00", + } + }, + } + (data_dir / "users.json").write_text(json.dumps(users), encoding="utf-8") + src_secret = Path("data/secret.key") + if src_secret.exists(): + shutil.copy2(str(src_secret), str(data_dir / "secret.key")) + + orig_cwd = os.getcwd() + os.chdir(str(tmp)) + monkeypatch.setenv("VAULT_1_NAME", "TestVault") + monkeypatch.setenv("VAULT_1_PATH", os.path.abspath("test-vault")) + monkeypatch.setenv("OBSIGATE_AUTH_ENABLED", "true") + monkeypatch.setenv("OBSIGATE_ADMIN_USER", "admin") + monkeypatch.setenv("OBSIGATE_ADMIN_PASSWORD", "chab30") + monkeypatch.setenv("OBSIGATE_WATCHER_ENABLED", "false") + monkeypatch.setenv("DRACO_SESSION_SECRET", "secret-de-test") + + # Fichiers de liaison/appareils isolés + caches remis à zéro. + monkeypatch.setattr(draco_appareils, "LIAISONS_FILE", + tmp_path / "draco_liaisons.json") + monkeypatch.setattr(draco_appareils, "APPAREILS_FILE", + tmp_path / "draco_appareils.json") + monkeypatch.setattr(draco_session, "REVOKED_FILE", + tmp_path / "draco_revoked.json") + monkeypatch.setattr(draco_session, "ISSUED_FILE", + tmp_path / "draco_issued.json") + draco_appareils._liaisons = None + draco_appareils._appareils = None + draco_session._revoked = None + draco_session._issued = None + # Rôle Hub inconnu par défaut (Hub injoignable en test) : le + # comportement actuel s'applique, sans appel réseau. + monkeypatch.setattr(hub_roles, "role_pour", lambda sub, cookie: None) + + import backend.main + backend.main._load_config = lambda: {"watcher_enabled": False} + from backend.main import app + from backend.indexer import build_index, index + for key in list(index.keys()): + del index[key] + loop = asyncio.new_event_loop() + asyncio.set_event_loop(loop) + loop.run_until_complete(build_index()) + from backend.search import init_inverted_index + init_inverted_index() + + client = TestClient(app) + resp = client.post("/api/auth/login", + json={"username": "admin", "password": "chab30"}) + assert resp.status_code == 200, resp.text + yield client + if hasattr(client, "close"): + client.close() + loop.run_until_complete(asyncio.sleep(0)) + os.chdir(orig_cwd) + shutil.rmtree(str(tmp), ignore_errors=True) + draco_appareils._liaisons = None + draco_appareils._appareils = None + draco_session._revoked = None + draco_session._issued = None + + +def _demarrer(client, nom="poste-test", type_appareil="tiktak"): + resp = client.post("/api/v1/liaison", + json={"nom": nom, "type": type_appareil}) + assert resp.status_code == 201, resp.text + return resp.json() + + +def _lier(client, nom="poste-test", type_appareil="tiktak"): + """Flux nominal jusqu'au jeton : retourne (demande, jeton, appareil).""" + demande = _demarrer(client, nom, type_appareil) + resp = client.post("/api/v1/liaison/approuver", + json={"code": demande["code_utilisateur"]}) + assert resp.status_code == 200, resp.text + appareil = resp.json()["appareil"] + assert "jeton" not in resp.text # l'approbation ne livre jamais le jeton + resp = client.post("/api/v1/liaison/sonder", json={ + "demande_id": demande["demande_id"], + "code_appareil": demande["code_appareil"]}) + assert resp.status_code == 200, resp.text + data = resp.json() + assert data["statut"] == "approuvee" + return demande, data["jeton"], data["appareil"] + + +# ── Flux nominal ───────────────────────────────────────────────────────── + +def test_flux_complet(client_liaison): + client = client_liaison + demande, jeton, appareil = _lier(client) + assert demande["code_utilisateur"][4] == "-" + assert len(demande["code_utilisateur"]) == 9 + assert demande["expire_dans_s"] <= 10 * 60 + assert demande["url_liaison"] == \ + "/liaison?code=" + demande["code_utilisateur"] + assert demande["url_liaison_absolue"].endswith(demande["url_liaison"]) + # Le jeton est un JWS draco de longue durée, portant le claim appareil. + claims = draco_session.verify_token(jeton) + assert claims is not None + assert claims["sub"] == "admin-1" + assert claims["appareil"] == appareil["id"] + assert claims["exp"] - claims["iat"] == \ + draco_appareils.DEVICE_TOKEN_TTL_SECONDS + # L'appareil est listé, actif. + resp = client.get("/api/v1/appareils") + assert resp.status_code == 200 + appareils = resp.json()["appareils"] + assert len(appareils) == 1 + assert appareils[0]["id"] == appareil["id"] + assert appareils[0]["nom"] == "poste-test" + assert appareils[0]["type"] == "tiktak" + assert appareils[0]["revoque"] is False + # Révocation : le jeton est rejeté dès l'appel suivant. + resp = client.post(f"/api/v1/appareils/{appareil['id']}/revoquer") + assert resp.status_code == 200 + assert resp.json() == {"revoque": True} + assert draco_session.verify_token(jeton) is None + assert any(r["jti"] == claims["jti"] + for r in draco_session.revoked_list()) + resp = client.get("/api/v1/appareils") + assert resp.json()["appareils"][0]["revoque"] is True + # Révocation d'un appareil déjà révoqué : 404. + resp = client.post(f"/api/v1/appareils/{appareil['id']}/revoquer") + assert resp.status_code == 404 + + +def test_page_liaison_publique(client_liaison): + resp = client_liaison.get("/liaison?code=ABCD-EFGH") + assert resp.status_code == 200 + assert "text/html" in resp.headers["content-type"] + assert "Liaison d'appareil" in resp.text + assert "/static/liaison.js" in resp.text + # Aucun script inline (CSP) : le seul