@nodefony/security 10.0.0-beta.4 → 10.0.0-beta.6

package/dist/nodefony/service/securityHeaders.js

@@ -1,5 +1,57 @@
-import { mergeCspFragments } from "../src/csp.js";
+import { UPGRADE_INSECURE_REQUESTS, mergeCspFragments, parseCsp, serializeCsp, withoutDirective } from "../src/csp.js";
+import { BootConfigurationError } from "nodefony";
+import { validateHeaderValue } from "node:http";
 // nodefony/service/securityHeaders.ts
+/**
+* Types qu'un navigateur rend comme un document, donc qui exécutent la
+* politique : HTML, et tout type XML (WHATWG MIME Sniffing §4.6, « XML MIME
+* type » — `text/xml`, `application/xml`, sous-type en `+xml`, dont XHTML et
+* SVG ; ces derniers sont lus par {@link responseKindOf}).
+*/
+const DOCUMENT_TYPES = /* @__PURE__ */ new Set([
+	"text/html",
+	"text/xml",
+	"application/xml"
+]);
+/** Essences d'un type MIME JavaScript (WHATWG MIME Sniffing § 4.6). */
+const SCRIPT_TYPES = /* @__PURE__ */ new Set([
+	"application/ecmascript",
+	"application/javascript",
+	"application/x-ecmascript",
+	"application/x-javascript",
+	"text/ecmascript",
+	"text/javascript",
+	"text/javascript1.0",
+	"text/javascript1.1",
+	"text/javascript1.2",
+	"text/javascript1.3",
+	"text/javascript1.4",
+	"text/javascript1.5",
+	"text/jscript",
+	"text/livescript",
+	"text/x-ecmascript",
+	"text/x-javascript"
+]);
+/**
+* Range une réponse dans sa famille d'après son `Content-Type`.
+*
+* @param contentType - valeur de `Content-Type` (paramètres admis) ; `null` =
+*   réponse sans contenu ; `undefined` = type INCONNU de l'appelant, traité en
+*   document — la politique la plus complète, jamais une plus faible par défaut.
+* @returns la famille dont la réponse reçoit la politique.
+*/
+function responseKindOf(contentType) {
+	if (contentType === void 0) return "document";
+	if (contentType === null) return "other";
+	const semi = contentType.indexOf(";");
+	const essence = (semi === -1 ? contentType : contentType.slice(0, semi)).trim().toLowerCase();
+	if (DOCUMENT_TYPES.has(essence)) return "document";
+	if (SCRIPT_TYPES.has(essence)) return "script";
+	if (essence.endsWith("+xml")) return "document";
+	return "other";
+}
+/** Politique des réponses qui ne sont ni document ni script (ADR-0024 §C11). */
+const NARROW_CSP = "default-src 'none'";
 /** Marqueur substitué par le nonce CSP de la requête (cf `Context.cspNonce`). */
 const NONCE_PLACEHOLDER = "{{nonce}}";
 /**
@@ -9,54 +61,121 @@ const NONCE_PLACEHOLDER = "{{nonce}}";
 * cross-origin COOP/COEP/CORP, Origin-Agent-Cluster, Permissions-Policy) → zéro
 * alloc, zéro concat par requête (le firewall la pose telle quelle).
 *
-* **Étape A+B** : en-têtes constants pré-calculés au boot (Referrer/COOP/…). Pour le
-* CSP, deux régimes mutuellement exclusifs : **statique** (posé tel quel via `headers`,
-* 0 alloc/req) OU **nonce par requête** (`cspNonces` + placeholder `{{nonce}}` dans le
-* CSP) → segments pré-split au boot, recomposés par requête via `cspFor(nonce)` (1
-* `join`, aucun parse/regex dans le hot-path). Le nonce lui-même vit sur `Context`.
+* Pour le CSP, deux régimes mutuellement exclusifs : **statique** (posé tel quel via
+* `headers`, 0 alloc/req) OU **nonce par requête** (`cspNonces` + placeholder
+* `{{nonce}}`) → segments pré-split au boot, recomposés par requête via
+* `cspFor(nonce)` (1 concaténation, aucun parse/regex dans le hot-path).
+*
+* **Deux variantes, composées au boot** (ADR-0024 §C6) : la politique telle
+* qu'écrite, servie en TLS, et la même SANS `upgrade-insecure-requests`, servie
+* en clair — sur une page `http`, la directive réécrirait les sous-ressources en
+* `https`, que le serveur ne sert pas. Sans la directive, les deux variantes sont
+* le MÊME objet : par requête, un booléen choisit, rien de plus.
 *
 * @see Fetch Metadata · W3C CSP Level 3 · WHATWG (COOP/COEP/CORP).
 */
 var SecurityHeaders = class {
-	#headers;
-	#cspParts;
-	#cspPrefix;
-	#cspSuffix;
-	#cspRaw;
-	constructor(o) {
-		const h = {};
-		let cspParts = null;
-		if (o.csp) {
-			if (o.cspNonces && o.csp.includes(NONCE_PLACEHOLDER)) cspParts = o.csp.split(NONCE_PLACEHOLDER);
-			else {
-				const csp = o.cspNonces ? o.csp : o.csp.replace(/\s*'nonce-\{\{nonce\}\}'/g, "");
-				if (csp) h["Content-Security-Policy"] = csp;
-			}
-		}
-		if (o.referrerPolicy) h["Referrer-Policy"] = o.referrerPolicy;
-		if (o.coop) h["Cross-Origin-Opener-Policy"] = o.coop;
-		if (o.coep) h["Cross-Origin-Embedder-Policy"] = o.coep;
-		if (o.corp) h["Cross-Origin-Resource-Policy"] = o.corp;
-		if (o.originAgentCluster) h["Origin-Agent-Cluster"] = "?1";
-		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;
+	#tls;
+	#plain;
+	#hasNonce;
+	#scriptTls;
+	#scriptPlain;
+	#other;
+	#fileTls;
+	#filePlain;
+	#extraComposed = null;
+	/** Prévenu (une fois par jeu de directives) quand un `@Csp` de route est ignoré. */
+	#onRejectedExtra;
+	/**
+	* @param o - options des en-têtes (config `security.headers`, CSP déjà fusionnée).
+	* @param onRejectedExtra - appelé quand les directives `@Csp` d'une route sortent
+	*   de la grammaire CSP3 : la route sert alors la politique de base.
+	*/
+	constructor(o, onRejectedExtra) {
+		this.#onRejectedExtra = onRejectedExtra ?? null;
+		const common = {};
+		if (o.referrerPolicy) common["Referrer-Policy"] = o.referrerPolicy;
+		if (o.coop) common["Cross-Origin-Opener-Policy"] = o.coop;
+		if (o.coep) common["Cross-Origin-Embedder-Policy"] = o.coep;
+		if (o.corp) common["Cross-Origin-Resource-Policy"] = o.corp;
+		if (o.originAgentCluster) common["Origin-Agent-Cluster"] = "?1";
+		if (o.permissionsPolicy) common["Permissions-Policy"] = o.permissionsPolicy;
+		if (o.reportingEndpoints) common["Reporting-Endpoints"] = o.reportingEndpoints;
+		for (const name in common) assertHeaderValue(name, common[name] ?? "");
+		const nonced = Boolean(o.csp) && o.cspNonces && o.csp.includes(NONCE_PLACEHOLDER);
+		this.#hasNonce = nonced;
+		this.#tls = buildVariant(o.csp, o.cspNonces, nonced, common);
+		const plainCsp = withoutDirective(o.csp, UPGRADE_INSECURE_REQUESTS);
+		this.#plain = plainCsp === o.csp ? this.#tls : buildVariant(plainCsp, o.cspNonces, nonced, common);
+		const other = {};
+		if (o.referrerPolicy) other["Referrer-Policy"] = o.referrerPolicy;
+		if (o.corp) other["Cross-Origin-Resource-Policy"] = o.corp;
+		const script = { ...other };
+		if (o.coep) script["Cross-Origin-Embedder-Policy"] = o.coep;
+		if (o.reportingEndpoints) script["Reporting-Endpoints"] = o.reportingEndpoints;
+		const scriptCsp = purgeNoncePlaceholder(o.csp);
+		this.#scriptTls = freezeTable(scriptCsp, script);
+		const scriptPlainCsp = withoutDirective(scriptCsp, UPGRADE_INSECURE_REQUESTS);
+		this.#scriptPlain = scriptPlainCsp === scriptCsp ? this.#scriptTls : freezeTable(scriptPlainCsp, script);
+		this.#other = freezeTable(narrowCspOf(o.csp), other);
+		const fileCsp = purgeNonceForDocument(o.csp);
+		this.#fileTls = freezeTable(fileCsp, common);
+		const filePlainCsp = withoutDirective(fileCsp, UPGRADE_INSECURE_REQUESTS);
+		this.#filePlain = filePlainCsp === fileCsp ? this.#fileTls : freezeTable(filePlainCsp, common);
+	}
+	/**
+	* Table d'en-têtes figée d'un DOCUMENT servi tel quel — fichier statique,
+	* réponse relayée — dont le corps ne passe par aucun gabarit et ne peut donc
+	* pas porter de nonce (ADR-0024 §C1) : politique complète sans nonce ni
+	* `'strict-dynamic'` orphelin, et tous les en-têtes d'un document.
+	*
+	* @param tls - la page est servie en `https` (garde `upgrade-insecure-requests`).
+	* @returns la table à poser telle quelle.
+	*/
+	headersForServedFile(tls) {
+		return tls ? this.#fileTls : this.#filePlain;
 	}
-	/** Table d'en-têtes applicatifs CONSTANTS (figée), posée telle quelle par le firewall. */
+	/**
+	* Table d'en-têtes figée d'une réponse qui n'est pas un document (ADR-0024
+	* §C11) : JavaScript (politique complète sans nonce, Referrer-Policy, COEP,
+	* CORP) ou reste (politique courte `default-src 'none'`, Referrer-Policy,
+	* CORP). Ni l'une ni l'autre ne porte de nonce ; COOP, Origin-Agent-Cluster
+	* et Permissions-Policy, lus sur un document seulement, n'y figurent pas.
+	*
+	* @param kind - famille de la réponse (cf {@link responseKindOf}).
+	* @param tls - la page est servie en `https` (garde `upgrade-insecure-requests`).
+	* @returns la table à poser telle quelle.
+	*/
+	headersForResource(kind, tls) {
+		if (kind === "other") return this.#other;
+		return tls ? this.#scriptTls : this.#scriptPlain;
+	}
+	/** Table d'en-têtes applicatifs CONSTANTS (figée) d'une réponse en clair. */
 	get headers() {
-		return this.#headers;
+		return this.#plain.headers;
+	}
+	/**
+	* Table constante SANS la CSP statique d'une réponse en clair — pour une
+	* réponse qui pose sa propre politique (route `@Csp`), afin que la CSP ne
+	* soit écrite qu'une fois.
+	*/
+	get headersWithoutCsp() {
+		return this.#plain.headersWithoutCsp;
+	}
+	/**
+	* Table d'en-têtes constants selon le transport de la réponse.
+	*
+	* @param tls - la page est servie en `https` (proxy de confiance compris).
+	* @param withoutCsp - omettre la CSP statique (route `@Csp` qui pose la sienne).
+	* @returns la table figée à poser telle quelle.
+	*/
+	headersFor(tls, withoutCsp = false) {
+		const variant = tls ? this.#tls : this.#plain;
+		return withoutCsp ? variant.headersWithoutCsp : variant.headers;
 	}
 	/** `true` si le CSP est recomposé par requête avec un nonce (→ `cspFor`). */
 	get hasNonce() {
-		return this.#cspParts !== null;
+		return this.#hasNonce;
 	}
 	/**
 	* Recompose le CSP en injectant le `nonce` de la requête aux emplacements
@@ -65,11 +184,14 @@ var SecurityHeaders = class {
 	* `'`/`;`/espace) → aucune évasion possible du token CSP.
 	*
 	* @param nonce - nonce base64 de la requête (`Context.cspNonce`).
+	* @param tls - la page est servie en `https` : la politique garde
+	*   `upgrade-insecure-requests`. Défaut : en clair.
 	* @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);
+	cspFor(nonce, tls = false) {
+		const variant = tls ? this.#tls : this.#plain;
+		if (variant.prefix !== null) return variant.prefix + nonce + variant.suffix;
+		return variant.parts.join(nonce);
 	}
 	/**
 	* Recompose le CSP en fusionnant ADDITIVEMENT les directives `extra` d'une
@@ -80,11 +202,182 @@ var SecurityHeaders = class {
 	*
 	* @param nonce - nonce base64 de la requête (ignoré si le CSP n'a pas de nonce).
 	* @param extra - directives additionnelles de la route (`directive → sources`).
+	* @param tls - la page est servie en `https`. Défaut : en clair.
 	* @returns la valeur `Content-Security-Policy` à poser sur la réponse.
 	*/
-	cspForExtra(nonce, extra) {
-		const merged = mergeCspFragments(this.#cspRaw, [extra]);
-		return this.#cspParts !== null ? merged.split(NONCE_PLACEHOLDER).join(nonce) : merged.replace(/\s*'nonce-\{\{nonce\}\}'/g, "");
+	cspForExtra(nonce, extra, tls = false) {
+		let pair = this.#extraComposed?.get(extra);
+		if (pair === void 0) {
+			pair = this.#composeExtra(extra);
+			(this.#extraComposed ??= /* @__PURE__ */ new WeakMap()).set(extra, pair);
+		}
+		const composed = tls ? pair.tls : pair.plain;
+		if (composed.tail !== null) return composed.head + nonce + composed.tail;
+		return composed.parts !== null ? composed.parts.join(nonce) : composed.head;
+	}
+	/** Compose les deux variantes d'une politique `@Csp` (une fois par route). */
+	#composeExtra(extra) {
+		let merged;
+		try {
+			merged = mergeCspFragments(this.#tls.raw, [extra]);
+		} catch (error) {
+			merged = this.#tls.raw;
+			this.#onRejectedExtra?.(error);
+		}
+		const tls = this.#composeAround(merged);
+		const plainCsp = withoutDirective(merged, UPGRADE_INSECURE_REQUESTS);
+		return {
+			tls,
+			plain: plainCsp === merged ? tls : this.#composeAround(plainCsp)
+		};
+	}
+	/**
+	* Nonce actif → découpe autour de `{{nonce}}` ; sinon purge un résiduel
+	* `'nonce-{{nonce}}'` (placeholder non substitué = CSP cassé).
+	*/
+	#composeAround(csp) {
+		return this.#hasNonce ? composeAroundNonce(csp.split(NONCE_PLACEHOLDER)) : {
+			head: purgeNonceForDocument(csp),
+			tail: null,
+			parts: null
+		};
 	}
 };
-export { SecurityHeaders, SecurityHeaders as default };
+/**
+* Compose une variante : table d'en-têtes figée (CSP statique comprise si elle
+* n'a pas de nonce) et segments de la CSP autour du nonce.
+*
+* @throws BootConfigurationError si la CSP ne peut pas être portée par un en-tête.
+*/
+function buildVariant(csp, cspNonces, nonced, common) {
+	let parts = null;
+	let staticCsp = "";
+	if (csp) {
+		if (nonced) {
+			parts = csp.split(NONCE_PLACEHOLDER);
+			assertHeaderValue("Content-Security-Policy", parts.join(NONCE_SAMPLE));
+		} else {
+			staticCsp = cspNonces ? csp : purgeNonceForDocument(csp);
+			if (staticCsp) assertHeaderValue("Content-Security-Policy", staticCsp);
+		}
+	}
+	const headersWithoutCsp = Object.freeze({ ...common });
+	const headers = staticCsp ? Object.freeze({
+		"Content-Security-Policy": staticCsp,
+		...common
+	}) : headersWithoutCsp;
+	const two = parts?.length === 2;
+	return {
+		headers,
+		headersWithoutCsp,
+		parts: parts ? Object.freeze(parts) : null,
+		prefix: two ? parts?.[0] ?? "" : null,
+		suffix: two ? parts?.[1] ?? "" : "",
+		raw: csp
+	};
+}
+/**
+* Table figée : la politique (validée) en tête, puis les en-têtes communs.
+*
+* @throws BootConfigurationError si la politique ne peut pas être portée par un en-tête.
+*/
+function freezeTable(csp, common) {
+	if (!csp) return Object.freeze({ ...common });
+	assertHeaderValue("Content-Security-Policy", csp);
+	return Object.freeze({
+		"Content-Security-Policy": csp,
+		...common
+	});
+}
+/**
+* Politique courte d'une réponse qui n'est ni document ni script :
+* `default-src 'none'`, plus le `frame-ancestors` de la politique complète. Une
+* politique complète vide (CSP coupée par l'application) n'en donne aucune.
+*/
+function narrowCspOf(csp) {
+	if (!csp.trim()) return "";
+	for (const [name, sources] of parseCsp(csp)) if (name.toLowerCase() === "frame-ancestors") {
+		const list = sources.length > 0 ? sources.join(" ") : "'none'";
+		return `${NARROW_CSP}; frame-ancestors ${list}`;
+	}
+	return NARROW_CSP;
+}
+const STRICT_DYNAMIC = "'strict-dynamic'";
+/** Source qui désigne un script par nonce ou par empreinte (W3C CSP3 § source-list). */
+const NONCE_OR_HASH = /^'(?:nonce|sha256|sha384|sha512)-/i;
+/**
+* Retire le nonce d'une politique de DOCUMENT : `'nonce-{{nonce}}'` part, et
+* `'strict-dynamic'` avec lui dans toute directive restée sans nonce ni hash.
+* Sous `'strict-dynamic'`, un navigateur CSP3 ignore `'self'` et les hôtes
+* (`w3c-csp3.bs` § « Authoring Considerations ») : la page ne pourrait plus
+* exécuter un seul `<script>` (ADR-0024 §C1). Une politique sans marqueur —
+* écrite ainsi par l'application — est rendue telle quelle.
+*
+* La politique d'un script (worker) n'y passe pas : ce qu'un worker charge
+* n'est pas « inséré par l'analyseur », et `'strict-dynamic'` l'autorise.
+*/
+function purgeNonceForDocument(csp) {
+	const purged = purgeNoncePlaceholder(csp);
+	if (purged === csp || !purged.includes(STRICT_DYNAMIC)) return purged;
+	const directives = parseCsp(purged);
+	let changed = false;
+	for (const entry of directives) {
+		const sources = entry[1];
+		if (!sources.includes(STRICT_DYNAMIC)) continue;
+		if (sources.some((s) => NONCE_OR_HASH.test(s))) continue;
+		entry[1] = sources.filter((s) => s !== STRICT_DYNAMIC);
+		changed = true;
+	}
+	return changed ? serializeCsp(directives) : purged;
+}
+/** Jeton CSP qui porte le marqueur, retiré tel quel d'une CSP sans nonce. */
+const NONCE_TOKEN = `'nonce-${NONCE_PLACEHOLDER}'`;
+/**
+* Retire chaque token `'nonce-{{nonce}}'` d'une CSP sans nonce, avec les blancs
+* qui le précèdent. Découpe + `trimEnd` plutôt qu'une regex `\s*…` : celle-ci
+* coûte O(n²) sur une longue suite de blancs (CodeQL `js/polynomial-redos`).
+*/
+function purgeNoncePlaceholder(csp) {
+	const parts = csp.split(NONCE_TOKEN);
+	if (parts.length === 1) return csp;
+	const last = parts.length - 1;
+	let out = "";
+	for (let i = 0; i < last; i++) out += (parts[i] ?? "").trimEnd();
+	return out + (parts[last] ?? "");
+}
+/** Nonce témoin pour valider le gabarit : même alphabet que `nextCspNonce` (base64). */
+const NONCE_SAMPLE = "AAAAAAAAAAAAAAAAAAAAAA==";
+/**
+* Refuse au démarrage une valeur qu'un en-tête HTTP ne peut pas porter.
+*
+* @throws BootConfigurationError en nommant l'en-tête et la raison de Node.
+*/
+function assertHeaderValue(name, value) {
+	try {
+		validateHeaderValue(name, value);
+	} catch (error) {
+		throw new BootConfigurationError(`[@nodefony/security] en-tête « ${name} » refusé : ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+/** Range les segments d'une politique découpée autour de `{{nonce}}`. */
+function composeAroundNonce(parts) {
+	if (parts.length === 2) {
+		const [head = "", tail = ""] = parts;
+		return {
+			head,
+			tail,
+			parts: null
+		};
+	}
+	if (parts.length === 1) return {
+		head: parts[0] ?? "",
+		tail: null,
+		parts: null
+	};
+	return {
+		head: "",
+		tail: null,
+		parts: Object.freeze(parts)
+	};
+}
+export { SecurityHeaders, SecurityHeaders as default, responseKindOf };

package/dist/nodefony/service/tokenService.js

@@ -1,15 +1,15 @@
-import { JwtKeystore } from "../src/token/JwtKeystore.js";
-import { ScopeGrantPolicy, refusedScopes } from "../src/token/scopeGrants.js";
-import { InsecureTransportError } from "../errors/InsecureTransportError.js";
+import { defineSecurityConfig } from "../config/defineModuleConfig.js";
 import { AuthenticationError } from "../errors/AuthenticationError.js";
 import { ThrottledError } from "../errors/ThrottledError.js";
-import { defineSecurityConfig } from "../config/defineModuleConfig.js";
-import { ACCOUNT_ID_KEY, CREDENTIALS_VERSION_KEY, credentialsVersionOf, isBoundToAccount } from "../src/accountBinding.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 { InsecureTransportError } from "../errors/InsecureTransportError.js";
+import { readAuditContext } from "../src/audit/readAuditContext.js";
 import { getTokenStoreFactory, listTokenStores } from "../src/token/tokenStoreRegistry.js";
+import { recordAudit } from "../src/audit/recordAudit.js";
+import { ACCOUNT_ID_KEY, CREDENTIALS_VERSION_KEY, credentialsVersionOf, isBoundToAccount } from "../src/accountBinding.js";
+import { JwtKeystore } from "../src/token/JwtKeystore.js";
+import { ScopeGrantPolicy, refusedScopes } from "../src/token/scopeGrants.js";
+import { defaultAudience, resolveJwtRuntime } from "../src/token/jwtRuntime.js";
 import { AUTO_STORE, BootConfigurationError, EMPTY_INFRA, GcScheduler, Service, canonicalIssuer, durableStoreRemedy, readStoreConnector, readStoreLocation, resolveAutoStore, storeConnectivity } from "nodefony";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
 // nodefony/service/tokenService.ts

package/dist/nodefony/service/totp.js

@@ -1,9 +1,9 @@
 import { defineSecurityConfig } from "../config/defineModuleConfig.js";
-import { recordAudit } from "../src/audit/recordAudit.js";
-import { readAuditContext } from "../src/audit/readAuditContext.js";
 import { getTotpStoreFactory, listTotpStores } from "../src/totp/totpSecretStoreRegistry.js";
-import { generateEphemeralKey } from "../src/crypto/secretCipher.js";
 import { deriveTotpKey } from "../src/totp/totpCipher.js";
+import { recordAudit } from "../src/audit/recordAudit.js";
+import { generateEphemeralKey } from "../src/crypto/secretCipher.js";
+import { readAuditContext } from "../src/audit/readAuditContext.js";
 import { beginTotpEnrollment, confirmTotpEnrollment, disableTotp, totpStatus, verifyTotpLogin } from "../src/totp/totpOperations.js";
 import { AUTO_STORE, EMPTY_INFRA, Service, deriveStoreBackend, durableStoreRemedy, readStoreConnector, readStoreLocation, resolveAutoStore, storeConnectivity } from "nodefony";
 // nodefony/service/totp.ts

package/dist/nodefony/service/webAuthn.js

@@ -1,5 +1,5 @@
-import { AuthenticationError } from "../errors/AuthenticationError.js";
 import { defineSecurityConfig } from "../config/defineModuleConfig.js";
+import { AuthenticationError } from "../errors/AuthenticationError.js";
 import { WebAuthnError } from "../errors/WebAuthnError.js";
 import { getWebAuthnStoreFactory, listWebAuthnStores } from "../src/webauthn/webAuthnCredentialStoreRegistry.js";
 import { AUTO_STORE, EMPTY_INFRA, Service, deriveStoreBackend, durableStoreRemedy, readStoreConnector, readStoreLocation, resolveAutoStore, storeConnectivity } from "nodefony";

package/dist/nodefony/service/webhooks.js

@@ -1,15 +1,15 @@
-import { defineSecurityConfig } from "../config/defineModuleConfig.js";
-import { decryptSecret, encryptSecret, generateEphemeralKey } from "../src/crypto/secretCipher.js";
 import { WEBHOOK_FACETS } from "../src/webhook/webhookFilters.js";
+import { decryptSecret, encryptSecret, generateEphemeralKey } from "../src/crypto/secretCipher.js";
+import { defineSecurityConfig } from "../config/defineModuleConfig.js";
 import { getWebhookStoreFactory, listWebhookStores } from "../src/webhook/webhookStoreRegistry.js";
 import { deriveWebhookKey } from "../src/webhook/webhookCipher.js";
 import { assertPublicUrl } from "../src/net/ssrfGuard.js";
-import { WebhookDispatcher } from "../src/webhook/WebhookDispatcher.js";
+import { WebhookDispatcher, assertSubscriptionPatterns } from "../src/webhook/WebhookDispatcher.js";
 import { deliverWebhook } from "../src/webhook/webhookDelivery.js";
 import { AUTO_STORE, EMPTY_INFRA, Service, countFacets, deriveStoreBackend, durableStoreRemedy, readStoreConnector, readStoreLocation, resolveAutoStore, storeConnectivity } from "nodefony";
 import { randomBytes } from "node:crypto";
-import { Buffer } from "node:buffer";
 import { schemaMismatchOf } from "@nodefony/http";
+import { Buffer } from "node:buffer";
 // nodefony/service/webhooks.ts
 const serviceName = "webhooks";
 /** Historique de livraisons gardé PAR endpoint (ring borné, RAM, par pod). */
@@ -107,6 +107,7 @@ var WebhookService = class extends Service {
 		const dispatcher = new WebhookDispatcher({
 			endpointCount: () => this.endpointCount(),
 			getSnapshot: () => this.getSnapshot(),
+			currentEndpoint: (id) => this.#endpoints?.get(id) ?? null,
 			secretOf: (ep) => this.decryptEndpointSecret(ep).toString("utf8"),
 			policy: this.getDeliveryPolicy(),
 			resolveTarget: (url) => this.#resolveTarget(url),
@@ -261,8 +262,13 @@ var WebhookService = class extends Service {
 	* (la seule occasion de le lire pour le copier).
 	*
 	* @throws SsrfError si l'URL est invalide / cible non publique.
+	* @throws Error si un motif de `events` porte plus de trois `*` (ADR-0023 W1).
+	* @throws Error si `tenantId` est rempli : le périmètre d'un locataire n'est pas
+	* encore appliqué à la livraison (ADR-0023 W2) — l'accepter le rendrait trompeur.
 	*/
 	async register(input) {
+		if (input.tenantId != null) throw new Error("webhooks: tenantId n'est pas encore pris en charge — le multi-tenant n'existe pas, et un abonnement rattaché à un locataire recevrait tout. Laisser tenantId absent ou null.");
+		assertSubscriptionPatterns(input.events);
 		const { store, key, config } = this.#assertReady();
 		await this.#assertSafeUrl(config, input.url);
 		const secret = generateSecret();
@@ -342,6 +348,7 @@ var WebhookService = class extends Service {
 	* ou `null` si absent.
 	*/
 	async update(id, patch) {
+		if (patch.events !== void 0) assertSubscriptionPatterns(patch.events);
 		const { store, config } = this.#assertReady();
 		const current = await store.findById(id);
 		if (!current) return null;

package/dist/nodefony/src/admin/SecurityAdminApi.js

@@ -155,6 +155,9 @@ function toCredentialView(c) {
 *  - `GET /nodefony/security/api/firewall` — introspection du firewall (zones,
 *    authenticators montés, défenses) — état RUNTIME, secrets exclus.
 *  - `GET /nodefony/security/api/roleHierarchy` — hiérarchie de rôles + résolution.
+*  - `GET /nodefony/security/api/csp-reports` — violations CSP reçues (ADR-0024
+*    §C7), dédoublonnées, la plus récente d’abord ; champs écrits par le
+*    navigateur, donc à afficher comme du texte.
 *  - `GET /nodefony/security/api/apikeys` — toutes les clés API (gouvernance),
 *    `GET …/apikeys/status` — backend du token store (« où on écrit »),
 *    `POST …/apikeys/{id}/revoke` — révocation par id (réponse à incident).
@@ -222,6 +225,22 @@ function createSecurityAdminApi(container) {
 				};
 			}
 		},
+		{
+			path: "csp-reports",
+			method: "GET",
+			role: "ROLE_NODEFONY_ADMIN",
+			summary: "Violations de la politique CSP rapportées par les navigateurs (dédoublonnées, URL expurgées, extrait jamais gardé). Champs écrits par le navigateur — à afficher comme du texte.",
+			handler: () => {
+				return container.get("cspReports")?.snapshot() ?? {
+					enabled: false,
+					endpoint: null,
+					capacity: 0,
+					received: 0,
+					rejected: 0,
+					items: []
+				};
+			}
+		},
 		{
 			path: "roleHierarchy",
 			method: "GET",

package/dist/nodefony/src/authenticator/ApiKeyAuthenticator.js

@@ -1,8 +1,8 @@
 import { AuthenticationError } from "../../errors/AuthenticationError.js";
 import { isBoundToAccount } from "../accountBinding.js";
 import { UserToken } from "../token/UserToken.js";
-import { bearerToken } from "./bearer.js";
 import { looksLikeApiKey, parseApiKey } from "../apikey/apiKeyFormat.js";
+import { bearerToken } from "./bearer.js";
 // nodefony/src/authenticator/ApiKeyAuthenticator.ts
 const INVALID_TOKEN = "Invalid token";
 /**

package/dist/nodefony/src/authenticator/ExternalSubjectResolver.js

@@ -1,7 +1,7 @@
-import { compileProviderRoleMapping, mapProviderRoles } from "../oauth/providerRoles.js";
 import { AuthenticationError } from "../../errors/AuthenticationError.js";
 import { UnverifiableTokenError } from "../../errors/UnverifiableTokenError.js";
 import { localIdentifierFor } from "./externalSubject.js";
+import { compileProviderRoleMapping, mapProviderRoles } from "../oauth/providerRoles.js";
 import { canonicalIssuer } from "nodefony";
 import { BaseUser } from "@nodefony/user";
 // nodefony/src/authenticator/ExternalSubjectResolver.ts
@@ -11,6 +11,25 @@ import { BaseUser } from "@nodefony/user";
 */
 const INVALID_TOKEN = "Invalid token";
 /**
+* Les utilisateurs FABRIQUÉS en mode `ephemeral` — aucun compte local derrière.
+* Faible : l'entrée meurt avec l'utilisateur, à la fin de sa requête ou de sa
+* socket ; rien n'est à nettoyer.
+*/
+const EPHEMERAL_SUBJECTS = /* @__PURE__ */ new WeakSet();
+/**
+* Cet utilisateur a-t-il été fabriqué pour un appelant machine SANS compte local (mode `ephemeral`) ?
+*
+* L'identité d'admission temps réel en tire `account: false` : rien ne
+* pourrait relire cet appelant par son `id` (`<émetteur>#<sujet>`), et un
+* abonnement durable ne doit pas s'y adosser (ADR-0021 §S10 point 6). Lu sur
+* le FAIT (l'objet vient du résolveur), jamais déduit de la forme de `id`.
+*
+* @param user - utilisateur résolu par le pare-feu.
+*/
+function isEphemeralSubject(user) {
+	return EPHEMERAL_SUBJECTS.has(user);
+}
+/**
 * Les options de rattachement des sujets externes, lues dans la configuration
 * de sécurité — UNE lecture, pour la zone `external-jwt` comme pour le
 * résolveur de compte d'une ressource protégée.
@@ -105,12 +124,17 @@ var ExternalSubjectResolver = class {
 	async resolve(issuer, subject, claims, area) {
 		const mapping = this.#issuers.get(issuer);
 		if (mapping === void 0) throw new UnverifiableTokenError(`émetteur « ${issuer} » vérifié mais absent de la table de rattachement des sujets — configuration incohérente.`);
+		if ((area?.subjectPolicy ?? this.#policy) === "ephemeral") {
+			const identifier = localIdentifierFor(issuer, subject, "prefixed");
+			const ephemeral = new BaseUser({
+				id: identifier,
+				identifier,
+				roles: [...area?.ephemeralRoles ?? this.#ephemeralRoles]
+			});
+			EPHEMERAL_SUBJECTS.add(ephemeral);
+			return ephemeral;
+		}
 		const identifier = localIdentifierFor(issuer, subject, mapping);
-		if ((area?.subjectPolicy ?? this.#policy) === "ephemeral") return new BaseUser({
-			id: identifier,
-			identifier,
-			roles: [...area?.ephemeralRoles ?? this.#ephemeralRoles]
-		});
 		const provider = this.#resolveUserProvider();
 		let user = null;
 		const linked = this.#linkedProviders?.get(issuer);
@@ -177,4 +201,4 @@ function linkProviders(trusted, providers) {
 	for (const issuer of ambiguous) links.delete(issuer);
 	return links.size > 0 ? links : null;
 }
-export { ExternalSubjectResolver, externalSubjectOptions };
+export { ExternalSubjectResolver, externalSubjectOptions, isEphemeralSubject };