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

package/dist/nodefony/src/cspReports.js

@@ -0,0 +1,307 @@
+import { MemoryRateLimitStore } from "@nodefony/http";
+// nodefony/src/cspReports.ts
+const MINUTE_MS = 6e4;
+const MAX_URL_LENGTH = 512;
+const MAX_USER_AGENT_LENGTH = 200;
+/** Directive ou mot-clé de la norme : minuscules et tirets, court. */
+const TOKEN = /^[a-z][a-z0-9-]{0,47}$/u;
+/** Contrôles C0, DEL et C1 — jamais dans une ligne de journal ni un affichage. */
+const CONTROL = /[\u0000-\u001f\u007f-\u009f]/gu;
+const MAX_INT = 1e7;
+/**
+* Reçoit, expurge, dédoublonne et garde EN MÉMOIRE les rapports de violation
+* CSP (ADR-0024 §C7). La porte qui les livre est publique — le navigateur
+* n'envoie aucun identifiant — donc tout ce qui entre est traité comme écrit
+* par un attaquant :
+*
+* - **quota par adresse** (fenêtre d'une minute, le limiteur de `@nodefony/http`) ;
+* - **deux types de contenu seulement** : `application/csp-report` (`report-uri`)
+*   et `application/reports+json` (`report-to`) ;
+* - **URL expurgées** de leur requête, de leur fragment et de leurs identifiants
+*   (la norme ne retire pas la requête : elle peut porter un jeton) ; une URL
+*   qui n'est pas HTTP(S) se réduit à son schéma ;
+* - **l'extrait de code n'est jamais gardé** — c'est une chaîne de l'attaquant ;
+* - **mémoire bornée** : au plus `capacity` violations distinctes, la moins
+*   récemment vue évincée d'abord ; une répétition incrémente un compteur ;
+* - **journal dédoublonné et borné** : une violation neuve y part une fois, et
+*   pas plus de `logPerMinute` lignes par minute.
+*
+* Rien n'est écrit sur disque : le journal centralisé voit déjà ce qui compte.
+*/
+var CspReportCollector = class {
+	/** URL que la politique désigne. */
+	endpoint;
+	/** Violations distinctes gardées au plus. */
+	capacity;
+	#violations = /* @__PURE__ */ new Map();
+	#limiter;
+	#log;
+	#now;
+	#logPerMinute;
+	#logWindowStart = 0;
+	#loggedInWindow = 0;
+	#silenced = 0;
+	#received = 0;
+	#rejected = 0;
+	/**
+	* @param options - URL désignée, bornes, journal, horloge.
+	*/
+	constructor(options) {
+		this.endpoint = options.endpoint;
+		this.capacity = options.capacity ?? 200;
+		this.#now = options.now ?? Date.now;
+		this.#log = options.log ?? null;
+		this.#logPerMinute = options.logPerMinute ?? 20;
+		this.#limiter = new MemoryRateLimitStore({
+			windowMs: MINUTE_MS,
+			max: options.perMinute ?? 120,
+			maxTracked: options.maxTrackedClients ?? 1e4
+		}, this.#now);
+	}
+	/**
+	* Traite un corps de rapport déjà lu (et déjà borné par l'appelant).
+	*
+	* @param contentType - type de contenu de la requête, paramètres compris ou non.
+	* @param body - le corps, octets ou texte.
+	* @param client - adresse cliente résolue (proxy de confiance compris) ;
+	*   `null` = inconnue, non comptée (jamais une clé commune à tous).
+	* @param userAgent - en-tête `User-Agent`, gardé tronqué.
+	* @returns ce que le rapport est devenu — pour le journal et les tests ;
+	*   l'émetteur reçoit 204 quoi qu'il arrive.
+	*/
+	receive(contentType, body, client, userAgent) {
+		this.#received++;
+		if (client !== null && this.#limiter.hit(client).limited) {
+			this.#rejected++;
+			return "limited";
+		}
+		const type = mediaTypeOf(contentType);
+		if (type !== "application/csp-report" && type !== "application/reports+json") {
+			this.#rejected++;
+			return "unsupported";
+		}
+		let payload;
+		try {
+			payload = JSON.parse(typeof body === "string" ? body : Buffer.from(body).toString("utf8"));
+		} catch {
+			this.#rejected++;
+			return "malformed";
+		}
+		const agent = cleanText(userAgent, MAX_USER_AGENT_LENGTH);
+		const violations = violationsOf(payload);
+		if (violations.length === 0) {
+			this.#rejected++;
+			return "malformed";
+		}
+		let outcome = "duplicate";
+		for (const violation of violations) if (this.#store(violation, agent)) outcome = "stored";
+		return outcome;
+	}
+	/**
+	* Photo des violations gardées, la plus récemment vue d'abord — ce que rend
+	* le plan d'administration.
+	*
+	* @returns une copie : la modifier ne touche pas le collecteur.
+	*/
+	snapshot() {
+		const items = [];
+		for (const v of this.#violations.values()) items.push({ ...v });
+		items.reverse();
+		return {
+			enabled: true,
+			endpoint: this.endpoint,
+			capacity: this.capacity,
+			received: this.#received,
+			rejected: this.#rejected,
+			items
+		};
+	}
+	/** Range une violation ; `true` si elle est neuve. */
+	#store(violation, userAgent) {
+		const now = this.#now();
+		const key = [
+			violation.disposition,
+			violation.effectiveDirective,
+			violation.documentURL,
+			violation.blockedURL ?? "",
+			violation.sourceFile ?? "",
+			violation.lineNumber ?? "",
+			violation.columnNumber ?? ""
+		].join("\0");
+		const known = this.#violations.get(key);
+		if (known !== void 0) {
+			known.count++;
+			known.lastSeen = now;
+			if (userAgent !== null) known.userAgent = userAgent;
+			this.#violations.delete(key);
+			this.#violations.set(key, known);
+			return false;
+		}
+		if (this.#violations.size >= this.capacity) {
+			const oldest = this.#violations.keys().next();
+			if (oldest.done !== true) this.#violations.delete(oldest.value);
+		}
+		this.#violations.set(key, {
+			...violation,
+			userAgent,
+			count: 1,
+			firstSeen: now,
+			lastSeen: now
+		});
+		this.#announce(violation, now);
+		return true;
+	}
+	/** Journalise une violation neuve, dans la limite du budget de la minute. */
+	#announce(v, now) {
+		if (this.#log === null) return;
+		if (now - this.#logWindowStart >= MINUTE_MS) {
+			if (this.#silenced > 0) this.#log(`CSP : ${this.#silenced} violation(s) neuve(s) non journalisée(s) la minute précédente — liste complète : GET /nodefony/security/api/csp-reports`, "NOTICE");
+			this.#logWindowStart = now;
+			this.#loggedInWindow = 0;
+			this.#silenced = 0;
+		}
+		if (this.#loggedInWindow >= this.#logPerMinute) {
+			this.#silenced++;
+			return;
+		}
+		this.#loggedInWindow++;
+		const where = v.sourceFile !== null ? ` (${v.sourceFile}${v.lineNumber !== null ? `:${v.lineNumber}` : ""})` : "";
+		this.#log(`CSP ${v.disposition === "report" ? "signalée" : "bloquée"} : ${v.effectiveDirective} refuse ${v.blockedURL ?? "?"} sur ${v.documentURL}${where}`, "WARNING");
+	}
+};
+/** Type de contenu sans paramètres, en minuscules. */
+function mediaTypeOf(value) {
+	if (typeof value !== "string") return null;
+	const semi = value.indexOf(";");
+	return (semi === -1 ? value : value.slice(0, semi)).trim().toLowerCase();
+}
+/** Objet ordinaire, ou `null`. */
+function recordOf(value) {
+	return isRecord(value) ? value : null;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Lit un corps de rapport selon sa FORME, quel que soit celui des deux types de
+* contenu admis qui l'annonce.
+*
+* Le type ne suffit pas à décider : WebKit (Safari) poste son `report-to` en
+* `application/csp-report` avec UN rapport de la Reporting API, ni enveloppé
+* dans `csp-report` ni mis en tableau (corps relevé au navigateur). Lu sur le
+* seul type, ce rapport était écarté comme malformé — et toutes les violations
+* de Safari avec lui.
+*/
+function violationsOf(payload) {
+	if (Array.isArray(payload)) return fromReportsJson(payload);
+	const record = recordOf(payload);
+	if (record === null) return [];
+	if ("csp-report" in record) return fromCspReport(record);
+	return fromReportsJson([record]);
+}
+/** Corps `{ "csp-report": { … } }` (CSP2, `report-uri`). */
+function fromCspReport(payload) {
+	const report = recordOf(payload["csp-report"]);
+	if (report === null) return [];
+	const one = normalize({
+		documentURL: report["document-uri"],
+		blockedURL: report["blocked-uri"],
+		effectiveDirective: report["effective-directive"],
+		violatedDirective: report["violated-directive"],
+		disposition: report["disposition"],
+		sourceFile: report["source-file"],
+		lineNumber: report["line-number"],
+		columnNumber: report["column-number"],
+		statusCode: report["status-code"]
+	});
+	return one === null ? [] : [one];
+}
+/**
+* Rapports de la Reporting API (`report-to`), dont seuls ceux de type
+* `csp-violation` sont lus.
+*/
+function fromReportsJson(payload) {
+	const out = [];
+	for (const item of payload) {
+		const report = recordOf(item);
+		if (report?.["type"] !== "csp-violation") continue;
+		const body = recordOf(report["body"]);
+		if (body === null) continue;
+		const one = normalize({
+			documentURL: body["documentURL"] ?? report["url"],
+			blockedURL: body["blockedURL"],
+			effectiveDirective: body["effectiveDirective"],
+			violatedDirective: void 0,
+			disposition: body["disposition"],
+			sourceFile: body["sourceFile"],
+			lineNumber: body["lineNumber"],
+			columnNumber: body["columnNumber"],
+			statusCode: body["statusCode"]
+		});
+		if (one !== null) out.push(one);
+	}
+	return out;
+}
+/**
+* Expurge une violation ; `null` si elle ne désigne ni un document ni une
+* directive — rien d'exploitable, donc rien à garder.
+*/
+function normalize(raw) {
+	const documentURL = stripUrl(raw.documentURL);
+	if (documentURL === null) return null;
+	const effectiveDirective = tokenOf(raw.effectiveDirective) ?? firstTokenOf(raw.violatedDirective);
+	if (effectiveDirective === null) return null;
+	return {
+		documentURL,
+		blockedURL: stripUrl(raw.blockedURL),
+		effectiveDirective,
+		disposition: raw.disposition === "report" ? "report" : "enforce",
+		sourceFile: stripUrl(raw.sourceFile),
+		lineNumber: intOf(raw.lineNumber),
+		columnNumber: intOf(raw.columnNumber),
+		statusCode: intOf(raw.statusCode)
+	};
+}
+/**
+* Une URL de rapport, expurgée : sans identifiants, requête ni fragment ; le
+* seul schéma si elle n'est pas HTTP(S) (`w3c-reporting.bs`, « Strip URL for
+* use in reports », qui garde la requête — pas nous : elle peut porter un
+* jeton). Un mot-clé de la norme (`inline`, `eval`…) passe tel quel.
+*/
+function stripUrl(value) {
+	if (typeof value !== "string" || value === "") return null;
+	if (TOKEN.test(value)) return value;
+	let url;
+	try {
+		url = new URL(value);
+	} catch {
+		return null;
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:") return url.protocol.slice(0, -1);
+	url.username = "";
+	url.password = "";
+	url.search = "";
+	url.hash = "";
+	const href = url.href;
+	return href.length > MAX_URL_LENGTH ? href.slice(0, MAX_URL_LENGTH) : href;
+}
+function tokenOf(value) {
+	return typeof value === "string" && TOKEN.test(value) ? value : null;
+}
+/** `violated-directive` (CSP2) porte la directive suivie de ses sources. */
+function firstTokenOf(value) {
+	if (typeof value !== "string") return null;
+	const space = value.indexOf(" ");
+	return tokenOf(space === -1 ? value : value.slice(0, space));
+}
+function intOf(value) {
+	return typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= MAX_INT ? value : null;
+}
+/** Texte libre de l'émetteur : sans contrôles, tronqué. */
+function cleanText(value, max) {
+	if (typeof value !== "string") return null;
+	const text = value.replace(CONTROL, "").trim();
+	if (text === "") return null;
+	return text.length > max ? text.slice(0, max) : text;
+}
+export { CspReportCollector };

package/dist/nodefony/src/oauth/clientCredentials.js

@@ -1,5 +1,5 @@
-import { postTokenRequest } from "./oauth2Client.js";
 import { discoverAuthorizationServer } from "./metadata.js";
+import { postTokenRequest } from "./oauth2Client.js";
 // nodefony/src/oauth/clientCredentials.ts
 /**
 * Obtient un jeton d'accès pour un programme, par le flux `client_credentials`

package/dist/nodefony/src/oauth/metadata.js

@@ -1,5 +1,5 @@
-import { describeTransportFailure, untrustedAuthorityHint } from "../net/transportFailure.js";
 import { readJsonObjectBounded } from "./httpJson.js";
+import { describeTransportFailure, untrustedAuthorityHint } from "../net/transportFailure.js";
 import { canonicalIssuer, isBackChannelTransportAllowed, metadataCandidateUrls, validateIssuerMetadata } from "nodefony";
 // nodefony/src/oauth/metadata.ts
 /**

package/dist/nodefony/src/oauth/oauthProviderRegistry.js

@@ -13,9 +13,22 @@ const factories = /* @__PURE__ */ new Map();
 function registerOAuthProvider(name, factory, registration = {}) {
 	factories.set(name, {
 		factory,
-		requiresIssuer: registration.requiresIssuer === true
+		requiresIssuer: registration.requiresIssuer === true,
+		imageSources: registration.imageSources ?? []
 	});
 }
+/**
+* Sources d'images (avatars) des fournisseurs nommés, sans doublon — ce que
+* `img-src` doit autoriser pour afficher leurs photos de profil.
+*
+* @param names - fournisseurs configurés ; un nom inconnu ne rend rien
+* @returns les sources déclarées par leurs enregistrements
+*/
+function oauthProviderImageSources(names) {
+	const sources = /* @__PURE__ */ new Set();
+	for (const name of names) for (const source of factories.get(name)?.imageSources ?? []) sources.add(source);
+	return [...sources];
+}
 /** Fabrique d'un fournisseur par nom, ou `undefined` si inconnu. */
 function getOAuthProviderFactory(name) {
 	return factories.get(name)?.factory;
@@ -51,8 +64,8 @@ function withKeycloakThemeHint(provider) {
 	};
 }
 const GOOGLE_ISSUER = "https://accounts.google.com";
-registerOAuthProvider("google", (ctx) => createDiscoveredOidcProvider("google", ctx, { issuer: GOOGLE_ISSUER }));
+registerOAuthProvider("google", (ctx) => createDiscoveredOidcProvider("google", ctx, { issuer: GOOGLE_ISSUER }), { imageSources: ["https://*.googleusercontent.com"] });
 registerOAuthProvider("keycloak", async (ctx) => withKeycloakThemeHint(await createDiscoveredOidcProvider("keycloak", ctx)), { requiresIssuer: true });
 registerOAuthProvider("oidc", (ctx) => createDiscoveredOidcProvider("oidc", ctx), { requiresIssuer: true });
-registerOAuthProvider("github", createGithubProvider);
-export { KEYCLOAK_THEME_PARAMETER, getOAuthProviderFactory, listOAuthProviders, oauthProviderRequiresIssuer, registerOAuthProvider, withKeycloakThemeHint };
+registerOAuthProvider("github", createGithubProvider, { imageSources: ["https://avatars.githubusercontent.com"] });
+export { KEYCLOAK_THEME_PARAMETER, getOAuthProviderFactory, listOAuthProviders, oauthProviderImageSources, oauthProviderRequiresIssuer, registerOAuthProvider, withKeycloakThemeHint };

package/dist/nodefony/src/oauth/providers/github.js

@@ -1,5 +1,5 @@
-import { readJsonBounded, readJsonObjectBounded } from "../httpJson.js";
 import { OAuth2Client, OAuth2RequestError } from "../oauth2Client.js";
+import { readJsonBounded, readJsonObjectBounded } from "../httpJson.js";
 import { isPlainObject } from "nodefony";
 // nodefony/src/oauth/providers/github.ts
 /** Scopes minimaux : profil public + emails (l'email primaire peut être privé). */

package/dist/nodefony/src/realtime/UserRealtimeToken.js

@@ -1,6 +1,11 @@
 // nodefony/src/realtime/UserRealtimeToken.ts
 /** Aucun scope — figé et partagé (0 allocation pour le cas humain, le plus courant). */
 const EMPTY_SCOPES = Object.freeze([]);
+/** Une session ou une clé d'API : aucun émetteur, un compte local — figé et partagé. */
+const LOCAL_ACCOUNT = Object.freeze({
+	issuer: null,
+	account: true
+});
 /**
 * Adaptateur `IUser` → `IRealtimeToken` (jeton realtime).
 *
@@ -35,6 +40,8 @@ var UserRealtimeToken = class {
 	* `null` = aucune re-validation câblée (best-effort).
 	*/
 	#revalidate;
+	/** Cause de l'état d'un jeton porteur ; `null` pour une session. */
+	#status;
 	/**
 	* Scopes délégués repris du jeton du firewall (clé API / JWT / OAuth). Vide
 	* pour une identité humaine, qui n'est pas downscopée.
@@ -46,15 +53,29 @@ var UserRealtimeToken = class {
 	* émet elle-même l'artefact. `null` = rien à confirmer.
 	*/
 	#confirmAccount;
+	/** Émetteur et compte, repris du jeton d'origine pour l'identité d'admission. */
+	#admission;
+	/**
+	* Identité d'admission, construite au PREMIER appel puis rendue telle quelle :
+	* `null` tant que personne ne l'a demandée (un jeton construit pour un test ou
+	* un pont qui ne la lit jamais ne la paie pas).
+	*/
+	#identity = null;
 	/**
 	* @param user - identité authentifiée résolue par le firewall.
 	* @param revalidate - preuve de vie de l'identité, adaptée à son mode.
 	* @param type - mode d'authentification réel (défaut `"session"`).
 	* @param scopes - scopes délégués du jeton d'origine (défaut aucun).
 	* @param confirmAccount - relecture du compte, payée sur `api.request` seul.
+	* @param status - la CAUSE de l'état, pour un jeton porteur (expiré ou révoqué) ;
+	*   `null` pour une session, qui n'a qu'un verdict.
+	* @param admission - émetteur et compte local du jeton d'origine (défaut :
+	*   aucun émetteur, compte local — une session).
 	*/
-	constructor(user, revalidate = null, type = "session", scopes = EMPTY_SCOPES, confirmAccount = null) {
+	constructor(user, revalidate = null, type = "session", scopes = EMPTY_SCOPES, confirmAccount = null, status = null, admission = LOCAL_ACCOUNT) {
+		this.#admission = admission;
 		this.#confirmAccount = confirmAccount;
+		this.#status = status;
 		this.#user = user;
 		this.#revalidate = revalidate;
 		this.type = type;
@@ -76,6 +97,17 @@ var UserRealtimeToken = class {
 		return this.#revalidate ? this.#revalidate(nowMs) : Promise.resolve(true);
 	}
 	/**
+	* La cause de l'état de l'identité — `expired` ferme la socket en 4006, `revoked`
+	* en 4001 (ADR-0021 §S11). Sans cause câblée (session), dérivée de
+	* {@link isValid} : `false` vaut `revoked`.
+	*
+	* @param nowMs - horloge injectable (epoch ms) ; par défaut l'heure courante.
+	*/
+	async status(nowMs) {
+		if (this.#status !== null) return this.#status(nowMs);
+		return await this.isValid(nowMs) ? "active" : "revoked";
+	}
+	/**
 	* Le compte qui a ouvert la socket existe-t-il toujours, actif, et sous le
 	* même `id` immuable ? `true` si aucune confirmation n'est câblée.
 	*/
@@ -101,8 +133,33 @@ var UserRealtimeToken = class {
 	getScopes() {
 		return [...this.#scopes];
 	}
+	/**
+	* Identité d'admission gelée de la connexion — la donnée plate que reçoit la règle `allow` d'un canal (ADR-0021 §S10).
+	*
+	* Construite une fois, au premier appel, puis rendue par RÉFÉRENCE : les rôles
+	* y sont copiés et gelés une seule fois (là où {@link getRoles} recopie à
+	* chaque appel), si bien que ni le `welcome` ni l'admission ne recopient
+	* plus rien. Gelée : une règle `allow` ne peut pas s'ajouter un rôle.
+	* `id` est l'identifiant immuable du compte, jamais son login.
+	*/
+	getIdentity() {
+		if (this.#identity !== null) return this.#identity;
+		const user = this.#user;
+		const scopes = this.#scopes;
+		this.#identity = Object.freeze({
+			type: this.type,
+			authenticated: true,
+			id: user.id,
+			userIdentifier: user.identifier,
+			roles: Object.freeze([...user.roles]),
+			scopes: Object.isFrozen(scopes) ? scopes : Object.freeze([...scopes]),
+			issuer: this.#admission.issuer,
+			account: this.#admission.account
+		});
+		return this.#identity;
+	}
 	getAttribute(key) {
 		return key === "user" ? this.#user : void 0;
 	}
 };
-export { UserRealtimeToken, UserRealtimeToken as default };
+export { LOCAL_ACCOUNT, UserRealtimeToken, UserRealtimeToken as default };

package/dist/nodefony/src/realtime/frameAuthorizer.js

@@ -224,7 +224,7 @@ function satisfies(policy, token, firewall) {
 * data plane. Le verrou n'accorde donc que le plancher de ZONE, pas l'action.
 */
 function authorizeApiRequest(firewall, params, token, onDeny) {
-	const path = params?.path;
+	const path = typeof params === "object" && params !== null && "path" in params ? params.path : void 0;
 	if (typeof path !== "string") return true;
 	const qi = path.indexOf("?");
 	const pathname = qi === -1 ? path : path.slice(0, qi);
@@ -254,7 +254,7 @@ function authorizeChannel(channel, token, firewall, resolver, systemRules, onDen
 * (api.request) ou la politique du canal (subscribe/inbound).
 *
 * Trois surfaces gardées :
-*  - `api.request {path}` (pont API souverain) : re-match de zone HTTP → zone
+*  - `api.request {path}` (pont socket) : re-match de zone HTTP → zone
 *    protégée + anonyme = refus (autorisation de ZONE, identique à `GET {path}` ;
 *    la méthode/action est gardée en aval par le router + `@IsGranted`).
 *  - `subscribe {channel}` : politique de canal (système plancher + déclaration
@@ -277,11 +277,12 @@ function buildFrameAuthorizer(firewall, options) {
 	const systemRules = options?.systemRules ?? DEFAULT_SYSTEM_RULES;
 	const onDeny = options?.onDeny;
 	return (frame, token) => {
-		const f = frame;
-		const method = f?.method;
-		if (method === "api.request") return authorizeApiRequest(firewall, f?.params, token, onDeny);
+		if (typeof frame !== "object" || frame === null || !("method" in frame)) return true;
+		const method = frame.method;
+		if (method === "api.request") return authorizeApiRequest(firewall, "params" in frame ? frame.params : void 0, token, onDeny);
 		if (method === "subscribe") {
-			const channel = (f?.params)?.channel;
+			const params = "params" in frame ? frame.params : void 0;
+			const channel = typeof params === "object" && params !== null && "channel" in params ? params.channel : void 0;
 			if (typeof channel !== "string") return true;
 			return authorizeChannel(channel, token, firewall, resolver, systemRules, onDeny);
 		}

package/dist/nodefony/src/token/RemoteJwtVerifier.js

@@ -1,4 +1,5 @@
 import { describeTransportFailure, untrustedAuthorityHint } from "../net/transportFailure.js";
+import { REQUIRED_TIME_CLAIMS, isIssuedInFuture } from "./tokenTimeClaims.js";
 import { canonicalIssuer, extractScopes, metadataCandidateUrls, parseDiscoveryUrl, validateIssuerMetadata } from "nodefony";
 // nodefony/src/token/RemoteJwtVerifier.ts
 /**
@@ -149,15 +150,20 @@ var RemoteJwtVerifier = class {
 			return null;
 		}
 		const { getKey } = await this.#resolve(trusted, jose);
+		const clockTolerance = this.#options.clockToleranceS ?? 5;
 		try {
 			const { payload } = await jose.jwtVerify(token, getKey, {
 				algorithms: [...trusted.algorithms],
 				issuer: trusted.issuer,
 				audience,
-				clockTolerance: this.#options.clockToleranceS ?? 5,
+				clockTolerance,
 				...trusted.typ ? { typ: trusted.typ } : {},
-				...trusted.requiredClaims?.length ? { requiredClaims: [...trusted.requiredClaims] } : {}
+				requiredClaims: [...REQUIRED_TIME_CLAIMS, ...trusted.requiredClaims ?? []]
 			});
+			if (isIssuedInFuture(payload, Math.floor(Date.now() / 1e3), clockTolerance)) {
+				this.#audit(`jeton refusé (${trusted.issuer}) : iat dans le futur`);
+				return null;
+			}
 			return {
 				issuer: claimedIssuer,
 				payload

package/dist/nodefony/src/token/tokenTimeClaims.js

@@ -0,0 +1,34 @@
+// nodefony/src/token/tokenTimeClaims.ts
+/**
+* Bornes temporelles qu'un jeton d'accès JWT DOIT porter : `exp` et `iat`
+* (RFC 9068 §2.2, l'un et l'autre REQUIRED).
+*
+* UNE règle pour les deux chemins de vérification — jeton de l'application
+* (`JwtAuthenticator`) et jeton d'un émetteur tiers (`RemoteJwtVerifier`). Sans
+* `exp`, une connexion ouverte avec le jeton n'a plus de borne propre : le
+* revalidateur d'une socket ne sait alors la fermer que par le store de
+* révocation, et une clé volée suffit à signer un accès éternel.
+*/
+const REQUIRED_TIME_CLAIMS = Object.freeze(["exp", "iat"]);
+/**
+* Tolérance d'horloge entre l'émetteur et ce serveur, en secondes : appliquée à
+* `exp`/`nbf` par jose, et à `iat` par {@link isIssuedInFuture}.
+*/
+const CLOCK_TOLERANCE_S = 5;
+/**
+* Le jeton se dit-il émis dans le futur, au-delà de la tolérance d'horloge ?
+*
+* jose ne contrôle `iat` que lorsqu'un âge maximal est imposé (`maxTokenAge`),
+* ce que Nodefony ne fait pas. Or un `iat` daté du futur rend inopérante la
+* révocation en masse (`invalidBefore`), qui compare `iat` à un seuil passé :
+* un jeton forgé à `iat = maintenant + 10 ans` ne serait jamais « émis avant ».
+*
+* @param payload - claims VÉRIFIÉS du jeton (signature déjà contrôlée)
+* @param nowS - instant présent, en secondes epoch
+* @param toleranceS - écart d'horloge admis, en secondes
+* @returns `true` si `iat` dépasse `nowS + toleranceS`
+*/
+function isIssuedInFuture(payload, nowS, toleranceS) {
+	return typeof payload.iat === "number" && payload.iat > nowS + toleranceS;
+}
+export { CLOCK_TOLERANCE_S, REQUIRED_TIME_CLAIMS, isIssuedInFuture };

package/dist/nodefony/src/totp/totpOperations.js

@@ -1,6 +1,6 @@
 import { decryptSecret, encryptSecret } from "../crypto/secretCipher.js";
-import "./totpCipher.js";
 import { base32Encode, buildOtpauthUri, generateRecoveryCodes, generateTotpSecret, hashRecoveryCode, matchRecoveryCode, verifyTotp } from "./totpCrypto.js";
+import "./totpCipher.js";
 // nodefony/src/totp/totpOperations.ts
 /**
 * Démarre l'enrôlement : génère un secret aléatoire, le **chiffre** au repos et

package/dist/nodefony/src/voter/RoleVoter.js

@@ -1,5 +1,5 @@
-import { RoleHierarchyWalker } from "../RoleHierarchyWalker.js";
 import "../../contracts/IAccessVoter.js";
+import { RoleHierarchyWalker } from "../RoleHierarchyWalker.js";
 // nodefony/src/voter/RoleVoter.ts
 /**
 * Voter built-in **niveau A** — résout les attributs `ROLE_*` via la hiérarchie