Compare commits
32
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
9021765b45 | ||
|
|
750dfc25a1 | ||
|
|
6f84ac03fa | ||
|
|
8c1e47b731 | ||
|
|
7e3af155a4 | ||
|
|
0560c9a6e5 | ||
|
|
9a6a2946b9 | ||
|
|
980274052f | ||
|
|
8d6b009170 | ||
|
|
e3c50b424b | ||
|
|
a48aaf18e5 | ||
|
|
fbf87c7a6b | ||
|
|
e13648f771 | ||
|
|
8ce9b15869 | ||
|
|
2c3a00946b | ||
|
|
aee01c21c1 | ||
|
|
3fce35e708 | ||
|
|
cb3a372af6 | ||
|
|
bc43b999df | ||
|
|
55a4171313 | ||
|
|
bf030669a0 | ||
|
|
83a81b931e | ||
|
|
23df2bdcbe | ||
|
|
03a1c9f6f5 | ||
|
|
045abd6a3c | ||
|
|
06855937bd | ||
|
|
854ff0f904 | ||
|
|
5a5d7a5c59 | ||
|
|
b8949b2ddc | ||
|
|
15d015e59b | ||
|
|
dcf847e2fd | ||
|
|
a3f76e9b0c |
Regular → Executable
Regular → Executable
+35
-1
@@ -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
@@ -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.
|
||||
|
||||
[]()
|
||||
[]()
|
||||
[](https://opensource.org/licenses/MIT)
|
||||
[](https://www.docker.com/)
|
||||
[](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*
|
||||
|
||||
@@ -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.
|
||||
|
||||
[]()
|
||||
[]()
|
||||
[](https://opensource.org/licenses/MIT)
|
||||
[](https://www.docker.com/)
|
||||
[](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*
|
||||
|
||||
@@ -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
@@ -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"]:
|
||||
|
||||
@@ -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
|
||||
@@ -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
|
||||
|
||||
|
||||
@@ -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
|
||||
@@ -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
|
||||
|
||||
@@ -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)."},
|
||||
|
||||
@@ -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}
|
||||
@@ -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", "")
|
||||
|
||||
Generated
+1
-1
@@ -2626,7 +2626,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "obsigate-desktop"
|
||||
version = "2.85.0"
|
||||
version = "2.87.0"
|
||||
dependencies = [
|
||||
"chrono",
|
||||
"env_logger",
|
||||
|
||||
+1
-1
@@ -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,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",
|
||||
|
||||
@@ -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
@@ -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.
|
||||
@@ -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/`.
|
||||
@@ -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).
|
||||
@@ -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).
|
||||
@@ -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 {
|
||||
|
||||
@@ -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();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
@@ -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
@@ -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;
|
||||
}
|
||||
|
||||
@@ -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; }
|
||||
@@ -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>
|
||||
@@ -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
@@ -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": {
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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"
|
||||
@@ -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):
|
||||
|
||||
@@ -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
|
||||
Reference in New Issue
Block a user