@nodefony/http 10.0.0-beta.1 → 10.0.0-beta.3

package/dist/nodefony/service/certificates.js

@@ -1,15 +1,125 @@
 import { asServersConfig } from "../src/servers/kernelServers.js";
-import { Service, extend } from "nodefony";
-import { randomBytes } from "node:crypto";
+import { SHA1_WITH_RSA_OID, createSelfSignedCertificate, distinguishedNameField, parseSubjectAltName, signatureAlgorithmName, signatureAlgorithmOid } from "./x509.js";
+import { BootConfigurationError, Service, extend } from "nodefony";
+import { X509Certificate, generateKeyPair, randomBytes } from "node:crypto";
 import fsp from "node:fs/promises";
 import path, { resolve } from "node:path";
+import tls from "node:tls";
 import { promisify } from "node:util";
 import { execFile } from "node:child_process";
 //#region nodefony/service/certificates.ts
 const execFileAsync = promisify(execFile);
+const generateKeyPairAsync = promisify(generateKeyPair);
+/** Compare deux PEM sans dépendre des fins de ligne ni des espaces. */
+function normalizePem(pem) {
+	return pem.replace(/\s+/g, "");
+}
+/**
+* Ajoute une autorité aux ancres TLS par défaut du processus (requêtes sortantes
+* `fetch`, `https`, `tls.connect`), sans en retirer aucune.
+*
+* C'est l'équivalent en cours d'exécution de `NODE_EXTRA_CA_CERTS`, qui n'est lu
+* qu'au lancement du processus — trop tôt pour une CA que le boot vient de
+* générer, et que seul un script de banc posait. La capacité se CONSTATE
+* (`tls.setDefaultCACertificates` n'existe qu'à partir de Node 24.5), elle ne se
+* déduit pas d'un numéro de version. Idempotent : une autorité déjà présente
+* n'est pas ajoutée deux fois.
+*
+* @param pem - autorité au format PEM.
+* @param store - accès aux ancres ; `node:tls` par défaut.
+* @returns `added`, `present` (déjà de confiance), ou `unsupported`.
+*/
+function addDefaultCaCertificate(pem, store = tls) {
+	const { getCACertificates, setDefaultCACertificates } = store;
+	if (typeof getCACertificates !== "function" || typeof setDefaultCACertificates !== "function") return "unsupported";
+	const current = getCACertificates("default");
+	const wanted = normalizePem(pem);
+	if (current.some((c) => normalizePem(c) === wanted)) return "present";
+	setDefaultCACertificates([...current, pem]);
+	return "added";
+}
+const PEM_CERTIFICATE = /-----BEGIN CERTIFICATE-----[\s\S]+?-----END CERTIFICATE-----/g;
+/**
+* Découpe un fichier PEM en ses certificats — une chaîne d'entreprise est
+* souvent livrée en un seul fichier (racine + intermédiaires).
+*
+* Chaque certificat est ajouté SÉPARÉMENT : c'est ce qui rend l'ajout
+* idempotent certificat par certificat, la liste par défaut du processus
+* n'étant faite que de certificats isolés.
+*
+* @param pem - contenu d'un fichier PEM (un ou plusieurs certificats)
+* @returns les certificats, dans l'ordre du fichier ; vide s'il n'y en a aucun
+*/
+function splitPemCertificates(pem) {
+	return pem.match(PEM_CERTIFICATE) ?? [];
+}
+/**
+* Ajoute les autorités d'un fichier PEM aux ancres TLS du processus
+* (`certificates.extraCaFiles`) — l'équivalent, porté par l'APPLICATION, de
+* `NODE_EXTRA_CA_CERTS`.
+*
+* `NODE_EXTRA_CA_CERTS` n'est lu qu'au lancement de Node, et se pose dans la
+* syntaxe du shell — `VAR=… npm run dev` n'existe pas sous Windows. Une autorité
+* d'entreprise (Keycloak interne, proxy sortant qui ré-signe) se déclare donc
+* dans la configuration, et sert à TOUTES les requêtes sortantes du processus :
+* découverte OpenID, point de jeton, jeu de clés, appels d'administration.
+*
+* @param file - chemin du fichier, absolu ou relatif à `root`
+* @param root - racine de l'application
+* @param store - accès aux ancres ; `node:tls` par défaut
+* @returns le bilan de l'ajout
+* @throws BootConfigurationError - fichier illisible, sans certificat, ou Node
+*         incapable d'élargir ses ancres en cours d'exécution
+*/
+async function trustCaFile(file, root, store = tls) {
+	const absolute = path.resolve(root, file);
+	let content;
+	try {
+		content = await fsp.readFile(absolute, "utf8");
+	} catch (error) {
+		const code = error instanceof Error && "code" in error ? error.code : void 0;
+		const reason = typeof code === "string" ? code : error instanceof Error ? error.message : String(error);
+		throw new BootConfigurationError(`http.certificates.extraCaFiles : « ${absolute} » est illisible (${reason}).`);
+	}
+	const certificates = splitPemCertificates(content);
+	if (certificates.length === 0) throw new BootConfigurationError(`http.certificates.extraCaFiles : « ${absolute} » ne contient aucun certificat PEM (-----BEGIN CERTIFICATE-----).`);
+	let added = 0;
+	let present = 0;
+	for (const pem of certificates) {
+		const verdict = addDefaultCaCertificate(pem, store);
+		if (verdict === "unsupported") throw new BootConfigurationError(`http.certificates.extraCaFiles : ce Node ne sait pas élargir ses ancres TLS en cours d'exécution (tls.setDefaultCACertificates, Node ≥ 24.5). Mettre Node à jour, ou lancer avec NODE_EXTRA_CA_CERTS=${absolute}.`);
+		if (verdict === "added") added += 1;
+		else present += 1;
+	}
+	return {
+		file: absolute,
+		added,
+		present
+	};
+}
+/**
+* Ajoute aux ancres TLS du processus les autorités déclarées
+* (`certificates.extraCaFiles`), au plus tôt : appelé à l'enregistrement du
+* module, avant tout service — toute requête sortante, commande console
+* comprise, les trouve en place.
+*
+* La CA de DÉVELOPPEMENT n'y figure pas : le service de certificats la pose
+* lui-même ({@link Certificate.generateServerCertificates}).
+*
+* @param files - `certificates.extraCaFiles`
+* @param root - racine de l'application
+* @param log - journal du module
+* @throws BootConfigurationError - cf {@link trustCaFile}
+*/
+async function trustOutboundAuthorities(files, root, log) {
+	for (const file of files) {
+		const trust = await trustCaFile(file, root);
+		log(`autorité sortante ${trust.file} : ${trust.added} ajoutée(s), ${trust.present} déjà présente(s)`, "INFO");
+	}
+}
 /**
 * Vrai si `host` est une IP littérale (IPv4 `n.n.n.n` ou IPv6 — contient `:`).
-* Une IP doit aller en SAN `iPAddress`, jamais en `dNSName` (RFC 6125).
+* Une IP doit aller en SAN `iPAddress`, jamais en `dNSName` (RFC 9525).
 */
 function isIpLiteral(host) {
 	return /^\d{1,3}(\.\d{1,3}){3}$/.test(host) || host.includes(":");
@@ -32,49 +142,30 @@ const defaultOptions = {
 	}
 };
 /**
-* Valeur texte d'un champ de certificat node-forge (`getField` rend `any`),
-* ou `null` si le champ est absent.
-*/
-function certFieldValue(field) {
-	if (field === null || typeof field !== "object") return null;
-	const value = field.value;
-	return typeof value === "string" ? value : String(value);
-}
-/**
 * Service de fourniture du certificat TLS du serveur HTTPS/WSS.
 *
 * Trois stratégies : `explicit` (certificat fourni en config — le cas de
 * PRODUCTION), `mkcert` (CA locale trustée, confort de dev) et `selfsigned`
-* (auto-signé node-forge, secours). La génération est réservée au
+* (auto-signé, secours). La génération est réservée au
 * DÉVELOPPEMENT : en production sans certificat fourni, le service crie un
 * avertissement (Nodefony n'est pas une autorité de certification).
 *
 * Conformité (génération auto-signée) : signature SHA-256 (jamais SHA-1,
 * RFC 5280 / CA-B Forum), numéro de série aléatoire 128 bits unique
-* (RFC 5280 §4.1.2.2), SAN qui fait foi (RFC 6125), `notBefore` reculé,
+* (RFC 5280 §4.1.2.2), SAN qui fait foi (RFC 9525), `notBefore` reculé,
 * clé privée écrite en `0600`.
 */
 var Certificate = class Certificate extends Service {
 	module;
 	files = [];
 	keysPair = null;
-	certForge = null;
 	ca = "";
 	key = "";
 	cert = "";
 	fullchainPem = "";
 	publicKeyPem = "";
-	rootCertPem = "";
-	intermediateCertPem = "";
 	/** CAROOT résolu de mkcert (null tant que non détecté / indisponible). */
 	mkcertCaRoot = null;
-	/**
-	* Backend crypto node-forge, chargé PARESSEUSEMENT. La génération de
-	* certificat est un confort de DÉVELOPPEMENT : en production avec un
-	* certificat fourni (`strategy: "explicit"`), cette grosse dépendance n'est
-	* jamais importée (règle perf-mémoire — pas de dep chargée « au cas où »).
-	*/
-	forge = null;
 	path = resolve(".", "nodefony", "config", "certificates");
 	serverPath = resolve(this.path, "server");
 	caPath = resolve(this.path, "ca", "nodefony-root-ca.crt.pem");
@@ -95,20 +186,6 @@ var Certificate = class Certificate extends Service {
 		return this.kernel?.environment === "development";
 	}
 	/**
-	* Charge node-forge à la demande (idempotent) — uniquement sur le chemin de
-	* GÉNÉRATION (selfsigned / mkcert / inspection). Le chemin `explicit` (prod)
-	* ne l'appelle jamais.
-	*/
-	async loadForge() {
-		this.forge ??= (await import("node-forge")).default;
-		return this.forge;
-	}
-	/** Accès au backend forge déjà chargé (lève si `loadForge` n'a pas été appelé). */
-	get forgeLib() {
-		if (!this.forge) throw new Error("node-forge non chargé — appeler loadForge() avant toute génération.");
-		return this.forge;
-	}
-	/**
 	* Fabrique-t-on un certificat au démarrage ?
 	*
 	* 🔴 Seulement si un serveur TLS est ACTIF. Sans cette question, le hook
@@ -199,7 +276,7 @@ var Certificate = class Certificate extends Service {
 	/**
 	* Génère (ou recharge) le certificat serveur selon la stratégie résolue :
 	* `explicit` (fourni en config / prod), `mkcert` (dev, CA trustée) ou
-	* `selfsigned` (auto-signé node-forge, secours). Régénère automatiquement si
+	* `selfsigned` (auto-signé, secours). Régénère automatiquement si
 	* le certificat présent sur disque n'est pas adéquat pour la stratégie active
 	* (expiré, SHA-1, SAN incomplet).
 	*
@@ -210,17 +287,17 @@ var Certificate = class Certificate extends Service {
 		await this.ensureDirectoriesExist();
 		const strategy = await this.resolveStrategy();
 		if (strategy === "explicit") return this.loadExplicitCert();
-		await this.loadForge();
-		if (await this.checkCertificates() && !force && await this.isCertAdequate(strategy)) return this.readCerticates();
+		if (await this.checkCertificates() && !force && await this.isCertAdequate(strategy)) {
+			await this.readCerticates();
+			this.trustDevelopmentAuthority();
+			return this;
+		}
 		if (strategy === "mkcert") await this.generateWithMkcert();
 		else {
-			this.keysPair = this.generateKeys();
-			this.certForge = this.createCertificate();
-			this.setExtension();
-			this.sign();
+			this.keysPair = await this.generateKeys();
 			this.key = this.generatePrivateKeyPem();
 			this.publicKeyPem = this.generatePublickeyPem();
-			const certPem = this.generateCertPem();
+			const certPem = await this.createCertificate();
 			this.cert = certPem;
 			this.ca = certPem;
 			this.fullchainPem = this.createFullChain();
@@ -228,7 +305,26 @@ var Certificate = class Certificate extends Service {
 			await this.writeCertificates(true);
 			await fsp.writeFile(this.caPath, certPem.toString(), "utf8");
 		}
-		return this.readCerticates();
+		await this.readCerticates();
+		this.trustDevelopmentAuthority();
+		return this;
+	}
+	/**
+	* En développement, fait confiance à la CA que Nodefony vient de générer ou de
+	* relire, pour les requêtes SORTANTES du processus.
+	*
+	* Sans elle, un service du décor qui sert le certificat de l'application
+	* (Keycloak, l'auto-vérification d'un jeton MCP) est injoignable depuis
+	* `nodefony development` — `fetch failed` / `SELF_SIGNED_CERT_IN_CHAIN` — alors
+	* que `curl -k` répond : la confiance n'existait que sous le script de banc.
+	* Réservé au DÉVELOPPEMENT et aux certificats que Nodefony fabrique : un
+	* certificat `explicit` (production) n'élargit jamais la confiance du processus.
+	*/
+	trustDevelopmentAuthority() {
+		if (!this.isDev() || !this.ca || this.ca.length === 0) return;
+		const verdict = addDefaultCaCertificate(this.ca.toString());
+		if (verdict === "added") this.log(`CA de développement ajoutée aux ancres TLS du processus (${this.caPath})`, "DEBUG");
+		else if (verdict === "unsupported") this.log(`Ce Node ne sait pas élargir ses ancres TLS en cours d'exécution (tls.setDefaultCACertificates, Node ≥ 24.5) : les requêtes sortantes vers un service qui sert le certificat de développement échoueront. Relancer avec NODE_EXTRA_CA_CERTS=${this.caPath}`, "WARNING");
 	}
 	/**
 	* Résout la stratégie effective à partir de `certificates.strategy` :
@@ -236,7 +332,7 @@ var Certificate = class Certificate extends Service {
 	*   erreur si absents.
 	* - `mkcert` : dev + binaire mkcert + CA locale présents. Forcé hors dev →
 	*   retombe sur `selfsigned` avec avertissement.
-	* - `selfsigned` : auto-signé node-forge (fallback). En PRODUCTION, crie un
+	* - `selfsigned` : auto-signé (fallback). En PRODUCTION, crie un
 	*   avertissement : la génération n'est pas le rôle d'un serveur de prod.
 	*/
 	async resolveStrategy() {
@@ -253,7 +349,7 @@ var Certificate = class Certificate extends Service {
 					this.mkcertCaRoot = caRoot;
 					return "mkcert";
 				}
-				this.log((requested === "mkcert" ? "strategy='mkcert' mais mkcert introuvable — " : "mkcert introuvable — ") + "fallback certificat auto-signé node-forge (non trusté). `brew install mkcert nss && mkcert -install` pour un HTTPS dev sans erreur (HMR cross-origin/WSS).", "WARNING");
+				this.log((requested === "mkcert" ? "strategy='mkcert' mais mkcert introuvable — " : "mkcert introuvable — ") + "fallback certificat auto-signé (non trusté). `brew install mkcert nss && mkcert -install` pour un HTTPS dev sans erreur (HMR cross-origin/WSS).", "WARNING");
 			} else if (requested === "mkcert") this.log("strategy='mkcert' ignoré hors development → certificat auto-signé.", "WARNING");
 		}
 		if (!this.isDev()) this.log("Aucun certificat TLS fourni en PRODUCTION : génération d'un auto-signé NON trusté (secours). Nodefony n'est PAS une autorité de certification de production — fournissez un vrai certificat (Let's Encrypt, ingress k8s, reverse-proxy edge) via certificates.{ key, cert, ca } (strategy='explicit').", "WARNING");
@@ -282,7 +378,7 @@ var Certificate = class Certificate extends Service {
 	/**
 	* SAN effectif : config explicite si fournie, sinon dérivé du kernel
 	* (localhost + domain en DNS ; loopback en IP). Une IP littérale (ex. domain
-	* `127.0.0.1` en dev) est classée en `ip`, pas en `dns` (RFC 6125).
+	* `127.0.0.1` en dev) est classée en `ip`, pas en `dns` (RFC 9525).
 	*/
 	derivedSan() {
 		const san = this.certOptions.san;
@@ -330,8 +426,10 @@ var Certificate = class Certificate extends Service {
 		await this.restrictPrivateKey();
 		const rootCaPem = await fsp.readFile(path.join(caRoot, "rootCA.pem"), "utf8");
 		const certPem = await fsp.readFile(this.certPath, "utf8");
-		const { pki } = this.forgeLib;
-		const publicKeyPem = pki.publicKeyToPem(pki.certificateFromPem(certPem).publicKey);
+		const publicKeyPem = new X509Certificate(certPem).publicKey.export({
+			type: "spki",
+			format: "pem"
+		});
 		await fsp.writeFile(this.publicKeyPath, publicKeyPem, "utf8");
 		await fsp.writeFile(this.fullchainPath, `${certPem}${rootCaPem}`, "utf8");
 		await fsp.writeFile(this.caPath, rootCaPem, "utf8");
@@ -348,25 +446,21 @@ var Certificate = class Certificate extends Service {
 	*/
 	async isCertAdequate(strategy) {
 		try {
-			const { pki } = this.forgeLib;
-			const certPem = await fsp.readFile(this.certPath, "utf8");
-			const cert = pki.certificateFromPem(certPem);
-			if (cert.validity.notAfter.getTime() <= Date.now()) return false;
-			const ext = cert.getExtension("subjectAltName");
-			if (!ext || !this.sanCovers(ext.altNames ?? [])) return false;
+			const cert = new X509Certificate(await fsp.readFile(this.certPath));
+			if (cert.validToDate.getTime() <= Date.now()) return false;
+			if (!this.sanCovers(parseSubjectAltName(cert.subjectAltName).dns)) return false;
 			if (strategy === "mkcert") {
-				const org = certFieldValue(cert.issuer.getField("O"));
+				const org = distinguishedNameField(cert.issuer, "O");
 				return org !== null && /mkcert/i.test(org);
 			}
-			return cert.signatureOid !== pki.oids.sha1WithRSAEncryption;
+			return signatureAlgorithmOid(cert.raw) !== SHA1_WITH_RSA_OID;
 		} catch {
 			return false;
 		}
 	}
-	/** Le SAN présent couvre-t-il tous les noms DNS requis (RFC 6125) ? */
-	sanCovers(present) {
-		const presentDns = new Set(present.filter((p) => p.type === 2 && p.value).map((p) => p.value));
-		return this.sanDnsNames().every((name) => presentDns.has(name));
+	/** Le SAN présent couvre-t-il tous les noms DNS requis (RFC 9525) ? */
+	sanCovers(presentDns) {
+		return this.sanDnsNames().every((name) => presentDns.includes(name));
 	}
 	/** Charge un certificat fourni en config (chemin fichier ou Buffer). */
 	async loadExplicitCert() {
@@ -386,11 +480,7 @@ var Certificate = class Certificate extends Service {
 		return Buffer.from(await fsp.readFile(value, "utf8"));
 	}
 	createFullChain() {
-		return [
-			this.cert,
-			this.intermediateCertPem,
-			this.rootCertPem
-		].map((part) => part?.toString().trim()).filter(Boolean).join("\n");
+		return this.cert?.toString().trim() ?? "";
 	}
 	async readCerticates() {
 		for (const file of this.files) try {
@@ -452,86 +542,58 @@ var Certificate = class Certificate extends Service {
 			this.log(err, "DEBUG");
 		}
 	}
-	generateKeys() {
-		return this.forgeLib.pki.rsa.generateKeyPair(this.certOptions.selfSigned.size);
+	/** Génère la paire RSA (taille configurée) hors de la boucle d'événements. */
+	async generateKeys() {
+		return generateKeyPairAsync("rsa", { modulusLength: this.certOptions.selfSigned.size });
 	}
+	/** Clé privée en PEM PKCS#1 (`BEGIN RSA PRIVATE KEY`). */
 	generatePrivateKeyPem() {
-		if (this.keysPair) return Buffer.from(this.forgeLib.pki.privateKeyToPem(this.keysPair.privateKey));
-		throw new Error(`pki.rsa.KeyPair  not found`);
+		if (this.keysPair) return Buffer.from(this.keysPair.privateKey.export({
+			type: "pkcs1",
+			format: "pem"
+		}));
+		throw new Error(`KeyPair not found`);
 	}
+	/** Clé publique en PEM SPKI (`BEGIN PUBLIC KEY`). */
 	generatePublickeyPem() {
-		if (this.keysPair) return Buffer.from(this.forgeLib.pki.publicKeyToPem(this.keysPair.publicKey));
-		throw new Error(`pki.rsa.KeyPair  not found`);
+		if (this.keysPair) return Buffer.from(this.keysPair.publicKey.export({
+			type: "spki",
+			format: "pem"
+		}));
+		throw new Error(`KeyPair not found`);
 	}
-	generateCertPem() {
-		if (this.certForge) return Buffer.from(this.forgeLib.pki.certificateToPem(this.certForge));
-		throw new Error(`pki.Certificate  not found`);
-	}
-	createCertificate() {
+	/**
+	* Fabrique et signe le certificat auto-signé avec la paire courante.
+	*
+	* Série aléatoire unique (RFC 5280 §4.1.2.2), `notBefore` reculé (décalage
+	* d'horloge du client), SAN DNS + IP (config explicite sinon dérivé), signé
+	* avec le hachage configuré — jamais SHA-1 (collision SHAttered 2017,
+	* CA/Browser Forum depuis 2016).
+	*
+	* @returns le certificat en PEM
+	* @throws Si la paire de clés n'a pas été générée
+	*/
+	async createCertificate() {
 		if (!this.keysPair) throw new Error(`KeyPair  not found`);
 		const o = this.certOptions.selfSigned;
-		const cert = this.forgeLib.pki.createCertificate();
-		cert.publicKey = this.keysPair.publicKey;
-		cert.serialNumber = Certificate.generateSerialHex();
-		const backdateMs = o.backdateMinutes * 6e4;
-		const start = Date.now() - backdateMs;
-		cert.validity.notBefore = new Date(start);
-		cert.validity.notAfter = new Date(start + o.validityDays * 864e5);
-		cert.setSubject(o.attrs);
-		cert.setIssuer(o.attrs);
-		return cert;
-	}
-	/** subjectAltName de l'auto-signé : DNS + IP (config explicite sinon dérivé). */
-	altNames() {
-		const out = [];
-		for (const dns of this.sanDnsNames()) out.push({
-			type: 2,
-			value: dns
-		});
-		for (const ip of this.sanIps()) out.push({
-			type: 7,
-			ip
+		const start = Date.now() - o.backdateMinutes * 6e4;
+		const pem = await createSelfSignedCertificate({
+			privateKey: this.keysPair.privateKey,
+			publicKey: this.keysPair.publicKey,
+			serialHex: Certificate.generateSerialHex(),
+			notBefore: new Date(start),
+			notAfter: new Date(start + o.validityDays * 864e5),
+			attributes: o.attrs,
+			dns: this.sanDnsNames(),
+			ip: this.sanIps(),
+			hash: this.allowedHash(o.hash)
 		});
-		return out;
-	}
-	setExtension() {
-		if (!this.certForge) throw new Error(`pki.Certificate  not found`);
-		this.certForge.setExtensions([
-			{
-				name: "basicConstraints",
-				cA: false
-			},
-			{
-				name: "keyUsage",
-				digitalSignature: true,
-				keyEncipherment: true
-			},
-			{
-				name: "extKeyUsage",
-				serverAuth: true,
-				clientAuth: true
-			},
-			{
-				name: "subjectAltName",
-				altNames: this.altNames()
-			},
-			{ name: "subjectKeyIdentifier" }
-		]);
-	}
-	/**
-	* Signe le certificat avec le hachage configuré (SHA-256 par défaut).
-	* SHA-1 est INTERDIT (collision SHAttered 2017, CA/Browser Forum depuis 2016) :
-	* `node-forge` signe en SHA-1 par défaut si on ne passe pas de digest → on en
-	* passe toujours un.
-	*/
-	sign() {
-		if (!this.certForge || !this.keysPair) throw new Error(`pki.rsa.KeyPair or pki.Certificate  not found`);
-		this.certForge.sign(this.keysPair.privateKey, this.digestFor(this.certOptions.selfSigned.hash));
+		return Buffer.from(pem);
 	}
 	/**
 	* Résumé introspectable du certificat serveur courant — réutilisé par la
 	* commande CLI `certificates` et un futur endpoint d'admin Studio (parité
-	* CLI ↔ Web). Parse le certificat chargé (charge node-forge à la demande).
+	* CLI ↔ Web).
 	*/
 	async describe() {
 		const info = {
@@ -545,38 +607,32 @@ var Certificate = class Certificate extends Service {
 			info.caPath = this.caPath;
 		} catch {}
 		if (!this.cert) return info;
-		const { pki } = await this.loadForge();
 		try {
-			const cert = pki.certificateFromPem(this.cert.toString());
-			info.serial = cert.serialNumber;
-			info.validFrom = cert.validity.notBefore.toISOString();
-			info.validTo = cert.validity.notAfter.toISOString();
-			info.signatureAlgorithm = this.oidName(cert.signatureOid, pki);
-			const cn = certFieldValue(cert.subject.getField("CN"));
+			const cert = new X509Certificate(this.cert);
+			info.serial = cert.serialNumber.toLowerCase();
+			info.validFrom = cert.validFromDate.toISOString();
+			info.validTo = cert.validToDate.toISOString();
+			info.signatureAlgorithm = signatureAlgorithmName(signatureAlgorithmOid(cert.raw));
+			const cn = cert.subject ? distinguishedNameField(cert.subject, "CN") : null;
 			if (cn !== null) info.commonName = cn;
-			const ext = cert.getExtension("subjectAltName");
-			if (ext?.altNames) info.san = ext.altNames.map((a) => a.type === 7 ? a.ip ?? "" : a.value ?? "");
+			const san = parseSubjectAltName(cert.subjectAltName);
+			if (san.dns.length > 0 || san.ip.length > 0) info.san = [...san.dns, ...san.ip];
 		} catch {}
 		return info;
 	}
-	/** Nom lisible de l'OID d'algorithme de signature. */
-	oidName(oid, pki) {
-		return pki.oids[oid] ?? oid;
-	}
-	/** Digest node-forge correspondant au hachage configuré (jamais SHA-1). */
-	digestFor(hash) {
-		const { md } = this.forgeLib;
+	/** Hachage configuré, ramené à SHA-256 s'il sort du contrat (jamais SHA-1). */
+	allowedHash(hash) {
 		switch (hash) {
-			case "sha512": return md.sha512.create();
-			case "sha384": return md.sha384.create();
-			case "sha256": return md.sha256.create();
+			case "sha512":
+			case "sha384":
+			case "sha256": return hash;
 			default: {
 				const refused = hash;
 				this.log(`Hachage '${refused}' refusé (SHA-1 interdit) → SHA-256.`, "WARNING");
-				return md.sha256.create();
+				return "sha256";
 			}
 		}
 	}
 };
 //#endregion
-export { Certificate as default };
+export { addDefaultCaCertificate, Certificate as default, splitPemCertificates, trustCaFile, trustOutboundAuthorities };

package/dist/nodefony/service/error-renderer.js

@@ -348,7 +348,7 @@ const SCHEMA_MISMATCH_HINT = {
 *   reason: error.message
 *
 * Stateless singleton — zero per-request allocation. Override via
-* `httpKernel.setErrorRenderer(custom)` for prod hardening or RFC 7807.
+* `httpKernel.setErrorRenderer(custom)` for prod hardening or RFC 9457.
 */
 var DefaultErrorRenderer = class {
 	renderHttp(error, context) {