Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
b5f49f4e39 | ||
|
|
f05a872caa | ||
|
|
b7145e398d | ||
|
|
6b1e2491dd | ||
|
|
e4531488d0 |
@@ -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,30 @@
|
||||
## 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).
|
||||
|
||||
@@ -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 » |
|
||||
|
||||
@@ -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,
|
||||
}
|
||||
|
||||
|
||||
|
||||
+343
-30
@@ -249,7 +249,7 @@ registry = connections_service.ForgeRegistry()
|
||||
SESSION_COOKIE = "kanbante_session"
|
||||
SESSION_DAYS = 7
|
||||
_PUBLIC_PATHS = ("/api/health", "/webhooks/gitea", "/api/capture", "/login",
|
||||
"/auth/draco")
|
||||
"/login/secours", "/auth/draco")
|
||||
|
||||
|
||||
def _session_secret() -> bytes:
|
||||
@@ -263,7 +263,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 +273,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 +299,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 +340,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 +365,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 +426,85 @@ 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
|
||||
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 +534,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
|
||||
@@ -451,6 +571,36 @@ 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).
|
||||
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,
|
||||
)
|
||||
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(
|
||||
@@ -536,11 +686,46 @@ 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.
|
||||
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."
|
||||
)
|
||||
return render(
|
||||
request, "login.html", next=_safe_next(next), error=erreur,
|
||||
porte_centrale=bool(get_settings().porte_centrale),
|
||||
)
|
||||
|
||||
|
||||
@app.post("/login")
|
||||
@@ -559,6 +744,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)
|
||||
@@ -622,15 +826,90 @@ 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)
|
||||
# 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")
|
||||
@@ -747,7 +1026,15 @@ def draco_bridge(request: Request, next: str = "/"):
|
||||
samesite="lax",
|
||||
)
|
||||
return response
|
||||
return RedirectResponse("/login", 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) ──────────────────────
|
||||
@@ -2090,11 +2377,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
|
||||
@@ -2448,19 +2742,38 @@ def render(
|
||||
f"{_urls.sso_url}/sso/authorize?return_to="
|
||||
f"{quote(_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)
|
||||
|
||||
@@ -133,14 +133,16 @@
|
||||
à 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) {
|
||||
|
||||
@@ -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>
|
||||
|
||||
@@ -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.
|
||||
@@ -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)
|
||||
|
||||
@@ -237,7 +237,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:
|
||||
@@ -313,6 +317,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,187 @@
|
||||
"""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_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
|
||||
@@ -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