Compare commits

..
63 Commits
Author SHA1 Message Date
bruno 4c686afac3 Merge pull request 'ObsiGate 2.87.0 — Liaison d'appareil : flux code d'appareil émettant un jeton draco (#75)' (#76) from feat/liaison-appareil-draco into main
CI / lint (push) Successful in 1m33s
CI / security (push) Failing after 44s
CI / test (push) Successful in 4m42s
CI / build (push) Successful in 11s
CI / e2e (push) Failing after 15m20s
2026-11-16 19:14:04 -05:00
bruno 9021765b45 docs: roadmap #229 — PR #76 (#75, 2.87.0)
CI / lint (pull_request) Successful in 1m37s
CI / security (pull_request) Failing after 25s
CI / test (pull_request) Successful in 3m41s
CI / build (pull_request) Successful in 46s
CI / e2e (pull_request) Failing after 15m14s
2026-11-16 17:29:52 -05:00
bruno 750dfc25a1 feat: liaison d'appareil — flux code d'appareil émettant un jeton draco (#75, 2.87.0)
CI / lint (pull_request) Successful in 1m51s
CI / security (pull_request) Failing after 31s
CI / test (pull_request) Successful in 3m39s
CI / build (pull_request) Successful in 12s
CI / e2e (pull_request) Failing after 14m50s
2026-11-16 17:29:00 -05:00
bruno 6f84ac03fa feat: liaison d'appareil — flux code d'appareil émettant un jeton draco (#75, 2.87.0) 2026-11-16 17:28:57 -05:00
bruno 8c1e47b731 feat: liaison d'appareil — flux code d'appareil émettant un jeton draco (#75, 2.87.0) 2026-11-16 17:28:54 -05:00
bruno 7e3af155a4 feat: liaison d'appareil — flux code d'appareil émettant un jeton draco (#75, 2.87.0) 2026-11-16 17:28:50 -05:00
bruno 0560c9a6e5 feat: liaison d'appareil — flux code d'appareil émettant un jeton draco (#75, 2.87.0) 2026-11-16 17:28:47 -05:00
bruno 9a6a2946b9 feat: liaison d'appareil — flux code d'appareil émettant un jeton draco (#75, 2.87.0) 2026-11-16 17:28:44 -05:00
bruno 980274052f feat: liaison d'appareil — flux code d'appareil émettant un jeton draco (#75, 2.87.0) 2026-11-16 17:28:42 -05:00
bruno 8d6b009170 feat: liaison d'appareil — flux code d'appareil émettant un jeton draco (#75, 2.87.0) 2026-11-16 17:28:40 -05:00
bruno e3c50b424b feat: liaison d'appareil — flux code d'appareil émettant un jeton draco (#75, 2.87.0) 2026-11-16 17:28:37 -05:00
bruno a48aaf18e5 feat: liaison d'appareil — flux code d'appareil émettant un jeton draco (#75, 2.87.0) 2026-11-16 17:28:34 -05:00
bruno fbf87c7a6b feat: liaison d'appareil — flux code d'appareil émettant un jeton draco (#75, 2.87.0) 2026-11-16 17:28:31 -05:00
bruno e13648f771 feat: liaison d'appareil — flux code d'appareil émettant un jeton draco (#75, 2.87.0) 2026-11-16 17:28:28 -05:00
bruno 8ce9b15869 feat: liaison d'appareil — flux code d'appareil émettant un jeton draco (#75, 2.87.0) 2026-11-16 17:28:25 -05:00
bruno 2c3a00946b feat: liaison d'appareil — flux code d'appareil émettant un jeton draco (#75, 2.87.0) 2026-11-16 17:28:22 -05:00
bruno aee01c21c1 feat: liaison d'appareil — flux code d'appareil émettant un jeton draco (#75, 2.87.0) 2026-11-16 17:28:18 -05:00
bruno 3fce35e708 feat: liaison d'appareil — flux code d'appareil émettant un jeton draco (#75, 2.87.0) 2026-11-16 17:28:15 -05:00
bruno cb3a372af6 feat: liaison d'appareil — flux code d'appareil émettant un jeton draco (#75, 2.87.0) 2026-11-16 17:28:11 -05:00
bruno bc43b999df feat: liaison d'appareil — flux code d'appareil émettant un jeton draco (#75, 2.87.0) 2026-11-16 17:28:08 -05:00
bruno 55a4171313 feat: liaison d'appareil — flux code d'appareil émettant un jeton draco (#75, 2.87.0) 2026-11-16 17:28:05 -05:00
bruno bf030669a0 Merge pull request 'ObsiGate 2.86.3 — retour SSO : réémission du cookie draco garantie à l’arrivée authorize (BUG-125)' (#74) from retour-sso-cookie-draco-bug-125 into main
CI / lint (push) Successful in 1m22s
CI / security (push) Successful in 24s
CI / test (push) Successful in 3m59s
CI / build (push) Successful in 15s
CI / e2e (push) Failing after 14m58s
2026-11-08 16:52:00 -05:00
Spark 83a81b931e fix: retour SSO — réémission du cookie draco garantie à l'arrivée authorize (BUG-125)
CI / lint (pull_request) Successful in 1m18s
CI / security (pull_request) Successful in 19s
CI / test (pull_request) Successful in 3m43s
CI / build (pull_request) Successful in 12s
CI / e2e (pull_request) Failing after 15m32s
2026-11-08 21:46:30 +00:00
bruno 23df2bdcbe Merge pull request 'ObsiGate 2.86.2 — entrée SSO : retour honoré à la restauration de session + nom poussé à la barre (BUG-123, BUG-124)' (#73) from entree-sso-bug-123-124 into main
CI / lint (push) Successful in 1m45s
CI / security (push) Successful in 18s
CI / test (push) Failing after 4m52s
CI / build (push) Skipped
CI / e2e (push) Skipped
2026-11-08 13:21:04 -05:00
Spark 03a1c9f6f5 fix: entrée SSO — retour honoré à la restauration de session et nom du compte poussé à la barre (BUG-123, BUG-124)
CI / lint (pull_request) Successful in 1m24s
CI / security (pull_request) Successful in 17s
CI / test (pull_request) Successful in 3m38s
CI / build (pull_request) Successful in 12s
CI / e2e (pull_request) Failing after 15m36s
BUG-123 : /sso/authorize déposait l'utilisateur déjà connecté
sur l'accueil ObsiGate sans suivre le return_to — seul
saveToken() (login frais) l'honorait. initAuth() l'honore
désormais sur ses deux chemins de restauration au démarrage ;
les refresh en cours de session ne redirigent jamais.

BUG-124 : après un login SPA, le menu compte de la barre
affichait « Compte » jusqu'au rechargement. Barre commune
re-vendangée en v0.7.0 (DRACO_BAR.setUser, commons PR #15) ;
renderUserSection() et le fetch d'amorçage poussent le nom.

Garde : tests/test_draco_barre.py (nouveau test épinglé).
Suite complète : 1977 passed, 1 skipped ; ruff et mypy 0.
2026-11-08 17:49:27 +00:00
bruno 045abd6a3c Merge pull request 'ObsiGate 2.86.1 — barre v0.6.0 : entrée « Administration » du menu compte (fusion #142)' (#72) from menu-compte-admin-v060 into main
CI / lint (push) Successful in 1m19s
CI / security (push) Successful in 19s
CI / test (push) Successful in 3m37s
CI / build (push) Successful in 11s
CI / e2e (push) Failing after 15m5s
2026-11-06 15:27:43 -05:00
Spark 06855937bd feat: barre v0.6.0 — entrée « Administration » du menu compte affirmée par le rôle global (fusion #142)
CI / lint (pull_request) Successful in 1m31s
CI / security (pull_request) Successful in 29s
CI / test (pull_request) Successful in 3m40s
CI / build (pull_request) Successful in 12s
CI / e2e (pull_request) Failing after 14m47s
2026-11-06 20:21:31 +00:00
bruno 854ff0f904 Merge pull request 'ObsiGate 2.86.0 — BUG-122 : déconnexion globale navigable GET /sso/logout (fusion #141)' (#71) from fix/deconnexion-globale-bug-122 into main
CI / lint (push) Successful in 1m21s
CI / security (push) Successful in 17s
CI / test (push) Successful in 3m40s
CI / build (push) Successful in 10s
CI / e2e (push) Failing after 15m8s
2026-11-06 14:26:43 -05:00
Spark 5a5d7a5c59 fix: brancher aussi la barre d'ObsiGate sur /sso/logout (BUG-122, fusion #141)
CI / lint (pull_request) Successful in 1m21s
CI / security (pull_request) Successful in 16s
CI / test (pull_request) Successful in 3m37s
CI / build (pull_request) Successful in 11s
CI / e2e (pull_request) Failing after 17m11s
2026-11-06 19:07:29 +00:00
Spark b8949b2ddc fix: point d'entrée navigable de la déconnexion globale GET /sso/logout (BUG-122, fusion #141) — 2.86.0
CI / lint (pull_request) Successful in 1m17s
CI / security (pull_request) Successful in 16s
CI / test (pull_request) Successful in 3m40s
CI / build (pull_request) Successful in 32s
CI / e2e (pull_request) Failing after 15m40s
2026-11-06 18:56:04 +00:00
bruno 15d015e59b Merge pull request 'ObsiGate 2.85.1 — HUB-19 : propagation des rôles du Hub (consommatrice, registre D3(a)) (#228)' (#69) from hub19-roles-obsigate-2-85-1 into main
CI / lint (push) Successful in 1m14s
CI / security (push) Successful in 19s
CI / test (push) Successful in 3m34s
CI / build (push) Successful in 11s
CI / e2e (push) Failing after 15m26s
2026-11-06 11:31:25 -05:00
Spark dcf847e2fd feat: HUB-19 — rôles du Hub consommés par ObsiGate (registre D3(a)) #228
CI / lint (pull_request) Successful in 1m17s
CI / security (pull_request) Successful in 21s
CI / test (pull_request) Failing after 3m39s
CI / build (pull_request) Skipped
CI / e2e (pull_request) Skipped
2026-11-06 16:30:30 +00:00
bruno a3f76e9b0c Merge pull request 'ObsiGate 2.85.0 — HUB-22 : API machine des sessions draco (liste et révocation, #227)' (#68) from hub22-sessions-machine into main
CI / lint (push) Failing after 11s
CI / test (push) Skipped
CI / build (push) Skipped
CI / e2e (push) Skipped
CI / security (push) Successful in 24s
2026-11-06 11:25:26 -05:00
Spark c157a22668 feat: HUB-22 — API machine des sessions draco : liste et révocation des sessions (2.85.0, #227)
CI / lint (pull_request) Successful in 1m17s
CI / security (pull_request) Successful in 17s
CI / test (pull_request) Successful in 3m34s
CI / build (pull_request) Successful in 17s
CI / e2e (pull_request) Failing after 16m29s
2026-11-06 11:08:04 -05:00
Spark cc3707be7a feat: HUB-22 — API machine des sessions draco : liste et révocation des sessions (2.85.0, #227) 2026-11-06 11:08:01 -05:00
Spark 75c6f61235 feat: HUB-22 — API machine des sessions draco : liste et révocation des sessions (2.85.0, #227) 2026-11-06 11:07:58 -05:00
Spark 8d7692c6df feat: HUB-22 — API machine des sessions draco : liste et révocation des sessions (2.85.0, #227) 2026-11-06 11:07:55 -05:00
Spark 318a20c652 feat: HUB-22 — API machine des sessions draco : liste et révocation des sessions (2.85.0, #227) 2026-11-06 11:07:51 -05:00
Spark 006cbeed64 feat: HUB-22 — API machine des sessions draco : liste et révocation des sessions (2.85.0, #227) 2026-11-06 11:07:46 -05:00
Spark 92ad47fc99 feat: HUB-22 — API machine des sessions draco : liste et révocation des sessions (2.85.0, #227) 2026-11-06 11:07:43 -05:00
Spark 84648591ea feat: HUB-22 — API machine des sessions draco : liste et révocation des sessions (2.85.0, #227) 2026-11-06 11:07:39 -05:00
Spark 308f99cf63 feat: HUB-22 — API machine des sessions draco : liste et révocation des sessions (2.85.0, #227) 2026-11-06 11:07:35 -05:00
Spark 3bfda066ab feat: HUB-22 — API machine des sessions draco : liste et révocation des sessions (2.85.0, #227) 2026-11-06 11:07:31 -05:00
Spark 0230f4fa72 feat: HUB-22 — API machine des sessions draco : liste et révocation des sessions (2.85.0, #227) 2026-11-06 11:07:30 -05:00
Spark 9f6f366870 feat: HUB-22 — API machine des sessions draco : liste et révocation des sessions (2.85.0, #227) 2026-11-06 11:07:27 -05:00
Spark 44a8154cae feat: HUB-22 — API machine des sessions draco : liste et révocation des sessions (2.85.0, #227) 2026-11-06 11:07:24 -05:00
Spark 222cd0b562 feat: HUB-22 — API machine des sessions draco : liste et révocation des sessions (2.85.0, #227) 2026-11-06 11:07:22 -05:00
Spark 5127510509 revert: HUB-22 — retrait du fichier poussé par erreur sur main (le PUT Contents a ignoré new_branch_name ; la livraison repart en branche hub22-sessions-machine, #227)
CI / lint (push) Successful in 1m20s
CI / security (push) Successful in 16s
CI / test (push) Successful in 4m42s
CI / build (push) Successful in 13s
CI / e2e (push) Failing after 14m59s
2026-11-06 11:06:56 -05:00
Spark 3876f0e9c3 feat: HUB-22 — API machine des sessions draco : liste et révocation des sessions (2.85.0, #227)
CI / lint (push) Successful in 1m18s
CI / security (push) Successful in 16s
CI / test (push) Successful in 3m35s
CI / build (push) Successful in 14s
CI / e2e (push) Failing after 15m32s
2026-11-06 11:06:00 -05:00
bruno c8d2eb19db Merge pull request 'ObsiGate 2.84.1 — HUB-18 : thème commun, barre v0.5.0 + initialisation thème Hub (fusion #132)' (#67) from hub18-theme-commun into main
CI / lint (push) Successful in 1m34s
CI / security (push) Successful in 28s
CI / test (push) Successful in 4m49s
CI / build (push) Successful in 10s
CI / e2e (push) Failing after 14m54s
2026-11-06 09:45:58 -05:00
Spark 2943e40e81 feat: HUB-18 thème commun — barre v0.5.0 + init thème Hub (2.84.1, fusion #132)
CI / lint (pull_request) Successful in 1m16s
CI / security (pull_request) Successful in 16s
CI / test (pull_request) Successful in 3m38s
CI / build (pull_request) Successful in 13s
CI / e2e (pull_request) Failing after 15m2s
2026-11-06 14:22:45 +00:00
bruno 128deb248d Merge pull request 'ObsiGate 2.84.0 — HUB-13 : API d'administration des comptes machine-à-machine (fusion #127)' (#66) from hub13-api-admin-comptes-2-84-0 into main
CI / lint (push) Successful in 1m15s
CI / security (push) Successful in 15s
CI / test (push) Successful in 3m45s
CI / build (push) Successful in 10s
CI / e2e (push) Successful in 14m48s
2026-11-06 08:40:24 -05:00
Spark 151d9faeab chore: relance de la vérification de la PR (commit vide, aucun changement de code)
CI / lint (pull_request) Successful in 1m17s
CI / security (pull_request) Successful in 16s
CI / test (pull_request) Successful in 3m46s
CI / build (pull_request) Successful in 11s
CI / e2e (pull_request) Successful in 15m53s
2026-11-06 13:34:29 +00:00
bruno c335f57ea2 Merge PR #66 : ObsiGate 2.84.0 — HUB-13 API admin des comptes (go Bruno)
CI / lint (push) Successful in 1m21s
CI / security (push) Successful in 17s
CI / test (push) Successful in 3m49s
CI / build (push) Successful in 15s
CI / e2e (push) Successful in 15m8s
2026-11-05 22:30:21 -05:00
Spark c27fd977a8 ObsiGate 2.84.0 : version et changelog (HUB-13, fusion #127) — VERSION + fichiers dérivés synchronisés par scripts/bump_version.py
CI / lint (pull_request) Successful in 1m23s
CI / security (pull_request) Successful in 23s
CI / test (pull_request) Successful in 3m34s
CI / build (pull_request) Successful in 1m32s
CI / e2e (pull_request) Successful in 15m8s
2026-11-06 00:58:19 +00:00
Spark 65d01f91b8 ObsiGate 2.84.0 : API d'administration des comptes machine-à-machine (HUB-13, fusion #127, #226) — routes /api/admin/machine/comptes protégées par DRACO_ADMIN_MACHINE_KEY, révocation des jti draco à la désactivation, must_change_password, journalisation d'audit 2026-11-06 00:58:16 +00:00
bruno 0427c00015 Merge pull request 'ObsiGate 2.83.5 — barre v0.4.1 : correctif des icônes invisibles du menu compte (#125)' (#65) from hub12-barre-v041 into main
CI / lint (push) Successful in 2m28s
CI / security (push) Successful in 25s
CI / test (push) Successful in 3m34s
CI / build (push) Successful in 9s
CI / e2e (push) Successful in 16m51s
2026-11-05 02:09:20 -05:00
Spark b83de53447 ObsiGate 2.83.5 : barre v0.4.1 — menu compte resserré à 232 px, re-vendange verbatim (fusion #125)
CI / lint (pull_request) Successful in 1m21s
CI / security (pull_request) Successful in 28s
CI / test (pull_request) Successful in 5m18s
CI / build (pull_request) Successful in 15s
CI / e2e (pull_request) Successful in 16m40s
2026-11-05 07:08:02 +00:00
Spark 5eba3e2558 ObsiGate 2.83.5 : version et changelog (barre v0.4.1, fusion #125) — VERSION + fichiers dérivés synchronisés par scripts/bump_version.py
CI / lint (pull_request) Successful in 1m28s
CI / security (pull_request) Successful in 17s
CI / test (pull_request) Successful in 3m57s
CI / build (pull_request) Successful in 10s
CI / e2e (pull_request) Successful in 17m0s
2026-11-05 05:53:14 +00:00
Spark 10aa88e03c ObsiGate 2.83.5 : barre v0.4.1 — correctif des icônes invisibles du menu compte, vendange verbatim (fusion #125) + garde 2026-11-05 05:53:05 +00:00
bruno e0e0f9af0f Merge pull request 'ObsiGate 2.83.4 — barre v0.4.0 : icônes monoline dans le menu compte (HUB-11)' (#64) from hub11-barre-v040 into main
CI / lint (push) Successful in 1m24s
CI / security (push) Successful in 17s
CI / test (push) Successful in 3m35s
CI / build (push) Successful in 10s
CI / e2e (push) Successful in 16m38s
2026-11-05 00:33:34 -05:00
Spark 35b828a4c5 ObsiGate 2.83.4 : version et changelog (barre v0.4.0, HUB-11) — VERSION + fichiers dérivés synchronisés par scripts/bump_version.py
CI / lint (pull_request) Successful in 1m19s
CI / security (pull_request) Successful in 21s
CI / test (pull_request) Successful in 3m37s
CI / build (pull_request) Successful in 12s
CI / e2e (pull_request) Successful in 16m51s
2026-11-05 05:03:01 +00:00
Spark 6ebb3b3eae ObsiGate 2.83.4 : barre v0.4.0 — icônes monoline du menu compte, vendange verbatim (HUB-11) + garde 2026-11-05 05:02:10 +00:00
44 changed files with 4539 additions and 34 deletions
Regular → Executable
View File
Regular → Executable
View File
+65 -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.83.3**.
> [Unreleased](#unreleased). La dernière version livrée est **2.87.0**.
---
@@ -14,6 +14,70 @@ 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`.
---
## [2.86.2] — 2026-11-08
- **BUG-123 — Aller-retour SSO refermé aussi quand la session ObsiGate existe déjà** (chantier « entrée SSO de bout en bout », écart constaté par Bruno en test réel le 2026-11-08) : `GET /sso/authorize?return_to=…` redirige vers `/?return_to=…`, mais le retour n'était honoré que par `AuthManager.saveToken()` (login frais, MFA, WebAuthn). Pour un utilisateur déjà connecté chez ObsiGate, `initAuth()` restaurait la session — jeton encore valide ou refresh silencieux — et affichait l'accueil sans jamais suivre le `return_to` : l'utilisateur restait chez ObsiGate, et l'application sœur ne recevait jamais son pont (aucune session locale). Correctif (`frontend/js/auth.js`) : `_honorReturnTo()` signale désormais la redirection (valeur de retour), et les deux chemins de restauration d'`initAuth()` l'invoquent avant d'afficher l'application. Les refresh silencieux **en cours de session** ne sont pas touchés : ils ne doivent jamais rediriger. Même liste blanche qu'avant (https + `*.dracodev.net`, jamais l'hôte courant). Garde : `tests/test_draco_barre.py` (`test_barre_v070_setuser_et_retour_sso_restauration`) ; chaîne complète prouvée en navigateur réel dans une pile locale aux noms publics (dossier `preuve-entree-sso`). Fiche : `docs/features/entree-sso-bug-123-124.md`.
- **BUG-124 — Le nom du compte rejoint la barre commune dès le login, sans rechargement** (même chantier) : après un login dans la SPA, le menu compte de la barre affichait l'en-tête générique « Compte » et l'avatar neutre « ✦ » jusqu'au rechargement forcé — `renderUserSection()` poussait le rôle (`setAdmin`) mais jamais le nom, et le seul poseur d'identité était le fetch d'amorçage d'`index.html`, limité aux sessions déjà présentes au chargement. Barre commune re-vendangée **verbatim** en **v0.7.0** depuis dracodev-commons (PR commons #15) : nouvelle API `DRACO_BAR.setUser(user)` qui resynchronise l'avatar (initiale, infobulle) et l'en-tête du menu compte immédiatement. Branchement hôte : `renderUserSection()` appelle `setUser(name)` pour toute session établie (et `setUser(null)` sans identité), le fetch d'amorçage d'`index.html` également. Garde : `tests/test_draco_barre.py` (même test).
---
## [2.86.1] — 2026-11-06
- **Barre commune v0.6.0 — entrée « Administration » du menu compte** (fusion #142, demande de Bruno) : barre re-vendangée **verbatim** depuis dracodev-commons (PR commons #14) — `frontend/draco-barre.js` et `frontend/draco-barre.css`. Le menu compte gagne un cinquième lien Hub, « Administration » → `<hub>/admin` (le Hub redirige vers `/admin/utilisateurs`), après le séparateur et avant « Déconnexion », à **visibilité conditionnelle** : l'entrée n'apparaît que si l'hôte affirme que le compte courant est administrateur de suite (`DRACO_BAR.setAdmin`). Branchement hôte : `frontend/index.html` affirme le statut depuis la réponse de `/api/auth/me` déjà chargée pour l'avatar — `setAdmin(u.role === "admin")`. Le rôle global du compte chez ObsiGate est la définition même de l'administrateur de suite (c'est lui que la garde `/admin/*` du Hub vérifie, via ce même endpoint) : ObsiGate le connaît nativement. Tout autre rôle, ou échec de l'appel : aucune affirmation, l'entrée reste masquée. Garde : `tests/test_draco_barre.py` (`test_barre_v060_entree_administration`).
---
## [2.86.0] — 2026-11-06
- **BUG-122 — Déconnexion globale navigable : `GET /sso/logout`** (fusion #141) : le bouton « Déconnexion » du menu compte de la barre commune ne faisait rien dans les applications sœurs — la barre relaie l'action à l'hôte, et la déconnexion globale d'ObsiGate (ACC-3.1, #216) n'était appelable qu'en same-origin depuis l'interface d'ObsiGate (`POST /api/auth/logout`). Nouvelle route `GET /sso/logout?return_to=`, symétrique de `/sso/authorize` : elle exécute la déconnexion globale — logique extraite dans `apply_global_logout()` (`backend/auth/router.py`), désormais partagée par les deux entrées (jetons natifs refresh/access révoqués, `jti` du cookie `draco_session` révoqué, cookie effacé sur le domaine parent) — puis redirige vers le `return_to` validé par la liste blanche existante (`validate_return_to` : https + `*.dracodev.net`, repli « / »). Idempotente sans session. Les applications sœurs branchent leur action `deconnexion` sur cette route (leur session locale est détruite d'abord chez celles qui en ont une) — et la barre d'ObsiGate elle-même aussi (`frontend/index.html`, retour à sa racine). Tests : `tests/test_draco_session.py` (+3 : révocation et redirection, liste blanche, idempotence), `tests/test_draco_barre.py` (+1 : branchement de la barre d'ObsiGate). Fiche : `docs/features/deconnexion-globale-bug-122.md`.
---
## [2.85.1] — 2026-11-06
- **HUB-19 — Propagation des rôles du Hub à ObsiGate (suite du pilote ShaarIt, fusion Hub v2 §2.2, décision D3(a), #228)** : ObsiGate, à la fois émettrice et consommatrice du SSO, consomme à son tour le registre des rôles du Hub. Nouveau client `backend/hub_roles.py` : à l'ouverture de session draco (validation locale `draco_session.user_for_draco`), consultation de `GET {hub}/api/roles/obsigate` (en-tête Cookie complet relayé, `Accept: application/json`, délai 2 s), cache mémoire 60 s par `sub` sur le patron du pilote (horodatage posé avant l'appel : un échec conserve l'ancien cache, pas de rafale) ; URL du Hub résolue comme la barre commune (`draco_config.app_url("hub")` : `DRACO_HUB_URL` explicite, dérivation par l'hôte sœur, défaut officiel — jamais d'URL dev figée). **Effets, sessions établies par draco seulement** : niveau connu `aucun` → session draco refusée, `require_auth` répond 403 avec un message explicite en français (l'authentification native d'ObsiGate — l'émettrice, son accès propre est le secours — n'est jamais touchée) ; routes d'administration `/api/auth/admin/*` : nouvelle garde `require_admin_hub` — canal draco + rôle connu ⇒ niveau `administrateur` du registre exigé, sessions natives et rôle inconnu (Hub injoignable ou en erreur) ⇒ règles actuelles inchangées, aucun verrouillage nouveau, et le registre n'élève aucun privilège local. Validation locale du jeton, émission, révocations et renouvellement inchangés ; aucun rôle dans le jeton. Aucun impact frontend (pas d'i18n). Fiche : `docs/features/hub-roles-obsigate-228.md`. Tests : `tests/test_hub_roles.py` (client : parsing/cache/repli/résolution d'URL ; intégration : refus draco, garde admin). **Hypothèse de version** : branche depuis le main 2.84.1, cible 2.85.1 — rebasée sur la 2.85.0 (PR « API sessions HUB-22 » fusionnée d'abord) avant fusion.
## [2.85.0] — 2026-11-06
- **HUB-22 — API machine des sessions draco (vague C du plan Hub v2.1, #227)** : trois nouvelles routes sous la garde machine existante (`DRACO_ADMIN_MACHINE_KEY`, en-têtes `X-Draco-Machine-Key` / `X-Draco-Actor` ; 401 sans clé valide, 404 si l'API n'est pas configurée ou le compte inconnu) — `GET /api/admin/machine/comptes/{username}/sessions` liste les sessions actives du compte (`jti`, `exp`, `expire_le` en ISO 8601 UTC, `revoquee`), `POST …/sessions/{jti}/revoquer` révoque une session (404 si le `jti` n'est pas dans l'ensemble actif de ce compte — jamais de révocation cross-utilisateur) et `POST …/sessions/revoquer-toutes` révoque toutes les sessions (déconnexion globale, **sans désactiver le compte**). Backend : `draco_session.issued_sessions_for_user()` (sessions actives triées par expiration, purge des expirés au passage) et `revoke_one_for_user()` (appartenance au `sub` vérifiée avant révocation), sur le registre des émissions de HUB-13 et la même clé d'identité (`id`, à défaut `username`). Écritures journalisées dans `data/audit.log` (`session_revoquee`, `sessions_revoquees`). Fiche : `docs/features/hub-sessions-machine-227.md`. Tests : `tests/test_comptes_machine.py` (`TestSessions`), `tests/test_draco_session.py`.
---
## [2.84.1] — 2026-11-06
- **HUB-18 — Thème commun (fusion #132)** : barre commune re-vendangée **verbatim** en **v0.5.0** depuis dracodev-commons (branche `hub18-theme-commun`, PR commons #12) — `frontend/draco-barre.js` seul change côté barre (CSS et fragment inchangés). La barre apprend la préférence de thème du profil du Hub (`GET <hub>/api/profil/theme`, cookie draco ; `<hub>` = URL résolue de la barre, jamais figée) et l'applique à l'ouverture : cache `localStorage` `draco-theme-hub` (TTL 12 h) appliqué synchrone, puis fetch asynchrone non bloquant ; `sombre`/`clair` posent `data-theme`, `systeme` le retire (`prefers-color-scheme` décide). **Repli intégral** si le Hub ne répond pas, répond non-OK ou `theme: null` : le comportement actuel (choix local, puis système) reste seul maître. Initialisation propre à ObsiGate dans `frontend/app.js` : `initTheme()` écoute l'événement `draco:theme` de la barre et route le mode effectif par `applyTheme()` — icône et libellé du bouton de thème et feuilles highlight.js restent synchronisés, le mode appliqué devient le choix local mémorisé (`obsigate-theme`), et le bouton de bascule reste fonctionnel pour la session. Garde ajoutée à `tests/test_draco_barre.py`.
---
## [2.84.0] — 2026-11-06
- **HUB-13 — API d'administration des comptes, machine-à-machine (fusion #127, #226)** : nouvelles routes `/api/admin/machine/comptes` (liste, profil étendu, création, modification, désactivation/réactivation, suppression, réinitialisation du mot de passe et du MFA), protégées par la clé machine dédiée `DRACO_ADMIN_MACHINE_KEY` (en-tête `X-Draco-Machine-Key`, distincte de `DRACO_SSO_MACHINE_KEY` ; aucune session utilisateur ne les ouvre ; API inerte si la clé n'est pas configurée). Le profil étendu expose nom d'utilisateur, nom affiché, langue, avatar (valeur + présence), rôle global, état actif, MFA activé oui/non — jamais le secret TOTP ni le haché du mot de passe. La désactivation arrête l'émission de nouveaux jetons et révoque les `jti` draco actifs : `draco_session` tient désormais un registre des émissions (`data/draco_issued.json`) et `revoke_all_for_user()` révoque via la liste existante ; le repère `password_changed_at` (BUG-028) est aussi avancé. Nouveau champ utilisateur `must_change_password` : posé à la création machine et à la réinitialisation du mot de passe, signalé par la connexion et `GET /api/auth/me`, effacé au changement effectif. Chaque action est journalisée dans `data/audit.log` (acteur = identité de service `X-Draco-Actor`, action, compte cible, horodatage). Fiche : `docs/features/hub-api-admin-comptes-226.md`. Tests : `tests/test_comptes_machine.py`.
---
## [2.83.5] — 2026-11-05
- **Barre commune v0.4.1 — correctif des icônes invisibles du menu compte (fusion #125)** : seul `frontend/draco-barre.js` change, re-vendangé **verbatim** depuis dracodev-commons (branche `menu-compte-icones-svg-ns-v0-4-1`, PR commons #11) ; le CSS est inchangé. En v0.4.0, `menuIcone()` créait le `<svg>` des icônes et ses primitives via `document.createElement()` — espace de noms **HTML**, jamais dessinés par le navigateur : les libellés du menu compte étaient décalés d'un cran d'icône, sans aucun glyphe. La v0.4.1 crée tout via `document.createElementNS()` (espace de noms SVG). Glyphes, CSS et comportements inchangés. Garde ajoutée à `tests/test_draco_barre.py`.
---
## [2.83.4] — 2026-11-05
- **Barre commune v0.4.0 — icônes monoline du menu compte (HUB-11, fusion #125)** : `frontend/draco-barre.js` et `frontend/draco-barre.css` re-vendangés **verbatim** depuis dracodev-commons v0.4.0 (branche `menu-compte-icones-v0-4-0`, PR commons #10). Les items du menu compte — **Télécharger**, **À Propos**, **Aides**, **Profil**, **Déconnexion** — reçoivent des **icônes SVG monoline** (contour, trait fin, `currentColor`, ~18 px) dans le style des icônes du rail de la console Spark ; aucun emoji. L'en-tête d'identité reste sans icône ; les liens Hub et le relais « Déconnexion » sont inchangés. Garde ajoutée à `tests/test_draco_barre.py`.
---
## [2.83.3] — 2026-11-04
- **Barre commune v0.3.0 — liens Hub du menu compte (HUB-1, fusion #115)** : `frontend/draco-barre.js` et `frontend/draco-barre.css` re-vendangés **verbatim** depuis dracodev-commons v0.3.0 (branche `hub-menu-compte-v0-3-0`, PR commons #9). Le menu compte gagne les liens **Télécharger**, **À Propos**, **Aides** et **Profil** (devenu un lien, plus un relais) vers le Hub. Branchement hôte : `backend/draco_config.py` gagne la clé `hub` (défaut officiel `https://hub.dracodev.net`, variable `DRACO_HUB_URL`, dérivation `-dev` → `hub-dev` depuis l'hôte de l'agent), servie dans `window.DRACO_URLS` ; `frontend/index.html` la passe en `urls.hub` de `DRACO_BAR_CONFIG`. « Déconnexion » reste relayée, inchangée. Aucun nouvel onglet : le Hub n'apparaît que dans le menu compte.
+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.83.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.83.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.83.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.83.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.83.3).
See [CHANGELOG.md](./CHANGELOG.md) for the complete version history (v1.0.0 → v2.87.0).
---
*Project: ObsiGate | Version: 2.83.3 | Last updated: September 2026*
*Project: ObsiGate | Version: 2.87.0 | Last updated: September 2026*
+1 -1
View File
@@ -1 +1 @@
2.83.3
2.87.0
+29
View File
@@ -154,6 +154,35 @@ def log_coffre_event(
_write_entry(entry)
def log_compte_admin(
acteur: str,
action: str,
cible: str,
ip: str | None = None,
details: dict | None = None,
):
"""Journal d'une action d'administration de compte (HUB-13, fusion #127).
``acteur`` est l'identité de service appelante (API machine des
comptes, en-tête ``X-Draco-Actor``), ``cible`` le compte visé.
Règle absolue : ``details`` ne contient jamais de mot de passe, de
secret TOTP ni de jeton — seulement des métadonnées (champs
modifiés, nombre de jti révoqués…). Le champ ``username`` reprend
l'acteur pour rester filtrable par l'écran d'audit existant.
"""
entry: dict = {
"timestamp": datetime.now(UTC).isoformat(),
"action": action,
"username": acteur,
"acteur": acteur,
"cible": cible,
"ip": ip or "unknown",
}
if details:
entry["details"] = details
_write_entry(entry)
def get_recent_entries(limit: int = 100, action: str | None = None) -> list:
"""Read the most recent audit log entries.
+43 -1
View File
@@ -141,9 +141,26 @@ def _draco_fallback(request: Request) -> dict | None:
return user
def require_auth(current_user=Depends(get_current_user)):
def require_auth(request: Request, current_user=Depends(get_current_user)):
"""Dependency: require a valid authenticated user."""
if not current_user:
# HUB-19 (#228) : la session draco a été refusée parce que le
# registre des rôles du Hub attribue le niveau « aucun » à ce
# compte pour ObsiGate — réponse explicite, distincte du 401
# générique. L'authentification native n'est pas concernée :
# ce refus ne naît que sur le chemin draco (user_for_draco).
if getattr(request.state, "role_hub_refuse", None) == "aucun":
raise HTTPException(
status_code=403,
detail=(
"Accès refusé : le registre des rôles du Hub attribue "
"le niveau « aucun » à votre compte pour ObsiGate, "
"l'accès par la session draco est donc refusé. "
"L'administrateur de la suite peut modifier ce niveau "
"dans la matrice des rôles du Hub. L'accès natif "
"d'ObsiGate (son propre identifiant) reste possible."
),
)
raise HTTPException(
status_code=401,
detail="Authentification requise",
@@ -159,6 +176,31 @@ def require_admin(current_user=Depends(require_auth)):
return current_user
def require_admin_hub(current_user=Depends(require_admin)):
"""Dependency: admin + garde du registre des rôles du Hub (HUB-19, #228).
Pour les routes d'administration des comptes (``/api/auth/admin/*``) :
quand la requête est authentifiée par le **canal draco** (``_draco_sub``
présent) et que le rôle du Hub est **connu** (``_hub_role`` non None),
le niveau ``administrateur`` du registre est exigé — le rôle local ne
suffit plus. Session native, ou rôle inconnu (Hub injoignable) :
règles actuelles inchangées.
"""
if current_user.get("_draco_sub"):
role_hub = current_user.get("_hub_role")
if role_hub is not None and role_hub != "administrateur":
raise HTTPException(
status_code=403,
detail=(
"Accès réservé au niveau « administrateur » d'ObsiGate "
"dans le registre des rôles du Hub (votre niveau actuel : "
f"« {role_hub} »). L'administrateur de la suite peut "
"l'accorder dans la matrice des rôles du Hub."
),
)
return current_user
def is_home_vault(vault_name: str) -> bool:
"""Un dossier personnel (#194) : vault « home-<user> »."""
return vault_name.startswith("home-")
+36 -12
View File
@@ -40,7 +40,7 @@ from .mfa import (
verify_recovery_code,
verify_totp,
)
from .middleware import is_auth_enabled, require_admin, require_auth
from .middleware import is_auth_enabled, require_admin_hub, require_auth
from .password import hash_password, validate_password_strength, verify_password
from .user_store import (
create_user,
@@ -298,6 +298,8 @@ def _issue_tokens(user: dict, username: str, remember_me: bool, response: Respon
"role": user["role"],
"vaults": user["vaults"],
"avatar": user.get("avatar"),
# HUB-13 : mot de passe temporaire — changement forcé signalé.
"must_change_password": bool(user.get("must_change_password")),
},
}
@@ -373,12 +375,15 @@ async def refresh_token_endpoint(request: Request, response: Response):
}
@router.post("/logout")
async def logout(
request: Request,
response: Response,
):
"""Logout: revoke refresh and access tokens, then delete cookies."""
def apply_global_logout(request: Request, response: Response) -> None:
"""Déconnexion globale (Fusion ACC-3.1, #216) appliquée à ``response``.
Révoque les jetons natifs (refresh + access, BUG-027), révoque le
``jti`` du cookie partagé ``draco_session`` et efface les cookies.
Partagée entre ``POST /api/auth/logout`` (réponse JSON) et
``GET /sso/logout`` (redirection, BUG-122) : les deux entrées
terminent exactement la même session, celle de la suite entière.
"""
refresh_tok = request.cookies.get("refresh_token")
if refresh_tok:
payload = decode_token(refresh_tok)
@@ -419,6 +424,15 @@ async def logout(
response.delete_cookie("refresh_token", path="/api/auth/refresh")
response.delete_cookie("access_token", path="/")
response.delete_cookie("access_token", path="/api") # just in case
@router.post("/logout")
async def logout(
request: Request,
response: Response,
):
"""Logout: revoke refresh and access tokens, then delete cookies."""
apply_global_logout(request, response)
return {"message": "Deconnecte avec succes"}
@@ -433,6 +447,8 @@ async def get_me(current_user=Depends(require_auth)):
"language": current_user.get("language", "fr"),
"last_login": current_user.get("last_login"),
"avatar": current_user.get("avatar"),
# HUB-13 : mot de passe temporaire — changement forcé signalé.
"must_change_password": bool(current_user.get("must_change_password")),
}
@@ -487,7 +503,11 @@ async def change_password(
assert user is not None, f"User {current_user['username']} not found"
if not verify_password(req.current_password, user["password_hash"]):
raise HTTPException(400, "Mot de passe actuel incorrect")
update_user(current_user["username"], {"password": req.new_password})
# HUB-13 : le changement effectif efface le marqueur de changement forcé.
update_user(current_user["username"], {
"password": req.new_password,
"must_change_password": False,
})
updated = get_user(current_user["username"])
result: dict = {"message": "Mot de passe mis à jour"}
if updated is not None:
@@ -949,9 +969,13 @@ async def mfa_recovery_login(body: MfaRecoveryRequest, response: Response, reque
# ── Admin endpoints ───────────────────────────────────────────────────
# Garde `require_admin_hub` (HUB-19, #228) : `require_admin` + — pour
# une requête authentifiée par le canal draco dont le rôle du Hub est
# connu — exigence du niveau « administrateur » du registre des rôles.
# Sessions natives et rôle inconnu : règles actuelles inchangées.
@router.get("/admin/users")
async def list_users(admin=Depends(require_admin)):
async def list_users(admin=Depends(require_admin_hub)):
"""List all users (admin only). Password hashes are never included."""
return get_all_users()
@@ -959,7 +983,7 @@ async def list_users(admin=Depends(require_admin)):
@router.post("/admin/users")
async def create_user_endpoint(
req: CreateUserRequest,
admin=Depends(require_admin),
admin=Depends(require_admin_hub),
):
"""Create a new user (admin only)."""
try:
@@ -986,7 +1010,7 @@ async def create_user_endpoint(
async def update_user_endpoint(
username: str,
req: UpdateUserRequest,
admin=Depends(require_admin),
admin=Depends(require_admin_hub),
):
"""Update a user (admin only)."""
updates = req.dict(exclude_none=True)
@@ -999,7 +1023,7 @@ async def update_user_endpoint(
@router.delete("/admin/users/{username}")
async def delete_user_endpoint(
username: str,
admin=Depends(require_admin),
admin=Depends(require_admin_hub),
):
"""Delete a user (admin only). Cannot delete own account."""
if username == admin["username"]:
+10 -1
View File
@@ -80,8 +80,16 @@ def create_user(
role: str = "user",
vaults: list[str] | None = None,
display_name: str | None = None,
must_change_password: bool = False,
) -> dict:
"""Create a new user. Raises ValueError if username already taken."""
"""Create a new user. Raises ValueError if username already taken.
``must_change_password`` (HUB-13) marque un mot de passe temporaire
(création/réinitialisation par l'administration machine) : le
changement est forcé à la première connexion. Les comptes créés
avant ce champ n'en portent pas — ils valent ``False`` partout où
le champ est lu via ``.get(..., False)``.
"""
with _users_lock:
data = _read()
if username in data["users"]:
@@ -95,6 +103,7 @@ def create_user(
"role": role,
"vaults": vaults or [],
"active": True,
"must_change_password": bool(must_change_password), # HUB-13
"language": "fr", # default UI language
"avatar": None, # profile picture data-URL (#113)
"created_at": datetime.now(UTC).isoformat(),
+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
+180 -4
View File
@@ -19,6 +19,27 @@
# vide = cookie lié à l'hôte, utile en dev)
# DRACO_SSO_MACHINE_KEY clé machine protégeant la lecture de la
# liste de révocation (GET /api/sso/revocations)
#
# Registre des émissions (HUB-13, fusion #127) : chaque jti émis est
# consigné par `sub` dans data/draco_issued.json (jti -> exp, purgé à
# l'expiration) pour que l'administration des comptes puisse révoquer
# toutes les sessions draco d'un utilisateur (désactivation,
# suppression, réinitialisation du mot de passe) via revoke().
# HUB-22 (#227) ajoute la lecture de ce registre
# (issued_sessions_for_user) et la révocation unitaire contrôlée par
# appartenance (revoke_one_for_user), exposées par l'API machine des
# sessions (backend/routers/comptes_machine.py).
#
# Rôles du Hub (HUB-19, #228) : à l'ouverture de session draco,
# `user_for_draco` consulte en plus le registre des rôles du Hub
# (`backend/hub_roles.py`, contrat D3(a) posé par le pilote ShaarIt) :
# niveau connu ``aucun`` → la session draco est refusée (l'authenti-
# fication native d'ObsiGate, émettrice, n'est jamais touchée) ;
# niveau connu → il est joint au dict utilisateur (``_hub_role``)
# pour que les routes d'administration du canal draco exigent
# ``administrateur`` ; rôle inconnu (Hub injoignable) → comportement
# actuel, aucun verrouillage nouveau. Aucun rôle dans le jeton :
# validation locale, émission et révocations sont inchangées.
from __future__ import annotations
@@ -40,10 +61,12 @@ ALGORITHM = "HS256"
TOKEN_TTL_SECONDS = 12 * 3600 # durée de vie du jeton (design §5.2)
RENEWAL_WINDOW_SECONDS = 2 * 3600 # réémettre si exp - now < 2 h
REVOKED_FILE = Path("data/draco_revoked.json")
ISSUED_FILE = Path("data/draco_issued.json")
ALLOWED_RETURN_SUFFIX = "dracodev.net"
_lock = threading.Lock()
_revoked: dict[str, int] | None = None # jti -> exp (chargé paresseusement)
_issued: dict[str, dict[str, int]] | None = None # sub -> {jti -> exp}
def _secret() -> str:
@@ -108,12 +131,129 @@ def revoked_list() -> list[dict]:
for jti, exp in _load_revoked().items() if exp > now]
# ── Registre des émissions (par utilisateur) ────────────────────────────
def _load_issued() -> dict[str, dict[str, int]]:
global _issued
if _issued is None:
try:
data = json.loads(ISSUED_FILE.read_text(encoding="utf-8"))
_issued = {
str(sub): {str(j): int(e) for j, e in tokens.items()}
for sub, tokens in data.items()
if isinstance(tokens, dict)
} if isinstance(data, dict) else {}
except (OSError, ValueError):
_issued = {}
return _issued
def _save_issued() -> None:
ISSUED_FILE.parent.mkdir(parents=True, exist_ok=True)
tmp = ISSUED_FILE.with_suffix(".tmp")
tmp.write_text(json.dumps(_issued or {}), encoding="utf-8")
tmp.replace(ISSUED_FILE)
def _register_issued(sub: str, jti: str, exp: int) -> None:
"""Consigne un jti émis pour ``sub`` (purge des expirés au passage)."""
if not sub:
return
try:
with _lock:
store = _load_issued()
now = int(time.time())
for key in list(store.keys()):
store[key] = {j: e for j, e in store[key].items() if e > now}
if not store[key]:
del store[key]
store.setdefault(sub, {})[jti] = int(exp)
_save_issued()
except Exception: # le registre ne casse jamais une émission
logger.warning("Registre des émissions draco non écrit", exc_info=True)
def revoke_all_for_user(sub: str) -> int:
"""Révoque tous les jti draco actifs émis pour ``sub``.
Retourne le nombre de jti révoqués. Utilisé par l'administration
des comptes (HUB-13) : désactivation, suppression, réinitialisation
du mot de passe.
"""
if not sub:
return 0
with _lock:
store = _load_issued()
tokens = store.pop(str(sub), {})
now = int(time.time())
actifs = {j: e for j, e in tokens.items() if e > now}
if tokens:
_save_issued()
for jti, exp in actifs.items():
revoke(jti, exp)
return len(actifs)
def issued_sessions_for_user(sub: str) -> list[dict]:
"""Sessions draco actives émises pour ``sub`` (HUB-22, #227).
Retourne ``[{jti, exp, revoquee}]`` triée par ``exp`` croissant,
où ``revoquee`` indique si le ``jti`` figure déjà dans la liste des
révocations. Les entrées expirées de cet utilisateur sont purgées
du registre au passage (même patron que ``_register_issued``).
"""
if not sub:
return []
with _lock:
store = _load_issued()
now = int(time.time())
tokens = store.get(str(sub), {})
actifs = {j: e for j, e in tokens.items() if e > now}
if len(actifs) != len(tokens):
if actifs:
store[str(sub)] = actifs
else:
store.pop(str(sub), None)
_save_issued()
revoques = _load_revoked()
entrees = sorted(actifs.items(), key=lambda kv: kv[1])
return [{"jti": jti, "exp": exp, "revoquee": jti in revoques}
for jti, exp in entrees]
def revoke_one_for_user(sub: str, jti: str) -> bool:
"""Révoque un seul ``jti`` draco de ``sub`` (HUB-22, #227).
Ne révoque (via ``revoke``) que si le ``jti`` appartient bien à
l'ensemble émis de ce ``sub`` et n'est pas expiré — jamais de
révocation d'une session d'un autre utilisateur. Retourne ``True``
si la révocation a eu lieu, ``False`` sinon.
"""
if not sub or not jti:
return False
with _lock:
store = _load_issued()
exp = store.get(str(sub), {}).get(jti)
if exp is None or exp <= int(time.time()):
return False
revoke(jti, exp)
return True
# ── É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 ""),
@@ -122,7 +262,13 @@ def issue_token(user: dict) -> tuple[str, str, int]:
"exp": exp,
"jti": jti,
}
return jwt.encode(claims, _secret(), algorithm=ALGORITHM), jti, exp
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
def decode_claims(token: str) -> dict | None:
@@ -211,6 +357,36 @@ 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`
# réponde un message explicite en français (et non un simple
# 401 générique). Rôle connu → joint au dict (`_hub_role`) ;
# rôle inconnu → `_hub_role` vaut None et le comportement
# actuel s'applique, sans verrouillage nouveau.
from backend import hub_roles
cookie = ""
try:
cookie = request.headers.get("cookie", "") or ""
except Exception: # un objet requête minimal (tests) ne casse rien
cookie = ""
role = hub_roles.role_pour(sub, cookie)
if role == "aucun":
try:
request.state.role_hub_refuse = "aucun"
except Exception: # pas d'état mutable : refus quand même
pass
return None
user["_hub_role"] = role
return user
return None
+126
View File
@@ -0,0 +1,126 @@
# backend/hub_roles.py
# Hub HUB-19 (propagation, #228) — Rôles par application : consommation
# du registre du Hub par ObsiGate, sur le contrat posé par l'hôte
# pilote ShaarIt (0.7.0, décision D3(a) du plan Hub v2).
#
# À l'ouverture de session draco (validation locale du cookie partagé,
# `draco_session.user_for_draco`), ObsiGate demande au Hub le niveau
# du porteur pour l'application `obsigate` :
# ``GET {hub}/api/roles/obsigate``, en relayant l'en-tête Cookie
# complet de la requête, ``Accept: application/json``, délai 2 s.
# Réponse 200 : ``{"app", "sub", "role", "explicite",
# "ttl_secondes": 60}``, rôle ∈ {aucun, utilisateur, administrateur}.
#
# Cache mémoire par `sub`, TTL 60 s, sur le patron du pilote (et du
# cache de révocations draco) : l'horodatage est posé **avant**
# l'appel — un échec conserve l'ancien cache et ne déclenche pas de
# rafale de requêtes vers un Hub en panne.
#
# **Repli obligatoire** : Hub injoignable, en erreur ou réponse
# illisible → rôle **inconnu** (``None``) et l'appelant garde son
# comportement actuel. Le registre ne crée jamais un verrouillage
# nouveau.
#
# URL du Hub : `draco_config.app_url("hub")` — la même résolution que
# la barre commune (#223) : variable explicite `DRACO_HUB_URL` d'abord,
# dérivation par l'hôte sœur (suffixe d'environnement de l'hôte de
# l'agent) ensuite, défaut officiel enfin. Jamais d'URL dev figée.
from __future__ import annotations
import json
import logging
import threading
import time
import urllib.request
logger = logging.getLogger("obsigate.hub_roles")
#: Identifiant d'ObsiGate dans le registre des applications du Hub.
APP = "obsigate"
#: Niveaux reconnus du registre (contrat D3(a)).
ROLES = ("aucun", "utilisateur", "administrateur")
#: TTL du cache, aligné sur ``ttl_secondes`` annoncé par le Hub (60 s).
CACHE_TTL_SECONDS = 60
#: Délai maximal de la consultation du Hub (contrat : 2 s).
DELAI_SECONDS = 2
_lock = threading.Lock()
_cache: dict[str, str] = {} # sub -> rôle connu
_cache_at: float | None = None # horodatage (monotone) du dernier appel
def _hub_url() -> str:
"""Base publique du Hub, résolue comme pour la barre commune."""
from backend.draco_config import app_url
return app_url("hub")
def _consulter_hub(url: str, cookie: str) -> str | None:
"""Appelle le Hub et retourne le rôle validé, ou ``None``.
Toute erreur (réseau, délai dépassé, statut ≠ 200, JSON illisible,
rôle hors contrat) retourne ``None`` : rôle inconnu, repli.
``cookie`` est l'en-tête Cookie complet de la requête, relayé tel
quel — c'est lui qui prouve l'identité du porteur au Hub.
"""
requete = urllib.request.Request(
url,
method="GET",
headers={"Cookie": cookie, "Accept": "application/json"},
)
try:
with urllib.request.urlopen(requete, timeout=DELAI_SECONDS) as reponse:
if reponse.status != 200:
return None
donnees = json.loads(reponse.read().decode("utf-8"))
except Exception: # le registre ne casse jamais une ouverture de session
return None
if not isinstance(donnees, dict):
return None
role = donnees.get("role")
return role if role in ROLES else None
def role_pour(sub: str, cookie: str) -> str | None:
"""Niveau connu pour ce `sub` : un des ``ROLES`` si le Hub a
répondu, ``None`` si le rôle est inconnu (Hub injoignable/erreur)
— repli = comportement actuel de l'appelant.
`cookie` est l'en-tête Cookie complet de la requête d'origine,
relayé tel quel au Hub.
"""
global _cache_at
if not sub:
return None
with _lock:
if _cache_at is not None \
and time.monotonic() - _cache_at < CACHE_TTL_SECONDS \
and sub in _cache:
return _cache[sub]
# Horodatage posé AVANT l'appel (patron du pilote) : l'ancien
# cache reste en vigueur, un échec ne déclenche pas de rafale.
_cache_at = time.monotonic()
url = f"{_hub_url().rstrip('/')}/api/roles/{APP}"
role = _consulter_hub(url, cookie)
if role is None:
logger.warning(
"Registre des rôles du Hub indisponible (%s) — "
"comportement actuel conservé", url)
return None
with _lock:
_cache[sub] = role
_cache_at = time.monotonic()
return role
def reinitialiser_cache() -> None:
"""Vide le cache des rôles (tests, redémarrage à chaud)."""
global _cache_at
with _lock:
_cache.clear()
_cache_at = None
+4
View File
@@ -550,6 +550,7 @@ from backend.auth.router import router as auth_router
from backend.bookslm_routes import router as bookslm_router
from backend.routers.backups import router as backups_router
from backend.routers.coffres import router as coffres_router
from backend.routers.comptes_machine import router as comptes_machine_router
from backend.routers.config import _load_config
from backend.routers.config import router as config_router
from backend.routers.conflicts import router as conflicts_router
@@ -561,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
@@ -579,12 +581,14 @@ 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
app.include_router(conflicts_router) # ROADMAP #85 T8 — Conflicts
app.include_router(config_router) # ROADMAP #85 T7 — Config
app.include_router(coffres_router) # Coffre Secrets Phase 1b — JAMAIS dans vaults.py
app.include_router(comptes_machine_router) # HUB-13 (fusion #127) — Admin des comptes, machine-à-machine
app.include_router(file_chat_router) # ROADMAP #169 — Chat par fichier
app.include_router(files_read_router) # ROADMAP #85 T6a — Files read
app.include_router(files_media_router) # ROADMAP #85 T6c — Media/export
+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)."},
+424
View File
@@ -0,0 +1,424 @@
# backend/routers/comptes_machine.py
# HUB-13 (fusion #127) — API d'administration des comptes, machine-à-machine.
#
# Le Hub (interface d'administration des utilisateurs) administre les
# comptes dont ObsiGate reste le magasin (décisions D1(a)/D2(a) du plan
# Hub v2) via ces routes, en lecture et en écriture : lister, lire le
# profil étendu, créer, modifier, désactiver/réactiver, supprimer,
# réinitialiser le mot de passe et le MFA.
#
# HUB-22 (#227, vague C du plan Hub v2.1) ajoute, sous la même garde et
# avec la même journalisation, les routes « sessions » : lister les
# sessions draco actives d'un compte, en révoquer une (par son `jti`,
# jamais celle d'un autre compte) ou toutes (déconnexion globale, sans
# désactiver le compte), via le registre des émissions de HUB-13.
#
# Emplacement : ``/api/admin/machine/comptes`` — dans l'espace
# d'administration existant (``/api/admin/…``), avec un segment
# ``machine`` explicite qui le distingue des routes d'administration par
# session (``/api/auth/admin/users``, garde ``require_admin``). Aucune
# session utilisateur — même administratrice — n'ouvre ces routes :
# seule la clé machine dédiée les protège.
#
# Authentification machine (même famille que ``GET /api/sso/revocations``) :
# DRACO_ADMIN_MACHINE_KEY clé dédiée à cette API (en-tête
# ``X-Draco-Machine-Key``). Distincte de
# ``DRACO_SSO_MACHINE_KEY`` : le périmètre
# (écriture de comptes) est plus sensible que
# la seule lecture des révocations (plan §3).
# Sans elle, l'API est inerte (404, comme la
# liste de révocations non configurée).
# X-Draco-Actor identité de service appelante, facultative
# (défaut ``service-machine``) — consignée
# comme acteur dans le journal d'audit.
#
# Chaque action est journalisée côté ObsiGate dans le journal d'audit
# existant (``data/audit.log``, voir backend.audit.log_compte_admin).
from __future__ import annotations
import hmac
import logging
import os
import re
import time
from datetime import UTC, datetime
from fastapi import APIRouter, Depends, HTTPException, Request
from pydantic import BaseModel, validator
from backend import draco_session
from backend.audit import log_compte_admin
from backend.auth.password import validate_password_strength
from backend.auth.user_store import (
create_user,
delete_user,
get_all_users,
get_user,
update_user,
)
from backend.services.net import get_client_ip
logger = logging.getLogger("obsigate.comptes_machine")
router = APIRouter(prefix="/api/admin/machine/comptes", tags=["admin"])
#: Variable d'environnement portant la clé machine dédiée à cette API.
MACHINE_KEY_ENV = "DRACO_ADMIN_MACHINE_KEY"
#: En-tête de la clé machine (même nom que pour /api/sso/revocations).
MACHINE_KEY_HEADER = "X-Draco-Machine-Key"
#: En-tête facultatif : identité de service appelante (journal d'audit).
ACTOR_HEADER = "X-Draco-Actor"
#: Acteur consigné quand l'appelant ne se nomme pas.
DEFAULT_ACTOR = "service-machine"
# ── Garde machine ───────────────────────────────────────────────────────
def require_machine_admin(request: Request) -> str:
"""Exige la clé machine dédiée ; retourne l'identité de service.
Jamais de repli sur une session utilisateur : sans en-tête valide,
la réponse est 401 (ou 404 si l'API n'est pas configurée, patron de
``GET /api/sso/revocations``).
"""
machine_key = os.environ.get(MACHINE_KEY_ENV, "")
if not machine_key:
raise HTTPException(404, "Non configuré")
provided = request.headers.get(MACHINE_KEY_HEADER, "")
if not provided or not hmac.compare_digest(provided, machine_key):
raise HTTPException(401, "Clé machine invalide")
actor = (request.headers.get(ACTOR_HEADER, "") or "").strip()
return actor[:64] if actor else DEFAULT_ACTOR
# ── Profil étendu (liste blanche — jamais de secret) ────────────────────
def _profil(user: dict) -> dict:
"""Profil étendu d'un compte, sûr à exposer à un service.
Liste blanche stricte : ni ``password_hash``, ni secret TOTP
(``mfa_secret``/``mfa_secret_pending``), ni codes de récupération,
ni identifiants WebAuthn ne sortent — seul l'état MFA (oui/non)
est exposé. L'avatar suit le modèle existant : la valeur stockée
(data-URL ou ``None``, comme ``GET /api/auth/me``) plus le booléen
de présence ``avatar_present`` pour les listes légères.
"""
return {
"id": user.get("id"),
"username": user.get("username"),
"display_name": user.get("display_name"),
"language": user.get("language", "fr"),
"avatar": user.get("avatar"),
"avatar_present": bool(user.get("avatar")),
"role": user.get("role"),
"active": bool(user.get("active")),
"vaults": user.get("vaults", []),
"mfa_enabled": bool(user.get("mfa_enabled")),
"mfa_method": user.get("mfa_method"),
"must_change_password": bool(user.get("must_change_password")),
"created_at": user.get("created_at"),
"last_login": user.get("last_login"),
}
def _compte_ou_404(username: str) -> dict:
user = get_user(username)
if user is None:
raise HTTPException(404, "Compte introuvable")
return user
def _identifiant_sessions(user: dict) -> str:
"""Clé du registre des émissions draco pour un compte.
C'est le ``sub`` des jetons draco : l'identifiant du compte
(``id``), à défaut son nom d'utilisateur — exactement la clé
qu'utilise ``_revoquer_sessions`` depuis HUB-13.
"""
return str(user.get("id") or user.get("username") or "")
def _revoquer_sessions(user: dict) -> int:
"""Révoque les sessions d'un compte ; retourne le nombre de jti draco.
Les ``jti`` du cookie partagé émis pour ce compte sont révoqués via
le mécanisme existant (``draco_session.revoke``, exposé aux autres
applications par ``GET /api/sso/revocations``). Les jetons natifs
sont invalidés par le garde ``password_changed_at`` (BUG-028),
avancé par l'appelant (désactivation, réinitialisation du mot de
passe) ou par le drapeau ``active`` tant que le compte est inactif.
"""
return draco_session.revoke_all_for_user(_identifiant_sessions(user))
def _audit(request: Request, acteur: str, action: str, cible: str,
details: dict | None = None) -> None:
log_compte_admin(acteur, action, cible,
ip=get_client_ip(request), details=details)
# ── Modèles de requête ──────────────────────────────────────────────────
class CreerCompteRequest(BaseModel):
username: str
password: str
display_name: str | None = None
role: str = "user"
vaults: list[str] = []
@validator("password")
def password_valid(cls, v):
return validate_password_strength(v)
@validator("username")
def username_valid(cls, v):
if not re.match(r"^[a-zA-Z0-9_-]{2,32}$", v):
raise ValueError("2-32 caractères alphanumériques, _ ou -")
return v.lower()
@validator("role")
def role_valid(cls, v):
if v not in ("admin", "user"):
raise ValueError("Rôle invalide")
return v
class ModifierCompteRequest(BaseModel):
display_name: str | None = None
role: str | None = None
language: str | None = None
vaults: list[str] | None = None
@validator("role")
def role_valid(cls, v):
if v is not None and v not in ("admin", "user"):
raise ValueError("Rôle invalide")
return v
@validator("language")
def language_valid(cls, v):
if v is not None and v not in ("fr", "en"):
raise ValueError("Langue invalide (fr | en)")
return v
class ReinitialiserMotDePasseRequest(BaseModel):
password: str
@validator("password")
def password_valid(cls, v):
return validate_password_strength(v)
# ── Lecture ─────────────────────────────────────────────────────────────
@router.get("")
async def lister_comptes(acteur: str = Depends(require_machine_admin)):
"""Liste tous les comptes (profils étendus, sans aucun secret)."""
comptes = [_profil(u) for u in get_all_users()]
return {"comptes": comptes, "total": len(comptes)}
@router.get("/{username}")
async def lire_compte(username: str,
acteur: str = Depends(require_machine_admin)):
"""Lit un compte et son profil étendu."""
return _profil(_compte_ou_404(username))
# ── Écriture ────────────────────────────────────────────────────────────
@router.post("", status_code=201)
async def creer_compte(req: CreerCompteRequest, request: Request,
acteur: str = Depends(require_machine_admin)):
"""Crée un compte. Le mot de passe initial est temporaire :
``must_change_password`` est posé (changement forcé signalé à la
première connexion, comme après une réinitialisation)."""
if get_user(req.username) is not None:
raise HTTPException(409, "Identifiant déjà utilisé")
try:
user = create_user(
req.username, req.password, req.role, req.vaults,
req.display_name, must_change_password=True,
)
except ValueError as e:
raise HTTPException(409, str(e)) from e
# #194 : dossier personnel — même provisionnement que la création
# par session administratrice (best effort).
from backend.user_home import ensure_user_home
await ensure_user_home(req.username)
fresh = get_user(req.username)
if fresh:
user = fresh
_audit(request, acteur, "compte_cree", req.username,
{"role": req.role})
return _profil(user)
@router.patch("/{username}")
async def modifier_compte(username: str, req: ModifierCompteRequest,
request: Request,
acteur: str = Depends(require_machine_admin)):
"""Modifie un compte (nom affiché, rôle global, langue, vaults)."""
_compte_ou_404(username)
updates = req.dict(exclude_none=True)
if not updates:
raise HTTPException(400, "Aucun champ à modifier")
updated = update_user(username, updates)
_audit(request, acteur, "compte_modifie", username,
{"champs": sorted(updates.keys())})
return _profil(updated)
@router.post("/{username}/desactiver")
async def desactiver_compte(username: str, request: Request,
acteur: str = Depends(require_machine_admin)):
"""Désactive un compte : plus aucun nouveau jeton n'est émis
(connexion refusée) et les ``jti`` draco actifs sont révoqués."""
user = _compte_ou_404(username)
updated = update_user(username, {
"active": False,
# BUG-028 : avancer le repère invalide aussi les jetons natifs
# déjà émis — ils ne ressuscitent pas à la réactivation.
"password_changed_at": time.time(),
})
nb_jti = _revoquer_sessions(user)
_audit(request, acteur, "compte_desactive", username,
{"jti_revoques": nb_jti})
return _profil(updated)
@router.post("/{username}/reactiver")
async def reactiver_compte(username: str, request: Request,
acteur: str = Depends(require_machine_admin)):
"""Réactive un compte désactivé (les anciennes sessions restent
révoquées : une nouvelle connexion est nécessaire)."""
_compte_ou_404(username)
updated = update_user(username, {"active": True})
_audit(request, acteur, "compte_reactive", username)
return _profil(updated)
@router.delete("/{username}")
async def supprimer_compte(username: str, request: Request,
acteur: str = Depends(require_machine_admin)):
"""Supprime un compte et révoque ses ``jti`` draco actifs."""
user = _compte_ou_404(username)
nb_jti = _revoquer_sessions(user)
try:
delete_user(username)
except ValueError as e:
raise HTTPException(404, str(e)) from e
# #194 : fermer le vault du dossier personnel (dossier conservé),
# comme la suppression par session administratrice.
from backend.user_home import release_user_home
await release_user_home(username)
_audit(request, acteur, "compte_supprime", username,
{"jti_revoques": nb_jti})
return {"message": f"Compte '{username}' supprimé"}
@router.post("/{username}/reinitialiser-mot-de-passe")
async def reinitialiser_mot_de_passe(
username: str, req: ReinitialiserMotDePasseRequest,
request: Request, acteur: str = Depends(require_machine_admin)):
"""Pose un nouveau mot de passe temporaire : changement forcé à la
première connexion (``must_change_password``, signalé par la
connexion et ``GET /api/auth/me``, effacé au changement effectif).
Les sessions existantes sont révoquées (repère BUG-028 + ``jti``
draco). Le mot de passe n'est jamais journalisé."""
user = _compte_ou_404(username)
updated = update_user(username, {
"password": req.password,
"must_change_password": True,
})
nb_jti = _revoquer_sessions(user)
_audit(request, acteur, "mot_de_passe_reinitialise", username,
{"jti_revoques": nb_jti})
return _profil(updated)
@router.post("/{username}/reinitialiser-mfa")
async def reinitialiser_mfa(username: str, request: Request,
acteur: str = Depends(require_machine_admin)):
"""Efface l'enrôlement TOTP d'un compte (utilisateur verrouillé
hors de son second facteur) : secret, secret en attente et codes
de récupération sont supprimés. Les clés WebAuthn éventuelles sont
conservées et gardent alors le MFA actif. Le secret n'est jamais
exposé — ni avant, ni après."""
user = _compte_ou_404(username)
webauthn_restantes = len(user.get("webauthn_credentials") or [])
updates: dict = {
"mfa_secret": None,
"mfa_secret_pending": None,
"mfa_recovery_codes": [],
}
if webauthn_restantes:
updates["mfa_method"] = "webauthn"
else:
updates["mfa_enabled"] = False
updates["mfa_method"] = None
updated = update_user(username, updates)
_audit(request, acteur, "mfa_reinitialise", username,
{"webauthn_conserves": webauthn_restantes})
return _profil(updated)
# ── Sessions draco (HUB-22) ─────────────────────────────────────────────
@router.get("/{username}/sessions")
async def lister_sessions(username: str,
acteur: str = Depends(require_machine_admin)):
"""Liste les sessions draco actives d'un compte.
Une session par ``jti`` émis et non expiré (registre des émissions
de HUB-13), triées par expiration croissante ; ``revoquee`` signale
un ``jti`` déjà présent dans la liste des révocations et
``expire_le`` est l'échéance ``exp`` en ISO 8601 UTC.
"""
user = _compte_ou_404(username)
sessions = [{
"jti": s["jti"],
"exp": s["exp"],
"expire_le": datetime.fromtimestamp(s["exp"], tz=UTC).isoformat(),
"revoquee": s["revoquee"],
} for s in draco_session.issued_sessions_for_user(
_identifiant_sessions(user))]
return {"username": username, "sessions": sessions}
@router.post("/{username}/sessions/{jti}/revoquer")
async def revoquer_session(username: str, jti: str, request: Request,
acteur: str = Depends(require_machine_admin)):
"""Révoque une seule session draco d'un compte, par son ``jti``.
404 si le ``jti`` ne figure pas dans l'ensemble actif de ce
compte : une session d'un autre utilisateur n'est jamais révoquée
par cette route (aucune révocation cross-utilisateur).
"""
user = _compte_ou_404(username)
if not draco_session.revoke_one_for_user(
_identifiant_sessions(user), jti):
raise HTTPException(404, "Session introuvable")
_audit(request, acteur, "session_revoquee", username, {"jti": jti})
return {"jti": jti, "revoquee": True}
@router.post("/{username}/sessions/revoquer-toutes")
async def revoquer_toutes_sessions(
username: str, request: Request,
acteur: str = Depends(require_machine_admin)):
"""Révoque toutes les sessions draco actives d'un compte.
C'est la « déconnexion globale » : contrairement à la
désactivation, le compte reste actif — seule l'émission d'une
nouvelle session (nouvelle connexion) rouvre l'accès.
"""
user = _compte_ou_404(username)
nb_jti = _revoquer_sessions(user)
_audit(request, acteur, "sessions_revoquees", username,
{"jti_revoques": nb_jti})
return {"revoquees": nb_jti}
+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}
+17
View File
@@ -11,6 +11,14 @@
# GET /api/sso/revocations : liste des jti révoqués, réservée aux
# autres applications (clé machine DRACO_SSO_MACHINE_KEY, en-tête
# X-Draco-Machine-Key) qui la mettent en cache 60 s (design §5.2).
#
# GET /sso/logout?return_to=<url> : symétrique de /sso/authorize —
# point d'entrée navigable de la déconnexion globale (BUG-122,
# fusion #141). Les autres applications y naviguent depuis leur menu
# compte ; la déconnexion exécutée est celle de POST /api/auth/logout
# (logique partagée : jetons natifs révoqués, jti draco révoqué,
# cookie effacé sur le domaine parent), puis redirection vers le
# return_to validé (même liste blanche ; repli « / »).
from __future__ import annotations
@@ -21,6 +29,7 @@ from fastapi import APIRouter, HTTPException, Request
from fastapi.responses import RedirectResponse
from backend import draco_session
from backend.auth.router import apply_global_logout
router = APIRouter(tags=["SSO"])
@@ -34,6 +43,14 @@ async def sso_authorize(return_to: str = ""):
return RedirectResponse(url="/", status_code=302)
@router.get("/sso/logout")
async def sso_logout(request: Request, return_to: str = ""):
target = draco_session.validate_return_to(return_to)
response = RedirectResponse(url=target or "/", status_code=302)
apply_global_logout(request, response)
return response
@router.get("/api/sso/revocations")
async def sso_revocations(request: Request):
machine_key = os.environ.get("DRACO_SSO_MACHINE_KEY", "")
+1 -1
View File
@@ -2626,7 +2626,7 @@ dependencies = [
[[package]]
name = "obsigate-desktop"
version = "2.83.3"
version = "2.87.0"
dependencies = [
"chrono",
"env_logger",
+1 -1
View File
@@ -1,6 +1,6 @@
[package]
name = "obsigate-desktop"
version = "2.83.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.83.3",
"version": "2.87.0",
"identifier": "com.obsigate.desktop",
"build": {
"frontendDist": "../frontend",
+7
View File
@@ -227,6 +227,10 @@ Avant de corriger quoi que ce soit, un agent IA doit :
| *BUG-117* | Drag & drop des fichiers dans la sidebar : le déplacement d'un répertoire à un autre ne fait plus rien, sans message | 🟢 corrigé | P1 | 📱 frontend / sidebar | IA | `frontend/js/dragdrop.js` (`onDrop`) | Glisser un fichier sur un dossier : aucune requête `/api/move`, aucun toast | La détection `isExternalFiles` dans `onDrop` (`items.length > 0`, ajoutée par #89) comptait aussi les formats string du drag interne (`tree:vault/path/type` posés par `setData` au `dragstart`) : tout déplacement partait dans la branche upload où rien ne passe le filtre `kind === 'file'` → drop avalé silencieusement. Corrigé à la racine : `dragState` (interne) prioritaire + items réellement fichiers. Livré avec #201 : menu contextuel Déplacer/Dupliquer réutilisant `promptTargetFolder`, emplacement actuel pré-sélectionné | Vérifié Playwright instance E2E : glisser `note1.md` → `d1` = toast « Moved file to d1 » + chemin déplacé ; 4 tests `TestDuplicateApi` |
| *BUG-119* | Panneau Spark : le « mode console » (surimpression iframe de la console du service d'agents) est bloqué par le navigateur (« This content is blocked ») | 🟢 corrigé | P1 | ⚙️ backend | IA | `backend/main.py` (`SecurityHeadersMiddleware`) | Panneau Spark → « Console ⤢ » : l'iframe reste sur la page d'erreur du navigateur | `frame-src 'self' blob: https://agent.dracodev.net` dans la CSP servie ; test `tests/test_security_headers.py::test_csp_frame_src_allows_agent_console` | Cause : `frame-src` n'autorisait pas l'origine du service d'agents, pourtant déjà présente dans `connect-src` (le panneau texte fonctionnait). Aucune autre directive modifiée. Redéploiement Docker requis |
| *BUG-120* | Menu inter-apps : sur l'environnement dev, les URL sœurs servies (`window.DRACO_URLS` : ObsiGate, Flowdeck, TikTak, Kanbante) restent en noms **prod** alors que l'URL de l'agent est bien en `-dev` | 🟢 corrigé | P1 | ⚙️ backend | IA | `backend/draco_config.py` (`app_url`, `_suffixe_environnement`) | Sur og-dev : `window.DRACO_URLS` donne `agent: https://agent-dev.dracodev.net` mais `tiktak: https://tiktak.dracodev.net` (prod) — le `.env` dev ne déclare pas les quatre `DRACO_<APP>_URL` | `backend/draco_config.py` : résolution sœur en 3 temps — explicite, puis **dérivation d'environnement** depuis l'hôte de `agent_url()` (`agent<SUFFIXE>.dracodev.net` → `https://<slug><SUFFIXE>.dracodev.net`, slugs `og`/`flowdeck`/`tiktak`/`kanbante` ; hors motif → rien), puis défaut officiel ; Gitea exclue. Tests `tests/test_draco_config.py` (+9 : dérivation `-dev` via `AGENT_EVENEMENTS_URL` et via `DRACO_AGENT_URL`, priorité de l'explicite, 5 hôtes hors motif, suffixe vide, injection) | Suite de #223 : seule l'URL de l'agent avait une dérivation de repli (`AGENT_EVENEMENTS_URL`) ; les sœurs retombaient sur les défauts officiels. Correctif de code demandé par Bruno : l'environnement se déduit de l'agent déjà configuré, sans variable supplémentaire. Redéploiement Docker requis |
| *BUG-122* | Déconnexion du menu compte inerte dans les applications sœurs : la barre commune relaie `deconnexion` à l'hôte, mais la déconnexion globale d'ObsiGate (ACC-3.1) n'est appelable qu'en same-origin (`POST /api/auth/logout`) — aucun point d'entrée navigable pour les autres hôtes | 🟢 corrigé | P1 | ⚙️ backend | IA | `backend/routers/sso.py` (`GET /sso/logout`), `backend/auth/router.py` (`apply_global_logout`) | Depuis la console Spark (ou Flowdeck/TikTak/ShaarIt/Hub) : menu compte → « Déconnexion » → rien ne se passe, la session draco reste vivante (vérifié en navigateur réel : cookie présent, `/api/v1/me` toujours 200) | Nouvelle route `GET /sso/logout?return_to=` : exécute la déconnexion globale (logique partagée `apply_global_logout` : jetons natifs refresh/access révoqués, `jti` draco révoqué, cookie effacé sur le domaine parent) puis redirige vers le `return_to` validé (liste blanche https + *.dracodev.net, repli `/`). Tests `tests/test_draco_session.py` (+3) | Signalé par Bruno le 2026-11-06 (capture console), carte fusion #141 ; les hôtes branchent leur action `deconnexion` sur cette route (PR sœurs). BUG-121 reste réservé au bug de couleur « Secrets » du vault Spark (proposé, non ordonné). Redéploiement Docker requis |
| *BUG-123* | Aller-retour SSO non refermé quand la session ObsiGate existe déjà : `GET /sso/authorize?return_to=…` dépose l'utilisateur sur `/?return_to=…`, mais le retour n'est honoré que par `AuthManager.saveToken()` (login frais, MFA, WebAuthn) — les chemins de restauration de session d'`initAuth()` (jeton encore valide en sessionStorage, ou refresh silencieux au démarrage) affichent l'accueil sans jamais suivre le `return_to` : l'utilisateur reste chez ObsiGate et, revenu manuellement à l'application sœur, n'y a toujours aucune session locale | 🟢 corrigé | P1 | 📱 frontend | IA | `frontend/js/auth.js` (`initAuth`, `_honorReturnTo`) | Navigateur avec session ObsiGate active → Kanbante → « Se connecter avec ObsiGate (SSO) » → retour automatique attendu dans Kanbante, connecté ; constaté en pile locale complète (chaîne d'URL journalisée) : arrivée sur l'accueil ObsiGate, retour jamais suivi | `_honorReturnTo()` retourne si la redirection a eu lieu ; les deux chemins de restauration d'`initAuth()` l'invoquent avant `showApp()` (les refresh en cours de session restent sans redirection). Garde : `tests/test_draco_barre.py` ; preuve navigateur complète du chantier (pile locale aux noms publics) | Signalé par Bruno le 2026-11-08 (test réel, compte « testeur » créé au Hub) ; le sous-cas login frais refermait déjà la boucle (vérifié). Fiche `docs/features/entree-sso-bug-123-124.md`. Redéploiement Docker requis |
| *BUG-124* | Nom du compte absent du menu de la barre commune juste après le login : `renderUserSection()` met à jour le bloc latéral et le drapeau admin de la barre, mais ne pousse jamais le nom — le seul poseur d'identité de la barre est le fetch d'amorçage au `DOMContentLoaded`, limité aux sessions déjà présentes au chargement. Après un login SPA sans rechargement : avatar « ✦ » et en-tête « Compte » jusqu'au rechargement forcé | 🟢 corrigé | P2 | 📱 frontend | IA | `frontend/js/auth.js` (`renderUserSection`), `frontend/index.html`, `frontend/draco-barre.js` (vendange commons v0.7.0) | Se connecter dans la SPA puis ouvrir le menu compte de la barre sans recharger : en-tête « Compte » au lieu du nom (reproduit en pile locale, capture) | Barre commune v0.7.0 re-vendangée verbatim (nouvelle API `DRACO_BAR.setUser`, PR dracodev-commons #15) ; `renderUserSection()` appelle `setUser(name)` / `setUser(null)`, le fetch d'amorçage d'`index.html` pousse aussi le nom par `setUser`. Garde : `tests/test_draco_barre.py` | Signalé par Bruno le 2026-11-08 (captures). Fiche `docs/features/entree-sso-bug-123-124.md`. Redéploiement Docker requis |
| *BUG-125* | Aller-retour SSO : le retour est honoré mais le pont de l'application sœur ne reçoit aucun cookie `draco_session` quand les cookies `access_token` et `draco_session` ont disparu alors que la session semble encore valide en `sessionStorage` — le chemin court d'`initAuth()` (BUG-123) repart sans aucun échange serveur, donc sans la réémission du cookie draco par `DracoRenewalMiddleware` ; côté sœur : jeton absent au pont = redirection vers le formulaire **nu, sans message** (à distinguer de l'échec de résolution, qui affiche le bandeau `draco=echec`, et du rôle « aucun », qui affiche une page 403) | 🟢 corrigé | P1 | 📱 frontend | IA | `frontend/js/auth.js` (`initAuth`) | Pile « conteneur dev réel » : login chez ObsiGate, suppression des cookies `draco_session` + `access_token` (cookie refresh conservé), Kanbante → clic SSO → la requête du pont part **sans cookie draco** (journalisée) → formulaire Kanbante nu ; un second clic, lui, aboutit (le premier passage a provoqué la réémission) | À l'arrivée d'un `/sso/authorize` (`return_to` présent), le chemin court est écarté : `initAuth()` passe par le refresh silencieux + `/api/auth/me`, dont la réponse traverse le middleware de renouvellement qui réémet le cookie draco manquant ou invalide **avant** que le retour soit honoré ; si le refresh échoue, écran de connexion comme avant (le `return_to` reste dans l'URL). Garde : `tests/test_draco_barre.py` (`test_retour_sso_refresh_force_bug_125`) ; preuve navigateur : la variante fautive de la pile retourne connectée après correctif | Signalé par Bruno le 2026-11-08 (retest réel après BUG-123 + retour sur le bon hôte) ; diagnostic complet (formes d'échec du pont cartographiées en pile) dans le dossier `preuve-retour-sso-hote`. Fiche `docs/features/retour-sso-cookie-draco-bug-125.md`. Redéploiement Docker requis |
| # | Titre | Statut | Priorité | Scope | Assigné | Zone (fichier) | Cmd de repro | Correctif / Commit | Notes |
|---|---|---|---|---|---|---|---|---|---|
@@ -361,6 +365,9 @@ Avant de corriger quoi que ce soit, un agent IA doit :
| 2026-10-09 | #194 | Correction (isolation) | `backend/auth/middleware.py`, `backend/services/recent.py`, `backend/services/search.py`, `backend/routers/search.py`, `backend/routers/config.py`, `backend/routers/conflicts.py`, `backend/routers/files_read.py`, `backend/routers/history.py`, `backend/push.py`, `backend/user_home.py`, `tests/test_user_home.py`, `tests/test_auth_api.py`, `docs/features/user-home-194.md`, `CHANGELOG.md` | **#194 — l'admin voyait le home de chaque utilisateur** (retour utilisateur) : `vaults: ["*"]` ouvrait **tous** les vaults, donc `home-<user>` compris. Correctif à la racine : `check_vault_access` exige un octroi **explicite** pour tout vault `home-*` (nouveau `is_home_vault()`), et les filtres « * » écrits en dur dans les routes ont été remplacés par cet appel unique — dashboard (`routers/config.py`), conflits, liens retour, favoris, abonnements push (`/api/search/replace` utilisait déjà `is_vault_allowed`). `/api/search` filtre désormais les bruts **avant** pagination via `search_vaults(is_allowed=…)` (sinon notes personnelles d'un autre compte dans les résultats). `_grant` n'écarte plus les comptes « * » → l'admin reçoit son propre `home-admin` (auto-réparé au démarrage). Vérifié : `test_user_home.py` 12→**14/14** (dont « * » sans homes + filtrage recherche), `test_auth_api.py` 2/2 (admin ne voit **plus** `home-alice`, alice voit le sien), suite **1705 passed / 2 skipped**, ruff backend 0, mypy 114 fichiers 0, **live Playwright instance 2020** : arborescence admin = `home-admin, TestDir, TestVault` (plus de `home-bruno`), `svg.lucide-home` rendu. Reste ouvert (fuite pré-existante, hors périmètre) : `/api/search/advanced`, `/api/tags`, `/api/tags/suggest`, `/api/tree-search`, `/api/suggest` ne filtrent pas par vault accessible | ✅ livré (en attente vérif utilisateur) |
| 2026-10-23 | BUG-119 | Correction | `backend/main.py`, `tests/test_security_headers.py`, `CHANGELOG.md`, `docs/ISSUES_TODOLIST.md`, `docs/ROADMAP.md` | **BUG-119 — le « mode console » du panneau Spark V3 (#222) était bloqué par le navigateur** (« This content is blocked ») : la console du service d'agents s'affiche dans une iframe `https://agent.dracodev.net`, mais la CSP servie par `SecurityHeadersMiddleware` limitait `frame-src` à `'self' blob:` — seul le panneau texte passait (`connect-src` autorisait déjà l'origine). Correctif strict : `frame-src 'self' blob: https://agent.dracodev.net`, toutes les autres directives inchangées à l'identique. Test de non-régression `test_csp_frame_src_allows_agent_console` (la CSP servie est analysée et la liste exacte des sources `frame-src` verrouillée). Vérifié : 100 passed (security_headers + csp_nonce + security_hardening + draco_barre + version), ruff propre sur les fichiers touchés (51 erreurs préexistantes ailleurs, inchangées), mypy 0 (120 fichiers) | 🟢 corrigé (en attente vérif utilisateur) |
| 2026-10-25 | BUG-120 (suite #223) | Correction | `backend/draco_config.py`, `tests/test_draco_config.py`, `.env.example`, `CHANGELOG.md`, `docs/ISSUES_TODOLIST.md`, `docs/ROADMAP.md`, `docs/features/devprod-urls-config-223.md` | **BUG-120 — le menu inter-apps de la dev pointait la prod** : `window.DRACO_URLS` servait l'agent en `-dev` mais les quatre sœurs en noms officiels, le `.env` dev ne déclarant pas les `DRACO_<APP>_URL`. Correctif dans `draco_config.app_url()` : après l'explicite, **dérivation d'environnement** — hôte de `agent_url()` de la forme `agent<SUFFIXE>.dracodev.net` sans port → sœur en `<slug><SUFFIXE>.dracodev.net` ; hors motif (autre domaine, LAN, IP, port) aucune dérivation ; Gitea jamais dérivée. Vérifié : `test_draco_config.py` 16 passed, suite complète **1668 passed / 9 skipped**, ruff 0 et mypy 0 sur les fichiers touchés (51 erreurs ruff préexistantes ailleurs, inchangées) | 🟢 corrigé (en attente vérif utilisateur) |
| 2026-11-06 | BUG-122 (fusion #141) | Correction | `backend/routers/sso.py`, `backend/auth/router.py`, `tests/test_draco_session.py`, `CHANGELOG.md`, `docs/ISSUES_TODOLIST.md`, `docs/features/deconnexion-globale-bug-122.md`, `VERSION` (+ dérivés) | **BUG-122 — la déconnexion du menu compte ne terminait rien hors ObsiGate** : ajout de `GET /sso/logout`, point d'entrée navigable de la déconnexion globale (logique partagée avec `POST /api/auth/logout`). Vérifié : `test_draco_session.py` 34 passed, ruff 0 et mypy 0 sur les fichiers touchés | 🟢 corrigé (en attente vérif utilisateur) |
| 2026-11-08 | BUG-123 + BUG-124 (chantier entrée SSO) | Correction | `frontend/js/auth.js`, `frontend/index.html`, `frontend/draco-barre.js`, `tests/test_draco_barre.py`, `CHANGELOG.md`, `docs/ISSUES_TODOLIST.md`, `docs/ROADMAP.md`, `docs/features/entree-sso-bug-123-124.md`, `VERSION` (+ dérivés) | **BUG-123 — aller-retour SSO refermé à la restauration de session** : `initAuth()` honore le `return_to` sur ses deux chemins de restauration (jeton valide, refresh silencieux au démarrage), comme le faisait déjà `saveToken` après un login frais. **BUG-124 — nom du compte dans la barre dès le login** : barre commune re-vendangée en v0.7.0 (`DRACO_BAR.setUser`, PR dracodev-commons #15), branchée dans `renderUserSection()` et le fetch d'amorçage. Chaînes prouvées en navigateur réel (pile locale aux noms publics, scénario de Bruno) | 🟢 corrigé (en attente vérif utilisateur) |
| 2026-11-08 | BUG-125 (suite entrée SSO) | Correction | `frontend/js/auth.js`, `tests/test_draco_barre.py`, `CHANGELOG.md`, `docs/ISSUES_TODOLIST.md`, `docs/ROADMAP.md`, `docs/features/retour-sso-cookie-draco-bug-125.md`, `VERSION` (+ dérivés) | **BUG-125 — retour SSO honoré mais pont sans cookie draco** : quand les cookies `access_token` et `draco_session` ont disparu alors que `sessionStorage` croit la session valide, le chemin court d'`initAuth()` repartait sans échange serveur — aucune réémission du cookie draco — et le pont de l'application sœur, sans jeton, déposait l'utilisateur devant son formulaire nu. Correctif : avec `return_to`, `initAuth()` force le refresh silencieux + `/api/auth/me` (réémission par `DracoRenewalMiddleware`) avant d'honorer le retour. Reproduit puis vérifié en navigateur réel dans la pile « conteneur dev réel » (requête du pont journalisée : sans cookie avant, avec cookie après) | 🟢 corrigé (en attente vérif utilisateur) |
---
+74 -1
View File
@@ -1,6 +1,6 @@
# ObsiGate — Roadmap
> **Version :** 2.83.3 | **Dernière mise à jour :** 2026-11-04
> **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,76 @@
## 🔵 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)
- **Fiche :** [features/hub-sessions-machine-227.md](./features/hub-sessions-machine-227.md)
- **Description :** vague C du plan Hub v2.1 (HUB-22) : le Hub doit lister
les sessions actives d'un utilisateur et les révoquer une à une ou
toutes, via le canal `jti` livré en HUB-13 (#226). Trois routes sous
la même garde machine (`require_machine_admin`) et la même
journalisation d'audit que les routes comptes existantes :
`GET /api/admin/machine/comptes/{username}/sessions`,
`POST …/sessions/{jti}/revoquer` (jamais de révocation
cross-utilisateur) et `POST …/sessions/revoquer-toutes`
(déconnexion globale, sans désactiver le compte).
- **Sous-tâches :**
- [x] `issued_sessions_for_user` + `revoke_one_for_user` (`backend/draco_session.py`)
- [x] Trois routes sessions (`backend/routers/comptes_machine.py`)
- [x] Tests étendus (`tests/test_comptes_machine.py`, `tests/test_draco_session.py`)
### 228. Hub HUB-19 — propagation des rôles du Hub à ObsiGate (consommatrice)
- **Effort :** ~0,5 jour | **Impact :** 🟡 | **Ouvert :** 2026-11-06 | **Statut :** ✅ livré en 2.85.1 (voir CHANGELOG ; branche rebasée sur la 2.85.0 avant fusion ; redéploiement Docker requis)
- **Fiche :** [features/hub-roles-obsigate-228.md](./features/hub-roles-obsigate-228.md)
- **Description :** suite de HUB-19 (plan Hub v2 §2.2, décision D3(a)) : le
pilote ShaarIt (0.7.0, en production) a posé le contrat ; ObsiGate —
à la fois émettrice et consommatrice du SSO — le consomme à son tour.
À l'ouverture de session draco, consultation de
`GET {hub}/api/roles/obsigate` (Cookie relayé, délai 2 s), cache
mémoire 60 s par `sub` (horodatage posé avant l'appel). Niveau connu
`aucun` → session draco refusée (réponse explicite en français) ;
routes `/api/auth/admin/*` authentifiées par le canal draco :
niveau `administrateur` exigé quand le rôle est connu. Toute erreur
du Hub → rôle inconnu → comportement actuel. L'authentification
native d'ObsiGate (émettrice, accès de secours) n'est jamais touchée ;
validation locale du jeton, émission et révocations inchangées,
aucun rôle dans le jeton.
- **Sous-tâches :**
- [x] Client `backend/hub_roles.py` (contrat D3(a), cache/repli, URL du Hub résolue comme la barre — `draco_config.app_url("hub")`)
- [x] Refus « aucun » dans `draco_session.user_for_draco` + réponse explicite de `require_auth`
- [x] Garde `require_admin_hub` sur les routes `/api/auth/admin/*`
- [x] Tests `tests/test_hub_roles.py` (client + intégration du chemin draco)
### 226. Hub HUB-13 — API d'administration des comptes (machine-à-machine)
- **Effort :** ~0,5 jour | **Impact :** 🟡 | **Ouvert :** 2026-11-05 | **Statut :** ✅ livré en 2.84.0 (PR en attente de fusion — voir CHANGELOG ; redéploiement Docker requis)
- **Fiche :** [features/hub-api-admin-comptes-226.md](./features/hub-api-admin-comptes-226.md)
- **Description :** carte fusion #127 (plan Hub v2 §2.2, D1(a)/D2(a)) : le Hub
administre les comptes dont ObsiGate reste le magasin, via
`/api/admin/machine/comptes` (liste, profil étendu, création,
modification, désactivation/réactivation avec révocation des `jti`
draco, suppression, réinitialisation du mot de passe avec changement
forcé `must_change_password`, réinitialisation du MFA), protégée par
la clé machine dédiée `DRACO_ADMIN_MACHINE_KEY` — jamais par une
session. Chaque action est journalisée dans `data/audit.log`.
- **Sous-tâches :**
- [x] Routes machine lecture/écriture + garde par clé dédiée (`backend/routers/comptes_machine.py`)
- [x] Registre des émissions draco + `revoke_all_for_user` (`backend/draco_session.py`)
- [x] Champ `must_change_password` (modèle, connexion, `/me`, changement de mot de passe)
- [x] Journalisation `log_compte_admin` (`backend/audit.py`) + tests `tests/test_comptes_machine.py`
### 225. Fusion — panneau Spark : version du service d'agents visible en mode sidebar
- **Effort :** ~0,1 jour | **Impact :** 🟢 | **Ouvert :** 2026-10-26 | **Statut :** ✅ livré le 2026-10-26 (version du hook — voir CHANGELOG ; redéploiement Docker requis)
@@ -1169,6 +1239,9 @@
| BUG-119 | Panneau Spark — « mode console » bloqué par la CSP (`frame-src` sans l'origine du service d'agents) | 2.77.1 | [ISSUES_TODOLIST.md](./ISSUES_TODOLIST.md) |
| BUG-120 | Menu inter-apps — les URL sœurs (`window.DRACO_URLS`) dérivent l'environnement de l'hôte de l'agent (`-dev` en dev), explicite prioritaire, Gitea inchangée (suite de #223) | 2.78.2 | [ISSUES_TODOLIST.md](./ISSUES_TODOLIST.md) |
| 225 | Panneau Spark — version du service d'agents visible en mode sidebar (pied du panneau, lue en direct via `GET /healthz`) | 2.79.0 | [features/fusion-panneau-version-agent-225.md](./features/fusion-panneau-version-agent-225.md) |
| BUG-123 | Aller-retour SSO — le `return_to` de `/sso/authorize` est honoré aussi après restauration de session au démarrage (`initAuth`), pas seulement après un login frais | Unreleased | [features/entree-sso-bug-123-124.md](./features/entree-sso-bug-123-124.md) |
| BUG-124 | Barre commune v0.7.0 — `DRACO_BAR.setUser` branché dans `renderUserSection()` : le nom du compte s'affiche dans le menu compte dès le login, sans rechargement | Unreleased | [features/entree-sso-bug-123-124.md](./features/entree-sso-bug-123-124.md) |
| BUG-125 | Aller-retour SSO — à l'arrivée d'un `/sso/authorize`, `initAuth` force le refresh silencieux + `/api/auth/me` pour que le cookie `draco_session` soit réémis avant que le retour soit honoré (pont sœur sans jeton = formulaire nu) | Unreleased | [features/retour-sso-cookie-draco-bug-125.md](./features/retour-sso-cookie-draco-bug-125.md) |
---
@@ -0,0 +1,59 @@
# BUG-122 — Déconnexion globale navigable : `GET /sso/logout`
**Carte :** fusion #141 (signalement de Bruno, 2026-11-06, capture
depuis la console Spark). **Version :** 2.86.0. **Prérequis :** ACC-3.1
(#216) — la déconnexion globale existe déjà dans
`POST /api/auth/logout`.
## Constat
Le bouton « Déconnexion » du menu compte de la barre commune
(dracodev-commons) est une **action relayée à l'hôte** (`cfg.onAction`,
sinon événement `draco:bar`) : la barre ne déconnecte jamais
elle-même. Or :
- console Spark, ObsiGate, Flowdeck, TikTak, ShaarIt et Hub ne
branchaient **aucune** action `deconnexion` (clic sans effet,
reproduit en navigateur réel sur la console : session draco intacte
après le clic) ;
- Kanbante, seul branché, ne détruisait que sa session locale — la
session SSO survivait ;
- et de toute façon, aucun hôte n'aurait pu terminer la session
globale : `POST /api/auth/logout` n'est appelable qu'en same-origin
depuis l'interface d'ObsiGate. Il manquait le point d'entrée
navigable, symétrique de `GET /sso/authorize`.
## Livraison (cette PR, côté émettrice)
| Méthode | Chemin | Effet |
|---|---|---|
| GET | `/sso/logout?return_to=<url>` | Déconnexion globale, puis redirection 302 vers le `return_to` validé (repli « / ») |
- La logique de `POST /api/auth/logout` est extraite dans
`apply_global_logout(request, response)` (`backend/auth/router.py`)
et partagée par les deux entrées : révocation des jetons natifs
refresh/access, révocation du `jti` du cookie `draco_session`,
effacement des cookies (dont `draco_session` sur le domaine parent).
- `return_to` passe par la liste blanche existante
(`draco_session.validate_return_to` : https + `dracodev.net` ou
sous-domaine) — aucun relais ouvert.
- Idempotente : sans session, la route redirige quand même (les hôtes
y naviguent même si leur session a déjà expiré).
- La barre d'ObsiGate elle-même branche son action `deconnexion` sur
cette route (`frontend/index.html`, retour à sa racine) — garde :
`tests/test_draco_barre.py::test_barre_deconnexion_branchee`.
## Côté hôtes (PR sœurs, carte fusion #141)
Chaque hôte branche son action `deconnexion` : destruction de sa
session locale d'abord (Flowdeck, TikTak, Kanbante, ShaarIt), puis
navigation vers `<émettrice>/sso/logout?return_to=<sa base>`. La
console et le Hub (session draco seule) naviguent directement.
Après le parcours complet, « Déconnexion » termine **la session de la
suite entière** et la session locale de l'hôte courant.
## Tests
`tests/test_draco_session.py` (+3) : révocation du `jti` + redirection
vers le `return_to` + cookie effacé (`Max-Age=0`), liste blanche
(relais refusé, repli « / »), idempotence sans session.
+77
View File
@@ -0,0 +1,77 @@
# Entrée SSO de bout en bout — BUG-123 + BUG-124
Chantier « entrée SSO de bout en bout » (écarts constatés par Bruno en
test réel le 2026-11-08, compte « testeur » créé au Hub) : deux des
trois écarts tenaient à ObsiGate. Diagnostic mené en navigateur réel
dans une pile locale complète servie sous les noms publics
(`*-dev.dracodev.net`, TLS local), chaîne d'URL et de cookies
journalisée à chaque saut — dossier de preuves `preuve-entree-sso`.
## BUG-123 — L'aller-retour SSO ne se referme pas (session existante)
**Chaîne observée (cas fautif)** : clic « Se connecter avec
ObsiGate (SSO) » dans l'application sœur → `GET
/sso/authorize?return_to=<app>/auth/draco` → `302 /?return_to=…` →
la SPA restaure la session (`initAuth` : jeton encore valide, ou
refresh silencieux via le cookie HttpOnly) et affiche l'accueil —
**le `return_to` n'est jamais suivi**. L'utilisateur reste chez
ObsiGate ; revenu manuellement à l'application, il n'y trouve
aucune session locale (« toujours pas connecté »).
**Cause racine** : le retour n'était honoré qu'à un seul endroit,
`AuthManager.saveToken()` → `_honorReturnTo()` — c'est-à-dire après
un login frais, une MFA ou un WebAuthn. Les deux chemins de
restauration d'`initAuth()` ne passaient ni par `saveToken` ni par
`_honorReturnTo`. Le sous-cas « login frais » refermait la boucle
correctement (vérifié dans la même pile) — d'où un bug invisible
pour qui teste en navigateur vierge sans session centrale.
**Correctif** (`frontend/js/auth.js`) :
- `_honorReturnTo()` retourne `true` quand il redirige (même liste
blanche inchangée : https + `*.dracodev.net`, jamais l'hôte
courant — re-validation cliente en plus de celle du serveur).
- `initAuth()` invoque `_honorReturnTo()` sur ses deux chemins de
restauration réussie, avant `showApp()`.
- Les refresh silencieux **en cours de session** (`refreshAccessToken`
appelé par l'intercepteur) n'honorent toujours pas le retour :
une page déjà ouverte ne doit jamais être redirigée.
## BUG-124 — Le nom du compte absent du menu de la barre après login
**Constat** : juste après le login, le menu compte de la barre
commune affiche l'en-tête générique « Compte » et l'avatar neutre
« ✦ » ; un rechargement forcé fait apparaître le nom.
**Cause racine** : la barre résout le nom dans `cfg.user`, sinon
dans le `title` de l'avatar. Chez ObsiGate, le seul poseur du
`title` était le fetch d'amorçage d'`index.html` au
`DOMContentLoaded` — limité aux sessions **déjà présentes au
chargement**. `renderUserSection()` (`js/auth.js`), appelée pour
toutes les sessions établies (login, restauration), mettait à jour
le bloc latéral et le drapeau admin de la barre (`setAdmin`,
v0.6.0/fusion #142) mais jamais le nom : la barre n'avait aucune
API pour le recevoir.
**Correctif** :
- dracodev-commons **v0.7.0** (PR #15) : API publique
`DRACO_BAR.setUser(user)` — même contrat de valeur que `cfg.user`
(chaîne, ou objet `display_name` / `name` / `username`) ;
resynchronise l'avatar (initiale, infobulle, aria-label) et
l'en-tête du menu compte immédiatement ; `setUser(null)` rétablit
l'état neutre. Barre re-vendangée verbatim dans
`frontend/draco-barre.js`.
- `renderUserSection()` appelle `setUser(name)` pour toute session
établie et `setUser(null)` sans identité ; le fetch d'amorçage
d'`index.html` pousse aussi le nom par `setUser` (le `title` seul
ne resynchronisait ni l'aria-label ni un menu déjà construit).
## Vérifications
- `tests/test_draco_barre.py::test_barre_v070_setuser_et_retour_sso_restauration`
(contrats épinglés) + suites draco/session/version vertes.
- `node ui/barre-apps/tests/barre-apps.test.js` côté commons :
58 tests, 284 assertions (nouveau test setUser).
- Preuve navigateur de bout en bout (scénario de Bruno, contexte
vierge) : voir le rapport du chantier et `preuve-entree-sso/`.
+105
View File
@@ -0,0 +1,105 @@
# #226 — HUB-13 : API d'administration des comptes (machine-à-machine)
**Carte :** fusion #127 (HUB-13, plan Hub v2 §2.2 et §4 vague A ; décisions
D1(a) — magasin des comptes chez ObsiGate — et D2(a) — ObsiGate émettrice).
**Version :** 2.84.0.
## Objet
Le Hub administre les comptes de la suite depuis son interface
d'administration ; ObsiGate reste le magasin des comptes. Cette API est
le bras armé de cette interface : administration complète des comptes,
en lecture et en écriture, réservée aux appels machine-à-machine.
## Routes — `/api/admin/machine/comptes`
Emplacement choisi : l'espace d'administration existant (`/api/admin/…`),
segment `machine` explicite. Il distingue ces routes de l'administration
par session (`/api/auth/admin/users`, garde `require_admin`) : aucune
session utilisateur, même administratrice, ne les ouvre.
| Méthode | Chemin | Effet |
|---|---|---|
| GET | `/api/admin/machine/comptes` | Liste des comptes (profils étendus) |
| GET | `/api/admin/machine/comptes/{username}` | Profil étendu d'un compte |
| POST | `/api/admin/machine/comptes` | Création (201 ; 409 si identifiant pris) |
| PATCH | `/api/admin/machine/comptes/{username}` | Modification (nom affiché, rôle global, langue, vaults) |
| POST | `/api/admin/machine/comptes/{username}/desactiver` | Désactivation + révocation des sessions |
| POST | `/api/admin/machine/comptes/{username}/reactiver` | Réactivation |
| DELETE | `/api/admin/machine/comptes/{username}` | Suppression + révocation des sessions |
| POST | `/api/admin/machine/comptes/{username}/reinitialiser-mot-de-passe` | Nouveau mot de passe temporaire, changement forcé |
| POST | `/api/admin/machine/comptes/{username}/reinitialiser-mfa` | Effacement de l'enrôlement TOTP |
Codes : 401 sans clé machine valide, 404 compte inconnu (ou API non
configurée), 409 conflit d'identifiant, 422 corps invalide.
## Protection
- Clé machine **dédiée** : `DRACO_ADMIN_MACHINE_KEY`, en-tête
`X-Draco-Machine-Key` (même famille et même en-tête que
`GET /api/sso/revocations`). Distincte de `DRACO_SSO_MACHINE_KEY` :
l'écriture de comptes est plus sensible que la lecture des
révocations (plan §3). Comparaison à temps constant.
- Sans la variable, l'API est inerte (404 « Non configuré »).
- Acteur consigné : en-tête facultatif `X-Draco-Actor` (défaut
`service-machine`).
## Profil étendu
Liste blanche stricte : `id`, `username`, `display_name`, `language`,
`avatar` (valeur du modèle — data-URL ou `null`, comme
`GET /api/auth/me`) et `avatar_present`, `role`, `active`, `vaults`,
`mfa_enabled` (oui/non), `mfa_method`, `must_change_password`,
`created_at`, `last_login`. **Jamais** le haché du mot de passe, le
secret TOTP, les codes de récupération ni les identifiants WebAuthn.
## Désactivation et sessions
- `active = false` → la connexion est refusée (401 uniforme, BUG-039)
et plus aucun jeton n'est émis.
- Les `jti` draco émis pour le compte sont révoqués via le mécanisme
existant (`draco_session.revoke`, liste publiée par
`GET /api/sso/revocations`). Pour les connaître, `draco_session`
tient désormais un registre des émissions (`data/draco_issued.json`,
`jti → exp` par `sub`, purgé à l'expiration) et
`revoke_all_for_user(sub)`.
- Le repère `password_changed_at` (BUG-028) est avancé : les jetons
natifs déjà émis sont invalidés et ne ressuscitent pas à la
réactivation. Les anciennes sessions draco restent révoquées après
réactivation : une nouvelle connexion est nécessaire.
## Changement forcé du mot de passe
Nouveau champ du modèle utilisateur : `must_change_password` (booléen,
défaut `false` — ajouté par `create_user`, aucun fichier à migrer :
les comptes existants sans le champ valent `false`). Posé à la
création machine et à la réinitialisation du mot de passe ; signalé
dans la réponse de connexion et `GET /api/auth/me` ; effacé par
`POST /api/auth/change-password`.
## Réinitialisation du MFA
Efface `mfa_secret`, `mfa_secret_pending` et `mfa_recovery_codes`.
Les clés WebAuthn éventuelles sont conservées et gardent le MFA
actif (méthode `webauthn`) ; sans elles, `mfa_enabled` passe à `false`.
## Journalisation
Chaque action est consignée dans le journal d'audit existant
(`data/audit.log`, JSON lignes) via `backend.audit.log_compte_admin` :
horodatage, `acteur` (identité de service), `action` (`compte_cree`,
`compte_modifie`, `compte_desactive`, `compte_reactive`,
`compte_supprime`, `mot_de_passe_reinitialise`, `mfa_reinitialise`),
`cible` (compte visé), IP et détails non sensibles (champs modifiés,
nombre de `jti` révoqués — jamais de mot de passe ni de secret).
## Tests
`tests/test_comptes_machine.py` : refus sans clé / mauvaise clé / clé
SSO / session admin, API inerte non configurée, liste et profil étendu
sans secret, création puis lecture et connexion, doublon 409,
modification, désactivation (connexion refusée, session native
refusée, `jti` draco révoqué et publié) puis réactivation,
réinitialisation du mot de passe (ancien refusé, nouveau accepté,
changement forcé signalé puis effacé au changement), réinitialisation
MFA (connexion directe après), suppression, journalisation.
+77
View File
@@ -0,0 +1,77 @@
# #228 — HUB-19 : propagation des rôles du Hub à ObsiGate
**Carte :** suite de HUB-19 (plan Hub v2 §2.2, décision D3(a)) — le pilote
ShaarIt (0.7.0, en production) a posé le contrat ; ObsiGate le consomme à
son tour, comme hôte à la fois **émettrice** et **consommatrice** du SSO.
**Version cible :** 2.85.1 (branche depuis le main 2.84.1 ; hypothèse : à
rebaser après la PR « API sessions HUB-22 » — 2.85.0 — si elle fusionne
d'abord).
## Contrat consommé (D3(a))
À l'ouverture de session draco — chez ObsiGate : la validation locale du
cookie partagé, `draco_session.user_for_draco()` (ACC-3.2, #217), appelée
par le repli draco de `get_current_user` — consultation du registre :
- `GET {hub}/api/roles/obsigate`, en-tête **Cookie complet** de la requête
relayé tel quel, `Accept: application/json`, délai **2 s** ;
- réponse 200 : `{"app", "sub", "role", "explicite", "ttl_secondes": 60}`,
`role` ∈ {`aucun`, `utilisateur`, `administrateur`} ;
- **URL du Hub** : `draco_config.app_url("hub")`, la résolution de la
barre commune (#223) — `DRACO_HUB_URL` explicite d'abord, dérivation
par l'hôte sœur (suffixe d'environnement de l'hôte de l'agent)
ensuite, défaut officiel enfin. Jamais d'URL dev figée.
## Client — `backend/hub_roles.py`
Sur le patron du pilote (`src/hub_roles.rs` de ShaarIt) :
- cache mémoire par `sub`, TTL **60 s** ;
- horodatage posé **avant** l'appel : un échec conserve l'ancien cache
et ne déclenche pas de rafale vers un Hub en panne ;
- toute erreur (réseau, délai, statut ≠ 200, JSON illisible, rôle hors
contrat) → rôle **inconnu** (`None`) → l'appelant garde son
comportement actuel. Le registre ne crée jamais un verrouillage
nouveau.
## Effets (sessions établies par draco seulement)
1. **Niveau connu `aucun`** → `user_for_draco` refuse : pas de session
établie par draco. `require_auth` répond alors **403** avec un
message explicite en français (niveau « aucun », matrice des rôles
du Hub, accès natif toujours possible), consigné via
`request.state.role_hub_refuse`. L'**authentification native**
d'ObsiGate (son propre login — c'est l'émettrice, son accès propre
est le secours) n'est **jamais** touchée.
2. **Routes d'administration `/api/auth/admin/*`** (CRUD des comptes,
`backend/auth/router.py`) : nouvelle garde `require_admin_hub`
(`backend/auth/middleware.py`) = `require_admin` + , quand la
requête est authentifiée par le **canal draco** (`_draco_sub`
présent, `_hub_role` joint par `user_for_draco`) et que le rôle est
**connu**, exigence du niveau `administrateur` du registre.
Sessions natives → règles actuelles inchangées ; rôle inconnu →
règles actuelles inchangées. Le registre n'élève aucun privilège :
un compte local non admin reste refusé par la règle locale, quel
que soit son niveau au Hub.
3. **Inchangés** : validation locale du jeton, émission du cookie,
révocations (`jti`), renouvellement glissant. **Aucun rôle dans le
jeton** (claims minimaux de #216 préservés).
Périmètre assumé : la garde du registre vise les routes nommées par la
carte, `/api/auth/admin/*`. Les autres surfaces gardées par
`require_admin` (configuration, vaults, coffres…) gardent leurs règles
actuelles ; les y soumettre serait un changement d'une ligne par
surface (`require_admin_hub` est réutilisable tel quel) si Bruno le
décide.
## Tests
`tests/test_hub_roles.py` : parsing du contrat (URL, Cookie relayé,
`Accept`, délai 2 s), rôles reconnus / hors contrat, JSON illisible,
erreurs HTTP et réseau → inconnu ; résolution de l'URL du Hub
(explicite, dérivée `-dev`, défaut officiel) ; cache par `sub`, TTL,
échec sans rafale avec ancien cache conservé ; intégration sur le
chemin draco (refus « aucun » explicite, login natif intact sous
« aucun », rôle inconnu = comportement actuel, `utilisateur` Hub
refusé sur `/api/auth/admin/*`, `administrateur` Hub accepté, compte
local non admin non élevé, session native jamais bloquée par le Hub).
+85
View File
@@ -0,0 +1,85 @@
# #227 — HUB-22 : API machine des sessions draco (liste et révocation)
**Carte :** vague C du plan Hub v2.1 (HUB-22) — le Hub consomme ces
routes en 0.17.0 pour l'écran des sessions d'un utilisateur.
**Version :** 2.85.0. **Prérequis :** HUB-13 (#226) — registre des
émissions `jti` et garde machine.
## Objet
Le Hub doit lister les sessions actives d'un utilisateur et les
révoquer une à une ou toutes, via le canal `jti` livré en HUB-13.
Aucune route machine « sessions » n'existait : cette livraison la crée,
sous la même garde (`require_machine_admin`, clé
`DRACO_ADMIN_MACHINE_KEY`, en-têtes `X-Draco-Machine-Key` /
`X-Draco-Actor`) et avec la même journalisation d'audit que les routes
comptes existantes. Sans la clé configurée, l'API reste inerte (404) ;
sans clé valide, 401.
## Routes — `/api/admin/machine/comptes/{username}/sessions`
| Méthode | Chemin | Effet |
|---|---|---|
| GET | `/api/admin/machine/comptes/{username}/sessions` | Sessions actives du compte |
| POST | `/api/admin/machine/comptes/{username}/sessions/{jti}/revoquer` | Révocation d'une session |
| POST | `/api/admin/machine/comptes/{username}/sessions/revoquer-toutes` | Révocation de toutes les sessions |
Codes : 401 sans clé machine valide, 404 compte inconnu (ou API non
configurée), 404 `jti` absent de l'ensemble actif du compte.
### Liste — `GET …/sessions`
`200 {"username": …, "sessions": [{"jti", "exp", "expire_le",
"revoquee"}]}` — une entrée par `jti` émis et non expiré, triée par
`exp` croissant ; `expire_le` est l'échéance en ISO 8601 UTC et
`revoquee` signale un `jti` déjà présent dans la liste des
révocations.
### Révocation unitaire — `POST …/sessions/{jti}/revoquer`
`200 {"jti", "revoquee": true}`. Le `jti` n'est révoqué que s'il
appartient à l'ensemble émis du compte visé et n'est pas expiré :
**404 sinon, jamais de révocation cross-utilisateur**.
### Tout révoquer — `POST …/sessions/revoquer-toutes`
`200 {"revoquees": n}` — réutilise `revoke_all_for_user` de HUB-13.
C'est la « déconnexion globale », **distincte de la désactivation** :
le compte reste actif, une nouvelle connexion émet une nouvelle
session.
## Backend — `backend/draco_session.py`
- `issued_sessions_for_user(sub)` : sessions actives
(`exp > maintenant`) du `sub`, `[{jti, exp, revoquee}]` triées par
`exp` croissant ; les entrées expirées du `sub` sont purgées du
registre au passage.
- `revoke_one_for_user(sub, jti)` : révoque via le `revoke()`
existant uniquement si le `jti` appartient à l'ensemble émis de ce
`sub` et n'est pas expiré ; retourne un booléen.
La clé du registre est le même `sub` que celui de HUB-13
(`_identifiant_sessions` dans `comptes_machine.py` : `id` du compte,
à défaut `username`) — factorisée depuis `_revoquer_sessions`, qui
l'utilise aussi désormais.
## Journalisation
Les deux écritures sont consignées dans `data/audit.log` via
`log_compte_admin` : actions `session_revoquee` (détail : le `jti`) et
`sessions_revoquees` (détail : nombre de `jti` révoqués), acteur =
identité de service `X-Draco-Actor`. La lecture suit le patron des
lectures existantes (non journalisée).
## Tests
- `tests/test_draco_session.py` : liste triée et marquage `revoquee`,
purge des expirés, révocation unitaire, refus cross-utilisateur,
refus d'un `jti` expiré ; le registre des émissions est isolé en
fichier temporaire dans la fixture.
- `tests/test_comptes_machine.py` (`TestSessions`) : liste (contenu,
`expire_le` ISO 8601 UTC), liste vide, compte inconnu 404,
révocation unitaire (succès + effet sur `verify_token`),
cross-utilisateur 404 sans effet, tout-révoquer (compte toujours
actif, autres comptes intacts, seconde passe à 0), garde (401 sans
clé, 404 API non configurée), journalisation.
+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`).
@@ -0,0 +1,99 @@
# Retour SSO — cookie draco réémis avant le retour (BUG-125)
Suite du chantier « entrée SSO de bout en bout » : retest réel de
Bruno le 2026-11-08, après la fusion de BUG-123/BUG-124 (2.86.2)
et du correctif « l'hôte de la requête fait foi » côté applications
sœurs (Kanbante 0.46.9). Le retour tombe désormais sur le bon
hôte, mais l'utilisateur arrive devant le formulaire de
l'application sœur, **sans message d'erreur** — pas connecté.
## Diagnostic (pile « conteneur dev réel », navigateur réel)
Les formes d'échec du pont Kanbante ont d'abord été
cartographiées une à une (jetons forgés/révoqués, compte lié
désactivé, rôle « aucun » au registre du Hub) :
| Cause au pont | Arrivée |
|---|---|
| Jeton valide, correspondance saine | session ouverte |
| Échec de résolution (compte lié désactivé) | `/login?draco=echec` **avec bandeau** |
| Rôle « aucun » au registre | page **403 explicite** |
| Jeton absent, illisible (signature) ou **révoqué** | `/login` **nu, sans signal** |
Le formulaire nu de Bruno ne peut donc venir que de la dernière
ligne : au moment du pont, aucun jeton draco valide n'est
présenté. La variante qui le reproduit à l'identique :
1. login chez ObsiGate (session établie, `sessionStorage`
alimenté) ;
2. suppression des cookies `access_token` et `draco_session`
(le cookie `refresh_token`, 7 j, est conservé) ;
3. Kanbante → « Se connecter avec ObsiGate (SSO) » ;
4. la SPA honore le `return_to` par son chemin court
(`sessionStorage` encore « valide ») — **aucun échange
serveur** ;
5. la requête du pont part **sans cookie `draco_session`**
(journalisée) → Kanbante répond `303 /login`, formulaire nu.
Un second clic, lui, aboutit : le premier passage chez ObsiGate
a provoqué entre-temps la réémission du cookie (activité
authentifiée traversant `DracoRenewalMiddleware`).
## Cause racine
La réémission du cookie `draco_session` est opportuniste :
`DracoRenewalMiddleware` ne peut la poser que sur la réponse
d'une requête portant un cookie `access_token` natif valide.
Le chemin court d'`initAuth()` (session « valide » en
`sessionStorage`, ajouté pour BUG-123) redirige vers
l'application sœur **sans aucune requête authentifiée** : si
les deux cookies ont disparu indépendamment de la session
(cookies purgés séparément, profil restauré, domaines nettoyés
à des rythmes différents — le cookie draco vit 12 h,
l'`access_token` 1 h, le refresh 7 j et `sessionStorage`
suit sa propre logique d'onglet), rien ne réémet le cookie
avant le départ, et le pont sœur est muet par construction
(un jeton absent est indiscernable d'un visiteur jamais
connecté).
## Correctif (`frontend/js/auth.js`, `initAuth()`)
Quand la page est l'arrivée d'un `/sso/authorize`
(`return_to` présent dans l'URL), le chemin court est
écarté : `initAuth()` emprunte toujours le chemin du refresh
silencieux — `POST /api/auth/refresh` (rotation, pose un
nouvel `access_token`) puis `GET /api/auth/me`, dont la
requête porte ce cookie et dont la réponse traverse
`DracoRenewalMiddleware` : le cookie draco absent, invalide
ou en fenêtre de renouvellement est réémis **avant**
`_honorReturnTo()`. Si le refresh échoue (plus de session
centrale réelle), l'écran de connexion s'affiche comme
avant et le `return_to`, toujours dans l'URL, sera honoré
par `saveToken` après login frais.
Hors arrivée `authorize`, le démarrage est strictement
inchangé (chemin court conservé pour les visites directes
d'ObsiGate) ; les refresh en cours de session ne redirigent
toujours jamais.
## Garde et preuve
- `tests/test_draco_barre.py::test_retour_sso_refresh_force_bug_125`
(test épinglé : le chemin court est conditionné à l'absence
de `return_to`, et le compte d'appels `_honorReturnTo` de
BUG-123 reste à 2).
- Preuve navigateur dans la pile « conteneur dev réel »
(dossier `preuve-retour-sso-hote`, scripts `diag-*.py`) :
la variante fautive retourne **connectée** après correctif,
la requête du pont portant le cookie draco réémis.
## Périmètre
Ce correctif ferme le mécanisme « retour honoré sans cookie »
côté émettrice. Les deux autres formes silencieuses relevées
au diagnostic relèvent d'autres gestes, inchangés : jeton
révoqué (déconnexion globale, révocation de session au Hub —
guéri par une reconnexion ou une activité chez ObsiGate) et
jeton illisible pour une application sœur (secret partagé
propre à son conteneur — permanent tant que la configuration
n'est pas alignée).
+24
View File
@@ -1214,6 +1214,30 @@
function initTheme() {
const saved = localStorage.getItem("obsigate-theme") || "dark";
applyTheme(saved);
// Thème commun de la suite (HUB-18, fusion #132) : la barre
// commune (barre v0.5.0) applique la préférence du Hub
// (sombre/clair/système) à l'ouverture — directement sur
// data-theme, et via l'événement « draco:theme » pour que le
// mécanisme propre d'ObsiGate suive (icône et libellé du bouton,
// feuilles highlight.js). applyTheme mémorise le mode appliqué
// dans « obsigate-theme » : la préférence du Hub devient le
// choix local courant, et le bouton de bascule reste le maître
// pour la suite de la session (aucune ré-application de la barre
// après l'ouverture). « systeme » arrive déjà résolu en mode
// effectif (detail.mode) par la barre. Repli : si le Hub ne
// répond pas, aucun événement n'arrive et le choix local
// ci-dessus reste seul maître, comme avant.
document.addEventListener("draco:theme", (e) => {
const mode = e && e.detail && e.detail.mode;
if (mode === "dark" || mode === "light") applyTheme(mode);
});
// Si la barre s'est initialisée AVANT ce module (ordre des
// scripts defer/module selon la page), sa préférence déjà
// résolue depuis son cache est reprise ici.
const barre = window.DRACO_BAR;
if (barre && (barre.themeMode === "dark" || barre.themeMode === "light")) {
applyTheme(barre.themeMode);
}
}
function applyTheme(theme) {
+22 -1
View File
@@ -24,7 +24,14 @@
compte (Télécharger, À Propos, Aides, Profil) réutilisent
.draco-menu-item (déjà ancre-compatible : text-decoration none)
et le séparateur .draco-menu-sep du menu des applications.
v0.4.0 (HUB-11) : .draco-menu-icone — les icônes monoline des
items du menu compte (SVG inline construit par le JS) : 18 px,
replacées à gauche du libellé par order: -1 (l'item est en
flex), couleur atténuée --ink-2, pleine --ink au survol/focus.
Jetons repris du prototype validé Console v7.2.
v0.4.1 (fusion #125) : menu compte resserré — min-width
248 → 232 px, le panneau épouse le contenu (demande de Bruno :
le menu était trop large une fois les icônes visibles).
Thème : clair par défaut, sombre via [data-theme="dark"] sur <html>
ou prefers-color-scheme si l'app intégratrice ne force rien
(aucun attribut data-theme sur <html>). */
@@ -82,7 +89,7 @@
* droite ; ses items réutilisent .draco-apps-item. */
.draco-compte-menu {
position: absolute; top: calc(100% + 6px); right: 10px; z-index: 400;
min-width: 248px; padding: 6px;
min-width: 232px; padding: 6px;
background: var(--surface); border: 1px solid var(--line); border-radius: 14px;
box-shadow: 0 16px 44px rgb(0 0 0 / .28);
}
@@ -94,6 +101,20 @@
text-decoration: none; cursor: pointer;
}
.draco-menu-item:hover, .draco-menu-item:focus-visible { background: var(--surface-2); }
/* Item conditionnel masqué (v0.6.0 : « Administration » tant que
l'hôte n'a pas affirmé le statut d'administrateur) — le
display:flex ci-dessus écraserait l'attribut hidden sans cette
règle, même patron que .draco-compte-menu[hidden]. */
.draco-menu-item[hidden] { display: none; }
/* Icônes monoline du menu compte (v0.4.0) : appendues après le
libellé dans le DOM, replacées à gauche par order: -1. */
.draco-menu-icone {
order: -1; flex: none; display: inline-flex; align-items: center;
width: 18px; height: 18px; color: var(--ink-2);
}
.draco-menu-icone svg { display: block; width: 18px; height: 18px; }
.draco-menu-item:hover .draco-menu-icone,
.draco-menu-item:focus-visible .draco-menu-icone { color: var(--ink); }
.draco-menu-sep { height: 1px; margin: 6px 10px; background: var(--line); }
.draco-compte-nom {
padding: 8px 10px 10px; font-weight: 700; font-size: 14px;
+306
View File
@@ -29,6 +29,46 @@
* l'ouverture des menus. Le Hub n'a pas d'onglet dans la barre :
* comme spark, sa clé est résolue et exposée via DRACO_BAR.urls,
* sans étape « href rendu » (voir « URL » ci-dessous).
* v0.4.0 (carte HUB-11, fusion #125) : icônes monoline dans le
* menu compte — chaque item (les 4 liens du Hub et « Déconnexion »)
* reçoit un glyphe SVG inline dans le style des icônes du rail de
* la console (contour, trait fin régulier, currentColor, aucun
* remplissage), aligné à gauche du libellé via .draco-menu-icone.
* L'en-tête d'identité ne reçoit pas d'icône. Aucun changement de
* comportement : liens résolus et Déconnexion relayée inchangés.
* v0.5.0 (carte HUB-18, fusion #132) : thème commun de la suite —
* la barre apprend la préférence de thème du profil du Hub
* (GET <hub>/api/profil/theme, cookie draco) et l'applique à
* l'ouverture par le mécanisme data-theme des hôtes, avec cache
* local court et repli intégral sur le comportement actuel de
* l'hôte si le Hub ne répond pas. Voir « Thème commun » plus bas.
* v0.6.0 (demande de Bruno, 2026-11-06) : le menu compte gagne un
* cinquième lien Hub, « Administration » → <hub>/admin (le Hub y
* redirige vers /admin/utilisateurs), placé après le séparateur,
* avant « Déconnexion », avec son icône monoline (curseurs de
* réglage). AFFICHAGE CONDITIONNEL : l'entrée n'apparaît que si
* l'hôte AFFIRME que le compte courant est administrateur de
* suite — cfg.admin === true à la configuration, ou
* DRACO_BAR.setAdmin(true) quand l'hôte l'apprend après coup
* (patron setUrls). L'hôte ne passe le drapeau que s'il l'a établi
* depuis SA source d'autorité (rôle global du compte chez
* ObsiGate, niveau du registre des rôles du Hub pour son app…) ;
* à défaut de certitude, pas de drapeau et l'entrée reste masquée.
* La barre ne devine jamais : le jeton draco ne porte aucun rôle
* (claims minimaux, par design). La vraie protection reste la
* garde serveur du Hub (/admin/*), pas ce masquage d'affichage.
* Voir le README, « Administration » — contrat de visibilité.
* v0.7.0 (chantier « entrée SSO de bout en bout », 2026-11-08) :
* l'API publique gagne DRACO_BAR.setUser(user) — l'hôte pousse le
* nom du compte courant DÈS qu'il l'établit, notamment une SPA qui
* termine son login sans rechargement (cas ObsiGate : le nom
* n'atteignait la barre qu'au chargement de la page suivante, le
* menu compte affichait l'en-tête générique « Compte » jusqu'au
* rechargement forcé). Même contrat de valeur que cfg.user
* (chaîne, ou objet display_name / name / username). L'avatar
* (initiale, infobulle) et l'en-tête du menu compte sont mis à
* jour immédiatement, sans rechargement ; null rétablit l'état
* neutre (✦, « Compte »).
*
* Aucun gestionnaire inline : un seul écouteur délégué sur le document
* (patron validé par le prototype — les onclick du HTML généré sont
@@ -41,6 +81,11 @@
* counts: { tiktak: 3, kanbante: 3, alertes: 3, spark: 0 },
* user: "Bruno", // nom affiché (v0.1.6) ;
* // ou { display_name: "Bruno", username: "bruno" }
* admin: true, // (v0.6.0, optionnel)
* // administrateur de suite ÉTABLI par l'hôte : démasque
* // l'entrée « Administration » du menu compte. Absent ou
* // non-strictement-true → entrée masquée. Peut aussi être
* // posé après coup via DRACO_BAR.setAdmin(true).
* urls: { // bases des applications
* obsigate: "https://og.dracodev.net/",
* flowdeck: "https://flowdeck.dracodev.net/",
@@ -261,6 +306,131 @@
}
var resolvedUrls = resolveUrls();
/* ── Thème commun (v0.5.0, carte HUB-18, fusion #132) ────────────
* La préférence de thème de la suite vit dans le profil du Hub :
* GET <hub>/api/profil/theme → {"theme": "sombre"|"clair"|"systeme"|null}
* authentifié par le cookie draco (credentials: "include").
* <hub> est l'URL RÉSOLUE ci-dessus (explicite > dérivation -dev >
* défaut officiel) — jamais un nom figé de plus.
* Application par le mécanisme data-theme existant des hôtes :
* "sombre" → data-theme="dark", "clair" → data-theme="light",
* "systeme" → attribut RETIRÉ (prefers-color-scheme décide, garde
* html:not([data-theme]) du CSS de la barre comme des hôtes).
* L'événement draco:theme ({theme, mode} — mode = "dark"/"light"
* EFFECTIF) est ensuite dispatché pour les hôtes dont le mécanisme
* propre doit suivre (icônes et libellés, feuilles de style,
* palettes ShaarIt, attribut dédié de la console…) ; un hôte qui
* s'initialise après la barre lit la même information dans
* DRACO_BAR.themePref / DRACO_BAR.themeMode.
* Ordre d'application : 1) le cache local FRAIS est appliqué de
* façon SYNCHRONE à l'initialisation de la barre (script en defer
* chez tous les hôtes : avant DOMContentLoaded, donc avant le
* premier rendu dans le cas général) ; 2) un fetch ASYNCHRONE et
* NON BLOQUANT rafraîchit le cache et ré-applique si la préférence
* a changé. À la toute première visite (aucun cache), un bref
* flash du thème local de l'hôte reste possible le temps du fetch :
* c'est le prix du repli — l'état affiché transitoire est le thème
* que l'hôte aurait de toute façon choisi seul, jamais un état
* cassé, et les visites suivantes sont servies par le cache.
* Cache : localStorage "draco-theme-hub" ({theme, ts}), TTL 12 h
* (ordre de la journée) ; il ne contient QUE la préférence du Hub,
* jamais le choix local de l'hôte.
* REPLI INTÉGRAL : Hub injoignable, réponse non-OK (401…), JSON
* invalide, theme null ou valeur inconnue → RIEN n'est appliqué et
* RIEN n'est mis en cache ; un échec de fetch n'efface pas un cache
* existant. Le comportement actuel de l'hôte (son localStorage,
* puis le système) reste alors exactement le maître, comme avant
* la v0.5.0. Le sélecteur de thème LOCAL de chaque hôte reste
* fonctionnel : la barre n'applique qu'à l'ouverture (cache, puis
* fetch) ; elle ne ré-applique ensuite que sur changement du
* schéma système, et seulement tant que la préférence résolue est
* "systeme". */
var THEME_CACHE_CLE = "draco-theme-hub";
var THEME_CACHE_TTL_MS = 12 * 60 * 60 * 1000;
var themePref = null; /* "sombre"|"clair"|"systeme"|null (non résolue) */
var themeMode = null; /* "dark"|"light"|null : mode effectif appliqué */
function themeSystemeEstSombre() {
try {
return !!(window.matchMedia &&
window.matchMedia("(prefers-color-scheme: dark)").matches);
} catch (e) { return false; }
}
function lireCacheTheme() {
try {
var brut = window.localStorage &&
window.localStorage.getItem(THEME_CACHE_CLE);
if (!brut) return null;
var c = JSON.parse(brut);
if (!c || typeof c.ts !== "number") return null;
if (Date.now() - c.ts > THEME_CACHE_TTL_MS) return null;
if (c.theme === "sombre" || c.theme === "clair" || c.theme === "systeme")
return c.theme;
} catch (e) { /* stockage indisponible ou corrompu : pas de cache */ }
return null;
}
function ecrireCacheTheme(theme) {
try {
if (window.localStorage) {
window.localStorage.setItem(THEME_CACHE_CLE,
JSON.stringify({ theme: theme, ts: Date.now() }));
}
} catch (e) { /* stockage indisponible : le prochain fetch refera le travail */ }
}
function appliquerThemeCommun(theme) {
var root = document.documentElement;
if (!root) return;
if (theme === "sombre" || theme === "clair") {
themeMode = theme === "sombre" ? "dark" : "light";
root.setAttribute("data-theme", themeMode);
} else if (theme === "systeme") {
themeMode = themeSystemeEstSombre() ? "dark" : "light";
root.removeAttribute("data-theme");
} else {
return;
}
themePref = theme;
if (window.DRACO_BAR) {
window.DRACO_BAR.themePref = themePref;
window.DRACO_BAR.themeMode = themeMode;
}
try {
document.dispatchEvent(new CustomEvent("draco:theme",
{ detail: { theme: themePref, mode: themeMode } }));
} catch (e) { /* aucun écouteur hôte : data-theme suffit */ }
}
function initThemeCommun() {
var enCache = lireCacheTheme();
if (enCache) appliquerThemeCommun(enCache);
/* Suivi du schéma système tant que la préférence est "systeme" :
* sans data-theme, le CSS suit tout seul ; l'événement est
* re-dispatché pour les hôtes qui matérialisent le mode. */
try {
var mq = window.matchMedia &&
window.matchMedia("(prefers-color-scheme: dark)");
if (mq && mq.addEventListener) {
mq.addEventListener("change", function () {
if (themePref === "systeme") appliquerThemeCommun("systeme");
});
}
} catch (e) { /* pas de matchMedia : pas de suivi */ }
if (typeof window.fetch !== "function") return;
var url = withSlash(resolvedUrls.hub || DEFAULT_URLS.hub) +
"api/profil/theme";
window.fetch(url, { credentials: "include" }).then(function (resp) {
if (!resp || !resp.ok) return null;
return resp.json();
}).then(function (data) {
if (!data) return;
var t = data.theme;
if (t === "sombre" || t === "clair" || t === "systeme") {
ecrireCacheTheme(t);
appliquerThemeCommun(t);
}
/* theme null ou inconnu : repli intégral, rien n'est touché. */
}).catch(function () { /* Hub injoignable : repli intégral */ });
}
function setCounts(counts) {
Object.keys(counts || {}).forEach(function (k) {
/* Toutes les occurrences : l'onglet ET sa ligne dans le menu. */
@@ -483,6 +653,93 @@
if (!appsMenu.hidden) lastOpener = brand;
}
/* Icônes monoline du menu compte (v0.4.0) — glyphes contour
* dans le style des icônes du rail de la console : viewBox 24,
* stroke currentColor, remplissage nul, extrémités rondes.
* Chaque glyphe est une liste de primitives [balise, attributs]
* construites en DOM (jamais d'innerHTML), comme le reste du
* fichier. Le libellé reste le nœud texte de l'item ; l'icône,
* appendue après, est replacée à gauche par le CSS (order: -1
* sur .draco-menu-icone, l'item étant déjà en flex). */
var MENU_ICONES = {
/* Flèche vers le bas dans un plateau. */
"telecharger": [
["path", { d: "M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4" }],
["polyline", { points: "7 10 12 15 17 10" }],
["line", { x1: "12", y1: "15", x2: "12", y2: "3" }]
],
/* Cercle d'information. */
"a-propos": [
["circle", { cx: "12", cy: "12", r: "9" }],
["line", { x1: "12", y1: "11", x2: "12", y2: "16" }],
["line", { x1: "12", y1: "8", x2: "12.01", y2: "8" }]
],
/* Cercle d'interrogation. */
"aide": [
["circle", { cx: "12", cy: "12", r: "9" }],
["path", { d: "M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3" }],
["line", { x1: "12", y1: "17", x2: "12.01", y2: "17" }]
],
/* Personne : tête + épaules. */
"profil": [
["path", { d: "M20 21v-2a4 4 0 0 0-4-4H8a4 4 0 0 0-4 4v2" }],
["circle", { cx: "12", cy: "7", r: "4" }]
],
/* Curseurs de réglage (trois axes, trois boutons) — v0.6.0. */
"admin": [
["line", { x1: "4", y1: "21", x2: "4", y2: "14" }],
["line", { x1: "4", y1: "10", x2: "4", y2: "3" }],
["line", { x1: "12", y1: "21", x2: "12", y2: "12" }],
["line", { x1: "12", y1: "8", x2: "12", y2: "3" }],
["line", { x1: "20", y1: "21", x2: "20", y2: "16" }],
["line", { x1: "20", y1: "12", x2: "20", y2: "3" }],
["line", { x1: "1", y1: "14", x2: "7", y2: "14" }],
["line", { x1: "9", y1: "8", x2: "15", y2: "8" }],
["line", { x1: "17", y1: "16", x2: "23", y2: "16" }]
],
/* Flèche sortant d'un cadre (porte). */
"deconnexion": [
["path", { d: "M9 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h4" }],
["polyline", { points: "16 17 21 12 16 7" }],
["line", { x1: "21", y1: "12", x2: "9", y2: "12" }]
]
};
/* Espace de noms SVG — OBLIGATOIRE : un élément « svg » (ou
* « path », « circle »…) créé par createElement() appartient à
* l'espace de noms HTML et le navigateur ne le dessine JAMAIS
* (bug v0.4.0 : libellés décalés d'un cran d'icône, aucun glyphe
* visible ; corrigé en v0.4.1, carte fusion #125). */
var SVG_NS = "http://www.w3.org/2000/svg";
function menuIcone(nom) {
var span = document.createElement("span");
span.className = "draco-menu-icone";
span.setAttribute("aria-hidden", "true");
var svg = document.createElementNS(SVG_NS, "svg");
svg.setAttribute("viewBox", "0 0 24 24");
svg.setAttribute("fill", "none");
svg.setAttribute("stroke", "currentColor");
svg.setAttribute("stroke-width", "1.8");
svg.setAttribute("stroke-linecap", "round");
svg.setAttribute("stroke-linejoin", "round");
svg.setAttribute("focusable", "false");
(MENU_ICONES[nom] || []).forEach(function (spec) {
var el = document.createElementNS(SVG_NS, spec[0]);
for (var k in spec[1]) el.setAttribute(k, spec[1][k]);
svg.appendChild(el);
});
span.appendChild(svg);
return span;
}
/* Visibilité de l'entrée « Administration » (v0.6.0) : vraie
* seulement si l'hôte l'a AFFIRMÉE — cfg.admin === true à la
* configuration, ou DRACO_BAR.setAdmin(true) après coup. La
* barre ne déduit jamais ce statut (le jeton draco ne porte
* aucun rôle) ; à défaut, l'entrée reste masquée et la garde
* serveur du Hub reste la vraie protection. */
var compteAdmin = cfg.admin === true;
var adminItem = null;
/* Menu compte (v0.1.6 ; v0.3.0 pour les liens) — en-tête
* d'identité, puis les liens du Hub (Télécharger, À Propos,
* Aides, Profil — vrais <a href>, même patron que le menu des
@@ -508,18 +765,36 @@
a.setAttribute("data-hub-link", pair[0]);
a.setAttribute("role", "menuitem");
a.textContent = pair[1];
a.appendChild(menuIcone(pair[0]));
compteMenu.appendChild(a);
});
var sep = document.createElement("div");
sep.className = "draco-menu-sep";
sep.setAttribute("aria-hidden", "true");
compteMenu.appendChild(sep);
/* « Administration » (v0.6.0) : cinquième lien Hub
* (<hub>/admin, où le Hub redirige vers /admin/utilisateurs).
* data-hub-link="admin" : son href est resynchronisé par
* refreshCompteHrefs / setUrls comme les quatre autres liens.
* Toujours construit ; masqué tant que l'hôte n'a pas affirmé
* le statut d'administrateur (compteAdmin). */
var adm = document.createElement("a");
adm.className = "draco-menu-item";
adm.href = hubHref("admin");
adm.setAttribute("data-hub-link", "admin");
adm.setAttribute("role", "menuitem");
adm.textContent = "Administration";
adm.appendChild(menuIcone("admin"));
adm.hidden = !compteAdmin;
compteMenu.appendChild(adm);
adminItem = adm;
var b = document.createElement("button");
b.type = "button";
b.className = "draco-menu-item";
b.setAttribute("data-compte-act", "deconnexion");
b.setAttribute("role", "menuitem");
b.textContent = "Déconnexion";
b.appendChild(menuIcone("deconnexion"));
compteMenu.appendChild(b);
bar.appendChild(compteMenu);
}
@@ -528,6 +803,7 @@
var head = compteMenu.querySelector(".draco-compte-nom");
var name = displayName();
if (head) head.textContent = name || "Compte";
if (adminItem) adminItem.hidden = !compteAdmin;
refreshCompteHrefs();
}
function toggleCompteMenu(force) {
@@ -620,12 +896,41 @@
window.DRACO_BAR = {
setCounts: setCounts, setCurrent: setCurrent, setDomain: setDomain,
urls: resolvedUrls,
/* Thème commun (v0.5.0) : préférence du Hub résolue et mode
* effectif appliqué ; null tant que rien n'a été résolu (repli). */
themePref: null, themeMode: null,
setUrls: function (urls) {
cfg.urls = Object.assign({}, cfg.urls, urls || {});
resolvedUrls = resolveUrls();
window.DRACO_BAR.urls = resolvedUrls;
applyUrls(resolvedUrls);
refreshCompteHrefs();
},
/* Administration (v0.6.0) : l'hôte pose le drapeau quand il a
* ÉTABLI que le compte courant est administrateur de suite
* (sa source d'autorité — voir l'en-tête et le README). Toute
* valeur autre que le booléen true masque l'entrée. */
setAdmin: function (v) {
compteAdmin = v === true;
if (adminItem) adminItem.hidden = !compteAdmin;
},
/* Identité (v0.7.0) : l'hôte pousse le nom du compte courant
* dès qu'il l'établit — même contrat de valeur que cfg.user
* (chaîne, ou objet display_name / name / username). L'avatar
* et l'en-tête du menu compte sont resynchronisés aussitôt,
* sans rechargement. setUser(null) rétablit l'état neutre. */
setUser: function (u) {
cfg.user = u || null;
if (!u) {
var av = document.querySelector(".draco-avatar");
if (av) {
av.textContent = "✦";
av.removeAttribute("title");
av.setAttribute("aria-label", "Compte");
}
}
syncAvatar();
refreshCompteMenu();
}
};
@@ -634,6 +939,7 @@
buildCompteMenu();
syncAvatar();
refreshCompteMenu();
initThemeCommun();
if (cfg.current) setCurrent(cfg.current);
if (cfg.domain) setDomain(cfg.domain);
if (cfg.counts) setCounts(cfg.counts);
+19
View File
@@ -410,6 +410,7 @@
return;
}
if (act === "palette") { location.href = "/recherche"; return; }
if (act === "deconnexion") { location.href = "/sso/logout?return_to=" + encodeURIComponent(location.origin + "/"); return; }
/* Correctif fusion #70 : relais "menu" supprimé avec le bouton trois points de la barre (la console agent est dans le menu de la marque, entrée « Console Spark »). Le bouton natif #header-menu-btn d'ObsiGate lui-même est inchangé et reste utilisable depuis l'en-tête ObsiGate. */
if (act === "alertes") { if (window.DRACO_ALERTES) { window.DRACO_ALERTES.open(); } else { dire("Alertes unifiées : le module n'a pas pu se charger."); } return; }
if (act === "spark") {
@@ -438,6 +439,24 @@
var av = document.getElementById("draco-avatar");
if (av) { av.textContent = nom.charAt(0).toUpperCase(); av.title = nom; }
}
/* Barre v0.6.0 (commons) : entrée « Administration »
du menu compte. Le rôle global du compte chez
ObsiGate EST la définition de l'administrateur
de suite (c'est lui que la garde /admin/* du Hub
vérifie, via ce même /api/auth/me) — ObsiGate le
connaît nativement, il l'affirme à la barre.
Tout autre rôle (ou échec) : pas d'affirmation,
l'entrée reste masquée. */
if (u && window.DRACO_BAR && window.DRACO_BAR.setAdmin) {
window.DRACO_BAR.setAdmin(u.role === "admin");
}
/* Barre v0.7.0 (commons, BUG-124) : le nom du
compte est aussi poussé par setUser — le
title seul ne resynchronisait ni l'aria-label
ni un menu compte déjà construit. */
if (u && nom && window.DRACO_BAR && window.DRACO_BAR.setUser) {
window.DRACO_BAR.setUser(nom);
}
}).catch(function () { /* avatar générique conservé */ });
});
</script>
+74 -2
View File
@@ -131,15 +131,17 @@ const AuthManager = {
_honorReturnTo() {
try {
const rt = new URLSearchParams(window.location.search).get("return_to");
if (!rt) return;
if (!rt) return false;
const u = new URL(rt);
const okHost = u.hostname === "dracodev.net"
|| u.hostname.endsWith(".dracodev.net");
if (u.protocol === "https:" && okHost
&& u.hostname !== window.location.hostname) {
window.location.replace(rt);
return true;
}
} catch (e) { /* return_to illisible : on reste sur place */ }
return false;
},
getToken() {
@@ -386,6 +388,17 @@ const AuthManager = {
const section = document.getElementById("sidebar-user");
if (!user || !this._authEnabled) {
if (section) section.hidden = true;
// Barre commune v0.6.0 (fusion #142) : sans identité
// établie, l'entrée « Administration » du menu compte
// reste masquée.
if (window.DRACO_BAR && window.DRACO_BAR.setAdmin) {
window.DRACO_BAR.setAdmin(false);
}
// Barre commune v0.7.0 (BUG-124) : symétriquement, le nom
// du compte est retiré de la barre (retour au neutre).
if (window.DRACO_BAR && window.DRACO_BAR.setUser) {
window.DRACO_BAR.setUser(null);
}
return;
}
if (!section) return;
@@ -427,6 +440,29 @@ const AuthManager = {
});
}
// Barre commune v0.6.0 (fusion #142) : l'entrée
// « Administration » du menu compte suit le rôle natif du
// compte — la définition même de l'administrateur de suite
// (garde /admin/* du Hub), même source que la rangée
// d'administration native ci-dessous. renderUserSection()
// est appelée par showApp() pour toutes les sessions
// établies (connexion, restauration, renouvellement
// silencieux) ; le fetch d'amorçage d'index.html ne couvre
// que les sessions déjà présentes au chargement de la page.
if (window.DRACO_BAR && window.DRACO_BAR.setAdmin) {
window.DRACO_BAR.setAdmin(user.role === "admin");
}
// Barre commune v0.7.0 (BUG-124) : pousser aussi le NOM du
// compte, pour le même motif — sans cet appel, la barre ne
// connaissait l'identité que par le fetch d'amorçage
// d'index.html (sessions déjà présentes au chargement) :
// après un login SPA sans rechargement, le menu compte
// affichait l'en-tête générique « Compte » et l'avatar
// neutre « ✦ » jusqu'au rechargement forcé.
if (window.DRACO_BAR && window.DRACO_BAR.setUser) {
window.DRACO_BAR.setUser(name || null);
}
const adminRow = document.getElementById("admin-menu-row");
if (adminRow) {
if (user.role === "admin") {
@@ -467,8 +503,34 @@ const AuthManager = {
return true;
}
// BUG-125 : la page est-elle l'arrivée d'un /sso/authorize
// (return_to présent) ? Si oui, le chemin court ci-dessous ne
// doit PAS s'appliquer : il repartait vers l'application
// sœur sans aucun échange serveur, donc sans laisser au
// middleware de renouvellement (DracoRenewalMiddleware)
// l'occasion de réémettre le cookie draco_session. Quand les
// cookies access_token et draco_session ont disparu alors
// que la session semble encore valide en sessionStorage
// (cookies purgés séparément, profil restauré), le pont de
// l'application sœur ne recevait AUCUN cookie : jeton absent
// = formulaire nu, sans message, côté sœur. En forçant le
// refresh silencieux ci-dessous (cookie refresh 7 j) suivi
// de /api/auth/me — dont la requête porte le nouvel
// access_token et dont la réponse traverse le middleware —
// le cookie draco manquant ou invalide est réémis 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 et saveToken l'honorera après login frais).
const retourDemande = new URLSearchParams(
window.location.search).get("return_to");
// Auth enabled — check for existing session
if (this.hasSession() && !this.isTokenExpired()) {
if (this.hasSession() && !this.isTokenExpired() && !retourDemande) {
// BUG-123 : session déjà établie au démarrage (jeton encore
// valide) — si la page a été ouverte par /sso/authorize avec
// un return_to, l'aller-retour SSO doit se refermer ici
// aussi, pas seulement après un login frais (saveToken).
if (this._honorReturnTo()) return true;
this.showApp();
return true;
}
@@ -485,6 +547,16 @@ const AuthManager = {
if (res.ok) {
const user = await res.json();
sessionStorage.setItem(this.USER_KEY, JSON.stringify(user));
// BUG-123 : même obligation après restauration par
// refresh silencieux au démarrage — refreshAccessToken()
// ne passe pas par saveToken, donc sans cet appel le
// return_to d'un /sso/authorize restait sans effet et
// l'utilisateur demeurait sur l'accueil ObsiGate au lieu
// de revenir, connecté, à l'application demanderesse.
// NB : seuls les chemins de démarrage d'initAuth honorent
// le retour ; les refresh silencieux en cours de session
// ne doivent jamais rediriger.
if (this._honorReturnTo()) return true;
this.showApp();
return true;
}
+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.83.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": {
+534
View File
@@ -0,0 +1,534 @@
# tests/test_comptes_machine.py — HUB-13 (fusion #127)
# API d'administration des comptes machine-à-machine
# (/api/admin/machine/comptes), protégée par la clé dédiée
# DRACO_ADMIN_MACHINE_KEY : lecture/écriture, désactivation avec
# révocation des sessions, réinitialisations du mot de passe (avec
# changement forcé) et du MFA, suppression, journalisation d'audit.
import json
import os
import shutil
import tempfile
from pathlib import Path
import pytest
MACHINE_KEY = "cle-admin-machine-test"
MACHINE_HEADERS = {"X-Draco-Machine-Key": MACHINE_KEY,
"X-Draco-Actor": "hub-test"}
BASE = "/api/admin/machine/comptes"
@pytest.fixture
def machine_client():
"""TestClient avec auth active, données isolées, clés machine posées."""
tmp = Path(tempfile.mkdtemp())
data_dir = tmp / "data"
data_dir.mkdir()
from backend.auth.mfa import generate_secret
from backend.auth.password import hash_password
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",
},
"mfauser": {
"id": "user-mfa",
"username": "mfauser",
"display_name": "Utilisateur MFA",
"password_hash": hash_password("motdepasse-mfa"),
"role": "user",
"vaults": ["TestVault"],
"active": True,
"created_at": "2026-01-01T00:00:00",
"mfa_enabled": True,
"mfa_secret": generate_secret(),
"mfa_method": "totp",
"mfa_recovery_codes": ["hash-fictif"],
},
},
}
(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()
test_vault_path = os.path.abspath("test-vault")
os.chdir(str(tmp))
os.environ["VAULT_1_NAME"] = "TestVault"
os.environ["VAULT_1_PATH"] = test_vault_path
os.environ["OBSIGATE_AUTH_ENABLED"] = "true"
os.environ["OBSIGATE_WATCHER_ENABLED"] = "false"
os.environ["DRACO_ADMIN_MACHINE_KEY"] = MACHINE_KEY
os.environ["DRACO_SSO_MACHINE_KEY"] = "cle-sso-test"
os.environ["DRACO_SESSION_SECRET"] = "secret-draco-test"
from backend import draco_session
draco_session._revoked = None
draco_session._issued = None
import backend.main
backend.main._load_config = lambda: {"watcher_enabled": False}
from backend.main import app
from backend.indexer import build_index, index
import asyncio
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()
from fastapi.testclient import TestClient
client = TestClient(app)
yield client
if hasattr(client, "close"):
client.close()
loop.run_until_complete(asyncio.sleep(0))
draco_session._revoked = None
draco_session._issued = None
os.chdir(orig_cwd)
shutil.rmtree(str(tmp), ignore_errors=True)
for k in ["VAULT_1_NAME", "VAULT_1_PATH", "OBSIGATE_AUTH_ENABLED",
"OBSIGATE_WATCHER_ENABLED", "DRACO_ADMIN_MACHINE_KEY",
"DRACO_SSO_MACHINE_KEY", "DRACO_SESSION_SECRET"]:
os.environ.pop(k, None)
def _login(client, username, password):
return client.post("/api/auth/login",
json={"username": username, "password": password})
def _creer(client, username="nouveau", password="motdepasse-initial", **kw):
corps = {"username": username, "password": password,
"display_name": kw.pop("display_name", "Nouveau Compte"),
"role": kw.pop("role", "user")}
corps.update(kw)
return client.post(BASE, headers=MACHINE_HEADERS, json=corps)
# ── Protection par clé machine ──────────────────────────────────────────
class TestProtection:
def test_sans_cle_refuse(self, machine_client):
assert machine_client.get(BASE).status_code == 401
assert machine_client.post(
BASE, json={"username": "x1", "password": "motdepasse"}
).status_code == 401
def test_mauvaise_cle_refusee(self, machine_client):
resp = machine_client.get(
BASE, headers={"X-Draco-Machine-Key": "mauvaise-cle"})
assert resp.status_code == 401
def test_cle_sso_ne_suffit_pas(self, machine_client):
"""La clé des révocations (lecture) n'ouvre pas l'administration."""
resp = machine_client.get(
BASE, headers={"X-Draco-Machine-Key": "cle-sso-test"})
assert resp.status_code == 401
def test_session_admin_ne_suffit_pas(self, machine_client):
"""Même une session administratrice ordinaire est refusée."""
token = _login(machine_client, "admin", "chab30").json()["access_token"]
resp = machine_client.get(
BASE, headers={"Authorization": f"Bearer {token}"})
assert resp.status_code == 401
def test_non_configuree_inerte(self, machine_client, monkeypatch):
monkeypatch.delenv("DRACO_ADMIN_MACHINE_KEY")
resp = machine_client.get(BASE, headers=MACHINE_HEADERS)
assert resp.status_code == 404
# ── Lecture ─────────────────────────────────────────────────────────────
class TestLecture:
def test_liste(self, machine_client):
resp = machine_client.get(BASE, headers=MACHINE_HEADERS)
assert resp.status_code == 200
data = resp.json()
assert data["total"] >= 2
noms = [c["username"] for c in data["comptes"]]
assert "admin" in noms and "mfauser" in noms
def test_profil_etendu_sans_secret(self, machine_client):
resp = machine_client.get(f"{BASE}/mfauser", headers=MACHINE_HEADERS)
assert resp.status_code == 200
profil = resp.json()
assert profil["username"] == "mfauser"
assert profil["display_name"] == "Utilisateur MFA"
assert profil["language"] == "fr"
assert profil["avatar_present"] is False
assert profil["role"] == "user"
assert profil["active"] is True
assert profil["mfa_enabled"] is True
# Jamais de secret : ni le haché du mot de passe, ni le TOTP.
brut = resp.text
assert "password_hash" not in brut
assert "mfa_secret" not in brut
assert "mfa_recovery" not in brut
def test_compte_inconnu_404(self, machine_client):
resp = machine_client.get(f"{BASE}/personne", headers=MACHINE_HEADERS)
assert resp.status_code == 404
# ── Création / modification ─────────────────────────────────────────────
class TestCreationModification:
def test_creation_puis_lecture(self, machine_client):
resp = _creer(machine_client)
assert resp.status_code == 201, resp.text
profil = resp.json()
assert profil["username"] == "nouveau"
assert profil["must_change_password"] is True
lu = machine_client.get(f"{BASE}/nouveau", headers=MACHINE_HEADERS)
assert lu.status_code == 200
assert lu.json()["display_name"] == "Nouveau Compte"
# Le compte créé se connecte, avec changement forcé signalé.
login = _login(machine_client, "nouveau", "motdepasse-initial")
assert login.status_code == 200
assert login.json()["user"]["must_change_password"] is True
def test_creation_doublon_409(self, machine_client):
assert _creer(machine_client).status_code == 201
assert _creer(machine_client).status_code == 409
assert _creer(machine_client, username="admin").status_code == 409
def test_modification(self, machine_client):
assert _creer(machine_client).status_code == 201
resp = machine_client.patch(
f"{BASE}/nouveau", headers=MACHINE_HEADERS,
json={"display_name": "Nom Modifié", "role": "admin"})
assert resp.status_code == 200
assert resp.json()["display_name"] == "Nom Modifié"
assert resp.json()["role"] == "admin"
def test_modification_inconnue_404(self, machine_client):
resp = machine_client.patch(
f"{BASE}/personne", headers=MACHINE_HEADERS,
json={"display_name": "X"})
assert resp.status_code == 404
# ── Désactivation / réactivation ────────────────────────────────────────
class TestDesactivation:
def test_desactivation_revoque_puis_reactivation(self, machine_client):
from backend import draco_session
assert _creer(machine_client).status_code == 201
login = _login(machine_client, "nouveau", "motdepasse-initial")
assert login.status_code == 200
token_natif = login.json()["access_token"]
profil = machine_client.get(
f"{BASE}/nouveau", headers=MACHINE_HEADERS).json()
token_draco, jti, _exp = draco_session.issue_token(
{"id": profil["id"], "username": "nouveau",
"display_name": "Nouveau Compte"})
assert draco_session.verify_token(token_draco) is not None
resp = machine_client.post(f"{BASE}/nouveau/desactiver",
headers=MACHINE_HEADERS)
assert resp.status_code == 200
assert resp.json()["active"] is False
# Connexion refusée, ancienne session native refusée,
# jti draco révoqué et publié dans la liste des révocations.
assert _login(machine_client, "nouveau",
"motdepasse-initial").status_code == 401
me = machine_client.get(
"/api/auth/me",
headers={"Authorization": f"Bearer {token_natif}"})
assert me.status_code == 401
assert draco_session.verify_token(token_draco) is None
revocations = machine_client.get(
"/api/sso/revocations",
headers={"X-Draco-Machine-Key": "cle-sso-test"})
assert revocations.status_code == 200
assert jti in [r["jti"] for r in revocations.json()["revoked"]]
resp = machine_client.post(f"{BASE}/nouveau/reactiver",
headers=MACHINE_HEADERS)
assert resp.status_code == 200
assert resp.json()["active"] is True
# Réactivation : nouvelle connexion OK, ancien jti toujours révoqué.
assert _login(machine_client, "nouveau",
"motdepasse-initial").status_code == 200
assert draco_session.verify_token(token_draco) is None
# ── Réinitialisation du mot de passe ────────────────────────────────────
class TestReinitialisationMotDePasse:
def test_ancien_refuse_nouveau_accepte_changement_force(
self, machine_client):
assert _creer(machine_client).status_code == 201
resp = machine_client.post(
f"{BASE}/nouveau/reinitialiser-mot-de-passe",
headers=MACHINE_HEADERS,
json={"password": "nouveau-mot-de-passe"})
assert resp.status_code == 200
assert resp.json()["must_change_password"] is True
assert _login(machine_client, "nouveau",
"motdepasse-initial").status_code == 401
login = _login(machine_client, "nouveau", "nouveau-mot-de-passe")
assert login.status_code == 200
assert login.json()["user"]["must_change_password"] is True
# Le changement effectif par l'utilisateur efface le marqueur.
token = login.json()["access_token"]
changement = machine_client.post(
"/api/auth/change-password",
headers={"Authorization": f"Bearer {token}"},
json={"current_password": "nouveau-mot-de-passe",
"new_password": "mot-de-passe-choisi"})
assert changement.status_code == 200, changement.text
login2 = _login(machine_client, "nouveau", "mot-de-passe-choisi")
assert login2.status_code == 200
assert login2.json()["user"]["must_change_password"] is False
# ── Réinitialisation du MFA ─────────────────────────────────────────────
class TestReinitialisationMfa:
def test_mfa_reinitialise(self, machine_client):
# Avant : la connexion exige le second facteur.
login = _login(machine_client, "mfauser", "motdepasse-mfa")
assert login.status_code == 200
assert login.json().get("mfa_required") is True
resp = machine_client.post(f"{BASE}/mfauser/reinitialiser-mfa",
headers=MACHINE_HEADERS)
assert resp.status_code == 200
assert resp.json()["mfa_enabled"] is False
# Après : connexion directe, sans second facteur.
login = _login(machine_client, "mfauser", "motdepasse-mfa")
assert login.status_code == 200
assert "access_token" in login.json()
# ── Suppression ─────────────────────────────────────────────────────────
class TestSuppression:
def test_suppression(self, machine_client):
assert _creer(machine_client).status_code == 201
resp = machine_client.delete(f"{BASE}/nouveau",
headers=MACHINE_HEADERS)
assert resp.status_code == 200
assert machine_client.get(
f"{BASE}/nouveau", headers=MACHINE_HEADERS).status_code == 404
assert _login(machine_client, "nouveau",
"motdepasse-initial").status_code == 401
def test_suppression_inconnue_404(self, machine_client):
resp = machine_client.delete(f"{BASE}/personne",
headers=MACHINE_HEADERS)
assert resp.status_code == 404
# ── Sessions draco (HUB-22) ─────────────────────────────────────────────
def _emettre(client, username, nombre=1):
"""Émet ``nombre`` jetons draco pour un compte ; retourne
[(jeton, jti, exp), …]."""
from backend import draco_session
profil = client.get(f"{BASE}/{username}",
headers=MACHINE_HEADERS).json()
return [draco_session.issue_token(
{"id": profil["id"], "username": username,
"display_name": profil["display_name"]})
for _ in range(nombre)]
class TestSessions:
def test_liste_sessions(self, machine_client):
from datetime import datetime
assert _creer(machine_client).status_code == 201
emis = _emettre(machine_client, "nouveau", 2)
resp = machine_client.get(f"{BASE}/nouveau/sessions",
headers=MACHINE_HEADERS)
assert resp.status_code == 200
data = resp.json()
assert data["username"] == "nouveau"
assert len(data["sessions"]) == 2
jtis = [s["jti"] for s in data["sessions"]]
assert jtis == [j for _t, j, _e in emis] # exp croissant
for session, (_t, _j, exp) in zip(data["sessions"], emis):
assert session["exp"] == exp
assert session["revoquee"] is False
echeance = datetime.fromisoformat(session["expire_le"])
assert echeance.tzinfo is not None
assert int(echeance.timestamp()) == exp
def test_liste_sessions_vide_et_compte_inconnu(self, machine_client):
resp = machine_client.get(f"{BASE}/mfauser/sessions",
headers=MACHINE_HEADERS)
assert resp.status_code == 200
assert resp.json() == {"username": "mfauser", "sessions": []}
resp = machine_client.get(f"{BASE}/personne/sessions",
headers=MACHINE_HEADERS)
assert resp.status_code == 404
def test_revocation_unitaire(self, machine_client):
from backend import draco_session
assert _creer(machine_client).status_code == 201
(t1, jti1, _e1), (t2, _jti2, _e2) = _emettre(
machine_client, "nouveau", 2)
resp = machine_client.post(
f"{BASE}/nouveau/sessions/{jti1}/revoquer",
headers=MACHINE_HEADERS)
assert resp.status_code == 200
assert resp.json() == {"jti": jti1, "revoquee": True}
# La session révoquée est morte, l'autre vit ; la liste la
# signale comme révoquée.
assert draco_session.verify_token(t1) is None
assert draco_session.verify_token(t2) is not None
sessions = machine_client.get(
f"{BASE}/nouveau/sessions", headers=MACHINE_HEADERS).json()
etats = {s["jti"]: s["revoquee"] for s in sessions["sessions"]}
assert etats[jti1] is True
def test_revocation_cross_utilisateur_404(self, machine_client):
from backend import draco_session
assert _creer(machine_client).status_code == 201
(token, jti, _e), = _emettre(machine_client, "nouveau", 1)
# Le jti de « nouveau » demandé sous « mfauser » : 404, et la
# session de « nouveau » reste valide (jamais de révocation
# cross-utilisateur).
resp = machine_client.post(
f"{BASE}/mfauser/sessions/{jti}/revoquer",
headers=MACHINE_HEADERS)
assert resp.status_code == 404
assert draco_session.verify_token(token) is not None
# Jti inconnu et compte inconnu : 404 également.
resp = machine_client.post(
f"{BASE}/nouveau/sessions/jti-inconnu/revoquer",
headers=MACHINE_HEADERS)
assert resp.status_code == 404
resp = machine_client.post(
f"{BASE}/personne/sessions/{jti}/revoquer",
headers=MACHINE_HEADERS)
assert resp.status_code == 404
def test_revoquer_toutes_sans_desactiver(self, machine_client):
from backend import draco_session
assert _creer(machine_client).status_code == 201
emis = _emettre(machine_client, "nouveau", 2)
(autre_token, _j, _e), = _emettre(machine_client, "mfauser", 1)
resp = machine_client.post(
f"{BASE}/nouveau/sessions/revoquer-toutes",
headers=MACHINE_HEADERS)
assert resp.status_code == 200
assert resp.json() == {"revoquees": 2}
for token, _jti, _exp in emis:
assert draco_session.verify_token(token) is None
# Les sessions des autres comptes ne sont pas touchées.
assert draco_session.verify_token(autre_token) is not None
# Plus rien à révoquer : le registre a été vidé pour ce compte
# (avant toute nouvelle connexion, qui émettrait une session).
resp = machine_client.post(
f"{BASE}/nouveau/sessions/revoquer-toutes",
headers=MACHINE_HEADERS)
assert resp.json() == {"revoquees": 0}
# Déconnexion globale ≠ désactivation : le compte reste actif
# et une nouvelle connexion fonctionne.
profil = machine_client.get(f"{BASE}/nouveau",
headers=MACHINE_HEADERS).json()
assert profil["active"] is True
assert _login(machine_client, "nouveau",
"motdepasse-initial").status_code == 200
def test_sessions_protegees_par_cle_machine(self, machine_client,
monkeypatch):
assert machine_client.get(
f"{BASE}/nouveau/sessions").status_code == 401
assert machine_client.post(
f"{BASE}/nouveau/sessions/un-jti/revoquer").status_code == 401
assert machine_client.post(
f"{BASE}/nouveau/sessions/revoquer-toutes").status_code == 401
monkeypatch.delenv("DRACO_ADMIN_MACHINE_KEY")
assert machine_client.get(
f"{BASE}/nouveau/sessions",
headers=MACHINE_HEADERS).status_code == 404
def test_sessions_journalisees(self, machine_client):
assert _creer(machine_client).status_code == 201
(_t, jti, _e), = _emettre(machine_client, "nouveau", 1)
machine_client.post(f"{BASE}/nouveau/sessions/{jti}/revoquer",
headers=MACHINE_HEADERS)
machine_client.post(f"{BASE}/nouveau/sessions/revoquer-toutes",
headers=MACHINE_HEADERS)
audit_file = Path("data/audit.log")
entrees = [json.loads(ligne)
for ligne in audit_file.read_text(
encoding="utf-8").splitlines() if ligne.strip()]
actions = {(e["action"], e["cible"]) for e in entrees
if e.get("cible") == "nouveau"}
assert ("session_revoquee", "nouveau") in actions
assert ("sessions_revoquees", "nouveau") in actions
# ── Journalisation ──────────────────────────────────────────────────────
class TestJournalisation:
def test_actions_consignees(self, machine_client):
assert _creer(machine_client).status_code == 201
machine_client.post(f"{BASE}/nouveau/desactiver",
headers=MACHINE_HEADERS)
audit_file = Path("data/audit.log")
assert audit_file.exists()
entrees = [json.loads(ligne)
for ligne in audit_file.read_text(
encoding="utf-8").splitlines() if ligne.strip()]
actions = {(e["action"], e["cible"]) for e in entrees
if e.get("cible") == "nouveau"}
assert ("compte_cree", "nouveau") in actions
assert ("compte_desactive", "nouveau") in actions
for e in entrees:
if e.get("cible") == "nouveau":
assert e["acteur"] == "hub-test"
assert e["timestamp"]
+153
View File
@@ -101,6 +101,96 @@ def test_barre_v030_liens_hub_menu_compte():
assert "v0.3.0" in html
def test_barre_v060_entree_administration():
# Barre v0.6.0 (dracodev-commons, demande de Bruno du
# 2026-11-06) : entrée « Administration » du menu compte —
# lien Hub <hub>/admin à visibilité conditionnelle. Le JS
# vendangé la construit (data-hub-link="admin"), masquée tant
# que l'hôte n'affirme pas le statut d'administrateur
# (cfg.admin / DRACO_BAR.setAdmin) ; le CSS porte la règle
# [hidden] qui la masque malgré le display:flex des items.
# Branchement hôte : index.html affirme le statut depuis le
# rôle global de /api/auth/me — la définition même de
# l'administrateur de suite (garde /admin/* du Hub).
js = (FRONTEND / "draco-barre.js").read_text(encoding="utf-8")
assert 'data-hub-link", "admin"' in js
assert '"Administration"' in js
assert "setAdmin" in js
assert "compteAdmin = cfg.admin === true" in js
css = _css()
assert ".draco-menu-item[hidden]" in css
html = _index()
assert 'window.DRACO_BAR.setAdmin(u.role === "admin")' in html
# Le fetch d'amorçage d'index.html tourne avant toute
# connexion : le branchement qui couvre la connexion par le
# formulaire vit dans renderUserSection() (js/auth.js — le
# frontend servi est en modules ES ; le app.js monolithique
# à la racine n'est plus chargé), appelée par showApp() pour
# toutes les sessions établies, au même endroit que la
# rangée d'administration native.
auth_js = (FRONTEND / "js" / "auth.js").read_text(encoding="utf-8")
assert "window.DRACO_BAR.setAdmin(user.role === \"admin\")" in auth_js
assert "window.DRACO_BAR.setAdmin(false)" in auth_js
def test_barre_v070_setuser_et_retour_sso_restauration():
# Barre v0.7.0 (dracodev-commons) + BUG-123/BUG-124 (chantier
# « entrée SSO de bout en bout », écarts constatés par Bruno le
# 2026-11-08) :
# - BUG-124 : le JS vendangé expose DRACO_BAR.setUser ; l'hôte
# le branche dans renderUserSection() (toutes les sessions
# établies, comme setAdmin) et dans le fetch d'amorçage
# d'index.html — sans quoi le menu compte affichait
# « Compte » jusqu'au rechargement après un login SPA.
# - BUG-123 : _honorReturnTo signale la redirection (return)
# et initAuth() l'invoque sur ses deux chemins de
# restauration au démarrage (jeton valide, refresh
# silencieux) — sans quoi l'aller-retour SSO ne se refermait
# pas quand la session ObsiGate existait déjà.
js = (FRONTEND / "draco-barre.js").read_text(encoding="utf-8")
assert "setUser: function (u)" in js
assert "v0.7.0" in js
html = _index()
assert "window.DRACO_BAR.setUser(nom)" in html
auth_js = (FRONTEND / "js" / "auth.js").read_text(encoding="utf-8")
assert "window.DRACO_BAR.setUser(name || null)" in auth_js
assert "window.DRACO_BAR.setUser(null)" in auth_js
# BUG-123 : le retour est honoré à la restauration, et
# _honorReturnTo rapporte s'il a redirigé.
assert "if (this._honorReturnTo()) return true;" in auth_js
assert auth_js.count("if (this._honorReturnTo()) return true;") == 2
assert "window.location.replace(rt);\n return true;" in auth_js
# Le login frais continue de passer par saveToken.
assert "this._honorReturnTo();\n }," in auth_js
def test_retour_sso_refresh_force_bug_125():
# BUG-125 (suite du chantier « entrée SSO », retest réel de
# Bruno le 2026-11-08 après BUG-123) : à l'arrivée d'un
# /sso/authorize (return_to présent), le chemin court
# d'initAuth (« session valide en sessionStorage ») repartait
# sans aucun échange serveur — donc sans réémission du
# cookie draco_session par DracoRenewalMiddleware. Cookies
# access_token et draco_session absents (sessionStorage
# encore « valide ») : le pont de l'application sœur ne
# recevait aucun jeton et déposait l'utilisateur devant son
# formulaire, sans message (reproduit en navigateur réel
# dans la pile « conteneur dev réel », requête du pont
# journalisée sans cookie draco). Garde : le chemin court
# est conditionné à l'ABSENCE de return_to ; avec return_to,
# initAuth passe par le refresh silencieux + /api/auth/me
# (réémission du cookie) avant d'honorer le retour — le
# nombre d'appels _honorReturnTo des chemins de restauration
# reste celui de BUG-123 (2).
auth_js = (FRONTEND / "js" / "auth.js").read_text(encoding="utf-8")
assert 'get("return_to")' in auth_js
assert "&& !retourDemande) {" in auth_js
bloc = auth_js.split("async initAuth()", 1)[1]
assert bloc.index("!retourDemande") < bloc.index(
"await this.refreshAccessToken()")
assert auth_js.count("if (this._honorReturnTo()) return true;") == 2
def test_panneau_spark_integre_218():
# #218 : le bouton Spark de la barre ouvre le panneau de l'agent
# commun (mêmes assets partagés que TikTak / Flowdeck / Kanbante).
@@ -184,6 +274,16 @@ def test_urls_ecosysteme_via_injection_hote_223():
assert "DRACO_URLS[a.dataset.app]" in html
def test_barre_deconnexion_branchee():
# BUG-122 (fusion #141) : la barre d'ObsiGate elle-même branche
# l'action « deconnexion » sur son point d'entrée de déconnexion
# globale (GET /sso/logout, retour à la racine) — avant, le clic
# ne faisait rien ici non plus.
html = _index()
assert 'act === "deconnexion"' in html
assert '"/sso/logout?return_to="' in html
def test_rail_mobile_vers_le_vrai_hamburger():
html = _index()
assert 'matchMedia("(max-width: 768px)")' in html
@@ -206,3 +306,56 @@ def test_panneau_version_service_affichee_225():
# La ligne naît masquée et n'est démasquée qu'avec une version lue.
assert 'class="draco-panneau-version"' in panneau
assert "versionEl.hidden = false" in panneau
def test_barre_v040_icones_monoline_menu_compte():
# v0.4.0 (HUB-11, fusion #125) : les items du menu compte
# portent des icônes SVG monoline construites en DOM, dans le
# style des icônes du rail de la console — aucun emoji, aucune
# icône pleine. La vendange reste verbatim commons.
js = (FRONTEND / "draco-barre.js").read_text(encoding="utf-8")
assert "MENU_ICONES" in js
for nom in ("telecharger", "a-propos", "aide", "profil", "deconnexion"):
assert nom in js
assert "draco-menu-icone" in js
assert "stroke: currentColor" not in js # attributs posés en DOM
assert 'setAttribute("stroke", "currentColor")' in js
assert 'setAttribute("fill", "none")' in js
css = _css()
assert ".draco-menu-icone" in css
bloc = css.split(".draco-menu-icone {", 1)[1].split("}", 1)[0]
assert "width: 18px" in bloc
assert "var(--ink-2)" in bloc
def test_barre_v041_correctif_icones_espace_de_noms_svg():
# v0.4.1 (correctif fusion #125) : les icônes du menu compte
# sont créées via createElementNS (espace de noms SVG). En
# v0.4.0, createElement() les créait dans l'espace de noms
# HTML : jamais dessinées par le navigateur, libellés
# décalés d'un cran d'icône sans aucun glyphe.
js = (FRONTEND / "draco-barre.js").read_text(encoding="utf-8")
assert 'createElementNS(SVG_NS, "svg")' in js
assert "createElementNS(SVG_NS, spec[0])" in js
assert 'createElement("svg")' not in js
assert "createElement(spec[0])" not in js
def test_barre_v050_theme_commun_hub18():
# v0.5.0 (HUB-18, fusion #132) : la barre apprend la préférence
# de thème du Hub et l'applique à l'ouverture. La vendange reste
# verbatim commons ; l'initialisation propre à ObsiGate vit dans
# app.js (écouteur draco:theme → applyTheme).
js = (FRONTEND / "draco-barre.js").read_text(encoding="utf-8")
assert "api/profil/theme" in js
assert 'credentials: "include"' in js
assert "draco-theme-hub" in js
assert "THEME_CACHE_TTL_MS" in js
assert 'CustomEvent("draco:theme"' in js
assert "themePref" in js and "themeMode" in js
# Aucun nom de Hub figé de plus que les défauts/dérivations
# documentés : l'URL du Hub reste la résolue de la barre.
assert "resolvedUrls.hub" in js
app = (FRONTEND / "app.js").read_text(encoding="utf-8")
assert 'addEventListener("draco:theme"' in app
assert "barre.themeMode" in app
+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"
+97
View File
@@ -18,9 +18,13 @@ def _draco_env(monkeypatch, tmp_path):
monkeypatch.setenv("DRACO_SESSION_SECRET", "secret-de-test")
monkeypatch.setattr(draco_session, "REVOKED_FILE",
tmp_path / "draco_revoked.json")
monkeypatch.setattr(draco_session, "ISSUED_FILE",
tmp_path / "draco_issued.json")
draco_session._revoked = None
draco_session._issued = None
yield
draco_session._revoked = None
draco_session._issued = None
# ── Jeton : émission / vérification ─────────────────────────────────────
@@ -185,6 +189,44 @@ def test_sso_authorize_liste_blanche(client):
assert r.headers["location"] == "/" # refusé, pas de relais
# ── Déconnexion globale navigable (BUG-122, fusion #141) ────────────────
def test_sso_logout_revoque_et_redirige(admin_client):
token = _token_depuis_login(admin_client)
assert draco_session.verify_token(token)
r = admin_client.get(
"/sso/logout",
params={"return_to": "https://tiktak.dracodev.net/"},
headers={"Cookie": f"draco_session={token}"},
follow_redirects=False)
assert r.status_code == 302
assert r.headers["location"] == "https://tiktak.dracodev.net/"
assert draco_session.verify_token(token) is None # jti révoqué
cookie = _draco_cookie(r) # cookie effacé
assert cookie is not None and "Max-Age=0" in cookie
def test_sso_logout_liste_blanche(admin_client):
r = admin_client.get("/sso/logout",
params={"return_to": "https://evil.com/phish"},
follow_redirects=False)
assert r.status_code == 302
assert r.headers["location"] == "/" # refusé, pas de relais
r = admin_client.get("/sso/logout", follow_redirects=False)
assert r.status_code == 302
assert r.headers["location"] == "/" # sans return_to
def test_sso_logout_sans_session_idempotent(client):
# Aucun cookie : la route reste une redirection propre (les autres
# applications y naviguent même si la session a déjà expiré).
r = client.get("/sso/logout",
params={"return_to": "https://hub.dracodev.net/"},
follow_redirects=False)
assert r.status_code == 302
assert r.headers["location"] == "https://hub.dracodev.net/"
# ── Validation locale (ACC-3.2, #9) ──────────────────────────────────────
def test_me_avec_cookie_draco_seul(admin_client):
@@ -232,3 +274,58 @@ def test_revocations_protegees_par_cle_machine(admin_client, monkeypatch):
headers={"X-Draco-Machine-Key": "cle-machine"})
assert r.status_code == 200
assert {"jti": jti, "exp": exp} in r.json()["revoked"]
# ── Registre des sessions (HUB-22, #227) ────────────────────────────────
AUTRE = {"id": "user-2", "username": "autre", "display_name": "Autre"}
def test_sessions_emises_listees_triees_et_marquees():
_t1, jti1, exp1 = draco_session.issue_token(USER)
t2, jti2, exp2 = draco_session.issue_token(USER)
draco_session.issue_token(AUTRE) # autre sub : exclu
draco_session.revoke(jti2, exp2)
sessions = draco_session.issued_sessions_for_user("admin-1")
assert [s["jti"] for s in sessions] == [jti1, jti2] # exp croissant
assert sessions[0] == {"jti": jti1, "exp": exp1, "revoquee": False}
assert sessions[1] == {"jti": jti2, "exp": exp2, "revoquee": True}
assert draco_session.verify_token(t2) is None # cohérent
def test_sessions_emises_expirees_purgees():
now = int(time.time())
with draco_session._lock:
store = draco_session._load_issued()
store["admin-1"] = {"ancien": now - 10, "frais": now + 600}
assert [s["jti"] for s in
draco_session.issued_sessions_for_user("admin-1")] == ["frais"]
with draco_session._lock:
assert "ancien" not in draco_session._load_issued()["admin-1"]
assert draco_session.issued_sessions_for_user("personne") == []
assert draco_session.issued_sessions_for_user("") == []
def test_revoquer_une_session_appartenante():
token, jti, _exp = draco_session.issue_token(USER)
assert draco_session.revoke_one_for_user("admin-1", jti) is True
assert draco_session.verify_token(token) is None
assert draco_session.is_revoked(jti)
def test_revoquer_une_session_cross_utilisateur_refusee():
token, jti, _exp = draco_session.issue_token(USER)
# Le jti existe, mais pas dans l'ensemble émis de cet autre sub.
assert draco_session.revoke_one_for_user("user-2", jti) is False
assert draco_session.verify_token(token) is not None
assert draco_session.revoke_one_for_user("admin-1", "inconnu") is False
assert draco_session.revoke_one_for_user("", jti) is False
def test_revoquer_une_session_expiree_refusee():
now = int(time.time())
with draco_session._lock:
draco_session._load_issued()["admin-1"] = {"perime": now - 10}
assert draco_session.revoke_one_for_user("admin-1", "perime") is False
assert not draco_session.is_revoked("perime")
+291
View File
@@ -0,0 +1,291 @@
# tests/test_hub_roles.py
# Hub HUB-19 (propagation, #228) — Rôles par application : client du
# registre du Hub (parsing, cache 60 s par sub, repli systématique) et
# effets sur le chemin draco d'ObsiGate (refus « aucun », garde
# administrateur des routes /api/auth/admin/* pour le canal draco).
# Contrat posé par l'hôte pilote ShaarIt 0.7.0 (décision D3(a)).
import io
import json
import time
import urllib.error
import pytest
from backend import draco_session, hub_roles
USER = {"id": "admin-1", "username": "admin", "display_name": "Admin"}
USER_SIMPLE = {"id": "user-1", "username": "normaluser", "display_name": "normal"}
@pytest.fixture(autouse=True)
def _hub_env(monkeypatch):
"""Cache vierge + Hub de test explicite pour chaque test."""
hub_roles.reinitialiser_cache()
monkeypatch.setenv("DRACO_HUB_URL", "https://hub-test.dracodev.net")
yield
hub_roles.reinitialiser_cache()
def _reponse(role, statut=200, corps=None):
"""Fausse réponse urlopen portant un payload du contrat D3(a)."""
if corps is None:
corps = {"app": "obsigate", "sub": "admin-1", "role": role,
"explicite": True, "ttl_secondes": 60}
charge = json.dumps(corps).encode("utf-8")
class _Resp:
status = statut
def read(self):
return charge
def __enter__(self):
return self
def __exit__(self, *exc):
return False
return _Resp()
def _patch_hub(monkeypatch, role, appels):
"""Remplace la consultation HTTP par un rôle fixe (compte les appels)."""
def _faux(url, cookie):
appels.append((url, cookie))
return role
monkeypatch.setattr(hub_roles, "_consulter_hub", _faux)
# ── Client : parsing du contrat ─────────────────────────────────────────
def test_consultation_parse_le_contrat(monkeypatch):
vu = {}
def _faux_urlopen(requete, timeout=None):
vu["url"] = requete.full_url
vu["cookie"] = requete.get_header("Cookie")
vu["accept"] = requete.get_header("Accept")
vu["timeout"] = timeout
return _reponse("administrateur")
monkeypatch.setattr(hub_roles.urllib.request, "urlopen", _faux_urlopen)
role = hub_roles.role_pour("admin-1", "draco_session=jeton; autre=1")
assert role == "administrateur"
assert vu["url"] == "https://hub-test.dracodev.net/api/roles/obsigate"
assert vu["cookie"] == "draco_session=jeton; autre=1" # Cookie complet relayé
assert vu["accept"] == "application/json"
assert vu["timeout"] == 2 # délai du contrat
@pytest.mark.parametrize("role", ["aucun", "utilisateur", "administrateur"])
def test_consultation_roles_reconnus(monkeypatch, role):
monkeypatch.setattr(hub_roles.urllib.request, "urlopen",
lambda requete, timeout=None: _reponse(role))
assert hub_roles.role_pour("admin-1", "c=1") == role
def test_consultation_role_hors_contrat_inconnu(monkeypatch):
monkeypatch.setattr(hub_roles.urllib.request, "urlopen",
lambda requete, timeout=None: _reponse("super-admin"))
assert hub_roles.role_pour("admin-1", "c=1") is None
def test_consultation_json_illisible_inconnu(monkeypatch):
class _Resp:
status = 200
def read(self):
return b"pas du json"
def __enter__(self):
return self
def __exit__(self, *exc):
return False
monkeypatch.setattr(hub_roles.urllib.request, "urlopen",
lambda requete, timeout=None: _Resp())
assert hub_roles.role_pour("admin-1", "c=1") is None
def test_consultation_erreur_http_inconnu(monkeypatch):
def _erreur(requete, timeout=None):
raise urllib.error.HTTPError(requete.full_url, 500, "boom", {}, io.BytesIO(b""))
monkeypatch.setattr(hub_roles.urllib.request, "urlopen", _erreur)
assert hub_roles.role_pour("admin-1", "c=1") is None
def test_consultation_hub_injoignable_inconnu(monkeypatch):
def _panne(requete, timeout=None):
raise urllib.error.URLError("injoignable")
monkeypatch.setattr(hub_roles.urllib.request, "urlopen", _panne)
assert hub_roles.role_pour("admin-1", "c=1") is None
def test_url_hub_derivee_par_hote_soeur(monkeypatch):
# Sans variable explicite : dérivation depuis l'hôte de l'agent
# (agent-dev → hub-dev), comme la barre commune (#223).
monkeypatch.delenv("DRACO_HUB_URL")
monkeypatch.setenv("DRACO_AGENT_URL", "https://agent-dev.dracodev.net")
appels = []
_patch_hub(monkeypatch, "utilisateur", appels)
assert hub_roles.role_pour("admin-1", "c=1") == "utilisateur"
assert appels[0][0] == "https://hub-dev.dracodev.net/api/roles/obsigate"
def test_url_hub_defaut_officiel(monkeypatch):
monkeypatch.delenv("DRACO_HUB_URL")
monkeypatch.delenv("DRACO_AGENT_URL", raising=False)
monkeypatch.delenv("AGENT_EVENEMENTS_URL", raising=False)
appels = []
_patch_hub(monkeypatch, "utilisateur", appels)
hub_roles.role_pour("admin-1", "c=1")
assert appels[0][0] == "https://hub.dracodev.net/api/roles/obsigate"
# ── Client : cache 60 s par sub, horodatage avant l'appel ──────────────
def test_cache_par_sub_et_ttl(monkeypatch):
appels = []
_patch_hub(monkeypatch, "utilisateur", appels)
assert hub_roles.role_pour("admin-1", "c=1") == "utilisateur"
assert hub_roles.role_pour("admin-1", "c=1") == "utilisateur"
assert len(appels) == 1 # 2e lecture : cache
assert hub_roles.role_pour("user-1", "c=2") == "utilisateur"
assert len(appels) == 2 # autre sub : nouvel appel
# TTL expiré → nouvel appel.
hub_roles._cache_at = time.monotonic() - hub_roles.CACHE_TTL_SECONDS - 1
assert hub_roles.role_pour("admin-1", "c=1") == "utilisateur"
assert len(appels) == 3
def test_echec_conserve_ancien_cache_sans_rafale(monkeypatch):
appels = []
_patch_hub(monkeypatch, "administrateur", appels)
assert hub_roles.role_pour("admin-1", "c=1") == "administrateur"
assert len(appels) == 1
# Le Hub tombe ; le TTL expire : un appel est tenté, échoue, et
# l'horodatage posé avant l'appel empêche la rafale — l'ancien
# rôle connu n'est ni effacé ni réinterrogé aussitôt.
hub_roles._cache_at = time.monotonic() - hub_roles.CACHE_TTL_SECONDS - 1
_patch_hub(monkeypatch, None, appels)
assert hub_roles.role_pour("user-1", "c=2") is None
assert len(appels) == 2
# Dans la fenêtre qui suit l'échec, l'ancien cache sert toujours.
assert hub_roles.role_pour("admin-1", "c=1") == "administrateur"
assert len(appels) == 2
def test_sub_vide_aucun_appel(monkeypatch):
appels = []
_patch_hub(monkeypatch, "utilisateur", appels)
assert hub_roles.role_pour("", "c=1") is None
assert appels == []
# ── Intégration : chemin draco (admin_client, secret draco posé) ──────
@pytest.fixture()
def _draco_env(monkeypatch, tmp_path):
monkeypatch.setenv("DRACO_SESSION_SECRET", "secret-de-test")
monkeypatch.setattr(draco_session, "REVOKED_FILE",
tmp_path / "draco_revoked.json")
monkeypatch.setattr(draco_session, "ISSUED_FILE",
tmp_path / "draco_issued.json")
draco_session._revoked = None
draco_session._issued = None
yield
draco_session._revoked = None
draco_session._issued = None
def _pose_cookie_draco(client, user):
token, _jti, _exp = draco_session.issue_token(user)
client.cookies.set("draco_session", token)
return token
def test_draco_aucun_refuse_session_explicite(admin_client, _draco_env, monkeypatch):
appels = []
_patch_hub(monkeypatch, "aucun", appels)
_pose_cookie_draco(admin_client, USER)
r = admin_client.get("/api/auth/me")
assert r.status_code == 403
assert "niveau « aucun »" in r.json()["detail"]
assert "registre des rôles du Hub" in r.json()["detail"]
assert appels and appels[0][1].find("draco_session=") >= 0 # Cookie relayé
def test_draco_aucun_mais_connexion_native_intacte(admin_client, _draco_env, monkeypatch):
# L'authentification native (émettrice, accès de secours) n'est
# jamais touchée par le registre : le login par mot de passe du
# même compte passe, même avec un niveau « aucun » au Hub.
_patch_hub(monkeypatch, "aucun", [])
r = admin_client.post("/api/auth/login",
json={"username": "admin", "password": "chab30"})
assert r.status_code == 200, r.text
# Et la session native ainsi établie ouvre /me (canal natif, le
# rôle du Hub ne s'applique pas).
r = admin_client.get("/api/auth/me")
assert r.status_code == 200, r.text
assert r.json()["username"] == "admin"
def test_draco_role_inconnu_comportement_actuel(admin_client, _draco_env, monkeypatch):
_patch_hub(monkeypatch, None, []) # Hub injoignable
_pose_cookie_draco(admin_client, USER)
r = admin_client.get("/api/auth/me")
assert r.status_code == 200, r.text
assert r.json()["username"] == "admin"
# Canal draco + rôle inconnu : les routes admin gardent les
# règles actuelles (le rôle local admin suffit).
r = admin_client.get("/api/auth/admin/users")
assert r.status_code == 200, r.text
def test_draco_utilisateur_admin_local_refuse_admin(admin_client, _draco_env, monkeypatch):
# Compte local admin authentifié par draco, mais niveau Hub
# « utilisateur » : /api/auth/admin/* exige « administrateur ».
_patch_hub(monkeypatch, "utilisateur", [])
_pose_cookie_draco(admin_client, USER)
r = admin_client.get("/api/auth/me")
assert r.status_code == 200, r.text # session draco OK
r = admin_client.get("/api/auth/admin/users")
assert r.status_code == 403
assert "administrateur" in r.json()["detail"]
def test_draco_administrateur_hub_admin_ok(admin_client, _draco_env, monkeypatch):
_patch_hub(monkeypatch, "administrateur", [])
_pose_cookie_draco(admin_client, USER)
r = admin_client.get("/api/auth/admin/users")
assert r.status_code == 200, r.text
assert any(u["username"] == "admin" for u in r.json())
def test_draco_utilisateur_simple_admin_refuse_comme_avant(admin_client, _draco_env, monkeypatch):
# Compte local non admin, niveau Hub « administrateur » : le
# registre n'élève aucun privilège local — refus par la règle
# actuelle (rôle local), comme avant HUB-19.
_patch_hub(monkeypatch, "administrateur", [])
_pose_cookie_draco(admin_client, USER_SIMPLE)
r = admin_client.get("/api/auth/admin/users")
assert r.status_code == 403
assert r.json()["detail"] == "Accès admin requis"
def test_natif_admin_sans_draco_jamais_bloque_par_hub(admin_client, _draco_env, monkeypatch):
# Session native (login) + niveau Hub « utilisateur » : le canal
# n'est pas draco, la garde du registre ne s'applique pas.
_patch_hub(monkeypatch, "utilisateur", [])
r = admin_client.post("/api/auth/login",
json={"username": "admin", "password": "chab30"})
assert r.status_code == 200, r.text
# Le jeton natif valide prime : get_current_user ne passe pas par
# le repli draco, le dict utilisateur n'a ni _draco_sub ni
# _hub_role — la garde du registre ne peut pas s'appliquer.
r = admin_client.get("/api/auth/admin/users")
assert r.status_code == 200, r.text