@nodefony/security 10.0.0-beta.5 → 10.0.0-beta.7

package/dist/nodefony/service/firewall.js

@@ -1,20 +1,21 @@
-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 { rolesWithin } from "../src/rolesWithin.js";
-import { mergeCspFragments } from "../src/csp.js";
+import { assertCspFragment, findInertScriptSources, findOverbroadSources, mergeCspFragments, parseCsp, reportUrlProblem, withFrameAncestors, withViolationReports, withoutOverbroadSources } from "../src/csp.js";
+import { CspReportCollector } from "../src/cspReports.js";
 import { CsrfTokenManager } from "../src/csrfToken.js";
-import { CsrfError } from "../errors/CsrfError.js";
 import { Csrf } from "./csrf.js";
 import { Cors } from "./cors.js";
-import { SecurityHeaders } from "./securityHeaders.js";
+import { SecurityHeaders, responseKindOf } from "./securityHeaders.js";
 import { AuthenticationError } from "../errors/AuthenticationError.js";
+import { StaleSessionError } from "../errors/StaleSessionError.js";
 import { ThrottledError } from "../errors/ThrottledError.js";
 import { UnverifiableTokenError } from "../errors/UnverifiableTokenError.js";
+import { InsecureTransportError } from "../errors/InsecureTransportError.js";
+import { CsrfError } from "../errors/CsrfError.js";
 import { defineSecurityConfig } from "../config/defineModuleConfig.js";
 import { getAuthenticatorFactory, listAuthenticatorFactories } from "../src/authenticator/authenticatorRegistry.js";
 import { FirewallRealtimeAuthenticator } from "../src/authenticator/FirewallRealtimeAuthenticator.js";
@@ -23,8 +24,10 @@ 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 { ROLES_WITHIN, RequestContext, Service, logColor } from "nodefony";
+import { compileProviderRoleMapping, isPlatformRole } from "../src/oauth/providerRoles.js";
+import { CSP_REPORT_GROUP, CSP_REPORT_PATH, ROLES_WITHIN, RequestContext, SESSION_AUTH_CHALLENGE, Service, logColor } from "nodefony";
 import { randomBytes } from "node:crypto";
+import { rpcCorsLists } from "@nodefony/http";
 import { encoderFromConfig } from "@nodefony/user";
 // nodefony/service/firewall.ts
 const serviceName = "firewall";
@@ -35,29 +38,27 @@ const serviceName = "firewall";
 * genre de dépense que la règle de lazy-allocation proscrit.
 */
 const EMPTY_PROTECTED_RESOURCES = Object.freeze([]);
+/**
+* `Cache-Control` par défaut d'une réponse dont la CSP porte un nonce : jamais
+* gardée par un cache partagé (le nonce y serait servi à plusieurs visiteurs),
+* toujours redemandée avant réutilisation (ADR-0024 §C2).
+*/
+const NONCED_DOCUMENT_CACHE_CONTROL = "private, no-cache";
 function headerValue(headers, name) {
 	const v = headers?.[name];
 	return Array.isArray(v) ? v[0] : v;
 }
 /**
-* Extrait la valeur d'un cookie de l'en-tête `Cookie` brut (lecture directe, sans
-* dépendre du parse du Context — robuste quel que soit l'ordre du pipeline).
-* Retient la 1ʳᵉ occurrence du nom. Utilisé par la défense synchronizer CSRF.
+* Valeur d'un cookie de la requête, lue sur le contexte : l'en-tête `Cookie`
+* n'a qu'UN lecteur, `cookiesParser` (`@nodefony/http`), qui tourne à la
+* construction du contexte — donc avant toute étape du pare-feu. Une seconde
+* lecture ici divergeait (décodage, doublons) et levait sur un `%` isolé.
 */
-function cookieValue(cookieHeader, name) {
-	if (!cookieHeader) return void 0;
-	for (const part of cookieHeader.split(";")) {
-		const eq = part.indexOf("=");
-		if (eq === -1) continue;
-		if (part.slice(0, eq).trim() === name) return decodeURIComponent(part.slice(eq + 1).trim());
-	}
+function requestCookie(context, name) {
+	const value = context.cookies[name]?.value;
+	return typeof value === "string" ? value : void 0;
 }
 /**
-* Défi posé sur un 401 quand aucun authenticator de la zone n'en déclare
-* (RFC 9110 §15.5.2). Schéma inconnu des navigateurs : aucune fenêtre de login.
-*/
-const FALLBACK_CHALLENGE = "Session realm=\"nodefony\"";
-/**
 * Orchestrateur de sécurité Nodefony — refonte 2026 (P6).
 *
 * `isSecure()` (hot-path, court-circuit si aucune zone) ne fait QUE matcher la
@@ -76,7 +77,7 @@ const FALLBACK_CHALLENGE = "Session realm=\"nodefony\"";
 *
 * Conformité : tout 401 porte un challenge `WWW-Authenticate` (RFC 9110
 * §15.5.2) — celui du premier authenticator de la zone qui en déclare un, sinon
-* le défi de repli {@link FALLBACK_CHALLENGE}.
+* le défi de repli {@link SESSION_AUTH_CHALLENGE}.
 *
 * CORS, CSRF et autorisation par décorateurs viennent se brancher en S4/S5.
 * Toutes les structures sont **lazy** (perf : une app sans zone = zéro alloc).
@@ -91,6 +92,11 @@ var Firewall = class extends Service {
 	#cors = null;
 	#securityHeaders = null;
 	#cspFragments = null;
+	#cspMerged = null;
+	#cspBase = "";
+	#appCspSources = null;
+	#cspReportUrl = null;
+	#reportingEndpoints = null;
 	#config = null;
 	#configError = null;
 	#longLivedRevalidation = null;
@@ -98,6 +104,29 @@ var Firewall = class extends Service {
 		super(serviceName, module.container, module.notificationsCenter, module.options);
 		this.module = module;
 		this.kernel?.once("onBoot", () => this.#build());
+		this.kernel?.once("onReady", () => this.#widenCorsForRpc());
+	}
+	/**
+	* Ajoute à la politique CORS les méthodes et en-têtes que demandent les
+	* protocoles RPC — dès qu'un service gRPC est déclaré et que le CORS est
+	* actif (ADR-0026 D9 point 2). Le préflight part AVANT le routage et ne
+	* connaît pas la route : l'union est la seule voie. Une seule politique,
+	* celle de l'application ; calculée une fois, annoncée au démarrage.
+	*/
+	#widenCorsForRpc() {
+		const config = this.#config;
+		const rpc = rpcCorsLists();
+		if (this.#cors === null || config === null || rpc === null) return;
+		const methods = withMissing(config.cors.methods, rpc.allowedMethods);
+		const allowedHeaders = withMissing(config.cors.allowedHeaders, rpc.allowedHeaders);
+		const added = [...methods.added, ...allowedHeaders.added];
+		if (added.length === 0) return;
+		this.#cors = new Cors({
+			...config.cors,
+			methods: methods.list,
+			allowedHeaders: allowedHeaders.list
+		});
+		this.log(`CORS : service gRPC déclaré — le préflight autorise aussi ${added.join(", ")} (ADR-0026 D9)`, "INFO");
 	}
 	#build() {
 		try {
@@ -121,7 +150,25 @@ var Firewall = class extends Service {
 			this.#csrfTokens = new CsrfTokenManager(secret);
 		}
 		if (this.#config.cors.enabled) this.#cors = new Cors(this.#config.cors);
-		if (this.#config.headers.enabled) this.#securityHeaders = new SecurityHeaders(this.#config.headers);
+		if (this.#config.headers.enabled) {
+			this.#appCspSources = this.#validatedAppCspSources(this.#config.headers.cspSources);
+			this.#cspReportUrl = this.#validatedCspReportUrl(this.#config.headers.cspReport);
+			this.#cspBase = this.#composeCspBase(this.#config.headers.csp);
+			this.#securityHeaders = this.#newSecurityHeaders({
+				...this.#config.headers,
+				csp: this.#cspBase
+			});
+			if (this.#reportingEndpoints !== null && this.#cspReportUrl === CSP_REPORT_PATH) this.container?.set("cspReports", new CspReportCollector({
+				endpoint: CSP_REPORT_PATH,
+				log: (message, severity) => this.log(message, severity)
+			}));
+			this.#cspMerged = null;
+			if (this.#cspFragments !== null && this.#cspFragments.size > 0) {
+				this.#rebuildSecurityHeaders();
+				for (const [name, fragment] of this.#cspFragments) this.#warnInertScriptSources(name, fragment);
+			}
+			for (const [directive, source] of findOverbroadSources(parseCsp(this.#config.headers.csp))) this.log(`CSP de l’application : « ${source} » dans ${directive} ouvre la directive à n’importe quel contenu — conservée (choix de la configuration) ; préférer une origine exacte.`, "WARNING");
+		}
 		const areas = this.#config.areas;
 		if (Object.keys(areas).length) {
 			const list = [];
@@ -258,7 +305,7 @@ var Firewall = class extends Service {
 	* @param config - config security, utilisée en repli si le HttpKernel est absent.
 	*/
 	#transportHeaderState(config) {
-		const emitted = (this.container?.get("HttpKernel"))?.describeTransportSecurityHeaders?.();
+		const emitted = this.#emittedTransportHeaders();
 		if (!emitted) return {
 			hsts: config.headers.hsts,
 			hstsMaxAgeS: config.headers.hstsMaxAgeS,
@@ -530,8 +577,7 @@ var Firewall = class extends Service {
 	* @returns la trace fraîche (posée sur le context), ou `null` hors profiling.
 	*/
 	#startTrace(context) {
-		const ctx = context;
-		if (!ctx.profiling) return null;
+		if (!context.profiling) return null;
 		const trace = {
 			authenticator: null,
 			outcome: "denied",
@@ -539,7 +585,7 @@ var Firewall = class extends Service {
 			user: null,
 			roles: null
 		};
-		ctx.securityTrace = trace;
+		context.securityTrace = trace;
 		return trace;
 	}
 	#recordAuth(context, area, action, outcome, reason, actor) {
@@ -597,7 +643,7 @@ var Firewall = class extends Service {
 			host: headerValue(headers, "host") ?? headerValue(headers, ":authority") ?? context.domain
 		});
 		if (ctx.csrfProtect && this.#csrfTokens) {
-			if (!this.#csrfTokens.verify(headerValue(headers, "x-csrf-token"), cookieValue(headerValue(headers, "cookie"), "csrf-token"))) throw new CsrfError("Missing or invalid CSRF token");
+			if (!this.#csrfTokens.verify(headerValue(headers, "x-csrf-token"), requestCookie(context, "csrf-token"))) throw new CsrfError("Missing or invalid CSRF token");
 		}
 	}
 	/**
@@ -643,39 +689,195 @@ var Firewall = class extends Service {
 	/**
 	* 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
-	* socle transport de `@nodefony/http` (nosniff/frame/HSTS, posé à l'entrée brute)
-	* SANS le ré-émettre. No-op si désactivé ou réponse non-HTTP (WS).
+	* Appelé par la réponse juste avant son `writeHead`, une fois son type fixé :
+	* la politique suit ce type (ADR-0024 §C11). Complète le socle transport de
+	* `@nodefony/http` (nosniff/frame/HSTS) SANS le ré-émettre. No-op si désactivé
+	* ou réponse non-HTTP (WS).
 	*
 	* En-têtes constants = table figée pré-calculée au boot (0 alloc/concat). Le CSP
-	* nonce/req (étape B) ajoute 1 `join` + 1 `setHeader` UNIQUEMENT si activé.
+	* nonce/req ajoute 1 `join` + 1 `setHeader`, sur un document seulement.
+	*
+	* @param context - contexte de la réponse.
+	* @param contentType - `Content-Type` de la réponse ; `null` = sans contenu ;
+	*   omis = type inconnu, servi comme un document (politique complète).
+	* @param servedAsFile - le corps est servi tel quel (fichier statique,
+	*   relais) : aucun gabarit ne l'a écrit, il ne peut pas porter de nonce. Un
+	*   document reçoit alors la politique sans nonce ni `'strict-dynamic'`
+	*   (ADR-0024 §C1) ; les autres types n'en changent pas.
 	*/
-	applySecurityHeaders(context) {
+	applySecurityHeaders(context, contentType, servedAsFile = false) {
 		const sh = this.#securityHeaders;
 		if (!sh) return;
 		const response = context.response;
 		if (typeof response?.setHeader !== "function") return;
-		const headers = sh.headers;
+		const extra = context.cspDirectives;
+		const tls = context.scheme === "https";
+		const validated = typeof response.setDefaultHeader === "function";
+		if (extra == null) {
+			const kind = responseKindOf(contentType);
+			if (kind !== "document" || servedAsFile) {
+				const table = kind === "document" ? sh.headersForServedFile(tls) : sh.headersForResource(kind, tls);
+				for (const name in table) {
+					const value = table[name];
+					if (value === void 0) continue;
+					if (validated) response.setDefaultHeader?.(name, value);
+					else response.setHeader(name, value);
+				}
+				return;
+			}
+		}
+		const headers = sh.headersFor(tls, extra != null && !sh.hasNonce);
 		for (const name in headers) {
 			const value = headers[name];
-			if (value !== void 0) response.setHeader(name, value);
+			if (value === void 0) continue;
+			if (validated) response.setDefaultHeader?.(name, value);
+			else response.setHeader(name, value);
 		}
-		const extra = context.cspDirectives;
+		let csp = null;
 		if (sh.hasNonce) {
 			const nonce = context.cspNonce;
-			response.setHeader("Content-Security-Policy", extra ? sh.cspForExtra(nonce, extra) : sh.cspFor(nonce));
-		} else if (extra) response.setHeader("Content-Security-Policy", sh.cspForExtra("", extra));
+			csp = extra ? sh.cspForExtra(nonce, extra, tls) : sh.cspFor(nonce, tls);
+		} else if (extra) csp = sh.cspForExtra("", extra, tls);
+		if (csp !== null) {
+			if (validated) response.setDefaultHeader?.("Content-Security-Policy", csp);
+			else response.setHeader("Content-Security-Policy", csp);
+		}
+		if (sh.hasNonce) {
+			if (validated) response.setDefaultHeader?.("Cache-Control", NONCED_DOCUMENT_CACHE_CONTROL);
+			else response.setHeader("Cache-Control", NONCED_DOCUMENT_CACHE_CONTROL);
+		}
 	}
 	/**
 	* Déclare des directives CSP additionnelles pour `moduleName` (cf `IFirewall`).
 	* No-op si les en-têtes applicatifs sont désactivés (pas de CSP à étendre).
 	* Recompose `#securityHeaders` (merge + re-split nonce) — hors hot-path.
 	*/
-	registerCspOrigins(moduleName, fragment) {
+	registerCspOrigins(moduleName, declared) {
+		const config = this.#config;
+		if (config !== null && this.#securityHeaders === null) return;
+		try {
+			assertCspFragment(declared, moduleName);
+		} catch (error) {
+			this.log(`CSP : contribution de ${moduleName} IGNORÉE — ${error instanceof Error ? error.message : String(error)}`, "ERROR");
+			return;
+		}
+		const { fragment, dropped } = withoutOverbroadSources(declared);
+		for (const [directive, source] of dropped) this.log(`CSP : « ${source} » déclarée par ${moduleName} dans ${directive} ouvre la directive à n’importe quel contenu — RETIRÉE de la politique ; déclarer l’origine exacte.`, "WARNING");
+		const fragments = this.#cspFragments ??= /* @__PURE__ */ new Map();
+		if (config === null) {
+			fragments.set(moduleName, fragment);
+			return;
+		}
+		this.#warnInertScriptSources(moduleName, fragment);
+		const previous = fragments.get(moduleName);
+		if (previous !== void 0 || this.#cspMerged === null && fragments.size > 0) {
+			fragments.set(moduleName, fragment);
+			try {
+				this.#rebuildSecurityHeaders();
+			} catch (error) {
+				if (previous === void 0) fragments.delete(moduleName);
+				else fragments.set(moduleName, previous);
+				throw error;
+			}
+			return;
+		}
+		const csp = mergeCspFragments(this.#cspMerged ?? this.#cspBase, [fragment]);
+		fragments.set(moduleName, fragment);
+		this.#cspMerged = csp;
+		this.#securityHeaders = this.#newSecurityHeaders({
+			...config.headers,
+			csp
+		});
+	}
+	/**
+	* Le noyau HTTP a recalculé ses en-têtes de transport (édition à chaud de sa
+	* config) : la politique suit `frameOptions`, qui pilote aussi
+	* `frame-ancestors` (ADR-0024 §C5). Hors chemin chaud.
+	*/
+	onTransportHeadersChanged() {
 		if (!this.#securityHeaders || !this.#config) return;
-		(this.#cspFragments ??= /* @__PURE__ */ new Map()).set(moduleName, fragment);
+		const base = this.#composeCspBase(this.#config.headers.csp);
+		if (base === this.#cspBase) return;
+		this.#cspBase = base;
 		this.#rebuildSecurityHeaders();
 	}
+	/**
+	* Politique de base : la config, complétée de `frame-ancestors` dérivé de ce
+	* que le noyau HTTP émet en `X-Frame-Options`. Lu chez l’émetteur, par son
+	* contrat d’introspection ; sans noyau HTTP, rien n’est dérivé.
+	*/
+	#composeCspBase(csp) {
+		const emitted = this.#emittedTransportHeaders();
+		const framed = emitted ? withFrameAncestors(csp, emitted.frameOptions) : csp;
+		const sources = this.#appCspSources;
+		const merged = sources === null || csp.trim() === "" ? framed : mergeCspFragments(framed, sources);
+		if (this.#cspReportUrl === null) {
+			this.#reportingEndpoints = null;
+			return merged;
+		}
+		const reported = withViolationReports(merged, this.#cspReportUrl, CSP_REPORT_GROUP);
+		this.#reportingEndpoints = reported.added ? `${CSP_REPORT_GROUP}="${this.#cspReportUrl}"` : null;
+		return reported.csp;
+	}
+	/**
+	* Lit `headers.cspReport` : `true` = la route du framework, une chaîne = le
+	* collecteur de l’application, `false` = aucun rapport. Une URL qu’un en-tête
+	* ne peut pas porter est RETIRÉE et dite (ADR-0024 C0 : une faute de
+	* configuration de sécurité n’empêche pas le démarrage).
+	*/
+	#validatedCspReportUrl(value) {
+		if (value === false) return null;
+		if (value === true) return CSP_REPORT_PATH;
+		const problem = reportUrlProblem(value);
+		if (problem === null) return value;
+		this.log(`CSP : headers.cspReport « ${value.slice(0, 120)} » IGNORÉE — ${problem} ; aucun rapport de violation demandé.`, "ERROR");
+		return null;
+	}
+	/**
+	* Dit, une fois, les sources de scripts d'un module que `'strict-dynamic'`
+	* rend inertes (cf `findInertScriptSources`) : gardées pour un navigateur
+	* CSP2, elles n'ouvrent rien aux autres — le module doit charger son script
+	* depuis un script signé.
+	*
+	* @param moduleName - module qui a déclaré le fragment
+	* @param fragment - fragment retenu (sources trop larges déjà retirées)
+	*/
+	#warnInertScriptSources(moduleName, fragment) {
+		for (const [directive, source] of findInertScriptSources(fragment, this.#cspBase)) this.log(`CSP : « ${source} » déclarée par ${moduleName} dans ${directive} est INERTE sous 'strict-dynamic' (navigateurs CSP3) — conservée pour CSP2 ; charger ce script depuis un script signé.`, "WARNING");
+	}
+	/**
+	* Valide les contributions nommées de `headers.cspSources`, une fois. Une
+	* contribution malformée est IGNORÉE et dite (l'application démarre, plus
+	* stricte) ; une source ouverte à tout hôte est GARDÉE — choix écrit par
+	* l'application, comme sa politique — et dite.
+	*
+	* @param declared - contributions par nom
+	* @returns les fragments retenus, ou `null` s'il n'y en a aucun
+	*/
+	#validatedAppCspSources(declared) {
+		let kept = null;
+		for (const [name, fragment] of Object.entries(declared)) {
+			try {
+				assertCspFragment(fragment, name);
+			} catch (error) {
+				this.log(`CSP : headers.cspSources.${name} IGNORÉE — ${error instanceof Error ? error.message : String(error)}`, "ERROR");
+				continue;
+			}
+			for (const [directive, source] of withoutOverbroadSources(fragment).dropped) this.log(`CSP : « ${source} » dans headers.cspSources.${name} (${directive}) ouvre la directive à n’importe quel contenu — conservée (choix de la configuration) ; préférer une origine exacte.`, "WARNING");
+			(kept ??= []).push(fragment);
+		}
+		return kept;
+	}
+	/**
+	* En-têtes de transport que le noyau HTTP ÉMET, lus par son contrat
+	* d’introspection, jamais par ses champs internes : `security` ne dépend pas
+	* de la mécanique de cache du kernel HTTP, seulement de ce qu’il déclare.
+	*
+	* @returns les valeurs émises, `undefined` sans noyau HTTP au conteneur.
+	*/
+	#emittedTransportHeaders() {
+		return (this.container?.get("HttpKernel"))?.describeTransportSecurityHeaders?.();
+	}
 	/** Retire les directives CSP de `moduleName` et recompose si nécessaire. */
 	unregisterCspOrigins(moduleName) {
 		if (!this.#cspFragments?.delete(moduleName)) return;
@@ -690,13 +892,27 @@ var Firewall = class extends Service {
 	#rebuildSecurityHeaders() {
 		const headers = this.#config?.headers;
 		if (!headers) return;
-		const csp = this.#cspFragments && this.#cspFragments.size > 0 ? mergeCspFragments(headers.csp, this.#cspFragments.values()) : headers.csp;
-		this.#securityHeaders = new SecurityHeaders({
+		const base = this.#cspBase;
+		const csp = this.#cspFragments && this.#cspFragments.size > 0 ? mergeCspFragments(base, this.#cspFragments.values()) : base;
+		this.#cspMerged = csp === base ? null : csp;
+		this.#securityHeaders = this.#newSecurityHeaders({
 			...headers,
 			csp
 		});
 	}
 	/**
+	* Construit la table des en-têtes applicatifs, branchée sur le journal : un
+	* `@Csp` de route hors grammaire est IGNORÉ (politique de base servie) et dit.
+	*/
+	#newSecurityHeaders(headers) {
+		return new SecurityHeaders({
+			...headers,
+			reportingEndpoints: this.#reportingEndpoints
+		}, (error) => {
+			this.log(`CSP : directives @Csp d’une route IGNORÉES, la politique de base est servie — ${error instanceof Error ? error.message : String(error)}`, "ERROR");
+		});
+	}
+	/**
 	* Exécute la chaîne d'authenticators de la zone selon son `mode`.
 	*
 	* `first` : le premier dont `supports()` est vrai authentifie — un credential
@@ -731,6 +947,10 @@ var Firewall = class extends Service {
 				authenticated = await authenticator.authenticate(created);
 			} catch (error) {
 				await authenticator.onFailure(context, error);
+				if (error instanceof StaleSessionError && area.mode === "first") {
+					this.log(`session périmée purgée (area "${area.name}", authenticator "${name}") — la requête continue sans elle`, "WARNING");
+					continue;
+				}
 				if (error instanceof AuthenticationError) {
 					this.log(`authentication failed (area "${area.name}", authenticator "${name}")`, "WARNING");
 					throw error;
@@ -792,11 +1012,28 @@ var Firewall = class extends Service {
 				return;
 			}
 		}
-		response.setHeader("WWW-Authenticate", FALLBACK_CHALLENGE);
+		response.setHeader("WWW-Authenticate", SESSION_AUTH_CHALLENGE);
 	}
 	log(pci, severity, msgid, msg) {
 		if (!msgid) msgid = logColor.cyan("FIREWALL");
 		return super.log(pci, severity, msgid, msg);
 	}
 };
-export { Firewall, Firewall as default };
+/**
+* La liste `base` complétée des entrées de `extra` qu'elle ne porte pas encore
+* — comparaison sans casse (les noms d'en-têtes et de méthodes HTTP ne
+* distinguent pas la casse) ; l'ordre et l'écriture de `base` sont gardés.
+*
+* @param base - la liste de la configuration.
+* @param extra - les entrées à garantir.
+* @returns la liste complétée et les entrées ajoutées.
+*/
+function withMissing(base, extra) {
+	const known = new Set(base.map((entry) => entry.toLowerCase()));
+	const added = extra.filter((entry) => !known.has(entry.toLowerCase()));
+	return {
+		list: [...base, ...added],
+		added
+	};
+}
+export { Firewall, Firewall as default, NONCED_DOCUMENT_CACHE_CONTROL };

package/dist/nodefony/service/keycloak.js

@@ -1,5 +1,5 @@
-import { readIfPresentSync } from "../src/token/secretFile.js";
 import { defineSecurityConfig } from "../config/defineModuleConfig.js";
+import { readIfPresentSync } from "../src/token/secretFile.js";
 import { buildKeycloakRealm, mergeKeycloakRealm, renderKeycloakRealm } from "../keycloak/keycloakRealm.js";
 import { KeycloakRealmError, deriveKeycloakRealmInput, keycloakLoginTheme } from "../keycloak/keycloakRealmInput.js";
 import { KeycloakAdminClient, keycloakAdminTarget } from "../keycloak/keycloakAdmin.js";

package/dist/nodefony/service/oauth2.js

@@ -1,14 +1,16 @@
-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 { AuthenticationError } from "../errors/AuthenticationError.js";
 import { keycloakLoginThemeCheck } from "../keycloak/keycloakAdmin.js";
+import { recordAudit } from "../src/audit/recordAudit.js";
+import { getOAuthProviderFactory, listOAuthProviders, oauthProviderImageSources, oauthProviderRequiresIssuer } from "../src/oauth/oauthProviderRegistry.js";
 import { generateCodeVerifier, generateState } from "../src/oauth/oauth2Client.js";
-import { getOAuthProviderFactory, listOAuthProviders, oauthProviderRequiresIssuer } from "../src/oauth/oauthProviderRegistry.js";
 import { diagnoseOAuthProvider } from "../src/oauth/providerDiagnosis.js";
+import { compileProviderRoleMapping, isPlatformRole, mapProviderRoles } from "../src/oauth/providerRoles.js";
 import { BootConfigurationError, LOGIN_PAGE_PATH, Service, canonicalIssuer } from "nodefony";
 // nodefony/service/oauth2.ts
 const serviceName = "oauth2";
+/** Nom sous lequel la connexion sociale contribue à la politique de contenu. */
+const OAUTH2_CSP_CONTRIBUTOR = "oauth2";
 /**
 * Clé de session de l'indice de déconnexion. Lue et écrite par CE service
 * seulement ({@link OAuth2Service.rememberLogout},
@@ -242,6 +244,8 @@ var OAuth2Service = class extends Service {
 		}
 		this.#config = config;
 		this.#ready = true;
+		const imageSources = oauthProviderImageSources(active);
+		if (imageSources.length > 0) this.get("firewall")?.registerCspOrigins(OAUTH2_CSP_CONTRIBUTOR, { "img-src": imageSources });
 		this.log(`oauth2 ready — providers: [${active.join(", ") || "aucun"}]`, "DEBUG");
 		if (this.kernel?.runProfile.servers === true) for (const name of active) this.#probe(name);
 	}