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

package/dist/nodefony/src/net/fetchPublic.js

@@ -0,0 +1,244 @@
+import { assertPublicUrl } from "./ssrfGuard.js";
+import { SsrfError } from "../../errors/SsrfError.js";
+import { FetchPublicError } from "../../errors/FetchPublicError.js";
+import { request } from "node:http";
+import { isIP } from "node:net";
+import { request as request$1 } from "node:https";
+// nodefony/src/net/fetchPublic.ts
+const DEFAULT_MAX_BYTES = 1048576;
+const DEFAULT_TIMEOUT_MS = 1e4;
+/** Statuts de redirection que l'on suit (RFC 9110 §15.4). */
+function isRedirectStatus(status) {
+	return status === 301 || status === 302 || status === 303 || status === 307 || status === 308;
+}
+/** En-têtes qui ne doivent jamais suivre une redirection. */
+const REDIRECT_STRIPPED = /* @__PURE__ */ new Set([
+	"cookie",
+	"authorization",
+	"proxy-authorization",
+	"host"
+]);
+/** En-têtes qui décrivent le corps — retirés quand la redirection l'abandonne. */
+const BODY_HEADERS = /* @__PURE__ */ new Set([
+	"content-type",
+	"content-length",
+	"content-encoding"
+]);
+/** `lookup` qui n'offre que les IP vérifiées — le nom ne sert plus qu'au SNI et à `Host`. */
+function pinnedLookup(addresses) {
+	return (_hostname, options, callback) => {
+		const entries = addresses.map((address) => ({
+			address,
+			family: isIP(address) === 6 ? 6 : 4
+		}));
+		const first = entries[0];
+		if (first === void 0) callback(Object.assign(/* @__PURE__ */ new Error("aucune adresse vérifiée"), {
+			code: "ENOTFOUND",
+			errno: -3008
+		}), "", 4);
+		else if (options.all === true) callback(null, entries, first.family);
+		else callback(null, first.address, first.family);
+	};
+}
+/** Concatène les morceaux reçus UNE fois dans un `Uint8Array`. */
+function concat(chunks, total) {
+	const out = new Uint8Array(total);
+	let offset = 0;
+	for (const chunk of chunks) {
+		out.set(chunk, offset);
+		offset += chunk.length;
+	}
+	return out;
+}
+/**
+* Un saut HTTP(S) vers l'IP épinglée. Le corps de réponse est lu jusqu'à
+* `maxBytes` puis la connexion est DÉTRUITE (jamais drainée).
+*/
+function hop(url, method, headers, payload, addresses, follow, maxBytes, state) {
+	return new Promise((resolve, reject) => {
+		let settled = false;
+		const finish = (outcome) => {
+			if (settled) return;
+			settled = true;
+			state.current = null;
+			resolve(outcome);
+		};
+		/** Un échec réseau ; `code` est celui d'une erreur système (`ECONNRESET`…). */
+		const fail = (error, code) => {
+			if (settled) return;
+			settled = true;
+			state.current = null;
+			reject(state.expired ?? new FetchPublicError("network", typeof code === "string" ? `${error.message} (${code})` : error.message));
+		};
+		const req = (url.protocol === "https:" ? request$1 : request)(url, {
+			method,
+			headers,
+			agent: false,
+			...addresses.length > 0 ? { lookup: pinnedLookup(addresses) } : {}
+		});
+		state.current = req;
+		const onError = (error) => fail(error, error.code);
+		req.on("error", onError);
+		req.on("response", (res) => {
+			const status = res.statusCode ?? 0;
+			const location = res.headers.location;
+			if (follow && isRedirectStatus(status) && typeof location === "string") {
+				res.destroy();
+				finish({
+					kind: "redirect",
+					status,
+					location
+				});
+				return;
+			}
+			const chunks = [];
+			let total = 0;
+			res.on("data", (chunk) => {
+				if (settled) return;
+				const room = maxBytes - total;
+				if (chunk.length > room) {
+					if (room > 0) chunks.push(chunk.subarray(0, room));
+					total = maxBytes;
+					finish({
+						kind: "final",
+						status,
+						headers: res.headers,
+						body: concat(chunks, total),
+						truncated: true
+					});
+					res.destroy();
+					req.destroy();
+					return;
+				}
+				chunks.push(chunk);
+				total += chunk.length;
+			});
+			res.on("end", () => finish({
+				kind: "final",
+				status,
+				headers: res.headers,
+				body: concat(chunks, total),
+				truncated: false
+			}));
+			res.on("error", onError);
+			res.on("close", () => {
+				if (!settled) fail(/* @__PURE__ */ new Error("connexion fermée avant la fin du corps"));
+			});
+		});
+		req.end(payload);
+	});
+}
+/**
+* Lit une URL fournie par un humain sans jamais atteindre le réseau interne.
+*
+* À CHAQUE saut (adresse de départ comme redirections) : protocole, absence
+* d'identifiants et IP sont jugés par `assertPublicUrl`, puis la connexion est
+* ÉPINGLÉE sur l'IP vérifiée (aucune seconde résolution : un rebinding DNS ne
+* mène nulle part). Le délai est TOTAL — un serveur qui goutte un octet par
+* seconde est coupé — et la lecture s'arrête à `maxBytes` en détruisant la
+* connexion. Aucun cookie, aucun `Authorization` n'est ajouté ni conservé à
+* travers une redirection, et le corps n'est jamais décodé (pas de bombe de
+* décompression).
+*
+* @param rawUrl - adresse à lire.
+* @param options - méthode, corps, bornes et politique de cible.
+* @returns la réponse finale, corps borné et non décodé.
+* @throws SsrfError si la cible, ou une redirection, est interdite.
+* @throws FetchPublicError si le délai total, le nombre de redirections ou le réseau échoue.
+*/
+async function fetchPublic(rawUrl, options = {}) {
+	const maxRedirects = options.maxRedirects ?? 0;
+	const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+	const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+	if (!Number.isSafeInteger(maxBytes) || maxBytes < 0) throw new RangeError("maxBytes doit être un entier positif ou nul");
+	if (!Number.isSafeInteger(maxRedirects) || maxRedirects < 0) throw new RangeError("maxRedirects doit être un entier positif ou nul");
+	if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) throw new RangeError("timeoutMs doit être strictement positif");
+	let payload = options.body === void 0 ? null : typeof options.body === "string" ? new TextEncoder().encode(options.body) : options.body;
+	let method = (options.method ?? (payload === null ? "GET" : "POST")).toUpperCase();
+	let headers = { "accept-encoding": "identity" };
+	if (options.headers !== void 0) for (const [name, value] of Object.entries(options.headers)) headers[name.toLowerCase()] = value;
+	if (payload !== null) headers["content-length"] = String(payload.length);
+	const allowHttp = options.allowHttp === true;
+	const state = {
+		current: null,
+		expired: null
+	};
+	let expire;
+	const deadline = new Promise((_, rejectDeadline) => {
+		expire = rejectDeadline;
+	});
+	deadline.catch(() => void 0);
+	const timer = setTimeout(() => {
+		const error = new FetchPublicError("timeout", `délai total de ${timeoutMs} ms dépassé`);
+		state.expired = error;
+		expire(error);
+		state.current?.destroy();
+	}, timeoutMs);
+	try {
+		let first = true;
+		let target = rawUrl;
+		let pinnedHost = null;
+		let pinnedAddresses = [];
+		let redirects = 0;
+		for (;;) {
+			let url;
+			let addresses;
+			if (first && options.vettedAddresses !== void 0 && options.vettedAddresses.length > 0) {
+				({url} = await Promise.race([assertPublicUrl(target, {
+					allowPrivate: true,
+					allowHttp
+				}), deadline]));
+				addresses = options.vettedAddresses;
+			} else if (!first && new URL(target).hostname === pinnedHost) {
+				({url} = await Promise.race([assertPublicUrl(target, {
+					allowPrivate: true,
+					allowHttp
+				}), deadline]));
+				addresses = pinnedAddresses;
+			} else {
+				const checked = await Promise.race([assertPublicUrl(target, {
+					allowPrivate: options.allowPrivate === true,
+					allowHttp,
+					...options.resolver !== void 0 ? { resolver: options.resolver } : {}
+				}), deadline]);
+				url = checked.url;
+				addresses = checked.addresses;
+			}
+			first = false;
+			pinnedHost = url.hostname;
+			pinnedAddresses = addresses;
+			const outcome = await Promise.race([hop(url, method, headers, payload, addresses, maxRedirects > 0, maxBytes, state), deadline]);
+			if (outcome.kind === "final") return {
+				status: outcome.status,
+				headers: outcome.headers,
+				body: outcome.body,
+				truncated: outcome.truncated,
+				url,
+				redirects
+			};
+			if (redirects >= maxRedirects) throw new FetchPublicError("too-many-redirects", `plus de ${maxRedirects} redirection(s)`);
+			redirects++;
+			try {
+				target = new URL(outcome.location, url).href;
+			} catch {
+				throw new SsrfError("en-tête Location invalide");
+			}
+			const toGet = outcome.status === 303 && method !== "GET" && method !== "HEAD" || (outcome.status === 301 || outcome.status === 302) && method === "POST";
+			const next = {};
+			for (const [name, value] of Object.entries(headers)) {
+				if (REDIRECT_STRIPPED.has(name)) continue;
+				if (toGet && BODY_HEADERS.has(name)) continue;
+				next[name] = value;
+			}
+			headers = next;
+			if (toGet) {
+				payload = null;
+				method = "GET";
+			}
+		}
+	} finally {
+		clearTimeout(timer);
+		state.current?.destroy();
+	}
+}
+export { fetchPublic };

package/dist/nodefony/src/net/ssrfGuard.js

@@ -116,9 +116,9 @@ async function assertPublicUrl(rawUrl, options = {}) {
 		try {
 			addresses = await resolver(host);
 		} catch {
-			throw new SsrfError(`hôte non résolvable : « ${host} »`);
+			throw new SsrfError(`hôte non résolvable : « ${host} »`, "unresolvable");
 		}
-		if (addresses.length === 0) throw new SsrfError(`hôte sans adresse : « ${host} »`);
+		if (addresses.length === 0) throw new SsrfError(`hôte sans adresse : « ${host} »`, "unresolvable");
 	}
 	for (const ip of addresses) if (isBlockedAddress(ip)) throw new SsrfError(`cible non publique interdite : ${host} → ${ip}`);
 	return {

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

@@ -130,40 +130,104 @@ function buildSystemRules(prefixes) {
 	return rules;
 }
 /**
-* `s` contient-il `needle`, insensible à la casse et sans allocation ? Pour les
-* conventions transverses `:health`/`:stats` (après le namespace de module —
-* `mymod:health` — éventuellement suffixées d'une cadence `nodefony:orm:health:5000`).
+* `word` (en minuscules) figure-t-il à la position `at` de `s`, insensible à la casse, sans allocation ?
 */
-function containsCI(s, needle) {
-	const last = s.length - needle.length;
-	for (let i = 0; i <= last; i++) {
-		let ok = true;
-		for (let j = 0; j < needle.length; j++) {
-			let a = s.charCodeAt(i + j);
-			if (a >= 65 && a <= 90) a += 32;
-			let b = needle.charCodeAt(j);
-			if (b >= 65 && b <= 90) b += 32;
-			if (a !== b) {
-				ok = false;
-				break;
-			}
-		}
-		if (ok) return true;
+function wordAtCI(s, at, word) {
+	if (at + word.length > s.length) return false;
+	for (let j = 0; j < word.length; j++) {
+		let c = s.charCodeAt(at + j);
+		if (c >= 65 && c <= 90) c += 32;
+		if (c !== word.charCodeAt(j)) return false;
+	}
+	return true;
+}
+/**
+* Convention transverse `:health` ou `:stats` portée par le nom, insensible à la casse et sans allocation — le suffixe trouvé (en minuscules), ou `null`. Après le namespace de module (`mymod:health`), éventuellement suffixée d'une cadence (`nodefony:orm:health:5000`).
+*
+* Exécuté à CHAQUE trame jugée — une action RPC n'est jamais retenue. Les deux
+* motifs commencent par `:`, qui n'a pas de casse : on saute de `:` en `:` par
+* `indexOf` (natif) et on ne compare les deux mots qu'à ces positions, en une
+* passe. Le balayage naïf (chaque position, deux passes, casse abaissée à
+* chaque caractère) pesait plus que tout le reste du verrou sur un canal libre
+* (micro-frame-authorizer, verrou seul : 125 → 55 ns). Même verdict, prouvé
+* contre le balayage naïf par `realtimeFrameLock.test.ts`. Les retours sont des
+* littéraux : rien n'est alloué, et le refus expliqué
+* ({@link explainReservedSuffix}) nomme le suffixe par la MÊME fonction.
+*/
+function reservedConventionAt(s) {
+	let i = s.indexOf(":");
+	while (i !== -1) {
+		if (wordAtCI(s, i + 1, "health")) return ":health";
+		if (wordAtCI(s, i + 1, "stats")) return ":stats";
+		i = s.indexOf(":", i + 1);
 	}
-	return false;
+	return null;
+}
+/**
+* Première règle système dont le préfixe couvre le canal, ou `null`. Premier
+* préfixe qui matche gagne (la config est placée AVANT les défauts par le
+* firewall → elle peut surcharger). Match INSENSIBLE À LA CASSE (cf
+* {@link startsWithCI}) : le plancher ne se contourne pas en altérant la casse
+* du namespace.
+*/
+function matchSystemRule(channel, rules) {
+	for (const rule of rules) if (startsWithCI(channel, rule.prefix)) return rule;
+	return null;
 }
 /**
 * Politique système applicable à un canal, ou `null` si le canal n'est pas
-* réservé. Premier préfixe qui matche gagne (la config est placée AVANT les
-* défauts par le firewall → elle peut surcharger). Les conventions transverses
-* `:health`/`:stats` retombent sur la politique système par défaut. Le match est
-* INSENSIBLE À LA CASSE (cf {@link startsWithCI}) : le plancher ne se contourne
-* pas en altérant la casse du namespace.
+* réservé. Une règle de préfixe ({@link matchSystemRule}) passe avant tout ; à
+* défaut, les conventions transverses `:health`/`:stats` retombent sur la
+* politique système par défaut.
 */
 function matchSystemPolicy(channel, rules) {
-	for (const rule of rules) if (startsWithCI(channel, rule.prefix)) return floorReserved(channel, rule.policy);
-	if (containsCI(channel, ":health") || containsCI(channel, ":stats")) return SYSTEM_CHANNEL_POLICY;
-	return null;
+	const rule = matchSystemRule(channel, rules);
+	if (rule !== null) return floorReserved(channel, rule.policy);
+	return reservedConventionAt(channel) !== null ? SYSTEM_CHANNEL_POLICY : null;
+}
+/**
+* Explique un refus dû à la convention transverse `:health` / `:stats` — la phrase qui nomme le suffixe réservé, le rôle exigé et la surcharge, ou `null` si le refus a une autre cause.
+*
+* Le cas mérite sa phrase parce qu'il SURPREND : le hub ne réserve que l'espace
+* `nodefony:`, et une application qui nomme son canal `net:health` se le voit
+* refuser sans avoir rien déclaré — elle finissait par le renommer à l'aveugle.
+* Les autres refus (namespace de plateforme, politique déclarée) gardent le
+* détail générique du hub : la règle y est écrite par l'application ou nommée
+* par l'espace lui-même.
+*
+* Chemin FROID : appelé seulement après un refus. Ce n'est pas un oracle de
+* plus — la convention est un défaut public du framework, pas une politique de
+* l'application —, et le hub ne la laisse de toute façon partir au client
+* qu'hors production (`deniedDetail`).
+*
+* @param channel - canal refusé.
+* @param token - jeton de la connexion.
+* @param firewall - checker de rôle (hiérarchie comprise).
+* @param rules - règles système effectives (config puis défauts).
+* @returns la phrase, ou `null`.
+*/
+function explainReservedSuffix(channel, token, firewall, rules) {
+	if (matchSystemRule(channel, rules) !== null) return null;
+	const suffix = reservedConventionAt(channel);
+	if (suffix === null) return null;
+	if (satisfies(SYSTEM_CHANNEL_POLICY, token, firewall)) return null;
+	const colon = channel.indexOf(":");
+	const prefix = colon > 0 ? channel.slice(0, colon + 1) : channel;
+	return `« ${channel} » porte le suffixe « ${suffix} », que les politiques par défaut de la sécurité réservent à la plateforme dans TOUT espace de noms (${(SYSTEM_CHANNEL_POLICY.roles ?? []).join(" ou ")} exigé). Pour l'ouvrir à l'application, déclare une règle de préfixe dans \`realtimeChannels\` de la configuration de sécurité — par exemple \`{ pattern: "${prefix}", authenticated: true }\` : placée avant les défauts, elle gagne`;
+}
+/**
+* Canal visé par une trame — celui d'un `subscribe`, ou le nom d'un canal
+* entrant — ; `null` pour un `api.request` ou une trame sans nom lisible.
+*/
+function frameChannel(frame) {
+	if (typeof frame !== "object" || frame === null || !("method" in frame)) return null;
+	const method = frame.method;
+	if (method === "subscribe") {
+		const params = "params" in frame ? frame.params : void 0;
+		const channel = typeof params === "object" && params !== null && "channel" in params ? params.channel : void 0;
+		return typeof channel === "string" ? channel : null;
+	}
+	return typeof method === "string" && method !== "api.request" ? method : null;
 }
 /**
 * F2 (revue 0.6) — applique le PLANCHER irréductible : si `channel` est dans un
@@ -224,7 +288,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);
@@ -236,16 +300,35 @@ function authorizeApiRequest(firewall, params, token, onDeny) {
 	return true;
 }
 /**
-* Verrou `subscribe {channel}` (et canaux inbound full-duplex) — applique la
-* politique du canal. PLANCHER système prioritaire (namespace réservé) ; sinon
-* politique métier déclarée (`@RealtimeChannel`) ; sinon canal libre.
+* Verrou `subscribe {channel}`, canaux entrants et actions — applique la
+* politique du nom. PLANCHER système prioritaire (namespace réservé) ; sinon
+* politique métier déclarée ; sinon canal libre.
+*
+* Deux sortes (ADR-0022 §6, décision 1 quater) : `subscribe` exige la LECTURE ;
+* une trame entrante (`writing`) exige la lecture ET l'écriture distincte quand
+* le nom en déclare une. L'écriture n'est jamais moins stricte que la lecture.
 */
-function authorizeChannel(channel, token, firewall, resolver, systemRules, onDeny) {
-	const policy = matchSystemPolicy(channel, systemRules) ?? resolver?.resolveChannelPolicy?.(channel) ?? null;
-	if (policy === null) return true;
-	if (satisfies(policy, token, firewall)) return true;
-	onDeny?.("channel", channel, "channel_policy", token);
-	return false;
+function authorizeChannel(channel, writing, token, firewall, resolver, systemRules, onDeny) {
+	let read = matchSystemPolicy(channel, systemRules);
+	let write = null;
+	if (read === null && resolver !== null) {
+		if (resolver.resolveChannelPolicies !== void 0) {
+			const declared = resolver.resolveChannelPolicies(channel);
+			if (declared === null) return true;
+			read = declared.policy;
+			if (writing) write = declared.write;
+		} else read = resolver.resolveChannelPolicy?.(channel) ?? null;
+	}
+	if (read === null) return true;
+	if (!satisfies(read, token, firewall)) {
+		onDeny?.("channel", channel, "channel_policy", token);
+		return false;
+	}
+	if (write !== null && !satisfies(write, token, firewall)) {
+		onDeny?.("channel", channel, "channel_write_policy", token);
+		return false;
+	}
+	return true;
 }
 /**
 * Construit le verrou de frame WS branché sur le hub realtime par le firewall au
@@ -276,17 +359,26 @@ function buildFrameAuthorizer(firewall, options) {
 	const resolver = options?.channelResolver ?? null;
 	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);
+	const authorizer = (frame, token) => {
+		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);
+			return authorizeChannel(channel, false, token, firewall, resolver, systemRules, onDeny);
 		}
-		if (typeof method === "string") return authorizeChannel(method, token, firewall, resolver, systemRules, onDeny);
+		if (typeof method === "string") return authorizeChannel(method, true, token, firewall, resolver, systemRules, onDeny);
 		return true;
 	};
+	const explain = (frame, token) => {
+		const channel = frameChannel(frame);
+		return channel === null ? null : explainReservedSuffix(channel, token, firewall, systemRules);
+	};
+	return Object.assign(authorizer, {
+		judgesWrite: true,
+		explain
+	});
 }
 export { DEFAULT_SYSTEM_PREFIXES, DEFAULT_SYSTEM_RULES, RESERVED_FLOOR_PREFIXES, SECURITY_CHANNEL_POLICY, SYSTEM_CHANNEL_POLICY, UPLINK_CHANNEL_POLICY, buildFrameAuthorizer, buildFrameAuthorizer as default, buildSystemRules };

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