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

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

@@ -0,0 +1,282 @@
+import { describeTransportFailure, untrustedAuthorityHint } from "../net/transportFailure.js";
+import { OAuth2RequestError, generateCodeVerifier, generateState } from "./oauth2Client.js";
+import { IssuerMismatchError } from "nodefony";
+// nodefony/src/oauth/providerDiagnosis.ts
+/** Le code présenté au point de jeton : il n'a jamais été émis, il sera refusé. */
+const PROBE_CODE = "nodefony-doctor-probe";
+const AUTHORIZATION_TIMEOUT_MS = 1e4;
+/**
+* Lu au plus sur une page d'erreur : de quoi y trouver le nom du paramètre en
+* cause, pas de quoi charger une page entière.
+*/
+const MAX_ERROR_PAGE_BYTES = 65536;
+function errorMessage(error) {
+	const hint = untrustedAuthorityHint(error);
+	const text = describeTransportFailure(error);
+	return hint === null ? text : `${text} — ${hint}`;
+}
+/** Les premiers octets d'une page, en texte — le reste est abandonné. */
+async function readHead(response, maxBytes) {
+	const body = response.body;
+	if (body === null) return "";
+	const reader = body.getReader();
+	const chunks = [];
+	let seen = 0;
+	for (;;) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		chunks.push(value);
+		seen += value.byteLength;
+		if (seen >= maxBytes) {
+			await reader.cancel();
+			break;
+		}
+	}
+	return Buffer.concat(chunks).toString("utf8");
+}
+/** `true` si `location` désigne l'URL de retour (même origine, même chemin). */
+function pointsTo(location, redirectUri) {
+	let target;
+	try {
+		target = new URL(redirectUri);
+	} catch {
+		return false;
+	}
+	return location.origin === target.origin && location.pathname === target.pathname;
+}
+/**
+* Sonde 1 — construit le fournisseur.
+*
+* @returns le fournisseur, ou la sonde en échec.
+*/
+async function probeDiscovery(input) {
+	try {
+		const provider = await input.build();
+		const pkce = provider.usesPkce ? ", PKCE S256" : ", sans PKCE";
+		return {
+			provider,
+			check: {
+				name: "discovery",
+				status: "ok",
+				message: provider.issuerPolicy === null ? `fournisseur construit — points d'entrée fixes, sans découverte${pkce}` : `métadonnées lues, émetteur « ${provider.issuerPolicy.issuer} » identique${pkce}`
+			}
+		};
+	} catch (error) {
+		if (error instanceof IssuerMismatchError) return {
+			provider: null,
+			check: {
+				name: "discovery",
+				status: "failed",
+				kind: "issuer-mismatch",
+				message: `l'émetteur se déclare « ${error.declaredIssuer} », la configuration écrit « ${error.expectedIssuer} » (RFC 8414 §3.3) — reprends l'adresse EXACTE que le serveur annonce (hôte, port, chemin du realm)`
+			}
+		};
+		return {
+			provider: null,
+			check: {
+				name: "discovery",
+				status: "failed",
+				kind: "discovery-failed",
+				message: errorMessage(error)
+			}
+		};
+	}
+}
+/**
+* Sonde 2 — la requête du bouton de connexion, sans la suivre.
+*
+* Un serveur qui refuse l'URL de retour ne doit PAS y renvoyer (RFC 6749
+* §4.1.2.1) : il répond lui-même, en erreur. Un renvoi vers l'URL de retour
+* prouve donc qu'elle est acceptée ; une page de connexion aussi.
+*/
+async function probeAuthorization(input, provider) {
+	const url = provider.createAuthorizationURL({
+		state: generateState(),
+		codeVerifier: provider.usesPkce ? generateCodeVerifier() : null,
+		scopes: input.scopes !== void 0 && input.scopes.length > 0 ? input.scopes : provider.defaultScopes
+	});
+	let response;
+	try {
+		response = await (input.fetch ?? globalThis.fetch)(url, {
+			headers: {
+				Accept: "text/html",
+				"User-Agent": "nodefony"
+			},
+			redirect: "manual",
+			signal: AbortSignal.timeout(input.timeoutMs ?? AUTHORIZATION_TIMEOUT_MS)
+		});
+	} catch (error) {
+		return {
+			client: null,
+			page: null,
+			check: {
+				name: "authorization",
+				status: "failed",
+				kind: "authorization-unreachable",
+				message: `point d'autorisation injoignable : ${errorMessage(error)}`
+			}
+		};
+	}
+	if (response.status >= 200 && response.status < 300) {
+		let page = null;
+		if (input.pageCheck === void 0) await response.body?.cancel();
+		else {
+			const html = await readHead(response, MAX_ERROR_PAGE_BYTES).catch(() => "");
+			page = input.pageCheck(html);
+		}
+		return {
+			client: "known",
+			page,
+			check: {
+				name: "authorization",
+				status: "ok",
+				message: "client et URL de retour acceptés (page de connexion servie)"
+			}
+		};
+	}
+	if (response.status >= 300 && response.status < 400) {
+		await response.body?.cancel();
+		const raw = response.headers.get("location");
+		const location = raw === null ? null : new URL(raw, url);
+		if (location !== null && pointsTo(location, input.redirectUri)) {
+			const refused = location.searchParams.get("error");
+			if (refused === null) return {
+				client: "known",
+				page: null,
+				check: {
+					name: "authorization",
+					status: "ok",
+					message: "client et URL de retour acceptés"
+				}
+			};
+			const description = location.searchParams.get("error_description");
+			return {
+				client: "known",
+				page: null,
+				check: {
+					name: "authorization",
+					status: "failed",
+					kind: "authorization-refused",
+					message: `URL de retour acceptée, mais la demande est refusée : « ${refused} »` + (description === null ? "" : ` — ${description}`)
+				}
+			};
+		}
+		return {
+			client: null,
+			page: null,
+			check: {
+				name: "authorization",
+				status: "inconclusive",
+				message: `le point d'autorisation renvoie vers ${location?.origin ?? "une adresse absente"} — l'URL de retour ne se juge alors qu'après une connexion`
+			}
+		};
+	}
+	if ((await readHead(response, MAX_ERROR_PAGE_BYTES).catch(() => "")).includes("redirect_uri")) return {
+		client: null,
+		page: null,
+		check: {
+			name: "authorization",
+			status: "failed",
+			kind: "redirect-uri-rejected",
+			message: `URL de retour refusée (HTTP ${response.status}) : « ${input.redirectUri} » n'est pas enregistrée sur le client « ${input.clientId} » — ajoute-la telle quelle aux URL de retour du client`
+		}
+	};
+	return {
+		client: null,
+		page: null,
+		check: {
+			name: "authorization",
+			status: "failed",
+			kind: "authorization-refused",
+			message: `le point d'autorisation refuse la demande (HTTP ${response.status}) sans renvoyer vers l'application — client « ${input.clientId} » inconnu ou désactivé, ou URL de retour non enregistrée`
+		}
+	};
+}
+/**
+* Sonde 3 — un code inventé, présenté avec les vrais identifiants.
+*
+* @param client - ce que la sonde 2 a établi : un client CONNU qui échoue à
+*   s'authentifier ne peut avoir qu'un secret faux.
+*/
+async function probeToken(input, provider, client) {
+	const publicClient = input.clientAuthMethod === "none";
+	try {
+		await provider.validateAuthorizationCode({
+			code: PROBE_CODE,
+			codeVerifier: provider.usesPkce ? generateCodeVerifier() : null
+		});
+		return {
+			name: "token",
+			status: "inconclusive",
+			message: "le point de jeton a ACCEPTÉ un code inventé — ce serveur ne se comporte pas comme un serveur OAuth 2.0, rien ne peut en être conclu"
+		};
+	} catch (error) {
+		if (!(error instanceof OAuth2RequestError)) return {
+			name: "token",
+			status: "failed",
+			kind: "token-unreachable",
+			message: `point de jeton injoignable : ${errorMessage(error)}`
+		};
+		if (error.code === "invalid_grant") return {
+			name: "token",
+			status: "ok",
+			message: publicClient ? "client public reconnu (le code de sonde est refusé, comme prévu)" : "secret accepté (le code de sonde est refusé, comme prévu)"
+		};
+		if (error.code === "invalid_client" || error.status === 401) {
+			if (client === "known" && !publicClient) return {
+				name: "token",
+				status: "failed",
+				kind: "secret-rejected",
+				message: `secret refusé : le client « ${input.clientId} » existe (le point d'autorisation l'accepte), mais son secret n'est pas celui que le serveur attend — recopie-le depuis le fournisseur`
+			};
+			return {
+				name: "token",
+				status: "failed",
+				kind: "client-rejected",
+				message: `authentification du client « ${input.clientId} » refusée (${error.code}) : client inconnu de ce serveur, ou secret faux`
+			};
+		}
+		return {
+			name: "token",
+			status: "failed",
+			kind: "token-refused",
+			message: `le point de jeton refuse le client : « ${error.code} »` + (error.description === null ? "" : ` — ${error.description}`)
+		};
+	}
+}
+/**
+* Diagnostique un fournisseur OAuth sans connexion humaine.
+*
+* Ne lève jamais : un serveur muet ou hostile devient une sonde en échec, et
+* les sondes que l'échec rend impossibles sont DITES sautées — un silence ne
+* vaut pas quitus.
+*
+* @param input - fournisseur à construire et configuration à confronter.
+* @returns les trois sondes et leur verdict.
+*/
+async function diagnoseOAuthProvider(input) {
+	const discovery = await probeDiscovery(input);
+	const checks = [discovery.check];
+	if (discovery.provider === null) {
+		const reason = "impossible sans fournisseur construit (découverte en échec)";
+		checks.push({
+			name: "authorization",
+			status: "skipped",
+			message: reason
+		}, {
+			name: "token",
+			status: "skipped",
+			message: reason
+		});
+	} else {
+		const authorization = await probeAuthorization(input, discovery.provider);
+		checks.push(authorization.check, await probeToken(input, discovery.provider, authorization.client));
+		if (authorization.page !== null) checks.push(authorization.page);
+	}
+	return {
+		provider: input.name,
+		ok: checks.every((c) => c.status !== "failed"),
+		checks
+	};
+}
+export { diagnoseOAuthProvider };

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

@@ -0,0 +1,78 @@
+// nodefony/src/oauth/providerRoles.ts
+/** Source par défaut : les rôles du CLIENT — ceux que l'annuaire attribue à CETTE application. */
+const DEFAULT_ROLE_SOURCES = ["client"];
+/**
+* Préfixe des rôles de PLATEFORME (console d'administration, plan
+* d'administration) — jamais accordés par un annuaire externe.
+*/
+const PLATFORM_ROLE_PREFIX = "ROLE_NODEFONY_";
+/** `true` si le rôle relève de la plateforme (`ROLE_NODEFONY_*`). */
+function isPlatformRole(role) {
+	return role.startsWith(PLATFORM_ROLE_PREFIX);
+}
+/**
+* Compile la table d'un fournisseur — `null` quand il n'en déclare aucune, ce
+* qui laisse les rôles du compte entièrement locaux (comportement historique).
+*
+* @param config - configuration du fournisseur.
+* @returns la table compilée, ou `null`.
+*/
+function compileProviderRoleMapping(config) {
+	const mapping = config.roleMapping;
+	if (mapping === void 0) return null;
+	const table = Object.create(null);
+	for (const [from, to] of Object.entries(mapping)) table[from] = to;
+	return {
+		clientId: config.clientId,
+		sources: config.rolesSource !== void 0 && config.rolesSource.length > 0 ? config.rolesSource : DEFAULT_ROLE_SOURCES,
+		table
+	};
+}
+/**
+* Rôles de l'application accordés par le fournisseur, d'après ses claims.
+*
+* Un rôle du fournisseur absent de la table est IGNORÉ — jamais recopié tel
+* quel : l'annuaire ne fabrique pas de rôle que l'application n'a pas déclaré.
+* Plusieurs jeux de claims (jeton d'accès, jeton d'identité) se cumulent : ils
+* viennent du même émetteur, chacun peut porter une partie des rôles selon
+* les « mappers » configurés chez lui.
+*
+* @param mapping - table compilée du fournisseur.
+* @param claimSets - claims à lire ; `null`/`undefined` ignorés.
+* @returns rôles de l'application, triés et sans doublon.
+*/
+function mapProviderRoles(mapping, ...claimSets) {
+	const granted = /* @__PURE__ */ new Set();
+	for (const claims of claimSets) {
+		if (claims === null || claims === void 0) continue;
+		for (const source of mapping.sources) for (const role of readSource(claims, source, mapping.clientId)) {
+			const mapped = mapping.table[role];
+			if (mapped !== void 0) granted.add(mapped);
+		}
+	}
+	return [...granted].sort();
+}
+/** Lit les rôles bruts d'une source — tableau vide si la forme n'est pas celle attendue. */
+function readSource(claims, source, clientId) {
+	switch (source) {
+		case "client": {
+			const access = asRecord(claims.resource_access);
+			return access === null ? [] : rolesOf(access[clientId]);
+		}
+		case "realm": return rolesOf(claims.realm_access);
+		case "groups": return strings(claims.groups);
+	}
+}
+/** `{ roles: [...] }` → les chaînes de `roles`. */
+function rolesOf(value) {
+	const record = asRecord(value);
+	return record === null ? [] : strings(record.roles);
+}
+function asRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function strings(value) {
+	if (!Array.isArray(value)) return [];
+	return value.filter((v) => typeof v === "string");
+}
+export { DEFAULT_ROLE_SOURCES, PLATFORM_ROLE_PREFIX, compileProviderRoleMapping, isPlatformRole, mapProviderRoles };

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

@@ -1,6 +1,7 @@
-import { readJsonBounded } from "../httpJson.js";
-import { OAuth2Client } from "../oauth2Client.js";
-//#region nodefony/src/oauth/providers/github.ts
+import { readJsonBounded, readJsonObjectBounded } from "../httpJson.js";
+import { OAuth2Client, OAuth2RequestError } from "../oauth2Client.js";
+import { isPlainObject } from "nodefony";
+// nodefony/src/oauth/providers/github.ts
 /** Scopes minimaux : profil public + emails (l'email primaire peut être privé). */
 const DEFAULT_SCOPES = ["read:user", "user:email"];
 const API = "https://api.github.com";
@@ -25,7 +26,39 @@ async function ghGet(url, accessToken) {
 		signal: AbortSignal.timeout(API_TIMEOUT_MS)
 	});
 	if (!res.ok) throw new Error(`GitHub API ${url} → ${res.status}`);
-	return readJsonBounded(res, MAX_PROFILE_BYTES, `GitHub API ${url}`);
+	return res;
+}
+/**
+* Les adresses que rend `GET /user/emails` — un tableau, sinon une erreur qui
+* nomme l'appel ; une entrée qui n'est pas un objet est écartée.
+*/
+async function ghEmails(accessToken) {
+	const url = `${API}/user/emails`;
+	const list = await readJsonBounded(await ghGet(url, accessToken), MAX_PROFILE_BYTES, `GitHub API ${url}`);
+	if (!Array.isArray(list)) throw new Error(`GitHub API ${url} → corps inattendu (tableau JSON attendu)`);
+	return list.filter(isPlainObject);
+}
+/**
+* Codes d'erreur PROPRES à GitHub, rendus dans leur équivalent RFC 6749 §5.2
+* (relevés sur le point de jeton réel : un code inventé rend
+* `bad_verification_code`, un secret faux `incorrect_client_credentials`,
+* tous deux en HTTP 200).
+*
+* Sans cette traduction, tout ce qui lit le code normalisé — le diagnostic
+* `security:oauth:doctor` d'abord — prendrait un secret ACCEPTÉ pour un refus.
+* Le code d'origine reste dans la description, pour le journal.
+*/
+const GITHUB_ERROR_CODES = {
+	bad_verification_code: "invalid_grant",
+	incorrect_client_credentials: "invalid_client",
+	redirect_uri_mismatch: "invalid_grant"
+};
+function normalizeGithubError(error) {
+	if (!(error instanceof OAuth2RequestError)) return error;
+	const code = GITHUB_ERROR_CODES[error.code];
+	if (code === void 0) return error;
+	const description = `${error.description ?? error.code} (GitHub : ${error.code})`;
+	return new OAuth2RequestError(code, description, error.status);
 }
 /**
 * Fournisseur **GitHub** (OAuth 2.0 simple, NON-OIDC). Pas de PKCE, pas d'ID
@@ -52,15 +85,19 @@ function createGithubProvider(ctx) {
 				codeVerifier: null
 			});
 		},
-		validateAuthorizationCode(request) {
-			return client.validateAuthorizationCode({
-				...request,
-				codeVerifier: null
-			});
+		async validateAuthorizationCode(request) {
+			try {
+				return await client.validateAuthorizationCode({
+					...request,
+					codeVerifier: null
+				});
+			} catch (error) {
+				throw normalizeGithubError(error);
+			}
 		},
 		async fetchProfile(tokens) {
 			const accessToken = tokens.accessToken();
-			const user = await ghGet(`${API}/user`, accessToken);
+			const user = await readJsonObjectBounded(await ghGet(`${API}/user`, accessToken), MAX_PROFILE_BYTES, `GitHub API ${API}/user`);
 			const id = user.id;
 			if (typeof id !== "number" && typeof id !== "string") throw new Error("GitHub /user sans identifiant.");
 			const login = typeof user.login === "string" ? user.login : null;
@@ -68,7 +105,7 @@ function createGithubProvider(ctx) {
 			let email = typeof user.email === "string" ? user.email : null;
 			let emailVerified = email !== null;
 			if (email === null) {
-				const list = await ghGet(`${API}/user/emails`, accessToken);
+				const list = await ghEmails(accessToken);
 				const primary = list.find((e) => e.primary === true) ?? list.at(0) ?? null;
 				if (primary && typeof primary.email === "string") {
 					email = primary.email;
@@ -86,5 +123,4 @@ function createGithubProvider(ctx) {
 		}
 	};
 }
-//#endregion
 export { createGithubProvider };

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

@@ -1,11 +1,55 @@
+import { RemoteJwtVerifier } from "../../token/RemoteJwtVerifier.js";
 import { OAuth2Client } from "../oauth2Client.js";
 import { discoverAuthorizationServer } from "../metadata.js";
-//#region nodefony/src/oauth/providers/oidc.ts
+import { isPlainObject } from "nodefony";
+// nodefony/src/oauth/providers/oidc.ts
 const DEFAULT_OIDC_SCOPES = [
 	"openid",
 	"profile",
 	"email"
 ];
+/** Membre de `events` qui déclare un jeton de déconnexion (§2.4). */
+const BACKCHANNEL_LOGOUT_EVENT = "http://schemas.openid.net/event/backchannel-logout";
+/**
+* Algorithme d'ID token par défaut quand l'émetteur n'en annonce aucun
+* (OpenID Connect Back-Channel Logout 1.0 §2.6, point 3).
+*/
+const DEFAULT_LOGOUT_TOKEN_ALGORITHMS = ["RS256"];
+/**
+* Lit ce qu'un jeton de déconnexion DÉSIGNE, une fois sa signature vérifiée —
+* les points 5 à 7 de la validation (OpenID Connect Back-Channel Logout 1.0
+* §2.6) : `sub` ou `sid` présent, `events` qui le déclare jeton de
+* déconnexion, AUCUN `nonce`.
+*
+* @remarks Ces gardes ferment la confusion entre jetons (§4.1) : un ID token
+* du même émetteur, pour le même client, porte une signature tout aussi
+* valide — c'est `events` qui le distingue, et l'absence de `nonce` qui
+* empêche le chemin inverse. Fonction PURE, éprouvable sans clé ni réseau.
+*
+* @param issuer - émetteur canonique rendu par la vérification de signature.
+* @param payload - claims vérifiés.
+* @returns les claims utiles, ou `null` si le jeton n'est pas un jeton de
+*   déconnexion valide.
+*/
+function readLogoutTokenClaims(issuer, payload) {
+	const sub = typeof payload.sub === "string" ? payload.sub : null;
+	const sid = typeof payload.sid === "string" ? payload.sid : null;
+	if ((sub === null || sub === "") && (sid === null || sid === "")) return null;
+	const events = payload.events;
+	if (!isPlainObject(events)) return null;
+	const event = events[BACKCHANNEL_LOGOUT_EVENT];
+	if (typeof event !== "object" || event === null || Array.isArray(event)) return null;
+	if ("nonce" in payload) return null;
+	if (typeof payload.jti !== "string" || payload.jti === "") return null;
+	if (typeof payload.exp !== "number") return null;
+	return {
+		issuer,
+		subject: sub === "" ? null : sub,
+		sid: sid === "" ? null : sid,
+		tokenId: payload.jti,
+		expiresAt: payload.exp
+	};
+}
 /**
 * Lit les claims d'un ID token SANS vérifier sa signature.
 *
@@ -27,14 +71,17 @@ async function decodeIdTokenClaims(idToken) {
 * écarts : un jeton d'un autre émetteur (point 2), délivré à une autre
 * application (point 3), ou périmé (point 9), n'a rien à faire ici.
 *
+* @returns le `sub` du jeton, éprouvé non vide.
 * @throws Error - un claim obligatoire est absent, discordant ou périmé.
 */
 function assertIdTokenClaims(claims, opts) {
-	if (typeof claims.sub !== "string" || claims.sub.length === 0) throw new Error(`${opts.name}: ID token sans claim 'sub'.`);
+	const sub = claims.sub;
+	if (typeof sub !== "string" || sub.length === 0) throw new Error(`${opts.name}: ID token sans claim 'sub'.`);
 	if (claims.iss !== opts.issuer) throw new Error(`${opts.name}: ID token émis par « ${String(claims.iss)} », attendu « ${opts.issuer} ».`);
 	const aud = claims.aud;
 	if (!(aud === opts.clientId || Array.isArray(aud) && aud.includes(opts.clientId))) throw new Error(`${opts.name}: ID token délivré à une autre application.`);
 	if (typeof claims.exp !== "number" || claims.exp * 1e3 <= Date.now()) throw new Error(`${opts.name}: ID token périmé ou sans 'exp'.`);
+	return sub;
 }
 /**
 * Fabrique un {@link IOAuthProvider} **générique OIDC** — couvre TOUT fournisseur
@@ -49,7 +96,7 @@ function createOidcProvider(opts) {
 		if (codeVerifier === null) throw new Error(`${opts.name}: code_verifier requis (PKCE OIDC).`);
 		return codeVerifier;
 	};
-	return {
+	const provider = {
 		usesPkce: true,
 		issuerPolicy: {
 			issuer: opts.issuer,
@@ -70,8 +117,8 @@ function createOidcProvider(opts) {
 		},
 		async fetchProfile(tokens) {
 			const claims = await opts.decodeIdToken(tokens.idToken());
-			assertIdTokenClaims(claims, opts);
-			const sub = claims.sub;
+			if (!isPlainObject(claims)) throw new Error(`${opts.name}: ID token sans charge utile objet.`);
+			const sub = assertIdTokenClaims(claims, opts);
 			return {
 				provider: opts.name,
 				providerId: sub,
@@ -82,6 +129,21 @@ function createOidcProvider(opts) {
 			};
 		}
 	};
+	const endSession = opts.endSessionEndpoint ?? null;
+	if (endSession !== null) provider.createLogoutURL = (request) => {
+		const url = new URL(endSession);
+		url.searchParams.set("id_token_hint", request.idTokenHint);
+		url.searchParams.set("post_logout_redirect_uri", request.postLogoutRedirectUri);
+		url.searchParams.set("client_id", opts.clientId);
+		return url;
+	};
+	const verifySignature = opts.verifyLogoutTokenSignature;
+	if (verifySignature !== void 0) provider.verifyLogoutToken = async (logoutToken) => {
+		const verified = await verifySignature(logoutToken);
+		if (verified === null) return null;
+		return readLogoutTokenClaims(verified.issuer, verified.payload);
+	};
+	return provider;
 }
 /**
 * Construit un fournisseur OIDC **en demandant ses points d'entrée à l'émetteur**
@@ -98,12 +160,33 @@ function createOidcProvider(opts) {
 async function createDiscoveredOidcProvider(name, ctx, options = {}) {
 	const effectiveIssuer = options.issuer ?? ctx.issuer;
 	if (!effectiveIssuer) throw new Error(`OAuth provider "${name}" : config "issuer" requise (URL de l'émetteur OIDC).`);
-	const metadata = await discoverAuthorizationServer(effectiveIssuer, options);
+	const metadata = await discoverAuthorizationServer(effectiveIssuer, {
+		...options,
+		discoveryUrl: options.discoveryUrl ?? ctx.discoveryUrl
+	});
 	if (metadata.codeChallengeMethodsSupported !== null && !metadata.codeChallengeMethodsSupported.includes("S256")) throw new Error(`OAuth provider "${name}" : l'émetteur « ${effectiveIssuer} » n'annonce pas PKCE S256 (RFC 7636).`);
+	const announced = (metadata.idTokenSigningAlgValuesSupported ?? []).filter((alg) => !alg.startsWith("HS") && alg.toLowerCase() !== "none");
+	const logoutTokenVerifier = new RemoteJwtVerifier({
+		issuers: [{
+			issuer: metadata.issuer,
+			jwksUri: metadata.jwksUri,
+			algorithms: announced.length > 0 ? announced : DEFAULT_LOGOUT_TOKEN_ALGORITHMS,
+			requiredClaims: [
+				"iat",
+				"exp",
+				"jti",
+				"events"
+			]
+		}],
+		...options.fetch !== void 0 ? { fetch: options.fetch } : {},
+		...options.timeoutMs !== void 0 ? { timeoutMs: options.timeoutMs } : {}
+	});
 	return createOidcProvider({
 		name,
 		issuer: metadata.issuer,
 		issParameterSupported: metadata.issParameterSupported,
+		endSessionEndpoint: metadata.endSessionEndpoint,
+		verifyLogoutTokenSignature: (logoutToken) => logoutTokenVerifier.verifyClaims(logoutToken, ctx.clientId),
 		clientId: ctx.clientId,
 		decodeIdToken: decodeIdTokenClaims,
 		client: new OAuth2Client({
@@ -118,5 +201,4 @@ async function createDiscoveredOidcProvider(name, ctx, options = {}) {
 		})
 	});
 }
-//#endregion
-export { createDiscoveredOidcProvider, createOidcProvider };
+export { createDiscoveredOidcProvider, createOidcProvider, readLogoutTokenClaims };

package/dist/nodefony/src/openToSignup.js

@@ -0,0 +1,46 @@
+// nodefony/src/openToSignup.ts
+/**
+* Les zones protégées qui n'exigent aucun rôle alors que la connexion OAuth
+* crée les comptes à la volée — c'est-à-dire ouvertes à tout compte que le
+* fournisseur délivre.
+*
+* Une zone sans `roles` laisse passer toute identité authentifiée : c'est un
+* défaut voulu. Il devient un piège quand `oauth2.allowSignup` vaut `true`
+* (le défaut) : avec Google ou GitHub, « authentifié » veut dire « n'importe
+* qui sur Internet ». Une zone est donc retenue quand TOUT ceci est vrai :
+* protégée, sans `anonymous`, sans `roles`, avec `session` (c'est par la
+* session qu'un compte OAuth entre), et `oauth2` actif avec au moins un
+* fournisseur et `allowSignup`.
+*
+* Le remède est une DÉCLARATION : `roles: ["ROLE_USER"]` ne change rien au
+* comportement (un compte créé reçoit ce rôle) mais écrit l'intention.
+*
+* Calculée au démarrage et dans `describe()`, jamais par requête. C'est la
+* SEULE implémentation de la règle : `doctor` lit son résultat par le plan
+* d'administration, il ne la recalcule pas.
+*
+* @param config - la configuration de sécurité validée.
+* @returns les zones concernées, dans l'ordre de déclaration ; vide sinon.
+*/
+function findZonesOpenToSignup(config) {
+	const { oauth2 } = config;
+	if (!oauth2.enabled || !oauth2.allowSignup) return [];
+	const providers = Object.keys(oauth2.providers).sort();
+	if (providers.length === 0) return [];
+	const found = [];
+	for (const [zone, area] of Object.entries(config.areas)) {
+		if (!area.security) continue;
+		if (area.roles.length > 0) continue;
+		if (area.authenticators.includes("anonymous")) continue;
+		if (!area.authenticators.includes("session")) continue;
+		const who = providers.join(", ");
+		found.push({
+			zone,
+			providers,
+			message: `la zone « ${zone} » est ouverte à tout compte que ${who} ${providers.length > 1 ? "délivrent" : "délivre"} : elle n'exige aucun rôle, et la connexion OAuth crée les comptes à la volée (\`oauth2.allowSignup\`)`,
+			action: `pour l'assumer, déclarer \`roles: ["ROLE_USER"]\` sur \`areas.${zone}\` ; pour la fermer, poser \`oauth2.allowSignup: false\` (un compte local préexistant devient alors requis)`
+		});
+	}
+	return found;
+}
+export { findZonesOpenToSignup };