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

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

@@ -0,0 +1,88 @@
+import { readJsonObjectBounded } from "./httpJson.js";
+import { canonicalIssuer, issuerMetadataUrls, validateIssuerMetadata } from "nodefony";
+//#region nodefony/src/oauth/metadata.ts
+/**
+* **Découverte des métadonnées d'un serveur d'autorisation** (RFC 8414) — la face
+* CLIENTE de la règle que le cœur porte déjà.
+*
+* C'est ce qui remplace, à soi seul, une classe par fournisseur : les points
+* d'entrée ne sont plus écrits en dur, ils sont demandés à l'émetteur. Ajouter un
+* fournisseur OIDC (Microsoft Entra, Auth0, Okta, Authentik...) ne demande donc
+* PLUS de code : son seul émetteur suffit.
+*
+* @remarks **Ce module ne réimplémente RIEN de la RFC 8414.** La normalisation de
+* l'émetteur (`canonicalIssuer`), l'ordre normatif des URL bien connues
+* (`issuerMetadataUrls`) et l'égalité stricte du §3.3 (`validateIssuerMetadata`)
+* vivent dans `nodefony` — la même implémentation sert à PUBLIER nos métadonnées
+* et à LIRE celles d'autrui, sans quoi les deux faces divergeraient en silence.
+* Il n'ajoute que le transport : requête bornée, et lecture des deux points
+* d'entrée dont le flux *Authorization Code* a besoin.
+*/
+/** Un émetteur muet ne doit pas retenir la requête de login. */
+const DISCOVERY_TIMEOUT_MS = 1e4;
+/** Au-delà, le document n'est plus un document de métadonnées — on refuse de lire. */
+const MAX_METADATA_BYTES = 1048576;
+async function fetchMetadataDocument(url, options) {
+	const response = await (options.fetch ?? globalThis.fetch)(url, {
+		headers: {
+			Accept: "application/json",
+			"User-Agent": "nodefony"
+		},
+		redirect: "error",
+		signal: AbortSignal.timeout(options.timeoutMs ?? DISCOVERY_TIMEOUT_MS)
+	});
+	if (!response.ok) throw new Error(`${url} → HTTP ${response.status}`);
+	return readJsonObjectBounded(response, MAX_METADATA_BYTES, url);
+}
+function requireEndpoint(document, field, issuer) {
+	const value = document[field];
+	if (typeof value !== "string" || value.length === 0) throw new Error(`métadonnées de « ${issuer} » : champ « ${field} » absent (RFC 8414 §2).`);
+	let url;
+	try {
+		url = new URL(value);
+	} catch {
+		throw new Error(`métadonnées de « ${issuer} » : « ${field} » n'est pas une URL.`);
+	}
+	if (url.protocol !== "https:") throw new Error(`métadonnées de « ${issuer} » : « ${field} » doit être en https.`);
+	return value;
+}
+/**
+* Interroge un serveur d'autorisation et rend ses points d'entrée.
+*
+* Les URL candidates sont celles du cœur (`issuerMetadataUrls`, ordre normatif
+* RFC 8414 §3.1 : insertion oauth → insertion oidc → ajout oidc), et la réponse
+* est CONFRONTÉE à l'émetteur demandé par `validateIssuerMetadata` (§3.3). C'est
+* cette garde qui empêche un émetteur détourné d'imposer ses propres points
+* d'entrée — la même attaque que le paramètre `iss` couvre au retour (RFC 9207).
+*
+* @param rawIssuer - identifiant d'émetteur tel qu'écrit en configuration.
+* @param options - transport injectable et délai d'attente.
+* @returns Les points d'entrée, prêts pour `OAuth2Client`.
+* @throws Error - émetteur mal formé, document introuvable, incomplet, ou `issuer` discordant.
+*/
+async function discoverAuthorizationServer(rawIssuer, options = {}) {
+	const issuer = canonicalIssuer(rawIssuer);
+	const failures = [];
+	for (const candidate of issuerMetadataUrls(issuer)) {
+		let document;
+		try {
+			document = await fetchMetadataDocument(candidate, options);
+		} catch (error) {
+			failures.push(error instanceof Error ? error.message : String(error));
+			continue;
+		}
+		const identity = validateIssuerMetadata(document, issuer);
+		const methods = document.code_challenge_methods_supported;
+		return {
+			issuer: identity.issuer,
+			jwksUri: identity.jwksUri,
+			authorizationEndpoint: requireEndpoint(document, "authorization_endpoint", issuer),
+			tokenEndpoint: requireEndpoint(document, "token_endpoint", issuer),
+			codeChallengeMethodsSupported: Array.isArray(methods) ? methods.filter((m) => typeof m === "string") : null,
+			issParameterSupported: document.authorization_response_iss_parameter_supported === true
+		};
+	}
+	throw new Error(`métadonnées introuvables pour « ${issuer} » — ${failures.join(" ; ")}`);
+}
+//#endregion
+export { discoverAuthorizationServer };

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

@@ -0,0 +1,266 @@
+import { readJsonObjectBounded } from "./httpJson.js";
+import { createHash, randomBytes } from "node:crypto";
+//#region nodefony/src/oauth/oauth2Client.ts
+/**
+* Client **OAuth 2.0 / Authorization Code** minimal — la face cliente du protocole
+* dont Nodefony écrit déjà la face serveur (émetteur de jetons, métadonnées,
+* ressource protégée). Aucune dépendance : `node:crypto` pour l'entropie, `fetch`
+* pour l'échange.
+*
+* Posture OAuth 2.1 (RFC 9700) : Authorization Code seul, **PKCE S256** (RFC 7636)
+* quand le fournisseur le supporte, `state` anti-CSRF, jamais d'implicit ni de ROPC.
+*
+* @remarks Le flux vit sur un chemin FROID (un login humain) : les quelques
+* allocations et l'unique requête sortante n'entrent dans aucun chemin de requête.
+*/
+/**
+* Entropie tirée pour `state` et `code_verifier` : 32 octets, soit 43 caractères
+* en base64url — exactement la borne basse du `code_verifier` (RFC 7636 §4.1),
+* dont l'alphabet est inclus dans les caractères `unreserved` exigés.
+*/
+const ENTROPY_BYTES = 32;
+/** Au-delà, la réponse d'un point de jeton n'est plus plausible — on refuse d'analyser. */
+const MAX_TOKEN_RESPONSE_BYTES = 1048576;
+/** Un serveur d'autorisation muet ne doit pas retenir la requête de login. */
+const TOKEN_REQUEST_TIMEOUT_MS = 1e4;
+/**
+* Tire un `state` anti-CSRF (RFC 6749 §10.12, RFC 9700 §4.7) — 256 bits issus du
+* générateur cryptographique du système.
+*/
+function generateState() {
+	return randomBytes(ENTROPY_BYTES).toString("base64url");
+}
+/**
+* Tire un `code_verifier` PKCE (RFC 7636 §4.1) — 43 caractères de l'alphabet
+* `unreserved`, porteurs de 256 bits d'entropie.
+*/
+function generateCodeVerifier() {
+	return randomBytes(ENTROPY_BYTES).toString("base64url");
+}
+/**
+* Calcule le `code_challenge` de la méthode **S256** (RFC 7636 §4.2) :
+* `BASE64URL(SHA256(ASCII(code_verifier)))`.
+*
+* @remarks La méthode `plain` n'est jamais proposée — OAuth 2.1 et la RFC 9700
+* §2.1.1 l'excluent : elle ne protège pas d'un code intercepté.
+*/
+function createCodeChallenge(codeVerifier) {
+	assertCodeVerifier(codeVerifier);
+	return createHash("sha256").update(codeVerifier, "ascii").digest("base64url");
+}
+/** Grammaire d'un `code_verifier` : 43 à 128 caractères `unreserved` (RFC 7636 §4.1). */
+const CODE_VERIFIER = /^[A-Za-z0-9\-._~]{43,128}$/;
+/**
+* Refuse un `code_verifier` hors grammaire AVANT de s'en servir.
+*
+* @remarks Sans cette garde, un appelant qui fournit son propre secret (le
+* contrat l'autorise) obtiendrait un défi calculé sur une valeur que le serveur
+* d'autorisation rejettera plus tard : l'erreur sortirait au retour, sous la
+* forme d'un `invalid_grant` que rien ne relie à sa cause.
+*
+* @throws Error - la valeur ne respecte pas la grammaire de la RFC 7636 §4.1.
+*/
+function assertCodeVerifier(codeVerifier) {
+	if (!CODE_VERIFIER.test(codeVerifier)) throw new Error("code_verifier invalide : 43 à 128 caractères parmi [A-Za-z0-9-._~] (RFC 7636 §4.1).");
+}
+/**
+* Encode une valeur selon `application/x-www-form-urlencoded`, la forme qu'exige
+* l'authentification cliente HTTP Basic (RFC 6749 §2.3.1).
+*/
+function formUrlencode(value) {
+	return new URLSearchParams([["", value]]).toString().slice(1);
+}
+/**
+* Refus du serveur d'autorisation au point de jeton (RFC 6749 §5.2). Porte le
+* code `error` normalisé — la seule partie de la réponse sûre à journaliser.
+*/
+var OAuth2RequestError = class extends Error {
+	/** Code normalisé (`invalid_grant`, `invalid_client`, ...) — RFC 6749 §5.2. */
+	code;
+	/** Description lisible fournie par le serveur, ou `null`. */
+	description;
+	constructor(code, description) {
+		super(description === null ? code : `${code}: ${description}`);
+		this.name = "OAuth2RequestError";
+		this.code = code;
+		this.description = description;
+	}
+};
+/**
+* Jetons rendus par le point de jeton (RFC 6749 §5.1), enveloppés pour qu'un champ
+* attendu mais absent lève une erreur NOMMÉE au lieu de propager un `undefined`
+* jusqu'au décodage du profil.
+*/
+var OAuth2Tokens = class {
+	/** Corps JSON brut de la réponse — donne accès aux extensions du fournisseur. */
+	data;
+	constructor(data) {
+		this.data = data;
+	}
+	#requireString(field) {
+		const value = this.data[field];
+		if (typeof value !== "string" || value.length === 0) throw new Error(`Réponse du point de jeton sans champ « ${field} ».`);
+		return value;
+	}
+	/** Jeton d'accès (RFC 6749 §5.1). */
+	accessToken() {
+		return this.#requireString("access_token");
+	}
+	/** Type du jeton d'accès — `Bearer` en pratique (RFC 6750). */
+	tokenType() {
+		return this.#requireString("token_type");
+	}
+	/** Jeton d'identité OIDC (OpenID Connect Core §3.1.3.3). */
+	idToken() {
+		return this.#requireString("id_token");
+	}
+	/** `true` si le serveur a émis un jeton de rafraîchissement. */
+	hasRefreshToken() {
+		return typeof this.data.refresh_token === "string";
+	}
+	/** Jeton de rafraîchissement (RFC 6749 §1.5). */
+	refreshToken() {
+		return this.#requireString("refresh_token");
+	}
+	/** Durée de vie restante du jeton d'accès, en secondes. */
+	accessTokenExpiresInSeconds() {
+		const value = this.data.expires_in;
+		if (typeof value !== "number" || !Number.isFinite(value)) throw new Error("Réponse du point de jeton sans champ « expires_in ».");
+		return value;
+	}
+	/** Instant d'expiration du jeton d'accès, dérivé de `expires_in`. */
+	accessTokenExpiresAt() {
+		return new Date(Date.now() + this.accessTokenExpiresInSeconds() * 1e3);
+	}
+	/** `true` si le serveur a annoncé les portées effectivement accordées. */
+	hasScopes() {
+		return typeof this.data.scope === "string";
+	}
+	/** Portées accordées, telles que le serveur les a annoncées (RFC 6749 §3.3). */
+	scopes() {
+		return this.#requireString("scope").split(" ");
+	}
+};
+/**
+* Les paramètres que le protocole POSE lui-même, et qu'un appelant ne peut donc
+* pas fournir en supplément.
+*
+* Sans cette garde, `additionalParameters` deviendrait une porte pour réécrire
+* `client_id` ou `redirect_uri` — c'est-à-dire pour faire émettre par ce client
+* une requête qui ne le désigne plus. Le refus est explicite et nomme la clé :
+* un paramètre silencieusement ignoré serait pire, l'appelant croirait l'avoir
+* envoyé.
+*/
+const RESERVED_PARAMETERS = /* @__PURE__ */ new Set([
+	"response_type",
+	"client_id",
+	"client_secret",
+	"redirect_uri",
+	"state",
+	"scope",
+	"code",
+	"code_verifier",
+	"code_challenge",
+	"code_challenge_method",
+	"grant_type"
+]);
+/**
+* Verse des paramètres supplémentaires sans jamais recouvrir ceux du protocole.
+*
+* @param target - la collection en construction (requête ou corps).
+* @param extra - ce que l'appelant ajoute, tel quel.
+* @throws Error - une clé réservée au protocole a été fournie.
+*/
+function applyAdditionalParameters(target, extra) {
+	if (extra === void 0) return;
+	for (const [key, value] of Object.entries(extra)) {
+		if (RESERVED_PARAMETERS.has(key)) throw new Error(`Paramètre « ${key} » réservé au protocole : il est posé par le client, pas par l'appelant.`);
+		target.set(key, value);
+	}
+}
+/**
+* Client d'un serveur d'autorisation donné : construit l'URL d'autorisation puis
+* échange le code contre des jetons.
+*
+* Un exemplaire porte les endpoints DÉJÀ résolus — par découverte de métadonnées
+* ({@link discoverAuthorizationServer}) ou en dur pour un fournisseur qui n'en
+* publie pas (GitHub).
+*/
+var OAuth2Client = class {
+	#options;
+	constructor(options) {
+		this.#options = options;
+	}
+	/**
+	* Construit l'URL d'autorisation (RFC 6749 §4.1.1). Le `code_challenge` S256 est
+	* ajouté dès qu'un `codeVerifier` est fourni.
+	*
+	* @param request - ce qu'on demande au point d'autorisation.
+	* @returns l'URL vers laquelle rediriger l'utilisateur.
+	* @throws Error - un paramètre supplémentaire empiète sur le protocole.
+	*/
+	createAuthorizationURL(request) {
+		const url = new URL(this.#options.authorizationEndpoint);
+		applyAdditionalParameters(url.searchParams, request.additionalParameters);
+		url.searchParams.set("response_type", "code");
+		url.searchParams.set("client_id", this.#options.clientId);
+		url.searchParams.set("redirect_uri", this.#options.redirectUri);
+		url.searchParams.set("state", request.state);
+		if (request.scopes.length > 0) url.searchParams.set("scope", request.scopes.join(" "));
+		if (request.codeVerifier !== null) {
+			url.searchParams.set("code_challenge_method", "S256");
+			url.searchParams.set("code_challenge", createCodeChallenge(request.codeVerifier));
+		}
+		return url;
+	}
+	/**
+	* Échange le code d'autorisation contre des jetons (RFC 6749 §4.1.3), de serveur
+	* à serveur — le secret client ne quitte jamais ce canal.
+	*
+	* @param request - ce qu'on présente au point de jeton.
+	* @throws OAuth2RequestError - le serveur a refusé, en nommant la cause (RFC 6749 §5.2).
+	* @throws Error - réponse inintelligible, hors gabarit, serveur injoignable, ou
+	*   paramètre supplémentaire empiétant sur le protocole.
+	*/
+	async validateAuthorizationCode(request) {
+		const body = new URLSearchParams();
+		applyAdditionalParameters(body, request.additionalParameters);
+		body.set("grant_type", "authorization_code");
+		body.set("code", request.code);
+		body.set("redirect_uri", this.#options.redirectUri);
+		if (request.codeVerifier !== null) body.set("code_verifier", request.codeVerifier);
+		const headers = {
+			"Content-Type": "application/x-www-form-urlencoded",
+			Accept: "application/json",
+			"User-Agent": "nodefony"
+		};
+		switch (this.#options.clientAuthMethod) {
+			case "client_secret_basic":
+				headers.Authorization = `Basic ${this.#basicCredentials()}`;
+				break;
+			case "client_secret_post":
+				body.set("client_id", this.#options.clientId);
+				body.set("client_secret", this.#options.clientSecret);
+				break;
+			case "none": body.set("client_id", this.#options.clientId);
+		}
+		const response = await (this.#options.fetch ?? globalThis.fetch)(this.#options.tokenEndpoint, {
+			method: "POST",
+			headers,
+			body: body.toString(),
+			redirect: "error",
+			signal: AbortSignal.timeout(this.#options.timeoutMs ?? TOKEN_REQUEST_TIMEOUT_MS)
+		});
+		const data = await readJsonObjectBounded(response, MAX_TOKEN_RESPONSE_BYTES, `point de jeton (HTTP ${response.status})`);
+		if (typeof data.error === "string") throw new OAuth2RequestError(data.error, typeof data.error_description === "string" ? data.error_description : null);
+		if (!response.ok) throw new Error(`Point de jeton en échec (HTTP ${response.status}).`);
+		return new OAuth2Tokens(data);
+	}
+	#basicCredentials() {
+		const id = formUrlencode(this.#options.clientId);
+		const secret = formUrlencode(this.#options.clientSecret);
+		return Buffer.from(`${id}:${secret}`, "utf8").toString("base64");
+	}
+};
+//#endregion
+export { OAuth2Client, OAuth2RequestError, OAuth2Tokens, createCodeChallenge, generateCodeVerifier, generateState };

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

@@ -1,4 +1,4 @@
-import { createOidcProvider } from "./providers/oidc.js";
+import { createDiscoveredOidcProvider } from "./providers/oidc.js";
 import { createGithubProvider } from "./providers/github.js";
 //#region nodefony/src/oauth/oauthProviderRegistry.ts
 const factories = /* @__PURE__ */ new Map();
@@ -17,21 +17,10 @@ function getOAuthProviderFactory(name) {
 function listOAuthProviders() {
 	return [...factories.keys()];
 }
-registerOAuthProvider("google", (ctx) => createOidcProvider({
-	name: "google",
-	client: new ctx.arctic.Google(ctx.clientId, ctx.clientSecret, ctx.redirectUri),
-	issuer: "https://accounts.google.com",
-	decodeIdToken: ctx.arctic.decodeIdToken
-}));
-registerOAuthProvider("keycloak", (ctx) => {
-	if (!ctx.issuer) throw new Error("OAuth provider \"keycloak\" : config \"issuer\" requise (URL du realm, ex. https://kc.example/realms/app).");
-	return createOidcProvider({
-		name: "keycloak",
-		client: new ctx.arctic.KeyCloak(ctx.issuer, ctx.clientId, ctx.clientSecret, ctx.redirectUri),
-		issuer: ctx.issuer,
-		decodeIdToken: ctx.arctic.decodeIdToken
-	});
-});
+const GOOGLE_ISSUER = "https://accounts.google.com";
+registerOAuthProvider("google", (ctx) => createDiscoveredOidcProvider("google", ctx, { issuer: GOOGLE_ISSUER }));
+registerOAuthProvider("keycloak", (ctx) => createDiscoveredOidcProvider("keycloak", ctx));
+registerOAuthProvider("oidc", (ctx) => createDiscoveredOidcProvider("oidc", ctx));
 registerOAuthProvider("github", createGithubProvider);
 //#endregion
 export { getOAuthProviderFactory, listOAuthProviders, registerOAuthProvider };

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

@@ -1,7 +1,15 @@
+import { readJsonBounded } from "../httpJson.js";
+import { OAuth2Client } from "../oauth2Client.js";
 //#region 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";
+/** Une API muette ne doit pas retenir le callback jusqu'aux délais du runtime. */
+const API_TIMEOUT_MS = 1e4;
+/** Au-delà, ce n'est plus un profil : on refuse de lire. */
+const MAX_PROFILE_BYTES = 1048576;
+const AUTHORIZATION_ENDPOINT = "https://github.com/login/oauth/authorize";
+const TOKEN_ENDPOINT = "https://github.com/login/oauth/access_token";
 function ghHeaders(accessToken) {
 	return {
 		Authorization: `Bearer ${accessToken}`,
@@ -11,27 +19,44 @@ function ghHeaders(accessToken) {
 	};
 }
 async function ghGet(url, accessToken) {
-	const res = await fetch(url, { headers: ghHeaders(accessToken) });
+	const res = await fetch(url, {
+		headers: ghHeaders(accessToken),
+		redirect: "error",
+		signal: AbortSignal.timeout(API_TIMEOUT_MS)
+	});
 	if (!res.ok) throw new Error(`GitHub API ${url} → ${res.status}`);
-	return res.json();
+	return readJsonBounded(res, MAX_PROFILE_BYTES, `GitHub API ${url}`);
 }
 /**
 * Fournisseur **GitHub** (OAuth 2.0 simple, NON-OIDC). Pas de PKCE, pas d'ID
 * token : le profil est lu via l'API REST (`/user`), et l'email — souvent privé —
 * via `/user/emails` (scope `user:email`). GitHub n'émet pas de paramètre `iss`
-* (`expectedIssuer = null`) : la défense anti-CSRF repose sur le `state`.
+* (`issuerPolicy = null`) : la défense anti-CSRF repose sur le `state`.
 */
 function createGithubProvider(ctx) {
-	const client = new ctx.arctic.GitHub(ctx.clientId, ctx.clientSecret, ctx.redirectUri);
+	const client = new OAuth2Client({
+		authorizationEndpoint: AUTHORIZATION_ENDPOINT,
+		tokenEndpoint: TOKEN_ENDPOINT,
+		clientId: ctx.clientId,
+		clientSecret: ctx.clientSecret,
+		clientAuthMethod: ctx.clientAuthMethod ?? "client_secret_basic",
+		redirectUri: ctx.redirectUri
+	});
 	return {
 		usesPkce: false,
-		expectedIssuer: null,
+		issuerPolicy: null,
 		defaultScopes: DEFAULT_SCOPES,
-		createAuthorizationURL(state, _codeVerifier, scopes) {
-			return client.createAuthorizationURL(state, scopes);
+		createAuthorizationURL(request) {
+			return client.createAuthorizationURL({
+				...request,
+				codeVerifier: null
+			});
 		},
-		validateAuthorizationCode(code, _codeVerifier) {
-			return client.validateAuthorizationCode(code);
+		validateAuthorizationCode(request) {
+			return client.validateAuthorizationCode({
+				...request,
+				codeVerifier: null
+			});
 		},
 		async fetchProfile(tokens) {
 			const accessToken = tokens.accessToken();

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

@@ -1,3 +1,5 @@
+import { OAuth2Client } from "../oauth2Client.js";
+import { discoverAuthorizationServer } from "../metadata.js";
 //#region nodefony/src/oauth/providers/oidc.ts
 const DEFAULT_OIDC_SCOPES = [
 	"openid",
@@ -5,14 +7,42 @@ const DEFAULT_OIDC_SCOPES = [
 	"email"
 ];
 /**
+* Lit les claims d'un ID token SANS vérifier sa signature.
+*
+* @remarks C'est ce qu'autorise OpenID Connect Core §3.1.3.7 dans le flux
+* *Authorization Code* : le jeton vient d'être reçu du point de jeton, sur un
+* canal TLS direct et authentifié — il n'a traversé ni le navigateur ni un tiers.
+* `jose` est chargé paresseusement, comme partout ailleurs dans ce module : il
+* n'entre jamais dans le coût du boot.
+*/
+async function decodeIdTokenClaims(idToken) {
+	return (await import("jose")).decodeJwt(idToken);
+}
+/**
+* Éprouve les claims OBLIGATOIRES d'un ID token (OpenID Connect Core §3.1.3.7).
+*
+* @remarks La SIGNATURE n'est pas vérifiée — le jeton vient d'être reçu du point
+* de jeton sur un canal TLS direct, ce que la norme admet explicitement. Mais les
+* autres exigences du même paragraphe ne coûtent aucun réseau et ferment de vrais
+* é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.
+*
+* @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'.`);
+	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'.`);
+}
+/**
 * Fabrique un {@link IOAuthProvider} **générique OIDC** — couvre TOUT fournisseur
 * OpenID Connect sans code spécifique : le profil se lit toujours pareil (claims
-* standard `sub`/`email`/`email_verified`/`name` de l'ID token). Ajouter un
-* fournisseur OIDC = une entrée de quelques lignes (nom + classe arctic + issuer),
-* pas un fichier.
+* standard `sub`/`email`/`email_verified`/`name` de l'ID token).
 *
-* PKCE S256 systématique (RFC 7636) ; le profil vient de l'ID token signé obtenu
-* du token endpoint via TLS (décodage suffisant en code flow, RFC 8725).
+* PKCE S256 systématique (RFC 7636) ; le profil vient de l'ID token obtenu du
+* point de jeton via TLS.
 */
 function createOidcProvider(opts) {
 	const requireVerifier = (codeVerifier) => {
@@ -21,18 +51,27 @@ function createOidcProvider(opts) {
 	};
 	return {
 		usesPkce: true,
-		expectedIssuer: opts.issuer,
+		issuerPolicy: {
+			issuer: opts.issuer,
+			requireIssParameter: opts.issParameterSupported === true
+		},
 		defaultScopes: opts.defaultScopes ?? DEFAULT_OIDC_SCOPES,
-		createAuthorizationURL(state, codeVerifier, scopes) {
-			return opts.client.createAuthorizationURL(state, requireVerifier(codeVerifier), scopes);
+		createAuthorizationURL(request) {
+			return opts.client.createAuthorizationURL({
+				...request,
+				codeVerifier: requireVerifier(request.codeVerifier)
+			});
 		},
-		validateAuthorizationCode(code, codeVerifier) {
-			return opts.client.validateAuthorizationCode(code, requireVerifier(codeVerifier));
+		validateAuthorizationCode(request) {
+			return opts.client.validateAuthorizationCode({
+				...request,
+				codeVerifier: requireVerifier(request.codeVerifier)
+			});
 		},
 		async fetchProfile(tokens) {
-			const claims = opts.decodeIdToken(tokens.idToken());
+			const claims = await opts.decodeIdToken(tokens.idToken());
+			assertIdTokenClaims(claims, opts);
 			const sub = claims.sub;
-			if (typeof sub !== "string" || sub.length === 0) throw new Error(`${opts.name}: ID token sans claim 'sub'.`);
 			return {
 				provider: opts.name,
 				providerId: sub,
@@ -44,5 +83,40 @@ function createOidcProvider(opts) {
 		}
 	};
 }
+/**
+* Construit un fournisseur OIDC **en demandant ses points d'entrée à l'émetteur**
+* (RFC 8414 / OpenID Connect Discovery) — aucune URL n'est écrite en dur.
+*
+* C'est ce qui permet d'enregistrer n'importe quel fournisseur OpenID Connect sans
+* écrire une ligne de code : seul son émetteur le distingue.
+*
+* @param name - nom sous lequel le fournisseur est configuré.
+* @param options - émetteur explicite, transport injectable, délai d'attente.
+* @throws Error - émetteur absent, découverte impossible, ou serveur annonçant ne
+*   pas supporter PKCE S256 alors que ce fournisseur l'exige.
+*/
+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);
+	if (metadata.codeChallengeMethodsSupported !== null && !metadata.codeChallengeMethodsSupported.includes("S256")) throw new Error(`OAuth provider "${name}" : l'émetteur « ${effectiveIssuer} » n'annonce pas PKCE S256 (RFC 7636).`);
+	return createOidcProvider({
+		name,
+		issuer: metadata.issuer,
+		issParameterSupported: metadata.issParameterSupported,
+		clientId: ctx.clientId,
+		decodeIdToken: decodeIdTokenClaims,
+		client: new OAuth2Client({
+			authorizationEndpoint: metadata.authorizationEndpoint,
+			tokenEndpoint: metadata.tokenEndpoint,
+			clientId: ctx.clientId,
+			clientSecret: ctx.clientSecret,
+			clientAuthMethod: ctx.clientAuthMethod ?? "client_secret_basic",
+			redirectUri: ctx.redirectUri,
+			fetch: options.fetch,
+			timeoutMs: options.timeoutMs
+		})
+	});
+}
 //#endregion
-export { createOidcProvider };
+export { createDiscoveredOidcProvider, createOidcProvider };

package/dist/types/index.d.ts

@@ -114,9 +114,16 @@ export type { IWebAuthnUser, IWebAuthnAssertionResult, } from "./nodefony/servic
 export type { IWebAuthnCredential } from "./nodefony/contracts/IWebAuthnCredential.js";
 export type { IWebAuthnCredentialStore, IWebAuthnCredentialSummary, IWebAuthnListQuery, WebAuthnAuthUpdate, } from "./nodefony/contracts/IWebAuthnCredentialStore.js";
 export type { IOAuthAuthorization } from "./nodefony/service/oauth2.js";
-export type { IOAuthProvider } from "./nodefony/contracts/IOAuthProvider.js";
+export type { IOAuthProvider, IIssuerPolicy, } from "./nodefony/contracts/IOAuthProvider.js";
 export { registerOAuthProvider, getOAuthProviderFactory, listOAuthProviders, } from "./nodefony/src/oauth/oauthProviderRegistry.js";
 export type { OAuthProviderFactory, IOAuthProviderContext, } from "./nodefony/src/oauth/oauthProviderRegistry.js";
+export { OAuth2Client, OAuth2Tokens, OAuth2RequestError, generateState, generateCodeVerifier, createCodeChallenge, } from "./nodefony/src/oauth/oauth2Client.js";
+export type { IOAuth2ClientOptions } from "./nodefony/src/oauth/oauth2Client.js";
+export { discoverAuthorizationServer } from "./nodefony/src/oauth/metadata.js";
+export type { IDiscoveredAuthorizationServer, IDiscoveryOptions, } from "./nodefony/src/oauth/metadata.js";
+export { createOidcProvider, createDiscoveredOidcProvider, } from "./nodefony/src/oauth/providers/oidc.js";
+export type { IOidcPkceClient, IOidcProviderOptions, } from "./nodefony/src/oauth/providers/oidc.js";
+export { createGithubProvider } from "./nodefony/src/oauth/providers/github.js";
 export { MemoryAuditStore } from "./nodefony/src/audit/MemoryAuditStore.js";
 export type { AuditStoreSnapshot } from "./nodefony/src/audit/MemoryAuditStore.js";
 export type { IAuditEvent, IAuditEventDraft, IAuditEventFlags, AuditCategory, AuditOutcome, } from "./nodefony/contracts/IAuditEvent.js";

package/dist/types/nodefony/config/config.d.ts

@@ -228,12 +228,18 @@ export declare const securityConfigSchema: z.ZodObject<{
         providers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
             clientId: z.ZodString;
             clientSecret: z.ZodString;
+            clientAuthMethod: z.ZodOptional<z.ZodEnum<{
+                client_secret_basic: "client_secret_basic";
+                client_secret_post: "client_secret_post";
+            }>>;
             redirectUri: z.ZodString;
             issuer: z.ZodOptional<z.ZodString>;
             scopes: z.ZodDefault<z.ZodArray<z.ZodString>>;
             successRedirect: z.ZodOptional<z.ZodString>;
             failureRedirect: z.ZodOptional<z.ZodString>;
             defaultRoles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            label: z.ZodOptional<z.ZodString>;
+            hidden: z.ZodDefault<z.ZodBoolean>;
         }, z.core.$strict>>>;
     }, z.core.$strict>>;
     apiKeys: z.ZodDefault<z.ZodObject<{