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

package/dist/nodefony/keycloak/security-keycloak-realm.js

@@ -0,0 +1,128 @@
+import { KeycloakRealmError } from "./keycloakRealmInput.js";
+import { KeycloakAdminError } from "./keycloakAdmin.js";
+import { Command } from "nodefony";
+import path from "node:path";
+//#region nodefony/keycloak/security-keycloak-realm.ts
+const options = {
+	helpGroup: "COMPTES ET SECRETS",
+	showBanner: false,
+	kernelEvent: "onReady",
+	quietBoot: true
+};
+const GREEN = "\x1B[32m";
+const YELLOW = "\x1B[33m";
+const DIM = "\x1B[2m";
+const RESET = "\x1B[0m";
+/** Codes de sortie (sysexits). */
+const EXIT_DIFFERS = 1;
+const EXIT_CONFIG = 78;
+/**
+* `nodefony security:keycloak:realm` — le realm Keycloak que la configuration
+* de l'application implique.
+*
+* Le realm d'import répète ce que la config dit déjà : identifiant du client,
+* URL de retour, audience de chaque zone, rôles de `roleMapping`. Écrit à la
+* main, il diverge — et le symptôme est un 401 ou une URL de retour refusée,
+* jamais un message qui nomme la cause. Cette commande le DÉRIVE, par le
+* service `keycloak` — qui porte toutes les actions Keycloak ; elle n'en
+* garde que l'affichage et les codes de sortie.
+*
+* Elle FUSIONNE dans le fichier existant au lieu de l'écraser : comptes de
+* démonstration, titres, secret machine, mappers posés dans la console
+* survivent (`mergeKeycloakRealm`, cœur — le même constructeur que
+* `create app`).
+*
+* - sans option : affiche le realm fusionné ;
+* - `--write` : l'écrit (le fichier par défaut est l'unique `.json` de
+*   `docker/keycloak/import/`) ;
+* - `--check` : sort en 1 si le fichier n'est plus à jour — la garde de CI ;
+* - `--apply` : pose sur le realm EXISTANT le thème de connexion qui suit
+*   `loginPage.skin`, par l'API d'administration (service `keycloak`) —
+*   développement seulement, compte `oauth2.providers.<nom>.admin` requis.
+*
+* ⚠️ Keycloak n'importe un realm qu'à sa CRÉATION : un realm déjà présent
+* n'est pas relu. Après `--write`, le porter par un import PARTIEL (clients en
+* « Overwrite » : comptes et seconds facteurs survivent) ; retirer le volume
+* ne se fait que sur un realm qui ne porte rien à garder.
+*/
+var SecurityKeycloakRealm = class extends Command {
+	constructor(cli) {
+		super("security:keycloak:realm", "écrit le realm Keycloak déduit de la configuration", cli, options);
+		this.addOption("-w, --write [fichier]", "écrit le realm fusionné dans le fichier d'import");
+		this.addOption("-c, --check [fichier]", "sort en 1 si le fichier d'import n'est plus à jour");
+		this.addOption("-a, --apply", "pose le thème de connexion sur le realm existant (développement)");
+		this.addOption("-p, --provider <nom>", "fournisseur de oauth2.providers (défaut keycloak)");
+		this.addOption("-m, --machine <clientId>", "client machine dont l'audience suit la config");
+		this.addOption("--backchannel-origin <url>", "origine par laquelle Keycloak joint l'application (canal arrière)");
+	}
+	/** Le service `keycloak`, ou `null` (code de sortie posé). */
+	#service() {
+		const service = this.kernel?.container?.get("keycloak");
+		if (service) return service;
+		this.log("service keycloak absent — module security non chargé ?", "ERROR");
+		process.exitCode = EXIT_CONFIG;
+		return null;
+	}
+	async generate(opts) {
+		const service = this.#service();
+		if (service === null) return this;
+		if (opts.apply === true) {
+			if (!await this.#apply(service, opts.provider) || opts.write === void 0 && opts.check === void 0) return this;
+		}
+		let plan;
+		try {
+			plan = service.realmPlan({
+				provider: opts.provider,
+				machine: opts.machine,
+				backchannelOrigin: opts.backchannelOrigin,
+				file: typeof opts.write === "string" ? opts.write : typeof opts.check === "string" ? opts.check : void 0
+			});
+		} catch (error) {
+			if (!(error instanceof KeycloakRealmError)) throw error;
+			this.log(error.message, "ERROR");
+			process.exitCode = EXIT_CONFIG;
+			return this;
+		}
+		for (const warning of plan.warnings) process.stderr.write(`${YELLOW}⚠ ${warning}${RESET}\n`);
+		const relative = path.relative(this.kernel?.path ?? process.cwd(), plan.file);
+		if (opts.check !== void 0) {
+			if (plan.upToDate) {
+				process.stdout.write(`${GREEN}✓${RESET} ${relative} est à jour\n`);
+				return this;
+			}
+			process.stderr.write(`${relative} ne correspond plus à la configuration — nodefony security:keycloak:realm --write\n`);
+			process.exitCode = EXIT_DIFFERS;
+			return this;
+		}
+		if (opts.write !== void 0) {
+			if (!service.writeRealm(plan)) {
+				process.stdout.write(`${GREEN}✓${RESET} ${relative} déjà à jour, rien d'écrit\n`);
+				return this;
+			}
+			process.stdout.write(`${GREEN}✓${RESET} ${relative} écrit\n${DIM}  Keycloak n'importe un realm qu'à sa CRÉATION — un realm déjà là ne relit pas ce fichier :\n  · thème de connexion : nodefony security:keycloak:realm --apply ;\n  · le reste : console › Realm settings › Action › Partial import, clients en « Overwrite » (comptes et seconds facteurs gardés) ;\n  · ou recréer le realm (retirer le volume Keycloak) s'il ne porte rien à garder.${RESET}\n`);
+			return this;
+		}
+		process.stdout.write(plan.text);
+		return this;
+	}
+	/**
+	* `--apply` : le thème que l'habillage demande, posé sur le realm vivant.
+	*
+	* @returns `false` si le geste a échoué (code de sortie posé)
+	*/
+	async #apply(service, provider) {
+		try {
+			const result = await service.applyLoginTheme(provider === void 0 ? {} : { provider });
+			const line = result.outcome === "applied" ? `${GREEN}✓${RESET} realm « ${result.realm} » : thème « ${result.previous ?? "—"} » → « ${result.theme} »` : result.outcome === "unchanged" ? `${GREEN}✓${RESET} realm « ${result.realm} » : déjà sur « ${result.theme} »` : `${YELLOW}⚠${RESET} realm « ${result.realm} » : thème « ${result.previous ?? "aucun"} » propre à l'application, laissé tel quel`;
+			process.stdout.write(`${line}\n`);
+			return true;
+		} catch (error) {
+			if (!(error instanceof KeycloakAdminError)) throw error;
+			this.log(error.message, "ERROR");
+			process.exitCode = EXIT_CONFIG;
+			return false;
+		}
+	}
+};
+//#endregion
+export { SecurityKeycloakRealm as default };

package/dist/nodefony/scaffold/contribute.js

@@ -0,0 +1,20 @@
+import { contributeKeycloak } from "../keycloak/scaffold.js";
+//#region nodefony/scaffold/contribute.ts
+/**
+* Le point de contribution de `@nodefony/security` : ce que le paquet livre à
+* une application, déclaré dans son `package.json` (`nodefony.contribute`) et
+* joué par le cœur, qui n'en connaît rien.
+*
+* @module
+*/
+/**
+* La contribution du paquet — aujourd'hui le seul décor Keycloak de
+* développement (`nodefony/keycloak/`).
+*
+* @param context - contexte fourni par le cœur (`runAppContributions`)
+*/
+function contribute(context) {
+	contributeKeycloak(context);
+}
+//#endregion
+export { contribute };

package/dist/nodefony/service/authFlow.js

@@ -1,10 +1,15 @@
+import { securityConfigSchema } from "../config/config.js";
+import { InsecureTransportError } from "../errors/InsecureTransportError.js";
 import { AuthenticationError } from "../errors/AuthenticationError.js";
 import { ThrottledError } from "../errors/ThrottledError.js";
 import { resolveSessionIdentity } from "../src/sessionIdentity.js";
 import { recordAudit } from "../src/audit/recordAudit.js";
 import { readAuditContext } from "../src/audit/readAuditContext.js";
-import { RequestContext, Service } from "nodefony";
+import { amrForFactor } from "../src/sessionAuthentication.js";
+import { LOGIN_PAGE_SKIN_SPECS, MFA_METHOD_TOTP, SESSION_AMR_KEY, SESSION_AUTH_AT_KEY, Service } from "nodefony";
+import { requestUser } from "@nodefony/user";
 //#region nodefony/service/authFlow.ts
+const MFA_METHODS = Object.freeze([MFA_METHOD_TOTP]);
 const serviceName = "authFlow";
 const INVALID_CREDENTIALS = "Invalid credentials";
 const PENDING_MFA_KEY = "mfa:pending";
@@ -34,8 +39,11 @@ var AuthFlow = class extends Service {
 	#sessions = null;
 	#throttler = null;
 	#throttlerResolved = false;
+	#transport = null;
 	#totp = null;
 	#totpResolved = false;
+	#loginPage = null;
+	#loginPageResolved = false;
 	constructor(module) {
 		super(serviceName, module.container, module.notificationsCenter, module.options);
 		this.module = module;
@@ -51,6 +59,8 @@ var AuthFlow = class extends Service {
 	* @param identifier - identifiant saisi (body JSON, non typé à la frontière).
 	* @param password - mot de passe saisi.
 	* @returns `authenticated` (identité établie) ou `mfa_required` (2ᵉ facteur requis).
+	* @throws InsecureTransportError (403) — mot de passe reçu en clair en
+	*   production (refusé AVANT le throttle et le verifier).
 	* @throws ThrottledError (429 + `Retry-After`) — backoff actif.
 	* @throws AuthenticationError (401, message uniforme) — credential absent ou
 	*   invalide.
@@ -58,6 +68,7 @@ var AuthFlow = class extends Service {
 	async login(context, identifier, password) {
 		const info = readAuditContext(context);
 		const who = typeof identifier === "string" ? identifier : null;
+		this.#assertTransport(context, "login", who, info);
 		if (typeof identifier !== "string" || identifier.length === 0 || typeof password !== "string" || password.length === 0) {
 			recordAudit(this.container, {
 				category: "auth",
@@ -113,12 +124,10 @@ var AuthFlow = class extends Service {
 			});
 			return {
 				status: "mfa_required",
-				methods: ["totp"]
+				methods: MFA_METHODS
 			};
 		}
-		await this.#openSession(context, user.identifier);
-		context.user = user.identifier;
-		RequestContext.set("user", user);
+		await this.#openSession(context, user.identifier, "password");
 		recordAudit(this.container, {
 			category: "auth",
 			action: "login.success",
@@ -148,9 +157,7 @@ var AuthFlow = class extends Service {
 	async establishSessionFor(context, identifier, reason = "federated") {
 		if (typeof identifier !== "string" || identifier.length === 0) throw new AuthenticationError(INVALID_CREDENTIALS);
 		const user = await resolveSessionIdentity(this.#resolveUsers(), identifier);
-		await this.#openSession(context, user.identifier);
-		context.user = user.identifier;
-		RequestContext.set("user", user);
+		await this.#openSession(context, user.identifier, reason);
 		recordAudit(this.container, {
 			category: "auth",
 			action: "login.success",
@@ -171,6 +178,7 @@ var AuthFlow = class extends Service {
 	* @param context - contexte HTTP (porte la session PENDING).
 	* @param code - code présenté (TOTP ou code de récupération).
 	* @returns la projection publique de l'utilisateur authentifié.
+	* @throws InsecureTransportError (403) — code reçu en clair en production.
 	* @throws ThrottledError (429) — trop de tentatives.
 	* @throws AuthenticationError (401, uniforme) — aucun défi en cours, code absent
 	*   ou invalide (la session N'est PAS ouverte ; le défi reste pour un retry).
@@ -178,6 +186,7 @@ var AuthFlow = class extends Service {
 	async completeMfaLogin(context, code) {
 		const info = readAuditContext(context);
 		const pending = context.session?.get(PENDING_MFA_KEY);
+		this.#assertTransport(context, "login/totp", typeof pending === "string" && pending.length > 0 ? pending : null, info);
 		if (typeof pending !== "string" || pending.length === 0) throw new AuthenticationError(INVALID_CREDENTIALS);
 		const throttler = this.#resolveThrottler();
 		if (throttler !== null) {
@@ -253,15 +262,35 @@ var AuthFlow = class extends Service {
 		return true;
 	}
 	/**
+	* Déconnexion COMPLÈTE : détruit la session locale et rend, si la session
+	* vient d'un fournisseur qui publie un point de déconnexion (Keycloak…),
+	* l'adresse où envoyer le navigateur pour fermer AUSSI sa session à lui —
+	* sans quoi le clic suivant sur « Continuer avec … » reconnecte sans mot de
+	* passe (OpenID Connect RP-Initiated Logout 1.0).
+	*
+	* @returns `destroyed` comme {@link logout} ; `logoutUrl` à suivre, ou `null`.
+	*/
+	async logoutWithProvider(context) {
+		const session = context.session;
+		const logoutUrl = session?.status === "active" ? await this.get("oauth2")?.logoutUrlFor(session) ?? null : null;
+		return {
+			destroyed: await this.logout(context),
+			logoutUrl
+		};
+	}
+	/**
 	* Identité portée par la session courante, re-résolue auprès du provider
 	* (mêmes contrôles que le `SessionAuthenticator` — source unique).
 	*
 	* @returns la projection publique, ou `null` (pas de session, session
-	*   orpheline, compte verrouillé/désactivé) — le handler répond 401.
+	*   orpheline, compte verrouillé/désactivé) — le handler répond `200`
+	*   `{ user: null }`.
 	*/
 	async me(context) {
 		const identifier = context.session?.user;
 		if (typeof identifier !== "string" || identifier.length === 0) return null;
+		const current = requestUser(identifier);
+		if (current !== null) return toSafeUser(current);
 		try {
 			return toSafeUser(await resolveSessionIdentity(this.#resolveUsers(), identifier));
 		} catch (error) {
@@ -269,7 +298,59 @@ var AuthFlow = class extends Service {
 			throw error;
 		}
 	}
-	async #openSession(context, identifier) {
+	/**
+	* Décrit la page de connexion par défaut : ce qu'elle propose et comment
+	* elle s'habille, depuis `security.loginPage` et les fournisseurs
+	* opérationnels.
+	*
+	* Lue par le contrôleur de `@nodefony/framework`, qui n'importe pas ce
+	* paquet. Les fournisseurs sont relus à chaque appel : l'un d'eux peut
+	* tomber ou revenir pendant que le serveur tourne.
+	*
+	* @returns la description, ou `null` quand la page par défaut est
+	*   désactivée (`loginPage.enabled: false`) ou la configuration invalide —
+	*   le contrôleur répond alors 404.
+	*/
+	describeLoginPage() {
+		const page = this.#resolveLoginPage();
+		if (page === null || !page.enabled) return null;
+		const offered = this.get("oauth2")?.listDisplayProviders() ?? [];
+		return {
+			path: page.path,
+			title: page.title ?? null,
+			logo: page.logo ?? null,
+			template: page.template ?? null,
+			heading: page.heading ?? null,
+			subtitle: page.subtitle ?? null,
+			stylesheet: page.stylesheet ?? null,
+			providersFirst: page.providersFirst,
+			hero: page.hero === void 0 ? null : page.hero === false ? false : {
+				heading: page.hero.heading,
+				text: page.hero.text ?? null
+			},
+			footer: page.footer,
+			skin: page.skin,
+			layout: page.layout ?? LOGIN_PAGE_SKIN_SPECS[page.skin].layout,
+			previewPicker: page.previewPicker,
+			previewHook: page.previewHook ?? null,
+			password: page.password,
+			passkey: this.get("webauthn")?.isEnabled() ?? false,
+			providers: offered.map(({ name, label, icon }) => ({
+				name,
+				label,
+				icon: icon ?? null
+			}))
+		};
+	}
+	#resolveLoginPage() {
+		if (!this.#loginPageResolved) {
+			this.#loginPageResolved = true;
+			const parsed = securityConfigSchema.safeParse(this.options);
+			this.#loginPage = parsed.success ? parsed.data.loginPage : null;
+		}
+		return this.#loginPage;
+	}
+	async #openSession(context, identifier, factor) {
 		const session = context.session ?? await this.#resolveSessions().start(context);
 		if (session === null) {
 			this.log("login: session service returned no session", "ERROR");
@@ -287,6 +368,8 @@ var AuthFlow = class extends Service {
 			const ua = provenance.getUserAgent?.();
 			if (ua) session.setMetaBag("ua", ua);
 		} catch {}
+		session.setMetaBag(SESSION_AUTH_AT_KEY, Date.now());
+		session.setMetaBag(SESSION_AMR_KEY, amrForFactor(factor));
 		await session.save(identifier);
 	}
 	#resolveSessions() {
@@ -305,6 +388,23 @@ var AuthFlow = class extends Service {
 		}
 		return this.#users;
 	}
+	#assertTransport(context, door, actor, info) {
+		this.#transport ??= this.get("credentialTransport") ?? null;
+		if (this.#transport === null) return;
+		try {
+			this.#transport.assert(context, door);
+		} catch (error) {
+			if (error instanceof InsecureTransportError) recordAudit(this.container, {
+				category: "auth",
+				action: "login.failure",
+				outcome: "failure",
+				actor,
+				reason: "insecure_transport",
+				...info
+			});
+			throw error;
+		}
+	}
 	#resolveThrottler() {
 		if (!this.#throttlerResolved) {
 			this.#throttler = this.get("loginThrottler") ?? null;
@@ -324,7 +424,7 @@ var AuthFlow = class extends Service {
 function toSafeUser(user) {
 	return {
 		id: user.id,
-		username: user.identifier,
+		identifier: user.identifier,
 		roles: [...user.roles]
 	};
 }

package/dist/nodefony/service/firewall.js

@@ -1,5 +1,9 @@
+import { compileProviderRoleMapping, isPlatformRole } from "../src/oauth/providerRoles.js";
 import { SecuredArea } from "../src/SecuredArea.js";
+import { entryPointLocation } from "../src/entryPoint.js";
 import { LoginThrottler } from "../src/throttle/LoginThrottler.js";
+import { InsecureTransportError } from "../errors/InsecureTransportError.js";
+import { CredentialTransportPolicy, shouldEnforceCredentialTransport } from "../src/transport/CredentialTransportPolicy.js";
 import { RoleHierarchyWalker } from "../src/RoleHierarchyWalker.js";
 import { mergeCspFragments } from "../src/csp.js";
 import { CsrfTokenManager } from "../src/csrfToken.js";
@@ -17,9 +21,10 @@ import { DEFAULT_SYSTEM_RULES, buildFrameAuthorizer, buildSystemRules } from "..
 import { recordAudit } from "../src/audit/recordAudit.js";
 import { readAuditContext } from "../src/audit/readAuditContext.js";
 import { SECURITY_AUDIT_CHANNEL, createAuditBridge } from "../src/audit/auditBridge.js";
+import { findZonesOpenToSignup } from "../src/openToSignup.js";
 import { RequestContext, Service, logColor } from "nodefony";
-import { encoderFromConfig } from "@nodefony/user";
 import { randomBytes } from "node:crypto";
+import { encoderFromConfig } from "@nodefony/user";
 //#region nodefony/service/firewall.ts
 const serviceName = "firewall";
 /**
@@ -87,6 +92,7 @@ var Firewall = class extends Service {
 	#cspFragments = null;
 	#config = null;
 	#configError = null;
+	#longLivedRevalidation = null;
 	constructor(module) {
 		super(serviceName, module.container, module.notificationsCenter, module.options);
 		this.module = module;
@@ -122,6 +128,7 @@ var Firewall = class extends Service {
 			this.#areas = list;
 			this.#instantiateAuthenticators(list);
 		}
+		for (const z of findZonesOpenToSignup(this.#config)) this.log(`${z.message} → ${z.action}`, "WARNING");
 		if (!this.#configError) {
 			this.#wireRealtime();
 			this.log(`Firewall ready — ${this.#areas?.length ?? 0} area(s), ${this.#authenticators?.size ?? 0} authenticator(s)`, "DEBUG");
@@ -172,6 +179,10 @@ var Firewall = class extends Service {
 		this.log(wired ? "Realtime data plane locked — WS handshake authenticators (RBAC) + frame authorizer + audit channel wired" : "Realtime data plane locked — frame authorizer (system floor) wired without qualifying zone; system channels closed to anonymous", "DEBUG");
 	}
 	#provisionSharedServices(config) {
+		this.container?.set("credentialTransport", new CredentialTransportPolicy({
+			enforce: shouldEnforceCredentialTransport(this.kernel?.environment, config.allowInsecureCredentials),
+			log: (message) => this.log(message, "WARNING")
+		}));
 		const specs = Object.values(config.encoders);
 		if (specs.length > 0) this.container?.set("passwordEncoder", encoderFromConfig(specs));
 		const rl = config.rateLimit;
@@ -263,17 +274,27 @@ var Firewall = class extends Service {
 	describe() {
 		const config = this.#config;
 		const mounted = this.#authenticators;
-		const zones = (this.#areas ?? []).map((a) => ({
-			name: a.name,
-			pattern: a.pattern.source,
-			security: a.security,
-			stateless: a.stateless,
-			mode: a.mode,
-			authenticators: [...a.authenticators],
-			allowsAnonymous: a.authenticators.includes("anonymous"),
-			host: a.host ?? null,
-			realtime: a.realtime
-		}));
+		const open = new Map((config ? findZonesOpenToSignup(config) : []).map((z) => [z.zone, z]));
+		const zones = (this.#areas ?? []).map((a) => {
+			const notice = open.get(a.name);
+			return {
+				name: a.name,
+				pattern: a.pattern.source,
+				security: a.security,
+				stateless: a.stateless,
+				mode: a.mode,
+				authenticators: [...a.authenticators],
+				allowsAnonymous: a.authenticators.includes("anonymous"),
+				host: a.host ?? null,
+				realtime: a.realtime,
+				roles: a.roles ? [...a.roles] : [],
+				openToSignup: notice !== void 0,
+				openToSignupNotice: notice ? {
+					message: notice.message,
+					action: notice.action
+				} : null
+			};
+		});
 		const available = new Set(listAuthenticatorFactories());
 		const names = new Set(available);
 		if (mounted) for (const n of mounted.keys()) names.add(n);
@@ -340,12 +361,32 @@ var Firewall = class extends Service {
 		const hierarchy = {};
 		for (const [role, inherited] of Object.entries(raw)) hierarchy[role] = [...inherited];
 		const walker = this.roleHierarchy;
+		const roles = Object.keys(hierarchy).map((role) => ({
+			role,
+			inherits: [...walker.reachableRoles([role])].filter((r) => r !== role).sort()
+		}));
+		const providerMappings = [];
+		for (const [provider, p] of Object.entries(this.#config?.oauth2.providers ?? {})) {
+			const mapping = compileProviderRoleMapping(p);
+			if (mapping === null) continue;
+			providerMappings.push({
+				provider,
+				sources: [...mapping.sources],
+				mappings: Object.keys(mapping.table).sort().map((from) => {
+					const to = mapping.table[from] ?? "";
+					return {
+						from,
+						to,
+						platform: isPlatformRole(to)
+					};
+				}),
+				allowPlatformRoles: p.allowPlatformRoles
+			});
+		}
 		return {
 			hierarchy,
-			roles: Object.keys(hierarchy).map((role) => ({
-				role,
-				inherits: [...walker.reachableRoles([role])].filter((r) => r !== role).sort()
-			}))
+			roles,
+			providerMappings
 		};
 	}
 	/**
@@ -424,7 +465,7 @@ var Firewall = class extends Service {
 	}
 	/**
 	* Pipeline complet de la zone : chaîne d'authenticators (selon `mode`) → ALS
-	* → Zero Trust. Rejette (401, challenge RFC 7235 posé) ou résout.
+	* → Zero Trust. Rejette (401, challenge RFC 9110 §11 posé) ou résout.
 	*/
 	async handleSecurity(context) {
 		if (this.#configError) throw new AuthenticationError("Security configuration invalid");
@@ -449,17 +490,22 @@ var Firewall = class extends Service {
 				this.#recordAuth(context, area, "auth.unverifiable", "failure", "verifier_unavailable", null);
 				throw error;
 			}
+			if (error instanceof InsecureTransportError) {
+				this.#recordAuth(context, area, "auth.failure", "failure", "insecure_transport", null);
+				throw error;
+			}
 			this.#setChallenge(context, area);
 			this.#recordAuth(context, area, "auth.failure", "failure", "invalid_credentials", null);
 			throw error;
 		}
 		if (token === null) {
-			this.#setChallenge(context, area);
+			if (!this.#redirectToEntryPoint(context, area)) this.#setChallenge(context, area);
 			this.#recordAuth(context, area, "auth.denied", "denied", "no_credentials", null);
 			throw new AuthenticationError(`Authentication required for area "${area.name}"`);
 		}
 		RequestContext.set("user", token.getUser());
 		RequestContext.set("token", token);
+		if (token.isAuthenticated()) context.userIdentifier = token.getUserIdentifier();
 		if (!token.isAuthenticated() && token.type !== "anonymous") {
 			this.#setChallenge(context, area);
 			this.#recordAuth(context, area, "auth.denied", "denied", "unauthenticated", token.getUserIdentifier());
@@ -520,8 +566,13 @@ var Firewall = class extends Service {
 	*    synchronizer token (`context.csrfToken`) — HttpContext pose ensuite le cookie
 	*    lisible `csrf-token`. Sinon, hot-path GET = retour immédiat (aucun en-tête lu).
 	*  - **Étape 1 (globale)** : sur une mutation, défense Fetch Metadata / Origin
-	*    (rejet cross-site même sur route publique). Skippée si `@CsrfExempt` (webhook,
-	*    auth par signature/clé) ou `bypassFirewall` (callbacks OAuth).
+	*    (rejet cross-site même sur route publique). Skippée SEULEMENT par `@CsrfExempt`
+	*    (webhook, auth par signature/clé). `bypassFirewall` ne l'en dispense PAS : il
+	*    retire l'authentification, pas la provenance — les routes de connexion sont
+	*    en bypass, et c'est précisément là qu'un formulaire tiers ouvrirait chez la
+	*    victime une session sur le compte de l'attaquant (login CSRF, CWE-352). Un
+	*    appel de serveur à serveur (canal arrière OIDC) ne porte ni `Sec-Fetch-Site`
+	*    ni `Origin` : il passe toujours.
 	*  - **Étape 2 (opt-in)** : sur une mutation `@CsrfProtect`, exige EN PLUS le
 	*    synchronizer token (en-tête `x-csrf-token` ≡ cookie + HMAC valide).
 	*
@@ -529,7 +580,6 @@ var Firewall = class extends Service {
 	*/
 	enforceCsrf(context) {
 		if (!this.#csrf) return;
-		if (context.resolver?.bypassFirewall) return;
 		const ctx = context;
 		if (!Csrf.isStateChanging(context.method)) {
 			if (ctx.csrfProtect && this.#csrfTokens && ctx.csrfToken == null) ctx.csrfToken = this.#csrfTokens.issue();
@@ -577,6 +627,18 @@ var Firewall = class extends Service {
 		return isPreflight ? 204 : void 0;
 	}
 	/**
+	* Le revalidateur de l'identité de la requête courante, pour une connexion
+	* longue qui la gardera (flux SSE). Même règle, même store de jetons que les
+	* sockets WebSocket — un transport qui en aurait une autre serait celui
+	* qu'un attaquant prendrait pour survivre à sa révocation.
+	*
+	* @returns `null` pour un anonyme ; sinon la fonction qui re-valide.
+	*/
+	currentRevalidator() {
+		this.#longLivedRevalidation ??= new FirewallRealtimeAuthenticator(() => this.container?.get("tokenStore") ?? null);
+		return this.#longLivedRevalidation.currentRevalidator();
+	}
+	/**
 	* En-têtes de sécurité APPLICATIFS (P6 J5) — CSP, Referrer-Policy, isolation
 	* cross-origin (COOP/COEP/CORP), Origin-Agent-Cluster, Permissions-Policy.
 	* Posés sur toute réponse du pipeline (branché dans `handleHttp`). Complète le
@@ -690,6 +752,34 @@ var Firewall = class extends Service {
 		}
 		return token;
 	}
+	/**
+	* Pose la redirection vers la page de connexion de la zone, quand la requête
+	* refusée est la navigation d'un navigateur. Cold path (refus seulement).
+	*
+	* La réponse est seulement MARQUÉE (`302` + `Location`) : le refus continue
+	* de remonter, et http rend une réponse déjà redirigée telle quelle au lieu
+	* d'un 401. Capability check : un contexte sans `redirect` (WebSocket) garde
+	* son refus.
+	*
+	* @returns `true` si la redirection est posée
+	*/
+	#redirectToEntryPoint(context, area) {
+		if (area.entryPoint === void 0 || !("redirect" in context)) return false;
+		const request = context.request;
+		const header = (name) => {
+			const value = request.headers[name];
+			return typeof value === "string" ? value : void 0;
+		};
+		const location = entryPointLocation(area.entryPoint, {
+			method: request.method,
+			accept: header("accept"),
+			fetchMode: header("sec-fetch-mode"),
+			path: request.url.pathname + request.url.search
+		});
+		if (location === null) return false;
+		context.redirect(location, 302);
+		return true;
+	}
 	#setChallenge(context, area) {
 		const response = context.response;
 		if (typeof response?.setHeader !== "function") return;