@nodefony/security 10.0.0-beta.1 → 10.0.0-beta.3

package/dist/nodefony/service/oauth2.js

@@ -1,11 +1,57 @@
+import { compileProviderRoleMapping, isPlatformRole, mapProviderRoles } from "../src/oauth/providerRoles.js";
 import { AuthenticationError } from "../errors/AuthenticationError.js";
 import { defineSecurityConfig } from "../config/defineModuleConfig.js";
+import { recordAudit } from "../src/audit/recordAudit.js";
+import { keycloakLoginThemeCheck } from "../keycloak/keycloakAdmin.js";
 import { generateCodeVerifier, generateState } from "../src/oauth/oauth2Client.js";
-import { getOAuthProviderFactory, listOAuthProviders } from "../src/oauth/oauthProviderRegistry.js";
-import { Service } from "nodefony";
+import { getOAuthProviderFactory, listOAuthProviders, oauthProviderRequiresIssuer } from "../src/oauth/oauthProviderRegistry.js";
+import { diagnoseOAuthProvider } from "../src/oauth/providerDiagnosis.js";
+import { BootConfigurationError, LOGIN_PAGE_PATH, Service, canonicalIssuer } from "nodefony";
 //#region nodefony/service/oauth2.ts
 const serviceName = "oauth2";
 /**
+* Clé de session de l'indice de déconnexion. Lue et écrite par CE service
+* seulement ({@link OAuth2Service.rememberLogout},
+* {@link OAuth2Service.logoutUrlFor}) : les contrôleurs ne la connaissent pas.
+*/
+const LOGOUT_HINT_KEY = "oauth2:logout";
+/**
+* Clé de MÉTADONNÉE de session (`metaBag`) qui indexe un login fédéré :
+* fournisseur et `sid`, sans l'ID token. C'est elle que lit le canal arrière.
+*
+* @remarks Pas dans les attributs : l'énumération des sessions les REDACTE
+* (aucun store ne les rend hors de la session elle-même), quand `metaBag` en
+* sort — et le résumé d'administration ne l'expose que par liste blanche.
+*/
+const FEDERATION_KEY = "oauth2:federation";
+/**
+* Plafond de la mémoire anti-rejeu du canal arrière — au-delà, les plus
+* anciens `jti` sont oubliés. Un fournisseur n'émet qu'un jeton par session
+* fermée : ce plafond n'est atteint que sous un flot anormal.
+*/
+const MAX_SEEN_LOGOUT_TOKENS = 1e4;
+/** Relit l'index fédéré d'une session énumérée — sa forme se vérifie. */
+function readFederation(value) {
+	if (typeof value !== "object" || value === null) return null;
+	const { provider, sid } = value;
+	if (typeof provider !== "string") return null;
+	return {
+		provider,
+		sid: typeof sid === "string" ? sid : null
+	};
+}
+/** Relit un indice de session — il vient du stockage, sa forme se vérifie. */
+function readLogoutHint(value) {
+	if (typeof value !== "object" || value === null) return null;
+	const { provider, idToken, sid } = value;
+	if (typeof provider !== "string" || typeof idToken !== "string") return null;
+	return {
+		provider,
+		idToken,
+		sid: typeof sid === "string" ? sid : null
+	};
+}
+/**
 * Sigles qui se lisent en capitales — les capitaliser mot à mot rendrait
 * « Oidc », « Sso », qu'aucun utilisateur ne reconnaît comme la technologie.
 */
@@ -58,19 +104,72 @@ function oauthDisplayLabel(name) {
 	return name.split(/[-_.\s]+/).filter((word) => word.length > 0).map((word) => ACRONYMS.has(word.toLowerCase()) ? word.toUpperCase() : word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
 }
 /**
+* Délai avant de retenter un fournisseur dont la construction a échoué — assez
+* long pour ne pas marteler un émetteur en panne à chaque affichage de l'écran
+* de connexion, assez court pour qu'un bouton revienne sans redémarrage.
+*/
+const UNREACHABLE_RETRY_MS = 3e4;
+/**
+* Confronte l'émetteur configuré d'un fournisseur à ce que sa fabrique exige.
+*
+* Une URL qui ne peut pas être un émetteur est refusée QUEL QUE SOIT le
+* fournisseur : aucune valeur mal formée n'est une configuration voulue. Une
+* absence ne l'est que si la fabrique a déclaré l'émetteur requis.
+*
+* @param name - nom du fournisseur (`oauth2.providers.<name>`).
+* @param issuer - émetteur lu dans sa configuration.
+* @throws BootConfigurationError - émetteur requis absent, ou mal formé.
+*/
+function checkProviderIssuer(name, issuer) {
+	const key = `security.oauth2.providers.${name}.issuer`;
+	if (issuer === void 0 || issuer === "") {
+		if (oauthProviderRequiresIssuer(name)) throw new BootConfigurationError(`[@nodefony/security] ${key} est requis : le fournisseur « ${name} » découvre ses points d'entrée à partir de son émetteur. Attendu : l'URL https de l'émetteur OpenID Connect (Keycloak : URL du realm, ex. « https://auth.example.com/realms/mon-royaume »).`);
+		return;
+	}
+	try {
+		canonicalIssuer(issuer);
+	} catch (error) {
+		throw new BootConfigurationError(`[@nodefony/security] ${key} — ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+/**
+* Claims du jeton d'ACCÈS, quand c'est un JWT — `null` sinon (jeton opaque).
+*
+* Keycloak pose les rôles dans le jeton d'accès, et seulement là par défaut
+* (`realm_access`, `resource_access`) : ni le jeton d'identité ni userinfo ne
+* les portent sans « mapper » ajouté. La signature n'est pas vérifiée, pour la
+* raison qui vaut pour le jeton d'identité (OpenID Connect Core §3.1.3.7) : il
+* vient d'être reçu du point de jeton, sur un canal TLS direct et authentifié.
+*/
+async function accessTokenClaims(tokens) {
+	try {
+		return (await import("jose")).decodeJwt(tokens.accessToken());
+	} catch {
+		return null;
+	}
+}
+/**
 * **Social login OAuth 2.0** (P6 J9) — orchestrateur du flux *Authorization Code*.
 *
 * Posture OAuth 2.1 (RFC 9700) : Authorization Code uniquement (jamais implicit /
 * ROPC), **PKCE S256** quand le fournisseur le supporte (RFC 7636), **state**
-* anti-CSRF, **iss** anti-mix-up (RFC 9207) ; aucun jeton n'atteint le navigateur
-* (le login produit une **session BFF**, gérée hors de ce service par le
-* controller + `AuthFlow`).
+* anti-CSRF, **iss** anti-mix-up (RFC 9207) ; aucun jeton d'accès n'atteint le
+* navigateur (le login produit une **session BFF**, gérée hors de ce service par
+* le controller + `AuthFlow`) — seul l'ID token y passe, une fois, à la
+* déconnexion ({@link IFederatedLogoutHint}).
+*
+* Au boot (si `oauth2.enabled`), la configuration de chaque fournisseur est
+* confrontée à ce que sa fabrique exige : un émetteur requis absent, ou qui n'est
+* pas une URL d'émetteur valide, INTERROMPT le démarrage en nommant la clé — une
+* faute d'écriture ne doit pas attendre le premier clic pour se montrer. Un nom
+* inconnu du registre reste un WARNING.
 *
-* Les fournisseurs sont construits **au premier login** (cold path — jamais au boot
-* ni par requête) puis mémoïsés : c'est là que les points d'entrée d'un émetteur
-* OIDC sont découverts, une seule fois par processus. Au boot (si `oauth2.enabled`)
-* : seule la config est validée et les fournisseurs configurés sont confrontés au
-* registre (un nom inconnu = WARNING, pas fatal).
+* Les fournisseurs sont construits une fois puis mémoïsés : c'est là que les
+* points d'entrée d'un émetteur OIDC sont découverts. Un run qui sert (ports
+* ouverts) les construit DÈS le boot, sans l'attendre : un émetteur injoignable
+* n'est pas une faute de configuration, il se journalise et son bouton quitte
+* l'écran de connexion jusqu'à ce qu'une nouvelle tentative réussisse. Un run
+* console ne touche jamais le réseau.
 *
 * Le service ne touche **ni HTTP ni session** : il rend à l'appelant les éléments
 * (URL, state, verifier) que le controller persiste en session — testable sans
@@ -80,11 +179,15 @@ var OAuth2Service = class extends Service {
 	module;
 	#config = null;
 	#providers = null;
+	#unreachable = null;
+	#seenLogoutTokens = null;
+	#roleMappings = null;
 	#ready = false;
 	constructor(module) {
 		super(serviceName, module.container, module.notificationsCenter, module.options);
 		this.module = module;
-		this.kernel?.once("onBoot", () => this.#build());
+		const oauth2ConfigCheck = () => this.#build();
+		this.kernel?.once("onBoot", oauth2ConfigCheck);
 	}
 	#build() {
 		let config;
@@ -97,13 +200,34 @@ var OAuth2Service = class extends Service {
 			this.log("oauth2 idle — social login désactivé en config", "DEBUG");
 			return;
 		}
-		this.#config = config;
 		const known = new Set(listOAuthProviders());
 		const configured = Object.keys(config.oauth2.providers);
 		for (const name of configured) if (!known.has(name)) this.log(`oauth2 provider "${name}" inconnu du registre — ignoré (registerOAuthProvider manquant ?)`, "WARNING");
-		this.#ready = true;
 		const active = configured.filter((n) => known.has(n));
+		for (const name of active) {
+			const provider = config.oauth2.providers[name];
+			checkProviderIssuer(name, provider?.issuer);
+			const mapping = provider === void 0 ? null : compileProviderRoleMapping(provider);
+			if (mapping !== null) {
+				if (provider?.allowPlatformRoles === true) {
+					const platform = Object.values(mapping.table).filter(isPlatformRole);
+					if (platform.length > 0) this.log(`oauth2 "${name}" : l'annuaire accorde des rôles de PLATEFORME (${[...new Set(platform)].join(", ")}) — son administrateur administre cette instance (allowPlatformRoles)`, "WARNING");
+				}
+				this.#roleMappings ??= Object.create(null);
+				this.#roleMappings[name] = mapping;
+			}
+		}
+		this.#config = config;
+		this.#ready = true;
 		this.log(`oauth2 ready — providers: [${active.join(", ") || "aucun"}]`, "DEBUG");
+		if (this.kernel?.runProfile.servers === true) for (const name of active) this.#probe(name);
+	}
+	/**
+	* Construit un fournisseur sans attendre le résultat — l'échec est consigné
+	* par {@link #resolveProvider}, rien n'est levé vers l'appelant.
+	*/
+	#probe(name) {
+		this.#resolveProvider(name).catch(() => void 0);
 	}
 	/** `true` si le social login est opérationnel (activé + boot OK). */
 	isEnabled() {
@@ -135,30 +259,43 @@ var OAuth2Service = class extends Service {
 	listDisplayProviders() {
 		if (this.#config === null) return [];
 		const configured = this.#config.oauth2.providers;
-		return this.listProviders().filter((name) => !configured[name]?.hidden).map((name) => ({
-			name,
-			label: configured[name]?.label ?? oauthDisplayLabel(name)
-		}));
+		return this.listProviders().filter((name) => !configured[name]?.hidden).filter((name) => this.#isReachable(name)).map((name) => {
+			const label = configured[name]?.label ?? oauthDisplayLabel(name);
+			const icon = configured[name]?.icon;
+			return icon === void 0 ? {
+				name,
+				label
+			} : {
+				name,
+				label,
+				icon
+			};
+		});
 	}
 	/**
 	* Redirections post-login (succès / échec) — lues par le controller.
 	* Surcharge PAR FOURNISSEUR si fournie, sinon valeur globale, sinon défaut.
+	*
+	* @remarks L'échec mène par défaut à la page de connexion (`loginPage.path`) :
+	* déplacer la page déplace la redirection, les deux ne peuvent pas diverger.
 	*/
 	getRedirects(provider) {
 		const o = this.#config?.oauth2;
 		const p = provider ? o?.providers[provider] : void 0;
 		return {
 			success: p?.successRedirect ?? o?.successRedirect ?? "/",
-			failure: p?.failureRedirect ?? o?.failureRedirect ?? "/login"
+			failure: p?.failureRedirect ?? o?.failureRedirect ?? this.#config?.loginPage.path ?? LOGIN_PAGE_PATH
 		};
 	}
 	/**
 	* Étape 1 — prépare l'URL d'autorisation + les éléments anti-replay à stocker
 	* en session (`state`, et `code_verifier` si PKCE).
 	*
+	* @param options.theme - thème rendu par l'application, transmis au seul
+	*   fournisseur qui sait l'afficher (Keycloak) ; les autres l'ignorent
 	* @throws AuthenticationError — fournisseur non configuré / inconnu du registre.
 	*/
-	async createAuthorization(provider) {
+	async createAuthorization(provider, options = {}) {
 		const resolved = await this.#resolveProvider(provider);
 		const state = generateState();
 		const codeVerifier = resolved.provider.usesPkce ? generateCodeVerifier() : null;
@@ -166,7 +303,8 @@ var OAuth2Service = class extends Service {
 			url: resolved.provider.createAuthorizationURL({
 				state,
 				codeVerifier,
-				scopes: resolved.scopes
+				scopes: resolved.scopes,
+				...options.theme ? { theme: options.theme } : {}
 			}).toString(),
 			state,
 			codeVerifier
@@ -194,10 +332,202 @@ var OAuth2Service = class extends Service {
 		const profile = await p.fetchProfile(tokens);
 		const cfg = this.#ensureReady().oauth2;
 		const defaultRoles = cfg.providers[provider]?.defaultRoles ?? cfg.defaultRoles;
-		return { identifier: (await this.#resolveProvisioner().provisionOAuthUser(profile, {
+		const mapping = this.#roleMappings?.[provider];
+		const providerRoles = mapping === void 0 ? void 0 : mapProviderRoles(mapping, await accessTokenClaims(tokens), profile.raw);
+		const user = await this.#resolveProvisioner().provisionOAuthUser(profile, {
 			defaultRoles: [...defaultRoles],
-			allowSignup: cfg.allowSignup
-		})).identifier };
+			allowSignup: cfg.allowSignup,
+			...providerRoles === void 0 ? {} : { providerRoles }
+		});
+		let logoutHint = null;
+		if (p.createLogoutURL !== void 0) {
+			const sid = profile.raw?.sid;
+			logoutHint = {
+				provider,
+				idToken: tokens.idToken(),
+				sid: typeof sid === "string" ? sid : null
+			};
+		}
+		return {
+			identifier: user.identifier,
+			logoutHint
+		};
+	}
+	/**
+	* Retient en session l'indice de déconnexion d'un login fédéré — à appeler
+	* APRÈS l'ouverture de la session authentifiée (l'ID de session est
+	* régénéré à l'ouverture).
+	*
+	* @param session - session authentifiée de la requête.
+	* @param hint - indice rendu par {@link exchangeAndProvision}, ou `null`.
+	*/
+	rememberLogout(session, hint) {
+		if (hint === null) return;
+		session.set(LOGOUT_HINT_KEY, hint);
+		session.setMetaBag?.(FEDERATION_KEY, {
+			provider: hint.provider,
+			sid: hint.sid
+		});
+	}
+	/**
+	* Adresse de déconnexion chez le fournisseur qui a ouvert la session, ou
+	* `null` : session locale, fournisseur sans point de déconnexion, ou
+	* fournisseur devenu indisponible. À lire AVANT de détruire la session.
+	*
+	* @param session - session courante, ou `null`.
+	* @returns l'URL vers laquelle envoyer le navigateur, ou `null`.
+	*/
+	async logoutUrlFor(session) {
+		const hint = readLogoutHint(session?.get(LOGOUT_HINT_KEY));
+		if (hint === null || !this.#ready) return null;
+		let p;
+		try {
+			({provider: p} = await this.#resolveProvider(hint.provider));
+		} catch {
+			return null;
+		}
+		if (p.createLogoutURL === void 0) return null;
+		return p.createLogoutURL({
+			idTokenHint: hint.idToken,
+			postLogoutRedirectUri: this.#postLogoutRedirectUri(hint.provider)
+		}).toString();
+	}
+	/**
+	* Déconnexion demandée PAR le fournisseur sur le canal arrière (OpenID
+	* Connect Back-Channel Logout 1.0) : vérifie le jeton, refuse un rejeu, puis
+	* détruit les sessions locales qu'il désigne.
+	*
+	* Une session est désignée si elle a été ouverte par CE fournisseur (index
+	* fédéré posé au login par {@link rememberLogout}) et, selon le jeton : porte son `sid` ; ou,
+	* sans `sid`, appartient à l'utilisateur lié à son `sub`. Une session ouverte
+	* par mot de passe ou par un autre fournisseur n'est jamais touchée — le
+	* fournisseur ne ferme que ce qu'il a ouvert.
+	*
+	* @remarks Les connexions WebSocket portées par une session détruite se
+	* ferment au tick de revalidation du hub temps réel (code `4001`).
+	*
+	* @param provider - fournisseur désigné par l'adresse appelée.
+	* @param logoutToken - paramètre `logout_token` reçu, brut.
+	* @returns `unsupported` si le fournisseur ne sait pas émettre de jeton de
+	*   déconnexion ; `refused` si le jeton est invalide ou rejoué ; sinon le
+	*   nombre de sessions détruites (0 : déjà déconnecté, c'est un succès §2.7).
+	* @throws Error - vérification impossible (jeu de clés injoignable) ou
+	*   sessions impossibles à parcourir : la déconnexion a ÉCHOUÉ.
+	*/
+	async backchannelLogout(provider, logoutToken) {
+		const { provider: p } = await this.#resolveProvider(provider);
+		if (p.verifyLogoutToken === void 0) return { outcome: "unsupported" };
+		const claims = await p.verifyLogoutToken(logoutToken);
+		if (claims === null || !this.#firstSeen(provider, claims)) return { outcome: "refused" };
+		let owner = null;
+		if (claims.subject !== null) {
+			const users = this.get("users");
+			try {
+				owner = (await users?.loadUserByOAuth?.(provider, claims.subject))?.identifier ?? null;
+			} catch {
+				owner = null;
+			}
+			if (owner === null && claims.sid === null) return {
+				outcome: "done",
+				destroyed: 0
+			};
+		}
+		const sessions = this.get("sessions");
+		if (sessions?.destroyWhere === void 0) throw new Error(`aucun service "sessions" capable de révocation groupée (destroyWhere)`);
+		const destroyed = await sessions.destroyWhere(owner !== null ? { user: owner } : void 0, (data) => {
+			if (owner !== null && data.user !== owner) return false;
+			const federation = readFederation(data.metaBag?.[FEDERATION_KEY]);
+			if (federation === null || federation.provider !== provider) return false;
+			return claims.sid === null || federation.sid === claims.sid;
+		});
+		this.log(`oauth2 back-channel logout "${provider}" — ${destroyed} session(s) fermée(s)` + (owner !== null ? ` user=${owner}` : ""), "INFO");
+		if (destroyed > 0) recordAudit(this.container, {
+			category: "session",
+			action: "session.revoked",
+			outcome: "success",
+			actor: `oauth2:${provider}`,
+			resource: owner,
+			reason: "backchannel_logout",
+			metadata: {
+				count: destroyed,
+				bySid: claims.sid !== null
+			}
+		});
+		return {
+			outcome: "done",
+			destroyed
+		};
+	}
+	/**
+	* Anti-rejeu du canal arrière (§2.6, point 8) : `true` au premier passage
+	* d'un `jti`, `false` s'il a déjà été vu et n'a pas expiré.
+	*
+	* @remarks Mémoire PAR PROCESSUS, bornée : le même jeton rejoué sur un autre
+	* exemplaire passerait. Le rejeu n'y fermerait que des sessions que le
+	* fournisseur a déjà déclarées closes — la borne est la durée de vie du
+	* jeton, que le fournisseur garde courte (§4).
+	*/
+	#firstSeen(provider, claims) {
+		const now = Date.now();
+		const seen = this.#seenLogoutTokens ??= /* @__PURE__ */ new Map();
+		for (const [key, expiresAt] of seen) {
+			if (expiresAt > now && seen.size < MAX_SEEN_LOGOUT_TOKENS) break;
+			seen.delete(key);
+		}
+		const key = `${provider}\n${claims.tokenId}`;
+		const known = seen.get(key);
+		if (known !== void 0 && known > now) return false;
+		seen.set(key, claims.expiresAt * 1e3);
+		return true;
+	}
+	/**
+	* Retour après déconnexion chez le fournisseur : la valeur configurée, sinon
+	* l'écran d'échec (la page de connexion) résolu contre `redirectUri` — une
+	* adresse ABSOLUE, sur une origine déjà enregistrée chez le fournisseur.
+	*
+	* @remarks Query et fragment de l'écran d'échec sont RETIRÉS : ils signalent
+	* un échec (`?error=oauth`), et un fournisseur OpenID Connect refuse une
+	* adresse de retour qui porte un paramètre du protocole (`error`, `code`…) —
+	* Keycloak répond `invalid_redirect_uri`.
+	*/
+	#postLogoutRedirectUri(provider) {
+		const cfg = this.#ensureReady().oauth2.providers[provider];
+		if (cfg?.postLogoutRedirectUri !== void 0) return cfg.postLogoutRedirectUri;
+		const { failure } = this.getRedirects(provider);
+		const url = new URL(failure, cfg?.redirectUri);
+		url.search = "";
+		url.hash = "";
+		return url.toString();
+	}
+	/**
+	* Diagnostique les fournisseurs CONFIGURÉS sans connexion humaine : découverte
+	* et émetteur, URL de retour acceptée, secret accepté (cf
+	* `diagnoseOAuthProvider`).
+	*
+	* Le fournisseur est construit à NEUF, hors de la mémoïsation du login : un
+	* diagnostic doit voir le serveur tel qu'il est maintenant, et son échec ne
+	* doit pas retirer un bouton de l'écran de connexion.
+	*
+	* @param name - un seul fournisseur ; à défaut, tous ceux de la configuration.
+	* @returns un diagnostic par fournisseur ; vide si le social login est éteint.
+	*/
+	async diagnose(name) {
+		if (!this.#ready || this.#config === null) return [];
+		const providers = this.#config.oauth2.providers;
+		const names = name === void 0 ? Object.keys(providers) : [name];
+		const pageCheck = keycloakLoginThemeCheck(this.#config.loginPage.skin);
+		return Promise.all(names.map((n) => {
+			const cfg = Object.hasOwn(providers, n) ? providers[n] : void 0;
+			return diagnoseOAuthProvider({
+				name: n,
+				build: async () => (await this.#buildProvider(n)).provider,
+				clientId: cfg?.clientId ?? "",
+				redirectUri: cfg?.redirectUri ?? "",
+				clientAuthMethod: cfg?.clientAuthMethod,
+				scopes: cfg?.scopes,
+				pageCheck
+			});
+		}));
 	}
 	#resolveProvider(name) {
 		this.#ensureReady();
@@ -206,9 +536,31 @@ var OAuth2Service = class extends Service {
 		if (cached) return cached;
 		const pending = this.#buildProvider(name);
 		this.#providers.set(name, pending);
-		pending.catch(() => this.#providers?.delete(name));
+		pending.then(() => {
+			if (this.#unreachable !== null && name in this.#unreachable) {
+				delete this.#unreachable[name];
+				this.log(`oauth2 provider "${name}" de nouveau joignable`, "INFO");
+			}
+		}, (error) => {
+			this.#providers?.delete(name);
+			this.#unreachable ??= Object.create(null);
+			this.#unreachable[name] = Date.now();
+			this.log(`oauth2 provider "${name}" indisponible — bouton retiré de l'écran de connexion : ${error instanceof Error ? error.message : String(error)}`, "WARNING");
+		});
 		return pending;
 	}
+	/**
+	* `true` si le fournisseur n'a pas échoué récemment. Un échec plus ancien que
+	* {@link UNREACHABLE_RETRY_MS} relance une construction en arrière-plan : sans
+	* elle, un bouton retiré ne reviendrait jamais, puisque plus personne ne
+	* pourrait cliquer pour déclencher la tentative suivante.
+	*/
+	#isReachable(name) {
+		const failedAt = this.#unreachable?.[name];
+		if (failedAt === void 0) return true;
+		if (Date.now() - failedAt >= UNREACHABLE_RETRY_MS && !this.#providers?.has(name)) this.#probe(name);
+		return false;
+	}
 	async #buildProvider(name) {
 		const providers = this.#ensureReady().oauth2.providers;
 		const cfg = Object.hasOwn(providers, name) ? providers[name] : void 0;
@@ -220,7 +572,8 @@ var OAuth2Service = class extends Service {
 			clientSecret: cfg.clientSecret,
 			clientAuthMethod: cfg.clientAuthMethod,
 			redirectUri: cfg.redirectUri,
-			issuer: cfg.issuer
+			issuer: cfg.issuer,
+			discoveryUrl: cfg.discoveryUrl
 		});
 		return {
 			provider,
@@ -238,4 +591,4 @@ var OAuth2Service = class extends Service {
 	}
 };
 //#endregion
-export { OAuth2Service, OAuth2Service as default, oauthDisplayLabel };
+export { OAuth2Service, OAuth2Service as default, checkProviderIssuer, oauthDisplayLabel };

package/dist/nodefony/service/securityHeaders.js

@@ -20,6 +20,8 @@ const NONCE_PLACEHOLDER = "{{nonce}}";
 var SecurityHeaders = class {
 	#headers;
 	#cspParts;
+	#cspPrefix;
+	#cspSuffix;
 	#cspRaw;
 	constructor(o) {
 		const h = {};
@@ -39,6 +41,13 @@ var SecurityHeaders = class {
 		if (o.permissionsPolicy) h["Permissions-Policy"] = o.permissionsPolicy;
 		this.#headers = Object.freeze(h);
 		this.#cspParts = cspParts ? Object.freeze(cspParts) : null;
+		if (cspParts?.length === 2) {
+			this.#cspPrefix = cspParts[0] ?? "";
+			this.#cspSuffix = cspParts[1] ?? "";
+		} else {
+			this.#cspPrefix = null;
+			this.#cspSuffix = "";
+		}
 		this.#cspRaw = o.csp;
 	}
 	/** Table d'en-têtes applicatifs CONSTANTS (figée), posée telle quelle par le firewall. */
@@ -51,13 +60,15 @@ var SecurityHeaders = class {
 	}
 	/**
 	* Recompose le CSP en injectant le `nonce` de la requête aux emplacements
-	* `{{nonce}}`. 1 `join` (segments pré-split au boot). Le nonce est base64 (jamais
+	* `{{nonce}}` : une concaténation s'il n'y en a qu'un, un `join` sinon (segments
+	* pré-split au boot). Le nonce est base64 (jamais
 	* `'`/`;`/espace) → aucune évasion possible du token CSP.
 	*
 	* @param nonce - nonce base64 de la requête (`Context.cspNonce`).
 	* @returns la valeur `Content-Security-Policy` à poser sur la réponse.
 	*/
 	cspFor(nonce) {
+		if (this.#cspPrefix !== null) return this.#cspPrefix + nonce + this.#cspSuffix;
 		return this.#cspParts.join(nonce);
 	}
 	/**

package/dist/nodefony/service/tokenService.js

@@ -1,12 +1,14 @@
+import { JwtKeystore } from "../src/token/JwtKeystore.js";
+import { InsecureTransportError } from "../errors/InsecureTransportError.js";
 import { AuthenticationError } from "../errors/AuthenticationError.js";
 import { ThrottledError } from "../errors/ThrottledError.js";
 import { defineSecurityConfig } from "../config/defineModuleConfig.js";
 import { defaultAudience, resolveJwtRuntime } from "../src/token/jwtRuntime.js";
 import { recordAudit } from "../src/audit/recordAudit.js";
+import { readAuditContext } from "../src/audit/readAuditContext.js";
 import { InvalidTargetError } from "../errors/InvalidTargetError.js";
 import { getTokenStoreFactory, listTokenStores } from "../src/token/tokenStoreRegistry.js";
-import { JwtKeystore } from "../src/token/JwtKeystore.js";
-import { AUTO_STORE, EMPTY_INFRA, GcScheduler, Service, canonicalIssuer, durableStoreRemedy, readStoreConnector, readStoreLocation, refusedAdminScopes, resolveAutoStore, runNeedsExternalServices } from "nodefony";
+import { AUTO_STORE, BootConfigurationError, EMPTY_INFRA, GcScheduler, Service, canonicalIssuer, durableStoreRemedy, readStoreConnector, readStoreLocation, refusedAdminScopes, resolveAutoStore, runNeedsExternalServices } from "nodefony";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
 //#region nodefony/service/tokenService.ts
 const serviceName = "tokenService";
@@ -36,13 +38,46 @@ var TokenService = class extends Service {
 	#users = null;
 	#throttler = null;
 	#throttlerResolved = false;
+	#transport = null;
 	#gc = null;
 	constructor(module) {
 		super(serviceName, module.container, module.notificationsCenter, module.options);
 		this.module = module;
-		this.kernel?.once("onBoot", () => this.#build());
+		const tokenServiceBoot = () => this.#build();
+		this.kernel?.once("onBoot", tokenServiceBoot);
 		this.kernel?.once("onTerminate", () => this.#shutdown());
 	}
+	/**
+	* Refuse de SERVIR en production sans clé de signature partagée.
+	*
+	* Sans `keySetJson` ni `dir`, le keystore tire une clé ÉPHÉMÈRE propre au
+	* process : derrière plusieurs pods ou workers, un jeton signé par l'un est
+	* refusé par l'autre (401 au hasard de la répartition), et chaque
+	* redémarrage invalide tous les jetons. Un avertissement au premier jeton ne
+	* suffisait pas — il tombait en production, loin de celui qui pouvait agir.
+	*
+	* Seul un run qui SERT est concerné (`runProfile.servers`) : une commande de
+	* console (`orm:migrate`, `security:user:add`) ne signe aucun jeton, et la
+	* bloquer casserait le job de migration pour rien.
+	*
+	* @throws BootConfigurationError - production, serveur, et aucune source.
+	*/
+	#requireSharedSigningKey(keystore) {
+		if (keystore.keySetJson || keystore.dir) return;
+		if (this.kernel?.environment !== "production") return;
+		if (!this.kernel.runProfile.servers) return;
+		throw new BootConfigurationError([
+			"[@nodefony/security] DÉMARRAGE REFUSÉ — aucune clé de signature des jetons partagée (jwt.keystore).",
+			"  Pourquoi : chaque process signerait avec la sienne. Un jeton émis par un pod ou un worker",
+			"  serait refusé par les autres (401 au hasard), et tous seraient perdus au redémarrage.",
+			"  Que faire — une des trois :",
+			"    1. Poser NF_JWT_KEYSET (câblée sur jwt.keystore.keySetJson) : valeur générée UNE fois par",
+			"       `npx nodefony security:secrets --jwt-keyset`, rangée dans le gestionnaire de secrets,",
+			"       injectée dans chaque pod.",
+			"    2. Serveur unique à disque persistant : jwt.keystore.dir.",
+			"    3. L'application n'émet aucun jeton : jwt.enabled: false."
+		].join("\n"));
+	}
 	#build() {
 		let config;
 		try {
@@ -89,6 +124,7 @@ var TokenService = class extends Service {
 		});
 		this.container?.set("tokenStore", this.#store);
 		if (jwtEnabled) {
+			this.#requireSharedSigningKey(config.jwt.keystore);
 			this.#runtime = resolveJwtRuntime(config.jwt);
 			this.#keystore = new JwtKeystore(config.jwt.keystore, (m, s) => this.log(m, s));
 			this.container?.set("jwtKeystore", this.#keystore);
@@ -193,10 +229,24 @@ var TokenService = class extends Service {
 	* Émet un couple access/refresh après vérification d'un credential
 	* identifiant/mot de passe (grant M2M/CLI). Throttling NIST partagé si activé.
 	*
+	* @param context - requête HTTP qui porte le credential. Présente, elle
+	*   soumet l'appel au refus du clair en production ; absente (CLI, appel
+	*   programmatique), il n'y a pas de transport à juger. Un endpoint HTTP DOIT
+	*   la passer.
+	* @throws InsecureTransportError (403) — credential reçu en clair en production.
 	* @throws ThrottledError (429) — backoff actif.
 	* @throws AuthenticationError (401, message uniforme) — credential invalide.
 	*/
-	async issueForCredentials(identifier, password, requestedScopes, resource) {
+	async issueForCredentials(identifier, password, requestedScopes, resource, context) {
+		if (context !== void 0) {
+			this.#transport ??= this.get("credentialTransport") ?? null;
+			try {
+				this.#transport?.assert(context, "token");
+			} catch (error) {
+				if (error instanceof InsecureTransportError) this.#auditGrant("login.failure", typeof identifier === "string" && identifier.length > 0 ? identifier : null, "insecure_transport", readAuditContext(context));
+				throw error;
+			}
+		}
 		if (typeof identifier !== "string" || identifier.length === 0 || typeof password !== "string" || password.length === 0) {
 			this.#auditGrant("login.failure", typeof identifier === "string" && identifier.length > 0 ? identifier : null, "invalid_credentials");
 			throw new AuthenticationError("Invalid credentials");
@@ -218,13 +268,14 @@ var TokenService = class extends Service {
 		throttler?.recordSuccess(identifier);
 		return this.issueTokens(user, requestedScopes, resource);
 	}
-	#auditGrant(action, actor, reason) {
+	#auditGrant(action, actor, reason, info) {
 		recordAudit(this.container, {
 			category: "auth",
 			action,
 			outcome: "failure",
 			actor,
-			reason
+			reason,
+			...info
 		});
 	}
 	/**