Compare commits

..
Author SHA1 Message Date
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
37 changed files with 2789 additions and 31 deletions
Regular → Executable
View File
Regular → Executable
View File
+35 -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.85.0**.
> [Unreleased](#unreleased). La dernière version livrée est **2.87.0**.
---
@@ -14,6 +14,40 @@ 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`.
+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.85.0-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.85.0).
Consultez le [CHANGELOG.md](./CHANGELOG.md) pour l'historique complet de toutes les versions (v1.0.0 → v2.87.0).
---
*Projet : ObsiGate | Version : 2.85.0 | 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.85.0-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.85.0).
See [CHANGELOG.md](./CHANGELOG.md) for the complete version history (v1.0.0 → v2.87.0).
---
*Project: ObsiGate | Version: 2.85.0 | Last updated: September 2026*
*Project: ObsiGate | Version: 2.87.0 | Last updated: September 2026*
+1 -1
View File
@@ -1 +1 @@
2.85.0
2.87.0
+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-")
+27 -11
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,
@@ -375,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)
@@ -421,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"}
@@ -957,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()
@@ -967,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:
@@ -994,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)
@@ -1007,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"]:
+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
+56 -3
View File
@@ -29,6 +29,17 @@
# (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
@@ -231,10 +242,18 @@ def revoke_one_for_user(sub: str, jti: str) -> bool:
# ── Émission / vérification ─────────────────────────────────────────────
def issue_token(user: dict) -> tuple[str, str, int]:
"""Émet un JWS pour l'utilisateur. Retourne (jeton, jti, exp)."""
def issue_token(user: dict, ttl_seconds: int = TOKEN_TTL_SECONDS,
extra_claims: dict | None = None) -> tuple[str, str, int]:
"""Émet un JWS pour l'utilisateur. Retourne (jeton, jti, exp).
``ttl_seconds`` permet une durée de vie différente de la
session navigateur (la liaison d'appareil, #75, émet des
jetons de longue durée) ; ``extra_claims`` ajoute des claims
non réservés (ex. ``{"appareil": "<id>"}`` pour un jeton
d'appareil — les claims réservés ``sub``/``name``/``iat``/
``exp``/``jti`` ne sont jamais écrasés)."""
now = int(time.time())
exp = now + TOKEN_TTL_SECONDS
exp = now + int(ttl_seconds)
jti = uuid.uuid4().hex
claims = {
"sub": str(user.get("id") or user.get("username") or ""),
@@ -243,6 +262,10 @@ def issue_token(user: dict) -> tuple[str, str, int]:
"exp": exp,
"jti": jti,
}
if extra_claims:
for key, value in extra_claims.items():
if key not in claims:
claims[key] = value
token = jwt.encode(claims, _secret(), algorithm=ALGORITHM)
_register_issued(str(claims["sub"]), jti, exp)
return token, jti, exp
@@ -334,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
+2
View File
@@ -562,6 +562,7 @@ from backend.routers.files_read import router as files_read_router
from backend.routers.files_write import router as files_write_router
from backend.routers.health import router as health_router
from backend.routers.history import router as history_router
from backend.routers.liaison import router as liaison_router
from backend.routers.notify import router as notify_router
from backend.routers.realtime import router as realtime_router
from backend.routers.scheduler import router as scheduler_router
@@ -580,6 +581,7 @@ app.include_router(health_router) # ROADMAP #85 T1 — System / health
app.include_router(history_router) # ROADMAP #85 T8 — History
app.include_router(external_refs_router) # Fusion #215 — Références croisées (ACC-1.3)
app.include_router(sso_router) # Fusion #216 — Émettrice SSO draco_session (ACC-3.1)
app.include_router(liaison_router) # #75 — Liaison d'appareil (jeton draco)
app.include_router(realtime_router) # ROADMAP #85 T9 — SSE + collab WS
app.include_router(search_router) # ROADMAP #85 T5 — Search
app.include_router(backups_router) # ROADMAP #85 T4 — Backups
+1
View File
@@ -30,6 +30,7 @@ TAGS_METADATA: list[dict[str, str]] = [
{"name": "Bookmarks", "description": "Recently opened files, bookmarks and saved searches."},
{"name": "ExternalRefs", "description": "Cross-application references from a note to Flowdeck, TikTak, Kanbante or ObsiGate objects (Fusion program, ACC-1.3)."},
{"name": "SSO", "description": "draco_session single sign-on emitter: authorize entry point and jti revocation list for the other dracodev apps (Fusion program, ACC-3.1)."},
{"name": "Liaison d'appareil", "description": "Device-code linking for native clients (TikTak Desktop first): start a link, approve it in the browser, poll for the long-lived draco token, list and revoke linked devices (#75)."},
{"name": "Backups", "description": "Automatic file backups, diffs, restore, compression and purge."},
{"name": "Export", "description": "Export notes or whole vaults to HTML, Markdown bundle or ePub."},
{"name": "Guide", "description": "Download the in-app user guide as Markdown or PDF (mirrors the help modal, FR/EN)."},
+218
View File
@@ -0,0 +1,218 @@
# backend/routers/liaison.py
# Liaison d'appareil (#75) — flux « code d'appareil » émettant un
# jeton draco pour les clients natifs (TikTak Desktop d'abord).
#
# Protocole (miroir d'agent-commun, Fusion #45) :
# 1. l'app démarre une liaison : POST /api/v1/liaison (sans auth)
# -> code utilisateur XXXX-XXXX (10 min) + code d'appareil
# secret + URL de la page d'approbation ;
# 2. l'humain approuve (ou refuse) sur GET /liaison?code=...
# — session native ObsiGate exigée, jamais un jeton
# d'appareil ; la réponse d'approbation ne contient JAMAIS
# le jeton ;
# 3. l'app sonde : POST /api/v1/liaison/sonder -> en_attente /
# approuvee (+ jeton, livré UNE fois) / refusee / expiree /
# livree ; 404 si demande inconnue ou mauvais code ;
# 4. l'utilisateur gère ses appareils : GET /api/v1/appareils,
# POST /api/v1/appareils/{id}/revoquer (session exigée).
#
# Un jeton d'appareil présenté comme cookie draco authentifie
# comme une session draco (c'est un JWS draco standard), mais
# les endpoints de gestion et de décision le refusent avec 403
# (garde ``_exiger_session_native``, patron ``_exiger_session``
# d'agent-commun) ; présenté en ``Authorization: Bearer``, il
# est rejeté dès ``get_current_user`` (401) car ce n'est pas un
# jeton natif.
from __future__ import annotations
from pathlib import Path
from fastapi import APIRouter, Depends, HTTPException, Request
from fastapi.responses import FileResponse
from pydantic import BaseModel, Field
from backend import draco_appareils
from backend.auth.middleware import require_auth
router = APIRouter(tags=["Liaison d'appareil"])
FRONTEND_DIR = Path(__file__).resolve().parent.parent.parent / "frontend"
def _exiger_session_native(user: dict) -> dict:
"""Réserve une action aux sessions (native ou draco navigateur) :
un jeton d'appareil — porteur du claim ``appareil`` — ne gère
PAS les appareils et ne décide PAS des liaisons. Un jeton volé
ne peut donc ni frapper d'autres jetons ni couper ceux des
autres."""
if user.get("_draco_appareil"):
raise HTTPException(
status_code=403,
detail="Un jeton d'appareil ne peut pas gérer les "
"appareils ni décider une liaison.")
return user
# ── Modèles ─────────────────────────────────────────────────────────────
class LiaisonDemarrerIn(BaseModel):
"""Demande de liaison d'une application sans identifiant."""
nom: str = Field(default="", description="Nom de l'appareil (hostname)")
type: str = Field(default="desktop",
description="Type d'appareil : desktop, terminal, tiktak")
class LiaisonDemarrerOut(BaseModel):
demande_id: str
code_utilisateur: str
code_appareil: str
expire_le: float
expire_dans_s: int
type: str
url_liaison: str
url_liaison_absolue: str
class LiaisonSonderIn(BaseModel):
demande_id: str
code_appareil: str
class LiaisonCodeIn(BaseModel):
code: str
class AppareilOut(BaseModel):
id: str
nom: str
portee: str
type: str
cree_le: float | None = None
derniere_utilisation: float | None = None
expire_le: int | None = None
revoque: bool = False
revoque_le: float | None = None
class LiaisonSonderOut(BaseModel):
statut: str
jeton: str | None = None
appareil: AppareilOut | None = None
class LiaisonEnAttenteOut(BaseModel):
code_utilisateur: str
nom: str
type: str
cree_le: float | None = None
expire_le: float | None = None
# ── Page d'approbation ──────────────────────────────────────────────────
@router.get("/liaison", include_in_schema=False)
async def liaison_page():
"""Page publique d'approbation d'une liaison (``?code=XXXX-XXXX``,
saisie manuelle possible). La page elle-même n'exige rien : c'est
son JavaScript qui vérifie la session (``/api/auth/me``) puis
appelle les endpoints de décision."""
page = FRONTEND_DIR / "liaison.html"
if not page.exists():
raise HTTPException(status_code=404, detail="Page introuvable")
return FileResponse(str(page), media_type="text/html")
# ── Liaison ─────────────────────────────────────────────────────────────
@router.post("/api/v1/liaison", status_code=201,
response_model=LiaisonDemarrerOut)
async def liaison_demarrer(body: LiaisonDemarrerIn, request: Request):
"""Démarre une liaison d'appareil — SANS authentification : c'est
l'application qui demande (elle n'a encore aucun identifiant).
Elle reçoit le code utilisateur court à montrer à l'humain, un
code d'appareil secret pour sonder la décision, et l'URL de la
page d'approbation à ouvrir."""
try:
res = draco_appareils.demarrer_liaison(body.nom, body.type)
except draco_appareils.ErreurLiaison as exc:
raise HTTPException(status_code=exc.statut, detail=exc.message)
res["url_liaison"] = "/liaison?code=" + res["code_utilisateur"]
base = str(request.base_url).rstrip("/")
res["url_liaison_absolue"] = base + res["url_liaison"] if base else ""
return res
@router.post("/api/v1/liaison/sonder", response_model=LiaisonSonderOut,
response_model_exclude_none=True)
async def liaison_sonder(body: LiaisonSonderIn):
"""Le sondage de l'application : ``en_attente``, ``approuvee``
(avec le jeton d'appareil, livré UNE fois), ``refusee``,
``expiree`` ou ``livree`` (déjà consommée). Demande inconnue et
mauvais code d'appareil sont indiscernables (404) : sonder
n'apprend rien à qui n'a pas le code."""
res = draco_appareils.sonder_liaison(body.demande_id, body.code_appareil)
if res is None:
raise HTTPException(status_code=404,
detail="Demande de liaison inconnue.")
return res
@router.get("/api/v1/liaison/en-attente")
async def liaisons_en_attente(user: dict = Depends(require_auth)):
"""Les demandes de liaison en attente de décision — lues par la
page /liaison. Session exigée : un jeton d'appareil ne voit pas
les demandes."""
_exiger_session_native(user)
return {"liaisons": draco_appareils.liaisons_en_attente()}
@router.post("/api/v1/liaison/approuver")
async def liaison_approuver(body: LiaisonCodeIn,
user: dict = Depends(require_auth)):
"""Approuve une demande (session seulement) : l'appareil est créé
pour cet utilisateur ; son jeton attend la délivrance unique par
le sondage de l'application. La réponse ne contient JAMAIS le
jeton."""
_exiger_session_native(user)
try:
appareil = draco_appareils.approuver_liaison(body.code, user)
except draco_appareils.ErreurLiaison as exc:
raise HTTPException(status_code=exc.statut, detail=exc.message)
return {"appareil": appareil}
@router.post("/api/v1/liaison/refuser")
async def liaison_refuser(body: LiaisonCodeIn,
user: dict = Depends(require_auth)):
"""Refuse une demande en attente (session seulement)."""
_exiger_session_native(user)
ok = draco_appareils.refuser_liaison(body.code)
return {"refusee": ok}
# ── Appareils ───────────────────────────────────────────────────────────
@router.get("/api/v1/appareils")
async def appareils_lister(user: dict = Depends(require_auth)):
"""Les appareils liés de l'utilisateur. Session seulement ;
aucune donnée d'authentification ne sort d'ici."""
_exiger_session_native(user)
sub = str(user.get("id") or user.get("username") or "")
return {"appareils": draco_appareils.lister_appareils(sub)}
@router.post("/api/v1/appareils/{appareil_id}/revoquer")
async def appareils_revoquer(appareil_id: str,
user: dict = Depends(require_auth)):
"""Révoque un appareil (session seulement) : l'accès est coupé
dès l'appel suivant du jeton, la liste de révocation draco
étant relue par les consommateurs à chaque validation."""
_exiger_session_native(user)
sub = str(user.get("id") or user.get("username") or "")
ok = draco_appareils.revoquer_appareil(appareil_id, sub)
if not ok:
raise HTTPException(status_code=404,
detail="Appareil inconnu ou déjà révoqué.")
return {"revoque": True}
+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.85.0"
version = "2.87.0"
dependencies = [
"chrono",
"env_logger",
+1 -1
View File
@@ -1,6 +1,6 @@
[package]
name = "obsigate-desktop"
version = "2.85.0"
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.85.0",
"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) |
---
+39 -2
View File
@@ -1,6 +1,6 @@
# ObsiGate — Roadmap
> **Version :** 2.85.0 | **Dernière mise à jour :** 2026-11-06
> **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,9 +30,21 @@
## 🔵 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 en attente de fusion — voir CHANGELOG ; redéploiement Docker requis)
- **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
@@ -47,6 +59,28 @@
- [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)
@@ -1205,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/`.
+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).
+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).
+5
View File
@@ -101,6 +101,11 @@
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 {
+96
View File
@@ -42,6 +42,33 @@
* 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
@@ -54,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/",
@@ -653,6 +685,18 @@
["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" }],
@@ -687,6 +731,15 @@
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
@@ -719,6 +772,22 @@
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";
@@ -734,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) {
@@ -835,6 +905,32 @@
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();
}
};
+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.85.0",
"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": {
+100
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
+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"
+38
View File
@@ -189,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):
+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