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
Showing only changes of commit fbf87c7a6b - Show all commits
+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"