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

package/dist/nodefony/service/firewall.js

@@ -11,6 +11,7 @@ import { Csrf } from "./csrf.js";
 import { Cors } from "./cors.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";
@@ -26,6 +27,7 @@ import { findZonesOpenToSignup } from "../src/openToSignup.js";
 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";
@@ -102,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 {
@@ -552,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",
@@ -561,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) {
@@ -923,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;
@@ -991,4 +1019,21 @@ var Firewall = class extends Service {
 		return super.log(pci, severity, msgid, msg);
 	}
 };
+/**
+* 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/tokenService.js

@@ -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

@@ -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

@@ -3,6 +3,7 @@ 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/src/audit/AuditRefusalAggregator.js

@@ -0,0 +1,139 @@
+// nodefony/src/audit/AuditRefusalAggregator.ts
+/** IP de la clé de repli, quand `maxKeys` est atteint. */
+const OVERFLOW_IP = "*";
+const SEP = "
";
+/**
+* Une clé suivie : le gabarit de la ligne de synthèse et les compteurs de la
+* fenêtre en cours. Champs déclarés au constructeur (forme stable).
+*/
+var RefusalBucket = class {
+	start;
+	count = 0;
+	suppressed = 0;
+	firstSuppressed = 0;
+	lastSuppressed = 0;
+	category;
+	action;
+	outcome;
+	resource;
+	reason;
+	ip;
+	constructor(draft, ip, now) {
+		this.start = now;
+		this.category = draft.category;
+		this.action = draft.action;
+		this.outcome = draft.outcome;
+		this.resource = draft.resource ?? null;
+		this.reason = draft.reason ?? null;
+		this.ip = ip;
+	}
+};
+/**
+* Agrège les REFUS du journal d'audit par source, pour qu'un flot ne se paie pas
+* d'une ligne par requête (OWASP Logging Cheat Sheet : la journalisation ne doit
+* pas épuiser les ressources ni le journal de la base).
+*
+* Clé : catégorie, action, motif, ressource et IP — l'IP résolue par le contexte
+* (`trustProxy`), donc non forgeable par le client. L'acteur n'entre PAS dans la
+* clé : un bourrage d'identifiants change d'acteur à chaque essai, c'est sa
+* source qui le trahit.
+*
+* Par clé et par fenêtre (ouverte au premier refus) : les `burst` premiers refus
+* sont écrits tels quels — l'enquêteur voit les premiers essais, acteur compris ;
+* les suivants sont seulement comptés, et la fenêtre close émet UNE ligne de
+* synthèse (`metadata.aggregated`). Mémoire bornée : au-delà de `maxKeys` clés,
+* les refus se regroupent sous l'IP `*`.
+*
+* Pur : l'horloge est passée à chaque appel, la synthèse part par `emit`. Les
+* succès n'y passent jamais (l'appelant les écarte).
+*/
+var AuditRefusalAggregator = class {
+	#buckets = /* @__PURE__ */ new Map();
+	#options;
+	#emit;
+	/**
+	* @param options - fenêtre, rafale écrite telle quelle, borne de clés.
+	* @param emit - écrit une ligne de synthèse dans le journal.
+	*/
+	constructor(options, emit) {
+		this.#options = options;
+		this.#emit = emit;
+	}
+	/** Nombre de clés suivies (fenêtres ouvertes). */
+	get size() {
+		return this.#buckets.size;
+	}
+	/**
+	* Compte un refus.
+	*
+	* @param draft - l'événement de refus.
+	* @param now - horloge, en ms.
+	* @returns `true` : l'écrire tel quel ; `false` : il est compté dans la synthèse.
+	*/
+	admit(draft, now) {
+		const prefix = draft.category + SEP + draft.action + SEP + draft.outcome + SEP + (draft.reason ?? "") + SEP + (draft.resource ?? "") + SEP;
+		const ip = draft.ip ?? null;
+		let key = prefix + (ip ?? "");
+		let bucket = this.#buckets.get(key);
+		if (bucket === void 0) {
+			let bucketIp = ip;
+			if (this.#buckets.size >= this.#options.maxKeys) {
+				key = prefix + OVERFLOW_IP;
+				bucketIp = OVERFLOW_IP;
+				bucket = this.#buckets.get(key);
+			}
+			if (bucket === void 0) {
+				bucket = new RefusalBucket(draft, bucketIp, now);
+				this.#buckets.set(key, bucket);
+			}
+		}
+		if (now - bucket.start >= this.#options.windowMs) {
+			this.#close(bucket);
+			bucket.start = now;
+			bucket.count = 0;
+			bucket.suppressed = 0;
+		}
+		bucket.count += 1;
+		if (bucket.count <= this.#options.burst) return true;
+		if (bucket.suppressed === 0) bucket.firstSuppressed = now;
+		bucket.suppressed += 1;
+		bucket.lastSuppressed = now;
+		return false;
+	}
+	/**
+	* Ferme les fenêtres échues : émet leur synthèse et libère leurs clés.
+	*
+	* @param now - horloge, en ms.
+	*/
+	sweep(now) {
+		for (const [key, bucket] of this.#buckets) {
+			if (now - bucket.start < this.#options.windowMs) continue;
+			this.#close(bucket);
+			this.#buckets.delete(key);
+		}
+	}
+	/** Émet la synthèse de toutes les fenêtres ouvertes (arrêt) et vide la table. */
+	flush() {
+		for (const bucket of this.#buckets.values()) this.#close(bucket);
+		this.#buckets.clear();
+	}
+	#close(bucket) {
+		if (bucket.suppressed === 0) return;
+		this.#emit({
+			category: bucket.category,
+			action: bucket.action,
+			outcome: bucket.outcome,
+			actor: null,
+			resource: bucket.resource,
+			reason: bucket.reason,
+			ip: bucket.ip,
+			metadata: { aggregated: {
+				count: bucket.suppressed,
+				firstTs: bucket.firstSuppressed,
+				lastTs: bucket.lastSuppressed,
+				windowMs: this.#options.windowMs
+			} }
+		});
+	}
+};
+export { AuditRefusalAggregator };

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

@@ -1,5 +1,6 @@
 import { AuthenticationError } from "../../errors/AuthenticationError.js";
 import { UserToken } from "../token/UserToken.js";
+import { defaultAudience } from "../token/jwtRuntime.js";
 import { REQUIRED_TIME_CLAIMS, isIssuedInFuture } from "../token/tokenTimeClaims.js";
 import { bearerToken } from "./bearer.js";
 import peekIssuer from "./peekIssuer.js";
@@ -8,6 +9,7 @@ import { canonicalIssuer } from "nodefony";
 // nodefony/src/authenticator/JwtAuthenticator.ts
 const COMPACT_JWS = /^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]*$/;
 const INVALID_TOKEN = "Invalid token";
+const AUDIENCE = "audience";
 /**
 * Authentification par **JWT Bearer** (RFC 6750) — réservée API service↔service /
 * agents (le web utilise la session BFF). Vérifie un access token EdDSA signé par
@@ -19,7 +21,8 @@ const INVALID_TOKEN = "Invalid token";
 *  - **clé par `kid` depuis le keyset LOCAL** (`createLocalJWKSet`) — jamais
 *    `jku`/`jwk` de l'en-tête (injection de clé / SSRF, §3.5).
 *  - **`aud` (§3.9) + `iss` (§3.8) obligatoires** + `typ:"at+jwt"` (§3.11, sépare
-*    access et refresh) + `exp`/`nbf` (jose).
+*    access et refresh) + `exp`/`nbf` (jose). L'audience est celle de la ZONE
+*    (`resource`, ou l'audience par défaut), jamais toute la liste `jwt.audiences`.
 *  - **révocation** : denylist `jti` + seuil `invalidBefore` par porteur (le JWT
 *    est auto-porté et non révocable sans état serveur).
 *  - **sujet revérifié** (§3.10) : `loadUserByIdentifier(sub)` → compte disparu,
@@ -68,15 +71,31 @@ var JwtAuthenticator = class {
 		const issuer = peekIssuer(token);
 		return issuer === null || issuer === this.#runtime.issuer;
 	}
-	/** Extrait le token brut (non vérifié) → porté par un `UserToken` type `"jwt"`. */
+	/**
+	* Extrait le token brut (non vérifié) → porté par un `UserToken` type `"jwt"`,
+	* avec la ressource de la zone quand elle en déclare une.
+	*
+	* L'audience transite par le token parce que `authenticate()` ne reçoit pas
+	* le contexte (même patron que `ExternalJwtAuthenticator`). Rien n'est posé
+	* pour une zone sans ressource : l'audience par défaut s'y applique.
+	*/
 	createToken(context) {
 		const auth = context.request?.headers.authorization;
-		return Promise.resolve(new UserToken("jwt", bearerToken(auth) ?? ""));
+		const token = new UserToken("jwt", bearerToken(auth) ?? "");
+		const zone = context.security;
+		if (zone && "resource" in zone && typeof zone.resource === "string" && zone.resource.length > 0) token.setAttribute(AUDIENCE, zone.resource);
+		return Promise.resolve(token);
 	}
 	/**
 	* Vérifie la signature + les claims du JWT, applique la révocation et résout le
 	* sujet — ou lève un 401 au message uniforme.
 	*
+	* L'audience exigée est celle de la ZONE, jamais la liste blanche d'émission
+	* entière (RFC 8707, RFC 9068 §4) : la `resource` de la zone si elle en
+	* déclare une, sinon l'audience par défaut — l'application elle-même. Un
+	* jeton émis pour la porte MCP, ou pour la ressource d'une autre zone, figure
+	* dans `jwt.audiences` sans pour autant ouvrir celle-ci.
+	*
 	* @throws AuthenticationError (401) — token absent/invalide/expiré/révoqué, ou
 	*   sujet disparu/banni.
 	* @throws Error (câblage : keystore/store/users absents) — logguée ERROR par le
@@ -85,7 +104,8 @@ var JwtAuthenticator = class {
 	async authenticate(token) {
 		const raw = token.getCredentials();
 		if (typeof raw !== "string" || raw.length === 0) throw new AuthenticationError(INVALID_TOKEN);
-		const { user, payload } = await this.#verify(raw, this.#runtime.audiences);
+		const audience = token.getAttribute(AUDIENCE) ?? defaultAudience(this.#runtime);
+		const { user, payload } = await this.#verify(raw, audience);
 		return this.#promote(token, user, payload);
 	}
 	/**

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

@@ -1,4 +1,5 @@
 import { AuthenticationError } from "../../errors/AuthenticationError.js";
+import { StaleSessionError } from "../../errors/StaleSessionError.js";
 import { resolveBoundSessionIdentity } from "../sessionIdentity.js";
 import { ACCOUNT_ID_KEY, CREDENTIALS_VERSION_KEY } from "../accountBinding.js";
 import { UserToken } from "../token/UserToken.js";
@@ -72,15 +73,22 @@ var SessionAuthenticator = class {
 	* token. Les contrôles d'état (existe, actif, non verrouillé) vivent dans
 	* {@link resolveSessionIdentity} — partagés avec `AuthFlow.me()`.
 	*
-	* @throws AuthenticationError (401, message uniforme) — session orpheline,
-	*   compte verrouillé ou désactivé.
+	* @throws StaleSessionError (401, message uniforme) — session orpheline,
+	*   compte verrouillé ou désactivé, liaison au compte rompue : un état à
+	*   purger ({@link onFailure}). Une PANNE de la source d'identité remonte
+	*   telle quelle, et ne purge rien.
 	*/
 	async authenticate(token) {
 		const credentials = token.getCredentials();
-		if (!credentials?.identifier) throw new AuthenticationError("Invalid session");
+		if (!credentials?.identifier) throw new StaleSessionError();
 		const provider = this.#provider ??= this.#resolveProvider();
-		const user = await resolveBoundSessionIdentity(provider, credentials.identifier, credentials.accountId, credentials.credentialsVersion);
-		return token.promote(user);
+		try {
+			const user = await resolveBoundSessionIdentity(provider, credentials.identifier, credentials.accountId, credentials.credentialsVersion);
+			return token.promote(user);
+		} catch (error) {
+			if (error instanceof AuthenticationError) throw new StaleSessionError(error.message);
+			throw error;
+		}
 	}
 	/**
 	* Pose l'identifiant sur le contexte : la persistance de session du pipeline
@@ -90,9 +98,14 @@ var SessionAuthenticator = class {
 		context.user = token.getUser().identifier;
 		return Promise.resolve();
 	}
-	/** Slot audit (P6.14). Le 401 est posé par le firewall. */
-	onFailure(_context, _error) {
-		return Promise.resolve();
+	/**
+	* Une session périmée est DÉTRUITE, côté serveur (entrée du stockage) et
+	* côté navigateur (cookie expiré, RFC 6265 §5.3) — sans quoi le navigateur la
+	* renvoie à chaque requête et chaque page lui répond 401, sans issue pour
+	* l'utilisateur. Le firewall poursuit ensuite la chaîne de la zone.
+	*/
+	async onFailure(context, error) {
+		if (error instanceof StaleSessionError) await context.session?.destroy(true);
 	}
 };
 export { SessionAuthenticator, SessionAuthenticator as default };

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

@@ -42,7 +42,7 @@ registerAuthenticatorFactory("session", ({ container }) => {
 	});
 });
 registerAuthenticatorFactory("jwt", ({ container, config }) => {
-	return new JwtAuthenticator(container, resolveJwtRuntime(config.jwt));
+	return new JwtAuthenticator(container, resolveJwtRuntime(config.jwt, config.areas));
 });
 registerAuthenticatorFactory("external-jwt", ({ container, config }) => {
 	return new ExternalJwtAuthenticator(container, externalSubjectOptions(config));