@nodefony/security 10.0.0-alpha.1

package/dist/nodefony/service/oauth2.js

@@ -0,0 +1,153 @@
+import { AuthenticationError } from "../errors/AuthenticationError.js";
+import { defineSecurityConfig } from "../config/defineModuleConfig.js";
+import { getOAuthProviderFactory, listOAuthProviders } from "../src/oauth/oauthProviderRegistry.js";
+import { Service } from "nodefony";
+//#region nodefony/service/oauth2.ts
+const serviceName = "oauth2";
+/**
+* **Social login OAuth 2.0** (P6 J9) — orchestrateur du flux *Authorization Code*
+* au-dessus d'`arctic`.
+*
+* Posture OAuth 2.1 (RFC 9700) : Authorization Code uniquement (jamais implicit /
+* ROPC), **PKCE S256** quand le fournisseur le supporte (RFC 7636), **state**
+* anti-CSRF, **iss** anti-mix-up (RFC 9207) ; aucun jeton n'atteint le navigateur
+* (le login produit une **session BFF**, gérée hors de ce service par le
+* controller + `AuthFlow`).
+*
+* `arctic` est **importé paresseusement** au premier login (cold path — jamais au
+* boot ni par requête), comme `@simplewebauthn`/`jose`. Au boot (si
+* `oauth2.enabled`) : seule la config est validée et les fournisseurs configurés
+* sont confrontés au registre (un nom inconnu = WARNING, pas fatal).
+*
+* Le service ne touche **ni HTTP ni session** : il rend à l'appelant les éléments
+* (URL, state, verifier) que le controller persiste en session — testable sans
+* transport, comme `AuthFlow`.
+*/
+var OAuth2Service = class extends Service {
+	module;
+	#config = null;
+	#lib = null;
+	#providers = null;
+	#ready = false;
+	constructor(module) {
+		super(serviceName, module.container, module.notificationsCenter, module.options);
+		this.module = module;
+		this.kernel?.once("onBoot", () => this.#build());
+	}
+	#build() {
+		let config;
+		try {
+			config = defineSecurityConfig(this.options);
+		} catch {
+			return;
+		}
+		if (!config.oauth2.enabled) {
+			this.log("oauth2 idle — social login désactivé en config", "DEBUG");
+			return;
+		}
+		this.#config = config;
+		const known = new Set(listOAuthProviders());
+		const configured = Object.keys(config.oauth2.providers);
+		for (const name of configured) if (!known.has(name)) this.log(`oauth2 provider "${name}" inconnu du registre — ignoré (registerOAuthProvider manquant ?)`, "WARNING");
+		this.#ready = true;
+		const active = configured.filter((n) => known.has(n));
+		this.log(`oauth2 ready — providers: [${active.join(", ") || "aucun"}]`, "DEBUG");
+	}
+	/** `true` si le social login est opérationnel (activé + boot OK). */
+	isEnabled() {
+		return this.#ready;
+	}
+	/** Noms des fournisseurs configurés ET connus du registre (UI : boutons à afficher). */
+	listProviders() {
+		if (!this.#ready || this.#config === null) return [];
+		const known = new Set(listOAuthProviders());
+		return Object.keys(this.#config.oauth2.providers).filter((n) => known.has(n));
+	}
+	/**
+	* Redirections post-login (succès / échec) — lues par le controller.
+	* Surcharge PAR FOURNISSEUR si fournie, sinon valeur globale, sinon défaut.
+	*/
+	getRedirects(provider) {
+		const o = this.#config?.oauth2;
+		const p = provider ? o?.providers[provider] : void 0;
+		return {
+			success: p?.successRedirect ?? o?.successRedirect ?? "/",
+			failure: p?.failureRedirect ?? o?.failureRedirect ?? "/login"
+		};
+	}
+	/**
+	* Étape 1 — prépare l'URL d'autorisation + les éléments anti-replay à stocker
+	* en session (`state`, et `code_verifier` si PKCE).
+	*
+	* @throws AuthenticationError — fournisseur non configuré / inconnu du registre.
+	*/
+	async createAuthorization(provider) {
+		const resolved = await this.#resolveProvider(provider);
+		const lib = await this.#ensureLib();
+		const state = lib.generateState();
+		const codeVerifier = resolved.provider.usesPkce ? lib.generateCodeVerifier() : null;
+		return {
+			url: resolved.provider.createAuthorizationURL(state, codeVerifier, resolved.scopes).toString(),
+			state,
+			codeVerifier
+		};
+	}
+	/**
+	* Étape 2 — valide la réponse, échange le `code`, lit le profil et provisionne
+	* l'utilisateur local (Shadow User). Retourne l'identifiant à ouvrir en session.
+	*
+	* @param returnedIss - paramètre `iss` reçu (anti-mix-up RFC 9207), ou `null`.
+	* @throws AuthenticationError — `iss` invalide, échange refusé, ou provisioning
+	*   impossible (lien inconnu + signup interdit).
+	*/
+	async exchangeAndProvision(provider, code, codeVerifier, returnedIss) {
+		const { provider: p } = await this.#resolveProvider(provider);
+		if (p.expectedIssuer !== null) {
+			if (returnedIss === null || returnedIss !== p.expectedIssuer) throw new AuthenticationError("OAuth issuer mismatch");
+		}
+		const tokens = await p.validateAuthorizationCode(code, codeVerifier);
+		const profile = await p.fetchProfile(tokens);
+		const cfg = this.#config.oauth2;
+		const defaultRoles = cfg.providers[provider]?.defaultRoles ?? cfg.defaultRoles;
+		return { identifier: (await this.#resolveProvisioner().provisionOAuthUser(profile, {
+			defaultRoles: [...defaultRoles],
+			allowSignup: cfg.allowSignup
+		})).identifier };
+	}
+	async #resolveProvider(name) {
+		this.#ensureReady();
+		this.#providers ??= /* @__PURE__ */ new Map();
+		const cached = this.#providers.get(name);
+		if (cached) return cached;
+		const cfg = this.#config.oauth2.providers[name];
+		if (!cfg) throw new AuthenticationError(`OAuth provider "${name}" non configuré`);
+		const factory = getOAuthProviderFactory(name);
+		if (!factory) throw new AuthenticationError(`OAuth provider "${name}" inconnu du registre`);
+		const provider = factory({
+			arctic: await this.#ensureLib(),
+			clientId: cfg.clientId,
+			clientSecret: cfg.clientSecret,
+			redirectUri: cfg.redirectUri,
+			issuer: cfg.issuer
+		});
+		const resolved = {
+			provider,
+			scopes: cfg.scopes.length > 0 ? cfg.scopes : provider.defaultScopes
+		};
+		this.#providers.set(name, resolved);
+		return resolved;
+	}
+	#resolveProvisioner() {
+		const users = this.get("users");
+		if (!users || typeof users.provisionOAuthUser !== "function") throw new AuthenticationError("OAuth provisioning indisponible (le service users n'implémente pas IOAuthUserProvisioner)");
+		return users;
+	}
+	async #ensureLib() {
+		return this.#lib ??= await import("arctic");
+	}
+	#ensureReady() {
+		if (!this.#ready || this.#config === null) throw new Error("OAuth2Service: non initialisé (social login désactivé ou boot échoué)");
+	}
+};
+//#endregion
+export { OAuth2Service, OAuth2Service as default };

package/dist/nodefony/service/securityHeaders.js

@@ -0,0 +1,80 @@
+import { mergeCspFragments } from "../src/csp.js";
+//#region nodefony/service/securityHeaders.ts
+/** Marqueur substitué par le nonce CSP de la requête (cf `Context.cspNonce`). */
+const NONCE_PLACEHOLDER = "{{nonce}}";
+/**
+* En-têtes de sécurité **applicatifs** de Nodefony (couche `@nodefony/security`,
+* complémentaire du socle transport de `@nodefony/http`). Pré-calcule une fois au
+* boot la table d'en-têtes CONSTANTS (CSP statique, Referrer-Policy, isolation
+* cross-origin COOP/COEP/CORP, Origin-Agent-Cluster, Permissions-Policy) → zéro
+* alloc, zéro concat par requête (le firewall la pose telle quelle).
+*
+* **Étape A+B** : en-têtes constants pré-calculés au boot (Referrer/COOP/…). Pour le
+* CSP, deux régimes mutuellement exclusifs : **statique** (posé tel quel via `headers`,
+* 0 alloc/req) OU **nonce par requête** (`cspNonces` + placeholder `{{nonce}}` dans le
+* CSP) → segments pré-split au boot, recomposés par requête via `cspFor(nonce)` (1
+* `join`, aucun parse/regex dans le hot-path). Le nonce lui-même vit sur `Context`.
+*
+* @see Fetch Metadata · W3C CSP Level 3 · WHATWG (COOP/COEP/CORP).
+*/
+var SecurityHeaders = class {
+	#headers;
+	#cspParts;
+	#cspRaw;
+	constructor(o) {
+		const h = {};
+		let cspParts = null;
+		if (o.csp) {
+			if (o.cspNonces && o.csp.includes(NONCE_PLACEHOLDER)) cspParts = o.csp.split(NONCE_PLACEHOLDER);
+			else {
+				const csp = o.cspNonces ? o.csp : o.csp.replace(/\s*'nonce-\{\{nonce\}\}'/g, "");
+				if (csp) h["Content-Security-Policy"] = csp;
+			}
+		}
+		if (o.referrerPolicy) h["Referrer-Policy"] = o.referrerPolicy;
+		if (o.coop) h["Cross-Origin-Opener-Policy"] = o.coop;
+		if (o.coep) h["Cross-Origin-Embedder-Policy"] = o.coep;
+		if (o.corp) h["Cross-Origin-Resource-Policy"] = o.corp;
+		if (o.originAgentCluster) h["Origin-Agent-Cluster"] = "?1";
+		if (o.permissionsPolicy) h["Permissions-Policy"] = o.permissionsPolicy;
+		this.#headers = Object.freeze(h);
+		this.#cspParts = cspParts ? Object.freeze(cspParts) : null;
+		this.#cspRaw = o.csp ?? "";
+	}
+	/** Table d'en-têtes applicatifs CONSTANTS (figée), posée telle quelle par le firewall. */
+	get headers() {
+		return this.#headers;
+	}
+	/** `true` si le CSP est recomposé par requête avec un nonce (→ `cspFor`). */
+	get hasNonce() {
+		return this.#cspParts !== null;
+	}
+	/**
+	* Recompose le CSP en injectant le `nonce` de la requête aux emplacements
+	* `{{nonce}}`. 1 `join` (segments pré-split au boot). Le nonce est base64 (jamais
+	* `'`/`;`/espace) → aucune évasion possible du token CSP.
+	*
+	* @param nonce - nonce base64 de la requête (`Context.cspNonce`).
+	* @returns la valeur `Content-Security-Policy` à poser sur la réponse.
+	*/
+	cspFor(nonce) {
+		return this.#cspParts.join(nonce);
+	}
+	/**
+	* Recompose le CSP en fusionnant ADDITIVEMENT les directives `extra` d'une
+	* route (`@Csp`) dans le CSP de base, PUIS en substituant le `nonce`. Le merge
+	* (parse/serialize) n'est payé QUE sur les routes décorées `@Csp` (rares) — le
+	* cas courant reste {@link cspFor} (1 `join`). Une directive déjà présente voit
+	* ses sources complétées (jamais dupliquée — W3C CSP3 §3).
+	*
+	* @param nonce - nonce base64 de la requête (ignoré si le CSP n'a pas de nonce).
+	* @param extra - directives additionnelles de la route (`directive → sources`).
+	* @returns la valeur `Content-Security-Policy` à poser sur la réponse.
+	*/
+	cspForExtra(nonce, extra) {
+		const merged = mergeCspFragments(this.#cspRaw, [extra]);
+		return this.#cspParts !== null ? merged.split(NONCE_PLACEHOLDER).join(nonce) : merged.replace(/\s*'nonce-\{\{nonce\}\}'/g, "");
+	}
+};
+//#endregion
+export { SecurityHeaders, SecurityHeaders as default };