449 lines
18 KiB
Python
449 lines
18 KiB
Python
# 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
|