Compare commits
18
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
d6d4914a84 | ||
|
|
f56c22c152 | ||
|
|
7b0fee43d2 | ||
|
|
bff3f74640 | ||
|
|
365a724e6e | ||
|
|
eac6156d47 | ||
|
|
530e24b529 | ||
|
|
d82a38d960 | ||
|
|
b5f49f4e39 | ||
|
|
f05a872caa | ||
|
|
b7145e398d | ||
|
|
6b1e2491dd | ||
|
|
e4531488d0 | ||
|
|
f8f8af63e1 | ||
|
|
d89b35061b | ||
|
|
4cd203ba5c | ||
|
|
5ba9bca3a3 | ||
|
|
4897009a93 |
@@ -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
|
||||
|
||||
+74
-7
@@ -1,12 +1,79 @@
|
||||
## 0.46.3 — 2026-11-06 — Réglages généraux du Hub consommés par Kanbante (HUB-21, propagation du pilote TikTak 0.61.22)
|
||||
## 0.46.11 — 2026-11-16 — SSO : plus aucune sortie nue, « aucun » seulement si décidé, pont inerte signalé
|
||||
|
||||
Version **corrective** au sens du patron du dépôt (branchement sur un contrat du Hub existant, aucun comportement métier nouveau au-delà de la bannière et du drapeau).
|
||||
Ronde 2 du cas réel (dev de Bruno) : la 0.46.10 déployée, le bouton SSO ramenait toujours le compte « bruno » au formulaire **nu** — URL `/login` sans paramètre, aucun message — alors que son cookie draco était valide (lu par ShaarIt et TikTak dans le même navigateur). Énumération complète des sorties de la chaîne d'entrée draco (pont, middleware de cohérence #150, entrée automatique 0.46.8, registre des rôles, révocations, rattachement/conflit, re-liaison) et reproduction en pile fidèle de chaque état candidat : la seule variante qui reproduit le symptôme à l'identique est **`DRACO_SESSION_SECRET` absent du conteneur Kanbante** — draco inerte, `claims_for` toujours None, le pont prenait la sortie « jeton absent » vers `/login` nu, pendant que le bouton SSO continuait d'être rendu. Les autres candidates sont signalées ou servent un compte (rôle explicite → 403 lu ; conflit → message dans la page finale ; jeton révoqué → `draco=invalide` ; session du clone « bruno-2 » → le clone est servi). La cause racine est donc un état du conteneur, mais le code taisait l'échec : c'est ce silence qui est corrigé ici, pour que le prochain écart de configuration se lise à l'écran au lieu de se deviner.
|
||||
|
||||
- **Client des réglages généraux** (`app/hub_reglages.py`, nouveau) : consultation côté serveur de `GET {hub}/api/reglages/effectifs` — endpoint public, aucun cookie, `Accept: application/json`, délai 2,0 s. 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 — `xxx-dev` → `hub-dev`), jamais d'URL dev figée. Cache mémoire 60 s, horodatage posé **avant** l'appel : un échec conserve l'ancien cache, pas de rafale. Forme validée strictement (liste fermée D6(a)) ; toute erreur (réseau, statut, JSON, forme) = **repli intégral** sur les défauts actuels (`recherche_partout: true`, `banniere: ""`, `domaine_defaut: null`), jamais d'exception.
|
||||
- **Bannière d'annonce** : `render()` pose `banniere_hub` dans le contexte commun ; le partiel `app/templates/_header.html` (toutes les pages applicatives) rend le bandeau sous la barre commune — texte échappé par l'autoescape Jinja (jamais de HTML injecté), bouton « fermer » qui mémorise le texte fermé en `sessionStorage` (clé `kanbante_banniere_masquee`) : une nouvelle annonce réapparaît. Bannière vide = aucun fragment rendu, zéro changement visuel. Styles `.banniere-hub*` dans `static/css/style.css` (fond `var(--accent)`).
|
||||
- **Drapeau `recherche_partout`** : `render()` pose aussi `recherche_partout_hub` ; le gabarit `recherche.html` le rend en `data-recherche-partout` sur le `<main id="recherche">`. Le JS vendangé `static/js/recherche.js` (même modification dans les 4 hôtes applicatifs) n'interroge plus les sœurs ni la console quand la valeur est `false` — sections « Recherche fédérée désactivée… », la recherche locale Kanbante continue ; attribut absent ou illisible = fédération active (repli).
|
||||
- **`domaine_defaut` non consommé** : Kanbante n'a pas de notion de domaine (Pro/Famille/Perso) propre — le sélecteur de la barre commune pilote le panneau Spark, pas les vues Kanbante. La valeur est lue et validée par le client, sans effet local ; seul l'hôte console (agent) l'applique.
|
||||
- Tests : `tests/test_hub_reglages.py` (nouveau, 10 tests — validation de la forme, contrat exact de l'appel, URL dérivée par l'hôte dev, cache 60 s et expiration, repli Hub muet/erreur 500/forme inattendue, ancien cache sans rafale ; intégration : bannière présente et échappée dans /recherche, absente si vide ou Hub muet, attribut du drapeau selon la valeur) ; `tests/recherche.test.js` étendu (fonction pure `federationAutorisee`).
|
||||
- **Aucune sortie nue (pont, middleware, re-liaison)** : jeton absent → `/login?draco=absent` (« Aucune session de la suite n'a été présentée ») ; cookie présent mais service draco inerte → `/login?draco=inactif` (« la connexion par la suite n'est pas active sur ce service — configuration incomplète ») ; les sorties `invalide` (0.46.10), `conflit` (0.46.10) et `echec` (0.46.8) sont inchangées. L'entrée automatique du middleware signale de même une page demandée avec un cookie présent mais inutilisable (`invalide` / `inactif`) au lieu du formulaire muet. Les sorties de `/auth/draco/relier` sans session native portent `draco=echec`. Le propriétaire légitime dont le conteneur perd le secret verra donc le nom du défaut — et le geste de réparation est côté hébergement (remettre le secret partagé dans l'environnement du conteneur, même valeur que l'émettrice).
|
||||
- **« Aucun » seulement si décidé** (`app/hub_roles.py`) : la consultation du registre transporte désormais le drapeau `explicite` de la réponse (nouveau `explicite_pour`, même cache que `role_pour`). Le pont ne refuse un rôle « aucun » que s'il est explicite ou d'origine inconnue (réponse sans le drapeau : comportement historique conservé). Un « aucun » que le registre présente comme son défaut (`explicite: false`) n'est pas une décision de l'administrateur : il ne verrouille plus l'entrée — conformément à l'esprit du pilote (« le registre ne crée jamais un verrouillage nouveau »). Vérifié en pile : avec le Hub actuel, un compte sans ligne reçoit `utilisateur` (défaut), donc un « aucun » réel reste toujours une ligne explicite de la matrice.
|
||||
- **Documentation** : `docs/correspondance-draco.md` (sorties d'échec toutes signalées ; précision `explicite` à la section des rôles).
|
||||
- **Tests** : `test_draco_sso.py` (les deux tests qui figeaient les sorties nues — `test_pont_sans_cookie_vers_login`, `test_pont_inerte_sans_secret`, le cas réel du conteneur sans secret — portent le nouveau contrat ; ajoutés : entrée par page avec service inerte, rôle « aucun » non explicite / explicite / d'origine inconnue), `test_entree_sso.py` (cookie invalide signalé au formulaire), `test_hub_roles.py` (transport du drapeau `explicite`, cache partagé), `test_draco_rattachement.py` (contrat du jeton absent mis à jour). Suite complète : listes d'échecs strictement identiques à l'arbre vierge (23, fonds préexistant instable), 7 tests nouveaux tous verts.
|
||||
|
||||
## 0.46.10 — 2026-11-16 — SSO : rattachement par homonymie, conflit explicite, re-liaison par double preuve
|
||||
|
||||
Cas réel (dev de Bruno) : connecté chez ObsiGate avec son compte « bruno », le bouton SSO de Kanbante ne le connectait pas à son compte. Diagnostic prouvé en pile fidèle à son état (secrets partagés identiques, épingles officielles, admin local « bruno » d'amorçage + instance multi-utilisateurs) : la résolution ne cherchait que par `sub` — à sub inconnu, le JIT créait un clone suffixé « bruno-2 » (membre) et ouvrait SA session, que le compte local « bruno » soit sans lien ou lié à un ancien sub ; et un jeton présent mais illisible pour Kanbante (secret du conteneur divergent, révocation) ramenait au formulaire **nu**, sans session ni message.
|
||||
|
||||
- **Rattachement par homonymie** (`app.accounts.resolve_draco_user`, étape 3) : un compte local portant exactement le nom d'utilisateur de l'identité présentée (base dérivée des claims) et **sans lien draco** est rattaché au sub vérifié et servi — fini le clone « bruno-2 » pour le propriétaire légitime. Fondement : les noms centraux font foi (comptes créés par l'administrateur au Hub, aucune inscription publique). Un sub de nom **différent** n'absorbe toujours aucun compte (fusion #145 intacte) ; un homonyme désactivé n'est jamais contourné.
|
||||
- **Conflit explicite** : homonyme déjà lié à un **autre** sub → aucun rattachement silencieux, aucun clone : le pont redirige vers `/login?draco=conflit` et le formulaire explique la sortie (nouveau `accounts.draco_conflit_nom`).
|
||||
- **Re-liaison par double preuve** : connexion locale par mot de passe réussie pendant qu'un cookie draco valide désaligné est présent (ou passage du pont avec session native) → page **`/auth/draco/relier`** nommant les deux identités ; le geste, revérifié (session + cookie + CSRF), réécrit `users.draco_sub` — retrait à l'ancien détenteur compris, journalisé `draco.relink.retrait` / `draco.relink`. Le compte délié garde son mot de passe local.
|
||||
- **Jeton illisible signalé** : jeton draco **présent** mais non validé par Kanbante (signature, expiration, révocation) → `/login?draco=invalide` avec message explicite ; jeton **absent** → formulaire nu inchangé.
|
||||
- **Documentation** : `docs/correspondance-draco.md` (résolution en 5 étapes, re-liaison par double preuve, jeton illisible).
|
||||
- **Tests** : nouveau `tests/test_draco_rattachement.py` (9) — cas réels A (rattachement), B (conflit), D (invalide), double preuve dans les deux sens, exigences de la re-liaison, JIT inchangé, non-absorption d'un nom différent. Le test historique `test_jit_n_adopte_pas_un_compte_homonyme_non_lie` est inversé en `test_homonyme_non_lie_rattache_depuis_04610` (le contrat qu'il figeait est précisément le défaut corrigé). Suite complète comparée à main vierge, environnement identique.
|
||||
|
||||
## 0.46.9 — 2026-11-08 — Retour SSO : l'hôte de la requête fait foi pour le retour navigateur (empilée sur la 0.46.8)
|
||||
|
||||
Cas réel (dev) : le bouton « Se connecter avec ObsiGate (SSO) » servi par kanbante-dev portait `return_to=https://kanbante.dracodev.net/auth/draco` — le retour atterrissait sur le nom officiel, où la prod n'est pas encore installée. Cause : l'adresse de retour venait de la chaîne de configuration (`resoudre_urls_draco` : variable explicite de l'app d'abord), et les adresses publiques explicites des conteneurs dev portent les noms officiels.
|
||||
|
||||
- **Nouveau `app.config.base_retour_navigateur(hote, repli)`** : pour un aller-retour SSO **initié par un navigateur**, la base de retour est `https://<hôte public de la requête>` quand cet hôte suit le motif fermé dracodev — elle prime sur toute la configuration. Hors motif (LAN, IP, domaine propre) : le repli (la chaîne habituelle) s'applique, inchangé. Les contextes sans requête et les appels serveur-à-serveur gardent la résolution par configuration.
|
||||
- **`render()`** construit `sso_authorize_url` avec ce helper (repli = l'URL publique résolue comme avant) ; l'émettrice et les autres URL du contexte (barre, panneau, CSP) restent résolues par la chaîne habituelle.
|
||||
- **Tests** : `tests/test_draco_barre.py` (le helper : hôte -dev prime sur un repli officiel, hôte officiel inchangé, hors motif = repli) et `tests/test_draco_sso.py` (le bouton servi : configuration « conteneur dev réel » — AGENT_URL et KANBANTE_PUBLIC_URL explicites sur les noms officiels, émettrice en -dev → `return_to` en **-dev** ; régressions prod et LAN).
|
||||
|
||||
## 0.46.8 — 2026-11-08 — Entrée SSO automatique sans session locale (chantier « entrée SSO de bout en bout », empilée sur la 0.46.7)
|
||||
|
||||
Écarts constatés par Bruno en test réel le 2026-11-08 (compte « testeur » créé au Hub), chaînes prouvées en navigateur réel dans une pile locale aux noms publics :
|
||||
|
||||
- **Entrée automatique par le pont** (`AuthMiddleware`) : une **page** demandée sans session locale mais avec un cookie `draco_session` **valide** (`app.draco.claims_for`) est renvoyée au pont `/auth/draco?next=…` au lieu du formulaire de connexion — le pont ouvre (ou crée, JIT) la session du compte désigné et revient à la cible. Avant : le formulaire était servi comme si la session de la suite n'existait pas, et le clic sur le bouton SSO restait sans effet pour qui avait déjà une session centrale (le retour se perdait chez ObsiGate — correctif compagne ObsiGate 2.86.2, BUG-123). **Gardes** : cookie absent ou invalide → formulaire et pages publiques inchangés ; les **API** gardent leur 401 (jamais de redirection) ; le `/login` est public, jamais réintercepté ; les gardes du pont s'appliquent telles quelles — rôle « aucun » au registre → sa page 403. Symétrique du contrôle de cohérence de la 0.46.7, qui couvre le cas inverse (session locale d'un AUTRE compte).
|
||||
- **Échec du pont signalé** : quand la résolution du compte échoue (p. ex. compte désactivé), le pont redirige désormais vers `/login?next=…&draco=echec` et l'écran de connexion affiche la raison au lieu d'un retour muet au formulaire. Le contrat de la redirection change donc de forme (`/login` nu → paramètres) — attente ajustée dans `tests/test_draco_correspondance.py`.
|
||||
- **Barre commune : l'identité de session** : `render()` pose désormais dans la configuration de la barre le **nom du compte de la session** (`display_name`, sinon `username`) et son initiale — la Fusion ACC-1 servait l'initiale de l'opérateur d'environnement (`auth_user`) à tous les comptes : un membre entré par le pont voyait « P » (opérateur) dans le menu compte alors que la barre latérale affichait son nom. Repli opérateur conservé sans utilisateur de session.
|
||||
- **Tests** : nouveau `tests/test_entree_sso.py` (10) — redirection au pont (compte lié et JIT), chaîne complète jusqu'à la session ouverte, API en 401, sans cookie / cookie invalide inchangés, page de connexion jamais interceptée, rôle « aucun » tranché par le pont sans boucle, échec de résolution signalé au formulaire, nom de session dans la barre. Suite complète comparée à la base 0.46.7 : aucun échec nouveau (23 échecs préexistants identiques, vérifiés aussi par exécution sur la base sans le présent correctif).
|
||||
|
||||
## 0.46.7 — 2026-11-07 — Cohérence d'identité au changement de compte
|
||||
|
||||
Cas réel : connecté « fred » chez ObsiGate, l'utilisateur ouvre Kanbante et y trouve son propre compte — la session locale préexistante gouvernait sans jamais reconsulter l'identité centrale.
|
||||
|
||||
- **Contrôle de cohérence dans `AuthMiddleware`** (`_coherence_draco`) : quand une requête authentifiée par la session signée porte aussi un cookie `draco_session` **valide** (`app.draco.claims_for` : signature, expiration, révocation) dont le `sub` diffère du sub lié (`users.draco_sub`) au compte de la session, la session locale est invalidée — Kanbante n'a pas de session serveur : le cookie est supprimé de la réponse — et les **pages** sont renvoyées au pont `/auth/draco` (JIT si besoin) ; les **API** reçoivent un 401 avec le même effacement (aucune écriture attribuée au mauvais compte ; l'action en vol n'est pas rejouée sous une autre identité). **Gardes** : aucun cookie ou cookie invalide/expiré/révoqué → rien (une panne de l'émettrice ne déconnecte personne) ; authentification Basic (scripts) → hors contrôle ; contrats navigateur inter-apps `/api/search` et `/api/events` → exemptés (sémantiques propres) ; cookie que le pont ne peut pas servir (rôle « aucun » au registre, compte désactivé ou sans résolution) → session gardée, pas d'exclusion en boucle. **Compte local sans aucun lien** : l'identité centrale présente gagne, le pont s'applique (choix documenté). Après alignement, le compte servi est celui du cookie : pas de boucle.
|
||||
- **Sessions de secours marquées** : segment signé `secours` dans le cookie de session (`user.expiry.secours.hmac`, même patron que le marqueur `draco` de la 0.46.2 ; `_session_info_complet` lit les trois formats, l'historique reste valide) — posée par `POST /login/secours`, elle exempte la session du contrôle de cohérence : elle vit hors circuit central par construction.
|
||||
- **Tests** : nouveau `tests/test_coherence_identite.py` (10) — page et API alignées, pont servant ensuite le compte du cookie, même sub / sans cookie / cookie invalide intacts, secours exemptée, rôle « aucun » gardé, compte sans lien aligné, marqueurs lisibles et infalsifiables. Montage ajusté dans `tests/test_draco_correspondance.py` (la déliaison par l'administrateur se fait désormais sans cookie draco étranger dans le navigateur — c'est précisément le cas aligné par la 0.46.7). Suite complète comparée à main vierge : aucun échec nouveau (23 échecs préexistants identiques, environnement et dérive de gabarits).
|
||||
|
||||
## 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)
|
||||
|
||||
|
||||
@@ -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 » |
|
||||
|
||||
+132
-23
@@ -79,19 +79,41 @@ def ensure_bootstrap_admin() -> dict | None:
|
||||
# (app.main.draco_bridge) et du contrôle draco de /api/search :
|
||||
#
|
||||
# 1. correspondance existante → son compte (None si désactivé) ;
|
||||
# 2. amorçage : s'il n'existe qu'UN seul compte et que c'est un
|
||||
# admin actif sans liaison, le premier sub valide s'y lie —
|
||||
# le compte d'amorçage (celui de Bruno, créé depuis
|
||||
# l'environnement) garde ainsi son accès sans verrouillage ;
|
||||
# 3. sinon, si provisionner=True : création JIT d'un compte
|
||||
# 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. rattachement par HOMONYMIE (0.46.10, chantier SSO
|
||||
# « bruno ») : si un compte local porte EXACTEMENT le nom
|
||||
# d'utilisateur que cette identité porterait (base dérivée
|
||||
# des claims, voir _base_nom_draco) et qu'il n'a AUCUN lien
|
||||
# draco, le sub y est rattaché et c'est CE compte qui est
|
||||
# servi — avant, le JIT créait un clone suffixé (« bruno-2 »)
|
||||
# et le propriétaire légitime n'atteignait jamais son compte.
|
||||
# Fondement : les noms centraux font foi — les comptes de la
|
||||
# suite sont créés par l'administrateur au Hub, il n'existe
|
||||
# aucune inscription publique ; un sub de nom DIFFÉRENT
|
||||
# n'absorbe toujours aucun compte (le #145 reste entier).
|
||||
# Si l'homonyme est déjà lié à un AUTRE sub : aucun
|
||||
# rattachement silencieux, aucun clone — résolution à None,
|
||||
# le pont signale le conflit (draco_conflit_nom) et la
|
||||
# re-liaison exige la double preuve (voir
|
||||
# app.main.draco_relier) ;
|
||||
# 4. sinon, si provisionner=True : création JIT d'un compte
|
||||
# propre à cette identité (voir provision_draco_user).
|
||||
#
|
||||
# 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).
|
||||
# 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).
|
||||
|
||||
|
||||
def _slug_draco(valeur: str) -> str:
|
||||
@@ -100,17 +122,28 @@ def _slug_draco(valeur: str) -> str:
|
||||
return re.sub(r"[^a-z0-9]+", "-", texte).strip("-")[:40].strip("-")
|
||||
|
||||
|
||||
def _base_nom_draco(nom_affiche: str) -> str | None:
|
||||
"""Base du nom d'utilisateur d'une identité draco : le nom
|
||||
affiché slugifié (« Alice Exemple » → « alice-exemple »,
|
||||
« bruno » → « bruno »). None si la base est inexploitable
|
||||
(< 3 caractères) : aucune homonymie ne peut alors être
|
||||
établie et le JIT retombe sur son nom de repli."""
|
||||
base = _slug_draco(nom_affiche)
|
||||
return base if len(base) >= 3 else None
|
||||
|
||||
|
||||
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.
|
||||
est déjà pris, un suffixe -2, -3… est ajouté : hors le
|
||||
rattachement par homonymie de resolve_draco_user (compte
|
||||
homonyme SANS lien), le JIT crée toujours un compte nouveau,
|
||||
distinct.
|
||||
"""
|
||||
base = _slug_draco(nom_affiche)
|
||||
if len(base) < 3:
|
||||
base = _base_nom_draco(nom_affiche)
|
||||
if base is None:
|
||||
base = _slug_draco(f"draco-{sub}") or "draco"
|
||||
candidat, n = base, 2
|
||||
while models.get_user_by_username(candidat) is not None:
|
||||
@@ -119,6 +152,43 @@ def _nom_utilisateur_draco(nom_affiche: str, sub: str) -> str:
|
||||
return candidat
|
||||
|
||||
|
||||
def _compte_homonyme(claims: dict | None, sub: str) -> dict | None:
|
||||
"""Compte local portant le nom d'utilisateur de l'identité
|
||||
draco présentée (base dérivée des claims), ou None.
|
||||
|
||||
C'est la clé du rattachement de l'étape 3 de
|
||||
resolve_draco_user et du conflit signalé par
|
||||
draco_conflit_nom : la comparaison porte sur le NOM
|
||||
D'UTILISATEUR local contre le nom que l'émetteur fait porter
|
||||
à l'identité — jamais sur un nom d'une autre forme.
|
||||
"""
|
||||
base = _base_nom_draco(str((claims or {}).get("name") or ""))
|
||||
if base is None:
|
||||
return None
|
||||
return models.get_user_by_username(base)
|
||||
|
||||
|
||||
def draco_conflit_nom(claims: dict | None) -> dict | None:
|
||||
"""Compte local homonyme de l'identité présentée mais lié à
|
||||
un AUTRE sub, ou None.
|
||||
|
||||
Distingue, pour le pont, l'échec « ce nom est déjà le compte
|
||||
d'une autre identité de la suite » (conflit explicite,
|
||||
re-liaison par double preuve) d'un échec ordinaire : la
|
||||
résolution refuse alors tout rattachement et tout clone JIT.
|
||||
"""
|
||||
sub = str((claims or {}).get("sub") or "")
|
||||
if not sub:
|
||||
return None
|
||||
homonyme = _compte_homonyme(claims, sub)
|
||||
if homonyme is None:
|
||||
return None
|
||||
lie = homonyme.get("draco_sub")
|
||||
if lie and lie != sub:
|
||||
return homonyme
|
||||
return None
|
||||
|
||||
|
||||
def provision_draco_user(sub: str, nom_affiche: str = "") -> dict | None:
|
||||
"""Création JIT du compte Kanbante d'une identité draco (HUB-16).
|
||||
|
||||
@@ -163,16 +233,33 @@ def provision_draco_user(sub: str, nom_affiche: str = "") -> dict | None:
|
||||
return models.get_user(user_id)
|
||||
|
||||
|
||||
def resolve_draco_user(claims: dict | None, provisionner: bool = False) -> dict | None:
|
||||
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).
|
||||
/api/search — le rattachement par homonymie, qui ÉCRIT le
|
||||
lien, n'y a pas lieu). provisionner=True : rattachement par
|
||||
homonymie si un compte local sans lien porte le nom de
|
||||
l'identité, sinon 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:
|
||||
@@ -186,12 +273,34 @@ def resolve_draco_user(claims: dict | None, provisionner: bool = False) -> dict
|
||||
seul["role"] == "admin"
|
||||
and seul["active"]
|
||||
and not seul.get("draco_sub")
|
||||
and (role_hub == "administrateur" or liaison_session_native)
|
||||
):
|
||||
# Compte d'amorçage : liaison au premier passage.
|
||||
# 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:
|
||||
# Étape 3 — rattachement par homonymie (0.46.10) : le
|
||||
# compte local qui porte le nom de cette identité et n'a
|
||||
# aucun lien draco EST le compte de cette identité (les
|
||||
# noms centraux sont émis par l'administrateur au Hub,
|
||||
# sans inscription publique). Un homonyme désactivé
|
||||
# résout à None, jamais contourné par un clone. Un
|
||||
# homonyme lié à un autre sub arrête tout : ni
|
||||
# rattachement silencieux, ni clone JIT — le pont
|
||||
# signalera le conflit (draco_conflit_nom) et la
|
||||
# re-liaison passera par la double preuve.
|
||||
homonyme = _compte_homonyme(claims, sub)
|
||||
if homonyme is not None:
|
||||
if homonyme.get("draco_sub"):
|
||||
return None
|
||||
if not homonyme["active"]:
|
||||
return None
|
||||
models.update_user(homonyme["id"], draco_sub=sub)
|
||||
models.log_admin(homonyme["id"], "draco.link.nom", sub)
|
||||
return models.get_user(homonyme["id"])
|
||||
cree = provision_draco_user(sub, str((claims or {}).get("name") or ""))
|
||||
if cree is not None and cree["active"]:
|
||||
return cree
|
||||
|
||||
@@ -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).
|
||||
@@ -317,6 +335,31 @@ class UrlsDraco:
|
||||
agent_url: str # base du service d'agents (panneau + CSP)
|
||||
|
||||
|
||||
def base_retour_navigateur(hote_requete: str | None, repli: str) -> str:
|
||||
"""Base de retour d'un aller-retour SSO **initié par un navigateur**.
|
||||
|
||||
L'hôte public de la requête fait foi quand il suit le motif fermé
|
||||
dracodev (``suffixe_environnement_requete``) : c'est l'origine
|
||||
que le navigateur utilise déjà, donc celle du retour — elle
|
||||
prime sur TOUTE la chaîne de configuration (variable explicite
|
||||
de l'app et dérivation par les adresses de l'agent comprises),
|
||||
qui peut décrire un autre environnement. Constat dev du
|
||||
2026-11-08 : avec les adresses publiques explicites sur les
|
||||
noms officiels, le retour SSO atterrissait sur le nom officiel
|
||||
(la prod n'est pas encore installée) alors que l'app est servie
|
||||
en « -dev ». Hors motif (LAN, IP, domaine propre) : ``repli`` —
|
||||
la chaîne de configuration habituelle, inchangée. Réservé aux
|
||||
retours navigateur ; les contextes sans requête et les appels
|
||||
serveur-à-serveur gardent la résolution par configuration.
|
||||
"""
|
||||
if suffixe_environnement_requete(hote_requete) is not None:
|
||||
hote = (hote_requete or "").strip().lower()
|
||||
if not hote.startswith("["):
|
||||
hote = hote.split(":", 1)[0]
|
||||
return f"https://{hote}"
|
||||
return repli
|
||||
|
||||
|
||||
def resoudre_urls_draco(
|
||||
hote_requete: str | None = None, base: "Settings | None" = None
|
||||
) -> UrlsDraco:
|
||||
@@ -370,6 +413,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 +502,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 +600,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,
|
||||
}
|
||||
|
||||
|
||||
|
||||
@@ -1,153 +0,0 @@
|
||||
"""Réglages généraux — consommation des réglages du Hub (HUB-21).
|
||||
|
||||
Propagation du pilote TikTak 0.61.22 : le Hub expose
|
||||
``GET {hub}/api/reglages/effectifs`` — endpoint **public** (aucun
|
||||
cookie relayé), ``Accept: application/json``, délai 2 s. Réponse
|
||||
200, forme figée (liste fermée D6(a)) : ``{"recherche_partout":
|
||||
bool, "banniere": str, "domaine_defaut": "pro"|"famille"|"perso"
|
||||
|null, "ttl_secondes": 60}``.
|
||||
|
||||
Cache mémoire 60 s, sur le patron du pilote : l'horodatage est
|
||||
posé **avant** l'appel — un échec conserve l'ancien cache et ne
|
||||
déclenche pas de rafale de requêtes vers un Hub en panne. L'URL
|
||||
du Hub est résolue comme celle de la barre commune
|
||||
(``app.config.resoudre_urls_draco`` : variable 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.
|
||||
|
||||
**Repli intégral** : Hub injoignable, en erreur ou réponse de
|
||||
forme inattendue → les **défauts actuels** (``recherche_partout:
|
||||
True``, ``banniere: ""``, ``domaine_defaut: None``), c'est-à-dire
|
||||
le comportement de Kanbante avant HUB-21. Ce module ne lève
|
||||
jamais.
|
||||
|
||||
Consommation chez Kanbante :
|
||||
|
||||
- ``banniere`` : bandeau sous la barre commune (partiel
|
||||
``_header.html``, présent sur toutes les pages applicatives),
|
||||
texte échappé par l'autoescape Jinja ;
|
||||
- ``recherche_partout`` : attribut ``data-recherche-partout`` de
|
||||
la page /recherche — si faux, la partie fédérée est désactivée
|
||||
(la recherche locale Kanbante continue) ;
|
||||
- ``domaine_defaut`` : **non consommé** — Kanbante n'a pas de
|
||||
notion de domaine (Pro/Famille/Perso) propre ; le sélecteur de
|
||||
domaine de la barre commune pilote le panneau Spark, pas les
|
||||
vues de Kanbante. La valeur est lue et validée, sans effet
|
||||
local.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
import threading
|
||||
import time
|
||||
|
||||
import httpx
|
||||
|
||||
from app.config import resoudre_urls_draco
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
#: Réglages par défaut = comportement actuel de Kanbante (repli).
|
||||
DEFAUTS = {"recherche_partout": True, "banniere": "", "domaine_defaut": None}
|
||||
|
||||
#: Domaines reconnus du contrat D6(a).
|
||||
DOMAINES = ("pro", "famille", "perso")
|
||||
|
||||
#: TTL du cache, aligné sur ``ttl_secondes`` annoncé par le Hub.
|
||||
CACHE_TTL = 60.0 # secondes
|
||||
|
||||
_verrou = threading.Lock()
|
||||
_cache: dict | None = None # derniers réglages validés
|
||||
_cache_fetched_at: float = 0.0 # horodatage (monotone) du dernier appel
|
||||
|
||||
|
||||
def _reset_cache() -> None:
|
||||
"""Vide le cache (tests, ou redémarrage de processus)."""
|
||||
global _cache, _cache_fetched_at
|
||||
with _verrou:
|
||||
_cache = None
|
||||
_cache_fetched_at = 0.0
|
||||
|
||||
|
||||
def _valider(donnees) -> dict | None:
|
||||
"""Valide la forme figée du contrat ; ``None`` si inattendue."""
|
||||
if not isinstance(donnees, dict):
|
||||
return None
|
||||
recherche = donnees.get("recherche_partout")
|
||||
banniere = donnees.get("banniere")
|
||||
domaine = donnees.get("domaine_defaut")
|
||||
if not isinstance(recherche, bool):
|
||||
return None
|
||||
if not isinstance(banniere, str):
|
||||
return None
|
||||
if domaine is not None and domaine not in DOMAINES:
|
||||
return None
|
||||
return {
|
||||
"recherche_partout": recherche,
|
||||
"banniere": banniere,
|
||||
"domaine_defaut": domaine,
|
||||
}
|
||||
|
||||
|
||||
def _consulter(hub_url: str) -> dict | None:
|
||||
"""Un appel au Hub ; réglages validés ou ``None`` (repli)."""
|
||||
url = f"{hub_url.rstrip('/')}/api/reglages/effectifs"
|
||||
try:
|
||||
reponse = httpx.get(
|
||||
url, headers={"Accept": "application/json"}, timeout=2.0)
|
||||
except Exception as exc: # Hub injoignable : repli, jamais un blocage
|
||||
logger.debug(
|
||||
"Réglages généraux du Hub injoignables (%s) : %s", url, exc)
|
||||
return None
|
||||
if getattr(reponse, "status_code", None) != 200:
|
||||
logger.debug(
|
||||
"Réglages généraux du Hub en erreur (%s) : statut %s",
|
||||
url, getattr(reponse, "status_code", "?"))
|
||||
return None
|
||||
try:
|
||||
donnees = reponse.json()
|
||||
except Exception:
|
||||
return None
|
||||
return _valider(donnees)
|
||||
|
||||
|
||||
def reglages_effectifs(hote: str | None = None) -> dict:
|
||||
"""Réglages généraux effectifs pour Kanbante.
|
||||
|
||||
Réponse du Hub validée et mise en cache 60 s ; à défaut (Hub
|
||||
muet, en erreur ou forme inattendue), l'ancien cache s'il
|
||||
existe, sinon les défauts actuels. ``hote`` est l'hôte public
|
||||
de la requête, pour résoudre l'URL du Hub comme la barre
|
||||
commune. Ne lève jamais.
|
||||
"""
|
||||
global _cache, _cache_fetched_at
|
||||
now = time.monotonic()
|
||||
with _verrou:
|
||||
if _cache is not None and now - _cache_fetched_at < CACHE_TTL:
|
||||
return dict(_cache)
|
||||
# Horodatage posé AVANT l'appel (patron du pilote) :
|
||||
# l'ancien cache reste en vigueur pendant l'appel.
|
||||
_cache_fetched_at = now
|
||||
hub_url = resoudre_urls_draco(hote).hub_url
|
||||
reglages = _consulter(hub_url)
|
||||
if reglages is None:
|
||||
logger.debug(
|
||||
"Réglages généraux du Hub indisponibles (%s) — "
|
||||
"comportement actuel conservé", hub_url)
|
||||
with _verrou:
|
||||
return dict(_cache) if _cache is not None else dict(DEFAUTS)
|
||||
with _verrou:
|
||||
_cache = reglages
|
||||
_cache_fetched_at = time.monotonic()
|
||||
return dict(reglages)
|
||||
|
||||
|
||||
def banniere(hote: str | None = None) -> str:
|
||||
"""Texte de la bannière d'annonce (``""`` = aucune bannière)."""
|
||||
return reglages_effectifs(hote)["banniere"]
|
||||
|
||||
|
||||
def recherche_partout(hote: str | None = None) -> bool:
|
||||
"""Drapeau de la recherche fédérée (défaut actuel : actif)."""
|
||||
return bool(reglages_effectifs(hote)["recherche_partout"])
|
||||
+52
-7
@@ -23,6 +23,16 @@ jamais d'URL dev figée.
|
||||
illisible → ``None`` (rôle **inconnu**), et l'appelant garde son
|
||||
comportement actuel. Le registre ne crée jamais un verrouillage
|
||||
nouveau.
|
||||
|
||||
Depuis la 0.46.11, la consultation transporte aussi le drapeau
|
||||
``explicite`` de la réponse : le niveau vient-il d'une ligne
|
||||
posée par l'administrateur (``True``), du défaut du registre
|
||||
(``False``), ou la réponse ne le dit-elle pas (``None``) ? Le
|
||||
pont s'en sert pour ne traiter un « aucun » comme un
|
||||
verrouillage que lorsqu'il est explicite ou d'origine inconnue :
|
||||
un « aucun » que le registre présente lui-même comme un défaut
|
||||
n'est pas une décision de l'administrateur et ne doit fermer
|
||||
aucune porte.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
@@ -47,7 +57,7 @@ CACHE_TTL = 60.0 # secondes
|
||||
ROLES_CONNUS = ("aucun", "utilisateur", "administrateur")
|
||||
|
||||
_verrou = threading.Lock()
|
||||
_cache: dict[str, str] = {}
|
||||
_cache: dict[str, tuple[str, bool | None]] = {}
|
||||
_cache_fetched_at: float = 0.0
|
||||
|
||||
|
||||
@@ -59,8 +69,16 @@ def _reset_cache() -> None:
|
||||
_cache_fetched_at = 0.0
|
||||
|
||||
|
||||
def _consulter(hub_url: str, cookie: str) -> str | None:
|
||||
"""Un appel au registre ; rôle connu ou ``None`` (inconnu)."""
|
||||
def _consulter(
|
||||
hub_url: str, cookie: str
|
||||
) -> tuple[str, bool | None] | None:
|
||||
"""Un appel au registre ; ``(rôle, explicite)`` ou ``None``.
|
||||
|
||||
``explicite`` vaut ``True`` si le niveau vient d'une ligne
|
||||
posée par l'administrateur, ``False`` s'il vient du défaut
|
||||
du registre, ``None`` si la réponse ne le dit pas (le Hub
|
||||
actuel l'émet toujours).
|
||||
"""
|
||||
url = f"{hub_url.rstrip('/')}/api/roles/{APP}"
|
||||
try:
|
||||
reponse = httpx.get(
|
||||
@@ -84,15 +102,22 @@ def _consulter(hub_url: str, cookie: str) -> str | None:
|
||||
if not isinstance(donnees, dict):
|
||||
return None
|
||||
role = donnees.get("role")
|
||||
return role if role in ROLES_CONNUS else None
|
||||
if role not in ROLES_CONNUS:
|
||||
return None
|
||||
explicite = donnees.get("explicite")
|
||||
return role, explicite if isinstance(explicite, bool) 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).
|
||||
def _detail_pour(
|
||||
cookie: str, sub: str, hote: str | None = None
|
||||
) -> tuple[str, bool | None] | None:
|
||||
"""``(rôle, explicite)`` connus pour ce ``sub``, ou ``None``.
|
||||
|
||||
``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.
|
||||
pour résoudre l'URL du Hub comme la barre commune. Cache
|
||||
partagé par ``role_pour`` et ``explicite_pour`` : une seule
|
||||
consultation par ``sub`` et par TTL.
|
||||
"""
|
||||
global _cache_fetched_at
|
||||
sub = str(sub or "")
|
||||
@@ -118,3 +143,23 @@ def role_pour(cookie: str, sub: str, hote: str | None = None) -> str | None:
|
||||
hub_url, APP,
|
||||
)
|
||||
return resultat
|
||||
|
||||
|
||||
def role_pour(cookie: str, sub: str, hote: str | None = None) -> str | None:
|
||||
"""Niveau connu pour ce ``sub`` : un rôle ou ``None`` (inconnu)."""
|
||||
detail = _detail_pour(cookie, sub, hote)
|
||||
return detail[0] if detail is not None else None
|
||||
|
||||
|
||||
def explicite_pour(
|
||||
cookie: str, sub: str, hote: str | None = None
|
||||
) -> bool | None:
|
||||
"""Le niveau de ce ``sub`` est-il une décision explicite ?
|
||||
|
||||
``True`` : ligne posée par l'administrateur dans la matrice
|
||||
du Hub. ``False`` : le registre applique son défaut, aucune
|
||||
décision n'existe pour ce compte. ``None`` : inconnu (Hub
|
||||
injoignable ou réponse sans le drapeau).
|
||||
"""
|
||||
detail = _detail_pour(cookie, sub, hote)
|
||||
return detail[1] if detail is not None else None
|
||||
|
||||
+701
-59
@@ -42,7 +42,8 @@ from fastapi.staticfiles import StaticFiles
|
||||
from jinja2 import Environment, FileSystemLoader, select_autoescape
|
||||
from starlette.middleware.base import BaseHTTPMiddleware
|
||||
|
||||
from app.config import APP_VERSION, get_settings, resoudre_urls_draco
|
||||
from app.config import (APP_VERSION, base_retour_navigateur, get_settings,
|
||||
resoudre_urls_draco)
|
||||
from app.gitea_client import GiteaClient
|
||||
from app import code_links as code_links_service
|
||||
from app import digest as digest_service
|
||||
@@ -249,7 +250,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,7 +264,8 @@ def _session_secret() -> bytes:
|
||||
|
||||
|
||||
|
||||
def _make_session(user: str, via_draco: bool = False) -> str:
|
||||
def _make_session(user: str, via_draco: bool = False,
|
||||
via_secours: bool = False) -> str:
|
||||
"""Signed session cookie (0.22.0): user.expiry.hmac.
|
||||
|
||||
HUB-19 (0.46.2) : une session **établie par le pont draco**
|
||||
@@ -272,9 +274,20 @@ def _make_session(user: str, via_draco: bool = False) -> str:
|
||||
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.
|
||||
|
||||
Cohérence d'identité (0.46.7) : une session **établie par la
|
||||
porte de secours** porte de même un segment ``secours``
|
||||
(``user.expiry.secours.hmac``) — c'est lui qui l'exempte du
|
||||
contrôle de cohérence (voir ``_coherence_draco``) : elle vit
|
||||
hors circuit central par construction.
|
||||
"""
|
||||
exp = int(time.time()) + SESSION_DAYS * 86400
|
||||
charge = f"{user}.{exp}.draco" if via_draco else f"{user}.{exp}"
|
||||
if via_draco:
|
||||
charge = f"{user}.{exp}.draco"
|
||||
elif via_secours:
|
||||
charge = f"{user}.{exp}.secours"
|
||||
else:
|
||||
charge = f"{user}.{exp}"
|
||||
sig = hmac.new(
|
||||
_session_secret(), charge.encode("utf-8"), hashlib.sha256
|
||||
).hexdigest()
|
||||
@@ -287,16 +300,31 @@ def _session_info(request: Request) -> tuple[str, bool] | None:
|
||||
Vérifie signature et expiration, dans les deux formats
|
||||
(natif historique et marqué draco de la 0.46.2).
|
||||
"""
|
||||
info = _session_info_complet(request)
|
||||
if info is None:
|
||||
return None
|
||||
return info[0], info[1]
|
||||
|
||||
|
||||
def _session_info_complet(request: Request) -> tuple[str, bool, bool] | None:
|
||||
"""(utilisateur, établie par draco, établie par secours), ou None.
|
||||
|
||||
Les segments marqueurs (``draco`` 0.46.2, ``secours`` 0.46.7)
|
||||
sont couverts par la signature ; la position est relative à la
|
||||
fin (l'expiration, numérique, ne peut pas les imiter).
|
||||
"""
|
||||
raw = request.cookies.get(SESSION_COOKIE, "")
|
||||
morceaux = raw.split(".")
|
||||
if len(morceaux) < 3:
|
||||
return None
|
||||
sig = morceaux[-1]
|
||||
via_draco = len(morceaux) >= 4 and morceaux[-2] == "draco"
|
||||
if via_draco:
|
||||
marqueur = morceaux[-2] if len(morceaux) >= 4 else ""
|
||||
via_draco = marqueur == "draco"
|
||||
via_secours = marqueur == "secours"
|
||||
if via_draco or via_secours:
|
||||
exp = morceaux[-3]
|
||||
user = ".".join(morceaux[:-3])
|
||||
charge = f"{user}.{exp}.draco"
|
||||
charge = f"{user}.{exp}.{marqueur}"
|
||||
else:
|
||||
exp = morceaux[-2]
|
||||
user = ".".join(morceaux[:-2])
|
||||
@@ -313,7 +341,7 @@ def _session_info(request: Request) -> tuple[str, bool] | None:
|
||||
return None
|
||||
except ValueError:
|
||||
return None
|
||||
return user, via_draco
|
||||
return user, via_draco, via_secours
|
||||
|
||||
|
||||
def _session_user(request: Request) -> str | None:
|
||||
@@ -338,6 +366,12 @@ def _session_via_draco(request: Request) -> bool:
|
||||
return bool(info and info[1] and _session_user(request) is not None)
|
||||
|
||||
|
||||
def _session_via_secours(request: Request) -> bool:
|
||||
"""Vrai si la session présentée a été établie par la porte de secours."""
|
||||
info = _session_info_complet(request)
|
||||
return bool(info and info[2] and _session_user(request) is not None)
|
||||
|
||||
|
||||
def _basic_ok(request: Request) -> bool:
|
||||
settings = get_settings()
|
||||
header = request.headers.get("authorization", "")
|
||||
@@ -393,6 +427,95 @@ def _current_user(request: Request) -> dict | None:
|
||||
return None
|
||||
|
||||
|
||||
def _coherence_draco(request: Request, session_user: str) -> Response | None:
|
||||
"""Cohérence d'identité au changement de compte (0.46.7).
|
||||
|
||||
Cas réel : connecté « fred » chez ObsiGate, l'utilisateur ouvre
|
||||
Kanbante et y trouve son propre compte — la session locale
|
||||
préexistante gouvernait sans reconsulter l'identité centrale.
|
||||
Quand la requête porte AUSSI un cookie ``draco_session``
|
||||
**valide** (``app.draco.claims_for`` : signature, expiration,
|
||||
révocation) dont le ``sub`` diffère du sub lié au compte de la
|
||||
session, la session locale est invalidée — Kanbante n'a pas de
|
||||
session serveur : supprimer le cookie de la réponse suffit —
|
||||
et le navigateur repasse par le pont ``/auth/draco`` (JIT si
|
||||
besoin) ; les appels API reçoivent un 401 avec le même
|
||||
effacement, aucune écriture n'est attribuée au mauvais compte.
|
||||
|
||||
Gardes : aucun cookie ou cookie invalide/expiré/révoqué → None
|
||||
(on ne touche à rien) ; session de la porte de secours
|
||||
(marqueur signé ``secours``) → exemptée ; compte local sans
|
||||
aucun lien draco → l'identité centrale présente gagne (le pont
|
||||
s'applique, choix documenté) ; cookie que le pont ne peut pas
|
||||
servir (rôle « aucun » au registre, compte désactivé, aucune
|
||||
résolution) → session gardée : la détruire exclurait son
|
||||
titulaire en boucle, le cookie refusé restant présent. Les
|
||||
contrats navigateur inter-apps ``/api/search`` et
|
||||
``/api/events`` gardent leurs sémantiques propres et sont
|
||||
exemptés. Après alignement, le compte servi est celui du
|
||||
cookie : pas de boucle.
|
||||
"""
|
||||
path = request.url.path
|
||||
if path in ("/api/search", "/api/events"):
|
||||
return None
|
||||
# Re-liaison par double preuve (0.46.10) : la page et son
|
||||
# geste POST sont EXEMPTÉS de l'alignement — les aligner
|
||||
# détruirait la session native (l'une des deux preuves) au
|
||||
# profit du détenteur actuel du sub, précisément le compte
|
||||
# que la re-liaison peut devoir délier. Les handlers de
|
||||
# /auth/draco/relier revérifient eux-mêmes les deux preuves
|
||||
# à l'instant du geste ; l'exemption ne sert aucune donnée
|
||||
# et tout autre chemin reste aligné comme avant.
|
||||
if path == "/auth/draco/relier":
|
||||
return None
|
||||
if _session_via_secours(request):
|
||||
return None
|
||||
try:
|
||||
from app import accounts as accounts_service
|
||||
from app import draco
|
||||
from app import hub_roles
|
||||
|
||||
claims = draco.claims_for(request)
|
||||
if claims is None:
|
||||
return None
|
||||
sub = str(claims.get("sub") or "")
|
||||
row = models.get_user_by_username(session_user)
|
||||
sub_lie = row["draco_sub"] if row is not None else None
|
||||
if sub_lie and sub_lie == sub:
|
||||
return None
|
||||
role = hub_roles.role_pour(
|
||||
request.headers.get("cookie", ""), sub,
|
||||
hote=request.headers.get("host"),
|
||||
)
|
||||
if role == "aucun":
|
||||
return None
|
||||
candidat = accounts_service.resolve_draco_user(
|
||||
claims, provisionner=True, role_hub=role)
|
||||
if candidat is None:
|
||||
return None
|
||||
if row is not None and candidat["id"] == row["id"]:
|
||||
return None # le pont résout déjà vers ce compte
|
||||
if row is None and candidat["username"] == session_user:
|
||||
return None # opérateur d'environnement résolu tel quel
|
||||
except Exception:
|
||||
return None
|
||||
if path.startswith("/api/") or path.startswith("/mcp"):
|
||||
response: Response = JSONResponse(
|
||||
{"ok": False,
|
||||
"error": "Session alignée sur l'identité de la suite — "
|
||||
"reconnectez-vous."},
|
||||
status_code=401,
|
||||
)
|
||||
else:
|
||||
target = path
|
||||
if request.url.query:
|
||||
target = f"{path}?{request.url.query}"
|
||||
response = RedirectResponse(
|
||||
f"/auth/draco?next={quote(target, safe='')}", status_code=303)
|
||||
response.delete_cookie(SESSION_COOKIE)
|
||||
return response
|
||||
|
||||
|
||||
class AuthMiddleware(BaseHTTPMiddleware):
|
||||
"""Session cookie (browser) or Basic header (scripts)."""
|
||||
|
||||
@@ -422,6 +545,14 @@ class AuthMiddleware(BaseHTTPMiddleware):
|
||||
row = models.get_user_by_username(session_user)
|
||||
if row is not None and not row["active"]:
|
||||
session_user = None # disabled account: session is dead
|
||||
# Cohérence d'identité (0.46.7) : une session locale qui
|
||||
# contredit un cookie draco valide est alignée sur le
|
||||
# cookie avant de servir quoi que ce soit. L'authentification
|
||||
# Basic (scripts) n'est pas une session : hors contrôle.
|
||||
if session_user is not None and not _basic_ok(request):
|
||||
reponse = _coherence_draco(request, session_user)
|
||||
if reponse is not None:
|
||||
return reponse
|
||||
if session_user is not None or _basic_ok(request):
|
||||
return await call_next(request)
|
||||
# Jetons d'API (0.25.0) : surfaces machine seulement — un jeton
|
||||
@@ -432,8 +563,8 @@ class AuthMiddleware(BaseHTTPMiddleware):
|
||||
# Recherche partout (#68) : /api/search accepte aussi le jeton
|
||||
# SSO draco_session — depuis la 0.46.0 (HUB-16), par
|
||||
# utilisateur : le sub doit désigner un compte Kanbante
|
||||
# (correspondance existante ou compte d'amorçage lié au
|
||||
# passage, voir app.accounts.resolve_draco_user) ; un jeton
|
||||
# (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.
|
||||
@@ -451,6 +582,44 @@ class AuthMiddleware(BaseHTTPMiddleware):
|
||||
return await call_next(request)
|
||||
except Exception:
|
||||
pass
|
||||
# Entrée automatique par le pont (0.46.8, chantier
|
||||
# « entrée SSO de bout en bout ») : une PAGE demandée sans
|
||||
# session locale mais avec un cookie draco VALIDE ne doit
|
||||
# pas aboutir au formulaire comme si la session de la
|
||||
# suite n'existait pas — le navigateur est renvoyé au pont
|
||||
# /auth/draco, qui ouvre (ou crée, JIT) la session du
|
||||
# compte désigné par le cookie et revient à la cible. Les
|
||||
# gardes du pont s'appliquent telles quelles : rôle
|
||||
# « aucun » au registre → sa page 403 ; échec de résolution
|
||||
# → retour au formulaire avec draco=echec (le /login est
|
||||
# public, jamais réintercepté : pas de boucle). Sans
|
||||
# cookie valide — ou si draco est inerte — le comportement
|
||||
# historique est inchangé (formulaire, pages publiques).
|
||||
# Symétrique du contrôle de cohérence de la 0.46.7, qui
|
||||
# couvre le cas inverse (session locale d'un AUTRE compte).
|
||||
# 0.46.11 : un cookie draco PRÉSENT mais inutilisable
|
||||
# (illisible, ou service inerte) n'aboutit plus au
|
||||
# formulaire muet — la redirection finale ci-dessous
|
||||
# porte draco=invalide / draco=inactif, comme le pont.
|
||||
draco_echec = None
|
||||
if not path.startswith("/api/") and not path.startswith("/mcp") \
|
||||
and "text/html" in request.headers.get("accept", ""):
|
||||
try:
|
||||
from app import draco as _draco
|
||||
|
||||
if _draco.claims_for(request) is not None:
|
||||
target = path
|
||||
if request.url.query:
|
||||
target = f"{path}?{request.url.query}"
|
||||
return RedirectResponse(
|
||||
f"/auth/draco?next={quote(target, safe='')}",
|
||||
status_code=303,
|
||||
)
|
||||
if request.cookies.get(_draco.COOKIE_NAME):
|
||||
draco_echec = (
|
||||
"invalide" if _draco.enabled() else "inactif")
|
||||
except Exception:
|
||||
pass
|
||||
# API consumers get a plain 401 (no browser prompt, no
|
||||
# redirect they cannot follow); browsers get the login page.
|
||||
if path.startswith("/api/") or "text/html" not in request.headers.get(
|
||||
@@ -463,6 +632,12 @@ class AuthMiddleware(BaseHTTPMiddleware):
|
||||
target = path
|
||||
if request.url.query:
|
||||
target = f"{path}?{request.url.query}"
|
||||
if draco_echec:
|
||||
return RedirectResponse(
|
||||
f"/login?next={quote(target, safe='')}"
|
||||
f"&draco={draco_echec}",
|
||||
status_code=303,
|
||||
)
|
||||
return RedirectResponse(f"/login?next={quote(target, safe='')}", status_code=303)
|
||||
|
||||
|
||||
@@ -536,11 +711,102 @@ def _safe_next(raw: str) -> str:
|
||||
return "/"
|
||||
|
||||
|
||||
def _ouvrir_session(username: str, next: str,
|
||||
secours: bool = False) -> RedirectResponse:
|
||||
"""Réponse de connexion native : session signée posée, redirection.
|
||||
|
||||
``secours=True`` (0.46.7) marque la session de la porte de
|
||||
secours : elle est exemptée du contrôle de cohérence
|
||||
d'identité (voir ``_coherence_draco``).
|
||||
"""
|
||||
response = RedirectResponse(_safe_next(next), status_code=303)
|
||||
response.set_cookie(
|
||||
SESSION_COOKIE,
|
||||
_make_session(username, via_secours=secours),
|
||||
max_age=SESSION_DAYS * 86400,
|
||||
httponly=True,
|
||||
samesite="lax",
|
||||
)
|
||||
return response
|
||||
|
||||
|
||||
@app.get("/login")
|
||||
async def login_page(request: Request, next: str = "/"):
|
||||
async def login_page(request: Request, next: str = "/", draco: 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).
|
||||
# Échec du pont (0.46.8) : draco=echec posé par /auth/draco
|
||||
# quand la résolution du compte a échoué — le formulaire
|
||||
# l'explique au lieu d'un retour muet. Depuis la 0.46.11,
|
||||
# chaque sortie d'échec de la chaîne est nommée : conflit,
|
||||
# invalide, absent, inactif (voir les branches ci-dessous).
|
||||
erreur = ""
|
||||
if draco == "echec":
|
||||
erreur = (
|
||||
"La connexion par la suite (ObsiGate) n'a pas abouti "
|
||||
"pour ce compte. Utilisez le formulaire ci-dessous, ou "
|
||||
"réessayez le bouton de connexion ObsiGate."
|
||||
)
|
||||
elif draco == "conflit":
|
||||
# Conflit de nom (0.46.10) : le compte local homonyme de
|
||||
# l'identité présentée est lié à un AUTRE sub — aucun
|
||||
# rattachement silencieux, aucun clone. La sortie est la
|
||||
# double preuve : connexion locale par mot de passe,
|
||||
# puis proposition de re-liaison (voir draco_relier).
|
||||
erreur = (
|
||||
"Un compte Kanbante porte le même nom que votre "
|
||||
"compte de la suite, mais il est relié à une autre "
|
||||
"identité : la connexion automatique est refusée "
|
||||
"pour protéger ce compte. Connectez-vous ci-dessous "
|
||||
"avec le mot de passe local de ce compte — la "
|
||||
"re-liaison à votre identité actuelle vous sera "
|
||||
"proposée."
|
||||
)
|
||||
elif draco == "invalide":
|
||||
# Jeton présent mais illisible pour CE service
|
||||
# (0.46.10) : signature, expiration ou révocation — à
|
||||
# distinguer d'une absence de session centrale
|
||||
# (draco=absent) et d'un pont non configuré
|
||||
# (draco=inactif), distingués depuis la 0.46.11.
|
||||
erreur = (
|
||||
"Le jeton de la suite présenté à Kanbante n'a pas "
|
||||
"pu être validé (expiré, révoqué ou illisible pour "
|
||||
"ce service). Reconnectez-vous chez ObsiGate, puis "
|
||||
"réessayez. Si ce message persiste, l'administrateur "
|
||||
"doit vérifier la configuration du service (secret "
|
||||
"partagé de la suite)."
|
||||
)
|
||||
elif draco == "absent":
|
||||
# Aucune session centrale présentée au pont (0.46.11) :
|
||||
# le parcours SSO est arrivé sans cookie draco — session
|
||||
# de la suite absente ou cookie non transmis.
|
||||
erreur = (
|
||||
"Aucune session de la suite n'a été présentée à "
|
||||
"Kanbante : la connexion par ObsiGate n'a reçu "
|
||||
"aucune identité à valider. Connectez-vous d'abord "
|
||||
"chez ObsiGate, puis réessayez le bouton — ou "
|
||||
"utilisez le formulaire ci-dessous."
|
||||
)
|
||||
elif draco == "inactif":
|
||||
# Pont draco non configuré sur CE service (0.46.11) :
|
||||
# aucun secret partagé dans la configuration du
|
||||
# conteneur — le pont ne peut valider aucune session
|
||||
# centrale, quel que soit le compte. Défaut de
|
||||
# configuration, pas une faute de l'utilisateur.
|
||||
erreur = (
|
||||
"La connexion par la suite (ObsiGate) n'est pas "
|
||||
"active sur ce service : Kanbante ne peut valider "
|
||||
"aucune session centrale (configuration du service "
|
||||
"incomplète). Utilisez le formulaire ci-dessous ; "
|
||||
"l'administrateur doit vérifier le secret partagé "
|
||||
"de la suite dans la configuration du service."
|
||||
)
|
||||
return render(
|
||||
request, "login.html", next=_safe_next(next), error=erreur,
|
||||
porte_centrale=bool(get_settings().porte_centrale),
|
||||
)
|
||||
|
||||
|
||||
@app.post("/login")
|
||||
@@ -559,6 +825,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)
|
||||
@@ -576,9 +861,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(
|
||||
@@ -587,8 +896,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)
|
||||
@@ -596,15 +907,104 @@ 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",
|
||||
# Double preuve (0.46.10) : le mot de passe local vient
|
||||
# d'être prouvé, et un cookie draco valide est présent
|
||||
# dont l'identité ne désigne pas ce compte (ce compte
|
||||
# est lié à un autre sub, ou ce sub est détenu par un
|
||||
# autre compte) — au lieu de laisser les deux identités
|
||||
# se contredire en silence, la session s'ouvre sur la
|
||||
# proposition de re-liaison (voir draco_relier).
|
||||
if _draco_desalignement(request, models.get_user(user["id"])) \
|
||||
is not None:
|
||||
return _ouvrir_session(
|
||||
username,
|
||||
"/auth/draco/relier?next="
|
||||
+ quote(_safe_next(next), safe=""),
|
||||
)
|
||||
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)
|
||||
# Session marquée « secours » (0.46.7) : exemptée du contrôle
|
||||
# de cohérence d'identité, elle vit hors circuit central.
|
||||
return _ouvrir_session(settings.porte_secours_user, next, secours=True)
|
||||
|
||||
|
||||
@app.get("/logout")
|
||||
@@ -614,6 +1014,107 @@ async def logout():
|
||||
return response
|
||||
|
||||
|
||||
def _draco_desalignement(request: Request, current: dict | None):
|
||||
"""Désalignement entre session native et identité draco.
|
||||
|
||||
Retourne ``(claims, détenteur)`` quand le navigateur porte
|
||||
À LA FOIS une session native (compte ``current``, authentifié
|
||||
par mot de passe) et un cookie draco **valide** dont le
|
||||
``sub`` ne désigne pas ce compte : soit ce compte est lié à
|
||||
un autre sub, soit ce sub est détenu par un autre compte
|
||||
(``détenteur``, éventuellement None dans le premier cas).
|
||||
Retourne None si les deux identités concordent, si le sub
|
||||
est libre et ce compte sans lien (la liaison silencieuse
|
||||
historique s'en charge), ou si l'une des deux preuves est
|
||||
absente. C'est l'état que la re-liaison par double preuve
|
||||
(``/auth/draco/relier``) propose de résoudre.
|
||||
"""
|
||||
if current is None or current.get("id") is None:
|
||||
return None
|
||||
from app import draco
|
||||
|
||||
claims = draco.claims_for(request)
|
||||
if claims is None:
|
||||
return None
|
||||
sub = str(claims.get("sub") or "")
|
||||
if not sub or current.get("draco_sub") == sub:
|
||||
return None
|
||||
detenteur = models.get_user_by_draco(sub)
|
||||
if current.get("draco_sub") or detenteur is not None:
|
||||
return claims, detenteur
|
||||
return None
|
||||
|
||||
|
||||
@app.get("/auth/draco/relier")
|
||||
async def draco_relier_page(request: Request, next: str = "/"):
|
||||
"""Proposition de re-liaison par double preuve (0.46.10).
|
||||
|
||||
Cas réel : le compte local « bruno » (mot de passe connu de
|
||||
son propriétaire) est lié à un ancien sub, pendant que le
|
||||
navigateur présente le sub actuel du même propriétaire —
|
||||
le pont refuse le rattachement silencieux (le nom seul ne
|
||||
prouve pas la propriété du compte local) et le JIT ne doit
|
||||
pas créer un clone. La double preuve tranche : la session
|
||||
native prouve le mot de passe local, le cookie draco valide
|
||||
prouve l'identité centrale ; réunies dans le même navigateur,
|
||||
elles autorisent la réécriture du lien, proposée ici de
|
||||
façon explicite — jamais appliquée sans ce geste.
|
||||
"""
|
||||
current = _current_user(request)
|
||||
if current is None or current.get("id") is None:
|
||||
# Sans la session native (une des deux preuves), rien à
|
||||
# proposer : retour au formulaire AVEC la raison
|
||||
# (0.46.11 — aucune redirection nue dans la chaîne).
|
||||
return RedirectResponse("/login?draco=echec", status_code=303)
|
||||
desalign = _draco_desalignement(request, current)
|
||||
if desalign is None:
|
||||
return RedirectResponse(_safe_next(next), status_code=303)
|
||||
claims, detenteur = desalign
|
||||
return render(
|
||||
request, "draco_relier.html", next=_safe_next(next),
|
||||
compte_local=current["username"],
|
||||
nom_draco=str(claims.get("name") or ""),
|
||||
detenteur=(detenteur or {}).get("username"),
|
||||
)
|
||||
|
||||
|
||||
@app.post("/auth/draco/relier")
|
||||
async def draco_relier_submit(
|
||||
request: Request,
|
||||
next: str = Form("/"),
|
||||
csrf_token: str = Form(""),
|
||||
):
|
||||
"""Re-liaison effective : réécrit users.draco_sub.
|
||||
|
||||
Les deux preuves sont revérifiées à l'instant du geste
|
||||
(session native + cookie draco valide + CSRF) : le sub est
|
||||
retiré à son détenteur actuel, s'il y en a un, et posé sur
|
||||
le compte de la session. Les deux gestes sont journalisés
|
||||
(draco.relink.retrait / draco.relink). Le compte délié
|
||||
garde son mot de passe local : il reste accessible par le
|
||||
formulaire, simplement plus désigné par la suite.
|
||||
"""
|
||||
current = _current_user(request)
|
||||
if current is None or current.get("id") is None:
|
||||
return RedirectResponse("/login?draco=echec", status_code=303)
|
||||
if not _csrf_valid(request, csrf_token):
|
||||
return render(
|
||||
request, "error.html", status_code=403,
|
||||
message="Session expirée — réessaie.",
|
||||
)
|
||||
desalign = _draco_desalignement(request, current)
|
||||
if desalign is None:
|
||||
return RedirectResponse(_safe_next(next), status_code=303)
|
||||
claims, detenteur = desalign
|
||||
sub = str(claims.get("sub") or "")
|
||||
if detenteur is not None and detenteur["id"] != current["id"]:
|
||||
models.update_user(detenteur["id"], draco_sub=None)
|
||||
models.log_admin(detenteur["id"], "draco.relink.retrait", sub)
|
||||
models.update_user(current["id"], draco_sub=sub)
|
||||
models.log_admin(current["id"], "draco.relink", sub)
|
||||
return RedirectResponse(_safe_next(next), status_code=303)
|
||||
|
||||
|
||||
@app.get("/auth/draco")
|
||||
def draco_bridge(request: Request, next: str = "/"):
|
||||
"""Fusion ACC-3.2 — pont SSO : cookie ``draco_session`` → session.
|
||||
@@ -624,11 +1125,36 @@ def draco_bridge(request: Request, next: str = "/"):
|
||||
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é) ;
|
||||
ce compte (première visite doublement connectée, inchangé) —
|
||||
c'est la voie (b) de la liaison explicite de l'amorçage ;
|
||||
si les deux identités se contredisent (ce compte lié à un
|
||||
autre sub, ou ce sub détenu par un autre compte), la
|
||||
re-liaison par double preuve est proposée
|
||||
(``/auth/draco/relier``, 0.46.10) ;
|
||||
- ``sub`` lié à un compte : sa session est ouverte ;
|
||||
- ``sub`` inconnu mais compte local HOMONYME sans lien :
|
||||
rattachement et session de CE compte (0.46.10, voir
|
||||
app.accounts) ; homonyme lié à un autre sub : refus
|
||||
explicite ``/login?draco=conflit``, aucun clone créé ;
|
||||
- jeton présent mais illisible pour ce service : refus
|
||||
explicite ``/login?draco=invalide`` (0.46.10) ;
|
||||
- depuis la 0.46.11, AUCUNE sortie du pont n'est nue :
|
||||
jeton absent → ``/login?draco=absent`` (le parcours SSO
|
||||
n'a présenté aucune identité à valider) et service draco
|
||||
inerte (aucun secret configuré) avec un cookie présenté
|
||||
→ ``/login?draco=inactif`` (le pont ne peut rien valider
|
||||
sur ce service : défaut de configuration, pas de
|
||||
l'utilisateur). Cas réel : le conteneur kanbante-dev
|
||||
avait perdu ``DRACO_SESSION_SECRET`` — le bouton SSO,
|
||||
rendu quand même, ramenait le propriétaire légitime au
|
||||
formulaire nu, sans session ni message, pendant que
|
||||
ShaarIt et TikTak lisaient son cookie ;
|
||||
- compte d'amorçage (unique compte, admin, sans liaison) :
|
||||
liaison au premier passage, puis sa session — le compte
|
||||
existant de l'opérateur garde son accès ;
|
||||
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.
|
||||
@@ -647,6 +1173,15 @@ def draco_bridge(request: Request, next: str = "/"):
|
||||
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_``.
|
||||
|
||||
0.46.11 : le refus sur « aucun » n'a lieu que si ce niveau
|
||||
est une décision — ``explicite`` vrai dans la réponse du
|
||||
registre, ou d'origine inconnue (réponse sans le drapeau :
|
||||
comportement historique conservé). Un « aucun » que le
|
||||
registre présente lui-même comme son défaut
|
||||
(``explicite: false``) n'a jamais été décidé par
|
||||
l'administrateur : il ne verrouille pas l'entrée (le
|
||||
registre ne crée jamais un verrouillage nouveau).
|
||||
"""
|
||||
from app import accounts as accounts_service
|
||||
from app import draco
|
||||
@@ -654,19 +1189,59 @@ def draco_bridge(request: Request, next: str = "/"):
|
||||
|
||||
settings = get_settings()
|
||||
claims = draco.claims_for(request)
|
||||
if not settings.auth_enabled or claims is None:
|
||||
return RedirectResponse("/login", status_code=303)
|
||||
if not settings.auth_enabled:
|
||||
# Aucune authentification sur cette instance : il n'y a
|
||||
# pas d'échec SSO à signaler — la cible directement (la
|
||||
# page /login redirigerait elle-même vers elle).
|
||||
return RedirectResponse(_safe_next(next), status_code=303)
|
||||
if claims is None:
|
||||
# Aucune sortie nue (0.46.11) : chaque échec du parcours
|
||||
# central est nommé au formulaire, qui l'explique.
|
||||
# — Jeton PRÉSENT mais illisible pour ce service
|
||||
# (signature, expiration, révocation — 0.46.10) :
|
||||
# draco=invalide, jamais silencieux — c'est le symptôme
|
||||
# « le bouton SSO me ramène au formulaire » du
|
||||
# propriétaire légitime quand le secret partagé du
|
||||
# conteneur diverge de l'émettrice.
|
||||
# — Cookie PRÉSENT mais service draco INERTE (aucun
|
||||
# secret configuré dans CE conteneur) : draco=inactif —
|
||||
# le pont ne peut valider aucune identité, c'est un
|
||||
# défaut de configuration du service, pas de
|
||||
# l'utilisateur (cas réel kanbante-dev, 2026-11-16).
|
||||
# — Jeton ABSENT : draco=absent — le parcours SSO n'a
|
||||
# présenté aucune session de la suite à valider.
|
||||
cible = f"/login?next={quote(_safe_next(next), safe='')}"
|
||||
if request.cookies.get(draco.COOKIE_NAME):
|
||||
if draco.enabled():
|
||||
return RedirectResponse(
|
||||
cible + "&draco=invalide", status_code=303)
|
||||
return RedirectResponse(
|
||||
cible + "&draco=inactif", status_code=303)
|
||||
return RedirectResponse(cible + "&draco=absent", status_code=303)
|
||||
sub = str(claims.get("sub") or "")
|
||||
if not sub:
|
||||
return RedirectResponse("/login", status_code=303)
|
||||
return RedirectResponse(
|
||||
f"/login?next={quote(_safe_next(next), safe='')}"
|
||||
"&draco=invalide",
|
||||
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).
|
||||
# un sub refusé ne doit jamais en recevoir un). Le refus sur
|
||||
# « aucun » exige une décision : niveau explicite dans la
|
||||
# matrice, ou drapeau inconnu (réponse sans « explicite » —
|
||||
# comportement historique). Un « aucun » que le registre
|
||||
# donne comme son défaut (explicite faux) ne verrouille pas
|
||||
# (0.46.11) : l'administrateur n'a rien décidé pour ce
|
||||
# compte, l'entrée ordinaire suit.
|
||||
role_hub = hub_roles.role_pour(
|
||||
request.headers.get("cookie", ""), sub,
|
||||
hote=request.headers.get("host"),
|
||||
)
|
||||
if role_hub == "aucun":
|
||||
if role_hub == "aucun" and hub_roles.explicite_pour(
|
||||
request.headers.get("cookie", ""), sub,
|
||||
hote=request.headers.get("host"),
|
||||
) is not False:
|
||||
return render(
|
||||
request, "error.html", status_code=403,
|
||||
message=(
|
||||
@@ -682,19 +1257,44 @@ def draco_bridge(request: Request, next: str = "/"):
|
||||
),
|
||||
)
|
||||
# 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 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", sub)
|
||||
# Désalignement restant (0.46.10) : ce compte est lié à
|
||||
# un autre sub, ou ce sub est détenu par un autre compte
|
||||
# — la session native (mot de passe prouvé) + le cookie
|
||||
# (identité prouvée) réunissent la double preuve : la
|
||||
# re-liaison est proposée, jamais appliquée ici.
|
||||
if _draco_desalignement(
|
||||
request, models.get_user(current["id"])
|
||||
) is not None:
|
||||
return RedirectResponse(
|
||||
"/auth/draco/relier?next="
|
||||
+ quote(_safe_next(next), safe=""),
|
||||
status_code=303,
|
||||
)
|
||||
return RedirectResponse(_safe_next(next), status_code=303)
|
||||
# Correspondance, amorçage ou création JIT : ouvrir la
|
||||
# session du compte que ce sub désigne — et seulement lui.
|
||||
# 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)
|
||||
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(
|
||||
@@ -705,7 +1305,26 @@ def draco_bridge(request: Request, next: str = "/"):
|
||||
samesite="lax",
|
||||
)
|
||||
return response
|
||||
return RedirectResponse("/login", status_code=303)
|
||||
# Conflit de nom (0.46.10) : l'homonyme local de cette
|
||||
# identité est lié à un autre sub — la résolution a refusé
|
||||
# tout rattachement et tout clone ; le formulaire explique
|
||||
# et la sortie est la double preuve (connexion locale puis
|
||||
# proposition de re-liaison).
|
||||
if accounts_service.draco_conflit_nom(claims) is not None:
|
||||
return RedirectResponse(
|
||||
f"/login?next={quote(_safe_next(next), safe='')}"
|
||||
"&draco=conflit",
|
||||
status_code=303,
|
||||
)
|
||||
# Échec de résolution (0.46.8) : retour au formulaire AVEC la
|
||||
# raison (paramètre draco=echec, traduit en message par
|
||||
# login_page) — jamais un échec silencieux, et le formulaire
|
||||
# reste le point d'arrivée (il est public : l'entrée
|
||||
# automatique du middleware ne peut pas boucler dessus).
|
||||
return RedirectResponse(
|
||||
f"/login?next={quote(_safe_next(next), safe='')}&draco=echec",
|
||||
status_code=303,
|
||||
)
|
||||
|
||||
|
||||
# ── Archives de projets (0.24.0, P4) ──────────────────────
|
||||
@@ -2048,11 +2667,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
|
||||
@@ -2401,35 +3027,51 @@ def render(
|
||||
},
|
||||
)
|
||||
context.setdefault("agent_url", _urls.agent_url)
|
||||
# Réglages généraux du Hub (HUB-21) : bannière d'annonce du
|
||||
# partiel _header.html et drapeau de la recherche fédérée de la
|
||||
# page /recherche. Client à cache 60 s et repli intégral
|
||||
# (app.hub_reglages) : Hub muet = bannière vide et fédération
|
||||
# active, c'est-à-dire le comportement actuel.
|
||||
from app import hub_reglages as _hub_reglages
|
||||
|
||||
_hote = request.headers.get("host")
|
||||
context.setdefault("banniere_hub", _hub_reglages.banniere(_hote))
|
||||
context.setdefault(
|
||||
"recherche_partout_hub", _hub_reglages.recherche_partout(_hote))
|
||||
# Aller-retour SSO initié par un navigateur : l'adresse de
|
||||
# retour est l'hôte public de la requête quand il suit le motif
|
||||
# fermé dracodev (base_retour_navigateur) — jamais une adresse
|
||||
# de configuration, qui peut décrire un autre environnement
|
||||
# (constat dev du 2026-11-08 : retour sur le nom officiel alors
|
||||
# que l'app est servie en « -dev »). L'émettrice et les autres
|
||||
# URL du contexte restent résolues par la chaîne habituelle.
|
||||
_hote_requete = request.headers.get("host")
|
||||
context.setdefault(
|
||||
"sso_authorize_url",
|
||||
f"{_urls.sso_url}/sso/authorize?return_to="
|
||||
f"{quote(_urls.public_url + '/auth/draco', safe='')}",
|
||||
f"{quote(base_retour_navigateur(_hote_requete, _urls.public_url) + '/auth/draco', safe='')}",
|
||||
)
|
||||
# Fusion ACC-1 : initiale de l'opérateur pour la barre d'apps commune.
|
||||
context.setdefault(
|
||||
"draco_avatar", (get_settings().auth_user or "K")[:1].upper()
|
||||
)
|
||||
context.setdefault("active_nav", _NAV_BY_TEMPLATE.get(name, ""))
|
||||
context.setdefault("auth_enabled", get_settings().auth_enabled)
|
||||
context.setdefault("data_freshness", snapshots_service.freshness_label())
|
||||
# 0.24.0 (P2/P3) : utilisateur courant, espaces, sélecteur.
|
||||
try:
|
||||
_cu = _current_user(request)
|
||||
except Exception:
|
||||
_cu = None
|
||||
context.setdefault("current_user", _cu)
|
||||
# Barre d'apps commune : l'identité affichée est celle de la
|
||||
# SESSION (0.46.8, chantier « entrée SSO ») — nom complet pour
|
||||
# l'en-tête du menu compte, initiale pour l'avatar. La Fusion
|
||||
# ACC-1 posait l'initiale de l'OPÉRATEUR d'environnement
|
||||
# (auth_user) pour tout le monde : un membre entré par le pont
|
||||
# voyait « P » (opérateur) au lieu de son nom, alors que
|
||||
# l'application le connaissait (barre latérale). Le repli
|
||||
# opérateur ne vaut que sans utilisateur de session (pages
|
||||
# publiques / erreur avant authentification).
|
||||
_nom_session = None
|
||||
if _cu:
|
||||
_nom_session = (
|
||||
(_cu.get("display_name") or _cu.get("username") or "").strip()
|
||||
or None
|
||||
)
|
||||
if _nom_session:
|
||||
context.setdefault("draco_avatar", _nom_session[:1].upper())
|
||||
context.setdefault("draco_user", _nom_session)
|
||||
else:
|
||||
context.setdefault(
|
||||
"draco_avatar", (get_settings().auth_user or "K")[:1].upper()
|
||||
)
|
||||
context.setdefault("draco_user", None)
|
||||
context.setdefault("active_nav", _NAV_BY_TEMPLATE.get(name, ""))
|
||||
context.setdefault("auth_enabled", get_settings().auth_enabled)
|
||||
context.setdefault("data_freshness", snapshots_service.freshness_label())
|
||||
context.setdefault("is_admin", bool(_cu and _cu.get("role") == "admin"))
|
||||
try:
|
||||
_ws, _ws_role = _current_workspace(request)
|
||||
|
||||
@@ -123,15 +123,26 @@
|
||||
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
|
||||
("Opérateur Kanbante" → "O"), qui est un libellé de rôle et
|
||||
non un nom. Contrepartie documentée : syncAvatar() réécrit
|
||||
aussi le title avec le nom d'affichage, donc l'infobulle
|
||||
devient l'initiale après chargement (le libellé reste dans
|
||||
le HTML servi). */
|
||||
user: "{{ draco_avatar }}",
|
||||
/* user = nom du compte de la SESSION (0.46.8, chantier
|
||||
« entrée SSO ») : display_name sinon username, posé par
|
||||
render() dans app/main.py (draco_user). La barre en
|
||||
dérive l'initiale de l'avatar ET l'en-tête du menu
|
||||
compte — avant, seule l'initiale de l'opérateur
|
||||
d'environnement (auth_user) était servie, quel que soit
|
||||
le compte connecté. Sans session (pages publiques),
|
||||
draco_user vaut null et l'avatar retombe sur l'initiale
|
||||
historique (draco_avatar). */
|
||||
user: {{ draco_user | tojson }},
|
||||
domain: (function () { try { return localStorage.getItem("draco_domain") || "pro"; } catch (e) { return "pro"; } })(),
|
||||
counts: {},
|
||||
onAction: function (act, el) {
|
||||
@@ -152,8 +163,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). */
|
||||
|
||||
@@ -11,37 +11,6 @@
|
||||
} catch (e) { /* mode privé : le thème ne survit qu'à la page */ }
|
||||
</script>
|
||||
{% include "_draco_bar.html" %}
|
||||
{# ── Bannière d'annonce des réglages généraux du Hub (HUB-21) ────
|
||||
Texte posé par render() (contexte `banniere_hub`, client serveur
|
||||
à cache 60 s et repli intégral) et échappé par l'autoescape
|
||||
Jinja — jamais de HTML injecté. Vide = aucun fragment rendu.
|
||||
Le script masque le bandeau si le même texte a déjà été fermé
|
||||
dans la session du navigateur (sessionStorage) : une nouvelle
|
||||
annonce réapparaît. #}
|
||||
{% if banniere_hub %}
|
||||
<div class="banniere-hub" id="banniere-hub" role="status" hidden>
|
||||
<span class="banniere-hub-texte">{{ banniere_hub }}</span>
|
||||
<button type="button" class="banniere-hub-fermer" id="banniere-hub-fermer" aria-label="Fermer l'annonce">✕</button>
|
||||
</div>
|
||||
<script>
|
||||
(function () {
|
||||
try {
|
||||
var b = document.getElementById('banniere-hub');
|
||||
if (!b) return;
|
||||
var t = b.querySelector('.banniere-hub-texte').textContent;
|
||||
if (sessionStorage.getItem('kanbante_banniere_masquee') === t) { b.remove(); return; }
|
||||
b.hidden = false;
|
||||
document.getElementById('banniere-hub-fermer').addEventListener('click', function () {
|
||||
try { sessionStorage.setItem('kanbante_banniere_masquee', t); } catch (e) { /* stockage indisponible */ }
|
||||
b.remove();
|
||||
});
|
||||
} catch (e) {
|
||||
var b2 = document.getElementById('banniere-hub');
|
||||
if (b2) b2.hidden = false;
|
||||
}
|
||||
})();
|
||||
</script>
|
||||
{% endif %}
|
||||
{# ── Cadre applicatif partagé (issue #16, refonte 0.16.0) ─────────
|
||||
Barre latérale unique pour TOUTES les pages applicatives :
|
||||
desktop = barre fixe repliable en rail d'icônes (état mémorisé),
|
||||
|
||||
@@ -0,0 +1,46 @@
|
||||
<!DOCTYPE html>
|
||||
<html lang="fr">
|
||||
<head>
|
||||
<meta charset="UTF-8">
|
||||
<script>try{var t=localStorage.getItem("kanbante-theme");document.documentElement.setAttribute("data-theme",t==="light"?"light":"dark");}catch(e){document.documentElement.setAttribute("data-theme","dark");}</script>
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0">
|
||||
<meta name="csrf-token" content="{{ csrf_token }}">
|
||||
<title>Relier le compte — Kanbante</title>
|
||||
<link rel="stylesheet" href="/static/css/style.css">
|
||||
</head>
|
||||
<body class="login-body">
|
||||
<main class="login-wrap">
|
||||
<section class="login-card">
|
||||
<div class="login-brand">
|
||||
<span class="login-mark" aria-hidden="true"><svg viewBox="0 0 24 24" fill="#fff" aria-hidden="true" style="width:20px;height:20px;display:block"><rect x="3" y="4" width="5" height="16" rx="1"/><rect x="9.5" y="4" width="5" height="10" rx="1"/><rect x="16" y="4" width="5" height="13" rx="1"/></svg></span>
|
||||
<h1>Kanbante</h1>
|
||||
<p class="login-sub">Relier ce compte à votre identité de la suite</p>
|
||||
</div>
|
||||
{# Re-liaison par double preuve (0.46.10) : la session
|
||||
native prouve le mot de passe local, le cookie draco
|
||||
valide prouve l'identité centrale — la page n'est
|
||||
rendue que lorsque les deux sont présentes et se
|
||||
contredisent (voir app.main.draco_relier_page). #}
|
||||
<p>Vous êtes connecté ici au compte local
|
||||
« {{ compte_local }} » par son mot de passe,
|
||||
et votre navigateur présente aussi l'identité de la
|
||||
suite « {{ nom_draco }} » (ObsiGate). Ces
|
||||
deux identités ne désignent pas le même compte
|
||||
Kanbante{% if detenteur %} : l'identité de la suite
|
||||
est actuellement reliée au compte
|
||||
« {{ detenteur }} »{% endif %}.</p>
|
||||
<p>Relier déplacera la liaison vers le compte
|
||||
« {{ compte_local }} » : la connexion par
|
||||
ObsiGate ouvrira désormais ce compte-ci. Le compte
|
||||
délié garde son mot de passe local et reste
|
||||
accessible par le formulaire de connexion.</p>
|
||||
<form method="post" action="/auth/draco/relier" class="login-form">
|
||||
<input type="hidden" name="csrf_token" value="{{ csrf_token }}">
|
||||
<input type="hidden" name="next" value="{{ next }}">
|
||||
<button type="submit" class="login-submit">Relier mon compte</button>
|
||||
</form>
|
||||
<a class="login-sso" href="{{ next }}">Plus tard — continuer sans relier</a>
|
||||
</section>
|
||||
</main>
|
||||
</body>
|
||||
</html>
|
||||
@@ -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>
|
||||
|
||||
@@ -12,7 +12,6 @@
|
||||
{% include "_header.html" %}
|
||||
|
||||
<main class="rp-page" id="recherche" data-host="kanbante"
|
||||
data-recherche-partout="{{ 'true' if recherche_partout_hub else 'false' }}"
|
||||
data-base-obsigate="{{ draco_urls.obsigate }}"
|
||||
data-base-flowdeck="{{ draco_urls.flowdeck }}"
|
||||
data-base-tiktak="{{ draco_urls.tiktak }}"
|
||||
|
||||
@@ -10,6 +10,7 @@ services:
|
||||
# l'environnement dev déclare ses noms en -dev dans son .env.
|
||||
- KANBANTE_PUBLIC_URL=${KANBANTE_PUBLIC_URL:-https://kanbante.dracodev.net}
|
||||
- DRACO_SSO_URL=${DRACO_SSO_URL:-https://og.dracodev.net}
|
||||
- DRACO_SESSION_SECRET=${DRACO_SESSION_SECRET:-}
|
||||
- DRACO_FLOWDECK_URL=${DRACO_FLOWDECK_URL:-https://flowdeck.dracodev.net}
|
||||
- DRACO_TIKTAK_URL=${DRACO_TIKTAK_URL:-https://tiktak.dracodev.net}
|
||||
- AGENT_URL=${AGENT_URL:-https://agent.dracodev.net}
|
||||
|
||||
+114
-22
@@ -36,24 +36,106 @@ Dans l'ordre :
|
||||
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** : s'il n'existe qu'**un seul compte** et
|
||||
que c'est un **admin actif sans liaison**, le premier `sub`
|
||||
valide s'y lie et sa session est ouverte. C'est le cas du
|
||||
compte créé à l'installation depuis l'environnement
|
||||
(`KANBANTE_AUTH_USER` / `KANBANTE_AUTH_PASSWORD`, Bruno) : sa
|
||||
correspondance s'établit au premier passage, sans le verrouiller
|
||||
dehors. Ses autres accès restent inchangés dans tous les cas :
|
||||
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
|
||||
(rattachement par homonymie, point 4, ou création JIT d'un
|
||||
compte **membre** propre, point 5) — 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
|
||||
d'urgence par les identifiants d'environnement (formulaire
|
||||
et Basic), qui ne dépendent pas de draco.
|
||||
4. **Rattachement par homonymie (0.46.10)** : si un compte local
|
||||
porte **exactement le nom d'utilisateur** que l'identité
|
||||
présentée porterait (nom des claims slugifié — `bruno` →
|
||||
`bruno`) et qu'il n'a **aucun lien draco**, le `sub` y est
|
||||
rattaché (journalisé `draco.link.nom`) et c'est la session de
|
||||
**ce** compte qui est ouverte. Fondement : les noms centraux
|
||||
font foi — les comptes de la suite sont créés par
|
||||
l'administrateur au Hub et il n'existe aucune inscription
|
||||
publique ; avant la 0.46.10, ce cas créait un clone JIT
|
||||
suffixé (`bruno-2`) et le propriétaire légitime n'atteignait
|
||||
jamais son compte. Si l'homonyme est déjà lié à un **autre**
|
||||
`sub` : **conflit explicite** — le pont redirige vers
|
||||
`/login?draco=conflit`, ne rattache rien et ne crée aucun
|
||||
clone ; la sortie est la re-liaison par double preuve
|
||||
(§ Re-liaison par double preuve). Un homonyme **désactivé**
|
||||
résout à un échec ordinaire, jamais contourné.
|
||||
5. **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.
|
||||
d'environnement ni celle d'un compte existant d'un **autre nom**
|
||||
que le sien : hors le rattachement par homonymie du point 4
|
||||
(compte homonyme **sans lien**), le JIT crée toujours un compte
|
||||
**nouveau** (nom suffixé `-2`, `-3`… en cas de collision),
|
||||
jamais une adoption.
|
||||
|
||||
## Re-liaison par double preuve (0.46.10)
|
||||
|
||||
Quand le compte local du propriétaire est lié à un **ancien**
|
||||
`sub` (ou quand le `sub` actuel est détenu par un autre
|
||||
compte), aucun geste automatique ne réécrit le lien : le nom
|
||||
prouve l'identité centrale, pas la propriété du compte local.
|
||||
La **double preuve** la tranche : la connexion locale par mot
|
||||
de passe réussie **pendant qu'un cookie draco valide de
|
||||
l'identité désalignée est présent** (ou le passage du pont avec
|
||||
une session native déjà ouverte) ouvre la page
|
||||
`/auth/draco/relier`, qui nomme les deux identités et propose
|
||||
le geste. La validation réécrit `users.draco_sub` (retrait à
|
||||
l'ancien détenteur journalisé `draco.relink.retrait`, pose
|
||||
journalisée `draco.relink`) ; le compte délié garde son mot de
|
||||
passe local. Sans les deux preuves réunies, la page est
|
||||
inatteignable et aucun lien ne bouge.
|
||||
|
||||
## Sorties d'échec du pont — toutes signalées (0.46.10, complété en 0.46.11)
|
||||
|
||||
Depuis la 0.46.11, **aucune** sortie d'échec de la chaîne
|
||||
d'entrée draco (pont, entrée automatique du middleware,
|
||||
re-liaison) ne ramène au formulaire sans message : chacune
|
||||
porte un paramètre `draco=` que la page de connexion traduit
|
||||
en explication.
|
||||
|
||||
- **Jeton présent mais illisible** (0.46.10) : signature —
|
||||
secret partagé du conteneur divergent —, expiration ou
|
||||
révocation → `/login?draco=invalide`, message explicite.
|
||||
- **Jeton absent** (0.46.11) : le parcours SSO est arrivé au
|
||||
pont sans aucun cookie `draco_session` (session de la suite
|
||||
absente ou cookie non transmis) → `/login?draco=absent`.
|
||||
Avant, c'était le formulaire nu historique.
|
||||
- **Service draco inerte** (0.46.11) : le conteneur Kanbante
|
||||
n'a **aucun** `DRACO_SESSION_SECRET` — le pont ne peut
|
||||
valider aucune identité, alors que le bouton SSO est rendu
|
||||
quand même. Un cookie présenté dans cet état →
|
||||
`/login?draco=inactif`, qui nomme un défaut de configuration
|
||||
du service. Cas réel (2026-11-16) : c'était l'état du
|
||||
conteneur kanbante-dev — le propriétaire légitime, cookie
|
||||
valide lu par ShaarIt et TikTak, revenait au formulaire nu
|
||||
sans aucun moyen de savoir que la faute était dans le
|
||||
conteneur. La même signalisation s'applique quand une page
|
||||
protégée est demandée avec un cookie présent mais
|
||||
inutilisable (entrée automatique du middleware).
|
||||
- **Échec de résolution** (0.46.8) : compte désigné
|
||||
désactivé, etc. → `/login?draco=echec`.
|
||||
- **Conflit de nom** (0.46.10) : homonyme lié à un autre
|
||||
`sub` → `/login?draco=conflit` (voir plus haut).
|
||||
|
||||
## Création JIT (juste-à-temps)
|
||||
|
||||
@@ -121,9 +203,17 @@ draco** :
|
||||
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`).
|
||||
`sub`, aucun compte créé. **Précision 0.46.11** : la
|
||||
consultation transporte le drapeau `explicite` de la
|
||||
réponse (`app.hub_roles.explicite_pour`) et le refus
|
||||
n'a lieu que si le niveau est une décision — explicite,
|
||||
ou d'origine inconnue (réponse sans le drapeau :
|
||||
comportement historique). Un `aucun` que le registre
|
||||
présente comme son **défaut** (`explicite: false`) n'a
|
||||
été décidé par personne : il ne verrouille pas l'entrée.
|
||||
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
|
||||
@@ -139,11 +229,13 @@ internes ni la réconciliation par étiquettes ne changent.
|
||||
|
||||
- **`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 ou compte
|
||||
d'amorçage lié au passage). 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.
|
||||
`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
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -2011,12 +2011,3 @@ html[data-theme="light"] .notes-panel { background: rgba(255, 255, 255, 0.85); }
|
||||
html[data-theme="light"] .age-badge { color: #b45309; }
|
||||
html[data-theme="light"] .age-badge.stale { color: #dc2626; }
|
||||
html[data-theme="light"] .column-count.over { color: #dc2626; }
|
||||
|
||||
/* Bannière d'annonce des réglages généraux du Hub (HUB-21) :
|
||||
bandeau rendu sous la barre commune (partiel _header.html),
|
||||
fermable (masquage mémorisé pour la session du navigateur). */
|
||||
.banniere-hub { display: flex; align-items: center; gap: 12px; padding: 8px 16px; background: var(--accent, #0d9488); color: #fff; font-size: 14px; }
|
||||
.banniere-hub[hidden] { display: none; }
|
||||
.banniere-hub-texte { flex: 1; overflow-wrap: anywhere; }
|
||||
.banniere-hub-fermer { flex: none; background: transparent; border: none; color: inherit; font-size: 15px; line-height: 1; padding: 4px 6px; cursor: pointer; border-radius: 6px; }
|
||||
.banniere-hub-fermer:hover { background: rgba(255, 255, 255, 0.18); }
|
||||
|
||||
@@ -42,6 +42,22 @@
|
||||
* 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
|
||||
@@ -54,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/",
|
||||
@@ -653,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" }],
|
||||
@@ -687,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
|
||||
@@ -719,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";
|
||||
@@ -734,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) {
|
||||
@@ -835,6 +894,14 @@
|
||||
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;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
+2
-74
@@ -246,21 +246,6 @@
|
||||
return [tab];
|
||||
}
|
||||
|
||||
/* HUB-21 (propagation des réglages généraux du Hub) : le drapeau
|
||||
* « Rechercher partout », rendu par l'hôte dans l'attribut
|
||||
* data-recherche-partout de #recherche (« true »/« false », lu
|
||||
* côté serveur depuis GET {hub}/api/reglages/effectifs, cache
|
||||
* 60 s, patron du pilote TikTak 0.61.22). Seules les valeurs
|
||||
* explicitement négatives désactivent la fédération ; attribut
|
||||
* absent ou illisible = fédération active — le comportement
|
||||
* actuel, qui est aussi le repli quand le Hub est muet.
|
||||
* Fonction pure, exposée aux tests. */
|
||||
function federationAutorisee(valeur) {
|
||||
if (valeur == null) return true;
|
||||
var v = String(valeur).trim().toLowerCase();
|
||||
return v !== "false" && v !== "0" && v !== "non";
|
||||
}
|
||||
|
||||
/* Troncature d'affichage : liste complète dans l'onglet propre à
|
||||
* l'application, PER_APP_LIMIT partout ailleurs (vue « Tout »). */
|
||||
function pageItems(items, full) {
|
||||
@@ -529,7 +514,6 @@
|
||||
visibleKeys: visibleKeys,
|
||||
pageItems: pageItems,
|
||||
buildSearchUrl: buildSearchUrl,
|
||||
federationAutorisee: federationAutorisee,
|
||||
tabCounts: tabCounts,
|
||||
searchPath: searchPath,
|
||||
normalize: normalize,
|
||||
@@ -625,14 +609,6 @@
|
||||
".</p>";
|
||||
return;
|
||||
}
|
||||
if (state.status === "desactivee") {
|
||||
count.textContent = "";
|
||||
body.innerHTML =
|
||||
'<p class="rp-state">Recherche fédérée désactivée dans les ' +
|
||||
"réglages généraux de la suite (Hub) : cette application " +
|
||||
"n'est pas interrogée.</p>";
|
||||
return;
|
||||
}
|
||||
if (state.status === "idle") {
|
||||
count.textContent = "";
|
||||
body.innerHTML =
|
||||
@@ -675,8 +651,6 @@
|
||||
var input = document.getElementById("rp-q");
|
||||
if (!input) return;
|
||||
var hostApp = root.getAttribute("data-host") || "";
|
||||
var federation = federationAutorisee(
|
||||
root.getAttribute("data-recherche-partout"));
|
||||
var explicit = {};
|
||||
APPS.forEach(function (app) {
|
||||
var v = root.getAttribute("data-base-" + app.key);
|
||||
@@ -798,23 +772,7 @@
|
||||
applyTab(tab, opts);
|
||||
/* La console n'est interrogée qu'une fois affichée. */
|
||||
if (parseTab(tab) === "console" && currentQ && consoleFetchedQ !== currentQ) {
|
||||
if (!federation) {
|
||||
var secConsOnglet = sections.console;
|
||||
if (secConsOnglet) {
|
||||
states.console = {
|
||||
status: "desactivee",
|
||||
items: [],
|
||||
message: "",
|
||||
q: currentQ,
|
||||
base: consoleBase,
|
||||
app: "console",
|
||||
};
|
||||
renderSection(secConsOnglet, states.console, true);
|
||||
renderTabs();
|
||||
}
|
||||
} else {
|
||||
fetchConsole(currentQ, runId);
|
||||
}
|
||||
fetchConsole(currentQ, runId);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -907,22 +865,6 @@
|
||||
APPS.forEach(function (app) {
|
||||
var sec = sections[app.key];
|
||||
if (!sec) return;
|
||||
if (!federation && app.key !== hostApp) {
|
||||
/* HUB-21 : fédération désactivée par le Hub — la section
|
||||
* sœur n'est pas interrogée, la recherche locale
|
||||
* (app.key === hostApp, même origine) continue. */
|
||||
states[app.key] = {
|
||||
status: "desactivee",
|
||||
items: [],
|
||||
message: "",
|
||||
q: q,
|
||||
base: bases[app.key],
|
||||
app: app.key,
|
||||
};
|
||||
renderSection(sec, states[app.key], activeTab === app.key);
|
||||
renderTabs();
|
||||
return;
|
||||
}
|
||||
states[app.key] = {
|
||||
status: "loading",
|
||||
items: [],
|
||||
@@ -973,21 +915,7 @@
|
||||
});
|
||||
/* Console : seulement si son onglet est affiché ; sinon son
|
||||
* compteur reste vide (pas de faux 0) jusqu'à son activation. */
|
||||
if (activeTab === "console" && !federation) {
|
||||
var secConsRecherche = sections.console;
|
||||
if (secConsRecherche) {
|
||||
states.console = {
|
||||
status: "desactivee",
|
||||
items: [],
|
||||
message: "",
|
||||
q: q,
|
||||
base: consoleBase,
|
||||
app: "console",
|
||||
};
|
||||
renderSection(secConsRecherche, states.console, true);
|
||||
renderTabs();
|
||||
}
|
||||
} else if (activeTab === "console") {
|
||||
if (activeTab === "console") {
|
||||
fetchConsole(q, myRun);
|
||||
} else {
|
||||
states.console = {
|
||||
|
||||
@@ -197,17 +197,4 @@ ok(rc.recognized === true && rc.items.length === 0, "console : resultats vide re
|
||||
ok(rp.consoleLinkFor({ type: "discussion", id: "c1" }) === "/?section=conversation&disc=c1", "consoleLinkFor discussion");
|
||||
ok(rp.resolveConsoleBase({ host: "x.example", tabHrefs: { agent: "https://agent-perso.example/" } }) === "https://agent-perso.example/", "console : href onglet barre agent accepte");
|
||||
|
||||
/* federationAutorisee (HUB-21) : seules les valeurs explicitement
|
||||
négatives désactivent la fédération ; absent/illisible = actif
|
||||
(repli = comportement actuel, Hub muet compris). */
|
||||
ok(rp.federationAutorisee("false") === false, "fédération : false désactive");
|
||||
ok(rp.federationAutorisee("0") === false, "fédération : 0 désactive");
|
||||
ok(rp.federationAutorisee(" FALSE ") === false, "fédération : casse/espaces ignorés");
|
||||
ok(rp.federationAutorisee("true") === true, "fédération : true active");
|
||||
ok(rp.federationAutorisee("1") === true, "fédération : 1 active");
|
||||
ok(rp.federationAutorisee(null) === true, "fédération : attribut absent = actif");
|
||||
ok(rp.federationAutorisee(undefined) === true, "fédération : undefined = actif");
|
||||
ok(rp.federationAutorisee("") === true, "fédération : vide = actif");
|
||||
ok(rp.federationAutorisee("nimporte") === true, "fédération : illisible = actif");
|
||||
|
||||
console.log("recherche.test.js : " + n + " assertions OK");
|
||||
|
||||
@@ -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
|
||||
@@ -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,213 @@
|
||||
"""Cohérence d'identité au changement de compte (0.46.7).
|
||||
|
||||
Cas réel : connecté « fred » chez ObsiGate, l'utilisateur ouvre
|
||||
Kanbante et y trouve son propre compte — la session locale
|
||||
préexistante gouvernait sans reconsulter l'identité centrale.
|
||||
Quand la requête porte aussi un cookie ``draco_session`` valide
|
||||
dont le ``sub`` diffère du sub lié au compte de la session,
|
||||
``AuthMiddleware`` invalide la session locale (suppression du
|
||||
cookie signé — Kanbante n'a pas de session serveur) et renvoie
|
||||
les pages au pont ``/auth/draco`` ; les API reçoivent un 401.
|
||||
|
||||
Gardes couvertes : même sub (inchangée), aucun cookie et cookie
|
||||
invalide (intacte), session de secours marquée (exemptée), rôle
|
||||
« aucun » au registre (session gardée — pas d'exclusion en
|
||||
boucle), compte local sans aucun lien (l'identité centrale
|
||||
présente gagne).
|
||||
|
||||
La base de test est partagée par toute la session (conftest) :
|
||||
comptes « coh-… » créés ici et supprimés au teardown.
|
||||
"""
|
||||
|
||||
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, hub_roles, models
|
||||
|
||||
SECRET = "coherence-test"
|
||||
|
||||
SUB_BRUNO = "coh-sub-bruno"
|
||||
SUB_FRED = "coh-sub-fred"
|
||||
NOMS = ("coh-bruno", "coh-fred", "coh-historique")
|
||||
|
||||
|
||||
def _jeton(sub, secret=SECRET, exp=None):
|
||||
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": "Testeur", "iat": int(time.time()),
|
||||
"exp": exp if exp is not None else 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():
|
||||
with models.get_db() as conn:
|
||||
ids = [r[0] for r in conn.execute(
|
||||
"SELECT id FROM users WHERE username IN ({})".format(
|
||||
",".join("?" * len(NOMS))), NOMS).fetchall()]
|
||||
ids += [r[0] for r in conn.execute(
|
||||
"SELECT id FROM users WHERE draco_sub IN (?, ?)",
|
||||
(SUB_BRUNO, SUB_FRED)).fetchall()]
|
||||
for uid in ids:
|
||||
conn.execute("DELETE FROM users WHERE id = ?", (uid,))
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def client_coh(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)
|
||||
# Registre des rôles muet (rôle inconnu), sauf test dédié.
|
||||
monkeypatch.setattr(hub_roles, "role_pour", lambda *a, **k: None)
|
||||
draco._revoked_cache.clear()
|
||||
_nettoyer()
|
||||
models.create_user(
|
||||
"coh-bruno", accounts.hash_password("local-bruno"),
|
||||
role="admin", draco_sub=SUB_BRUNO)
|
||||
models.create_user(
|
||||
"coh-fred", accounts.hash_password("local-fred"),
|
||||
role="member", draco_sub=SUB_FRED)
|
||||
models.create_user(
|
||||
"coh-historique", accounts.hash_password("local-hist"),
|
||||
role="member")
|
||||
with TestClient(main.app) as client:
|
||||
yield client
|
||||
_nettoyer()
|
||||
draco._revoked_cache.clear()
|
||||
|
||||
|
||||
def _session(client, nom, **kwargs):
|
||||
client.cookies.set(
|
||||
"kanbante_session", main._make_session(nom, **kwargs))
|
||||
|
||||
|
||||
def _cookie_detruit(reponse) -> bool:
|
||||
brut = reponse.headers.get("set-cookie", "")
|
||||
return "kanbante_session=" in brut and "Max-Age=0" in brut
|
||||
|
||||
|
||||
# ── (iii) session d'un autre compte + cookie valide → alignement ──
|
||||
|
||||
def test_page_session_autre_compte_renvoyee_au_pont(client_coh):
|
||||
_session(client_coh, "coh-fred")
|
||||
client_coh.cookies.set("draco_session", _jeton(SUB_BRUNO))
|
||||
r = client_coh.get("/", follow_redirects=False)
|
||||
assert r.status_code == 303
|
||||
assert r.headers["location"].startswith("/auth/draco")
|
||||
assert _cookie_detruit(r)
|
||||
|
||||
|
||||
def test_apres_alignement_le_pont_sert_le_compte_du_cookie(client_coh):
|
||||
_session(client_coh, "coh-fred")
|
||||
client_coh.cookies.set("draco_session", _jeton(SUB_BRUNO))
|
||||
client_coh.get("/", follow_redirects=False)
|
||||
# Le navigateur honore le Max-Age=0 de la réponse d'alignement
|
||||
# (le jar du TestClient, lui, conserve le cookie périmé : on
|
||||
# retire donc la session du jar pour simuler le navigateur).
|
||||
client_coh.cookies.delete("kanbante_session")
|
||||
# Sans session locale, le navigateur repasse par le pont.
|
||||
r = client_coh.get("/auth/draco", follow_redirects=False)
|
||||
assert r.status_code == 303
|
||||
assert r.headers["location"] == "/"
|
||||
# La session résultante (jar du client) est celle du compte du
|
||||
# cookie, établie par le pont (segment marqueur « draco »).
|
||||
session = client_coh.cookies.get("kanbante_session") or ""
|
||||
assert session.startswith("coh-bruno.")
|
||||
assert ".draco." in session
|
||||
r = client_coh.get("/", follow_redirects=False)
|
||||
assert r.status_code == 200
|
||||
|
||||
|
||||
def test_api_session_autre_compte_401_et_cookie_detruit(client_coh):
|
||||
_session(client_coh, "coh-fred")
|
||||
client_coh.cookies.set("draco_session", _jeton(SUB_BRUNO))
|
||||
r = client_coh.get("/api/standup")
|
||||
assert r.status_code == 401
|
||||
assert _cookie_detruit(r)
|
||||
|
||||
|
||||
# ── (ii) même sub, (iv) pas de cookie, cookie invalide → intacte ──
|
||||
|
||||
def test_meme_sub_session_inchangee(client_coh):
|
||||
_session(client_coh, "coh-fred")
|
||||
client_coh.cookies.set("draco_session", _jeton(SUB_FRED))
|
||||
r = client_coh.get("/", follow_redirects=False)
|
||||
assert r.status_code == 200
|
||||
assert not _cookie_detruit(r)
|
||||
|
||||
|
||||
def test_sans_cookie_session_intacte(client_coh):
|
||||
_session(client_coh, "coh-fred")
|
||||
r = client_coh.get("/", follow_redirects=False)
|
||||
assert r.status_code == 200
|
||||
|
||||
|
||||
def test_cookie_invalide_session_intacte(client_coh):
|
||||
_session(client_coh, "coh-fred")
|
||||
client_coh.cookies.set(
|
||||
"draco_session", _jeton(SUB_BRUNO, secret="mauvais-secret"))
|
||||
r = client_coh.get("/", follow_redirects=False)
|
||||
assert r.status_code == 200
|
||||
|
||||
|
||||
# ── (v) session de secours exemptée ──────────────────────────────
|
||||
|
||||
def test_session_secours_exemptee(client_coh):
|
||||
_session(client_coh, "coh-bruno", via_secours=True)
|
||||
client_coh.cookies.set("draco_session", _jeton(SUB_FRED))
|
||||
r = client_coh.get("/", follow_redirects=False)
|
||||
assert r.status_code == 200
|
||||
assert not _cookie_detruit(r)
|
||||
|
||||
|
||||
# ── Gardes : rôle « aucun », compte sans lien ────────────────────
|
||||
|
||||
def test_role_aucun_session_gardee(client_coh, monkeypatch):
|
||||
monkeypatch.setattr(
|
||||
hub_roles, "role_pour", lambda *a, **k: "aucun")
|
||||
_session(client_coh, "coh-fred")
|
||||
client_coh.cookies.set("draco_session", _jeton(SUB_BRUNO))
|
||||
r = client_coh.get("/", follow_redirects=False)
|
||||
assert r.status_code == 200
|
||||
assert not _cookie_detruit(r)
|
||||
|
||||
|
||||
def test_compte_sans_lien_identite_centrale_gagne(client_coh):
|
||||
_session(client_coh, "coh-historique")
|
||||
client_coh.cookies.set("draco_session", _jeton(SUB_BRUNO))
|
||||
r = client_coh.get("/", follow_redirects=False)
|
||||
assert r.status_code == 303
|
||||
assert r.headers["location"].startswith("/auth/draco")
|
||||
assert _cookie_detruit(r)
|
||||
|
||||
|
||||
def test_marqueur_secours_lisible_et_infalsifiable():
|
||||
brut = main._make_session("coh-bruno", via_secours=True)
|
||||
|
||||
class Faux:
|
||||
cookies = {"kanbante_session": brut}
|
||||
|
||||
info = main._session_info_complet(Faux())
|
||||
assert info == ("coh-bruno", False, True)
|
||||
# Les formats historique et draco restent lisibles.
|
||||
natif = main._make_session("coh-bruno")
|
||||
|
||||
class Faux2:
|
||||
cookies = {"kanbante_session": natif}
|
||||
|
||||
assert main._session_info_complet(Faux2()) == ("coh-bruno", False, False)
|
||||
|
||||
@@ -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
|
||||
@@ -420,3 +420,27 @@ def test_resolution_sans_requete_inchangee(monkeypatch):
|
||||
assert urls.public_url == "https://kanbante.dracodev.net"
|
||||
assert urls.agent_url == "https://agent.dracodev.net"
|
||||
assert _env_settings().agent_url == "https://agent.dracodev.net"
|
||||
|
||||
|
||||
# ── Retour SSO navigateur : l'hôte de la requête fait foi ──────────
|
||||
# Correctif du constat dev du 2026-11-08 : le bouton SSO servi en
|
||||
# « -dev » portait return_to sur le nom officiel parce que la chaîne
|
||||
# de configuration (KANBANTE_PUBLIC_URL / AGENT_URL explicites sur
|
||||
# les noms officiels) primait. Pour un aller-retour initié par un
|
||||
# navigateur, l'hôte public de la requête (motif fermé dracodev)
|
||||
# prime sur toute la configuration.
|
||||
|
||||
def test_base_retour_navigateur():
|
||||
from app.config import base_retour_navigateur
|
||||
|
||||
assert base_retour_navigateur(
|
||||
"kanbante-dev.dracodev.net", "https://kanbante.dracodev.net") == \
|
||||
"https://kanbante-dev.dracodev.net"
|
||||
assert base_retour_navigateur(
|
||||
"kanbante.dracodev.net", "https://kanbante.dracodev.net") == \
|
||||
"https://kanbante.dracodev.net"
|
||||
for hote in ("192.168.30.101:8082", "atelier.example.net",
|
||||
"nimporte-dev.dracodev.net", "testserver", "", None):
|
||||
assert base_retour_navigateur(
|
||||
hote, "https://kanbante.dracodev.net") == \
|
||||
"https://kanbante.dracodev.net", hote
|
||||
|
||||
@@ -4,12 +4,19 @@ 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 se lie au
|
||||
premier passage (le compte existant garde son accès) ;
|
||||
- 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é ;
|
||||
- rattachement par homonymie (0.46.10, chantier SSO
|
||||
« bruno ») : un compte préexistant non lié portant le nom de
|
||||
l'identité présentée est rattaché et servi — le JIT ne crée
|
||||
plus de clone suffixé dans ce cas (matrice complète :
|
||||
tests/test_draco_rattachement.py) ; un compte d'un nom
|
||||
DIFFÉRENT n'est toujours jamais absorbé ;
|
||||
- liaison / déliaison par l'administrateur depuis /admin,
|
||||
conflit de sub refusé ;
|
||||
- compte désactivé : correspondance refusée, aucun contournement ;
|
||||
@@ -129,7 +136,17 @@ def _unique_admin_sans_liaison():
|
||||
|
||||
# ── Amorçage ──────────────────────────────────────────────────
|
||||
|
||||
def test_amorcage_unique_admin_se_lie_au_premier_passage(client_hub16):
|
||||
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")
|
||||
@@ -187,7 +204,16 @@ def test_jit_deux_identites_deux_comptes_distincts(client_hub16):
|
||||
models.update_user(admin["id"], draco_sub=None)
|
||||
|
||||
|
||||
def test_jit_n_adopte_pas_un_compte_homonyme_non_lie(client_hub16):
|
||||
def test_homonyme_non_lie_rattache_depuis_04610(client_hub16):
|
||||
# Contrat inversé en 0.46.10 (chantier SSO « bruno ») :
|
||||
# avant, ce cas créait un clone JIT suffixé et le compte
|
||||
# préexistant n'était ni lié ni servi — le propriétaire
|
||||
# légitime n'atteignait jamais son compte. Désormais, le
|
||||
# compte homonyme SANS lien est rattaché au sub vérifié
|
||||
# (les noms centraux font foi : comptes créés par
|
||||
# l'administrateur au Hub, aucune inscription publique).
|
||||
# La matrice complète (conflit, double preuve, gardes) vit
|
||||
# dans tests/test_draco_rattachement.py.
|
||||
admin, pur = _unique_admin_sans_liaison()
|
||||
if pur:
|
||||
models.update_user(admin["id"], draco_sub="hub16-temoin-amorce")
|
||||
@@ -196,16 +222,14 @@ def test_jit_n_adopte_pas_un_compte_homonyme_non_lie(client_hub16):
|
||||
"carole-exemple", accounts.hash_password("local-carole"),
|
||||
role="member", display_name="Carole Exemple",
|
||||
)
|
||||
avant = models.count_users()
|
||||
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"
|
||||
# Le compte préexistant est lié et servi ; aucun clone.
|
||||
assert models.count_users() == avant
|
||||
lie = models.get_user_by_draco("hub16-carole")
|
||||
assert lie is not None and lie["id"] == local_id
|
||||
assert _profil_username(client_hub16) == "carole-exemple"
|
||||
finally:
|
||||
if pur:
|
||||
models.update_user(admin["id"], draco_sub=None)
|
||||
@@ -224,7 +248,11 @@ def test_compte_desactive_refuse_sans_contournement(client_hub16):
|
||||
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"
|
||||
# Depuis la 0.46.8, le retour au formulaire porte la
|
||||
# raison (draco=echec, message affiché par login_page) et
|
||||
# le next, au lieu du « /login » nu historique.
|
||||
assert r.headers["location"].startswith("/login?")
|
||||
assert "draco=echec" in r.headers["location"]
|
||||
assert "kanbante_session" not in r.headers.get("set-cookie", "")
|
||||
assert models.count_users() == avant
|
||||
finally:
|
||||
@@ -300,6 +328,12 @@ def test_liaison_par_administrateur(client_hub16):
|
||||
assert _profil_username(client_hub16) == "hub16-dave"
|
||||
|
||||
# Déliaison par l'administrateur (champ vide).
|
||||
# Le cookie draco de Dave encore présent dans le navigateur est
|
||||
# retiré : depuis la cohérence d'identité (0.46.7), une session
|
||||
# locale présentée avec le cookie valide d'un AUTRE sub est
|
||||
# alignée sur ce sub avant tout service — l'administrateur agit
|
||||
# ici dans un navigateur sans identité centrale étrangère.
|
||||
client_hub16.cookies.delete("draco_session")
|
||||
_connecter_admin(client_hub16)
|
||||
r = client_hub16.post(
|
||||
f"/admin/users/{dave_id}/draco",
|
||||
|
||||
@@ -0,0 +1,326 @@
|
||||
"""0.46.10 — rattachement par homonymie, conflit explicite et
|
||||
re-liaison par double preuve (chantier SSO « bruno »).
|
||||
|
||||
Cas réel (dev de Bruno, 2026-11-16) : connecté chez ObsiGate
|
||||
avec son compte « bruno », le bouton SSO de Kanbante ne le
|
||||
connectait pas à SON compte. Reproduction en pile fidèle
|
||||
(secrets partagés identiques, instance multi-utilisateurs,
|
||||
admin local « bruno » issu de l'amorçage par l'environnement) :
|
||||
|
||||
- bruno local SANS lien draco : le pont créait un clone JIT
|
||||
« bruno-2 » (membre) et ouvrait SA session — l'admin légitime
|
||||
restait sans lien, invisible ;
|
||||
- bruno local lié à un ANCIEN sub : même clone, aucun signal ;
|
||||
- jeton présent mais illisible pour Kanbante (secret du
|
||||
conteneur divergent) : retour au formulaire NU, sans session
|
||||
ni message — indiscernable d'une absence de session centrale.
|
||||
|
||||
Correctifs couverts ici :
|
||||
|
||||
- rattachement par homonymie : le compte local qui porte le
|
||||
nom de l'identité présentée et n'a aucun lien draco est
|
||||
rattaché au sub vérifié et servi (les noms centraux font
|
||||
foi : comptes créés par l'administrateur au Hub, aucune
|
||||
inscription publique) ;
|
||||
- homonyme lié à un autre sub : refus explicite
|
||||
``/login?draco=conflit``, aucun rattachement, aucun clone ;
|
||||
- re-liaison par double preuve : connexion locale par mot de
|
||||
passe pendant qu'un cookie draco valide d'une identité
|
||||
désalignée est présent → proposition ``/auth/draco/relier``
|
||||
→ réécriture du lien (retrait à l'ancien détenteur compris) ;
|
||||
- jeton présent mais illisible : ``/login?draco=invalide``
|
||||
explicite ; jeton absent : formulaire nu inchangé en
|
||||
0.46.10, nommé ``draco=absent`` depuis la 0.46.11 (ronde
|
||||
2 : plus aucune sortie nue dans la chaîne d'entrée) ;
|
||||
- gardes : un sub de nom DIFFÉRENT n'absorbe toujours aucun
|
||||
compte (#145 intact) ; le JIT ordinaire est inchangé quand
|
||||
aucun homonyme n'existe ; la re-liaison exige les deux
|
||||
preuves et le CSRF.
|
||||
"""
|
||||
|
||||
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-rattachement-04610"
|
||||
SECRET_FAUX = "secret-rattachement-DIVERGENT"
|
||||
|
||||
SUB_ACTUEL = "rat-sub-actuel-bruno"
|
||||
SUB_ANCIEN = "rat-sub-ancien-bruno"
|
||||
SUB_INCONNU = "rat-sub-inconnu"
|
||||
|
||||
|
||||
def _jeton(sub, nom="bruno", 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ôle « utilisateur » par défaut."""
|
||||
def faux_get(url, headers=None, timeout=None):
|
||||
sub = _sub_depuis_cookie((headers or {}).get("Cookie", ""))
|
||||
return _Reponse(200, {
|
||||
"app": "kanbante", "sub": sub, "role": "utilisateur",
|
||||
"explicite": True, "ttl_secondes": 60,
|
||||
})
|
||||
|
||||
monkeypatch.setattr(httpx, "get", faux_get)
|
||||
return {}
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def instance_bruno(monkeypatch, tmp_path, fake_gitea, faux_hub):
|
||||
"""Instance comme celle de Bruno : amorçage « bruno » (admin,
|
||||
mot de passe local connu) + une membre « marie » — donc
|
||||
multi-utilisateurs : l'adoption d'amorçage (#145) ne peut
|
||||
pas jouer, seul le chemin testé décide."""
|
||||
monkeypatch.setenv("KANBANTE_DB_PATH", str(tmp_path / "bruno.db"))
|
||||
monkeypatch.setenv("KANBANTE_AUTH_USER", "bruno")
|
||||
monkeypatch.setenv("KANBANTE_AUTH_PASSWORD", "mdp-local-bruno")
|
||||
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 and users[0]["username"] == "bruno"
|
||||
bruno = users[0]
|
||||
marie_id = models.create_user(
|
||||
"marie", accounts.hash_password("mdp-marie"),
|
||||
role="member", display_name="Marie Test")
|
||||
yield client, bruno, models.get_user(marie_id)
|
||||
draco._revoked_cache.clear()
|
||||
|
||||
|
||||
def _pont(client, sub, nom="bruno", secret=SECRET):
|
||||
client.cookies.set("draco_session", _jeton(sub, nom, secret))
|
||||
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 ""
|
||||
|
||||
|
||||
def _login_natif(client, username, password):
|
||||
token = _csrf_via_login(client)
|
||||
return client.post(
|
||||
"/login",
|
||||
data={"username": username, "password": password,
|
||||
"next": "/", "csrf_token": token},
|
||||
follow_redirects=False,
|
||||
)
|
||||
|
||||
|
||||
# ── Cas réel A : homonyme sans lien → rattachement ───────────
|
||||
|
||||
def test_homonyme_sans_lien_rattache_et_sert_son_compte(instance_bruno):
|
||||
client, bruno, _marie = instance_bruno
|
||||
r = _pont(client, SUB_ACTUEL, "bruno")
|
||||
assert r.status_code == 303 and r.headers["location"] == "/"
|
||||
# Aucun clone : toujours deux comptes, et le lien est sur
|
||||
# l'admin « bruno » lui-même.
|
||||
assert models.count_users() == 2
|
||||
assert models.get_user_by_username("bruno-2") is None
|
||||
lie = models.get_user_by_draco(SUB_ACTUEL)
|
||||
assert lie is not None and lie["id"] == bruno["id"]
|
||||
assert lie["role"] == "admin"
|
||||
assert _profil_username(client) == "bruno"
|
||||
|
||||
|
||||
# ── Cas réel B : homonyme lié à un autre sub → conflit ───────
|
||||
|
||||
def test_homonyme_lie_autre_sub_conflit_explicite_sans_clone(instance_bruno):
|
||||
client, bruno, _marie = instance_bruno
|
||||
models.update_user(bruno["id"], draco_sub=SUB_ANCIEN)
|
||||
r = _pont(client, SUB_ACTUEL, "bruno")
|
||||
assert r.status_code == 303
|
||||
assert "draco=conflit" in r.headers["location"]
|
||||
assert "kanbante_session" not in r.headers.get("set-cookie", "")
|
||||
# Ni rattachement ni clone : l'état est exactement l'initial.
|
||||
assert models.count_users() == 2
|
||||
assert models.get_user(bruno["id"])["draco_sub"] == SUB_ANCIEN
|
||||
assert models.get_user_by_draco(SUB_ACTUEL) is None
|
||||
# Le formulaire explique la sortie (double preuve).
|
||||
r = client.get("/login?draco=conflit")
|
||||
assert r.status_code == 200
|
||||
assert "relié à une autre" in r.text
|
||||
assert "re-liaison" in r.text
|
||||
|
||||
|
||||
# ── Cas réel D : jeton présent illisible → signalé ───────────
|
||||
|
||||
def test_jeton_present_illisible_signale_invalide(instance_bruno):
|
||||
client, _bruno, _marie = instance_bruno
|
||||
r = _pont(client, SUB_ACTUEL, "bruno", secret=SECRET_FAUX)
|
||||
assert r.status_code == 303
|
||||
assert "draco=invalide" in r.headers["location"]
|
||||
assert "kanbante_session" not in r.headers.get("set-cookie", "")
|
||||
r = client.get("/login?draco=invalide")
|
||||
assert r.status_code == 200
|
||||
assert "Le jeton de la suite" in r.text and "validé" in r.text
|
||||
|
||||
|
||||
def test_jeton_absent_formulaire_nu_inchange(instance_bruno):
|
||||
# Contrat 0.46.10 : jeton absent → formulaire, rien d'autre.
|
||||
# La 0.46.11 (ronde 2) nomme aussi CET échec : la
|
||||
# destination reste le formulaire, mais la redirection porte
|
||||
# draco=absent — le pont ne produit plus de sortie nue,
|
||||
# pour que « le bouton SSO me ramène au formulaire » soit
|
||||
# toujours explicable à l'écran.
|
||||
client, _bruno, _marie = instance_bruno
|
||||
r = client.get("/auth/draco", follow_redirects=False)
|
||||
assert r.status_code == 303
|
||||
assert r.headers["location"].startswith("/login?")
|
||||
assert "draco=absent" in r.headers["location"]
|
||||
|
||||
|
||||
# ── Re-liaison par double preuve ─────────────────────────────
|
||||
|
||||
def test_reliage_apres_login_local_compte_lie_ancien_sub(instance_bruno):
|
||||
client, bruno, _marie = instance_bruno
|
||||
models.update_user(bruno["id"], draco_sub=SUB_ANCIEN)
|
||||
# Cookie draco du sub ACTUEL présent pendant la connexion
|
||||
# locale par mot de passe : la proposition suit la session.
|
||||
client.cookies.set("draco_session", _jeton(SUB_ACTUEL, "bruno"))
|
||||
r = _login_natif(client, "bruno", "mdp-local-bruno")
|
||||
assert r.status_code == 303
|
||||
assert r.headers["location"].startswith("/auth/draco/relier")
|
||||
# La page nomme les deux identités et le geste.
|
||||
r = client.get(r.headers["location"])
|
||||
assert r.status_code == 200
|
||||
assert "bruno" in r.text and "Relier mon compte" in r.text
|
||||
# Le geste réécrit le lien ; le pont sert ensuite CE compte.
|
||||
token = client.cookies.get("kanbante_csrf") or ""
|
||||
r = client.post(
|
||||
"/auth/draco/relier",
|
||||
data={"next": "/", "csrf_token": token},
|
||||
follow_redirects=False,
|
||||
)
|
||||
assert r.status_code == 303 and r.headers["location"] == "/"
|
||||
assert models.get_user(bruno["id"])["draco_sub"] == SUB_ACTUEL
|
||||
client.cookies.delete("kanbante_session")
|
||||
r = _pont(client, SUB_ACTUEL, "bruno")
|
||||
assert r.status_code == 303 and r.headers["location"] == "/"
|
||||
assert _profil_username(client) == "bruno"
|
||||
|
||||
|
||||
def test_reliage_retire_le_sub_a_son_detenteur(instance_bruno):
|
||||
client, bruno, marie = instance_bruno
|
||||
# Le sub actuel est détenu par marie ; bruno n'a aucun lien.
|
||||
models.update_user(marie["id"], draco_sub=SUB_ACTUEL)
|
||||
client.cookies.set("draco_session", _jeton(SUB_ACTUEL, "bruno"))
|
||||
r = _login_natif(client, "bruno", "mdp-local-bruno")
|
||||
assert r.status_code == 303
|
||||
assert r.headers["location"].startswith("/auth/draco/relier")
|
||||
token = client.cookies.get("kanbante_csrf") or ""
|
||||
r = client.post(
|
||||
"/auth/draco/relier",
|
||||
data={"next": "/", "csrf_token": token},
|
||||
follow_redirects=False,
|
||||
)
|
||||
assert r.status_code == 303
|
||||
assert models.get_user(marie["id"])["draco_sub"] is None
|
||||
assert models.get_user(bruno["id"])["draco_sub"] == SUB_ACTUEL
|
||||
|
||||
|
||||
def test_reliage_exige_les_deux_preuves_et_le_csrf(instance_bruno):
|
||||
client, bruno, _marie = instance_bruno
|
||||
models.update_user(bruno["id"], draco_sub=SUB_ANCIEN)
|
||||
# Sans session native : la page n'existe pas pour un visiteur
|
||||
# (le middleware renvoie un navigateur au formulaire).
|
||||
r = client.get("/auth/draco/relier", follow_redirects=False,
|
||||
headers={"Accept": "text/html"})
|
||||
assert r.status_code == 303
|
||||
assert r.headers["location"].startswith("/login")
|
||||
# Session native mais AUCUN cookie draco : pas de
|
||||
# désalignement, la page renvoie à la destination.
|
||||
r = _login_natif(client, "bruno", "mdp-local-bruno")
|
||||
assert r.status_code == 303 and r.headers["location"] == "/"
|
||||
r = client.get("/auth/draco/relier", follow_redirects=False)
|
||||
assert r.status_code == 303 and r.headers["location"] == "/"
|
||||
# Double preuve réunie mais CSRF absent : refus, lien intact.
|
||||
client.cookies.set("draco_session", _jeton(SUB_ACTUEL, "bruno"))
|
||||
r = client.post(
|
||||
"/auth/draco/relier",
|
||||
data={"next": "/", "csrf_token": "faux"},
|
||||
follow_redirects=False,
|
||||
)
|
||||
assert r.status_code == 403
|
||||
assert models.get_user(bruno["id"])["draco_sub"] == SUB_ANCIEN
|
||||
|
||||
|
||||
# ── Gardes : JIT ordinaire et non-absorption ─────────────────
|
||||
|
||||
def test_jit_inchange_quand_aucun_homonyme(instance_bruno):
|
||||
client, _bruno, _marie = instance_bruno
|
||||
r = _pont(client, SUB_INCONNU, "Alice Exemple")
|
||||
assert r.status_code == 303 and r.headers["location"] == "/"
|
||||
cree = models.get_user_by_draco(SUB_INCONNU)
|
||||
assert cree is not None and cree["username"] == "alice-exemple"
|
||||
assert cree["role"] == "member"
|
||||
assert _profil_username(client) == "alice-exemple"
|
||||
|
||||
|
||||
def test_nom_different_n_absorbe_aucun_compte(instance_bruno):
|
||||
client, bruno, _marie = instance_bruno
|
||||
r = _pont(client, SUB_INCONNU, "Mario Frère")
|
||||
assert r.status_code == 303 and r.headers["location"] == "/"
|
||||
# L'admin « bruno » n'est ni lié ni servi : un JIT propre.
|
||||
assert models.get_user(bruno["id"])["draco_sub"] is None
|
||||
cree = models.get_user_by_draco(SUB_INCONNU)
|
||||
assert cree is not None and cree["id"] != bruno["id"]
|
||||
assert _profil_username(client) == cree["username"]
|
||||
+163
-8
@@ -5,9 +5,20 @@ Le cookie émis par ObsiGate (ACC-3.1) est vérifié localement
|
||||
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 est l'admin d'amorçage,
|
||||
auquel le premier jeton valide se lie (cas d'amorçage documenté).
|
||||
Sans DRACO_SESSION_SECRET, le pont renvoie simplement au login.
|
||||
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 est inerte : depuis la
|
||||
0.46.11, un cookie présenté dans cet état est signalé
|
||||
(draco=inactif) au lieu du retour nu historique — c'était le
|
||||
cas réel du conteneur kanbante-dev de Bruno (ronde 2 du
|
||||
chantier SSO « bruno ») : cookie valide lu par les autres
|
||||
applications, bouton SSO rendu, et retour au formulaire sans
|
||||
session ni message.
|
||||
"""
|
||||
|
||||
import base64
|
||||
@@ -20,7 +31,7 @@ import pytest
|
||||
from fastapi.testclient import TestClient
|
||||
|
||||
import app.main as main
|
||||
from app import draco
|
||||
from app import draco, hub_roles
|
||||
|
||||
SECRET = "secret-partage-de-test"
|
||||
|
||||
@@ -61,9 +72,16 @@ def test_verify_token(monkeypatch):
|
||||
|
||||
|
||||
def test_pont_sans_cookie_vers_login(client_sso):
|
||||
# Depuis la 0.46.11 : même destination (le formulaire),
|
||||
# mais l'échec du parcours est NOMMÉ (draco=absent) — le
|
||||
# pont ne produit plus aucune redirection nue.
|
||||
r = client_sso.get("/auth/draco", follow_redirects=False)
|
||||
assert r.status_code == 303
|
||||
assert r.headers["location"] == "/login"
|
||||
assert r.headers["location"].startswith("/login?")
|
||||
assert "draco=absent" in r.headers["location"]
|
||||
r2 = client_sso.get(r.headers["location"], follow_redirects=False)
|
||||
assert r2.status_code == 200
|
||||
assert "Aucune session de la suite" in r2.text
|
||||
|
||||
|
||||
def test_pont_cookie_valide_ouvre_la_session(client_sso):
|
||||
@@ -77,26 +95,104 @@ def test_pont_cookie_valide_ouvre_la_session(client_sso):
|
||||
|
||||
|
||||
def test_pont_cookie_falsifie_vers_login(client_sso):
|
||||
# Depuis la 0.46.10 : un jeton PRÉSENT mais illisible n'est
|
||||
# plus ramené au formulaire nu — l'échec est explicite
|
||||
# (draco=invalide, message affiché par la page de connexion).
|
||||
# La 0.46.11 a fermé les deux sorties nues restantes :
|
||||
# jeton absent (draco=absent) et service draco inerte
|
||||
# (draco=inactif, test_pont_inerte_sans_secret).
|
||||
client_sso.cookies.set("draco_session", _jeton(secret="mauvais"))
|
||||
r = client_sso.get("/auth/draco", follow_redirects=False)
|
||||
assert r.headers["location"] == "/login"
|
||||
assert r.headers["location"].startswith("/login?")
|
||||
assert "draco=invalide" in r.headers["location"]
|
||||
|
||||
|
||||
def test_pont_jeton_revoque_refuse(client_sso):
|
||||
# Même contrat 0.46.10 : refusé, et signalé comme invalide.
|
||||
draco._revoked_cache["jti-revoque"] = int(time.time()) + 3600
|
||||
client_sso.cookies.set("draco_session", _jeton(jti="jti-revoque"))
|
||||
r = client_sso.get("/auth/draco", follow_redirects=False)
|
||||
assert r.headers["location"] == "/login"
|
||||
assert r.headers["location"].startswith("/login?")
|
||||
assert "draco=invalide" in r.headers["location"]
|
||||
|
||||
|
||||
def test_pont_inerte_sans_secret(monkeypatch, fake_gitea):
|
||||
# LE cas réel de la ronde 2 (conteneur kanbante-dev sans
|
||||
# DRACO_SESSION_SECRET) : avant la 0.46.11, cette réponse
|
||||
# était « /login » NU — aucune session, aucun message,
|
||||
# pendant que le navigateur présentait un cookie valide.
|
||||
# Désormais : draco=inactif, et le formulaire nomme le
|
||||
# défaut de configuration du service.
|
||||
monkeypatch.setenv("KANBANTE_AUTH_USER", "bruno")
|
||||
monkeypatch.setenv("KANBANTE_AUTH_PASSWORD", "motdepasse")
|
||||
monkeypatch.delenv("DRACO_SESSION_SECRET", raising=False)
|
||||
with TestClient(main.app) as client:
|
||||
client.cookies.set("draco_session", _jeton())
|
||||
r = client.get("/auth/draco", follow_redirects=False)
|
||||
assert r.headers["location"] == "/login"
|
||||
assert r.status_code == 303
|
||||
assert "draco=inactif" in r.headers["location"]
|
||||
r2 = client.get(r.headers["location"], follow_redirects=False)
|
||||
assert r2.status_code == 200
|
||||
assert "n'est pas active sur ce service" in \
|
||||
r2.text.replace("'", "'")
|
||||
|
||||
|
||||
def test_entree_page_cookie_present_mais_service_inerte(
|
||||
monkeypatch, fake_gitea):
|
||||
# Même état, autre entrée : une PAGE protégée demandée avec
|
||||
# le cookie — le middleware signale draco=inactif au lieu du
|
||||
# formulaire muet (0.46.11).
|
||||
monkeypatch.setenv("KANBANTE_AUTH_USER", "bruno")
|
||||
monkeypatch.setenv("KANBANTE_AUTH_PASSWORD", "motdepasse")
|
||||
monkeypatch.delenv("DRACO_SESSION_SECRET", raising=False)
|
||||
with TestClient(main.app) as client:
|
||||
client.headers["Accept"] = "text/html"
|
||||
client.cookies.set("draco_session", _jeton())
|
||||
r = client.get("/", follow_redirects=False)
|
||||
assert r.status_code == 303
|
||||
assert "draco=inactif" in r.headers["location"]
|
||||
|
||||
|
||||
# ── Registre des rôles : « aucun » ne verrouille que décidé ──
|
||||
|
||||
def test_role_aucun_non_explicite_ne_verrouille_pas(
|
||||
client_sso, monkeypatch):
|
||||
# Le registre répond « aucun » mais dit lui-même que ce
|
||||
# n'est PAS une décision de l'administrateur (défaut) :
|
||||
# l'entrée ordinaire suit — session ouverte (0.46.11).
|
||||
monkeypatch.setattr(hub_roles, "role_pour", lambda *a, **k: "aucun")
|
||||
monkeypatch.setattr(
|
||||
hub_roles, "explicite_pour", lambda *a, **k: False)
|
||||
client_sso.cookies.set("draco_session", _jeton())
|
||||
r = client_sso.get("/auth/draco", follow_redirects=False)
|
||||
assert r.status_code == 303
|
||||
assert r.headers["location"] == "/"
|
||||
assert "kanbante_session" in r.headers.get("set-cookie", "")
|
||||
|
||||
|
||||
def test_role_aucun_explicite_verrouille_403(client_sso, monkeypatch):
|
||||
# Décision explicite de l'administrateur : le refus 403
|
||||
# historique s'applique, avec son message.
|
||||
monkeypatch.setattr(hub_roles, "role_pour", lambda *a, **k: "aucun")
|
||||
monkeypatch.setattr(
|
||||
hub_roles, "explicite_pour", lambda *a, **k: True)
|
||||
client_sso.cookies.set("draco_session", _jeton())
|
||||
r = client_sso.get("/auth/draco", follow_redirects=False)
|
||||
assert r.status_code == 403
|
||||
assert "registre des rôles" in r.text
|
||||
assert "kanbante_session" not in r.headers.get("set-cookie", "")
|
||||
|
||||
|
||||
def test_role_aucun_origine_inconnue_verrouille_403(
|
||||
client_sso, monkeypatch):
|
||||
# Réponse sans le drapeau « explicite » (registre ancien) :
|
||||
# comportement historique conservé — le refus s'applique.
|
||||
monkeypatch.setattr(hub_roles, "role_pour", lambda *a, **k: "aucun")
|
||||
monkeypatch.setattr(
|
||||
hub_roles, "explicite_pour", lambda *a, **k: None)
|
||||
client_sso.cookies.set("draco_session", _jeton())
|
||||
r = client_sso.get("/auth/draco", follow_redirects=False)
|
||||
assert r.status_code == 403
|
||||
|
||||
|
||||
def test_bouton_sso_sur_la_page_login(client_sso):
|
||||
@@ -117,3 +213,62 @@ def test_bouton_sso_par_configuration(client_sso, monkeypatch):
|
||||
assert r.status_code == 200
|
||||
assert "og-dev.dracodev.net/sso/authorize" in r.text
|
||||
assert "kanbante-dev.dracodev.net%2Fauth%2Fdraco" in r.text
|
||||
|
||||
|
||||
# ── Retour SSO navigateur : l'hôte de la requête fait foi ──────────
|
||||
# Correctif du constat dev du 2026-11-08 : le bouton servi en « -dev »
|
||||
# portait return_to sur le nom officiel parce que la configuration
|
||||
# explicite primait sur l'hôte de la requête dans la construction
|
||||
# du lien. Pour un aller-retour initié par un navigateur, l'hôte
|
||||
# public de la requête (motif fermé dracodev) prime désormais sur
|
||||
# toute la configuration (app.config.base_retour_navigateur).
|
||||
|
||||
def _env_retour_sso(monkeypatch):
|
||||
for nom in ("AGENT_EVENEMENTS_URL", "DRACO_AGENT_URL"):
|
||||
monkeypatch.delenv(nom, raising=False)
|
||||
|
||||
|
||||
def test_bouton_sso_dev_malgre_configuration_officielle(client_sso, monkeypatch):
|
||||
# Configuration « conteneur dev réel » : les adresses publiques
|
||||
# explicites portent les noms OFFICIELS, seule l'émettrice est
|
||||
# épinglée en -dev — avant le correctif, le bouton retombait
|
||||
# sur le nom officiel (le constat de Bruno).
|
||||
_env_retour_sso(monkeypatch)
|
||||
monkeypatch.setenv("AGENT_URL", "https://agent.dracodev.net")
|
||||
monkeypatch.setenv("KANBANTE_PUBLIC_URL",
|
||||
"https://kanbante.dracodev.net")
|
||||
monkeypatch.setenv("DRACO_SSO_URL", "https://og-dev.dracodev.net")
|
||||
r = client_sso.get("/login", headers={"Host": "kanbante-dev.dracodev.net"})
|
||||
assert r.status_code == 200
|
||||
assert ("https://og-dev.dracodev.net/sso/authorize"
|
||||
"?return_to=https%3A%2F%2Fkanbante-dev.dracodev.net"
|
||||
"%2Fauth%2Fdraco") in r.text
|
||||
assert ("return_to=https%3A%2F%2Fkanbante.dracodev.net"
|
||||
"%2Fauth%2Fdraco") not in r.text
|
||||
|
||||
|
||||
def test_bouton_sso_prod_reste_officiel(client_sso, monkeypatch):
|
||||
# Régression prod : servi sur le nom officiel, le retour reste
|
||||
# le nom officiel.
|
||||
_env_retour_sso(monkeypatch)
|
||||
monkeypatch.setenv("AGENT_URL", "https://agent.dracodev.net")
|
||||
monkeypatch.setenv("DRACO_SSO_URL", "https://og.dracodev.net")
|
||||
r = client_sso.get("/login", headers={"Host": "kanbante.dracodev.net"})
|
||||
assert r.status_code == 200
|
||||
assert ("https://og.dracodev.net/sso/authorize"
|
||||
"?return_to=https%3A%2F%2Fkanbante.dracodev.net"
|
||||
"%2Fauth%2Fdraco") in r.text
|
||||
|
||||
|
||||
def test_bouton_sso_hors_motif_chaine_inchangee(client_sso, monkeypatch):
|
||||
# Hôte hors motif (LAN) : la chaîne de configuration décide,
|
||||
# comme avant le correctif.
|
||||
_env_retour_sso(monkeypatch)
|
||||
monkeypatch.setenv("KANBANTE_PUBLIC_URL",
|
||||
"https://kanbante.dracodev.net")
|
||||
monkeypatch.setenv("DRACO_SSO_URL", "https://og.dracodev.net")
|
||||
r = client_sso.get("/login", headers={"Host": "192.168.30.101:8081"})
|
||||
assert r.status_code == 200
|
||||
assert ("https://og.dracodev.net/sso/authorize"
|
||||
"?return_to=https%3A%2F%2Fkanbante.dracodev.net"
|
||||
"%2Fauth%2Fdraco") in r.text
|
||||
|
||||
@@ -0,0 +1,203 @@
|
||||
"""Entrée SSO automatique sans session locale (0.46.8).
|
||||
|
||||
Chantier « entrée SSO de bout en bout » — écart constaté par
|
||||
Bruno en test réel le 2026-11-08 : arrivé chez Kanbante avec une
|
||||
session centrale valide (cookie ``draco_session``) mais aucune
|
||||
session locale, l'application servait son formulaire de connexion
|
||||
comme si le cookie n'existait pas. Attendu : à l'arrivée sur une
|
||||
page, passage automatique par le pont ``/auth/draco`` et service
|
||||
de l'application connectée au compte désigné par le cookie.
|
||||
|
||||
Couvert : redirection du middleware vers le pont (compte lié et
|
||||
création JIT), chaîne complète jusqu'à la session ouverte, API
|
||||
jamais redirigées, absence de cookie et cookie invalide
|
||||
inchangés, rôle « aucun » (le pont tranche : 403, pas de boucle),
|
||||
échec de résolution signalé au formulaire (``draco=echec``, pas
|
||||
d'échec silencieux), et identité de SESSION dans la barre
|
||||
commune (le nom du compte connecté, pas l'opérateur).
|
||||
|
||||
Montage repris de tests/test_coherence_identite.py.
|
||||
"""
|
||||
|
||||
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, hub_roles, models
|
||||
|
||||
SECRET = "entree-test"
|
||||
|
||||
SUB_LIE = "ent-sub-lie"
|
||||
SUB_INCONNU = "ent-sub-inconnu"
|
||||
SUB_INACTIF = "ent-sub-inactif"
|
||||
NOMS = ("ent-lie", "ent-inactif", "ent-inconnu-test")
|
||||
|
||||
|
||||
def _jeton(sub, 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": "Testeur Test", "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():
|
||||
with models.get_db() as conn:
|
||||
ids = [r[0] for r in conn.execute(
|
||||
"SELECT id FROM users WHERE username IN ({})".format(
|
||||
",".join("?" * len(NOMS))), NOMS).fetchall()]
|
||||
ids += [r[0] for r in conn.execute(
|
||||
"SELECT id FROM users WHERE draco_sub IN (?, ?, ?)",
|
||||
(SUB_LIE, SUB_INCONNU, SUB_INACTIF)).fetchall()]
|
||||
for uid in ids:
|
||||
conn.execute("DELETE FROM users WHERE id = ?", (uid,))
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def client_ent(monkeypatch, fake_gitea):
|
||||
monkeypatch.setenv("KANBANTE_AUTH_USER", "operateur")
|
||||
monkeypatch.setenv("KANBANTE_AUTH_PASSWORD", "motdepasse")
|
||||
monkeypatch.setenv("DRACO_SESSION_SECRET", SECRET)
|
||||
monkeypatch.setattr(draco, "_refresh_revocations", lambda: None)
|
||||
monkeypatch.setattr(hub_roles, "role_pour", lambda *a, **k: None)
|
||||
draco._revoked_cache.clear()
|
||||
_nettoyer()
|
||||
models.create_user(
|
||||
"ent-lie", accounts.hash_password("local-lie"),
|
||||
role="member", draco_sub=SUB_LIE)
|
||||
with models.get_db() as conn:
|
||||
conn.execute(
|
||||
"UPDATE users SET display_name = 'Testeur Test' "
|
||||
"WHERE username = 'ent-lie'")
|
||||
inactif_id = models.create_user(
|
||||
"ent-inactif", accounts.hash_password("local-inactif"),
|
||||
role="member", draco_sub=SUB_INACTIF)
|
||||
models.update_user(inactif_id, active=False)
|
||||
with TestClient(main.app) as client:
|
||||
# Le TestClient doit parler comme un navigateur : sans
|
||||
# Accept text/html, le middleware classe la requête en
|
||||
# cliente d'API (401) — c'est l'en-tête, pas le correctif,
|
||||
# qui décide de la famille de la requête.
|
||||
client.headers["Accept"] = (
|
||||
"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8")
|
||||
yield client
|
||||
_nettoyer()
|
||||
draco._revoked_cache.clear()
|
||||
|
||||
|
||||
# ── Entrée automatique par le pont ───────────────────────────────
|
||||
|
||||
def test_page_sans_session_cookie_valide_renvoyee_au_pont(client_ent):
|
||||
client_ent.cookies.set("draco_session", _jeton(SUB_LIE))
|
||||
r = client_ent.get("/", follow_redirects=False)
|
||||
assert r.status_code == 303
|
||||
assert r.headers["location"].startswith("/auth/draco")
|
||||
|
||||
|
||||
def test_chaine_complete_session_ouverte_pour_le_compte_du_cookie(client_ent):
|
||||
client_ent.cookies.set("draco_session", _jeton(SUB_LIE))
|
||||
r = client_ent.get("/", follow_redirects=False)
|
||||
pont = r.headers["location"]
|
||||
r2 = client_ent.get(pont, follow_redirects=False)
|
||||
assert r2.status_code == 303
|
||||
assert "kanbante_session" in r2.headers.get("set-cookie", "")
|
||||
r3 = client_ent.get("/", follow_redirects=False)
|
||||
assert r3.status_code == 200
|
||||
|
||||
|
||||
def test_page_sans_session_sub_inconnu_jit_par_le_pont(client_ent):
|
||||
client_ent.cookies.set("draco_session", _jeton(SUB_INCONNU))
|
||||
r = client_ent.get("/", follow_redirects=False)
|
||||
assert r.headers["location"].startswith("/auth/draco")
|
||||
r2 = client_ent.get(r.headers["location"], follow_redirects=False)
|
||||
assert r2.status_code == 303
|
||||
assert models.get_user_by_draco(SUB_INCONNU) is not None
|
||||
|
||||
|
||||
def test_api_sans_session_cookie_valide_reste_401(client_ent):
|
||||
client_ent.cookies.set("draco_session", _jeton(SUB_LIE))
|
||||
r = client_ent.get("/api/projects", follow_redirects=False)
|
||||
assert r.status_code == 401
|
||||
|
||||
|
||||
# ── Régressions : sans session centrale, rien ne change ─────────
|
||||
|
||||
def test_sans_cookie_formulaire_comme_avant(client_ent):
|
||||
r = client_ent.get("/", follow_redirects=False)
|
||||
assert r.status_code == 303
|
||||
assert r.headers["location"].startswith("/login?next=")
|
||||
|
||||
|
||||
def test_cookie_invalide_formulaire_comme_avant(client_ent):
|
||||
client_ent.cookies.set("draco_session", _jeton(SUB_LIE, secret="mauvais"))
|
||||
r = client_ent.get("/", follow_redirects=False)
|
||||
assert r.status_code == 303
|
||||
assert r.headers["location"].startswith("/login?next=")
|
||||
|
||||
|
||||
def test_cookie_invalide_signale_au_formulaire(client_ent):
|
||||
# 0.46.11 : la destination reste le formulaire (contrat du
|
||||
# test précédent inchangé), mais l'échec du parcours central
|
||||
# est NOMMÉ — draco=invalide, traduit en message par la page
|
||||
# de connexion. Avant : retour muet, indistinguable d'une
|
||||
# absence de session centrale.
|
||||
client_ent.cookies.set(
|
||||
"draco_session", _jeton(SUB_LIE, secret="mauvais"))
|
||||
r = client_ent.get("/", follow_redirects=False)
|
||||
assert r.status_code == 303
|
||||
assert "draco=invalide" in r.headers["location"]
|
||||
r2 = client_ent.get(r.headers["location"], follow_redirects=False)
|
||||
assert r2.status_code == 200
|
||||
assert "n'a pas pu être validé" in r2.text.replace("'", "'")
|
||||
|
||||
|
||||
def test_page_login_jamais_interceptee(client_ent):
|
||||
client_ent.cookies.set("draco_session", _jeton(SUB_LIE))
|
||||
r = client_ent.get("/login", follow_redirects=False)
|
||||
assert r.status_code == 200
|
||||
|
||||
|
||||
# ── Gardes du pont : refus explicite, échec signalé ─────────────
|
||||
|
||||
def test_role_aucun_le_pont_tranche_403_sans_boucle(client_ent, monkeypatch):
|
||||
monkeypatch.setattr(hub_roles, "role_pour", lambda *a, **k: "aucun")
|
||||
client_ent.cookies.set("draco_session", _jeton(SUB_LIE))
|
||||
r = client_ent.get("/", follow_redirects=False)
|
||||
assert r.headers["location"].startswith("/auth/draco")
|
||||
r2 = client_ent.get(r.headers["location"], follow_redirects=False)
|
||||
assert r2.status_code == 403
|
||||
|
||||
|
||||
def test_echec_de_resolution_signale_au_formulaire(client_ent):
|
||||
client_ent.cookies.set("draco_session", _jeton(SUB_INACTIF))
|
||||
r = client_ent.get("/auth/draco", follow_redirects=False)
|
||||
assert r.status_code == 303
|
||||
assert "draco=echec" in r.headers["location"]
|
||||
r2 = client_ent.get(r.headers["location"], follow_redirects=False)
|
||||
assert r2.status_code == 200
|
||||
# L'apostrophe du message est échappée par Jinja (n') :
|
||||
# on cherche le fragment invariant.
|
||||
assert "pas abouti pour ce compte" in r2.text
|
||||
|
||||
|
||||
# ── Barre commune : l'identité de session, pas l'opérateur ──────
|
||||
|
||||
def test_barre_affiche_le_nom_du_compte_de_session(client_ent):
|
||||
client_ent.cookies.set(
|
||||
"kanbante_session", main._make_session("ent-lie"))
|
||||
r = client_ent.get("/", follow_redirects=False)
|
||||
assert r.status_code == 200
|
||||
assert 'user: "Testeur Test"' in r.text
|
||||
assert 'user: "O"' not in r.text # initiale de l'opérateur
|
||||
@@ -1,185 +0,0 @@
|
||||
"""HUB-21 — réglages généraux du Hub consommés par Kanbante.
|
||||
|
||||
Propagation du pilote TikTak 0.61.22 : client serveur
|
||||
``app.hub_reglages`` (cache 60 s, horodatage posé avant l'appel,
|
||||
repli intégral sur les défauts actuels), bannière d'annonce dans
|
||||
le partiel ``_header.html`` (texte échappé par l'autoescape
|
||||
Jinja) et drapeau ``recherche_partout`` rendu en attribut
|
||||
``data-recherche-partout`` de la page /recherche (la logique JS
|
||||
associée est couverte par tests/recherche.test.js).
|
||||
``domaine_defaut`` n'est pas appliqué : Kanbante n'a pas de
|
||||
notion de domaine propre (voir le docstring du module).
|
||||
"""
|
||||
|
||||
import httpx
|
||||
import pytest
|
||||
|
||||
from app import hub_reglages
|
||||
|
||||
|
||||
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_reglages._reset_cache()
|
||||
yield
|
||||
hub_reglages._reset_cache()
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def faux_hub(monkeypatch):
|
||||
"""Faux Hub des réglages : état pilotable + journal d'appels."""
|
||||
etat = {"reglages": None, "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"})
|
||||
return _Reponse(200, etat["reglages"])
|
||||
|
||||
monkeypatch.setattr(httpx, "get", faux_get)
|
||||
return etat
|
||||
|
||||
|
||||
# ── Client : validation, contrat d'appel, résolution d'URL ──────────
|
||||
|
||||
def test_validation_forme_du_contrat():
|
||||
assert hub_reglages._valider({
|
||||
"recherche_partout": False, "banniere": "Maintenance dimanche",
|
||||
"domaine_defaut": "famille", "ttl_secondes": 60}) == {
|
||||
"recherche_partout": False, "banniere": "Maintenance dimanche",
|
||||
"domaine_defaut": "famille"}
|
||||
for charge in (
|
||||
None, "texte", ["x"], {},
|
||||
{"recherche_partout": "oui", "banniere": "", "domaine_defaut": None},
|
||||
{"recherche_partout": True, "banniere": 42, "domaine_defaut": None},
|
||||
{"recherche_partout": True, "banniere": "", "domaine_defaut": "travail"},
|
||||
):
|
||||
assert hub_reglages._valider(charge) is None, charge
|
||||
|
||||
|
||||
def test_appel_contrat_exact_et_cache(faux_hub):
|
||||
faux_hub["reglages"] = {
|
||||
"recherche_partout": False, "banniere": "Annonce A",
|
||||
"domaine_defaut": None, "ttl_secondes": 60}
|
||||
assert hub_reglages.banniere() == "Annonce A"
|
||||
assert hub_reglages.recherche_partout() is False
|
||||
assert len(faux_hub["appels"]) == 1 # cache 60 s
|
||||
appel = faux_hub["appels"][0]
|
||||
assert appel["url"] == "https://hub.dracodev.net/api/reglages/effectifs"
|
||||
assert appel["headers"]["Accept"] == "application/json"
|
||||
assert "Cookie" not in appel["headers"] # endpoint public
|
||||
assert appel["timeout"] == 2.0
|
||||
|
||||
|
||||
def test_url_hub_par_hote_dev(faux_hub):
|
||||
faux_hub["reglages"] = {
|
||||
"recherche_partout": True, "banniere": "", "domaine_defaut": None}
|
||||
hub_reglages.reglages_effectifs(hote="kanbante-dev.dracodev.net")
|
||||
assert faux_hub["appels"][0]["url"] == (
|
||||
"https://hub-dev.dracodev.net/api/reglages/effectifs")
|
||||
|
||||
|
||||
def test_ttl_expire_reconsulte(faux_hub):
|
||||
faux_hub["reglages"] = {
|
||||
"recherche_partout": True, "banniere": "Annonce A",
|
||||
"domaine_defaut": None}
|
||||
assert hub_reglages.banniere() == "Annonce A"
|
||||
hub_reglages._cache_fetched_at -= hub_reglages.CACHE_TTL + 1
|
||||
faux_hub["reglages"] = {
|
||||
"recherche_partout": True, "banniere": "Annonce B",
|
||||
"domaine_defaut": None}
|
||||
assert hub_reglages.banniere() == "Annonce B"
|
||||
assert len(faux_hub["appels"]) == 2
|
||||
|
||||
|
||||
def test_hub_muet_repli_defauts(faux_hub):
|
||||
faux_hub["mode"] = "panne"
|
||||
assert hub_reglages.reglages_effectifs() == hub_reglages.DEFAUTS
|
||||
hub_reglages._reset_cache()
|
||||
faux_hub["mode"] = "erreur500"
|
||||
assert hub_reglages.reglages_effectifs() == hub_reglages.DEFAUTS
|
||||
hub_reglages._reset_cache()
|
||||
faux_hub["mode"] = "ok"
|
||||
faux_hub["reglages"] = {"forme": "inattendue"}
|
||||
assert hub_reglages.reglages_effectifs() == hub_reglages.DEFAUTS
|
||||
assert hub_reglages.banniere() == ""
|
||||
assert hub_reglages.recherche_partout() is True
|
||||
|
||||
|
||||
def test_echec_ancien_cache_sans_rafale(faux_hub):
|
||||
faux_hub["reglages"] = {
|
||||
"recherche_partout": True, "banniere": "Annonce A",
|
||||
"domaine_defaut": None}
|
||||
assert hub_reglages.banniere() == "Annonce A"
|
||||
hub_reglages._cache_fetched_at -= hub_reglages.CACHE_TTL + 1
|
||||
faux_hub["mode"] = "panne" # Hub tombe
|
||||
assert hub_reglages.banniere() == "Annonce A" # ancien cache
|
||||
appels = len(faux_hub["appels"])
|
||||
assert hub_reglages.banniere() == "Annonce A"
|
||||
assert len(faux_hub["appels"]) == appels # pas de rafale
|
||||
|
||||
|
||||
# ── Intégration : bannière et drapeau dans les pages ────────────────
|
||||
|
||||
def test_banniere_presente_et_echappee(client, faux_hub):
|
||||
faux_hub["reglages"] = {
|
||||
"recherche_partout": True,
|
||||
"banniere": "Maintenance dimanche <b>gras</b> & cie",
|
||||
"domaine_defaut": None, "ttl_secondes": 60}
|
||||
r = client.get("/recherche")
|
||||
assert r.status_code == 200
|
||||
assert 'id="banniere-hub"' in r.text
|
||||
assert "Maintenance dimanche <b>gras</b> & cie" in r.text
|
||||
assert "kanbante_banniere_masquee" in r.text
|
||||
|
||||
|
||||
def test_banniere_absente_si_vide_ou_hub_muet(client, faux_hub):
|
||||
faux_hub["reglages"] = {
|
||||
"recherche_partout": True, "banniere": "", "domaine_defaut": "pro",
|
||||
"ttl_secondes": 60}
|
||||
r = client.get("/recherche")
|
||||
assert r.status_code == 200
|
||||
assert "banniere-hub" not in r.text
|
||||
hub_reglages._reset_cache()
|
||||
faux_hub["mode"] = "panne"
|
||||
r = client.get("/recherche")
|
||||
assert r.status_code == 200
|
||||
assert "banniere-hub" not in r.text
|
||||
|
||||
|
||||
def test_recherche_drapeau_rendu(client, faux_hub):
|
||||
faux_hub["reglages"] = {
|
||||
"recherche_partout": False, "banniere": "", "domaine_defaut": None,
|
||||
"ttl_secondes": 60}
|
||||
r = client.get("/recherche")
|
||||
assert r.status_code == 200
|
||||
assert 'data-recherche-partout="false"' in r.text
|
||||
hub_reglages._reset_cache()
|
||||
faux_hub["reglages"] = {
|
||||
"recherche_partout": True, "banniere": "", "domaine_defaut": None,
|
||||
"ttl_secondes": 60}
|
||||
r = client.get("/recherche")
|
||||
assert 'data-recherche-partout="true"' in r.text
|
||||
hub_reglages._reset_cache()
|
||||
faux_hub["mode"] = "panne" # Hub muet → défaut actif
|
||||
r = client.get("/recherche")
|
||||
assert 'data-recherche-partout="true"' in r.text
|
||||
|
||||
|
||||
def test_version_0_46_3():
|
||||
from pathlib import Path
|
||||
version = (Path(__file__).parent.parent / "VERSION").read_text().strip()
|
||||
assert version == "0.46.3"
|
||||
@@ -186,6 +186,40 @@ def test_client_reponses_illisibles_inconnues(monkeypatch):
|
||||
assert hub_roles.role_pour("c=1", "sub-f") is None
|
||||
|
||||
|
||||
# ── Drapeau « explicite » (0.46.11) ────────────────────────────
|
||||
|
||||
def test_explicite_transporte_depuis_la_reponse(monkeypatch):
|
||||
# Le drapeau voyage avec le rôle, servi par le même cache :
|
||||
# une seule consultation pour les deux lectures.
|
||||
appels = []
|
||||
|
||||
def faux_get(url, headers=None, timeout=None):
|
||||
appels.append(url)
|
||||
return _Reponse(200, {
|
||||
"app": "kanbante", "sub": "sub-g", "role": "aucun",
|
||||
"explicite": False, "ttl_secondes": 60,
|
||||
})
|
||||
|
||||
monkeypatch.setattr(httpx, "get", faux_get)
|
||||
cookie = f"draco_session={_jeton('sub-g')}"
|
||||
assert hub_roles.role_pour(cookie, "sub-g") == "aucun"
|
||||
assert hub_roles.explicite_pour(cookie, "sub-g") is False
|
||||
assert len(appels) == 1
|
||||
|
||||
|
||||
def test_explicite_absent_de_la_reponse_vaut_inconnu(monkeypatch):
|
||||
# Un registre qui ne dit pas le drapeau : rôle lu,
|
||||
# explicite inconnu (None) — le pont conserve alors son
|
||||
# comportement historique pour un « aucun ».
|
||||
def faux_get(url, headers=None, timeout=None):
|
||||
return _Reponse(200, {"role": "utilisateur"})
|
||||
|
||||
monkeypatch.setattr(httpx, "get", faux_get)
|
||||
cookie = f"draco_session={_jeton('sub-h')}"
|
||||
assert hub_roles.role_pour(cookie, "sub-h") == "utilisateur"
|
||||
assert hub_roles.explicite_pour(cookie, "sub-h") is None
|
||||
|
||||
|
||||
# ── Intégration : pont draco et garde /admin ─────────────────
|
||||
|
||||
def _nettoyer():
|
||||
|
||||
@@ -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