ObsiGate 2.87.0 — Liaison d'appareil : flux code d'appareil émettant un jeton draco (#75) #76

Merged
bruno merged 20 commits from feat/liaison-appareil-draco into main 2026-11-16 19:14:06 -05:00
19 changed files with 1547 additions and 16 deletions
+7 -1
View File
@@ -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`.
+3 -3
View File
@@ -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*
+3 -3
View File
@@ -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*
+1 -1
View File
@@ -1 +1 @@
2.86.3
2.87.0
+448
View File
@@ -0,0 +1,448 @@
# backend/draco_appareils.py
# Liaison d'appareil — flux « code d'appareil » (#75).
#
# Une application native (TikTak Desktop d'abord) ne peut pas obtenir
# le jeton central draco par le navigateur : ``draco_session`` est un
# cookie HttpOnly sur ``.dracodev.net`` et ``/sso/authorize`` refuse
# tout ``return_to`` hors ``*.dracodev.net``. Ce module émet donc, par
# ObsiGate elle-même, un jeton draco pour un appareil lié — en miroir
# de ``app/appareils.py`` d'agent-commun (Fusion #45, 0.50.0), dont
# il reprend le protocole :
#
# 1. l'application, qui n'a encore AUCUN identifiant, démarre une
# liaison : le service émet un code utilisateur court
# (``XXXX-XXXX``, 10 minutes) et un code d'appareil secret, que
# l'app garde pour sonder ;
# 2. l'app ouvre la page ``/liaison`` ; Bruno, connecté par sa
# session native ObsiGate, y voit la demande et l'APPROUVE (ou
# la refuse) — la décision exige une session, jamais un jeton
# d'appareil ;
# 3. l'app sonde : une fois approuvée, elle reçoit le jeton
# d'appareil — UNE fois : la délivrance est consommée à la
# première lecture ;
# 4. le jeton est un JWS draco standard (``draco_session``), de
# longue durée (10 ans, révocable) : il authentifie l'appareil
# auprès de toute application qui valide draco (TikTak en
# premier lieu). Il est RÉVOCABLE : la révocation pose
# ``revoque_le`` et révoque le jti draco, ce qui prend effet
# dès l'appel suivant (liste de révocation exposée par
# ``GET /api/sso/revocations``).
#
# Différences assumées avec agent-commun (documentées) :
# - le jeton n'est PAS opaque (``dka_``) : c'est un draco JWS,
# donc il est valable partout où draco est accepté — y compris
# chez ObsiGate elle-même comme session (mêmes gardes que la
# session navigateur : changement de mot de passe, rôle Hub) —
# et il porte le claim ``"appareil": "<id>"`` pour le
# distinguer. Les endpoints de gestion des appareils refusent
# expressément un jeton d'appareil (403) : un jeton volé ne
# peut ni gérer les appareils ni décider une liaison.
# - ObsiGate n'a pas de base de données : les demandes et les
# appareils vivent en JSON dans ``data/`` (même patron que
# ``draco_session.py`` : chargement paresseux, verrou, écriture
# atomique via fichier temporaire). Seule l'empreinte SHA-256
# du code d'appareil est stockée ; le jeton en clair ne
# transite que par la ligne de liaison, entre l'approbation et
# sa délivrance unique (la colonne est vidée à la délivrance,
# les lignes expirées sont purgées).
# - ``derniere_utilisation`` reste à ``None`` : l'émettrice ne
# voit jamais l'usage du jeton — seul le consommateur (TikTak)
# le voit. Le champ est conservé (à ``None``) pour la parité
# de forme avec agent-commun.
#
# Sécurité : jamais de secret en code/logs ; jamais de jeton
# dans une réponse d'approbation ni dans un journal.
from __future__ import annotations
import hashlib
import hmac
import json
import logging
import os
import secrets
import threading
import time
import uuid
from pathlib import Path
from backend import draco_session
logger = logging.getLogger("obsigate.draco_appareils")
LIAISONS_FILE = Path("data/draco_liaisons.json")
APPAREILS_FILE = Path("data/draco_appareils.json")
# Types d'appareils connus. « desktop » = un poste de travail
# (client historique) ; « terminal » = un poste DracoTerm/DracoSH
# (le jeton est celui DU POSTE, partagé par les deux programmes) ;
# « tiktak » = TikTak Desktop, type dédié pour ne pas l'ambiguïté
# avec un desktop générique dans la vue Appareils. Un type absent
# ou inconnu retombe sur le défaut, jamais en erreur : un client
# ancien ne casse pas la liaison.
TYPES_APPAREILS = ("desktop", "terminal", "tiktak")
TYPE_APPAREIL_DEFAUT = "desktop"
# Alphabet sans caractères ambigus (pas de I, L, O, 0, 1) : le
# code se lit et se recopie à la main sans hésitation.
ALPHABET_CODE = "ABCDEFGHJKMNPQRSTUVWXYZ23456789"
LIAISONS_MAX_EN_ATTENTE = 20
# Durée de vie du jeton d'appareil : longue durée comme ``dka_``
# (agent-commun), révocable — c'est le sens d'un appareil lié :
# un desktop ne doit pas se relier chaque jour. La révocation
# (liste ``/api/sso/revocations`` + ``revoque_le``) est le
# contrôle, pas l'expiration.
DEVICE_TOKEN_TTL_SECONDS = 10 * 365 * 24 * 3600 # 10 ans
_lock = threading.Lock()
_liaisons: dict[str, dict] | None = None # demande_id -> enregistrement
_appareils: dict[str, dict] | None = None # appareil_id -> enregistrement
def _expiration_min() -> float:
"""Durée de vie d'une demande de liaison (défaut 10 min)."""
try:
return float(os.environ.get("OBSIGATE_LIAISON_EXPIRATION_MIN", "10"))
except ValueError:
return 10.0
def _norm_type_appareil(valeur) -> str:
v = str(valeur or "").strip().lower()
return v if v in TYPES_APPAREILS else TYPE_APPAREIL_DEFAUT
class ErreurLiaison(Exception):
"""Refus propre d'une opération de liaison : message en
français + statut HTTP, traduits par la route."""
def __init__(self, message: str, statut: int = 400):
super().__init__(message)
self.message = message
self.statut = statut
def _hacher(valeur: str) -> str:
return hashlib.sha256(valeur.encode("utf-8")).hexdigest()
def _nouveau_code() -> str:
brut = "".join(secrets.choice(ALPHABET_CODE) for _ in range(8))
return f"{brut[:4]}-{brut[4:]}"
def _norm_code(code) -> str:
"""Normalise un code saisi ou reçu : majuscules, alphanumérique
seulement — « abcd-2345 », « ABCD 2345 » et « ABCD2345 » sont
le même code."""
return "".join(c for c in str(code or "").upper() if c.isalnum())
def _formater_code(code_norm: str) -> str:
return f"{code_norm[:4]}-{code_norm[4:]}" if len(code_norm) == 8 \
else code_norm
# ── Persistance JSON (patron draco_session.py) ─────────────────────────
def _charger(fichier: Path, cache: str) -> dict[str, dict]:
global _liaisons, _appareils
courant = _liaisons if cache == "liaisons" else _appareils
if courant is not None:
return courant
try:
data = json.loads(fichier.read_text(encoding="utf-8"))
store = {str(k): dict(v) for k, v in data.items()} \
if isinstance(data, dict) else {}
except (OSError, ValueError):
store = {}
if cache == "liaisons":
_liaisons = store
else:
_appareils = store
return store
def _sauver(fichier: Path, store: dict[str, dict]) -> None:
fichier.parent.mkdir(parents=True, exist_ok=True)
tmp = fichier.with_suffix(".tmp")
tmp.write_text(json.dumps(store), encoding="utf-8")
tmp.replace(fichier)
def _liaisons_store() -> dict[str, dict]:
return _charger(LIAISONS_FILE, "liaisons")
def _appareils_store() -> dict[str, dict]:
return _charger(APPAREILS_FILE, "appareils")
def _purger_expirees(maintenant: float) -> None:
store = _liaisons_store()
morts = [k for k, v in store.items()
if float(v.get("expire_le", 0)) < maintenant]
for k in morts:
row = store[k]
if row.get("statut") == "approuvee" and row.get("appareil_id"):
# Approuvée mais jamais délivrée : le jeton ne doit pas
# survivre à la demande — l'appareil est révoqué avec
# elle (son jti draco rejoint la liste de révocation).
appareils = _appareils_store()
cible = appareils.get(str(row["appareil_id"]))
if cible is not None and cible.get("revoque_le") is None:
cible["revoque_le"] = maintenant
if cible.get("jti"):
draco_session.revoke(
str(cible["jti"]),
int(cible.get("exp", maintenant)))
_sauver(APPAREILS_FILE, appareils)
del store[k]
if morts:
_sauver(LIAISONS_FILE, store)
# ── Liaison ────────────────────────────────────────────────────────────
def demarrer_liaison(nom: str, type_appareil: str = TYPE_APPAREIL_DEFAUT,
maintenant: float | None = None) -> dict:
"""Ouvre une demande de liaison (sans authentification : c'est
l'appareil qui demande). Retourne les éléments à montrer à
l'humain (code utilisateur) et à garder pour sonder (code
d'appareil, en clair ici seulement — son empreinte est stockée).
"""
maintenant = time.time() if maintenant is None else maintenant
with _lock:
_purger_expirees(maintenant)
store = _liaisons_store()
en_attente = [v for v in store.values()
if v.get("statut") == "en_attente"
and float(v.get("expire_le", 0)) >= maintenant]
if len(en_attente) >= LIAISONS_MAX_EN_ATTENTE:
raise ErreurLiaison(
"Trop de demandes de liaison en attente — réessayez dans "
"quelques minutes.", 429)
prises = {_norm_code(v["code_utilisateur"]) for v in en_attente}
code = _nouveau_code()
while _norm_code(code) in prises:
code = _nouveau_code()
code_appareil = secrets.token_urlsafe(24)
demande_id = uuid.uuid4().hex
expire_le = maintenant + _expiration_min() * 60.0
type_norm = _norm_type_appareil(type_appareil)
store[demande_id] = {
"id": demande_id,
"code_utilisateur": code,
"code_appareil_hash": _hacher(code_appareil),
"nom": (nom or "").strip()[:80],
"type": type_norm,
"statut": "en_attente",
"cree_le": maintenant,
"expire_le": expire_le,
"user_sub": "",
"appareil_id": None,
"jeton_livrable": None,
}
_sauver(LIAISONS_FILE, store)
return {"demande_id": demande_id, "code_utilisateur": code,
"code_appareil": code_appareil, "expire_le": expire_le,
"expire_dans_s": int(expire_le - maintenant),
"type": type_norm}
def _liaison_par_code(code) -> dict | None:
"""Retrouve une demande par son code utilisateur (comparaison
normalisée sur les demandes encore vivantes)."""
norm = _norm_code(code)
if len(norm) != 8:
return None
for row in _liaisons_store().values():
if row.get("statut") not in ("en_attente", "approuvee"):
continue
if _norm_code(row.get("code_utilisateur", "")) == norm:
return dict(row)
return None
def approuver_liaison(code, user: dict,
maintenant: float | None = None) -> dict:
"""Approuve une demande (session requise — vérifié par la
route) : crée l'appareil de l'utilisateur et dépose son jeton
draco dans la ligne, en attente de délivrance unique.
Retourne l'appareil public (jamais le jeton)."""
maintenant = time.time() if maintenant is None else maintenant
sub = str(user.get("id") or user.get("username") or "")
if not sub:
raise ErreurLiaison("Utilisateur introuvable.", 401)
with _lock:
liaison = _liaison_par_code(code)
if liaison is None or liaison.get("statut") != "en_attente":
raise ErreurLiaison(
"Code inconnu ou demande déjà traitée.", 404)
if float(liaison.get("expire_le", 0)) < maintenant:
store = _liaisons_store()
store[liaison["id"]]["statut"] = "expiree"
_sauver(LIAISONS_FILE, store)
raise ErreurLiaison(
"Ce code a expiré — relancez la liaison depuis "
"l'application.", 410)
appareil_id = uuid.uuid4().hex
token, jti, exp = draco_session.issue_token(
user, ttl_seconds=DEVICE_TOKEN_TTL_SECONDS,
extra_claims={"appareil": appareil_id})
appareils = _appareils_store()
appareils[appareil_id] = {
"id": appareil_id,
"user_sub": sub,
"nom": liaison.get("nom", ""),
"type": _norm_type_appareil(liaison.get("type")),
"jti": jti,
"exp": exp,
"cree_le": maintenant,
"derniere_utilisation": None,
"revoque_le": None,
}
_sauver(APPAREILS_FILE, appareils)
store = _liaisons_store()
store[liaison["id"]].update({
"statut": "approuvee",
"user_sub": sub,
"appareil_id": appareil_id,
"jeton_livrable": token,
})
# Dédoublonnage (vécu chez agent-commun le 2026-11-13) :
# relier un poste déjà lié sous le même nom créait un
# SOSIE. Une liaison approuvée REMPLACE les appareils
# actifs de même nom et de même type du même utilisateur :
# un poste = une ligne, un jeton vivant.
for autre in appareils.values():
if autre["id"] == appareil_id:
continue
if autre.get("user_sub") != sub:
continue
if autre.get("type") != _norm_type_appareil(liaison.get("type")):
continue
if autre.get("nom") != liaison.get("nom", ""):
continue
if autre.get("revoque_le") is not None:
continue
autre["revoque_le"] = maintenant
if autre.get("jti"):
draco_session.revoke(str(autre["jti"]),
int(autre.get("exp", maintenant)))
_sauver(APPAREILS_FILE, appareils)
_sauver(LIAISONS_FILE, store)
return _appareil_public(appareils[appareil_id])
def refuser_liaison(code, maintenant: float | None = None) -> bool:
"""Refuse une demande en attente. False si le code ne désigne
aucune demande en attente."""
maintenant = time.time() if maintenant is None else maintenant
with _lock:
liaison = _liaison_par_code(code)
if liaison is None or liaison.get("statut") != "en_attente":
return False
store = _liaisons_store()
store[liaison["id"]]["statut"] = "refusee"
_sauver(LIAISONS_FILE, store)
return True
def liaisons_en_attente(maintenant: float | None = None) -> list[dict]:
"""Les demandes qu'une session peut décider : code, nom
déclaré par l'app, échéance. Jamais le code d'appareil."""
maintenant = time.time() if maintenant is None else maintenant
rows = [dict(v) for v in _liaisons_store().values()
if v.get("statut") == "en_attente"
and float(v.get("expire_le", 0)) >= maintenant]
rows.sort(key=lambda r: r.get("cree_le", 0))
return [{"code_utilisateur": r["code_utilisateur"],
"nom": r.get("nom", ""), "type": r.get("type", "desktop"),
"cree_le": r.get("cree_le"),
"expire_le": r.get("expire_le")} for r in rows]
def sonder_liaison(demande_id: str, code_appareil: str,
maintenant: float | None = None) -> dict | None:
"""Le sondage de l'application : None si la demande est
inconnue ou si le code d'appareil ne correspond pas (les deux
cas sont indiscernables, volontairement). À l'approbation, le
jeton est livré UNE fois puis la ligne est vidée."""
maintenant = time.time() if maintenant is None else maintenant
with _lock:
row = _liaisons_store().get(str(demande_id or ""))
if row is None:
return None
if not hmac.compare_digest(str(row.get("code_appareil_hash", "")),
_hacher(code_appareil or "")):
return None
statut = row.get("statut")
if statut == "en_attente" \
and float(row.get("expire_le", 0)) < maintenant:
store = _liaisons_store()
store[row["id"]]["statut"] = "expiree"
_sauver(LIAISONS_FILE, store)
return {"statut": "expiree"}
if statut == "approuvee":
jeton = row.get("jeton_livrable")
store = _liaisons_store()
store[row["id"]]["statut"] = "livree"
store[row["id"]]["jeton_livrable"] = None
_sauver(LIAISONS_FILE, store)
appareil = _appareils_store().get(str(row.get("appareil_id") or ""))
return {"statut": "approuvee", "jeton": jeton,
"appareil": _appareil_public(appareil)}
return {"statut": statut}
# ── Appareils ──────────────────────────────────────────────────────────
def _appareil_public(row) -> dict:
"""La forme publique d'un appareil : identité et état —
jamais le jti ni quoi que ce soit qui authentifie."""
if row is None:
return {}
d = dict(row)
return {"id": d["id"], "nom": d.get("nom", ""),
"portee": "client",
"type": _norm_type_appareil(d.get("type")),
"cree_le": d.get("cree_le"),
"derniere_utilisation": d.get("derniere_utilisation"),
"expire_le": d.get("exp"),
"revoque": d.get("revoque_le") is not None,
"revoque_le": d.get("revoque_le")}
def lister_appareils(user_sub: str) -> list[dict]:
"""Les appareils de l'utilisateur, actifs d'abord puis les
révoqués (l'historique reste lisible)."""
rows = [v for v in _appareils_store().values()
if v.get("user_sub") == str(user_sub)]
rows.sort(key=lambda r: (r.get("revoque_le") is not None,
-(r.get("cree_le") or 0)))
return [_appareil_public(r) for r in rows]
def revoquer_appareil(appareil_id: str, user_sub: str,
maintenant: float | None = None) -> bool:
"""Révoque un appareil de l'utilisateur : pose ``revoque_le``
et révoque le jti draco — effet immédiat, la liste de
révocation étant relue par les consommateurs à chaque
validation. False si l'appareil est inconnu, à un autre
utilisateur, ou déjà révoqué."""
maintenant = time.time() if maintenant is None else maintenant
with _lock:
store = _appareils_store()
row = store.get(str(appareil_id or ""))
if row is None or row.get("user_sub") != str(user_sub):
return False
if row.get("revoque_le") is not None:
return False
row["revoque_le"] = maintenant
_sauver(APPAREILS_FILE, store)
if row.get("jti"):
draco_session.revoke(str(row["jti"]),
int(row.get("exp", maintenant)))
return True
+23 -3
View File
@@ -242,10 +242,18 @@ def revoke_one_for_user(sub: str, jti: str) -> bool:
# ── Émission / vérification ─────────────────────────────────────────────
def issue_token(user: dict) -> tuple[str, str, int]:
"""Émet un JWS pour l'utilisateur. Retourne (jeton, jti, exp)."""
def issue_token(user: dict, ttl_seconds: int = TOKEN_TTL_SECONDS,
extra_claims: dict | None = None) -> tuple[str, str, int]:
"""Émet un JWS pour l'utilisateur. Retourne (jeton, jti, exp).
``ttl_seconds`` permet une durée de vie différente de la
session navigateur (la liaison d'appareil, #75, émet des
jetons de longue durée) ; ``extra_claims`` ajoute des claims
non réservés (ex. ``{"appareil": "<id>"}`` pour un jeton
d'appareil — les claims réservés ``sub``/``name``/``iat``/
``exp``/``jti`` ne sont jamais écrasés)."""
now = int(time.time())
exp = now + TOKEN_TTL_SECONDS
exp = now + int(ttl_seconds)
jti = uuid.uuid4().hex
claims = {
"sub": str(user.get("id") or user.get("username") or ""),
@@ -254,6 +262,10 @@ def issue_token(user: dict) -> tuple[str, str, int]:
"exp": exp,
"jti": jti,
}
if extra_claims:
for key, value in extra_claims.items():
if key not in claims:
claims[key] = value
token = jwt.encode(claims, _secret(), algorithm=ALGORITHM)
_register_issued(str(claims["sub"]), jti, exp)
return token, jti, exp
@@ -345,6 +357,14 @@ def user_for_draco(request) -> dict | None:
user["_token_vaults"] = candidate.get("vaults", [])
user["_token_scope"] = "full"
user["_draco_sub"] = sub
# Liaison d'appareil (#75) : un jeton portant le claim
# ``appareil`` est un jeton d'appareil, pas une session
# navigateur — l'identifiant est joint au dict pour que
# les endpoints de gestion des appareils le refusent (403).
# Les autres gardes (mot de passe, rôle Hub) s'appliquent
# à l'identique : un jeton d'appareil est un jeton draco.
if claims.get("appareil"):
user["_draco_appareil"] = str(claims["appareil"])
# HUB-19 (#228) : rôle du registre du Hub pour ce porteur.
# Niveau connu « aucun » → pas de session établie par draco :
# le refus est consigné sur la requête pour que `require_auth`
+2
View File
@@ -562,6 +562,7 @@ from backend.routers.files_read import router as files_read_router
from backend.routers.files_write import router as files_write_router
from backend.routers.health import router as health_router
from backend.routers.history import router as history_router
from backend.routers.liaison import router as liaison_router
from backend.routers.notify import router as notify_router
from backend.routers.realtime import router as realtime_router
from backend.routers.scheduler import router as scheduler_router
@@ -580,6 +581,7 @@ app.include_router(health_router) # ROADMAP #85 T1 — System / health
app.include_router(history_router) # ROADMAP #85 T8 — History
app.include_router(external_refs_router) # Fusion #215 — Références croisées (ACC-1.3)
app.include_router(sso_router) # Fusion #216 — Émettrice SSO draco_session (ACC-3.1)
app.include_router(liaison_router) # #75 — Liaison d'appareil (jeton draco)
app.include_router(realtime_router) # ROADMAP #85 T9 — SSE + collab WS
app.include_router(search_router) # ROADMAP #85 T5 — Search
app.include_router(backups_router) # ROADMAP #85 T4 — Backups
+1
View File
@@ -30,6 +30,7 @@ TAGS_METADATA: list[dict[str, str]] = [
{"name": "Bookmarks", "description": "Recently opened files, bookmarks and saved searches."},
{"name": "ExternalRefs", "description": "Cross-application references from a note to Flowdeck, TikTak, Kanbante or ObsiGate objects (Fusion program, ACC-1.3)."},
{"name": "SSO", "description": "draco_session single sign-on emitter: authorize entry point and jti revocation list for the other dracodev apps (Fusion program, ACC-3.1)."},
{"name": "Liaison d'appareil", "description": "Device-code linking for native clients (TikTak Desktop first): start a link, approve it in the browser, poll for the long-lived draco token, list and revoke linked devices (#75)."},
{"name": "Backups", "description": "Automatic file backups, diffs, restore, compression and purge."},
{"name": "Export", "description": "Export notes or whole vaults to HTML, Markdown bundle or ePub."},
{"name": "Guide", "description": "Download the in-app user guide as Markdown or PDF (mirrors the help modal, FR/EN)."},
+218
View File
@@ -0,0 +1,218 @@
# backend/routers/liaison.py
# Liaison d'appareil (#75) — flux « code d'appareil » émettant un
# jeton draco pour les clients natifs (TikTak Desktop d'abord).
#
# Protocole (miroir d'agent-commun, Fusion #45) :
# 1. l'app démarre une liaison : POST /api/v1/liaison (sans auth)
# -> code utilisateur XXXX-XXXX (10 min) + code d'appareil
# secret + URL de la page d'approbation ;
# 2. l'humain approuve (ou refuse) sur GET /liaison?code=...
# — session native ObsiGate exigée, jamais un jeton
# d'appareil ; la réponse d'approbation ne contient JAMAIS
# le jeton ;
# 3. l'app sonde : POST /api/v1/liaison/sonder -> en_attente /
# approuvee (+ jeton, livré UNE fois) / refusee / expiree /
# livree ; 404 si demande inconnue ou mauvais code ;
# 4. l'utilisateur gère ses appareils : GET /api/v1/appareils,
# POST /api/v1/appareils/{id}/revoquer (session exigée).
#
# Un jeton d'appareil présenté comme cookie draco authentifie
# comme une session draco (c'est un JWS draco standard), mais
# les endpoints de gestion et de décision le refusent avec 403
# (garde ``_exiger_session_native``, patron ``_exiger_session``
# d'agent-commun) ; présenté en ``Authorization: Bearer``, il
# est rejeté dès ``get_current_user`` (401) car ce n'est pas un
# jeton natif.
from __future__ import annotations
from pathlib import Path
from fastapi import APIRouter, Depends, HTTPException, Request
from fastapi.responses import FileResponse
from pydantic import BaseModel, Field
from backend import draco_appareils
from backend.auth.middleware import require_auth
router = APIRouter(tags=["Liaison d'appareil"])
FRONTEND_DIR = Path(__file__).resolve().parent.parent.parent / "frontend"
def _exiger_session_native(user: dict) -> dict:
"""Réserve une action aux sessions (native ou draco navigateur) :
un jeton d'appareil — porteur du claim ``appareil`` — ne gère
PAS les appareils et ne décide PAS des liaisons. Un jeton volé
ne peut donc ni frapper d'autres jetons ni couper ceux des
autres."""
if user.get("_draco_appareil"):
raise HTTPException(
status_code=403,
detail="Un jeton d'appareil ne peut pas gérer les "
"appareils ni décider une liaison.")
return user
# ── Modèles ─────────────────────────────────────────────────────────────
class LiaisonDemarrerIn(BaseModel):
"""Demande de liaison d'une application sans identifiant."""
nom: str = Field(default="", description="Nom de l'appareil (hostname)")
type: str = Field(default="desktop",
description="Type d'appareil : desktop, terminal, tiktak")
class LiaisonDemarrerOut(BaseModel):
demande_id: str
code_utilisateur: str
code_appareil: str
expire_le: float
expire_dans_s: int
type: str
url_liaison: str
url_liaison_absolue: str
class LiaisonSonderIn(BaseModel):
demande_id: str
code_appareil: str
class LiaisonCodeIn(BaseModel):
code: str
class AppareilOut(BaseModel):
id: str
nom: str
portee: str
type: str
cree_le: float | None = None
derniere_utilisation: float | None = None
expire_le: int | None = None
revoque: bool = False
revoque_le: float | None = None
class LiaisonSonderOut(BaseModel):
statut: str
jeton: str | None = None
appareil: AppareilOut | None = None
class LiaisonEnAttenteOut(BaseModel):
code_utilisateur: str
nom: str
type: str
cree_le: float | None = None
expire_le: float | None = None
# ── Page d'approbation ──────────────────────────────────────────────────
@router.get("/liaison", include_in_schema=False)
async def liaison_page():
"""Page publique d'approbation d'une liaison (``?code=XXXX-XXXX``,
saisie manuelle possible). La page elle-même n'exige rien : c'est
son JavaScript qui vérifie la session (``/api/auth/me``) puis
appelle les endpoints de décision."""
page = FRONTEND_DIR / "liaison.html"
if not page.exists():
raise HTTPException(status_code=404, detail="Page introuvable")
return FileResponse(str(page), media_type="text/html")
# ── Liaison ─────────────────────────────────────────────────────────────
@router.post("/api/v1/liaison", status_code=201,
response_model=LiaisonDemarrerOut)
async def liaison_demarrer(body: LiaisonDemarrerIn, request: Request):
"""Démarre une liaison d'appareil — SANS authentification : c'est
l'application qui demande (elle n'a encore aucun identifiant).
Elle reçoit le code utilisateur court à montrer à l'humain, un
code d'appareil secret pour sonder la décision, et l'URL de la
page d'approbation à ouvrir."""
try:
res = draco_appareils.demarrer_liaison(body.nom, body.type)
except draco_appareils.ErreurLiaison as exc:
raise HTTPException(status_code=exc.statut, detail=exc.message)
res["url_liaison"] = "/liaison?code=" + res["code_utilisateur"]
base = str(request.base_url).rstrip("/")
res["url_liaison_absolue"] = base + res["url_liaison"] if base else ""
return res
@router.post("/api/v1/liaison/sonder", response_model=LiaisonSonderOut,
response_model_exclude_none=True)
async def liaison_sonder(body: LiaisonSonderIn):
"""Le sondage de l'application : ``en_attente``, ``approuvee``
(avec le jeton d'appareil, livré UNE fois), ``refusee``,
``expiree`` ou ``livree`` (déjà consommée). Demande inconnue et
mauvais code d'appareil sont indiscernables (404) : sonder
n'apprend rien à qui n'a pas le code."""
res = draco_appareils.sonder_liaison(body.demande_id, body.code_appareil)
if res is None:
raise HTTPException(status_code=404,
detail="Demande de liaison inconnue.")
return res
@router.get("/api/v1/liaison/en-attente")
async def liaisons_en_attente(user: dict = Depends(require_auth)):
"""Les demandes de liaison en attente de décision — lues par la
page /liaison. Session exigée : un jeton d'appareil ne voit pas
les demandes."""
_exiger_session_native(user)
return {"liaisons": draco_appareils.liaisons_en_attente()}
@router.post("/api/v1/liaison/approuver")
async def liaison_approuver(body: LiaisonCodeIn,
user: dict = Depends(require_auth)):
"""Approuve une demande (session seulement) : l'appareil est créé
pour cet utilisateur ; son jeton attend la délivrance unique par
le sondage de l'application. La réponse ne contient JAMAIS le
jeton."""
_exiger_session_native(user)
try:
appareil = draco_appareils.approuver_liaison(body.code, user)
except draco_appareils.ErreurLiaison as exc:
raise HTTPException(status_code=exc.statut, detail=exc.message)
return {"appareil": appareil}
@router.post("/api/v1/liaison/refuser")
async def liaison_refuser(body: LiaisonCodeIn,
user: dict = Depends(require_auth)):
"""Refuse une demande en attente (session seulement)."""
_exiger_session_native(user)
ok = draco_appareils.refuser_liaison(body.code)
return {"refusee": ok}
# ── Appareils ───────────────────────────────────────────────────────────
@router.get("/api/v1/appareils")
async def appareils_lister(user: dict = Depends(require_auth)):
"""Les appareils liés de l'utilisateur. Session seulement ;
aucune donnée d'authentification ne sort d'ici."""
_exiger_session_native(user)
sub = str(user.get("id") or user.get("username") or "")
return {"appareils": draco_appareils.lister_appareils(sub)}
@router.post("/api/v1/appareils/{appareil_id}/revoquer")
async def appareils_revoquer(appareil_id: str,
user: dict = Depends(require_auth)):
"""Révoque un appareil (session seulement) : l'accès est coupé
dès l'appel suivant du jeton, la liste de révocation draco
étant relue par les consommateurs à chaque validation."""
_exiger_session_native(user)
sub = str(user.get("id") or user.get("username") or "")
ok = draco_appareils.revoquer_appareil(appareil_id, sub)
if not ok:
raise HTTPException(status_code=404,
detail="Appareil inconnu ou déjà révoqué.")
return {"revoque": True}
+1 -1
View File
@@ -2626,7 +2626,7 @@ dependencies = [
[[package]]
name = "obsigate-desktop"
version = "2.86.3"
version = "2.87.0"
dependencies = [
"chrono",
"env_logger",
+1 -1
View File
@@ -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"
+1 -1
View File
@@ -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",
+13 -1
View File
@@ -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)
+113
View File
@@ -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": "<id>"` ; 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`).
+87
View File
@@ -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; }
+51
View File
@@ -0,0 +1,51 @@
<!DOCTYPE html>
<html lang="fr">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Liaison d'appareil — ObsiGate</title>
<link rel="stylesheet" href="/static/liaison.css">
</head>
<body>
<main class="card">
<h1 data-i18n="title">Liaison d'appareil</h1>
<p class="subtitle" data-i18n="subtitle">Autorisez une application à se connecter à votre compte ObsiGate.</p>
<div id="etat-connexion" class="bloc" hidden>
<p data-i18n="loginNeeded">Vous devez être connecté à ObsiGate pour approuver une liaison.</p>
<a id="lien-connexion" class="btn primary" href="/" data-i18n="login">Se connecter</a>
</div>
<div id="bloc-code" class="bloc" hidden>
<label for="code" data-i18n="codeLabel">Code affiché par l'application</label>
<div class="ligne-code">
<input id="code" type="text" inputmode="text" autocomplete="off"
maxlength="9" placeholder="XXXX-XXXX" spellcheck="false">
<button id="btn-chercher" class="btn" type="button" data-i18n="search">Rechercher</button>
</div>
<p id="erreur-code" class="erreur" hidden></p>
</div>
<div id="bloc-demande" class="bloc" hidden>
<dl>
<div><dt data-i18n="device">Appareil</dt><dd id="demande-nom"></dd></div>
<div><dt data-i18n="type">Type</dt><dd id="demande-type"></dd></div>
<div><dt data-i18n="expires">Expire</dt><dd id="demande-expire"></dd></div>
</dl>
<div class="actions">
<button id="btn-approuver" class="btn primary" type="button" data-i18n="approve">Approuver</button>
<button id="btn-refuser" class="btn danger" type="button" data-i18n="refuse">Refuser</button>
</div>
<p id="message" class="message" hidden></p>
</div>
<div id="bloc-liste" class="bloc" hidden>
<h2 data-i18n="pendingTitle">Demandes en attente</h2>
<ul id="liste-demandee"></ul>
</div>
<p class="note" data-i18n="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.</p>
</main>
<script src="/static/liaison.js"></script>
</body>
</html>
+229
View File
@@ -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);
});
});
})();
+1 -1
View File
@@ -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": {
+344
View File
@@ -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 <script> est externe.
assert resp.text.count("<script") == 1
resp = client_liaison.get("/liaison")
assert resp.status_code == 200
def test_types_inconnus_retombent_sur_desktop(client_liaison):
demande = _demarrer(client_liaison, type_appareil="inconnu")
assert demande["type"] == "desktop"
def test_dedoublonnage_meme_nom_type(client_liaison):
client = client_liaison
_, jeton1, appareil1 = _lier(client, nom="poste-dup", type_appareil="tiktak")
_, jeton2, appareil2 = _lier(client, nom="poste-dup", type_appareil="tiktak")
assert appareil1["id"] != appareil2["id"]
# Le premier jeton a été révoqué par la seconde liaison.
assert draco_session.verify_token(jeton1) is None
assert draco_session.verify_token(jeton2) is not None
resp = client.get("/api/v1/appareils")
par_id = {a["id"]: a for a in resp.json()["appareils"]}
assert par_id[appareil1["id"]]["revoque"] is True
assert par_id[appareil2["id"]]["revoque"] is False
# ── Refus / erreurs ──────────────────────────────────────────────────────
def test_refus(client_liaison):
client = client_liaison
demande = _demarrer(client)
resp = client.post("/api/v1/liaison/refuser",
json={"code": demande["code_utilisateur"]})
assert resp.status_code == 200
assert resp.json() == {"refusee": True}
resp = client.post("/api/v1/liaison/sonder", json={
"demande_id": demande["demande_id"],
"code_appareil": demande["code_appareil"]})
assert resp.json()["statut"] == "refusee"
# Approuver une demande refusée : 404.
resp = client.post("/api/v1/liaison/approuver",
json={"code": demande["code_utilisateur"]})
assert resp.status_code == 404
# Refuser deux fois : False.
resp = client.post("/api/v1/liaison/refuser",
json={"code": demande["code_utilisateur"]})
assert resp.json() == {"refusee": False}
def test_sonder_inconnu_ou_mauvais_code_404(client_liaison):
client = client_liaison
demande = _demarrer(client)
resp = client.post("/api/v1/liaison/sonder", json={
"demande_id": "inexistant", "code_appareil": "nimporte"})
assert resp.status_code == 404
resp = client.post("/api/v1/liaison/sonder", json={
"demande_id": demande["demande_id"],
"code_appareil": "mauvais-code"})
assert resp.status_code == 404
# Demande inconnue et mauvais code sont indiscernables.
assert resp.json()["detail"] == "Demande de liaison inconnue."
def test_expiration(client_liaison, monkeypatch):
client = client_liaison
monkeypatch.setattr(draco_appareils, "_expiration_min", lambda: 0.0)
# Expiration immédiate : la demande naît déjà expirée.
demande = _demarrer(client)
assert demande["expire_dans_s"] == 0
resp = client.post("/api/v1/liaison/approuver",
json={"code": demande["code_utilisateur"]})
assert resp.status_code == 410
resp = client.post("/api/v1/liaison/sonder", json={
"demande_id": demande["demande_id"],
"code_appareil": demande["code_appareil"]})
assert resp.json()["statut"] == "expiree"
def test_double_livraison(client_liaison):
client = client_liaison
demande, jeton, _appareil = _lier(client)
resp = client.post("/api/v1/liaison/sonder", json={
"demande_id": demande["demande_id"],
"code_appareil": demande["code_appareil"]})
assert resp.status_code == 200
assert resp.json()["statut"] == "livree"
assert "jeton" not in resp.json()
def test_plafond_demandes_en_attente(client_liaison, monkeypatch):
monkeypatch.setattr(draco_appareils, "LIAISONS_MAX_EN_ATTENTE", 2)
_demarrer(client_liaison, nom="a")
_demarrer(client_liaison, nom="b")
resp = client_liaison.post("/api/v1/liaison",
json={"nom": "c", "type": "desktop"})
assert resp.status_code == 429
def test_sans_session_401(client_liaison):
# Client vierge (sans cookies de session) : les décisions exigent
# une session.
from backend.main import app
vierge = TestClient(app)
resp = vierge.get("/api/v1/appareils")
assert resp.status_code == 401
resp = vierge.post("/api/v1/liaison/approuver", json={"code": "ABCD-EFGH"})
assert resp.status_code == 401
resp = vierge.get("/api/v1/liaison/en-attente")
assert resp.status_code == 401
# Mais démarrer et sonder restent publics (l'app n'a pas d'identité).
resp = vierge.post("/api/v1/liaison", json={"nom": "x", "type": "desktop"})
assert resp.status_code == 201
# ── Jeton d'appareil : ni gestion, ni décision ──────────────────────────
def test_jeton_appareil_refuse_sur_gestion(client_liaison):
from backend.main import app
client = client_liaison
_, jeton, appareil = _lier(client)
# Client vierge ne portant QUE le jeton d'appareil : sans la
# session native, c'est le jeton qui authentifie.
nu = TestClient(app)
# En cookie draco (session draco) : 403 explicite.
nu.cookies.set("draco_session", jeton)
resp = nu.get("/api/v1/appareils")
assert resp.status_code == 403
resp = nu.post("/api/v1/liaison/approuver",
json={"code": "ABCD-EFGH"})
assert resp.status_code == 403
resp = nu.post(f"/api/v1/appareils/{appareil['id']}/revoquer")
assert resp.status_code == 403
# En Bearer : pas un jeton natif -> 401 (rejet dès get_current_user).
nu.cookies.delete("draco_session")
resp = nu.get("/api/v1/appareils",
headers={"Authorization": f"Bearer {jeton}"})
assert resp.status_code == 401
def test_role_hub_aucun_refuse_le_jeton_appareil(client_liaison, monkeypatch):
# HUB-19 : si le Hub attribue « aucun » au porteur, le jeton
# d'appareil ne vaut pas session — comme la session draco.
monkeypatch.setattr(hub_roles, "role_pour",
lambda sub, cookie: "aucun")
from backend.main import app
_, jeton, _appareil = _lier(client_liaison)
nu = TestClient(app)
nu.cookies.set("draco_session", jeton)
resp = nu.get("/api/v1/appareils")
# HUB-19 : refus explicite 403 (pas le 401 générique), message en
# français sur le rôle « aucun ».
assert resp.status_code == 403
assert "aucun" in resp.json()["detail"]
# ── issue_token : ttl et claims supplémentaires ─────────────────────────
def test_issue_token_ttl_et_claims(client_liaison):
# La fixture pose le secret draco et isole les fichiers de registre.
token, _jti, exp = draco_session.issue_token(
{"id": "admin-1", "username": "admin"},
ttl_seconds=3600, extra_claims={"appareil": "abc"})
claims = draco_session.verify_token(token)
assert claims["exp"] - claims["iat"] == 3600
assert claims["appareil"] == "abc"
# Les claims réservés ne sont jamais écrasés.
token2, _j, _e = draco_session.issue_token(
{"id": "admin-1", "username": "admin"},
extra_claims={"sub": "intrus", "exp": 1})
assert draco_session.verify_token(token2)["sub"] == "admin-1"