"""User accounts: password hashing and bootstrap (0.24.0, P2). Passwords are hashed with PBKDF2-HMAC-SHA256 (stdlib) with a per-user salt; the stored string carries its parameters ("pbkdf2$$$") so the cost can be raised later without invalidating existing hashes. """ import base64 import hashlib import hmac import re import secrets import sqlite3 import unicodedata from app import models _ITERATIONS = 260_000 def hash_password(password: str) -> str: salt = secrets.token_bytes(16) digest = hashlib.pbkdf2_hmac( "sha256", password.encode("utf-8"), salt, _ITERATIONS ) return "pbkdf2${}${}${}".format( _ITERATIONS, base64.b64encode(salt).decode("ascii"), base64.b64encode(digest).decode("ascii"), ) def verify_password(password: str, stored: str) -> bool: try: scheme, iterations, salt_b64, hash_b64 = stored.split("$") if scheme != "pbkdf2": return False salt = base64.b64decode(salt_b64) expected = base64.b64decode(hash_b64) digest = hashlib.pbkdf2_hmac( "sha256", password.encode("utf-8"), salt, int(iterations) ) return hmac.compare_digest(digest, expected) except Exception: return False def ensure_bootstrap_admin() -> dict | None: """Create the first admin from the env credentials. Runs when the users table is empty and KANBANTE_AUTH_USER / _PASSWORD are configured (decision D6): Bruno's existing login becomes the initial database admin, with no lockout. The env path keeps working as an emergency fallback either way (see app.main auth). """ from app.config import get_settings if models.count_users() > 0: return None settings = get_settings() if not settings.auth_enabled: return None user_id = models.create_user( settings.auth_user, hash_password(settings.auth_password), role="admin", display_name=settings.auth_user, ) return models.get_user(user_id) # ── Correspondance draco par utilisateur (HUB-16, 0.46.0) ──── # La correspondance identité draco ↔ compte Kanbante vit dans la # colonne users.draco_sub (UNIQUE, présente depuis la 0.24.0) : # models.get_user_by_draco(sub) est la résolution canonique. # resolve_draco_user() est l'unique point d'entrée du pont SSO # (app.main.draco_bridge) et du contrôle draco de /api/search : # # 1. correspondance existante → son compte (None si désactivé) ; # 2. amorçage CONDITIONNÉ (fusion #145, 0.46.5) : s'il n'existe # qu'UN seul compte et que c'est un admin actif sans liaison, # ce compte d'amorçage ne peut être adopté que si # a) le sub entrant est « administrateur » pour kanbante # au registre des rôles du Hub (app.hub_roles, rôle # transmis par l'appelant via ``role_hub`` — dans le # doute, registre muet ou rôle moindre, PAS d'adoption), # ou b) l'adoption est initiée depuis une session native # déjà authentifiée (``liaison_session_native=True`` : # l'utilisateur connecté lie explicitement son compte) ; # tout autre sub inconnu suit le parcours ordinaire (JIT ou # refus selon la surface), JAMAIS l'amorçage ; # 3. rattachement par HOMONYMIE (0.46.10, chantier SSO # « bruno ») : si un compte local porte EXACTEMENT le nom # d'utilisateur que cette identité porterait (base dérivée # des claims, voir _base_nom_draco) et qu'il n'a AUCUN lien # draco, le sub y est rattaché et c'est CE compte qui est # servi — avant, le JIT créait un clone suffixé (« bruno-2 ») # et le propriétaire légitime n'atteignait jamais son compte. # Fondement : les noms centraux font foi — les comptes de la # suite sont créés par l'administrateur au Hub, il n'existe # aucune inscription publique ; un sub de nom DIFFÉRENT # n'absorbe toujours aucun compte (le #145 reste entier). # Si l'homonyme est déjà lié à un AUTRE sub : aucun # rattachement silencieux, aucun clone — résolution à None, # le pont signale le conflit (draco_conflit_nom) et la # re-liaison exige la double preuve (voir # app.main.draco_relier) ; # 4. sinon, si provisionner=True : création JIT d'un compte # propre à cette identité (voir provision_draco_user). # # Avant la 0.46.5, l'étape 2 liait l'amorçage au PREMIER sub # valide de passage : sur une instance fraîche, un simple # utilisateur de la suite devenait l'administrateur local # (audit « compte partout » du 2026-11-06, carte fusion #145). def _slug_draco(valeur: str) -> str: texte = unicodedata.normalize("NFKD", valeur or "") texte = texte.encode("ascii", "ignore").decode("ascii").lower() return re.sub(r"[^a-z0-9]+", "-", texte).strip("-")[:40].strip("-") def _base_nom_draco(nom_affiche: str) -> str | None: """Base du nom d'utilisateur d'une identité draco : le nom affiché slugifié (« Alice Exemple » → « alice-exemple », « bruno » → « bruno »). None si la base est inexploitable (< 3 caractères) : aucune homonymie ne peut alors être établie et le JIT retombe sur son nom de repli.""" base = _slug_draco(nom_affiche) return base if len(base) >= 3 else None def _nom_utilisateur_draco(nom_affiche: str, sub: str) -> str: """Nom d'utilisateur libre dérivé des claims (jamais réutilisé). Base : le nom affiché slugifié (« Alice Exemple » → « alice-exemple ») ; repli « draco- ». Si le nom est déjà pris, un suffixe -2, -3… est ajouté : hors le rattachement par homonymie de resolve_draco_user (compte homonyme SANS lien), le JIT crée toujours un compte nouveau, distinct. """ base = _base_nom_draco(nom_affiche) if base is None: base = _slug_draco(f"draco-{sub}") or "draco" candidat, n = base, 2 while models.get_user_by_username(candidat) is not None: candidat = f"{base}-{n}" n += 1 return candidat def _compte_homonyme(claims: dict | None, sub: str) -> dict | None: """Compte local portant le nom d'utilisateur de l'identité draco présentée (base dérivée des claims), ou None. C'est la clé du rattachement de l'étape 3 de resolve_draco_user et du conflit signalé par draco_conflit_nom : la comparaison porte sur le NOM D'UTILISATEUR local contre le nom que l'émetteur fait porter à l'identité — jamais sur un nom d'une autre forme. """ base = _base_nom_draco(str((claims or {}).get("name") or "")) if base is None: return None return models.get_user_by_username(base) def draco_conflit_nom(claims: dict | None) -> dict | None: """Compte local homonyme de l'identité présentée mais lié à un AUTRE sub, ou None. Distingue, pour le pont, l'échec « ce nom est déjà le compte d'une autre identité de la suite » (conflit explicite, re-liaison par double preuve) d'un échec ordinaire : la résolution refuse alors tout rattachement et tout clone JIT. """ sub = str((claims or {}).get("sub") or "") if not sub: return None homonyme = _compte_homonyme(claims, sub) if homonyme is None: return None lie = homonyme.get("draco_sub") if lie and lie != sub: return homonyme return None def provision_draco_user(sub: str, nom_affiche: str = "") -> dict | None: """Création JIT du compte Kanbante d'une identité draco (HUB-16). Rôle par défaut sûr : membre (« member », l'utilisateur standard de Kanbante) — jamais admin. Le mot de passe local est un secret aléatoire haché, jamais divulgué : l'accès normal passe par draco ; un administrateur peut poser un mot de passe local depuis /admin si besoin. Le compte rejoint l'espace Principal comme membre, comme tout nouvel utilisateur créé par l'administration. """ sub = str(sub or "") if not sub: return None existant = models.get_user_by_draco(sub) if existant is not None: return existant nom = (nom_affiche or "").strip()[:80] for _tentative in range(5): username = _nom_utilisateur_draco(nom, sub) try: user_id = models.create_user( username, hash_password(secrets.token_urlsafe(32)), role="member", display_name=nom, draco_sub=sub, ) break except sqlite3.IntegrityError: # Course sur draco_sub ou username : la correspondance # gagnante fait foi ; sinon, réessayer un autre nom. existant = models.get_user_by_draco(sub) if existant is not None: return existant else: return models.get_user_by_draco(sub) espaces = models.list_workspaces() if espaces: models.set_member(espaces[0]["id"], user_id, "member") models.log_admin(user_id, "draco.jit", f"{username} (sub {sub})") return models.get_user(user_id) def resolve_draco_user( claims: dict | None, provisionner: bool = False, role_hub: str | None = None, liaison_session_native: bool = False, ) -> dict | None: """Compte Kanbante désigné par des claims draco valides. provisionner=False : correspondance et amorçage seulement (surfaces qui ne doivent pas créer de compte, p. ex. /api/search — le rattachement par homonymie, qui ÉCRIT le lien, n'y a pas lieu). provisionner=True : rattachement par homonymie si un compte local sans lien porte le nom de l'identité, sinon création JIT si aucune correspondance n'existe (pont /auth/draco — la « première connexion draco » du critère « un compte fonctionne partout »). Un compte désactivé résout à None et n'est jamais contourné par un JIT (la correspondance existe). Adoption de l'amorçage (fusion #145) : ``role_hub`` est le rôle du sub au registre du Hub pour kanbante, déjà consulté par l'appelant (app.hub_roles ; ``None`` = inconnu, Hub muet) et ``liaison_session_native`` signale une adoption initiée depuis une session native authentifiée. L'amorçage n'est adopté que si l'un des deux vaut respectivement ``"administrateur"`` / ``True`` — sinon, aucun paramètre ne doit être deviné ici : dans le doute, pas d'adoption. """ sub = str((claims or {}).get("sub") or "") if not sub: return None lie = models.get_user_by_draco(sub) if lie is not None: return lie if lie["active"] else None if models.count_users() == 1: seul = models.list_users()[0] if ( seul["role"] == "admin" and seul["active"] and not seul.get("draco_sub") and (role_hub == "administrateur" or liaison_session_native) ): # Compte d'amorçage : adoption conditionnée (#145) — # administrateur au registre du Hub, ou liaison # explicite depuis une session native authentifiée. models.update_user(seul["id"], draco_sub=sub) models.log_admin(seul["id"], "draco.link.amorcage", sub) return models.get_user(seul["id"]) if provisionner: # Étape 3 — rattachement par homonymie (0.46.10) : le # compte local qui porte le nom de cette identité et n'a # aucun lien draco EST le compte de cette identité (les # noms centraux sont émis par l'administrateur au Hub, # sans inscription publique). Un homonyme désactivé # résout à None, jamais contourné par un clone. Un # homonyme lié à un autre sub arrête tout : ni # rattachement silencieux, ni clone JIT — le pont # signalera le conflit (draco_conflit_nom) et la # re-liaison passera par la double preuve. homonyme = _compte_homonyme(claims, sub) if homonyme is not None: if homonyme.get("draco_sub"): return None if not homonyme["active"]: return None models.update_user(homonyme["id"], draco_sub=sub) models.log_admin(homonyme["id"], "draco.link.nom", sub) return models.get_user(homonyme["id"]) cree = provision_draco_user(sub, str((claims or {}).get("name") or "")) if cree is not None and cree["active"]: return cree return None