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

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
@@ -47,9 +47,14 @@ var TokenService = class extends Service {
 	constructor(module) {
 		super(serviceName, module.container, module.notificationsCenter, module.options);
 		this.module = module;
-		const tokenServiceBoot = () => this.#build();
+		const tokenServiceBoot = () => {
+			try {
+				this.#build();
+			} finally {
+				this.kernel?.once("onTerminate", () => this.#shutdown());
+			}
+		};
 		this.kernel?.once("onBoot", tokenServiceBoot);
-		this.kernel?.once("onTerminate", () => this.#shutdown());
 	}
 	/**
 	* Refuse de SERVIR en production sans clé de signature partagée.
@@ -130,7 +135,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.#runtime = resolveJwtRuntime(config.jwt, config.areas);
 			this.#keystore = new JwtKeystore(config.jwt.keystore, (m, s) => this.log(m, s));
 			this.container?.set("jwtKeystore", this.#keystore);
 			this.#resolvePublication(config.jwt.jwks, this.#runtime.issuer);

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
@@ -36,8 +36,13 @@ var TotpService = class extends Service {
 	constructor(module) {
 		super(serviceName, module.container, module.notificationsCenter, module.options);
 		this.module = module;
-		this.kernel?.once("onBoot", () => this.#build());
-		this.kernel?.once("onTerminate", () => void this.#shutdown());
+		this.kernel?.once("onBoot", () => {
+			try {
+				this.#build();
+			} finally {
+				this.kernel?.once("onTerminate", () => this.#shutdown());
+			}
+		});
 	}
 	#build() {
 		let config;

package/dist/nodefony/service/webAuthn.js

@@ -1,8 +1,9 @@
-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";
+import { domainToASCII } from "node:url";
 import { createHash } from "node:crypto";
 import { Buffer } from "node:buffer";
 // nodefony/service/webAuthn.ts
@@ -59,12 +60,19 @@ var WebAuthnService = class extends Service {
 	#store = null;
 	#rpID = "localhost";
 	#rpName = "Nodefony";
+	/** Origines de la config, en ASCII (punycode) — résolues au boot. */
+	#origins = [];
 	#ready = false;
 	constructor(module) {
 		super(serviceName, module.container, module.notificationsCenter, module.options);
 		this.module = module;
-		this.kernel?.once("onBoot", () => this.#build());
-		this.kernel?.once("onTerminate", () => void this.#shutdown());
+		this.kernel?.once("onBoot", () => {
+			try {
+				this.#build();
+			} finally {
+				this.kernel?.once("onTerminate", () => this.#shutdown());
+			}
+		});
 	}
 	#build() {
 		let config;
@@ -79,7 +87,11 @@ var WebAuthnService = class extends Service {
 		}
 		this.#config = config;
 		const rawDomain = config.passkeys.rpId ?? (this.kernel?.domain || "localhost");
-		this.#rpID = /^(\d{1,3}\.){3}\d{1,3}$|:/.test(rawDomain) ? "localhost" : rawDomain;
+		const isIp = /^(\d{1,3}\.){3}\d{1,3}$|:/.test(rawDomain);
+		const asciiDomain = isIp ? "" : domainToASCII(rawDomain);
+		if (!isIp && asciiDomain === "") this.log(`passkeys : domaine « ${rawDomain} » invalide comme RP ID — repli sur « localhost »`, "ERROR");
+		this.#rpID = asciiDomain === "" ? "localhost" : asciiDomain;
+		this.#origins = asciiOrigins(config.passkeys.origins, (bad) => this.log(`passkeys.origins : « ${bad} » n'est pas une origine (scheme://hôte[:port]) — écartée`, "ERROR"));
 		this.#rpName = config.passkeys.rpName ?? "Nodefony";
 		const existing = this.get("webAuthnCredentialStore");
 		let resolved;
@@ -195,7 +207,7 @@ var WebAuthnService = class extends Service {
 			verification = await lib.verifyRegistrationResponse({
 				response,
 				expectedChallenge,
-				expectedOrigin: this.#expectedOrigin(pk.origins, requestOrigin),
+				expectedOrigin: this.#expectedOrigin(this.#origins, requestOrigin),
 				expectedRPID: this.#rpID,
 				requireUserVerification: pk.userVerification === "required"
 			});
@@ -268,7 +280,7 @@ var WebAuthnService = class extends Service {
 			verification = await lib.verifyAuthenticationResponse({
 				response,
 				expectedChallenge,
-				expectedOrigin: this.#expectedOrigin(pk.origins, requestOrigin),
+				expectedOrigin: this.#expectedOrigin(this.#origins, requestOrigin),
 				expectedRPID: this.#rpID,
 				credential: {
 					id: stored.id,
@@ -365,4 +377,31 @@ var WebAuthnService = class extends Service {
 		};
 	}
 };
-export { WebAuthnService, WebAuthnService as default, userHandleBytes };
+/**
+* Origines WebAuthn rendues en ASCII (punycode), forme sous laquelle le
+* navigateur les présente — `https://café.example` → `https://xn--caf-dma.example`.
+*
+* Une entrée qui n'est pas une origine (`scheme://hôte[:port]`) est écartée et
+* signalée : la garder ferait échouer CHAQUE cérémonie, sans que personne ne
+* sache pourquoi.
+*
+* @param origins - origines telles qu'écrites dans la config.
+* @param onInvalid - appelé pour chaque entrée écartée.
+* @returns les origines valides, sérialisées en ASCII, dans l'ordre reçu.
+*/
+function asciiOrigins(origins, onInvalid) {
+	const out = [];
+	for (const origin of origins) {
+		let ascii;
+		try {
+			const serialized = new URL(origin).origin;
+			ascii = serialized === "null" ? null : serialized;
+		} catch {
+			ascii = null;
+		}
+		if (ascii === null) onInvalid(origin);
+		else out.push(ascii);
+	}
+	return out;
+}
+export { WebAuthnService, WebAuthnService as default, asciiOrigins, userHandleBytes };

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;