Compare commits
7
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
b7145e398d | ||
|
|
6b1e2491dd | ||
|
|
e4531488d0 | ||
|
|
f8f8af63e1 | ||
|
|
d89b35061b | ||
|
|
4cd203ba5c | ||
|
|
5ba9bca3a3 |
@@ -6,6 +6,14 @@ GITEA_TOKEN=
|
||||
KANBANTE_AUTH_USER=
|
||||
KANBANTE_AUTH_PASSWORD=
|
||||
KANBANTE_REQUIRE_AUTH=0
|
||||
# Porte centrale unique (désactivée par défaut ; activable aussi au
|
||||
# panneau d'administration, réglage « porte_centrale »)
|
||||
KANBANTE_PORTE_CENTRALE=0
|
||||
# Porte de secours administrateur (chemin discret /login/secours,
|
||||
# jamais proposé sur l'écran principal) — compte administrateur
|
||||
# local désigné, identifiants d'environnement uniquement :
|
||||
# KANBANTE_PORTE_SECOURS_USER=
|
||||
# KANBANTE_PORTE_SECOURS_PASSWORD=
|
||||
# Noms publics dracodev — défauts = noms OFFICIELS (prod).
|
||||
# Environnement dev : déclarer ici les noms en -dev, sans toucher au code.
|
||||
KANBANTE_PUBLIC_URL=https://kanbante.dracodev.net
|
||||
|
||||
@@ -1,3 +1,29 @@
|
||||
## 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.
|
||||
|
||||
@@ -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 » |
|
||||
|
||||
+36
-6
@@ -79,13 +79,26 @@ 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 ;
|
||||
# 2. amorçage CONDITIONNÉ (fusion #145, 0.46.5) : s'il n'existe
|
||||
# qu'UN seul compte et que c'est un admin actif sans liaison,
|
||||
# ce compte d'amorçage ne peut être adopté que si
|
||||
# a) le sub entrant est « administrateur » pour kanbante
|
||||
# au registre des rôles du Hub (app.hub_roles, rôle
|
||||
# transmis par l'appelant via ``role_hub`` — dans le
|
||||
# doute, registre muet ou rôle moindre, PAS d'adoption),
|
||||
# ou b) l'adoption est initiée depuis une session native
|
||||
# déjà authentifiée (``liaison_session_native=True`` :
|
||||
# l'utilisateur connecté lie explicitement son compte) ;
|
||||
# tout autre sub inconnu suit le parcours ordinaire (JIT ou
|
||||
# refus selon la surface), JAMAIS l'amorçage ;
|
||||
# 3. sinon, si provisionner=True : création JIT d'un compte
|
||||
# propre à cette identité (voir provision_draco_user).
|
||||
#
|
||||
# Avant la 0.46.5, l'étape 2 liait l'amorçage au PREMIER sub
|
||||
# valide de passage : sur une instance fraîche, un simple
|
||||
# utilisateur de la suite devenait l'administrateur local
|
||||
# (audit « compte partout » du 2026-11-06, carte fusion #145).
|
||||
#
|
||||
# Un sub inconnu ne désigne JAMAIS un compte existant non lié
|
||||
# (ni l'opérateur d'environnement, ni un compte dont le nom
|
||||
# ressemblerait au nom affiché draco) : la liaison d'un compte
|
||||
@@ -163,7 +176,12 @@ 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
|
||||
@@ -173,6 +191,15 @@ def resolve_draco_user(claims: dict | None, provisionner: bool = False) -> dict
|
||||
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,8 +213,11 @@ 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"])
|
||||
|
||||
@@ -11,6 +11,24 @@ Environment variables:
|
||||
KANBANTE_AUTH_USER Login username (with _PASSWORD: enables auth).
|
||||
KANBANTE_AUTH_PASSWORD Login password.
|
||||
KANBANTE_REQUIRE_AUTH "1" = refuse to serve if auth is not configured.
|
||||
KANBANTE_PORTE_CENTRALE "1" = active la « porte centrale unique »
|
||||
(0.46.6) : l'écran de connexion ne présente
|
||||
plus que l'entrée centrale (SSO ObsiGate)
|
||||
et le formulaire local est refusé. Défaut
|
||||
"0" (désactivé) ; surchargeable depuis le
|
||||
panneau d'administration (réglage
|
||||
``porte_centrale``, l'environnement amorce,
|
||||
le panneau gouverne).
|
||||
KANBANTE_PORTE_SECOURS_USER / KANBANTE_PORTE_SECOURS_PASSWORD
|
||||
Identifiants de la porte de secours
|
||||
administrateur (0.46.6) : LE compte
|
||||
administrateur local désigné, joignable
|
||||
par le chemin discret /login/secours
|
||||
(jamais proposé sur l'écran principal),
|
||||
y compris quand la porte centrale est
|
||||
active. Secrets d'environnement uniquement,
|
||||
jamais en base ni dans le panneau. Variables
|
||||
absentes = porte de secours désactivée.
|
||||
KANBANTE_SESSION_SECRET HMAC key for the login session cookie
|
||||
(default: derived from the credentials —
|
||||
rotating the password invalidates sessions).
|
||||
@@ -370,6 +388,9 @@ class Settings:
|
||||
auth_user: str = ""
|
||||
auth_password: str = ""
|
||||
require_auth: bool = False
|
||||
porte_centrale: bool = False
|
||||
porte_secours_user: str = ""
|
||||
porte_secours_password: str = ""
|
||||
active_window_days: int = 365
|
||||
cache_ttl: float = 30.0
|
||||
max_note_chars: int = 20_000
|
||||
@@ -456,6 +477,9 @@ def _env_settings() -> Settings:
|
||||
auth_user=os.getenv("KANBANTE_AUTH_USER", ""),
|
||||
auth_password=os.getenv("KANBANTE_AUTH_PASSWORD", ""),
|
||||
require_auth=_env_bool("KANBANTE_REQUIRE_AUTH", False),
|
||||
porte_centrale=_env_bool("KANBANTE_PORTE_CENTRALE", False),
|
||||
porte_secours_user=os.getenv("KANBANTE_PORTE_SECOURS_USER", ""),
|
||||
porte_secours_password=os.getenv("KANBANTE_PORTE_SECOURS_PASSWORD", ""),
|
||||
active_window_days=_env_int("KANBANTE_ACTIVE_WINDOW_DAYS", 365),
|
||||
cache_ttl=_env_float("KANBANTE_CACHE_TTL", 30.0),
|
||||
max_note_chars=_env_int("KANBANTE_MAX_NOTE_CHARS", 20_000),
|
||||
@@ -551,6 +575,11 @@ OVERRIDABLE_SETTINGS: dict[str, type] = {
|
||||
"capture_repo": str,
|
||||
"sync_labels": bool,
|
||||
"sync_gitea": bool,
|
||||
# Porte centrale unique (0.46.6) : booléen du panneau —
|
||||
# l'administrateur l'active/la désactive sans redémarrage.
|
||||
# Les identifiants de la porte de secours, eux, restent en
|
||||
# environnement (secrets, jamais surchargeables).
|
||||
"porte_centrale": bool,
|
||||
}
|
||||
|
||||
|
||||
|
||||
+186
-26
@@ -249,7 +249,7 @@ registry = connections_service.ForgeRegistry()
|
||||
SESSION_COOKIE = "kanbante_session"
|
||||
SESSION_DAYS = 7
|
||||
_PUBLIC_PATHS = ("/api/health", "/webhooks/gitea", "/api/capture", "/login",
|
||||
"/auth/draco")
|
||||
"/login/secours", "/auth/draco")
|
||||
|
||||
|
||||
def _session_secret() -> bytes:
|
||||
@@ -432,8 +432,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.
|
||||
@@ -536,11 +536,30 @@ def _safe_next(raw: str) -> str:
|
||||
return "/"
|
||||
|
||||
|
||||
def _ouvrir_session(username: str, next: str) -> RedirectResponse:
|
||||
"""Réponse de connexion native : session signée posée, redirection."""
|
||||
response = RedirectResponse(_safe_next(next), status_code=303)
|
||||
response.set_cookie(
|
||||
SESSION_COOKIE,
|
||||
_make_session(username),
|
||||
max_age=SESSION_DAYS * 86400,
|
||||
httponly=True,
|
||||
samesite="lax",
|
||||
)
|
||||
return response
|
||||
|
||||
|
||||
@app.get("/login")
|
||||
async def login_page(request: Request, next: str = "/"):
|
||||
if not get_settings().auth_enabled or _session_user(request) is not None:
|
||||
return RedirectResponse(_safe_next(next), status_code=303)
|
||||
return render(request, "login.html", next=_safe_next(next), error="")
|
||||
# Porte centrale (0.46.6) : en mode actif, le gabarit ne
|
||||
# présente que l'entrée centrale (lien SSO) — aucun champ
|
||||
# local (voir app/templates/login.html et docs/porte-centrale.md).
|
||||
return render(
|
||||
request, "login.html", next=_safe_next(next), error="",
|
||||
porte_centrale=bool(get_settings().porte_centrale),
|
||||
)
|
||||
|
||||
|
||||
@app.post("/login")
|
||||
@@ -559,6 +578,25 @@ async def login_submit(
|
||||
request, "login.html", status_code=403,
|
||||
next=_safe_next(next), error="Session expirée — réessaie.",
|
||||
)
|
||||
if settings.porte_centrale:
|
||||
# Porte centrale unique (0.46.6) : en mode actif, les
|
||||
# identifiants locaux ordinaires ne sont plus acceptés
|
||||
# sur ce formulaire — ni mot de passe de base, ni repli
|
||||
# d'environnement. Seules restent : l'entrée centrale
|
||||
# (SSO ObsiGate, ci-dessous sur l'écran) et, pour
|
||||
# l'administrateur désigné, la porte de secours discrète
|
||||
# (/login/secours, identifiants d'environnement — jamais
|
||||
# proposée ici). Les sessions déjà établies ne passent
|
||||
# pas par ce formulaire et ne sont pas touchées.
|
||||
return render(
|
||||
request, "login.html", status_code=403,
|
||||
next=_safe_next(next), porte_centrale=True,
|
||||
error=(
|
||||
"La porte centrale est active sur cette instance : "
|
||||
"la connexion locale est fermée. Utilise « Se "
|
||||
"connecter avec ObsiGate (SSO) » ci-dessous."
|
||||
),
|
||||
)
|
||||
from app import accounts as accounts_service
|
||||
|
||||
user = models.get_user_by_username(username)
|
||||
@@ -576,9 +614,33 @@ async def login_submit(
|
||||
if ok and user is not None and user["active"]:
|
||||
models.log_admin(user["id"], "login.env_fallback", username)
|
||||
if not ok:
|
||||
# Fusion #144 (part Kanbante) : l'échec ne doit plus être
|
||||
# une impasse muette pour un compte de la suite. Un compte
|
||||
# créé au Hub n'a pas de mot de passe local ici (il vit
|
||||
# chez ObsiGate) : le message suggère la voie centrale —
|
||||
# le bouton « Se connecter avec ObsiGate (SSO) » présent
|
||||
# sur ce même écran — au lieu du seul refus sec. Quand
|
||||
# l'identifiant ne correspond à aucun compte local (et
|
||||
# n'est pas l'opérateur d'environnement), le message le
|
||||
# dit explicitement : c'est le cas typique du compte
|
||||
# centralisé essayé dans le formulaire local.
|
||||
if user is None and username != settings.auth_user:
|
||||
erreur = (
|
||||
"Identifiants incorrects — aucun compte local ne "
|
||||
"correspond à cet identifiant. Si ton compte a été "
|
||||
"créé dans la suite Dracodev (au Hub), il n'a pas "
|
||||
"de mot de passe local ici : utilise « Se connecter "
|
||||
"avec ObsiGate (SSO) » ci-dessous."
|
||||
)
|
||||
else:
|
||||
erreur = (
|
||||
"Identifiants incorrects. Si tu te connectes avec "
|
||||
"un compte de la suite Dracodev, utilise plutôt "
|
||||
"« Se connecter avec ObsiGate (SSO) » ci-dessous."
|
||||
)
|
||||
return render(
|
||||
request, "login.html", status_code=401,
|
||||
next=_safe_next(next), error="Identifiants incorrects.",
|
||||
next=_safe_next(next), error=erreur,
|
||||
)
|
||||
if user is not None:
|
||||
models.update_user(
|
||||
@@ -587,8 +649,10 @@ async def login_submit(
|
||||
"%Y-%m-%d %H:%M:%S", time.gmtime()
|
||||
),
|
||||
)
|
||||
# First doubly-connected visit: link the draco identity
|
||||
# to this account (same mechanics as the other apps).
|
||||
# Première visite doublement connectée : la session
|
||||
# native vient d'être authentifiée par mot de passe —
|
||||
# lier l'identité draco à ce compte est la voie (b) de
|
||||
# liaison explicite de l'amorçage (fusion #145).
|
||||
from app import draco
|
||||
|
||||
claims = draco.claims_for(request)
|
||||
@@ -596,15 +660,88 @@ async def login_submit(
|
||||
sub = claims.get("sub")
|
||||
if sub and models.get_user_by_draco(sub) is None:
|
||||
models.update_user(user["id"], draco_sub=sub)
|
||||
response = RedirectResponse(_safe_next(next), status_code=303)
|
||||
response.set_cookie(
|
||||
SESSION_COOKIE,
|
||||
_make_session(username),
|
||||
max_age=SESSION_DAYS * 86400,
|
||||
httponly=True,
|
||||
samesite="lax",
|
||||
return _ouvrir_session(username, next)
|
||||
|
||||
|
||||
# ── Porte de secours administrateur (0.46.6) ──────────────────
|
||||
# Chemin discret /login/secours : jamais lié ni proposé sur
|
||||
# l'écran principal (ni en mode porte centrale, ni sinon).
|
||||
# Un seul compte, désigné par l'environnement :
|
||||
# KANBANTE_PORTE_SECOURS_USER / KANBANTE_PORTE_SECOURS_PASSWORD
|
||||
# (voir app/config.py). Le compte désigné doit être un
|
||||
# administrateur local actif (ou l'opérateur d'environnement) :
|
||||
# un membre désigné par erreur ne passe pas. Sans les deux
|
||||
# variables, la porte n'existe pas (404 sec, sans explication).
|
||||
|
||||
def _porte_secours_configuree(settings) -> bool:
|
||||
return bool(settings.porte_secours_user and settings.porte_secours_password)
|
||||
|
||||
|
||||
@app.get("/login/secours")
|
||||
async def login_secours_page(request: Request, next: str = "/"):
|
||||
settings = get_settings()
|
||||
if not settings.auth_enabled or _session_user(request) is not None:
|
||||
return RedirectResponse(_safe_next(next), status_code=303)
|
||||
if not _porte_secours_configuree(settings):
|
||||
return render(
|
||||
request, "error.html", status_code=404,
|
||||
message="Page introuvable.",
|
||||
)
|
||||
return render(
|
||||
request, "login.html", next=_safe_next(next), error="",
|
||||
mode_secours=True,
|
||||
)
|
||||
return response
|
||||
|
||||
|
||||
@app.post("/login/secours")
|
||||
async def login_secours_submit(
|
||||
request: Request,
|
||||
username: str = Form(""),
|
||||
password: str = Form(""),
|
||||
next: str = Form("/"),
|
||||
csrf_token: str = Form(""),
|
||||
):
|
||||
settings = get_settings()
|
||||
if not settings.auth_enabled:
|
||||
return RedirectResponse("/", status_code=303)
|
||||
if not _porte_secours_configuree(settings):
|
||||
return render(
|
||||
request, "error.html", status_code=404,
|
||||
message="Page introuvable.",
|
||||
)
|
||||
if not _csrf_valid(request, csrf_token):
|
||||
return render(
|
||||
request, "login.html", status_code=403, mode_secours=True,
|
||||
next=_safe_next(next), error="Session expirée — réessaie.",
|
||||
)
|
||||
identifiants_ok = secrets.compare_digest(
|
||||
username, settings.porte_secours_user
|
||||
) and secrets.compare_digest(password, settings.porte_secours_password)
|
||||
compte = (
|
||||
models.get_user_by_username(settings.porte_secours_user)
|
||||
if identifiants_ok
|
||||
else None
|
||||
)
|
||||
if compte is not None:
|
||||
admin_ok = bool(compte["active"]) and compte["role"] == "admin"
|
||||
else:
|
||||
# Pas de ligne en base : seul l'opérateur d'environnement
|
||||
# (administrateur synthétique) peut être le compte désigné.
|
||||
admin_ok = settings.porte_secours_user == settings.auth_user
|
||||
if not identifiants_ok or not admin_ok:
|
||||
return render(
|
||||
request, "login.html", status_code=401, mode_secours=True,
|
||||
next=_safe_next(next), error="Identifiants incorrects.",
|
||||
)
|
||||
if compte is not None:
|
||||
models.update_user(
|
||||
compte["id"],
|
||||
last_login_at=time.strftime(
|
||||
"%Y-%m-%d %H:%M:%S", time.gmtime()
|
||||
),
|
||||
)
|
||||
models.log_admin(compte["id"], "login.porte_secours", username)
|
||||
return _ouvrir_session(settings.porte_secours_user, next)
|
||||
|
||||
|
||||
@app.get("/logout")
|
||||
@@ -624,11 +761,15 @@ 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 ;
|
||||
- ``sub`` lié à un compte : sa session est ouverte ;
|
||||
- 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.
|
||||
@@ -682,6 +823,12 @@ 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"):
|
||||
@@ -689,12 +836,18 @@ def draco_bridge(request: Request, next: str = "/"):
|
||||
models.update_user(current["id"], draco_sub=sub)
|
||||
models.log_admin(current["id"], "draco.link", sub)
|
||||
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(
|
||||
@@ -2048,11 +2201,18 @@ async def admin_settings_save(request: Request, csrf_token: str = Form("")):
|
||||
if raw is None or str(raw).strip() == "":
|
||||
continue # champ vide = retour à la valeur d'environnement
|
||||
try:
|
||||
overrides[key] = (
|
||||
str(raw).strip()
|
||||
if converter is str
|
||||
else converter(str(raw).strip())
|
||||
)
|
||||
if converter is bool:
|
||||
# Booléen lu EXPLICITEMENT (0.46.6) : bool("false")
|
||||
# vaudrait True — un réglage booléen du panneau
|
||||
# (porte_centrale, sync_*, briefing_*) doit pouvoir
|
||||
# se désactiver en saisissant « false ».
|
||||
overrides[key] = str(raw).strip().lower() in (
|
||||
"1", "true", "on", "oui",
|
||||
)
|
||||
elif converter is str:
|
||||
overrides[key] = str(raw).strip()
|
||||
else:
|
||||
overrides[key] = converter(str(raw).strip())
|
||||
except (TypeError, ValueError):
|
||||
continue
|
||||
import json as _json
|
||||
|
||||
@@ -123,6 +123,15 @@
|
||||
requête, dérivation par l'agent, défaut officiel) ;
|
||||
le Hub n'a pas d'onglet, urls.hub alimente les liens
|
||||
du menu compte. */
|
||||
/* Barre v0.6.0 (fusion #142) : JS/CSS re-vendangés
|
||||
verbatim — le menu compte gagne l'entrée
|
||||
« Administration » (lien Hub <hub>/admin) à visibilité
|
||||
conditionnelle. Kanbante ne passe PAS le drapeau admin :
|
||||
il ne connaît que le rôle du registre du Hub pour sa
|
||||
propre app (consulté avant la création JIT), pas le
|
||||
rôle global de suite (rôle du compte chez ObsiGate) —
|
||||
à défaut de certitude, l'entrée reste masquée ici,
|
||||
comme le contrat l'exige. */
|
||||
urls: { hub: "{{ draco_urls.hub }}/" },
|
||||
/* v0.1.6 : user = initiale auth_user ou K (draco_avatar). Sans
|
||||
cfg.user, le nouveau JS dériverait l'initiale du title
|
||||
|
||||
@@ -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>
|
||||
|
||||
@@ -36,16 +36,32 @@ 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 :
|
||||
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.
|
||||
3. **Compte d'amorçage — adoption conditionnée (fusion #145,
|
||||
0.46.5)** : s'il n'existe qu'**un seul compte** et que c'est un
|
||||
**admin actif sans liaison**, ce compte (celui créé à
|
||||
l'installation depuis l'environnement `KANBANTE_AUTH_USER` /
|
||||
`KANBANTE_AUTH_PASSWORD`, Bruno) n'est adopté que dans l'un
|
||||
de ces deux cas :
|
||||
- **(a)** le `sub` entrant est **« administrateur » pour
|
||||
kanbante au registre des rôles du Hub** (le pont consulte le
|
||||
registre avant la résolution et transmet le rôle à
|
||||
`resolve_draco_user()` ; Hub muet ou rôle moindre = **pas
|
||||
d'adoption**, dans le doute on ne lie pas) ;
|
||||
- **(b)** l'adoption est initiée depuis une **session native
|
||||
déjà authentifiée** (point 1 ci-dessus, ou connexion native
|
||||
doublement connectée) : l'utilisateur connecté lie
|
||||
explicitement son propre compte.
|
||||
Tout autre `sub` inconnu reçoit le parcours ordinaire
|
||||
(création JIT d'un compte **membre** propre, point 4) —
|
||||
jamais l'amorçage. Avant la 0.46.5, le premier `sub` valide
|
||||
de passage adoptait l'amorçage quel qu'il soit : sur une
|
||||
instance fraîche, un simple utilisateur de la suite devenait
|
||||
l'administrateur local (audit « compte partout » du
|
||||
2026-11-06). Les autres accès de l'amorçage restent inchangés
|
||||
dans tous les cas : connexion native avec le mot de passe du
|
||||
compte, et repli d'urgence par les identifiants
|
||||
d'environnement (formulaire et Basic), qui ne dépendent pas
|
||||
de draco.
|
||||
4. **Création JIT** : sinon, un compte Kanbante est créé pour
|
||||
cette identité (détail ci-dessous) et sa session est ouverte.
|
||||
|
||||
@@ -139,11 +155,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 {
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
@@ -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
|
||||
@@ -4,8 +4,11 @@ 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
|
||||
@@ -129,7 +132,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")
|
||||
|
||||
@@ -5,8 +5,13 @@ 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é).
|
||||
valides : dans ce module, le seul compte préexistant est l'admin
|
||||
d'amorçage ; depuis la 0.46.5 (fusion #145), le premier jeton
|
||||
valide ne s'y lie PLUS automatiquement (adoption conditionnée au
|
||||
rôle « administrateur » du registre du Hub ou à une session
|
||||
native) — le pont ouvre alors la session d'un compte JIT propre
|
||||
à l'identité, ce que ces cas vérifient (session ouverte, accès
|
||||
à l'app) sans présumer du compte résolu.
|
||||
Sans DRACO_SESSION_SECRET, le pont renvoie simplement au login.
|
||||
"""
|
||||
|
||||
|
||||
@@ -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