Compare commits
25
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
b7145e398d | ||
|
|
6b1e2491dd | ||
|
|
e4531488d0 | ||
|
|
f8f8af63e1 | ||
|
|
d89b35061b | ||
|
|
4cd203ba5c | ||
|
|
5ba9bca3a3 | ||
|
|
4897009a93 | ||
|
|
bb0cc2c72b | ||
|
|
bd8af99652 | ||
|
|
00920e8e02 | ||
|
|
e024bd1a97 | ||
|
|
f88df99c97 | ||
|
|
da522904c7 | ||
|
|
a3aa1f73d1 | ||
|
|
48d0066dbe | ||
|
|
0a5d83737b | ||
|
|
7c457db59f | ||
|
|
169aa78479 | ||
|
|
123029d2e9 | ||
|
|
5402624e20 | ||
|
|
9bc5399b6c | ||
|
|
f6476c786d | ||
|
|
5f19488c47 | ||
|
|
37aa83ee45 |
@@ -6,6 +6,14 @@ GITEA_TOKEN=
|
||||
KANBANTE_AUTH_USER=
|
||||
KANBANTE_AUTH_PASSWORD=
|
||||
KANBANTE_REQUIRE_AUTH=0
|
||||
# Porte centrale unique (désactivée par défaut ; activable aussi au
|
||||
# panneau d'administration, réglage « porte_centrale »)
|
||||
KANBANTE_PORTE_CENTRALE=0
|
||||
# Porte de secours administrateur (chemin discret /login/secours,
|
||||
# jamais proposé sur l'écran principal) — compte administrateur
|
||||
# local désigné, identifiants d'environnement uniquement :
|
||||
# KANBANTE_PORTE_SECOURS_USER=
|
||||
# KANBANTE_PORTE_SECOURS_PASSWORD=
|
||||
# Noms publics dracodev — défauts = noms OFFICIELS (prod).
|
||||
# Environnement dev : déclarer ici les noms en -dev, sans toucher au code.
|
||||
KANBANTE_PUBLIC_URL=https://kanbante.dracodev.net
|
||||
|
||||
@@ -1,3 +1,67 @@
|
||||
## 0.46.6 — 2026-11-06 — Porte centrale unique (programme « compte partout », phase 2 — basée sur la 0.46.5)
|
||||
|
||||
Version **fonctionnelle** dans la série 0.46.x (base : branche 0.46.5, fusion #145/#144 ; la 0.47.0 de la PR #87 reste indépendante et non touchée). **Désactivée par défaut à la livraison** : sans activation explicite d'un administrateur, le comportement est exactement celui de la 0.46.5.
|
||||
|
||||
- **Nouveau réglage `porte_centrale`** (booléen, `app/config.py`) : amorçable par l'environnement (`KANBANTE_PORTE_CENTRALE=1`) et **surchargeable au panneau d'administration** (Administration → Paramètres, patron « l'environnement amorce, le panneau gouverne »). Un compte créé au Hub n'a pas de mot de passe local (il vit chez ObsiGate) : la porte centrale fait de la voie SSO le parcours normal au lieu d'un formulaire voué à échouer pour ces comptes.
|
||||
- **Mode actif** : l'écran de connexion ne présente **que l'entrée centrale** — le lien « Se connecter avec ObsiGate (SSO) », bien visible, avec l'explication qu'il n'y a pas de mot de passe local ; aucun champ local n'est rendu, et `POST /login` refuse toute tentative (403), identifiants de base comme repli d'environnement. **Sessions déjà établies : aucun impact** (contrôle de session inchangé). Non touchés : Basic d'environnement (voie scripts), jetons `kbt_`, pont `/auth/draco`, `/api/search`.
|
||||
- **Porte de secours administrateur** : un seul compte désigné, par l'environnement uniquement — `KANBANTE_PORTE_SECOURS_USER` / `KANBANTE_PORTE_SECOURS_PASSWORD` (secrets, jamais en base ni dans le panneau ni en dur) — joignable par le **chemin discret `/login/secours`**, jamais proposé ni lié sur l'écran principal ; sans les deux variables, le chemin répond 404. Gardes : le compte désigné doit être un administrateur local **actif** (ou l'opérateur d'environnement) — un membre désigné par erreur est refusé ; le geste est journalisé (`login.porte_secours`). Fiche complète : `docs/porte-centrale.md` (dont la fiche d'activation opérateur).
|
||||
- **Correctif au passage (panneau des paramètres)** : la conversion des réglages booléens à l'enregistrement est désormais explicite (`true`/`false` lus en toutes lettres) — auparavant `bool("false")` valait `True`, donc un booléen du panneau (dont `porte_centrale`, mais aussi `sync_*`, `briefing_include_standup`) ne pouvait pas se désactiver en saisissant `false`.
|
||||
- **Tests** : nouveau `tests/test_porte_centrale.py` (7) — mode inactif par défaut = comportement actuel ; activation puis désactivation par le panneau ; mode actif : écran central seul, secours jamais proposé, formulaire refusé pour un membre comme pour l'amorçage, session préexistante intacte ; porte de secours : chemin discret fonctionnel en plein mode central, mauvais mot de passe et membre refusés, membre désigné refusé, 404 sans configuration ; amorçage par variable d'environnement et surcharge du panneau par-dessus.
|
||||
|
||||
## 0.46.5 — 2026-11-06 — Pont draco : adoption de l'amorçage conditionnée (fusion #145) et échec de connexion qui suggère le SSO (fusion #144, part Kanbante)
|
||||
|
||||
Version **corrective de sécurité** dans la série 0.46.x (base 0.46.4 ; la 0.47.0 de la PR #87, métadonnées des jetons, reste indépendante et non touchée).
|
||||
|
||||
- **Trou corrigé (audit « compte partout » du 2026-11-06)** : sur une instance fraîche, le premier visiteur du pont `/auth/draco` adoptait le compte administrateur d'amorçage — un simple compte `user` de la suite (« dan ») l'a fait en pile de contrôle et est devenu l'admin local. Cause : la « liaison au premier passage » de `resolve_draco_user()` (`app/accounts.py`), commodité de l'ère mono-utilisateur.
|
||||
- **Nouvelle règle** : l'amorçage (unique compte, admin actif, sans liaison) n'est adopté que si **(a)** le `sub` entrant est « administrateur » pour kanbante **au registre des rôles du Hub** — le pont, qui consultait déjà le registre (HUB-19), transmet désormais le rôle à la résolution — ou **(b)** l'adoption est initiée depuis une **session native déjà authentifiée** (liaison explicite par l'utilisateur connecté : passage du pont avec session native ouverte, ou connexion native doublement connectée — mécanismes existants, inchangés). **Repli propre** : Hub muet, réponse illisible ou rôle moindre → **pas d'adoption** ; tout autre `sub` inconnu reçoit le parcours JIT ordinaire (compte **membre** propre, jamais l'amorçage). La correspondance existante (cas de production : amorçage déjà lié) résout exactement comme avant. `/api/search`, qui ne consulte pas le registre, ne peut plus adopter l'amorçage du tout.
|
||||
- **Fusion #144 (part Kanbante)** : l'échec du formulaire local ne rend plus le seul « Identifiants incorrects. ». Quand l'identifiant ne correspond à aucun compte local, le message le dit et suggère la voie centrale — « Se connecter avec ObsiGate (SSO) », le bouton déjà présent sur l'écran (libellé inchangé, référence d'harmonisation) ; un compte créé au Hub n'a en effet pas de mot de passe local (il vit chez ObsiGate). Le même renvoi au SSO suit l'échec sur un compte local existant.
|
||||
- **Documentation** : `docs/correspondance-draco.md` — section « Compte d'amorçage » réécrite (adoption conditionnée a/b, surface `/api/search` sans adoption).
|
||||
- **Tests** : nouveau `tests/test_amorcage_pont.py` — instance réellement fraîche par test (base temporaire : seul l'amorçage, sans liaison) : (i) `sub` simple utilisateur → JIT membre propre, amorçage intact non lié ; (ii) `sub` administrateur au registre → adoption ; (ii-bis) Hub muet → pas d'adoption ; (iii) liaison existante → résolution inchangée ; (iv) session native authentifiée → liaison explicite (pont et résolution directe) ; échecs de formulaire #144 (identifiant sans compte local, mauvais mot de passe). Le test historique d'amorçage de `tests/test_draco_correspondance.py` simule désormais le rôle « administrateur » du registre, et le docstring de `tests/test_draco_sso.py` est aligné (le premier jeton ne se lie plus à l'amorçage).
|
||||
|
||||
## 0.46.4 — 2026-11-06 — Barre commune v0.6.0 re-vendangée : entrée « Administration » (fusion #142)
|
||||
|
||||
- **Re-vendange verbatim** de la barre commons v0.6.0 (PR dracodev-commons #14) : `static/js/draco-barre.js` + `static/css/draco-barre.css`. Le menu compte gagne l'entrée **Administration** → `<hub>/admin` (le Hub redirige vers `/admin/utilisateurs`), à **visibilité conditionnelle** (affirmée par l'hôte via `cfg.admin` / `DRACO_BAR.setAdmin`, jamais déduite par la barre).
|
||||
- **Pas de drapeau chez Kanbante** : Kanbante ne connaît que le rôle du registre du Hub pour sa propre application (consulté avant la création JIT de la correspondance) — pas le rôle global de suite (rôle du compte chez ObsiGate, la définition de la garde du Hub). À défaut de certitude, le contrat v0.6.0 impose de ne pas affirmer : l'entrée reste masquée dans Kanbante (elle apparaît chez ObsiGate et dans la console, qui peuvent l'établir). Commentaire posé dans le gabarit `_draco_bar.html`.
|
||||
- **Tests** : nouveau `tests/test_barre_v060.py` (marqueurs de la vendange + absence d'affirmation dans le gabarit).
|
||||
|
||||
## 0.46.3 — 2026-11-06 — Déconnexion du menu compte : locale **et** globale (fusion #141)
|
||||
|
||||
- **Défaut corrigé** : Kanbante était le seul hôte à brancher l'action `deconnexion` de la barre commune, mais sa branche ne faisait que naviguer vers `GET /logout` — la session locale était détruite, **la session draco (SSO) survivait** : le pont `/auth/draco` rouvrait une session Kanbante sans mot de passe. Une « déconnexion » qui ne déconnectait pas vraiment.
|
||||
- **Branchement corrigé** (`app/templates/_draco_bar.html`) : destruction d'abord de la session locale (`fetch GET /logout`), puis navigation vers la déconnexion globale de l'émettrice (`GET {draco_urls.obsigate}/sso/logout?return_to={origine}/`, nouvelle route ObsiGate 2.86.0, PR sœur) : le `jti` draco y est révoqué et le cookie effacé sur le domaine parent. Après le parcours, la session de la suite entière et la session locale Kanbante sont terminées ; le retour se fait sur la racine Kanbante (page de connexion).
|
||||
- **Test** : nouveau `tests/test_deconnexion.py` (marqueurs du branchement + disparition de l'ancien branchement local seul). Périmètre draco/barre : 33 passés (environnement local : variables `NO_PROXY`/proxy de la VM à écarter pour httpx, fonds connu).
|
||||
|
||||
## 0.46.2 — 2026-11-06 — Rôles du Hub propagés à Kanbante (HUB-19, suite du pilote ShaarIt 0.7.0)
|
||||
|
||||
Version **corrective** au sens du patron du dépôt (pas de fonction nouvelle côté métier : un garde d'accès branché sur le registre du Hub, contrat D3(a) du plan Hub v2).
|
||||
|
||||
- **Client du registre** (`app/hub_roles.py`, portage Python du pilote `hub_roles.rs` de ShaarIt) : à l'ouverture de session draco, consultation de `GET {hub}/api/roles/kanbante` en relayant l'en-tête Cookie complet de la requête (`Accept: application/json`, délai 2 s) → rôle ∈ {`aucun`, `utilisateur`, `administrateur`}. Cache mémoire par `sub`, TTL 60 s, horodatage posé **avant** l'appel (échec = ancien cache conservé, pas de rafale). URL du Hub résolue comme la barre commune (`resoudre_urls_draco` : `DRACO_HUB_URL` explicite > hôte public de la requête > dérivation par l'hôte sœur de l'agent > défaut officiel) — jamais d'URL dev figée. **Toute erreur = rôle inconnu → comportement actuel** : le registre ne crée jamais un verrouillage nouveau.
|
||||
- **Pont `/auth/draco` — consultation d'abord** : le registre est consulté **avant** la liaison à une session native, avant `resolve_draco_user()` et donc avant toute création JIT (HUB-16). Rôle connu `aucun` → refus explicite en français (403, page d'erreur) : **aucune session Kanbante ouverte par draco pour ce `sub`, aucun compte créé, aucune liaison posée**. La session ouverte par le pont porte désormais un marqueur « établie par draco » **couvert par la signature** du cookie de session (`user.expiry.draco.hmac` ; le format natif historique reste lu tel quel).
|
||||
- **`/admin` gardé par le registre pour les sessions draco** : `_require_admin` (qui couvre `/admin` et toutes ses actions) exige, pour une session établie par draco dont le rôle du registre est **connu**, le niveau `administrateur` du registre **en plus** du rôle local admin. Rôle inconnu ou session native → règles locales actuelles, inchangées.
|
||||
- **Non touchés** : session native préexistante, connexion native (mot de passe), Basic d'environnement, jetons `kbt_`, `/api/search`, droits internes et réconciliation Gitea par étiquettes (le piège « exactement une étiquette reconnue » n'est pas le sujet de cette carte). Détails : `docs/correspondance-draco.md`, section « Rôles du Hub (HUB-19) ».
|
||||
- Tests : `tests/test_hub_roles.py` — client (contrat d'appel, cookie relayé, cache et TTL, échec sans rafale avec ancien cache conservé, réponses illisibles, résolution d'URL par hôte dev et par variable explicite), marqueur de session signé, pont (refus `aucun` sans création ni liaison, JIT `utilisateur`, repli rôle inconnu) et garde `/admin` (session draco `utilisateur` refusée malgré le rôle local admin, `administrateur` accepté, inconnu = repli local, session native non soumise).
|
||||
|
||||
## 0.46.1 — 2026-11-06 — Barre commune v0.5.0 : thème commun (HUB-18, fusion #132)
|
||||
|
||||
> **Hypothèse d'ordre** : cette version suppose la fusion préalable de la PR #84 (Kanbante 0.46.0, HUB-16) ; branchée sur `main` (0.45.12), elle vise **0.46.1**.
|
||||
|
||||
- **Barre d'apps v0.5.0 vendangée (dracodev-commons, branche `hub18-theme-commun`, PR commons #12)** : `static/js/draco-barre.js` remplacé **verbatim** — SHA-256 JS `384e2b02…6e188ce11c7` (preuve dans `tests/test_barre_v050.py`). Le CSS est inchangé en v0.5.0 (empreinte v0.4.1 conservée ; `tests/test_barre_v041.py` supersédé pour le seul JS).
|
||||
- **Thème commun** : la barre apprend la préférence de thème du profil du Hub (`GET <hub>/api/profil/theme`, cookie draco ; `<hub>` = URL résolue de la barre, jamais figée) et l'applique à l'ouverture : cache `localStorage` `draco-theme-hub` (TTL 12 h) appliqué synchrone, puis fetch asynchrone non bloquant ; `sombre`/`clair` posent `data-theme`, `systeme` le retire (`prefers-color-scheme` décide). **Repli intégral** si le Hub ne répond pas, répond non-OK ou `theme: null` : l'amorce actuelle (choix local `kanbante-theme`, défaut sombre) reste seule maître.
|
||||
- **Initialisation propre à Kanbante** (`static/js/nav.js`) : écoute de l'événement `draco:theme` de la barre (+ reprise de `DRACO_BAR.themeMode` au démarrage, la barre s'exécutant avant nav.js) — le mode effectif est posé sur `data-theme` et le bouton de bascule est resynchronisé (`syncThemeBtn`). Le choix local `kanbante-theme` n'est **pas** écrasé : le bouton reste le maître pour la session.
|
||||
- **Cache** : le bump du fichier `VERSION` change le `?v=` des CSS/JS de la barre ; `APP_VERSION` suit automatiquement (source unique `VERSION`).
|
||||
- Tests : `tests/test_barre_v050.py` (verbatim v0.5.0 prouvé par SHA-256, marqueurs thème, initialisation nav.js).
|
||||
|
||||
## 0.46.0 — 2026-11-06 — Correspondance draco par utilisateur (HUB-16, carte fusion #130)
|
||||
|
||||
Version **mineure** : c'est une fonction (nouveau comportement d'identité), selon le patron du dépôt (fonctions en mineur — 0.24.0 comptes, 0.25.0 jetons ; les 0.45.x étaient des vendanges et correctifs).
|
||||
|
||||
- **Fin de l'hypothèse mono-utilisateur du pont SSO (ACC-3.2)** : un jeton `draco_session` valide désigne désormais **le compte Kanbante de son identité**. La correspondance vit dans la colonne existante `users.draco_sub` (UNIQUE, depuis la 0.24.0) ; la résolution est centralisée dans `app.accounts.resolve_draco_user()`, seul point d'entrée du pont `/auth/draco` et du contrôle draco de `/api/search`.
|
||||
- **Création JIT** : à la première connexion draco d'une identité sans correspondance, son compte Kanbante est créé automatiquement — nom dérivé des claims (slug du nom affiché, suffixé en cas de collision, jamais d'adoption d'un compte non lié), rôle **membre**, mot de passe local aléatoire haché **non divulgué** (l'accès normal passe par draco), membre de l'espace Principal, geste journalisé (`draco.jit`).
|
||||
- **Compte d'amorçage** : si l'unique compte existant est un admin actif sans liaison, le premier `sub` valide s'y lie au premier passage (journalisé `draco.link.amorcage`) — le compte actuel de l'opérateur garde son accès ; ses voies natives (mot de passe du compte, repli environnement formulaire/Basic) sont inchangées.
|
||||
- **Liaison par l'administrateur** : colonne « Draco (sub) » de `/admin` — saisir le `sub` et « Lier », ou « Délier » ; refus si le `sub` est déjà lié à un autre compte ; permis sur son propre compte (voie manuelle pour l'amorçage). Journalisé (`draco.link.admin` / `draco.unlink.admin`). Procédure et modèle : `docs/correspondance-draco.md`. Le registre matriciel côté Hub viendra avec HUB-19 ; ici, seul le côté Kanbante — la source de vérité locale — est livré.
|
||||
- **`/api/search`** : le cookie draco n'y vaut plus « opérateur » — le `sub` doit désigner un compte (correspondance ou amorçage) ; aucun JIT sur cette surface.
|
||||
- **Non-régressions** : jetons personnels `kbt_` (création, usage `/mcp` et `/api/`, révocation), sessions propres Kanbante, connexion native (avec liaison à la première visite doublement connectée), authentification Basic, pont inerte sans `DRACO_SESSION_SECRET`, compte désactivé refusé partout sans contournement JIT. La réconciliation par étiquettes Kanbante/Gitea n'est pas touchée.
|
||||
- Tests : `tests/test_draco_correspondance.py` (amorçage unique admin, deux identités → deux comptes distincts, JIT sans adoption d'un compte homonyme non lié, liaison/déliaison admin et conflit de `sub`, compte désactivé refusé, `/api/search` par utilisateur, jeton `kbt_` toujours accepté) ; le docstring de `tests/test_draco_sso.py` est mis à jour (le pont n'est plus mono-utilisateur).
|
||||
|
||||
## 0.45.12 — 2026-11-05 — Barre commune v0.4.1 : correctif des icônes invisibles du menu compte (fusion #125)
|
||||
|
||||
- **Barre d'apps v0.4.1 vendangée (dracodev-commons, branche `menu-compte-icones-svg-ns-v0-4-1`, PR commons #11)** : `static/js/draco-barre.js` remplacé **verbatim** — SHA-256 JS `82c4940e…b34f85a42` (preuve dans `tests/test_barre_v041.py`). Le CSS est inchangé (empreinte v0.4.0 conservée) ; le gabarit `_draco_bar.html` est inchangé.
|
||||
|
||||
@@ -120,6 +120,8 @@ sudo systemctl enable --now docker
|
||||
| `KANBANTE_DB_PATH` | `~/.kanbante/kanbante.db` | Base SQLite locale (en Docker : `/data/kanbante.db`) |
|
||||
| `KANBANTE_AUTH_USER` / `KANBANTE_AUTH_PASSWORD` | *(vide)* | Active l'authentification dès que les deux sont définis : écran de connexion + session signée pour les navigateurs ; l'en-tête Basic reste accepté pour les scripts |
|
||||
| `KANBANTE_REQUIRE_AUTH` | `0` | `1` = l'app refuse de servir (503) si l'auth n'est pas configurée |
|
||||
| `KANBANTE_PORTE_CENTRALE` | `0` | `1` = porte centrale unique : l'écran de connexion ne présente que l'entrée ObsiGate (SSO) et le formulaire local est refusé ; surchargeable au panneau d'administration (réglage `porte_centrale`) — voir `docs/porte-centrale.md` |
|
||||
| `KANBANTE_PORTE_SECOURS_USER` / `KANBANTE_PORTE_SECOURS_PASSWORD` | *(vide)* | Porte de secours : compte administrateur local désigné, joignable par le chemin discret `/login/secours` (jamais proposé sur l'écran principal) ; vide = porte désactivée |
|
||||
| `KANBANTE_SESSION_SECRET` | *(dérivé)* | Clé HMAC du cookie de session ; par défaut dérivée des identifiants (changer le mot de passe invalide les sessions) |
|
||||
| `KANBANTE_SNAPSHOT_INTERVAL` | `120` | Secondes entre les rafraîchissements d'instantanés d'arrière-plan (chantier B) ; `0` = désactivé |
|
||||
| `KANBANTE_ACTIVE_WINDOW_DAYS` | `365` | Un dépôt non archivé mis à jour depuis moins de N jours est « actif » |
|
||||
|
||||
+160
@@ -9,7 +9,10 @@ be raised later without invalidating existing hashes.
|
||||
import base64
|
||||
import hashlib
|
||||
import hmac
|
||||
import re
|
||||
import secrets
|
||||
import sqlite3
|
||||
import unicodedata
|
||||
|
||||
from app import models
|
||||
|
||||
@@ -66,3 +69,160 @@ def ensure_bootstrap_admin() -> dict | None:
|
||||
display_name=settings.auth_user,
|
||||
)
|
||||
return models.get_user(user_id)
|
||||
|
||||
|
||||
# ── Correspondance draco par utilisateur (HUB-16, 0.46.0) ────
|
||||
# La correspondance identité draco ↔ compte Kanbante vit dans la
|
||||
# colonne users.draco_sub (UNIQUE, présente depuis la 0.24.0) :
|
||||
# models.get_user_by_draco(sub) est la résolution canonique.
|
||||
# resolve_draco_user() est l'unique point d'entrée du pont SSO
|
||||
# (app.main.draco_bridge) et du contrôle draco de /api/search :
|
||||
#
|
||||
# 1. correspondance existante → son compte (None si désactivé) ;
|
||||
# 2. amorçage CONDITIONNÉ (fusion #145, 0.46.5) : s'il n'existe
|
||||
# qu'UN seul compte et que c'est un admin actif sans liaison,
|
||||
# ce compte d'amorçage ne peut être adopté que si
|
||||
# a) le sub entrant est « administrateur » pour kanbante
|
||||
# au registre des rôles du Hub (app.hub_roles, rôle
|
||||
# transmis par l'appelant via ``role_hub`` — dans le
|
||||
# doute, registre muet ou rôle moindre, PAS d'adoption),
|
||||
# ou b) l'adoption est initiée depuis une session native
|
||||
# déjà authentifiée (``liaison_session_native=True`` :
|
||||
# l'utilisateur connecté lie explicitement son compte) ;
|
||||
# tout autre sub inconnu suit le parcours ordinaire (JIT ou
|
||||
# refus selon la surface), JAMAIS l'amorçage ;
|
||||
# 3. sinon, si provisionner=True : création JIT d'un compte
|
||||
# propre à cette identité (voir provision_draco_user).
|
||||
#
|
||||
# Avant la 0.46.5, l'étape 2 liait l'amorçage au PREMIER sub
|
||||
# valide de passage : sur une instance fraîche, un simple
|
||||
# utilisateur de la suite devenait l'administrateur local
|
||||
# (audit « compte partout » du 2026-11-06, carte fusion #145).
|
||||
#
|
||||
# Un sub inconnu ne désigne JAMAIS un compte existant non lié
|
||||
# (ni l'opérateur d'environnement, ni un compte dont le nom
|
||||
# ressemblerait au nom affiché draco) : la liaison d'un compte
|
||||
# préexistant est un geste d'administrateur (/admin, voir
|
||||
# docs/correspondance-draco.md) ou la première visite
|
||||
# doublement connectée (session native + cookie draco).
|
||||
|
||||
|
||||
def _slug_draco(valeur: str) -> str:
|
||||
texte = unicodedata.normalize("NFKD", valeur or "")
|
||||
texte = texte.encode("ascii", "ignore").decode("ascii").lower()
|
||||
return re.sub(r"[^a-z0-9]+", "-", texte).strip("-")[:40].strip("-")
|
||||
|
||||
|
||||
def _nom_utilisateur_draco(nom_affiche: str, sub: str) -> str:
|
||||
"""Nom d'utilisateur libre dérivé des claims (jamais réutilisé).
|
||||
|
||||
Base : le nom affiché slugifié (« Alice Exemple » →
|
||||
« alice-exemple ») ; repli « draco-<sub slugifié> ». Si le nom
|
||||
est déjà pris — y compris par un compte préexistant NON lié,
|
||||
qui ne doit pas être adopté — un suffixe -2, -3… est ajouté :
|
||||
le JIT crée toujours un compte nouveau, distinct.
|
||||
"""
|
||||
base = _slug_draco(nom_affiche)
|
||||
if len(base) < 3:
|
||||
base = _slug_draco(f"draco-{sub}") or "draco"
|
||||
candidat, n = base, 2
|
||||
while models.get_user_by_username(candidat) is not None:
|
||||
candidat = f"{base}-{n}"
|
||||
n += 1
|
||||
return candidat
|
||||
|
||||
|
||||
def provision_draco_user(sub: str, nom_affiche: str = "") -> dict | None:
|
||||
"""Création JIT du compte Kanbante d'une identité draco (HUB-16).
|
||||
|
||||
Rôle par défaut sûr : membre (« member », l'utilisateur
|
||||
standard de Kanbante) — jamais admin. Le mot de passe local
|
||||
est un secret aléatoire haché, jamais divulgué : l'accès
|
||||
normal passe par draco ; un administrateur peut poser un mot
|
||||
de passe local depuis /admin si besoin. Le compte rejoint
|
||||
l'espace Principal comme membre, comme tout nouvel
|
||||
utilisateur créé par l'administration.
|
||||
"""
|
||||
sub = str(sub or "")
|
||||
if not sub:
|
||||
return None
|
||||
existant = models.get_user_by_draco(sub)
|
||||
if existant is not None:
|
||||
return existant
|
||||
nom = (nom_affiche or "").strip()[:80]
|
||||
for _tentative in range(5):
|
||||
username = _nom_utilisateur_draco(nom, sub)
|
||||
try:
|
||||
user_id = models.create_user(
|
||||
username,
|
||||
hash_password(secrets.token_urlsafe(32)),
|
||||
role="member",
|
||||
display_name=nom,
|
||||
draco_sub=sub,
|
||||
)
|
||||
break
|
||||
except sqlite3.IntegrityError:
|
||||
# Course sur draco_sub ou username : la correspondance
|
||||
# gagnante fait foi ; sinon, réessayer un autre nom.
|
||||
existant = models.get_user_by_draco(sub)
|
||||
if existant is not None:
|
||||
return existant
|
||||
else:
|
||||
return models.get_user_by_draco(sub)
|
||||
espaces = models.list_workspaces()
|
||||
if espaces:
|
||||
models.set_member(espaces[0]["id"], user_id, "member")
|
||||
models.log_admin(user_id, "draco.jit", f"{username} (sub {sub})")
|
||||
return models.get_user(user_id)
|
||||
|
||||
|
||||
def resolve_draco_user(
|
||||
claims: dict | None,
|
||||
provisionner: bool = False,
|
||||
role_hub: str | None = None,
|
||||
liaison_session_native: bool = False,
|
||||
) -> dict | None:
|
||||
"""Compte Kanbante désigné par des claims draco valides.
|
||||
|
||||
provisionner=False : correspondance et amorçage seulement
|
||||
(surfaces qui ne doivent pas créer de compte, p. ex.
|
||||
/api/search). provisionner=True : création JIT si aucune
|
||||
correspondance n'existe (pont /auth/draco — la « première
|
||||
connexion draco » du critère « un compte fonctionne
|
||||
partout »). Un compte désactivé résout à None et n'est
|
||||
jamais contourné par un JIT (la correspondance existe).
|
||||
|
||||
Adoption de l'amorçage (fusion #145) : ``role_hub`` est le
|
||||
rôle du sub au registre du Hub pour kanbante, déjà consulté
|
||||
par l'appelant (app.hub_roles ; ``None`` = inconnu, Hub
|
||||
muet) et ``liaison_session_native`` signale une adoption
|
||||
initiée depuis une session native authentifiée. L'amorçage
|
||||
n'est adopté que si l'un des deux vaut respectivement
|
||||
``"administrateur"`` / ``True`` — sinon, aucun paramètre ne
|
||||
doit être deviné ici : dans le doute, pas d'adoption.
|
||||
"""
|
||||
sub = str((claims or {}).get("sub") or "")
|
||||
if not sub:
|
||||
return None
|
||||
lie = models.get_user_by_draco(sub)
|
||||
if lie is not None:
|
||||
return lie if lie["active"] else None
|
||||
if models.count_users() == 1:
|
||||
seul = models.list_users()[0]
|
||||
if (
|
||||
seul["role"] == "admin"
|
||||
and seul["active"]
|
||||
and not seul.get("draco_sub")
|
||||
and (role_hub == "administrateur" or liaison_session_native)
|
||||
):
|
||||
# Compte d'amorçage : adoption conditionnée (#145) —
|
||||
# administrateur au registre du Hub, ou liaison
|
||||
# explicite depuis une session native authentifiée.
|
||||
models.update_user(seul["id"], draco_sub=sub)
|
||||
models.log_admin(seul["id"], "draco.link.amorcage", sub)
|
||||
return models.get_user(seul["id"])
|
||||
if provisionner:
|
||||
cree = provision_draco_user(sub, str((claims or {}).get("name") or ""))
|
||||
if cree is not None and cree["active"]:
|
||||
return cree
|
||||
return None
|
||||
|
||||
@@ -11,6 +11,24 @@ Environment variables:
|
||||
KANBANTE_AUTH_USER Login username (with _PASSWORD: enables auth).
|
||||
KANBANTE_AUTH_PASSWORD Login password.
|
||||
KANBANTE_REQUIRE_AUTH "1" = refuse to serve if auth is not configured.
|
||||
KANBANTE_PORTE_CENTRALE "1" = active la « porte centrale unique »
|
||||
(0.46.6) : l'écran de connexion ne présente
|
||||
plus que l'entrée centrale (SSO ObsiGate)
|
||||
et le formulaire local est refusé. Défaut
|
||||
"0" (désactivé) ; surchargeable depuis le
|
||||
panneau d'administration (réglage
|
||||
``porte_centrale``, l'environnement amorce,
|
||||
le panneau gouverne).
|
||||
KANBANTE_PORTE_SECOURS_USER / KANBANTE_PORTE_SECOURS_PASSWORD
|
||||
Identifiants de la porte de secours
|
||||
administrateur (0.46.6) : LE compte
|
||||
administrateur local désigné, joignable
|
||||
par le chemin discret /login/secours
|
||||
(jamais proposé sur l'écran principal),
|
||||
y compris quand la porte centrale est
|
||||
active. Secrets d'environnement uniquement,
|
||||
jamais en base ni dans le panneau. Variables
|
||||
absentes = porte de secours désactivée.
|
||||
KANBANTE_SESSION_SECRET HMAC key for the login session cookie
|
||||
(default: derived from the credentials —
|
||||
rotating the password invalidates sessions).
|
||||
@@ -370,6 +388,9 @@ class Settings:
|
||||
auth_user: str = ""
|
||||
auth_password: str = ""
|
||||
require_auth: bool = False
|
||||
porte_centrale: bool = False
|
||||
porte_secours_user: str = ""
|
||||
porte_secours_password: str = ""
|
||||
active_window_days: int = 365
|
||||
cache_ttl: float = 30.0
|
||||
max_note_chars: int = 20_000
|
||||
@@ -456,6 +477,9 @@ def _env_settings() -> Settings:
|
||||
auth_user=os.getenv("KANBANTE_AUTH_USER", ""),
|
||||
auth_password=os.getenv("KANBANTE_AUTH_PASSWORD", ""),
|
||||
require_auth=_env_bool("KANBANTE_REQUIRE_AUTH", False),
|
||||
porte_centrale=_env_bool("KANBANTE_PORTE_CENTRALE", False),
|
||||
porte_secours_user=os.getenv("KANBANTE_PORTE_SECOURS_USER", ""),
|
||||
porte_secours_password=os.getenv("KANBANTE_PORTE_SECOURS_PASSWORD", ""),
|
||||
active_window_days=_env_int("KANBANTE_ACTIVE_WINDOW_DAYS", 365),
|
||||
cache_ttl=_env_float("KANBANTE_CACHE_TTL", 30.0),
|
||||
max_note_chars=_env_int("KANBANTE_MAX_NOTE_CHARS", 20_000),
|
||||
@@ -551,6 +575,11 @@ OVERRIDABLE_SETTINGS: dict[str, type] = {
|
||||
"capture_repo": str,
|
||||
"sync_labels": bool,
|
||||
"sync_gitea": bool,
|
||||
# Porte centrale unique (0.46.6) : booléen du panneau —
|
||||
# l'administrateur l'active/la désactive sans redémarrage.
|
||||
# Les identifiants de la porte de secours, eux, restent en
|
||||
# environnement (secrets, jamais surchargeables).
|
||||
"porte_centrale": bool,
|
||||
}
|
||||
|
||||
|
||||
|
||||
+6
-3
@@ -9,9 +9,12 @@ est présenté). Vérification hmac/hashlib — mêmes sémantiques que
|
||||
les validateurs de TikTak (0.52.0) et Flowdeck (7.74.0).
|
||||
|
||||
Le pont ``GET /auth/draco`` (app/main.py) convertit un cookie valide
|
||||
en session Kanbante native. Kanbante est mono-utilisateur
|
||||
(identifiants configurés par l'environnement) : un jeton valide
|
||||
désigne l'opérateur configuré — pas de table de liens. Sans secret
|
||||
en session Kanbante native. Depuis la 0.46.0 (HUB-16), la
|
||||
correspondance est PAR UTILISATEUR : le ``sub`` des claims désigne
|
||||
le compte Kanbante lié dans ``users.draco_sub`` (résolution et
|
||||
création JIT : app.accounts.resolve_draco_user) — un jeton valide
|
||||
ne désigne plus « l'opérateur » par hypothèse. Ce module ne fait
|
||||
que valider le jeton ; il ne connaît aucun compte. Sans secret
|
||||
configuré, module inerte.
|
||||
"""
|
||||
|
||||
|
||||
@@ -0,0 +1,120 @@
|
||||
"""Rôles par application — consommation du registre du Hub (HUB-19).
|
||||
|
||||
Portage Python du pilote ShaarIt 0.7.0 (``src/hub_roles.rs``),
|
||||
contrat D3(a) du plan Hub v2 : à l'ouverture de session draco,
|
||||
Kanbante demande au Hub le niveau du porteur du cookie pour
|
||||
l'application ``kanbante`` — ``GET {hub}/api/roles/kanbante``,
|
||||
en-tête Cookie complet de la requête relayé tel quel,
|
||||
``Accept: application/json``, délai 2 s → ``{"app", "sub",
|
||||
"role", "explicite", "ttl_secondes": 60}``, rôle ∈ {``aucun``,
|
||||
``utilisateur``, ``administrateur``}.
|
||||
|
||||
Cache mémoire par ``sub``, TTL 60 s, sur le patron du cache de
|
||||
révocations de ``app.draco`` : l'horodatage est posé **avant**
|
||||
l'appel — un échec ne déclenche pas de rafale et l'ancien cache
|
||||
reste en vigueur (il resservira aux appels suivants pendant le
|
||||
TTL posé par la tentative). L'URL du Hub est résolue comme celle
|
||||
de la barre commune (``app.config.resoudre_urls_draco`` :
|
||||
variable explicite ``DRACO_HUB_URL`` > hôte public de la requête
|
||||
> dérivation par l'hôte sœur de l'agent > défaut officiel) —
|
||||
jamais d'URL dev figée.
|
||||
|
||||
**Repli obligatoire** : Hub injoignable, en erreur ou réponse
|
||||
illisible → ``None`` (rôle **inconnu**), et l'appelant garde son
|
||||
comportement actuel. Le registre ne crée jamais un verrouillage
|
||||
nouveau.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
import threading
|
||||
import time
|
||||
|
||||
import httpx
|
||||
|
||||
from app.config import resoudre_urls_draco
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
#: Identifiant de Kanbante dans le registre des applications du Hub.
|
||||
APP = "kanbante"
|
||||
|
||||
#: TTL du cache, aligné sur ``ttl_secondes`` annoncé par le Hub
|
||||
#: et sur le cache de révocations draco.
|
||||
CACHE_TTL = 60.0 # secondes
|
||||
|
||||
ROLES_CONNUS = ("aucun", "utilisateur", "administrateur")
|
||||
|
||||
_verrou = threading.Lock()
|
||||
_cache: dict[str, str] = {}
|
||||
_cache_fetched_at: float = 0.0
|
||||
|
||||
|
||||
def _reset_cache() -> None:
|
||||
"""Vide le cache (tests, ou redémarrage de processus)."""
|
||||
global _cache_fetched_at
|
||||
with _verrou:
|
||||
_cache.clear()
|
||||
_cache_fetched_at = 0.0
|
||||
|
||||
|
||||
def _consulter(hub_url: str, cookie: str) -> str | None:
|
||||
"""Un appel au registre ; rôle connu ou ``None`` (inconnu)."""
|
||||
url = f"{hub_url.rstrip('/')}/api/roles/{APP}"
|
||||
try:
|
||||
reponse = httpx.get(
|
||||
url,
|
||||
headers={"Cookie": cookie, "Accept": "application/json"},
|
||||
timeout=2.0,
|
||||
)
|
||||
except Exception as exc: # Hub injoignable : repli, jamais un blocage
|
||||
logger.debug("Registre des rôles du Hub injoignable (%s) : %s", url, exc)
|
||||
return None
|
||||
if getattr(reponse, "status_code", None) != 200:
|
||||
logger.debug(
|
||||
"Registre des rôles du Hub en erreur (%s) : statut %s",
|
||||
url, getattr(reponse, "status_code", "?"),
|
||||
)
|
||||
return None
|
||||
try:
|
||||
donnees = reponse.json()
|
||||
except Exception:
|
||||
return None
|
||||
if not isinstance(donnees, dict):
|
||||
return None
|
||||
role = donnees.get("role")
|
||||
return role if role in ROLES_CONNUS else None
|
||||
|
||||
|
||||
def role_pour(cookie: str, sub: str, hote: str | None = None) -> str | None:
|
||||
"""Niveau connu pour ce ``sub`` : un rôle ou ``None`` (inconnu).
|
||||
|
||||
``cookie`` est l'en-tête Cookie complet de la requête, relayé
|
||||
tel quel au Hub ; ``hote`` est l'hôte public de la requête,
|
||||
pour résoudre l'URL du Hub comme la barre commune.
|
||||
"""
|
||||
global _cache_fetched_at
|
||||
sub = str(sub or "")
|
||||
if not sub:
|
||||
return None
|
||||
now = time.monotonic()
|
||||
with _verrou:
|
||||
if now - _cache_fetched_at < CACHE_TTL and sub in _cache:
|
||||
return _cache[sub]
|
||||
# Horodatage posé avant l'appel (patron révocations) :
|
||||
# l'ancien cache est conservé tel quel pendant l'appel.
|
||||
_cache_fetched_at = now
|
||||
hub_url = resoudre_urls_draco(hote).hub_url
|
||||
resultat = _consulter(hub_url, cookie)
|
||||
if resultat is not None:
|
||||
with _verrou:
|
||||
_cache[sub] = resultat
|
||||
_cache_fetched_at = time.monotonic()
|
||||
else:
|
||||
logger.debug(
|
||||
"Registre des rôles du Hub indisponible (%s/api/roles/%s)"
|
||||
" — comportement actuel conservé",
|
||||
hub_url, APP,
|
||||
)
|
||||
return resultat
|
||||
+381
-75
@@ -249,7 +249,7 @@ registry = connections_service.ForgeRegistry()
|
||||
SESSION_COOKIE = "kanbante_session"
|
||||
SESSION_DAYS = 7
|
||||
_PUBLIC_PATHS = ("/api/health", "/webhooks/gitea", "/api/capture", "/login",
|
||||
"/auth/draco")
|
||||
"/login/secours", "/auth/draco")
|
||||
|
||||
|
||||
def _session_secret() -> bytes:
|
||||
@@ -263,23 +263,48 @@ def _session_secret() -> bytes:
|
||||
|
||||
|
||||
|
||||
def _make_session(user: str) -> str:
|
||||
"""Signed session cookie (0.22.0): user.expiry.hmac."""
|
||||
def _make_session(user: str, via_draco: bool = False) -> str:
|
||||
"""Signed session cookie (0.22.0): user.expiry.hmac.
|
||||
|
||||
HUB-19 (0.46.2) : une session **établie par le pont draco**
|
||||
porte un segment ``draco`` couvert par la signature
|
||||
(``user.expiry.draco.hmac``) — c'est ce marqueur infalsifiable
|
||||
qui soumet ensuite ``/admin`` au registre des rôles du Hub
|
||||
(voir ``_require_admin``). Les sessions natives gardent le
|
||||
format historique, et les deux formats restent lisibles.
|
||||
"""
|
||||
exp = int(time.time()) + SESSION_DAYS * 86400
|
||||
charge = f"{user}.{exp}.draco" if via_draco else f"{user}.{exp}"
|
||||
sig = hmac.new(
|
||||
_session_secret(), f"{user}.{exp}".encode("utf-8"), hashlib.sha256
|
||||
_session_secret(), charge.encode("utf-8"), hashlib.sha256
|
||||
).hexdigest()
|
||||
return f"{user}.{exp}.{sig}"
|
||||
return f"{charge}.{sig}"
|
||||
|
||||
|
||||
def _session_user(request: Request) -> str | None:
|
||||
def _session_info(request: Request) -> tuple[str, bool] | None:
|
||||
"""(utilisateur, établie par draco) de la session, ou None.
|
||||
|
||||
Vérifie signature et expiration, dans les deux formats
|
||||
(natif historique et marqué draco de la 0.46.2).
|
||||
"""
|
||||
raw = request.cookies.get(SESSION_COOKIE, "")
|
||||
user, _, rest = raw.partition(".")
|
||||
exp, _, sig = rest.partition(".")
|
||||
morceaux = raw.split(".")
|
||||
if len(morceaux) < 3:
|
||||
return None
|
||||
sig = morceaux[-1]
|
||||
via_draco = len(morceaux) >= 4 and morceaux[-2] == "draco"
|
||||
if via_draco:
|
||||
exp = morceaux[-3]
|
||||
user = ".".join(morceaux[:-3])
|
||||
charge = f"{user}.{exp}.draco"
|
||||
else:
|
||||
exp = morceaux[-2]
|
||||
user = ".".join(morceaux[:-2])
|
||||
charge = f"{user}.{exp}"
|
||||
if not user or not exp or not sig:
|
||||
return None
|
||||
expected = hmac.new(
|
||||
_session_secret(), f"{user}.{exp}".encode("utf-8"), hashlib.sha256
|
||||
_session_secret(), charge.encode("utf-8"), hashlib.sha256
|
||||
).hexdigest()
|
||||
if not secrets.compare_digest(sig, expected):
|
||||
return None
|
||||
@@ -288,6 +313,14 @@ def _session_user(request: Request) -> str | None:
|
||||
return None
|
||||
except ValueError:
|
||||
return None
|
||||
return user, via_draco
|
||||
|
||||
|
||||
def _session_user(request: Request) -> str | None:
|
||||
info = _session_info(request)
|
||||
if info is None:
|
||||
return None
|
||||
user = info[0]
|
||||
# 0.24.0 : la session peut appartenir à n'importe quel
|
||||
# compte de la base (résolu ensuite par _current_user) ou,
|
||||
# en mode env pur, à l'opérateur d'environnement.
|
||||
@@ -299,6 +332,12 @@ def _session_user(request: Request) -> str | None:
|
||||
return None
|
||||
|
||||
|
||||
def _session_via_draco(request: Request) -> bool:
|
||||
"""Vrai si la session présentée a été établie par le pont draco."""
|
||||
info = _session_info(request)
|
||||
return bool(info and info[1] and _session_user(request) is not None)
|
||||
|
||||
|
||||
def _basic_ok(request: Request) -> bool:
|
||||
settings = get_settings()
|
||||
header = request.headers.get("authorization", "")
|
||||
@@ -391,15 +430,24 @@ class AuthMiddleware(BaseHTTPMiddleware):
|
||||
and _bearer_user(request) is not None:
|
||||
return await call_next(request)
|
||||
# Recherche partout (#68) : /api/search accepte aussi le jeton
|
||||
# SSO draco_session (mono-utilisateur : un jeton valide désigne
|
||||
# l'opérateur), comme les API de recherche des sœurs. Les
|
||||
# preflights OPTIONS ne portent jamais de cookies : ils sont
|
||||
# répondus par RechercheCorsMiddleware avant d'arriver ici.
|
||||
# SSO draco_session — depuis la 0.46.0 (HUB-16), par
|
||||
# utilisateur : le sub doit désigner un compte Kanbante
|
||||
# (correspondance existante, voir
|
||||
# app.accounts.resolve_draco_user) ; un jeton
|
||||
# valide sans correspondance ne désigne plus l'opérateur et
|
||||
# ne suffit plus. Aucun JIT ici : la création du compte a
|
||||
# lieu à la première connexion par le pont /auth/draco.
|
||||
# Les preflights OPTIONS ne portent jamais de cookies : ils
|
||||
# sont répondus par RechercheCorsMiddleware avant d'arriver ici.
|
||||
if path == "/api/search":
|
||||
try:
|
||||
from app import accounts as accounts_service
|
||||
from app import draco
|
||||
|
||||
if draco.claims_for(request) is not None:
|
||||
claims = draco.claims_for(request)
|
||||
if claims is not None and (
|
||||
accounts_service.resolve_draco_user(claims) is not None
|
||||
):
|
||||
return await call_next(request)
|
||||
except Exception:
|
||||
pass
|
||||
@@ -488,11 +536,30 @@ def _safe_next(raw: str) -> str:
|
||||
return "/"
|
||||
|
||||
|
||||
def _ouvrir_session(username: str, next: str) -> RedirectResponse:
|
||||
"""Réponse de connexion native : session signée posée, redirection."""
|
||||
response = RedirectResponse(_safe_next(next), status_code=303)
|
||||
response.set_cookie(
|
||||
SESSION_COOKIE,
|
||||
_make_session(username),
|
||||
max_age=SESSION_DAYS * 86400,
|
||||
httponly=True,
|
||||
samesite="lax",
|
||||
)
|
||||
return response
|
||||
|
||||
|
||||
@app.get("/login")
|
||||
async def login_page(request: Request, next: str = "/"):
|
||||
if not get_settings().auth_enabled or _session_user(request) is not None:
|
||||
return RedirectResponse(_safe_next(next), status_code=303)
|
||||
return render(request, "login.html", next=_safe_next(next), error="")
|
||||
# Porte centrale (0.46.6) : en mode actif, le gabarit ne
|
||||
# présente que l'entrée centrale (lien SSO) — aucun champ
|
||||
# local (voir app/templates/login.html et docs/porte-centrale.md).
|
||||
return render(
|
||||
request, "login.html", next=_safe_next(next), error="",
|
||||
porte_centrale=bool(get_settings().porte_centrale),
|
||||
)
|
||||
|
||||
|
||||
@app.post("/login")
|
||||
@@ -511,6 +578,25 @@ async def login_submit(
|
||||
request, "login.html", status_code=403,
|
||||
next=_safe_next(next), error="Session expirée — réessaie.",
|
||||
)
|
||||
if settings.porte_centrale:
|
||||
# Porte centrale unique (0.46.6) : en mode actif, les
|
||||
# identifiants locaux ordinaires ne sont plus acceptés
|
||||
# sur ce formulaire — ni mot de passe de base, ni repli
|
||||
# d'environnement. Seules restent : l'entrée centrale
|
||||
# (SSO ObsiGate, ci-dessous sur l'écran) et, pour
|
||||
# l'administrateur désigné, la porte de secours discrète
|
||||
# (/login/secours, identifiants d'environnement — jamais
|
||||
# proposée ici). Les sessions déjà établies ne passent
|
||||
# pas par ce formulaire et ne sont pas touchées.
|
||||
return render(
|
||||
request, "login.html", status_code=403,
|
||||
next=_safe_next(next), porte_centrale=True,
|
||||
error=(
|
||||
"La porte centrale est active sur cette instance : "
|
||||
"la connexion locale est fermée. Utilise « Se "
|
||||
"connecter avec ObsiGate (SSO) » ci-dessous."
|
||||
),
|
||||
)
|
||||
from app import accounts as accounts_service
|
||||
|
||||
user = models.get_user_by_username(username)
|
||||
@@ -528,9 +614,33 @@ async def login_submit(
|
||||
if ok and user is not None and user["active"]:
|
||||
models.log_admin(user["id"], "login.env_fallback", username)
|
||||
if not ok:
|
||||
# Fusion #144 (part Kanbante) : l'échec ne doit plus être
|
||||
# une impasse muette pour un compte de la suite. Un compte
|
||||
# créé au Hub n'a pas de mot de passe local ici (il vit
|
||||
# chez ObsiGate) : le message suggère la voie centrale —
|
||||
# le bouton « Se connecter avec ObsiGate (SSO) » présent
|
||||
# sur ce même écran — au lieu du seul refus sec. Quand
|
||||
# l'identifiant ne correspond à aucun compte local (et
|
||||
# n'est pas l'opérateur d'environnement), le message le
|
||||
# dit explicitement : c'est le cas typique du compte
|
||||
# centralisé essayé dans le formulaire local.
|
||||
if user is None and username != settings.auth_user:
|
||||
erreur = (
|
||||
"Identifiants incorrects — aucun compte local ne "
|
||||
"correspond à cet identifiant. Si ton compte a été "
|
||||
"créé dans la suite Dracodev (au Hub), il n'a pas "
|
||||
"de mot de passe local ici : utilise « Se connecter "
|
||||
"avec ObsiGate (SSO) » ci-dessous."
|
||||
)
|
||||
else:
|
||||
erreur = (
|
||||
"Identifiants incorrects. Si tu te connectes avec "
|
||||
"un compte de la suite Dracodev, utilise plutôt "
|
||||
"« Se connecter avec ObsiGate (SSO) » ci-dessous."
|
||||
)
|
||||
return render(
|
||||
request, "login.html", status_code=401,
|
||||
next=_safe_next(next), error="Identifiants incorrects.",
|
||||
next=_safe_next(next), error=erreur,
|
||||
)
|
||||
if user is not None:
|
||||
models.update_user(
|
||||
@@ -539,8 +649,10 @@ async def login_submit(
|
||||
"%Y-%m-%d %H:%M:%S", time.gmtime()
|
||||
),
|
||||
)
|
||||
# First doubly-connected visit: link the draco identity
|
||||
# to this account (same mechanics as the other apps).
|
||||
# Première visite doublement connectée : la session
|
||||
# native vient d'être authentifiée par mot de passe —
|
||||
# lier l'identité draco à ce compte est la voie (b) de
|
||||
# liaison explicite de l'amorçage (fusion #145).
|
||||
from app import draco
|
||||
|
||||
claims = draco.claims_for(request)
|
||||
@@ -548,15 +660,88 @@ async def login_submit(
|
||||
sub = claims.get("sub")
|
||||
if sub and models.get_user_by_draco(sub) is None:
|
||||
models.update_user(user["id"], draco_sub=sub)
|
||||
response = RedirectResponse(_safe_next(next), status_code=303)
|
||||
response.set_cookie(
|
||||
SESSION_COOKIE,
|
||||
_make_session(username),
|
||||
max_age=SESSION_DAYS * 86400,
|
||||
httponly=True,
|
||||
samesite="lax",
|
||||
return _ouvrir_session(username, next)
|
||||
|
||||
|
||||
# ── Porte de secours administrateur (0.46.6) ──────────────────
|
||||
# Chemin discret /login/secours : jamais lié ni proposé sur
|
||||
# l'écran principal (ni en mode porte centrale, ni sinon).
|
||||
# Un seul compte, désigné par l'environnement :
|
||||
# KANBANTE_PORTE_SECOURS_USER / KANBANTE_PORTE_SECOURS_PASSWORD
|
||||
# (voir app/config.py). Le compte désigné doit être un
|
||||
# administrateur local actif (ou l'opérateur d'environnement) :
|
||||
# un membre désigné par erreur ne passe pas. Sans les deux
|
||||
# variables, la porte n'existe pas (404 sec, sans explication).
|
||||
|
||||
def _porte_secours_configuree(settings) -> bool:
|
||||
return bool(settings.porte_secours_user and settings.porte_secours_password)
|
||||
|
||||
|
||||
@app.get("/login/secours")
|
||||
async def login_secours_page(request: Request, next: str = "/"):
|
||||
settings = get_settings()
|
||||
if not settings.auth_enabled or _session_user(request) is not None:
|
||||
return RedirectResponse(_safe_next(next), status_code=303)
|
||||
if not _porte_secours_configuree(settings):
|
||||
return render(
|
||||
request, "error.html", status_code=404,
|
||||
message="Page introuvable.",
|
||||
)
|
||||
return render(
|
||||
request, "login.html", next=_safe_next(next), error="",
|
||||
mode_secours=True,
|
||||
)
|
||||
return response
|
||||
|
||||
|
||||
@app.post("/login/secours")
|
||||
async def login_secours_submit(
|
||||
request: Request,
|
||||
username: str = Form(""),
|
||||
password: str = Form(""),
|
||||
next: str = Form("/"),
|
||||
csrf_token: str = Form(""),
|
||||
):
|
||||
settings = get_settings()
|
||||
if not settings.auth_enabled:
|
||||
return RedirectResponse("/", status_code=303)
|
||||
if not _porte_secours_configuree(settings):
|
||||
return render(
|
||||
request, "error.html", status_code=404,
|
||||
message="Page introuvable.",
|
||||
)
|
||||
if not _csrf_valid(request, csrf_token):
|
||||
return render(
|
||||
request, "login.html", status_code=403, mode_secours=True,
|
||||
next=_safe_next(next), error="Session expirée — réessaie.",
|
||||
)
|
||||
identifiants_ok = secrets.compare_digest(
|
||||
username, settings.porte_secours_user
|
||||
) and secrets.compare_digest(password, settings.porte_secours_password)
|
||||
compte = (
|
||||
models.get_user_by_username(settings.porte_secours_user)
|
||||
if identifiants_ok
|
||||
else None
|
||||
)
|
||||
if compte is not None:
|
||||
admin_ok = bool(compte["active"]) and compte["role"] == "admin"
|
||||
else:
|
||||
# Pas de ligne en base : seul l'opérateur d'environnement
|
||||
# (administrateur synthétique) peut être le compte désigné.
|
||||
admin_ok = settings.porte_secours_user == settings.auth_user
|
||||
if not identifiants_ok or not admin_ok:
|
||||
return render(
|
||||
request, "login.html", status_code=401, mode_secours=True,
|
||||
next=_safe_next(next), error="Identifiants incorrects.",
|
||||
)
|
||||
if compte is not None:
|
||||
models.update_user(
|
||||
compte["id"],
|
||||
last_login_at=time.strftime(
|
||||
"%Y-%m-%d %H:%M:%S", time.gmtime()
|
||||
),
|
||||
)
|
||||
models.log_admin(compte["id"], "login.porte_secours", username)
|
||||
return _ouvrir_session(settings.porte_secours_user, next)
|
||||
|
||||
|
||||
@app.get("/logout")
|
||||
@@ -571,67 +756,103 @@ def draco_bridge(request: Request, next: str = "/"):
|
||||
"""Fusion ACC-3.2 — pont SSO : cookie ``draco_session`` → session.
|
||||
|
||||
Point de retour de ``GET /sso/authorize`` de l'émettrice
|
||||
(ObsiGate). Depuis 0.24.0 la liaison est PAR UTILISATEUR :
|
||||
si le ``sub`` draco est lié à un compte, sa session est
|
||||
créée ; si une session native est déjà ouverte, le ``sub``
|
||||
est lié à ce compte (première visite doublement connectée) ;
|
||||
sans compte lié, retour au login — la connexion native qui
|
||||
suit crée le lien (voir login_submit). Sans utilisateurs en
|
||||
base, comportement historique : session de l'opérateur.
|
||||
(ObsiGate). Depuis la 0.46.0 (HUB-16), la correspondance est
|
||||
PAR UTILISATEUR et l'hypothèse mono-utilisateur a disparu —
|
||||
résolution centralisée dans app.accounts.resolve_draco_user :
|
||||
|
||||
- session native déjà ouverte : le ``sub`` libre est lié à
|
||||
ce compte (première visite doublement connectée, inchangé) —
|
||||
c'est la voie (b) de la liaison explicite de l'amorçage ;
|
||||
- ``sub`` lié à un compte : sa session est ouverte ;
|
||||
- compte d'amorçage (unique compte, admin, sans liaison) :
|
||||
adoption CONDITIONNÉE (fusion #145, 0.46.5) — seulement si
|
||||
le registre du Hub donne « administrateur » pour kanbante
|
||||
à ce ``sub`` (rôle consulté ci-dessous et transmis à la
|
||||
résolution) ; dans le doute (Hub muet, rôle moindre), PAS
|
||||
d'adoption : le parcours ordinaire suit, ci-dessous ;
|
||||
- sinon : création JIT d'un compte propre à cette identité
|
||||
(rôle membre, mot de passe local aléatoire non divulgué)
|
||||
et ouverture de sa session.
|
||||
|
||||
Un ``sub`` inconnu n'ouvre plus jamais la session de
|
||||
l'opérateur d'environnement ni celle d'un compte non lié.
|
||||
Inerte sans ``DRACO_SESSION_SECRET``.
|
||||
|
||||
HUB-19 (0.46.2, contrat D3(a)) : le registre des rôles du Hub
|
||||
est consulté **en premier** — avant la liaison à une session
|
||||
native, avant la résolution de la correspondance et avant
|
||||
toute création JIT. Rôle connu ``aucun`` → le pont refuse :
|
||||
aucune session Kanbante n'est ouverte par draco pour ce
|
||||
``sub`` et aucun compte n'est créé. Rôle inconnu (Hub
|
||||
injoignable) → comportement actuel, inchangé. Les autres
|
||||
accès ne passent pas par ce pont et ne sont pas touchés :
|
||||
session native préexistante, connexion native (mot de
|
||||
passe), Basic d'environnement, jetons ``kbt_``.
|
||||
"""
|
||||
from app import accounts as accounts_service
|
||||
from app import draco
|
||||
from app import hub_roles
|
||||
|
||||
settings = get_settings()
|
||||
claims = draco.claims_for(request)
|
||||
if not settings.auth_enabled or claims is None:
|
||||
return RedirectResponse("/login", status_code=303)
|
||||
sub = claims.get("sub")
|
||||
sub = str(claims.get("sub") or "")
|
||||
if not sub:
|
||||
return RedirectResponse("/login", status_code=303)
|
||||
# HUB-19 : consultation du registre AVANT toute résolution
|
||||
# ou création (resolve_draco_user peut créer le compte JIT :
|
||||
# un sub refusé ne doit jamais en recevoir un).
|
||||
role_hub = hub_roles.role_pour(
|
||||
request.headers.get("cookie", ""), sub,
|
||||
hote=request.headers.get("host"),
|
||||
)
|
||||
if role_hub == "aucun":
|
||||
return render(
|
||||
request, "error.html", status_code=403,
|
||||
message=(
|
||||
"Accès refusé : le registre des rôles de la suite "
|
||||
"(Hub Dracodev) attribue le niveau « aucun » à "
|
||||
"votre compte pour Kanbante — l'ouverture de "
|
||||
"session par draco est refusée et aucun compte "
|
||||
"Kanbante n'a été créé. L'administrateur de la "
|
||||
"suite peut modifier ce niveau dans la matrice "
|
||||
"des rôles du Hub. Vos autres accès à Kanbante "
|
||||
"(connexion par mot de passe, session déjà "
|
||||
"ouverte) ne sont pas touchés."
|
||||
),
|
||||
)
|
||||
# Déjà connecté nativement : lier le sub à ce compte.
|
||||
# C'est la voie (b) de l'adoption de l'amorçage (fusion
|
||||
# #145) : la liaison est initiée par l'utilisateur déjà
|
||||
# authentifié en session native, qui connaît donc les
|
||||
# identifiants du compte qu'il lie — aucun rôle du registre
|
||||
# n'est exigé pour CE geste explicite (le refus « aucun »
|
||||
# ci-dessus continue de le précéder, patron HUB-19).
|
||||
current = _current_user(request)
|
||||
if current is not None and current.get("id") is not None:
|
||||
if sub and not current.get("draco_sub"):
|
||||
if not current.get("draco_sub"):
|
||||
if models.get_user_by_draco(sub) is None:
|
||||
models.update_user(current["id"], draco_sub=sub)
|
||||
models.log_admin(current["id"], "draco.link", str(sub))
|
||||
models.log_admin(current["id"], "draco.link", sub)
|
||||
return RedirectResponse(_safe_next(next), status_code=303)
|
||||
# Compte lié à ce sub : ouvrir sa session.
|
||||
linked = models.get_user_by_draco(sub) if sub else None
|
||||
if linked is not None and linked["active"]:
|
||||
# Correspondance, amorçage conditionné ou création JIT :
|
||||
# ouvrir la session du compte que ce sub désigne — et
|
||||
# seulement lui. Le rôle du registre consulté ci-dessus est
|
||||
# transmis à la résolution : c'est lui (et lui seul, hors
|
||||
# session native déjà traitée plus haut) qui peut autoriser
|
||||
# l'adoption du compte d'amorçage (fusion #145).
|
||||
# La session est marquée « établie par draco » (segment signé,
|
||||
# voir _make_session) : c'est elle, et elle seule, que le
|
||||
# garde de /admin soumettra au registre du Hub.
|
||||
user = accounts_service.resolve_draco_user(
|
||||
claims, provisionner=True, role_hub=role_hub
|
||||
)
|
||||
if user is not None:
|
||||
response = RedirectResponse(_safe_next(next), status_code=303)
|
||||
response.set_cookie(
|
||||
SESSION_COOKIE,
|
||||
_make_session(linked["username"]),
|
||||
max_age=SESSION_DAYS * 86400,
|
||||
httponly=True,
|
||||
samesite="lax",
|
||||
)
|
||||
return response
|
||||
if models.count_users() == 1:
|
||||
# Mono-utilisateur (cas historique) : le premier sub
|
||||
# valide se lie au compte unique et ouvre sa session —
|
||||
# c'est la sémantique livrée en 0.23.0, conservée tant
|
||||
# qu'il n'y a qu'un seul compte.
|
||||
sole = models.list_users()[0]
|
||||
if sole["active"]:
|
||||
if sub and not sole.get("draco_sub"):
|
||||
if models.get_user_by_draco(sub) is None:
|
||||
models.update_user(sole["id"], draco_sub=sub)
|
||||
response = RedirectResponse(_safe_next(next), status_code=303)
|
||||
response.set_cookie(
|
||||
SESSION_COOKIE,
|
||||
_make_session(sole["username"]),
|
||||
max_age=SESSION_DAYS * 86400,
|
||||
httponly=True,
|
||||
samesite="lax",
|
||||
)
|
||||
return response
|
||||
if models.count_users() == 0:
|
||||
# Mode env pur (aucun compte) : session de l'opérateur.
|
||||
response = RedirectResponse(_safe_next(next), status_code=303)
|
||||
response.set_cookie(
|
||||
SESSION_COOKIE,
|
||||
_make_session(settings.auth_user),
|
||||
_make_session(user["username"], via_draco=True),
|
||||
max_age=SESSION_DAYS * 86400,
|
||||
httponly=True,
|
||||
samesite="lax",
|
||||
@@ -1014,6 +1235,28 @@ def _require_admin(request: Request) -> dict | None:
|
||||
user = _current_user(request)
|
||||
if user is None or user.get("role") != "admin":
|
||||
return None
|
||||
# HUB-19 (0.46.2) : pour une session **établie par le pont
|
||||
# draco** (marqueur signé, voir _make_session), si le rôle du
|
||||
# registre du Hub est connu, il faut AUSSI « administrateur »
|
||||
# dans le registre — en plus du rôle local ci-dessus. Rôle
|
||||
# inconnu (Hub injoignable) ou session native (mot de passe,
|
||||
# Basic, jeton) : règles locales actuelles, inchangées. Ce
|
||||
# garde couvre /admin et toutes ses actions (même fonction).
|
||||
if _session_via_draco(request):
|
||||
from app import draco
|
||||
from app import hub_roles
|
||||
|
||||
sub = str(user.get("draco_sub") or "")
|
||||
if not sub:
|
||||
claims = draco.claims_for(request)
|
||||
sub = str((claims or {}).get("sub") or "")
|
||||
if sub:
|
||||
role_hub = hub_roles.role_pour(
|
||||
request.headers.get("cookie", ""), sub,
|
||||
hote=request.headers.get("host"),
|
||||
)
|
||||
if role_hub is not None and role_hub != "administrateur":
|
||||
return None
|
||||
return user
|
||||
|
||||
|
||||
@@ -1164,6 +1407,62 @@ async def admin_reset_user(
|
||||
return RedirectResponse("/admin?msg=Mot+de+passe+r%C3%A9initialis%C3%A9", status_code=303)
|
||||
|
||||
|
||||
@app.post("/admin/users/{user_id}/draco")
|
||||
async def admin_draco_user(
|
||||
request: Request,
|
||||
user_id: int,
|
||||
draco_sub: str = Form(""),
|
||||
csrf_token: str = Form(""),
|
||||
):
|
||||
"""Liaison draco par l'administrateur (HUB-16, 0.46.0).
|
||||
|
||||
C'est le mécanisme de liaison des comptes Kanbante
|
||||
préexistants : l'administrateur saisit le ``sub`` draco du
|
||||
compte (colonne Draco de /admin) ; un champ vide délie.
|
||||
Un ``sub`` déjà lié à un autre compte est refusé (la
|
||||
correspondance est biunivoque : users.draco_sub est UNIQUE).
|
||||
Contrairement au rôle et à l'activation, le geste est permis
|
||||
sur son propre compte : c'est la voie manuelle qui établit la
|
||||
correspondance du compte d'amorçage si le premier passage ne
|
||||
l'a pas fait. Le registre matriciel côté Hub (HUB-19) lira
|
||||
cette même correspondance ; ici, seul le côté Kanbante est
|
||||
requis. Procédure : docs/correspondance-draco.md.
|
||||
"""
|
||||
from urllib.parse import quote as _q
|
||||
|
||||
admin = _require_admin(request)
|
||||
if admin is None:
|
||||
return _admin_denied(request)
|
||||
if not _csrf_valid(request, csrf_token):
|
||||
return _csrf_error()
|
||||
target = models.get_user(user_id)
|
||||
if target is None:
|
||||
return RedirectResponse("/admin", status_code=303)
|
||||
sub = draco_sub.strip()
|
||||
if sub:
|
||||
autre = models.get_user_by_draco(sub)
|
||||
if autre is not None and autre["id"] != user_id:
|
||||
return RedirectResponse(
|
||||
"/admin?err="
|
||||
+ _q("Identité draco déjà liée à un autre compte"),
|
||||
status_code=303,
|
||||
)
|
||||
models.update_user(user_id, draco_sub=sub)
|
||||
models.log_admin(
|
||||
admin.get("id"), "draco.link.admin",
|
||||
f"{target['username']} : {sub}",
|
||||
)
|
||||
return RedirectResponse(
|
||||
"/admin?msg=" + _q("Liaison draco enregistrée"),
|
||||
status_code=303,
|
||||
)
|
||||
models.update_user(user_id, draco_sub=None)
|
||||
models.log_admin(admin.get("id"), "draco.unlink.admin", target["username"])
|
||||
return RedirectResponse(
|
||||
"/admin?msg=" + _q("Liaison draco retirée"), status_code=303
|
||||
)
|
||||
|
||||
|
||||
@app.get("/admin/connections")
|
||||
async def admin_connections(request: Request, msg: str = "", err: str = ""):
|
||||
admin = _require_admin(request)
|
||||
@@ -1902,11 +2201,18 @@ async def admin_settings_save(request: Request, csrf_token: str = Form("")):
|
||||
if raw is None or str(raw).strip() == "":
|
||||
continue # champ vide = retour à la valeur d'environnement
|
||||
try:
|
||||
overrides[key] = (
|
||||
str(raw).strip()
|
||||
if converter is str
|
||||
else converter(str(raw).strip())
|
||||
)
|
||||
if converter is bool:
|
||||
# Booléen lu EXPLICITEMENT (0.46.6) : bool("false")
|
||||
# vaudrait True — un réglage booléen du panneau
|
||||
# (porte_centrale, sync_*, briefing_*) doit pouvoir
|
||||
# se désactiver en saisissant « false ».
|
||||
overrides[key] = str(raw).strip().lower() in (
|
||||
"1", "true", "on", "oui",
|
||||
)
|
||||
elif converter is str:
|
||||
overrides[key] = str(raw).strip()
|
||||
else:
|
||||
overrides[key] = converter(str(raw).strip())
|
||||
except (TypeError, ValueError):
|
||||
continue
|
||||
import json as _json
|
||||
|
||||
+4
-2
@@ -1012,12 +1012,14 @@ def create_user(
|
||||
role: str = "member",
|
||||
display_name: str = "",
|
||||
must_change_password: int = 0,
|
||||
draco_sub: str | None = None,
|
||||
) -> int:
|
||||
with get_db() as conn:
|
||||
cur = conn.execute(
|
||||
"INSERT INTO users (username, password_hash, role, display_name, "
|
||||
"must_change_password) VALUES (?, ?, ?, ?, ?)",
|
||||
(username, password_hash, role, display_name, must_change_password),
|
||||
"must_change_password, draco_sub) VALUES (?, ?, ?, ?, ?, ?)",
|
||||
(username, password_hash, role, display_name,
|
||||
must_change_password, draco_sub),
|
||||
)
|
||||
return int(cur.lastrowid)
|
||||
|
||||
|
||||
@@ -123,6 +123,15 @@
|
||||
requête, dérivation par l'agent, défaut officiel) ;
|
||||
le Hub n'a pas d'onglet, urls.hub alimente les liens
|
||||
du menu compte. */
|
||||
/* Barre v0.6.0 (fusion #142) : JS/CSS re-vendangés
|
||||
verbatim — le menu compte gagne l'entrée
|
||||
« Administration » (lien Hub <hub>/admin) à visibilité
|
||||
conditionnelle. Kanbante ne passe PAS le drapeau admin :
|
||||
il ne connaît que le rôle du registre du Hub pour sa
|
||||
propre app (consulté avant la création JIT), pas le
|
||||
rôle global de suite (rôle du compte chez ObsiGate) —
|
||||
à défaut de certitude, l'entrée reste masquée ici,
|
||||
comme le contrat l'exige. */
|
||||
urls: { hub: "{{ draco_urls.hub }}/" },
|
||||
/* v0.1.6 : user = initiale auth_user ou K (draco_avatar). Sans
|
||||
cfg.user, le nouveau JS dériverait l'initiale du title
|
||||
@@ -152,8 +161,24 @@
|
||||
donc RETIRÉE : la page /profile elle-même continue
|
||||
d'exister (jetons API, réglages du compte Kanbante),
|
||||
mais elle n'est plus la cible du menu compte de la
|
||||
barre. « Déconnexion » reste relayée, inchangée. */
|
||||
if (act === "deconnexion") { location.href = "/logout"; return; }
|
||||
barre. « Déconnexion » : voir la branche ci-dessous. */
|
||||
if (act === "deconnexion") {
|
||||
/* Fusion #141 : la déconnexion n'est plus seulement
|
||||
locale. Détruire d'abord la session Kanbante
|
||||
(GET /logout), puis naviguer vers la déconnexion
|
||||
globale de l'émettrice (ObsiGate, GET /sso/logout)
|
||||
avec retour ici — le jti draco y est révoqué et le
|
||||
cookie effacé sur le domaine parent. Avant ce
|
||||
correctif, le seul /logout laissait la session SSO
|
||||
vivante : le pont /auth/draco rouvrait une session
|
||||
Kanbante sans mot de passe. */
|
||||
var retourKb = encodeURIComponent(location.origin + "/");
|
||||
var cibleKb = "{{ draco_urls.obsigate }}/sso/logout?return_to=" + retourKb;
|
||||
fetch("/logout", { credentials: "same-origin" })
|
||||
.catch(function () { })
|
||||
.finally(function () { location.href = cibleKb; });
|
||||
return;
|
||||
}
|
||||
if (act === "palette") { location.href = "/recherche"; return; }
|
||||
if (act === "alertes") { if (window.DRACO_ALERTES) { window.DRACO_ALERTES.open(); } else { location.href = "/activity"; } return; }
|
||||
/* Correctif fusion #70 : action "menu" supprimée avec le bouton trois points (console agent dans le menu de la marque). */
|
||||
|
||||
@@ -20,9 +20,10 @@
|
||||
|
||||
<section class="briefing-card">
|
||||
<h2>Utilisateurs ({{ users|length }})</h2>
|
||||
<p class="notes-hint">Correspondance draco (SSO, HUB-16) : chaque identité draco (<code>sub</code>) désigne <strong>son</strong> compte Kanbante. Un compte de suite sans correspondance est créé automatiquement à sa première connexion draco (JIT, rôle membre). Pour un compte Kanbante <strong>préexistant</strong>, c'est ici que l'administrateur établit la liaison : saisir le <code>sub</code> draco du compte puis « Lier » (champ affiché = délier). Un <code>sub</code> ne peut être lié qu'à un seul compte. Procédure complète : <code>docs/correspondance-draco.md</code>.</p>
|
||||
<table class="proj-table">
|
||||
<thead>
|
||||
<tr><th>Utilisateur</th><th>Rôle</th><th>État</th><th>Draco</th><th>Dernière connexion</th><th>Actions</th></tr>
|
||||
<tr><th>Utilisateur</th><th>Rôle</th><th>État</th><th>Draco (sub)</th><th>Dernière connexion</th><th>Actions</th></tr>
|
||||
</thead>
|
||||
<tbody>
|
||||
{% for u in users %}
|
||||
@@ -38,7 +39,22 @@
|
||||
</form>
|
||||
</td>
|
||||
<td>{% if u.active %}Actif{% else %}Désactivé{% endif %}</td>
|
||||
<td>{% if u.draco_sub %}lié{% else %}—{% endif %}</td>
|
||||
<td>
|
||||
{% if u.draco_sub %}
|
||||
<code>{{ u.draco_sub }}</code>
|
||||
<form method="post" action="/admin/users/{{ u.id }}/draco" class="inline-form">
|
||||
<input type="hidden" name="csrf_token" value="{{ csrf_token }}">
|
||||
<input type="hidden" name="draco_sub" value="">
|
||||
<button type="submit" class="btn-mini">Délier</button>
|
||||
</form>
|
||||
{% else %}
|
||||
<form method="post" action="/admin/users/{{ u.id }}/draco" class="inline-form">
|
||||
<input type="hidden" name="csrf_token" value="{{ csrf_token }}">
|
||||
<input type="text" name="draco_sub" placeholder="sub draco" size="12" autocomplete="off">
|
||||
<button type="submit" class="btn-mini">Lier</button>
|
||||
</form>
|
||||
{% endif %}
|
||||
</td>
|
||||
<td>{{ u.last_login_at or '—' }}</td>
|
||||
<td class="admin-actions">
|
||||
<form method="post" action="/admin/users/{{ u.id }}/toggle" class="inline-form">
|
||||
|
||||
@@ -19,6 +19,29 @@
|
||||
{% if error %}
|
||||
<p class="login-error" role="alert">{{ error }}</p>
|
||||
{% endif %}
|
||||
{% if mode_secours|default(false) %}
|
||||
{# Porte de secours administrateur (0.46.6) : ce gabarit n'est
|
||||
rendu que par le chemin discret /login/secours, jamais
|
||||
proposé depuis l'écran principal. #}
|
||||
<p class="login-sub">Porte de secours — administrateur désigné uniquement.</p>
|
||||
<form method="post" action="/login/secours" class="login-form">
|
||||
<input type="hidden" name="csrf_token" value="{{ csrf_token }}">
|
||||
<input type="hidden" name="next" value="{{ next }}">
|
||||
<label>Nom d'utilisateur
|
||||
<input type="text" name="username" autocomplete="username" required autofocus>
|
||||
</label>
|
||||
<label>Mot de passe
|
||||
<input type="password" name="password" autocomplete="current-password" required>
|
||||
</label>
|
||||
<button type="submit" class="login-submit">Se connecter</button>
|
||||
</form>
|
||||
{% elif porte_centrale|default(false) %}
|
||||
{# Porte centrale unique (0.46.6) : aucune entrée locale —
|
||||
seule l'entrée centrale est présentée. #}
|
||||
<p class="login-sub">Cette instance se connecte par la porte centrale de la suite Dracodev : ton compte du Hub ouvre Kanbante via ObsiGate, sans mot de passe local.</p>
|
||||
<a class="login-sso" href="{{ sso_authorize_url }}">Se connecter avec ObsiGate (SSO)</a>
|
||||
<p class="login-foot">Accès restreint — session de {{ 7 }} jours, déconnexion depuis le menu latéral.</p>
|
||||
{% else %}
|
||||
<form method="post" action="/login" class="login-form">
|
||||
<input type="hidden" name="csrf_token" value="{{ csrf_token }}">
|
||||
<input type="hidden" name="next" value="{{ next }}">
|
||||
@@ -32,6 +55,7 @@
|
||||
</form>
|
||||
<a class="login-sso" href="{{ sso_authorize_url }}">Se connecter avec ObsiGate (SSO)</a>
|
||||
<p class="login-foot">Accès restreint — session de {{ 7 }} jours, déconnexion depuis le menu latéral.</p>
|
||||
{% endif %}
|
||||
</section>
|
||||
</main>
|
||||
</body>
|
||||
|
||||
@@ -92,7 +92,7 @@
|
||||
<button type="submit" class="btn-mini">Délier</button>
|
||||
</form>
|
||||
{% else %}
|
||||
<p class="muted">Pas de liaison. Elle se crée automatiquement à la première visite où ta session Kanbante et ton cookie draco coexistent (par exemple en arrivant depuis ObsiGate).</p>
|
||||
<p class="muted">Pas de liaison. Elle se crée automatiquement à la première visite où ta session Kanbante et ton cookie draco coexistent (par exemple en arrivant depuis ObsiGate) ; un administrateur peut aussi l'établir depuis la page Administration. Sans compte lié, la première connexion draco d'une identité de suite crée automatiquement son propre compte Kanbante (JIT).</p>
|
||||
{% endif %}
|
||||
</section>
|
||||
|
||||
|
||||
@@ -0,0 +1,185 @@
|
||||
# Correspondance draco par utilisateur (HUB-16, 0.46.0)
|
||||
|
||||
Kanbante participe au SSO de la suite dracodev : ObsiGate émet le
|
||||
cookie `draco_session` (JWS HS256, claims `sub`, `name`, `iat`,
|
||||
`exp`, `jti`), Kanbante le valide localement (`app/draco.py`) et le
|
||||
pont `GET /auth/draco` le convertit en session Kanbante native.
|
||||
|
||||
Depuis la 0.46.0, un jeton draco valide désigne **le compte
|
||||
Kanbante de cette identité** — et aucun autre. L'ancienne
|
||||
hypothèse mono-utilisateur (« un jeton valide = l'opérateur ») a
|
||||
disparu. C'est ce qui fait tenir le critère de la suite : « un
|
||||
compte créé fonctionne dans toutes les applications ».
|
||||
|
||||
## Où vit la correspondance
|
||||
|
||||
Dans le modèle existant des comptes : la colonne
|
||||
**`users.draco_sub`** (texte, `UNIQUE`, présente depuis la 0.24.0)
|
||||
porte le `sub` draco lié à chaque compte Kanbante.
|
||||
`models.get_user_by_draco(sub)` est la résolution canonique ; la
|
||||
règle de décision complète vit dans
|
||||
`app.accounts.resolve_draco_user()`, seul point d'entrée du pont
|
||||
et du contrôle draco de `/api/search`. La correspondance est donc
|
||||
biunivoque : un `sub` ↔ un compte, garanti par la contrainte
|
||||
d'unicité.
|
||||
|
||||
## Résolution d'une connexion draco (`/auth/draco`)
|
||||
|
||||
Dans l'ordre :
|
||||
|
||||
1. **Session native déjà ouverte** : si le navigateur porte à la
|
||||
fois une session Kanbante et un cookie draco dont le `sub`
|
||||
n'est lié à aucun compte, le `sub` est lié au compte de la
|
||||
session (première visite doublement connectée — mécanisme
|
||||
historique, inchangé, aussi appliqué à la connexion native
|
||||
dans `login_submit`).
|
||||
2. **Correspondance existante** : la session du compte lié est
|
||||
ouverte. Un compte **désactivé** n'ouvre aucune session et
|
||||
n'est jamais contourné (voir § Désactivation).
|
||||
3. **Compte d'amorçage — adoption conditionnée (fusion #145,
|
||||
0.46.5)** : s'il n'existe qu'**un seul compte** et que c'est un
|
||||
**admin actif sans liaison**, ce compte (celui créé à
|
||||
l'installation depuis l'environnement `KANBANTE_AUTH_USER` /
|
||||
`KANBANTE_AUTH_PASSWORD`, Bruno) n'est adopté que dans l'un
|
||||
de ces deux cas :
|
||||
- **(a)** le `sub` entrant est **« administrateur » pour
|
||||
kanbante au registre des rôles du Hub** (le pont consulte le
|
||||
registre avant la résolution et transmet le rôle à
|
||||
`resolve_draco_user()` ; Hub muet ou rôle moindre = **pas
|
||||
d'adoption**, dans le doute on ne lie pas) ;
|
||||
- **(b)** l'adoption est initiée depuis une **session native
|
||||
déjà authentifiée** (point 1 ci-dessus, ou connexion native
|
||||
doublement connectée) : l'utilisateur connecté lie
|
||||
explicitement son propre compte.
|
||||
Tout autre `sub` inconnu reçoit le parcours ordinaire
|
||||
(création JIT d'un compte **membre** propre, point 4) —
|
||||
jamais l'amorçage. Avant la 0.46.5, le premier `sub` valide
|
||||
de passage adoptait l'amorçage quel qu'il soit : sur une
|
||||
instance fraîche, un simple utilisateur de la suite devenait
|
||||
l'administrateur local (audit « compte partout » du
|
||||
2026-11-06). Les autres accès de l'amorçage restent inchangés
|
||||
dans tous les cas : connexion native avec le mot de passe du
|
||||
compte, et repli d'urgence par les identifiants
|
||||
d'environnement (formulaire et Basic), qui ne dépendent pas
|
||||
de draco.
|
||||
4. **Création JIT** : sinon, un compte Kanbante est créé pour
|
||||
cette identité (détail ci-dessous) et sa session est ouverte.
|
||||
|
||||
Un `sub` inconnu n'ouvre **jamais** la session de l'opérateur
|
||||
d'environnement ni celle d'un compte existant non lié — y compris
|
||||
si le nom affiché draco ressemble au nom d'un compte local : le
|
||||
JIT crée toujours un compte **nouveau** (nom suffixé `-2`, `-3`…
|
||||
en cas de collision), jamais une adoption.
|
||||
|
||||
## Création JIT (juste-à-temps)
|
||||
|
||||
À la première connexion draco d'une identité sans correspondance :
|
||||
|
||||
- **nom d'utilisateur** : nom affiché des claims slugifié
|
||||
(`Alice Exemple` → `alice-exemple`), libre ou suffixé ;
|
||||
repli `draco-<sub>` si le nom est inexploitable ;
|
||||
- **nom d'affichage** : le `name` des claims ;
|
||||
- **rôle** : `member` (utilisateur standard) — jamais admin ;
|
||||
- **mot de passe local** : secret aléatoire, haché (PBKDF2 comme
|
||||
tous les comptes), **jamais divulgué** — l'accès normal passe
|
||||
par draco. Un administrateur peut ensuite poser un mot de
|
||||
passe local depuis `/admin` (bouton « Réinitialiser ») si un
|
||||
accès local est voulu ;
|
||||
- **espace** : le compte rejoint l'espace Principal comme membre,
|
||||
comme tout utilisateur créé par l'administration ;
|
||||
- le geste est journalisé (`draco.jit` dans le journal
|
||||
d'administration).
|
||||
|
||||
## Liaison par l'administrateur (comptes préexistants)
|
||||
|
||||
Pour associer un compte Kanbante existant à une identité draco
|
||||
sans attendre un premier passage :
|
||||
|
||||
1. Se connecter à Kanbante avec un compte **admin**.
|
||||
2. Ouvrir **Administration** (`/admin`), section **Utilisateurs**.
|
||||
3. Dans la colonne **Draco (sub)** du compte visé, saisir le
|
||||
`sub` draco de l'identité (l'identifiant du compte de suite
|
||||
chez l'émettrice, ObsiGate) et cliquer **Lier**.
|
||||
4. La liaison est immédiate et journalisée (`draco.link.admin`).
|
||||
Le bouton **Délier** de la même colonne la retire
|
||||
(`draco.unlink.admin`).
|
||||
|
||||
Gardes : un `sub` déjà lié à un autre compte est refusé avec un
|
||||
message d'erreur (délier l'autre compte d'abord). L'administrateur
|
||||
peut lier **son propre** compte — c'est la voie manuelle pour le
|
||||
compte d'amorçage si le premier passage ne l'a pas lié.
|
||||
|
||||
Chaque utilisateur peut aussi voir sa propre liaison dans
|
||||
**Mon profil → Liaison draco (SSO)** et la délier lui-même.
|
||||
|
||||
> Le registre matriciel des rôles par application côté Hub
|
||||
> (carte HUB-19) lit cette correspondance ; la 0.46.0 ne livrait
|
||||
> que le côté Kanbante, qui reste la source de vérité locale.
|
||||
> La consommation du registre par Kanbante est décrite à la
|
||||
> section suivante (0.46.2).
|
||||
|
||||
## Rôles du Hub (HUB-19, 0.46.2)
|
||||
|
||||
Le registre des rôles du Hub (matrice par application, contrat
|
||||
D3(a)) est consulté par `app/hub_roles.py` — portage du pilote
|
||||
ShaarIt 0.7.0 : `GET {hub}/api/roles/kanbante`, en-tête Cookie
|
||||
complet de la requête relayé, délai 2 s, cache mémoire par
|
||||
`sub` de 60 s avec horodatage posé avant l'appel (un échec
|
||||
conserve l'ancien cache et ne déclenche pas de rafale). L'URL
|
||||
du Hub est celle de la barre commune (`resoudre_urls_draco`).
|
||||
Toute erreur rend un rôle **inconnu**, qui vaut toujours
|
||||
« comportement actuel » — jamais un verrouillage nouveau.
|
||||
|
||||
Effets, pour les seules sessions **établies par le pont
|
||||
draco** :
|
||||
|
||||
1. **Pont `/auth/draco`** : la consultation précède la
|
||||
liaison, la résolution de la correspondance et la création
|
||||
JIT. Rôle connu `aucun` → refus explicite (403, en
|
||||
français) : aucune session ouverte par draco pour ce
|
||||
`sub`, aucun compte créé. La session que le pont ouvre
|
||||
porte un marqueur « draco » couvert par la signature du
|
||||
cookie (`user.expiry.draco.hmac`).
|
||||
2. **`/admin`** (et ses actions, même garde
|
||||
`_require_admin`) : session établie par draco + rôle du
|
||||
registre connu ⇒ il faut `administrateur` dans le
|
||||
registre, **en plus** du rôle local. Rôle inconnu ou
|
||||
session native ⇒ règles locales, inchangées.
|
||||
|
||||
Les autres accès ne sont pas draco et ne sont pas touchés :
|
||||
session native préexistante, connexion native (mot de
|
||||
passe), Basic d'environnement, jetons `kbt_`. Ni les droits
|
||||
internes ni la réconciliation par étiquettes ne changent.
|
||||
|
||||
## Surfaces voisines
|
||||
|
||||
- **`GET /api/search`** (« Rechercher partout ») : le cookie draco
|
||||
n'y est plus accepté « en tant qu'opérateur ». Il faut que le
|
||||
`sub` désigne un compte (correspondance existante). Cette
|
||||
surface ne consulte pas le registre et n'initie aucune liaison :
|
||||
elle ne peut donc **jamais adopter le compte d'amorçage**
|
||||
(fusion #145) — l'adoption a lieu au pont, ou pas. Aucune
|
||||
création JIT sur cette surface : la création a lieu à la
|
||||
première vraie connexion, par le pont. Les autres modes d'accès
|
||||
à `/api/search` (session, Basic, jeton `kbt_`) sont inchangés.
|
||||
- **Désactivation** : désactiver un compte dans `/admin` coupe
|
||||
tous ses accès — session native, pont draco (la correspondance
|
||||
résout à « refusé ») et jetons `kbt_`. Réactiver le compte
|
||||
rétablit la correspondance telle quelle.
|
||||
|
||||
## Non-régressions garanties
|
||||
|
||||
- **Jetons personnels `kbt_`** : création, usage sur `/mcp` et
|
||||
`/api/`, révocation — inchangés ; un jeton n'ouvre toujours pas
|
||||
l'interface web.
|
||||
- **Sessions propres Kanbante** et **connexion native**
|
||||
(formulaire, mot de passe de la base) : inchangées, y compris
|
||||
la liaison automatique à la première visite doublement
|
||||
connectée.
|
||||
- **Authentification Basic** (identifiants d'environnement, pour
|
||||
les scripts) : inchangée.
|
||||
- **Pont inerte sans `DRACO_SESSION_SECRET`** : sans secret
|
||||
configuré, `/auth/draco` renvoie au login, comme avant.
|
||||
- La réconciliation Kanbante/Gitea par étiquettes (adoption d'une
|
||||
colonne seulement si exactement une étiquette `kanban:*` est
|
||||
reconnue) n'est pas touchée par cette carte.
|
||||
@@ -0,0 +1,81 @@
|
||||
# Porte centrale unique (0.46.6)
|
||||
|
||||
Programme « compte partout / porte centrale unique » : un compte
|
||||
créé au Hub n'a pas de mot de passe local (il vit chez ObsiGate) ;
|
||||
les formulaires locaux des applications ne pourront donc jamais
|
||||
l'accepter. La porte centrale fait de cette réalité le parcours
|
||||
normal : une seule entrée présentée, celle de la suite.
|
||||
|
||||
## Le réglage
|
||||
|
||||
- **Nom** : `porte_centrale` (booléen).
|
||||
- **Défaut à la livraison : désactivé.** Tant qu'il est inactif,
|
||||
Kanbante se comporte exactement comme avant (formulaire local
|
||||
+ bouton « Se connecter avec ObsiGate (SSO) »).
|
||||
- **Activation** : un administrateur Kanbante le règle dans
|
||||
**Administration → Paramètres** (ligne `porte_centrale` :
|
||||
saisir `true` pour activer, `false` pour désactiver, vide pour
|
||||
revenir à l'environnement). L'environnement peut aussi amorcer
|
||||
la valeur : `KANBANTE_PORTE_CENTRALE=1` — l'environnement
|
||||
amorce, le panneau gouverne, comme les autres réglages
|
||||
surchargeables (`app.config.OVERRIDABLE_SETTINGS`).
|
||||
|
||||
## Mode actif
|
||||
|
||||
- L'écran de connexion (`GET /login`) ne présente **que**
|
||||
l'entrée centrale : le lien « Se connecter avec ObsiGate
|
||||
(SSO) », bien visible, et un texte qui explique qu'il n'y a
|
||||
pas de mot de passe local. Aucun champ identifiant/mot de
|
||||
passe n'est rendu.
|
||||
- Le formulaire local (`POST /login`) **refuse** toute tentative
|
||||
(403), quels que soient les identifiants présentés — mot de
|
||||
passe de base comme repli d'environnement : les identifiants
|
||||
locaux ordinaires ne sont plus acceptés sur cette voie.
|
||||
- **Sessions déjà établies : aucun impact.** Le contrôle de
|
||||
session (cookie signé) ne change pas ; une session ouverte
|
||||
avant l'activation reste valide jusqu'à son expiration
|
||||
normale, et le pont draco continue d'en ouvrir par le SSO.
|
||||
- Non touchés : l'authentification Basic d'environnement (voie
|
||||
scripts historique), les jetons personnels `kbt_`, le pont
|
||||
`/auth/draco` et `/api/search`.
|
||||
|
||||
## Porte de secours administrateur
|
||||
|
||||
Pour ne jamais se verrouiller dehors (panne de l'émettrice,
|
||||
liaison à réparer…), **un** compte administrateur local désigné
|
||||
peut toujours se connecter — par un **chemin discret**, jamais
|
||||
proposé ni lié sur l'écran principal :
|
||||
|
||||
- **Chemin** : `GET /login/secours` (formulaire), `POST
|
||||
/login/secours` (connexion). Sans configuration, le chemin
|
||||
répond 404, sans explication.
|
||||
- **Désignation, par l'environnement uniquement** (secrets —
|
||||
jamais en base, jamais dans le panneau, jamais en dur) :
|
||||
- `KANBANTE_PORTE_SECOURS_USER` : nom du compte administrateur
|
||||
local désigné ;
|
||||
- `KANBANTE_PORTE_SECOURS_PASSWORD` : son mot de passe de
|
||||
secours (comparé en temps constant ; il peut différer du mot
|
||||
de passe de base du compte — c'est un identifiant dédié).
|
||||
- **Gardes** : les deux variables doivent être présentes ; le
|
||||
compte désigné doit exister en base, être **actif** et de rôle
|
||||
**admin** (ou être l'opérateur d'environnement, administrateur
|
||||
synthétique). Un membre désigné par erreur ne passe pas.
|
||||
L'ouverture de session par cette voie est journalisée
|
||||
(`login.porte_secours`).
|
||||
- La session ouverte est une session native ordinaire
|
||||
(7 jours) : l'administrateur peut ensuite désactiver la porte
|
||||
centrale dans le panneau, lier un `sub` draco, réparer une
|
||||
correspondance, etc.
|
||||
|
||||
## Fiche d'activation (résumé opérateur)
|
||||
|
||||
1. Poser `KANBANTE_PORTE_SECOURS_USER` et
|
||||
`KANBANTE_PORTE_SECOURS_PASSWORD` dans l'environnement du
|
||||
conteneur Kanbante, recréer le conteneur.
|
||||
2. Vérifier la porte de secours : ouvrir `/login/secours`,
|
||||
se connecter avec le compte désigné.
|
||||
3. Activer : Administration → Paramètres →
|
||||
`porte_centrale` = `true` → Enregistrer.
|
||||
4. Vérifier : déconnecté, `/login` ne montre que l'entrée
|
||||
ObsiGate (SSO) ; un essai de formulaire local est refusé ;
|
||||
les sessions déjà ouvertes restent valides.
|
||||
@@ -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 {
|
||||
|
||||
@@ -36,6 +36,28 @@
|
||||
* remplissage), aligné à gauche du libellé via .draco-menu-icone.
|
||||
* L'en-tête d'identité ne reçoit pas d'icône. Aucun changement de
|
||||
* comportement : liens résolus et Déconnexion relayée inchangés.
|
||||
* v0.5.0 (carte HUB-18, fusion #132) : thème commun de la suite —
|
||||
* la barre apprend la préférence de thème du profil du Hub
|
||||
* (GET <hub>/api/profil/theme, cookie draco) et l'applique à
|
||||
* l'ouverture par le mécanisme data-theme des hôtes, avec cache
|
||||
* local court et repli intégral sur le comportement actuel de
|
||||
* l'hôte si le Hub ne répond pas. Voir « Thème commun » plus bas.
|
||||
* v0.6.0 (demande de Bruno, 2026-11-06) : le menu compte gagne un
|
||||
* cinquième lien Hub, « Administration » → <hub>/admin (le Hub y
|
||||
* redirige vers /admin/utilisateurs), placé après le séparateur,
|
||||
* avant « Déconnexion », avec son icône monoline (curseurs de
|
||||
* réglage). AFFICHAGE CONDITIONNEL : l'entrée n'apparaît que si
|
||||
* l'hôte AFFIRME que le compte courant est administrateur de
|
||||
* suite — cfg.admin === true à la configuration, ou
|
||||
* DRACO_BAR.setAdmin(true) quand l'hôte l'apprend après coup
|
||||
* (patron setUrls). L'hôte ne passe le drapeau que s'il l'a établi
|
||||
* depuis SA source d'autorité (rôle global du compte chez
|
||||
* ObsiGate, niveau du registre des rôles du Hub pour son app…) ;
|
||||
* à défaut de certitude, pas de drapeau et l'entrée reste masquée.
|
||||
* La barre ne devine jamais : le jeton draco ne porte aucun rôle
|
||||
* (claims minimaux, par design). La vraie protection reste la
|
||||
* garde serveur du Hub (/admin/*), pas ce masquage d'affichage.
|
||||
* Voir le README, « Administration » — contrat de visibilité.
|
||||
*
|
||||
* 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
|
||||
@@ -48,6 +70,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/",
|
||||
@@ -268,6 +295,131 @@
|
||||
}
|
||||
var resolvedUrls = resolveUrls();
|
||||
|
||||
/* ── Thème commun (v0.5.0, carte HUB-18, fusion #132) ────────────
|
||||
* La préférence de thème de la suite vit dans le profil du Hub :
|
||||
* GET <hub>/api/profil/theme → {"theme": "sombre"|"clair"|"systeme"|null}
|
||||
* authentifié par le cookie draco (credentials: "include").
|
||||
* <hub> est l'URL RÉSOLUE ci-dessus (explicite > dérivation -dev >
|
||||
* défaut officiel) — jamais un nom figé de plus.
|
||||
* Application par le mécanisme data-theme existant des hôtes :
|
||||
* "sombre" → data-theme="dark", "clair" → data-theme="light",
|
||||
* "systeme" → attribut RETIRÉ (prefers-color-scheme décide, garde
|
||||
* html:not([data-theme]) du CSS de la barre comme des hôtes).
|
||||
* L'événement draco:theme ({theme, mode} — mode = "dark"/"light"
|
||||
* EFFECTIF) est ensuite dispatché pour les hôtes dont le mécanisme
|
||||
* propre doit suivre (icônes et libellés, feuilles de style,
|
||||
* palettes ShaarIt, attribut dédié de la console…) ; un hôte qui
|
||||
* s'initialise après la barre lit la même information dans
|
||||
* DRACO_BAR.themePref / DRACO_BAR.themeMode.
|
||||
* Ordre d'application : 1) le cache local FRAIS est appliqué de
|
||||
* façon SYNCHRONE à l'initialisation de la barre (script en defer
|
||||
* chez tous les hôtes : avant DOMContentLoaded, donc avant le
|
||||
* premier rendu dans le cas général) ; 2) un fetch ASYNCHRONE et
|
||||
* NON BLOQUANT rafraîchit le cache et ré-applique si la préférence
|
||||
* a changé. À la toute première visite (aucun cache), un bref
|
||||
* flash du thème local de l'hôte reste possible le temps du fetch :
|
||||
* c'est le prix du repli — l'état affiché transitoire est le thème
|
||||
* que l'hôte aurait de toute façon choisi seul, jamais un état
|
||||
* cassé, et les visites suivantes sont servies par le cache.
|
||||
* Cache : localStorage "draco-theme-hub" ({theme, ts}), TTL 12 h
|
||||
* (ordre de la journée) ; il ne contient QUE la préférence du Hub,
|
||||
* jamais le choix local de l'hôte.
|
||||
* REPLI INTÉGRAL : Hub injoignable, réponse non-OK (401…), JSON
|
||||
* invalide, theme null ou valeur inconnue → RIEN n'est appliqué et
|
||||
* RIEN n'est mis en cache ; un échec de fetch n'efface pas un cache
|
||||
* existant. Le comportement actuel de l'hôte (son localStorage,
|
||||
* puis le système) reste alors exactement le maître, comme avant
|
||||
* la v0.5.0. Le sélecteur de thème LOCAL de chaque hôte reste
|
||||
* fonctionnel : la barre n'applique qu'à l'ouverture (cache, puis
|
||||
* fetch) ; elle ne ré-applique ensuite que sur changement du
|
||||
* schéma système, et seulement tant que la préférence résolue est
|
||||
* "systeme". */
|
||||
var THEME_CACHE_CLE = "draco-theme-hub";
|
||||
var THEME_CACHE_TTL_MS = 12 * 60 * 60 * 1000;
|
||||
var themePref = null; /* "sombre"|"clair"|"systeme"|null (non résolue) */
|
||||
var themeMode = null; /* "dark"|"light"|null : mode effectif appliqué */
|
||||
|
||||
function themeSystemeEstSombre() {
|
||||
try {
|
||||
return !!(window.matchMedia &&
|
||||
window.matchMedia("(prefers-color-scheme: dark)").matches);
|
||||
} catch (e) { return false; }
|
||||
}
|
||||
function lireCacheTheme() {
|
||||
try {
|
||||
var brut = window.localStorage &&
|
||||
window.localStorage.getItem(THEME_CACHE_CLE);
|
||||
if (!brut) return null;
|
||||
var c = JSON.parse(brut);
|
||||
if (!c || typeof c.ts !== "number") return null;
|
||||
if (Date.now() - c.ts > THEME_CACHE_TTL_MS) return null;
|
||||
if (c.theme === "sombre" || c.theme === "clair" || c.theme === "systeme")
|
||||
return c.theme;
|
||||
} catch (e) { /* stockage indisponible ou corrompu : pas de cache */ }
|
||||
return null;
|
||||
}
|
||||
function ecrireCacheTheme(theme) {
|
||||
try {
|
||||
if (window.localStorage) {
|
||||
window.localStorage.setItem(THEME_CACHE_CLE,
|
||||
JSON.stringify({ theme: theme, ts: Date.now() }));
|
||||
}
|
||||
} catch (e) { /* stockage indisponible : le prochain fetch refera le travail */ }
|
||||
}
|
||||
function appliquerThemeCommun(theme) {
|
||||
var root = document.documentElement;
|
||||
if (!root) return;
|
||||
if (theme === "sombre" || theme === "clair") {
|
||||
themeMode = theme === "sombre" ? "dark" : "light";
|
||||
root.setAttribute("data-theme", themeMode);
|
||||
} else if (theme === "systeme") {
|
||||
themeMode = themeSystemeEstSombre() ? "dark" : "light";
|
||||
root.removeAttribute("data-theme");
|
||||
} else {
|
||||
return;
|
||||
}
|
||||
themePref = theme;
|
||||
if (window.DRACO_BAR) {
|
||||
window.DRACO_BAR.themePref = themePref;
|
||||
window.DRACO_BAR.themeMode = themeMode;
|
||||
}
|
||||
try {
|
||||
document.dispatchEvent(new CustomEvent("draco:theme",
|
||||
{ detail: { theme: themePref, mode: themeMode } }));
|
||||
} catch (e) { /* aucun écouteur hôte : data-theme suffit */ }
|
||||
}
|
||||
function initThemeCommun() {
|
||||
var enCache = lireCacheTheme();
|
||||
if (enCache) appliquerThemeCommun(enCache);
|
||||
/* Suivi du schéma système tant que la préférence est "systeme" :
|
||||
* sans data-theme, le CSS suit tout seul ; l'événement est
|
||||
* re-dispatché pour les hôtes qui matérialisent le mode. */
|
||||
try {
|
||||
var mq = window.matchMedia &&
|
||||
window.matchMedia("(prefers-color-scheme: dark)");
|
||||
if (mq && mq.addEventListener) {
|
||||
mq.addEventListener("change", function () {
|
||||
if (themePref === "systeme") appliquerThemeCommun("systeme");
|
||||
});
|
||||
}
|
||||
} catch (e) { /* pas de matchMedia : pas de suivi */ }
|
||||
if (typeof window.fetch !== "function") return;
|
||||
var url = withSlash(resolvedUrls.hub || DEFAULT_URLS.hub) +
|
||||
"api/profil/theme";
|
||||
window.fetch(url, { credentials: "include" }).then(function (resp) {
|
||||
if (!resp || !resp.ok) return null;
|
||||
return resp.json();
|
||||
}).then(function (data) {
|
||||
if (!data) return;
|
||||
var t = data.theme;
|
||||
if (t === "sombre" || t === "clair" || t === "systeme") {
|
||||
ecrireCacheTheme(t);
|
||||
appliquerThemeCommun(t);
|
||||
}
|
||||
/* theme null ou inconnu : repli intégral, rien n'est touché. */
|
||||
}).catch(function () { /* Hub injoignable : repli intégral */ });
|
||||
}
|
||||
|
||||
function setCounts(counts) {
|
||||
Object.keys(counts || {}).forEach(function (k) {
|
||||
/* Toutes les occurrences : l'onglet ET sa ligne dans le menu. */
|
||||
@@ -522,6 +674,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" }],
|
||||
@@ -556,6 +720,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
|
||||
@@ -588,6 +761,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";
|
||||
@@ -603,6 +792,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) {
|
||||
@@ -695,12 +885,23 @@
|
||||
window.DRACO_BAR = {
|
||||
setCounts: setCounts, setCurrent: setCurrent, setDomain: setDomain,
|
||||
urls: resolvedUrls,
|
||||
/* Thème commun (v0.5.0) : préférence du Hub résolue et mode
|
||||
* effectif appliqué ; null tant que rien n'a été résolu (repli). */
|
||||
themePref: null, themeMode: null,
|
||||
setUrls: function (urls) {
|
||||
cfg.urls = Object.assign({}, cfg.urls, urls || {});
|
||||
resolvedUrls = resolveUrls();
|
||||
window.DRACO_BAR.urls = resolvedUrls;
|
||||
applyUrls(resolvedUrls);
|
||||
refreshCompteHrefs();
|
||||
},
|
||||
/* Administration (v0.6.0) : l'hôte pose le drapeau quand il a
|
||||
* ÉTABLI que le compte courant est administrateur de suite
|
||||
* (sa source d'autorité — voir l'en-tête et le README). Toute
|
||||
* valeur autre que le booléen true masque l'entrée. */
|
||||
setAdmin: function (v) {
|
||||
compteAdmin = v === true;
|
||||
if (adminItem) adminItem.hidden = !compteAdmin;
|
||||
}
|
||||
};
|
||||
|
||||
@@ -709,6 +910,7 @@
|
||||
buildCompteMenu();
|
||||
syncAvatar();
|
||||
refreshCompteMenu();
|
||||
initThemeCommun();
|
||||
if (cfg.current) setCurrent(cfg.current);
|
||||
if (cfg.domain) setDomain(cfg.domain);
|
||||
if (cfg.counts) setCounts(cfg.counts);
|
||||
|
||||
@@ -63,6 +63,30 @@
|
||||
});
|
||||
}
|
||||
|
||||
/* Thème commun de la suite (HUB-18, fusion #132) : la barre
|
||||
commune (v0.5.0) applique la préférence du Hub à l'ouverture —
|
||||
directement sur data-theme depuis son cache, et via
|
||||
l'événement « draco:theme » quand le fetch aboutit. Ici, on
|
||||
resynchronise le bouton de bascule avec le mode effectif.
|
||||
Le choix local « kanbante-theme » n'est PAS écrasé : la
|
||||
préférence du Hub initialise l'ouverture, le bouton reste le
|
||||
maître pour la session (son clic mémorise comme avant).
|
||||
Repli : Hub muet → aucun événement, l'amorce de _header.html
|
||||
(choix local, défaut sombre) reste seule maître, comme avant.
|
||||
La barre (defer) s'exécute avant nav.js : sa préférence déjà
|
||||
résolue depuis son cache est aussi reprise au démarrage. */
|
||||
function appliquerThemeCommun(mode) {
|
||||
document.documentElement.setAttribute('data-theme', mode);
|
||||
syncThemeBtn(mode);
|
||||
}
|
||||
document.addEventListener('draco:theme', function (e) {
|
||||
var mode = e && e.detail && e.detail.mode;
|
||||
if (mode === 'dark' || mode === 'light') appliquerThemeCommun(mode);
|
||||
});
|
||||
if (window.DRACO_BAR && (window.DRACO_BAR.themeMode === 'dark' || window.DRACO_BAR.themeMode === 'light')) {
|
||||
appliquerThemeCommun(window.DRACO_BAR.themeMode);
|
||||
}
|
||||
|
||||
/* En mobile, le bouton de repli dans le tiroir FERME le tiroir :
|
||||
replier un tiroir de 264 px n'a pas de sens, et avant ce
|
||||
correctif il basculait l'état desktop (tiroir 68 px). */
|
||||
|
||||
@@ -0,0 +1,293 @@
|
||||
"""Fusion #145 (0.46.5) — adoption CONDITIONNÉE du compte d'amorçage.
|
||||
|
||||
Avant ce correctif, sur une instance fraîche, le premier visiteur
|
||||
du pont draco adoptait le compte administrateur d'amorçage
|
||||
(« liaison au premier passage ») — un simple utilisateur de la
|
||||
suite (« dan », audit « compte partout » du 2026-11-06) l'a fait
|
||||
en pile de contrôle. Désormais, l'adoption n'a lieu que si :
|
||||
|
||||
(a) le ``sub`` entrant est « administrateur » pour kanbante au
|
||||
registre des rôles du Hub (repli propre : Hub muet = rôle
|
||||
inconnu = PAS d'adoption) ;
|
||||
(b) ou l'adoption est initiée depuis une session native déjà
|
||||
authentifiée (liaison explicite par l'utilisateur connecté).
|
||||
|
||||
Couvert ici, sur instance RÉELLEMENT fraîche (base SQLite
|
||||
temporaire propre à chaque test : au démarrage, seul le compte
|
||||
d'amorçage créé depuis l'environnement existe, sans liaison) :
|
||||
|
||||
(i) sub simple utilisateur → compte membre JIT propre,
|
||||
amorçage intact et toujours sans liaison ;
|
||||
(ii) sub administrateur au registre → adoption de l'amorçage ;
|
||||
(ii-bis) Hub muet (rôle inconnu) → pas d'adoption, JIT membre ;
|
||||
(iii) liaison existante (cas de production) → résolution
|
||||
inchangée, quel que soit le rôle du registre ;
|
||||
(iv) session native authentifiée → liaison explicite de
|
||||
l'amorçage possible (pont et résolution directe) ;
|
||||
|
||||
plus la part Kanbante de la fusion #144 : l'échec du formulaire
|
||||
local suggère la voie « Se connecter avec ObsiGate (SSO) ».
|
||||
|
||||
Le faux Hub suit le patron de tests/test_hub_roles.py : l'appel
|
||||
``httpx.get`` du client du registre est simulé, les rôles sont
|
||||
lus dans le cookie relayé.
|
||||
"""
|
||||
|
||||
import base64
|
||||
import hashlib
|
||||
import hmac
|
||||
import json
|
||||
import time
|
||||
|
||||
import httpx
|
||||
import pytest
|
||||
from fastapi.testclient import TestClient
|
||||
|
||||
import app.main as main
|
||||
from app import accounts, draco, hub_roles, models
|
||||
|
||||
SECRET = "secret-amorcage-145"
|
||||
|
||||
SUB_SIMPLE = "fus145-simple"
|
||||
SUB_ADMIN = "fus145-admin"
|
||||
SUB_INCONNU = "fus145-inconnu"
|
||||
SUB_LIE = "fus145-deja-lie"
|
||||
SUB_NATIF = "fus145-natif"
|
||||
SUB_NATIF_DIRECT = "fus145-natif-direct"
|
||||
|
||||
|
||||
def _jeton(sub, nom="Visiteur Exemple", secret=SECRET):
|
||||
def b64(d: bytes) -> str:
|
||||
return base64.urlsafe_b64encode(d).rstrip(b"=").decode()
|
||||
|
||||
header = b64(json.dumps({"alg": "HS256", "typ": "JWT"}).encode())
|
||||
payload = b64(json.dumps({
|
||||
"sub": sub, "name": nom, "iat": int(time.time()),
|
||||
"exp": int(time.time()) + 3600, "jti": f"jti-{sub}",
|
||||
}).encode())
|
||||
sig = hmac.new(secret.encode(), f"{header}.{payload}".encode(),
|
||||
hashlib.sha256).digest()
|
||||
return f"{header}.{payload}.{b64(sig)}"
|
||||
|
||||
|
||||
def _sub_depuis_cookie(cookie: str) -> str:
|
||||
for morceau in (cookie or "").split(";"):
|
||||
nom, _, valeur = morceau.strip().partition("=")
|
||||
if nom == "draco_session" and valeur.count(".") == 2:
|
||||
segment = valeur.split(".")[1]
|
||||
segment += "=" * (-len(segment) % 4)
|
||||
try:
|
||||
return json.loads(base64.urlsafe_b64decode(segment))["sub"]
|
||||
except Exception:
|
||||
return ""
|
||||
return ""
|
||||
|
||||
|
||||
class _Reponse:
|
||||
def __init__(self, status_code=200, donnees=None):
|
||||
self.status_code = status_code
|
||||
self._donnees = donnees
|
||||
|
||||
def json(self):
|
||||
return self._donnees
|
||||
|
||||
|
||||
@pytest.fixture(autouse=True)
|
||||
def _cache_propre():
|
||||
hub_roles._reset_cache()
|
||||
yield
|
||||
hub_roles._reset_cache()
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def faux_hub(monkeypatch):
|
||||
"""Faux registre du Hub : rôles par ``sub``, lus dans le cookie relayé."""
|
||||
etat = {"roles": {}, "mode": "ok"}
|
||||
|
||||
def faux_get(url, headers=None, timeout=None):
|
||||
if etat["mode"] == "panne":
|
||||
raise httpx.ConnectError("Hub injoignable (simulation)")
|
||||
sub = _sub_depuis_cookie((headers or {}).get("Cookie", ""))
|
||||
role = etat["roles"].get(sub, "utilisateur")
|
||||
return _Reponse(200, {
|
||||
"app": "kanbante", "sub": sub, "role": role,
|
||||
"explicite": True, "ttl_secondes": 60,
|
||||
})
|
||||
|
||||
monkeypatch.setattr(httpx, "get", faux_get)
|
||||
return etat
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def instance_fraiche(monkeypatch, tmp_path, fake_gitea, faux_hub):
|
||||
"""Instance neuve : base temporaire, amorçage seul et non lié.
|
||||
|
||||
Au démarrage (TestClient), ``ensure_bootstrap_admin`` crée
|
||||
l'unique compte « proprio » (admin) depuis l'environnement —
|
||||
c'est exactement l'état de l'audit : un seul compte, aucune
|
||||
liaison draco.
|
||||
"""
|
||||
monkeypatch.setenv("KANBANTE_DB_PATH", str(tmp_path / "fraiche.db"))
|
||||
monkeypatch.setenv("KANBANTE_AUTH_USER", "proprio")
|
||||
monkeypatch.setenv("KANBANTE_AUTH_PASSWORD", "mdp-amorce")
|
||||
monkeypatch.setenv("DRACO_SESSION_SECRET", SECRET)
|
||||
monkeypatch.setattr(draco, "_refresh_revocations", lambda: None)
|
||||
draco._revoked_cache.clear()
|
||||
with TestClient(main.app) as client:
|
||||
users = models.list_users()
|
||||
assert len(users) == 1, users
|
||||
assert users[0]["username"] == "proprio"
|
||||
assert users[0]["role"] == "admin"
|
||||
assert not users[0].get("draco_sub")
|
||||
yield client, faux_hub, users[0]
|
||||
draco._revoked_cache.clear()
|
||||
|
||||
|
||||
def _pont(client, sub, nom="Visiteur Exemple"):
|
||||
client.cookies.set("draco_session", _jeton(sub, nom))
|
||||
return client.get("/auth/draco", follow_redirects=False)
|
||||
|
||||
|
||||
def _profil_username(client) -> str:
|
||||
r = client.get("/profile")
|
||||
assert r.status_code == 200
|
||||
return r.text.split("page-sub\">", 1)[1].split(" ·", 1)[0].strip()
|
||||
|
||||
|
||||
def _csrf_via_login(client) -> str:
|
||||
client.get("/login")
|
||||
return client.cookies.get("kanbante_csrf") or ""
|
||||
|
||||
|
||||
# ── (i) Simple utilisateur : JIT membre, amorçage intact ─────
|
||||
|
||||
def test_simple_utilisateur_jit_membre_amorcage_intact(instance_fraiche):
|
||||
client, hub, amorce = instance_fraiche
|
||||
hub["roles"][SUB_SIMPLE] = "utilisateur"
|
||||
r = _pont(client, SUB_SIMPLE, "Dan Simple")
|
||||
assert r.status_code == 303 and r.headers["location"] == "/"
|
||||
assert "kanbante_session" in r.headers.get("set-cookie", "")
|
||||
# L'amorçage est intact : toujours là, admin, TOUJOURS sans liaison.
|
||||
apres = models.get_user(amorce["id"])
|
||||
assert apres["role"] == "admin"
|
||||
assert not apres.get("draco_sub")
|
||||
# Le visiteur a reçu SON compte : membre, distinct, lié à son sub.
|
||||
cree = models.get_user_by_draco(SUB_SIMPLE)
|
||||
assert cree is not None and cree["id"] != amorce["id"]
|
||||
assert cree["role"] == "member"
|
||||
assert models.count_users() == 2
|
||||
assert _profil_username(client) == cree["username"]
|
||||
|
||||
|
||||
# ── (ii) Administrateur au registre : adoption ───────────────
|
||||
|
||||
def test_administrateur_registre_adopte_amorcage(instance_fraiche):
|
||||
client, hub, amorce = instance_fraiche
|
||||
hub["roles"][SUB_ADMIN] = "administrateur"
|
||||
r = _pont(client, SUB_ADMIN, "Chef Suite")
|
||||
assert r.status_code == 303 and r.headers["location"] == "/"
|
||||
# Aucun compte créé : le sub s'est lié au compte d'amorçage.
|
||||
assert models.count_users() == 1
|
||||
lie = models.get_user_by_draco(SUB_ADMIN)
|
||||
assert lie is not None and lie["id"] == amorce["id"]
|
||||
assert lie["role"] == "admin"
|
||||
assert _profil_username(client) == "proprio"
|
||||
|
||||
|
||||
def test_hub_muet_pas_d_adoption(instance_fraiche):
|
||||
"""Repli propre : rôle inconnu (Hub injoignable) = pas d'adoption."""
|
||||
client, hub, amorce = instance_fraiche
|
||||
hub["mode"] = "panne"
|
||||
r = _pont(client, SUB_INCONNU, "Inconnu Exemple")
|
||||
assert r.status_code == 303 and r.headers["location"] == "/"
|
||||
assert not models.get_user(amorce["id"]).get("draco_sub")
|
||||
cree = models.get_user_by_draco(SUB_INCONNU)
|
||||
assert cree is not None and cree["role"] == "member"
|
||||
assert cree["id"] != amorce["id"]
|
||||
|
||||
|
||||
# ── (iii) Liaison existante : résolution inchangée ───────────
|
||||
|
||||
def test_liaison_existante_resolution_inchangee(instance_fraiche):
|
||||
client, hub, amorce = instance_fraiche
|
||||
# Cas de production : l'amorçage est DÉJÀ lié (à Bruno).
|
||||
models.update_user(amorce["id"], draco_sub=SUB_LIE)
|
||||
# Même avec un rôle moindre au registre, la correspondance
|
||||
# existante désigne son compte, comme avant le correctif.
|
||||
hub["roles"][SUB_LIE] = "utilisateur"
|
||||
claims = {"sub": SUB_LIE, "name": "Bruno"}
|
||||
resolu = accounts.resolve_draco_user(claims)
|
||||
assert resolu is not None and resolu["id"] == amorce["id"]
|
||||
r = _pont(client, SUB_LIE, "Bruno")
|
||||
assert r.status_code == 303 and r.headers["location"] == "/"
|
||||
assert models.count_users() == 1
|
||||
assert _profil_username(client) == "proprio"
|
||||
|
||||
|
||||
# ── (iv) Session native authentifiée : liaison explicite ─────
|
||||
|
||||
def test_session_native_lie_explicitement_via_le_pont(instance_fraiche):
|
||||
client, hub, amorce = instance_fraiche
|
||||
hub["roles"][SUB_NATIF] = "utilisateur"
|
||||
# Connexion native de l'amorçage (mot de passe du compte).
|
||||
token = _csrf_via_login(client)
|
||||
r = client.post(
|
||||
"/login",
|
||||
data={"username": "proprio", "password": "mdp-amorce",
|
||||
"next": "/", "csrf_token": token},
|
||||
follow_redirects=False,
|
||||
)
|
||||
assert r.status_code == 303
|
||||
assert "kanbante_session" in r.headers.get("set-cookie", "")
|
||||
# Le passage du pont, session native ouverte, lie le sub libre
|
||||
# au compte de la session — sans rôle administrateur au registre.
|
||||
r = _pont(client, SUB_NATIF, "Proprio Lui-Même")
|
||||
assert r.status_code == 303
|
||||
lie = models.get_user_by_draco(SUB_NATIF)
|
||||
assert lie is not None and lie["id"] == amorce["id"]
|
||||
assert models.count_users() == 1
|
||||
|
||||
|
||||
def test_resolution_directe_avec_session_native(instance_fraiche):
|
||||
_client, _hub, amorce = instance_fraiche
|
||||
claims = {"sub": SUB_NATIF_DIRECT, "name": "Proprio"}
|
||||
# Sans drapeau : aucune adoption (résolution « à froid »).
|
||||
assert accounts.resolve_draco_user(claims) is None
|
||||
assert not models.get_user(amorce["id"]).get("draco_sub")
|
||||
# Avec le drapeau « session native authentifiée » : adoption.
|
||||
resolu = accounts.resolve_draco_user(
|
||||
claims, liaison_session_native=True
|
||||
)
|
||||
assert resolu is not None and resolu["id"] == amorce["id"]
|
||||
assert models.get_user_by_draco(SUB_NATIF_DIRECT)["id"] == amorce["id"]
|
||||
|
||||
|
||||
# ── Fusion #144 : l'échec du formulaire suggère le SSO ───────
|
||||
|
||||
def test_echec_login_identifiant_sans_compte_local_suggere_sso(instance_fraiche):
|
||||
client, _hub, _amorce = instance_fraiche
|
||||
token = _csrf_via_login(client)
|
||||
r = client.post(
|
||||
"/login",
|
||||
data={"username": "compte-du-hub", "password": "peu-importe",
|
||||
"next": "/", "csrf_token": token},
|
||||
follow_redirects=False,
|
||||
)
|
||||
assert r.status_code == 401
|
||||
assert "aucun compte local" in r.text
|
||||
assert "Se connecter avec ObsiGate (SSO)" in r.text
|
||||
assert "kanbante_session" not in r.headers.get("set-cookie", "")
|
||||
|
||||
|
||||
def test_echec_login_mauvais_mot_de_passe_suggere_sso(instance_fraiche):
|
||||
client, _hub, _amorce = instance_fraiche
|
||||
token = _csrf_via_login(client)
|
||||
r = client.post(
|
||||
"/login",
|
||||
data={"username": "proprio", "password": "mauvais",
|
||||
"next": "/", "csrf_token": token},
|
||||
follow_redirects=False,
|
||||
)
|
||||
assert r.status_code == 401
|
||||
assert "Identifiants incorrects" in r.text
|
||||
assert "Se connecter avec ObsiGate (SSO)" in r.text
|
||||
@@ -30,8 +30,12 @@ def _sha256(chemin):
|
||||
|
||||
|
||||
def test_barre_css_js_verbatim_commons_v041():
|
||||
# Remplacé en 0.46.1 : la re-vendange v0.5.0 (HUB-18, thème
|
||||
# commun) supersède l'empreinte JS v0.4.1 — l'empreinte courante
|
||||
# est verrouillée par tests/test_barre_v050.py. Le CSS, inchangé
|
||||
# en v0.5.0, garde son empreinte v0.4.1 ; le JS a quitté la v0.4.1.
|
||||
assert _sha256("static/css/draco-barre.css") == SHA256_CSS_V041
|
||||
assert _sha256("static/js/draco-barre.js") == SHA256_JS_V041
|
||||
assert _sha256("static/js/draco-barre.js") != SHA256_JS_V041
|
||||
|
||||
|
||||
def test_js_icones_espace_de_noms_svg():
|
||||
|
||||
@@ -0,0 +1,46 @@
|
||||
"""Barre commune v0.5.0 (HUB-18, fusion #132) — re-vendange 0.46.1.
|
||||
|
||||
- JS vendangé VERBATIM depuis dracodev-commons, branche
|
||||
hub18-theme-commun (PR commons #12), ui/barre-apps/. Le CSS est
|
||||
inchangé en v0.5.0 : il garde l'empreinte v0.4.1 (verrouillée
|
||||
par tests/test_barre_v041.py).
|
||||
- Thème commun : la barre apprend la préférence du Hub
|
||||
(GET <hub>/api/profil/theme) et l'applique à l'ouverture ;
|
||||
l'initialisation propre à Kanbante vit dans static/js/nav.js
|
||||
(écouteur draco:theme → data-theme + resynchronisation du
|
||||
bouton de bascule, sans écraser le choix local kanbante-theme).
|
||||
"""
|
||||
import hashlib
|
||||
from pathlib import Path
|
||||
|
||||
R = Path(__file__).resolve().parents[1]
|
||||
|
||||
SHA256_JS_V050 = "384e2b0248a7c84d77fbb6eae6c25366828554162556a6b5b19c96e188ce11c7"
|
||||
|
||||
|
||||
def _sha256(chemin):
|
||||
return hashlib.sha256((R / chemin).read_bytes()).hexdigest()
|
||||
|
||||
|
||||
def test_barre_js_verbatim_commons_v050():
|
||||
assert _sha256("static/js/draco-barre.js") == SHA256_JS_V050
|
||||
|
||||
|
||||
def test_js_theme_commun_hub18():
|
||||
js = (R / "static/js/draco-barre.js").read_text(encoding="utf-8")
|
||||
assert "api/profil/theme" in js
|
||||
assert 'credentials: "include"' in js
|
||||
assert "draco-theme-hub" in js
|
||||
assert 'CustomEvent("draco:theme"' in js
|
||||
assert "themePref" in js and "themeMode" in js
|
||||
assert "resolvedUrls.hub" in js
|
||||
# Comportements conservés (v0.4.1) : icônes en espace de noms SVG.
|
||||
assert 'createElementNS(SVG_NS, "svg")' in js
|
||||
|
||||
|
||||
def test_nav_js_init_theme_hub():
|
||||
nav = (R / "static/js/nav.js").read_text(encoding="utf-8")
|
||||
assert 'addEventListener(\'draco:theme\'' in nav or 'addEventListener("draco:theme"' in nav
|
||||
assert "appliquerThemeCommun" in nav
|
||||
assert "syncThemeBtn(mode)" in nav
|
||||
assert "DRACO_BAR" in nav and "themeMode" in nav
|
||||
@@ -0,0 +1,27 @@
|
||||
"""Barre commune v0.6.0 (fusion #142) — entrée « Administration ».
|
||||
|
||||
Re-vendange verbatim du JS/CSS commons v0.6.0 : le menu compte
|
||||
gagne l'entrée « Administration » (lien Hub <hub>/admin), à
|
||||
visibilité conditionnelle. Kanbante ne passe pas le drapeau
|
||||
admin : il ne connaît que le rôle du registre du Hub pour sa
|
||||
propre app, pas le rôle global de suite — l'entrée reste donc
|
||||
masquée ici.
|
||||
"""
|
||||
from pathlib import Path
|
||||
|
||||
R = Path(__file__).resolve().parents[1]
|
||||
|
||||
|
||||
def test_barre_v060_entree_administration_vendangee():
|
||||
js = (R / "static/js/draco-barre.js").read_text(encoding="utf-8")
|
||||
assert 'setAttribute("data-hub-link", "admin")' in js
|
||||
assert '"Administration"' in js
|
||||
assert "setAdmin" in js
|
||||
css = (R / "static/css/draco-barre.css").read_text(encoding="utf-8")
|
||||
assert ".draco-menu-item[hidden]" in css
|
||||
|
||||
|
||||
def test_gabarit_sans_drapeau_admin():
|
||||
gabarit = (R / "app/templates/_draco_bar.html").read_text(encoding="utf-8")
|
||||
assert "v0.6.0" in gabarit
|
||||
assert "admin: true" not in gabarit
|
||||
@@ -0,0 +1,21 @@
|
||||
"""Déconnexion du menu compte (fusion #141) — branchement global.
|
||||
|
||||
Kanbante était le seul hôte branché, mais sa branche ne faisait que
|
||||
naviguer vers son /logout local : la session draco (SSO) survivait
|
||||
et le pont /auth/draco rouvrait une session sans mot de passe. Le
|
||||
branchement livré : destruction de la session locale (GET /logout)
|
||||
puis navigation vers la déconnexion globale de l'émettrice
|
||||
(GET /sso/logout chez ObsiGate, retour ici).
|
||||
"""
|
||||
from pathlib import Path
|
||||
|
||||
R = Path(__file__).resolve().parents[1]
|
||||
|
||||
|
||||
def test_gabarit_branche_deconnexion_globale():
|
||||
gabarit = (R / "app/templates/_draco_bar.html").read_text(encoding="utf-8")
|
||||
assert 'act === "deconnexion"' in gabarit
|
||||
assert 'fetch("/logout"' in gabarit
|
||||
assert "{{ draco_urls.obsigate }}/sso/logout?return_to=" in gabarit
|
||||
# L'ancien branchement local seul a disparu.
|
||||
assert 'if (act === "deconnexion") { location.href = "/logout"; return; }' not in gabarit
|
||||
@@ -0,0 +1,409 @@
|
||||
"""HUB-16 (0.46.0) — correspondance draco PAR UTILISATEUR.
|
||||
|
||||
Le pont SSO ne désigne plus « l'opérateur » : chaque identité
|
||||
draco (claim ``sub``) désigne SON compte Kanbante, via la colonne
|
||||
users.draco_sub. Couvert ici :
|
||||
|
||||
- amorçage : l'unique compte admin sans liaison ne se lie plus
|
||||
au premier passage — depuis la 0.46.5 (fusion #145), il faut
|
||||
un rôle « administrateur » au registre du Hub (voir
|
||||
tests/test_amorcage_pont.py pour la matrice complète) ; le
|
||||
cas historique est couvert ici avec ce rôle simulé ;
|
||||
- JIT : deux identités distinctes → deux comptes distincts,
|
||||
rôle membre, mot de passe local non divulgué/inutilisable ;
|
||||
- le JIT n'adopte jamais un compte préexistant non lié, même
|
||||
homonyme : il crée un compte nouveau, suffixé ;
|
||||
- liaison / déliaison par l'administrateur depuis /admin,
|
||||
conflit de sub refusé ;
|
||||
- compte désactivé : correspondance refusée, aucun contournement ;
|
||||
- /api/search : un jeton draco sans correspondance ne suffit plus,
|
||||
un jeton lié passe ;
|
||||
- non-régression : un jeton personnel kbt_ reste accepté sur les
|
||||
surfaces machine pendant que l'authentification est active.
|
||||
|
||||
La base de test est partagée par toute la session (voir
|
||||
conftest) : les comptes créés ici portent des noms/subs uniques
|
||||
« hub16-… » et sont supprimés au teardown de chaque test.
|
||||
"""
|
||||
|
||||
import base64
|
||||
import hashlib
|
||||
import hmac
|
||||
import json
|
||||
import time
|
||||
|
||||
import pytest
|
||||
from fastapi.testclient import TestClient
|
||||
|
||||
import app.main as main
|
||||
from app import accounts, draco, models
|
||||
|
||||
SECRET = "secret-partage-hub16"
|
||||
|
||||
SUBS_TEST = (
|
||||
"hub16-alice", "hub16-bob", "hub16-carole", "hub16-dave",
|
||||
"hub16-erin", "hub16-franck", "hub16-amorce", "hub16-sans-lien",
|
||||
"hub16-recherche",
|
||||
)
|
||||
|
||||
|
||||
def _jeton(sub, nom="Alice Exemple", secret=SECRET):
|
||||
def b64(d: bytes) -> str:
|
||||
return base64.urlsafe_b64encode(d).rstrip(b"=").decode()
|
||||
|
||||
header = b64(json.dumps({"alg": "HS256", "typ": "JWT"}).encode())
|
||||
payload = b64(json.dumps({
|
||||
"sub": sub, "name": nom, "iat": int(time.time()),
|
||||
"exp": int(time.time()) + 3600, "jti": f"jti-{sub}",
|
||||
}).encode())
|
||||
sig = hmac.new(secret.encode(), f"{header}.{payload}".encode(),
|
||||
hashlib.sha256).digest()
|
||||
return f"{header}.{payload}.{b64(sig)}"
|
||||
|
||||
|
||||
def _nettoyer():
|
||||
"""Supprime les comptes créés par ces tests (et leurs traces)."""
|
||||
with models.get_db() as conn:
|
||||
ids = [
|
||||
r[0] for r in conn.execute(
|
||||
"SELECT id FROM users WHERE draco_sub IN ({})".format(
|
||||
",".join("?" * len(SUBS_TEST))
|
||||
),
|
||||
SUBS_TEST,
|
||||
).fetchall()
|
||||
]
|
||||
ids += [
|
||||
r[0] for r in conn.execute(
|
||||
"SELECT id FROM users WHERE username IN"
|
||||
" ('hub16-dave', 'hub16-erin', 'carole-exemple')"
|
||||
).fetchall()
|
||||
]
|
||||
for uid in ids:
|
||||
conn.execute("DELETE FROM api_tokens WHERE user_id = ?", (uid,))
|
||||
conn.execute(
|
||||
"DELETE FROM workspace_members WHERE user_id = ?", (uid,)
|
||||
)
|
||||
conn.execute("DELETE FROM users WHERE id = ?", (uid,))
|
||||
|
||||
|
||||
def _restaurer_temoin():
|
||||
"""Délie le compte témoin d'amorçage (jamais supprimé)."""
|
||||
temoin = models.get_user_by_draco("hub16-temoin-amorce")
|
||||
if temoin is not None:
|
||||
models.update_user(temoin["id"], draco_sub=None)
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def client_hub16(monkeypatch, fake_gitea):
|
||||
monkeypatch.setenv("KANBANTE_AUTH_USER", "bruno")
|
||||
monkeypatch.setenv("KANBANTE_AUTH_PASSWORD", "motdepasse")
|
||||
monkeypatch.setenv("DRACO_SESSION_SECRET", SECRET)
|
||||
monkeypatch.setattr(draco, "_refresh_revocations", lambda: None)
|
||||
draco._revoked_cache.clear()
|
||||
_restaurer_temoin()
|
||||
_nettoyer()
|
||||
with TestClient(main.app) as client:
|
||||
yield client
|
||||
_restaurer_temoin()
|
||||
_nettoyer()
|
||||
draco._revoked_cache.clear()
|
||||
|
||||
|
||||
def _pont(client, sub, nom="Alice Exemple"):
|
||||
client.cookies.set("draco_session", _jeton(sub, nom))
|
||||
return client.get("/auth/draco", follow_redirects=False)
|
||||
|
||||
|
||||
def _profil_username(client) -> str:
|
||||
r = client.get("/profile")
|
||||
assert r.status_code == 200
|
||||
# « <username> · rôle : … » dans l'en-tête de la page profil.
|
||||
return r.text.split("page-sub\">", 1)[1].split(" ·", 1)[0].strip()
|
||||
|
||||
|
||||
def _unique_admin_sans_liaison():
|
||||
"""(compte, vrai) si l'état partagé est le cas d'amorçage pur."""
|
||||
users = models.list_users()
|
||||
if len(users) == 1 and users[0]["role"] == "admin" \
|
||||
and not users[0].get("draco_sub"):
|
||||
return users[0], True
|
||||
return None, False
|
||||
|
||||
|
||||
# ── Amorçage ──────────────────────────────────────────────────
|
||||
|
||||
def test_amorcage_unique_admin_se_lie_au_premier_passage(client_hub16, monkeypatch):
|
||||
# Depuis la 0.46.5 (fusion #145), le premier passage ne lie
|
||||
# l'amorçage que pour un « administrateur » du registre du
|
||||
# Hub : c'est ce rôle qui est simulé ici. Sans lui, le même
|
||||
# passage crée un compte membre JIT (test_amorcage_pont.py).
|
||||
from app import hub_roles
|
||||
|
||||
monkeypatch.setattr(
|
||||
hub_roles, "role_pour",
|
||||
lambda cookie, sub, hote=None: "administrateur",
|
||||
)
|
||||
admin, pur = _unique_admin_sans_liaison()
|
||||
if not pur:
|
||||
pytest.skip("base partagée : le cas d'amorçage pur n'est pas en place")
|
||||
avant = models.count_users()
|
||||
r = _pont(client_hub16, "hub16-amorce", "Bruno")
|
||||
assert r.status_code == 303 and r.headers["location"] == "/"
|
||||
assert "kanbante_session" in r.headers.get("set-cookie", "")
|
||||
# Aucun compte créé : le sub s'est lié au compte admin existant.
|
||||
assert models.count_users() == avant
|
||||
lie = models.get_user_by_draco("hub16-amorce")
|
||||
assert lie is not None and lie["id"] == admin["id"]
|
||||
assert lie["role"] == "admin"
|
||||
assert _profil_username(client_hub16) == admin["username"]
|
||||
# Nettoyage propre à ce test : rendre l'amorçage à son état.
|
||||
models.update_user(admin["id"], draco_sub=None)
|
||||
|
||||
|
||||
# ── Création JIT ──────────────────────────────────────────────
|
||||
|
||||
def test_jit_deux_identites_deux_comptes_distincts(client_hub16):
|
||||
admin, pur = _unique_admin_sans_liaison()
|
||||
if pur:
|
||||
# Neutraliser l'amorçage : les scénarios JIT doivent être purs.
|
||||
models.update_user(admin["id"], draco_sub="hub16-temoin-amorce")
|
||||
try:
|
||||
r = _pont(client_hub16, "hub16-alice", "Alice Exemple")
|
||||
assert r.status_code == 303 and r.headers["location"] == "/"
|
||||
assert _profil_username(client_hub16) == "alice-exemple"
|
||||
alice = models.get_user_by_draco("hub16-alice")
|
||||
assert alice is not None
|
||||
assert alice["username"] == "alice-exemple"
|
||||
assert alice["display_name"] == "Alice Exemple"
|
||||
assert alice["role"] == "member"
|
||||
# Mot de passe local aléatoire : ni le mot de passe
|
||||
# d'environnement ni le nom ne l'ouvrent.
|
||||
assert accounts.verify_password("motdepasse", alice["password_hash"]) is False
|
||||
assert alice["password_hash"].startswith("pbkdf2$")
|
||||
|
||||
client_hub16.cookies.delete("kanbante_session")
|
||||
r = _pont(client_hub16, "hub16-bob", "Bob Exemple")
|
||||
assert r.status_code == 303 and r.headers["location"] == "/"
|
||||
assert _profil_username(client_hub16) == "bob-exemple"
|
||||
bob = models.get_user_by_draco("hub16-bob")
|
||||
assert bob is not None and bob["id"] != alice["id"]
|
||||
|
||||
# Deuxième passage d'Alice : MÊME compte, pas de doublon.
|
||||
client_hub16.cookies.delete("kanbante_session")
|
||||
avant = models.count_users()
|
||||
_pont(client_hub16, "hub16-alice", "Alice Exemple")
|
||||
assert models.count_users() == avant
|
||||
assert models.get_user_by_draco("hub16-alice")["id"] == alice["id"]
|
||||
assert _profil_username(client_hub16) == "alice-exemple"
|
||||
finally:
|
||||
if pur:
|
||||
models.update_user(admin["id"], draco_sub=None)
|
||||
|
||||
|
||||
def test_jit_n_adopte_pas_un_compte_homonyme_non_lie(client_hub16):
|
||||
admin, pur = _unique_admin_sans_liaison()
|
||||
if pur:
|
||||
models.update_user(admin["id"], draco_sub="hub16-temoin-amorce")
|
||||
try:
|
||||
local_id = models.create_user(
|
||||
"carole-exemple", accounts.hash_password("local-carole"),
|
||||
role="member", display_name="Carole Exemple",
|
||||
)
|
||||
r = _pont(client_hub16, "hub16-carole", "Carole Exemple")
|
||||
assert r.status_code == 303 and r.headers["location"] == "/"
|
||||
# Le compte préexistant n'a PAS été lié ni utilisé…
|
||||
local = models.get_user(local_id)
|
||||
assert local["draco_sub"] is None
|
||||
# …un compte nouveau, suffixé, porte la correspondance.
|
||||
cree = models.get_user_by_draco("hub16-carole")
|
||||
assert cree is not None and cree["id"] != local_id
|
||||
assert cree["username"] == "carole-exemple-2"
|
||||
assert _profil_username(client_hub16) == "carole-exemple-2"
|
||||
finally:
|
||||
if pur:
|
||||
models.update_user(admin["id"], draco_sub=None)
|
||||
|
||||
|
||||
def test_compte_desactive_refuse_sans_contournement(client_hub16):
|
||||
admin, pur = _unique_admin_sans_liaison()
|
||||
if pur:
|
||||
models.update_user(admin["id"], draco_sub="hub16-temoin-amorce")
|
||||
try:
|
||||
_pont(client_hub16, "hub16-franck", "Franck Exemple")
|
||||
franck = models.get_user_by_draco("hub16-franck")
|
||||
assert franck is not None
|
||||
models.update_user(franck["id"], active=0)
|
||||
client_hub16.cookies.delete("kanbante_session")
|
||||
avant = models.count_users()
|
||||
r = _pont(client_hub16, "hub16-franck", "Franck Exemple")
|
||||
# Refusé au login, aucune session, aucun nouveau compte.
|
||||
assert r.headers["location"] == "/login"
|
||||
assert "kanbante_session" not in r.headers.get("set-cookie", "")
|
||||
assert models.count_users() == avant
|
||||
finally:
|
||||
if pur:
|
||||
models.update_user(admin["id"], draco_sub=None)
|
||||
|
||||
|
||||
# ── Liaison par l'administrateur ──────────────────────────────
|
||||
|
||||
def _jeton_csrf_via_login(client) -> str:
|
||||
"""Charge la page de connexion (elle pose le cookie CSRF).
|
||||
|
||||
csrf_from() charge « / », qui répond 401 JSON sans cookie
|
||||
quand l'authentification est active et qu'aucune session
|
||||
n'est ouverte — la page /login, elle, est rendue (render()
|
||||
pose le cookie) dans tous les cas.
|
||||
"""
|
||||
client.get("/login")
|
||||
return client.cookies.get("kanbante_csrf") or ""
|
||||
|
||||
|
||||
def _connecter_admin(client):
|
||||
token = _jeton_csrf_via_login(client)
|
||||
r = client.post(
|
||||
"/login",
|
||||
data={"username": "bruno", "password": "motdepasse",
|
||||
"next": "/", "csrf_token": token},
|
||||
follow_redirects=False,
|
||||
)
|
||||
assert r.status_code == 303, r.text
|
||||
assert "kanbante_session" in r.headers.get("set-cookie", "")
|
||||
|
||||
|
||||
def test_liaison_par_administrateur(client_hub16):
|
||||
dave_id = models.create_user(
|
||||
"hub16-dave", accounts.hash_password("local-dave"),
|
||||
role="member", display_name="Dave",
|
||||
)
|
||||
erin_id = models.create_user(
|
||||
"hub16-erin", accounts.hash_password("local-erin"),
|
||||
role="member", display_name="Erin",
|
||||
)
|
||||
_connecter_admin(client_hub16)
|
||||
# L'écran d'administration expose le mécanisme de liaison.
|
||||
r = client_hub16.get("/admin")
|
||||
assert r.status_code == 200
|
||||
assert "/draco" in r.text and "Lier" in r.text
|
||||
|
||||
# Lier Dave au sub hub16-dave.
|
||||
r = client_hub16.post(
|
||||
f"/admin/users/{dave_id}/draco",
|
||||
data={"draco_sub": "hub16-dave",
|
||||
"csrf_token": client_hub16.cookies.get("kanbante_csrf")},
|
||||
follow_redirects=False,
|
||||
)
|
||||
assert r.status_code == 303 and r.headers["location"].startswith("/admin?msg=")
|
||||
assert models.get_user(dave_id)["draco_sub"] == "hub16-dave"
|
||||
|
||||
# Conflit : le même sub pour Erin est refusé, Erin inchangée.
|
||||
r = client_hub16.post(
|
||||
f"/admin/users/{erin_id}/draco",
|
||||
data={"draco_sub": "hub16-dave",
|
||||
"csrf_token": client_hub16.cookies.get("kanbante_csrf")},
|
||||
follow_redirects=False,
|
||||
)
|
||||
assert r.status_code == 303 and "err=" in r.headers["location"]
|
||||
assert models.get_user(erin_id)["draco_sub"] is None
|
||||
|
||||
# Le pont route désormais ce sub vers Dave, et seulement lui.
|
||||
client_hub16.cookies.delete("kanbante_session")
|
||||
r = _pont(client_hub16, "hub16-dave", "Dave")
|
||||
assert r.status_code == 303 and r.headers["location"] == "/"
|
||||
assert _profil_username(client_hub16) == "hub16-dave"
|
||||
|
||||
# Déliaison par l'administrateur (champ vide).
|
||||
_connecter_admin(client_hub16)
|
||||
r = client_hub16.post(
|
||||
f"/admin/users/{dave_id}/draco",
|
||||
data={"draco_sub": "",
|
||||
"csrf_token": client_hub16.cookies.get("kanbante_csrf")},
|
||||
follow_redirects=False,
|
||||
)
|
||||
assert r.status_code == 303
|
||||
assert models.get_user(dave_id)["draco_sub"] is None
|
||||
|
||||
|
||||
def test_liaison_refusee_aux_non_admins(client_hub16):
|
||||
dave_id = models.create_user(
|
||||
"hub16-dave", accounts.hash_password("local-dave"),
|
||||
role="member", display_name="Dave",
|
||||
)
|
||||
# Connexion native de Dave (membre) : aucun droit d'administration.
|
||||
token = _jeton_csrf_via_login(client_hub16)
|
||||
r = client_hub16.post(
|
||||
"/login",
|
||||
data={"username": "hub16-dave", "password": "local-dave",
|
||||
"next": "/", "csrf_token": token},
|
||||
follow_redirects=False,
|
||||
)
|
||||
assert r.status_code == 303
|
||||
r = client_hub16.post(
|
||||
f"/admin/users/{dave_id}/draco",
|
||||
data={"draco_sub": "hub16-dave",
|
||||
"csrf_token": client_hub16.cookies.get("kanbante_csrf")},
|
||||
follow_redirects=False,
|
||||
)
|
||||
assert r.status_code == 403
|
||||
assert models.get_user(dave_id)["draco_sub"] is None
|
||||
|
||||
|
||||
# ── /api/search par utilisateur ───────────────────────────────
|
||||
|
||||
def test_api_search_draco_par_utilisateur(client_hub16):
|
||||
admin, pur = _unique_admin_sans_liaison()
|
||||
if pur:
|
||||
models.update_user(admin["id"], draco_sub="hub16-temoin-amorce")
|
||||
try:
|
||||
# Jeton draco valide mais SANS correspondance : refusé
|
||||
# (il ne désigne plus l'opérateur).
|
||||
client_hub16.cookies.set(
|
||||
"draco_session", _jeton("hub16-sans-lien", "Sans Lien")
|
||||
)
|
||||
r = client_hub16.get("/api/search", params={"q": "demo"})
|
||||
assert r.status_code == 401
|
||||
# Après création JIT par le pont, le même chemin passe.
|
||||
_pont(client_hub16, "hub16-recherche", "Recherche Exemple")
|
||||
client_hub16.cookies.delete("kanbante_session")
|
||||
client_hub16.cookies.set(
|
||||
"draco_session", _jeton("hub16-recherche", "Recherche Exemple")
|
||||
)
|
||||
r = client_hub16.get("/api/search", params={"q": "demo"})
|
||||
assert r.status_code == 200
|
||||
assert r.json()["query"] == "demo"
|
||||
finally:
|
||||
if pur:
|
||||
models.update_user(admin["id"], draco_sub=None)
|
||||
|
||||
|
||||
# ── Non-régression : jetons kbt_ ──────────────────────────────
|
||||
|
||||
def test_jeton_kbt_toujours_accepte(client_hub16):
|
||||
uid = models.create_user(
|
||||
"hub16-erin", accounts.hash_password("local-erin"),
|
||||
role="member", display_name="Erin Jetons",
|
||||
)
|
||||
user = models.get_user(uid)
|
||||
_row, clair = models.create_api_token(uid, "service-agents")
|
||||
assert clair.startswith("kbt_")
|
||||
corps = {"jsonrpc": "2.0", "id": 1, "method": "initialize",
|
||||
"params": {"protocolVersion": "2024-11-05"}}
|
||||
# Sans jeton : 401 ; avec le jeton Bearer : le handshake passe.
|
||||
assert client_hub16.post("/mcp", json=corps).status_code == 401
|
||||
r = client_hub16.post(
|
||||
"/mcp", json=corps, headers={"Authorization": f"Bearer {clair}"}
|
||||
)
|
||||
assert r.status_code == 200
|
||||
assert r.json()["result"]["serverInfo"]["name"] == "kanbante"
|
||||
# Le jeton sert aussi /api/search (surface machine)…
|
||||
r = client_hub16.get(
|
||||
"/api/search", params={"q": "demo"},
|
||||
headers={"Authorization": f"Bearer {clair}"},
|
||||
)
|
||||
assert r.status_code == 200
|
||||
# …mais jamais l'interface web.
|
||||
assert client_hub16.get(
|
||||
"/", headers={"Authorization": f"Bearer {clair}",
|
||||
"Accept": "application/json"},
|
||||
).status_code == 401
|
||||
assert user["username"] == "hub16-erin"
|
||||
+11
-3
@@ -2,9 +2,17 @@
|
||||
|
||||
Le cookie émis par ObsiGate (ACC-3.1) est vérifié localement
|
||||
(secret partagé, HS256) et converti en session Kanbante native par
|
||||
GET /auth/draco. Kanbante est mono-utilisateur : un jeton valide
|
||||
ouvre la session de l'opérateur configuré. Sans
|
||||
DRACO_SESSION_SECRET, le pont renvoie simplement au login.
|
||||
GET /auth/draco. Depuis la 0.46.0 (HUB-16), la correspondance est
|
||||
par utilisateur (users.draco_sub, création JIT) — voir
|
||||
tests/test_draco_correspondance.py. Les cas couverts ici restent
|
||||
valides : dans ce module, le seul compte préexistant est l'admin
|
||||
d'amorçage ; depuis la 0.46.5 (fusion #145), le premier jeton
|
||||
valide ne s'y lie PLUS automatiquement (adoption conditionnée au
|
||||
rôle « administrateur » du registre du Hub ou à une session
|
||||
native) — le pont ouvre alors la session d'un compte JIT propre
|
||||
à l'identité, ce que ces cas vérifient (session ouverte, accès
|
||||
à l'app) sans présumer du compte résolu.
|
||||
Sans DRACO_SESSION_SECRET, le pont renvoie simplement au login.
|
||||
"""
|
||||
|
||||
import base64
|
||||
|
||||
@@ -0,0 +1,375 @@
|
||||
"""HUB-19 (0.46.2) — rôles du Hub propagés à Kanbante (contrat D3(a)).
|
||||
|
||||
Portage du pilote ShaarIt 0.7.0. Couvert ici :
|
||||
|
||||
- client ``app.hub_roles`` : appel ``GET {hub}/api/roles/kanbante``
|
||||
(Cookie complet relayé, ``Accept: application/json``), URL du
|
||||
Hub résolue comme la barre (explicite > hôte de la requête >
|
||||
défaut officiel), cache 60 s par ``sub``, horodatage posé avant
|
||||
l'appel (échec = ancien cache conservé, pas de rafale), tout
|
||||
échec = rôle inconnu (``None``) ;
|
||||
- pont ``/auth/draco`` : la consultation précède la résolution et
|
||||
la création JIT — rôle connu ``aucun`` → refus explicite 403,
|
||||
**aucune session ouverte, aucun compte créé**, aucune liaison à
|
||||
une session native préexistante ;
|
||||
- ``/admin`` : session établie par draco + rôle connu ≠
|
||||
``administrateur`` → refusé malgré le rôle local admin ; rôle
|
||||
``administrateur`` → accepté ; rôle inconnu → repli local ;
|
||||
session **native** (même admin, même cookie draco présent) →
|
||||
règles locales inchangées.
|
||||
"""
|
||||
|
||||
import base64
|
||||
import hashlib
|
||||
import hmac
|
||||
import json
|
||||
import time
|
||||
|
||||
import httpx
|
||||
import pytest
|
||||
from fastapi.testclient import TestClient
|
||||
|
||||
import app.main as main
|
||||
from app import draco, hub_roles, models
|
||||
|
||||
SECRET = "secret-hub19-partage"
|
||||
|
||||
SUBS_TEST = (
|
||||
"hub19-refuse", "hub19-membre", "hub19-chef", "hub19-inconnu",
|
||||
"hub19-sans-liaison",
|
||||
)
|
||||
|
||||
|
||||
def _jeton(sub, nom="Alice Exemple", secret=SECRET):
|
||||
def b64(d: bytes) -> str:
|
||||
return base64.urlsafe_b64encode(d).rstrip(b"=").decode()
|
||||
|
||||
header = b64(json.dumps({"alg": "HS256", "typ": "JWT"}).encode())
|
||||
payload = b64(json.dumps({
|
||||
"sub": sub, "name": nom, "iat": int(time.time()),
|
||||
"exp": int(time.time()) + 3600, "jti": f"jti-{sub}",
|
||||
}).encode())
|
||||
sig = hmac.new(secret.encode(), f"{header}.{payload}".encode(),
|
||||
hashlib.sha256).digest()
|
||||
return f"{header}.{payload}.{b64(sig)}"
|
||||
|
||||
|
||||
def _sub_depuis_cookie(cookie: str) -> str:
|
||||
for morceau in (cookie or "").split(";"):
|
||||
nom, _, valeur = morceau.strip().partition("=")
|
||||
if nom == "draco_session" and valeur.count(".") == 2:
|
||||
segment = valeur.split(".")[1]
|
||||
segment += "=" * (-len(segment) % 4)
|
||||
try:
|
||||
return json.loads(base64.urlsafe_b64decode(segment))["sub"]
|
||||
except Exception:
|
||||
return ""
|
||||
return ""
|
||||
|
||||
|
||||
class _Reponse:
|
||||
def __init__(self, status_code=200, donnees=None):
|
||||
self.status_code = status_code
|
||||
self._donnees = donnees
|
||||
|
||||
def json(self):
|
||||
if isinstance(self._donnees, Exception):
|
||||
raise self._donnees
|
||||
return self._donnees
|
||||
|
||||
|
||||
@pytest.fixture(autouse=True)
|
||||
def _cache_propre():
|
||||
hub_roles._reset_cache()
|
||||
yield
|
||||
hub_roles._reset_cache()
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def faux_hub(monkeypatch):
|
||||
"""Faux registre du Hub : rôles par ``sub``, lu dans le cookie relayé."""
|
||||
etat = {"roles": {}, "appels": [], "mode": "ok"}
|
||||
|
||||
def faux_get(url, headers=None, timeout=None):
|
||||
etat["appels"].append(
|
||||
{"url": url, "headers": dict(headers or {}), "timeout": timeout}
|
||||
)
|
||||
if etat["mode"] == "panne":
|
||||
raise httpx.ConnectError("Hub injoignable (simulation)")
|
||||
if etat["mode"] == "erreur500":
|
||||
return _Reponse(500, {"detail": "erreur"})
|
||||
sub = _sub_depuis_cookie((headers or {}).get("Cookie", ""))
|
||||
role = etat["roles"].get(sub, "utilisateur")
|
||||
return _Reponse(200, {
|
||||
"app": "kanbante", "sub": sub, "role": role,
|
||||
"explicite": True, "ttl_secondes": 60,
|
||||
})
|
||||
|
||||
monkeypatch.setattr(httpx, "get", faux_get)
|
||||
return etat
|
||||
|
||||
|
||||
# ── Client : contrat d'appel et résolution d'URL ─────────────
|
||||
|
||||
def test_client_appel_contrat_et_cache(faux_hub):
|
||||
faux_hub["roles"]["sub-a"] = "administrateur"
|
||||
cookie = f"draco_session={_jeton('sub-a')}; autre=1"
|
||||
assert hub_roles.role_pour(cookie, "sub-a") == "administrateur"
|
||||
# Deuxième appel dans le TTL : servi par le cache, aucun appel.
|
||||
assert hub_roles.role_pour(cookie, "sub-a") == "administrateur"
|
||||
assert len(faux_hub["appels"]) == 1
|
||||
appel = faux_hub["appels"][0]
|
||||
assert appel["url"] == "https://hub.dracodev.net/api/roles/kanbante"
|
||||
assert appel["headers"]["Cookie"] == cookie
|
||||
assert appel["headers"]["Accept"] == "application/json"
|
||||
assert appel["timeout"] == 2.0
|
||||
|
||||
|
||||
def test_client_url_hub_par_hote_dev(faux_hub):
|
||||
hub_roles.role_pour(
|
||||
f"draco_session={_jeton('sub-b')}", "sub-b",
|
||||
hote="kanbante-dev.dracodev.net",
|
||||
)
|
||||
assert faux_hub["appels"][0]["url"] == (
|
||||
"https://hub-dev.dracodev.net/api/roles/kanbante"
|
||||
)
|
||||
|
||||
|
||||
def test_client_url_hub_explicite_prioritaire(faux_hub, monkeypatch):
|
||||
monkeypatch.setenv("DRACO_HUB_URL", "https://hub.exemple.test/")
|
||||
hub_roles.role_pour(
|
||||
f"draco_session={_jeton('sub-c')}", "sub-c",
|
||||
hote="kanbante-dev.dracodev.net",
|
||||
)
|
||||
assert faux_hub["appels"][0]["url"] == (
|
||||
"https://hub.exemple.test/api/roles/kanbante"
|
||||
)
|
||||
|
||||
|
||||
def test_client_ttl_expire_reconsulte(faux_hub):
|
||||
cookie = f"draco_session={_jeton('sub-d')}"
|
||||
faux_hub["roles"]["sub-d"] = "utilisateur"
|
||||
assert hub_roles.role_pour(cookie, "sub-d") == "utilisateur"
|
||||
hub_roles._cache_fetched_at -= hub_roles.CACHE_TTL + 1
|
||||
faux_hub["roles"]["sub-d"] = "administrateur"
|
||||
assert hub_roles.role_pour(cookie, "sub-d") == "administrateur"
|
||||
assert len(faux_hub["appels"]) == 2
|
||||
|
||||
|
||||
def test_client_echec_inconnu_et_ancien_cache_conserve(faux_hub):
|
||||
cookie = f"draco_session={_jeton('sub-e')}"
|
||||
faux_hub["roles"]["sub-e"] = "utilisateur"
|
||||
assert hub_roles.role_pour(cookie, "sub-e") == "utilisateur"
|
||||
# TTL expiré, Hub en panne : l'appel tenté rend « inconnu »…
|
||||
hub_roles._cache_fetched_at -= hub_roles.CACHE_TTL + 1
|
||||
faux_hub["mode"] = "panne"
|
||||
assert hub_roles.role_pour(cookie, "sub-e") is None
|
||||
appels = len(faux_hub["appels"])
|
||||
# …mais l'horodatage posé avant l'appel garde l'ancien cache :
|
||||
# l'appel suivant (dans le nouveau TTL) le ressert sans rafale.
|
||||
assert hub_roles.role_pour(cookie, "sub-e") == "utilisateur"
|
||||
assert len(faux_hub["appels"]) == appels
|
||||
|
||||
|
||||
def test_client_reponses_illisibles_inconnues(monkeypatch):
|
||||
def faux_get(url, headers=None, timeout=None):
|
||||
return _Reponse(200, {"role": "super-utilisateur"})
|
||||
|
||||
monkeypatch.setattr(httpx, "get", faux_get)
|
||||
assert hub_roles.role_pour("c=1", "sub-f") is None
|
||||
hub_roles._reset_cache()
|
||||
|
||||
def faux_get_403(url, headers=None, timeout=None):
|
||||
return _Reponse(403, {"role": "aucun"})
|
||||
|
||||
monkeypatch.setattr(httpx, "get", faux_get_403)
|
||||
assert hub_roles.role_pour("c=1", "sub-f") is None
|
||||
|
||||
|
||||
# ── Intégration : pont draco et garde /admin ─────────────────
|
||||
|
||||
def _nettoyer():
|
||||
with models.get_db() as conn:
|
||||
ids = [
|
||||
r[0] for r in conn.execute(
|
||||
"SELECT id FROM users WHERE draco_sub IN ({})".format(
|
||||
",".join("?" * len(SUBS_TEST))
|
||||
),
|
||||
SUBS_TEST,
|
||||
).fetchall()
|
||||
]
|
||||
for uid in ids:
|
||||
conn.execute("DELETE FROM api_tokens WHERE user_id = ?", (uid,))
|
||||
conn.execute(
|
||||
"DELETE FROM workspace_members WHERE user_id = ?", (uid,)
|
||||
)
|
||||
conn.execute("DELETE FROM users WHERE id = ?", (uid,))
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def client_hub19(monkeypatch, fake_gitea, faux_hub):
|
||||
monkeypatch.setenv("KANBANTE_AUTH_USER", "bruno")
|
||||
monkeypatch.setenv("KANBANTE_AUTH_PASSWORD", "motdepasse")
|
||||
monkeypatch.setenv("DRACO_SESSION_SECRET", SECRET)
|
||||
monkeypatch.setattr(draco, "_refresh_revocations", lambda: None)
|
||||
draco._revoked_cache.clear()
|
||||
_nettoyer()
|
||||
with TestClient(main.app) as client:
|
||||
admin = next(u for u in models.list_users() if u["role"] == "admin")
|
||||
sub_avant = admin.get("draco_sub")
|
||||
try:
|
||||
yield client, faux_hub, admin
|
||||
finally:
|
||||
models.update_user(admin["id"], draco_sub=sub_avant)
|
||||
_nettoyer()
|
||||
draco._revoked_cache.clear()
|
||||
|
||||
|
||||
def _neutraliser_amorcage(admin) -> bool:
|
||||
"""Vrai si l'amorçage pur a été neutralisé (témoin lié à l'admin).
|
||||
|
||||
Même patron que tests/test_draco_correspondance.py : les
|
||||
scénarios JIT exigent que l'unique admin sans liaison ne
|
||||
capture pas le premier sub de passage.
|
||||
"""
|
||||
users = models.list_users()
|
||||
if len(users) == 1 and users[0]["role"] == "admin" \
|
||||
and not users[0].get("draco_sub"):
|
||||
models.update_user(users[0]["id"], draco_sub="hub19-temoin-amorce")
|
||||
return True
|
||||
return False
|
||||
|
||||
|
||||
def _pont(client, sub, nom="Alice Exemple"):
|
||||
client.cookies.set("draco_session", _jeton(sub, nom))
|
||||
return client.get("/auth/draco", follow_redirects=False)
|
||||
|
||||
|
||||
def test_pont_role_aucun_refuse_sans_creation(client_hub19):
|
||||
client, hub, _admin = client_hub19
|
||||
hub["roles"]["hub19-refuse"] = "aucun"
|
||||
avant = models.count_users()
|
||||
r = _pont(client, "hub19-refuse", "Refusée Exemple")
|
||||
assert r.status_code == 403
|
||||
assert "Accès refusé" in r.text
|
||||
assert "« aucun »" in r.text
|
||||
# Aucune session Kanbante ouverte par draco…
|
||||
assert "kanbante_session" not in r.headers.get("set-cookie", "")
|
||||
# …et aucun compte JIT créé pour ce sub.
|
||||
assert models.count_users() == avant
|
||||
assert models.get_user_by_draco("hub19-refuse") is None
|
||||
|
||||
|
||||
def test_pont_role_aucun_ne_lie_pas_une_session_native(client_hub19):
|
||||
client, hub, admin = client_hub19
|
||||
hub["roles"]["hub19-sans-liaison"] = "aucun"
|
||||
# Session native préexistante (format historique, sans marqueur).
|
||||
client.cookies.set(
|
||||
"kanbante_session", main._make_session(admin["username"])
|
||||
)
|
||||
r = _pont(client, "hub19-sans-liaison")
|
||||
assert r.status_code == 403
|
||||
# La consultation a précédé la liaison : rien n'a été lié.
|
||||
assert models.get_user_by_draco("hub19-sans-liaison") is None
|
||||
# La session native elle-même n'est pas touchée.
|
||||
assert client.get("/").status_code == 200
|
||||
|
||||
|
||||
def test_pont_role_utilisateur_ouvre_session_jit(client_hub19):
|
||||
client, hub, admin = client_hub19
|
||||
hub["roles"]["hub19-membre"] = "utilisateur"
|
||||
pur = _neutraliser_amorcage(admin)
|
||||
try:
|
||||
r = _pont(client, "hub19-membre", "Membre Exemple")
|
||||
assert r.status_code == 303 and r.headers["location"] == "/"
|
||||
assert "kanbante_session" in r.headers.get("set-cookie", "")
|
||||
cree = models.get_user_by_draco("hub19-membre")
|
||||
assert cree is not None and cree["role"] == "member"
|
||||
assert client.get("/").status_code == 200
|
||||
finally:
|
||||
if pur:
|
||||
models.update_user(admin["id"], draco_sub=None)
|
||||
|
||||
|
||||
def test_pont_role_inconnu_comportement_actuel(client_hub19):
|
||||
client, hub, admin = client_hub19
|
||||
hub["mode"] = "panne"
|
||||
pur = _neutraliser_amorcage(admin)
|
||||
try:
|
||||
r = _pont(client, "hub19-inconnu", "Inconnu Exemple")
|
||||
assert r.status_code == 303 and r.headers["location"] == "/"
|
||||
assert models.get_user_by_draco("hub19-inconnu") is not None
|
||||
finally:
|
||||
if pur:
|
||||
models.update_user(admin["id"], draco_sub=None)
|
||||
|
||||
|
||||
def _admin_lie_au_pont(client, hub, admin, role_hub):
|
||||
"""Lie le compte admin local au sub chef, puis ouvre sa session par le pont."""
|
||||
models.update_user(admin["id"], draco_sub="hub19-chef")
|
||||
hub["roles"]["hub19-chef"] = role_hub
|
||||
hub_roles._reset_cache()
|
||||
r = _pont(client, "hub19-chef", "Chef Exemple")
|
||||
assert r.status_code == 303 and r.headers["location"] == "/"
|
||||
return r
|
||||
|
||||
|
||||
def test_admin_session_draco_exige_administrateur_du_registre(client_hub19):
|
||||
client, hub, admin = client_hub19
|
||||
_admin_lie_au_pont(client, hub, admin, "utilisateur")
|
||||
# Rôle local admin, mais registre connu « utilisateur » : refusé.
|
||||
r = client.get("/admin")
|
||||
assert r.status_code == 403
|
||||
# Registre passé à « administrateur » : accepté.
|
||||
hub["roles"]["hub19-chef"] = "administrateur"
|
||||
hub_roles._reset_cache()
|
||||
r = client.get("/admin")
|
||||
assert r.status_code == 200
|
||||
|
||||
|
||||
def test_admin_session_draco_role_inconnu_repli_local(client_hub19):
|
||||
client, hub, admin = client_hub19
|
||||
_admin_lie_au_pont(client, hub, admin, "administrateur")
|
||||
assert client.get("/admin").status_code == 200
|
||||
# Hub en panne et cache expiré : rôle inconnu → règles locales.
|
||||
hub["mode"] = "panne"
|
||||
hub_roles._cache_fetched_at -= hub_roles.CACHE_TTL + 1
|
||||
# L'appel de garde rend « inconnu » (l'ancien cache ne ressert
|
||||
# qu'aux appels suivants, patron du pilote) : le repli local joue.
|
||||
r = client.get("/admin")
|
||||
assert r.status_code == 200
|
||||
|
||||
|
||||
def test_admin_session_native_non_soumise_au_registre(client_hub19):
|
||||
client, hub, admin = client_hub19
|
||||
models.update_user(admin["id"], draco_sub="hub19-chef")
|
||||
hub["roles"]["hub19-chef"] = "utilisateur"
|
||||
# Session NATIVE de l'admin (mot de passe / format historique) :
|
||||
# même avec un cookie draco présent et un rôle registre connu
|
||||
# « utilisateur », /admin reste régi par les règles locales.
|
||||
client.cookies.set(
|
||||
"kanbante_session", main._make_session(admin["username"])
|
||||
)
|
||||
client.cookies.set("draco_session", _jeton("hub19-chef", "Chef Exemple"))
|
||||
r = client.get("/admin")
|
||||
assert r.status_code == 200
|
||||
|
||||
|
||||
def test_marqueur_session_draco_signe():
|
||||
"""Le marqueur « établie par draco » est couvert par la signature."""
|
||||
from starlette.requests import Request
|
||||
|
||||
def requete(valeur):
|
||||
scope = {
|
||||
"type": "http", "method": "GET", "path": "/",
|
||||
"headers": [(b"cookie", f"kanbante_session={valeur}".encode())],
|
||||
}
|
||||
return Request(scope)
|
||||
|
||||
natif = main._make_session("bruno")
|
||||
assert main._session_info(requete(natif)) == ("bruno", False)
|
||||
via = main._make_session("bruno", via_draco=True)
|
||||
assert main._session_info(requete(via)) == ("bruno", True)
|
||||
# Marqueur ajouté à la main sur un jeton natif : signature fausse.
|
||||
pirate = natif.rsplit(".", 1)[0] + ".draco." + natif.rsplit(".", 1)[1]
|
||||
assert main._session_info(requete(pirate)) is None
|
||||
@@ -0,0 +1,216 @@
|
||||
"""Porte centrale unique (0.46.6) — réglage, écran, refus, secours.
|
||||
|
||||
Branche de la phase 2 du programme « compte partout » (basée sur
|
||||
la 0.46.5, fusion #145/#144). Couvert ici, sur instance fraîche
|
||||
par test (base temporaire : seul le compte d'amorçage « proprio »,
|
||||
admin, créé depuis l'environnement — même patron que
|
||||
tests/test_amorcage_pont.py) :
|
||||
|
||||
- mode INACTIF (défaut à la livraison) : comportement actuel —
|
||||
formulaire local visible et fonctionnel ;
|
||||
- activation par le PANNEAU d'administration (le réglage
|
||||
``porte_centrale`` se pose et se retire : ``true`` puis
|
||||
``false`` — la conversion booléenne explicite de
|
||||
l'enregistrement est exercée au passage) ;
|
||||
- mode ACTIF : l'écran ne présente que l'entrée centrale (lien
|
||||
SSO, aucun champ local) ; le formulaire local est refusé même
|
||||
avec des identifiants locaux valides ; une session déjà
|
||||
établie reste valide (aucun impact) ;
|
||||
- porte de secours : chemin discret ``/login/secours``, jamais
|
||||
proposé sur l'écran principal ; identifiants posés par les
|
||||
variables d'environnement ``KANBANTE_PORTE_SECOURS_USER`` /
|
||||
``KANBANTE_PORTE_SECOURS_PASSWORD`` ; seul le compte
|
||||
administrateur désigné passe (un membre désigné est refusé) ;
|
||||
sans les variables, le chemin répond 404.
|
||||
"""
|
||||
|
||||
import json
|
||||
|
||||
import pytest
|
||||
from fastapi.testclient import TestClient
|
||||
|
||||
import app.main as main
|
||||
from app import accounts, models
|
||||
from app.config import get_settings
|
||||
|
||||
MDP_AMORCE = "mdp-amorce"
|
||||
MDP_MEMBRE = "mdp-membre"
|
||||
MDP_SECOURS = "mdp-secours-test"
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def instance(monkeypatch, tmp_path, fake_gitea):
|
||||
monkeypatch.setenv("KANBANTE_DB_PATH", str(tmp_path / "porte.db"))
|
||||
monkeypatch.setenv("KANBANTE_AUTH_USER", "proprio")
|
||||
monkeypatch.setenv("KANBANTE_AUTH_PASSWORD", MDP_AMORCE)
|
||||
with TestClient(main.app) as client:
|
||||
users = models.list_users()
|
||||
assert len(users) == 1 and users[0]["username"] == "proprio"
|
||||
membre_id = models.create_user(
|
||||
"membre1", accounts.hash_password(MDP_MEMBRE),
|
||||
role="member", display_name="Membre Un",
|
||||
)
|
||||
yield client, users[0], membre_id
|
||||
|
||||
|
||||
def _csrf(client, chemin="/login"):
|
||||
client.get(chemin)
|
||||
return client.cookies.get("kanbante_csrf") or ""
|
||||
|
||||
|
||||
def _connecter(client, username, password, chemin="/login"):
|
||||
token = _csrf(client, chemin)
|
||||
return client.post(
|
||||
chemin,
|
||||
data={"username": username, "password": password,
|
||||
"next": "/", "csrf_token": token},
|
||||
follow_redirects=False,
|
||||
)
|
||||
|
||||
|
||||
def _activer_porte_par_le_panneau(client):
|
||||
"""Connexion admin native, puis POST /admin/settings (true)."""
|
||||
r = _connecter(client, "proprio", MDP_AMORCE)
|
||||
assert r.status_code == 303
|
||||
r = client.get("/admin/settings")
|
||||
assert r.status_code == 200
|
||||
assert "porte_centrale" in r.text # le réglage est au panneau
|
||||
token = client.cookies.get("kanbante_csrf") or ""
|
||||
r = client.post(
|
||||
"/admin/settings",
|
||||
data={"setting_porte_centrale": "true", "csrf_token": token},
|
||||
follow_redirects=False,
|
||||
)
|
||||
assert r.status_code == 303
|
||||
assert get_settings().porte_centrale is True
|
||||
|
||||
|
||||
# ── Mode inactif : comportement actuel ───────────────────────
|
||||
|
||||
def test_mode_inactif_par_defaut_comportement_actuel(instance):
|
||||
client, _amorce, _membre = instance
|
||||
assert get_settings().porte_centrale is False
|
||||
r = client.get("/login")
|
||||
assert r.status_code == 200
|
||||
assert 'name="password"' in r.text # formulaire local présent
|
||||
assert "Se connecter avec ObsiGate (SSO)" in r.text
|
||||
# Le formulaire local fonctionne pour un compte ordinaire.
|
||||
r = _connecter(client, "membre1", MDP_MEMBRE)
|
||||
assert r.status_code == 303
|
||||
assert "kanbante_session" in r.headers.get("set-cookie", "")
|
||||
assert client.get("/").status_code == 200
|
||||
|
||||
|
||||
def test_panneau_active_puis_desactive(instance):
|
||||
client, _amorce, _membre = instance
|
||||
_activer_porte_par_le_panneau(client)
|
||||
# Désactivation : saisir « false » doit RÉELLEMENT désactiver
|
||||
# (conversion booléenne explicite, pas bool("false") == True).
|
||||
token = client.cookies.get("kanbante_csrf") or ""
|
||||
r = client.post(
|
||||
"/admin/settings",
|
||||
data={"setting_porte_centrale": "false", "csrf_token": token},
|
||||
follow_redirects=False,
|
||||
)
|
||||
assert r.status_code == 303
|
||||
assert get_settings().porte_centrale is False
|
||||
# Et le formulaire refonctionne (session admin refermée).
|
||||
client.cookies.delete("kanbante_session")
|
||||
r = _connecter(client, "membre1", MDP_MEMBRE)
|
||||
assert r.status_code == 303
|
||||
|
||||
|
||||
# ── Mode actif : écran central, formulaire refusé ────────────
|
||||
|
||||
def test_mode_actif_ecran_et_formulaire_refuse(instance):
|
||||
client, _amorce, _membre = instance
|
||||
_activer_porte_par_le_panneau(client)
|
||||
# La session DÉJÀ ÉTABLIE (celle de l'admin qui vient
|
||||
# d'activer) n'est pas touchée par l'activation.
|
||||
assert client.get("/").status_code == 200
|
||||
assert client.get("/admin/settings").status_code == 200
|
||||
# Écran de connexion, visiteur déconnecté : entrée centrale seule.
|
||||
client.cookies.delete("kanbante_session")
|
||||
r = client.get("/login")
|
||||
assert r.status_code == 200
|
||||
assert "Se connecter avec ObsiGate (SSO)" in r.text
|
||||
assert 'name="password"' not in r.text
|
||||
assert 'action="/login"' not in r.text
|
||||
# Le chemin de secours n'est JAMAIS proposé sur l'écran principal.
|
||||
assert "/login/secours" not in r.text
|
||||
# Formulaire local refusé, même avec les identifiants valides
|
||||
# d'un compte ordinaire…
|
||||
r = _connecter(client, "membre1", MDP_MEMBRE)
|
||||
assert r.status_code == 403
|
||||
assert "porte centrale est active" in r.text
|
||||
assert "kanbante_session" not in r.headers.get("set-cookie", "")
|
||||
# …et même avec ceux de l'administrateur d'amorçage.
|
||||
r = _connecter(client, "proprio", MDP_AMORCE)
|
||||
assert r.status_code == 403
|
||||
assert "kanbante_session" not in r.headers.get("set-cookie", "")
|
||||
|
||||
|
||||
# ── Porte de secours ─────────────────────────────────────────
|
||||
|
||||
def test_porte_secours_chemin_discret(instance, monkeypatch):
|
||||
client, _amorce, _membre = instance
|
||||
monkeypatch.setenv("KANBANTE_PORTE_SECOURS_USER", "proprio")
|
||||
monkeypatch.setenv("KANBANTE_PORTE_SECOURS_PASSWORD", MDP_SECOURS)
|
||||
_activer_porte_par_le_panneau(client)
|
||||
client.cookies.delete("kanbante_session")
|
||||
# L'écran principal ne propose toujours pas le chemin.
|
||||
assert "/login/secours" not in client.get("/login").text
|
||||
# Le chemin discret, lui, présente son formulaire…
|
||||
r = client.get("/login/secours")
|
||||
assert r.status_code == 200
|
||||
assert 'action="/login/secours"' in r.text
|
||||
# …refuse un mauvais mot de passe…
|
||||
r = _connecter(client, "proprio", "mauvais", chemin="/login/secours")
|
||||
assert r.status_code == 401
|
||||
assert "kanbante_session" not in r.headers.get("set-cookie", "")
|
||||
# …refuse le compte membre (pas le compte désigné)…
|
||||
r = _connecter(client, "membre1", MDP_SECOURS, chemin="/login/secours")
|
||||
assert r.status_code == 401
|
||||
# …et ouvre la session de l'administrateur désigné, en plein
|
||||
# mode porte centrale.
|
||||
r = _connecter(client, "proprio", MDP_SECOURS, chemin="/login/secours")
|
||||
assert r.status_code == 303
|
||||
assert "kanbante_session" in r.headers.get("set-cookie", "")
|
||||
assert client.get("/admin").status_code == 200
|
||||
|
||||
|
||||
def test_porte_secours_membre_designe_refuse(instance, monkeypatch):
|
||||
"""Le compte désigné doit être administrateur : un membre ne passe pas."""
|
||||
client, _amorce, _membre = instance
|
||||
monkeypatch.setenv("KANBANTE_PORTE_SECOURS_USER", "membre1")
|
||||
monkeypatch.setenv("KANBANTE_PORTE_SECOURS_PASSWORD", MDP_SECOURS)
|
||||
r = _connecter(client, "membre1", MDP_SECOURS, chemin="/login/secours")
|
||||
assert r.status_code == 401
|
||||
assert "kanbante_session" not in r.headers.get("set-cookie", "")
|
||||
|
||||
|
||||
def test_porte_secours_non_configuree_404(instance):
|
||||
client, _amorce, _membre = instance
|
||||
# Aucune variable de secours dans l'environnement de test.
|
||||
assert client.get("/login/secours").status_code == 404
|
||||
r = _connecter(client, "proprio", MDP_AMORCE, chemin="/login/secours")
|
||||
assert r.status_code == 404
|
||||
assert "kanbante_session" not in r.headers.get("set-cookie", "")
|
||||
|
||||
|
||||
def test_activation_par_variable_environnement(monkeypatch, tmp_path, fake_gitea):
|
||||
"""L'environnement peut amorcer le réglage (défaut officiel : inactif)."""
|
||||
monkeypatch.setenv("KANBANTE_DB_PATH", str(tmp_path / "porte-env.db"))
|
||||
monkeypatch.setenv("KANBANTE_AUTH_USER", "proprio")
|
||||
monkeypatch.setenv("KANBANTE_AUTH_PASSWORD", MDP_AMORCE)
|
||||
monkeypatch.setenv("KANBANTE_PORTE_CENTRALE", "1")
|
||||
with TestClient(main.app) as client:
|
||||
assert get_settings().porte_centrale is True
|
||||
r = client.get("/login")
|
||||
assert 'name="password"' not in r.text
|
||||
# La surcharge du panneau reste possible par-dessus :
|
||||
# (kv settings_overrides, même écriture que le panneau).
|
||||
models.set_kv(
|
||||
"settings_overrides", json.dumps({"porte_centrale": False})
|
||||
)
|
||||
assert get_settings().porte_centrale is False
|
||||
Reference in New Issue
Block a user