@nodefony/security 10.0.0-beta.6 → 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/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
@@ -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,7 +359,7 @@ function buildFrameAuthorizer(firewall, options) {
 	const resolver = options?.channelResolver ?? null;
 	const systemRules = options?.systemRules ?? DEFAULT_SYSTEM_RULES;
 	const onDeny = options?.onDeny;
-	return (frame, token) => {
+	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);
@@ -284,10 +367,18 @@ function buildFrameAuthorizer(firewall, options) {
 			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/jwtRuntime.js

@@ -3,12 +3,32 @@
 * Dérive les paramètres effectifs depuis la config sécurité. `issuer` omis →
 * `"nodefony"` (DEVRAIT être surchargé en prod) ; `audiences` vide → l'app est sa
 * propre audience (`[issuer]`).
+*
+* La ressource d'une ZONE (`areas.<zone>.resource`) entre aussi dans la liste,
+* APRÈS les audiences déclarées : c'est une ressource que ce serveur protège, et
+* la redéclarer dans `jwt.audiences` était une seconde écriture de la même
+* valeur — celle qu'on oublie, et dont le seul symptôme est un `invalid_target`
+* à l'émission. Ajoutée en fin de liste, elle ne change jamais l'audience par
+* défaut ({@link defaultAudience}).
+*
+* Elle n'ouvre rien de plus à la VÉRIFICATION : chaque zone, `jwt` comme
+* `external-jwt`, exige SA ressource (l'audience par défaut pour une zone `jwt`
+* qui n'en déclare pas) — un jeton émis pour une zone n'en ouvre pas une autre.
+*
+* @param jwt - section `jwt` de la config validée
+* @param areas - zones du pare-feu ; omises, seules les audiences déclarées comptent
+* @returns les paramètres partagés par l'émetteur et les vérificateurs
 */
-function resolveJwtRuntime(jwt) {
+function resolveJwtRuntime(jwt, areas) {
 	const issuer = jwt.issuer && jwt.issuer.length > 0 ? jwt.issuer : "nodefony";
+	const audiences = jwt.audiences.length > 0 ? [...jwt.audiences] : [issuer];
+	if (areas !== void 0) for (const name in areas) {
+		const resource = areas[name]?.resource;
+		if (resource !== void 0 && !audiences.includes(resource)) audiences.push(resource);
+	}
 	return {
 		issuer,
-		audiences: jwt.audiences.length > 0 ? [...jwt.audiences] : [issuer],
+		audiences,
 		accessTtlS: jwt.accessTtlS,
 		refreshTtlS: jwt.refreshTtlS,
 		rotateRefresh: jwt.rotateRefresh,

package/dist/nodefony/src/webhook/webhookDelivery.js

@@ -1,101 +1,52 @@
-import { request } from "node:http";
-import { Buffer } from "node:buffer";
-import { isIP } from "node:net";
-import { request as request$1 } from "node:https";
+import { fetchPublic } from "../net/fetchPublic.js";
+import { FetchPublicError } from "../../errors/FetchPublicError.js";
 // nodefony/src/webhook/webhookDelivery.ts
 /**
-* Émetteur HTTP d'une livraison webhook — `node:http(s)` natif (0 dép). Trois
-* propriétés de sécurité par rapport à `fetch` :
-*
-* 1. **Pas de suivi de redirection** : `node:http(s)` ne suit JAMAIS les 3xx
-*    (contrairement à `fetch`) → un `302 → 169.254.169.254` ne contourne pas le
-*    contrôle SSRF ; le 3xx est rendu tel quel (échec de config).
-* 2. **Pin de l'IP validée** (anti DNS-rebinding) : `lookup` force la connexion TCP
-*    vers l'IP déjà contrôlée par `assertPublicUrl`, tout en gardant le hostname
-*    pour le SNI/TLS et l'en-tête `Host` → pas de re-résolution entre contrôle et
-*    connexion.
-* 3. **Timeout dur** : la requête est détruite au-delà du délai.
+* Émetteur HTTP d'une livraison webhook — délègue à {@link fetchPublic}, la
+* primitive unique des requêtes sortantes : pas de suivi de redirection, IP
+* vérifiée épinglée (anti DNS-rebinding), délai total, lecture bornée.
 */
 /** Taille max du corps de réponse capturé (observabilité, anti-mémoire). */
 const RESPONSE_BODY_CAP = 2048;
 /**
-* POST le corps signé vers l'URL, en pinnant l'IP validée et sans suivre les
-* redirections. Ne lève jamais : tout échec est encodé dans {@link IDeliveryResult}.
+* POST le corps signé vers l'URL, par {@link fetchPublic} : IP vérifiée épinglée,
+* aucune redirection suivie, délai TOTAL (un destinataire qui goutte un octet
+* ne retient pas la livraison) et lecture du corps coupée à
+* {@link RESPONSE_BODY_CAP} (connexion détruite, pas drainée). Ne lève jamais :
+* tout échec est encodé dans {@link IDeliveryResult}.
 */
-function deliverWebhook(url, body, headers, opts) {
-	let u;
+async function deliverWebhook(url, body, headers, opts) {
 	try {
-		u = new URL(url);
-	} catch {
-		return Promise.resolve({
+		const vetted = opts.addresses !== void 0 && opts.addresses.length > 0;
+		const r = await fetchPublic(url, {
+			method: "POST",
+			headers,
+			body,
+			maxBytes: RESPONSE_BODY_CAP,
+			timeoutMs: opts.timeoutMs,
+			allowHttp: opts.allowHttp === true,
+			allowPrivate: !vetted,
+			...vetted ? { vettedAddresses: opts.addresses } : {}
+		});
+		const ok = r.status >= 200 && r.status < 300;
+		const text = r.body.length > 0 ? new TextDecoder().decode(r.body) : "";
+		return {
+			ok,
+			status: r.status,
+			error: ok ? null : `HTTP ${r.status}`,
+			responseBody: text.length > 0 ? text : null
+		};
+	} catch (e) {
+		if (e instanceof FetchPublicError && e.reason === "timeout") return {
 			ok: false,
 			status: null,
-			error: "URL invalide"
-		});
-	}
-	const isHttps = u.protocol === "https:";
-	if (!isHttps && !(u.protocol === "http:" && opts.allowHttp)) return Promise.resolve({
-		ok: false,
-		status: null,
-		error: `protocole ${u.protocol} non autorisé`
-	});
-	const pinned = opts.addresses && opts.addresses.length > 0 ? opts.addresses[0] : null;
-	const lookup = pinned ? (_hostname, options, callback) => {
-		const family = isIP(pinned) === 6 ? 6 : 4;
-		if (options.all) callback(null, [{
-			address: pinned,
-			family
-		}], family);
-		else callback(null, pinned, family);
-	} : void 0;
-	const payload = Buffer.from(body, "utf8");
-	const requestFn = isHttps ? request$1 : request;
-	return new Promise((resolve) => {
-		let settled = false;
-		const done = (r) => {
-			if (!settled) {
-				settled = true;
-				resolve(r);
-			}
+			error: "timeout"
 		};
-		const req = requestFn(url, {
-			method: "POST",
-			headers: {
-				...headers,
-				"content-length": String(payload.length)
-			},
-			lookup
-		}, (res) => {
-			const status = res.statusCode ?? 0;
-			const ok = status >= 200 && status < 300;
-			let resBody = "";
-			res.on("data", (c) => {
-				if (resBody.length < RESPONSE_BODY_CAP) {
-					resBody += c.toString("utf8");
-					if (resBody.length > RESPONSE_BODY_CAP) resBody = resBody.slice(0, RESPONSE_BODY_CAP);
-				}
-			});
-			res.on("end", () => done({
-				ok,
-				status,
-				error: ok ? null : `HTTP ${status}`,
-				responseBody: resBody.length > 0 ? resBody : null
-			}));
-			res.on("error", (e) => done({
-				ok: false,
-				status,
-				error: e.message,
-				responseBody: resBody.length > 0 ? resBody : null
-			}));
-		});
-		req.setTimeout(opts.timeoutMs, () => req.destroy(/* @__PURE__ */ new Error("timeout")));
-		req.on("error", (e) => done({
+		return {
 			ok: false,
 			status: null,
-			error: e.message
-		}));
-		req.write(payload);
-		req.end();
-	});
+			error: e instanceof Error ? e.message : String(e)
+		};
+	}
 }
 export { deliverWebhook };

package/dist/types/index.d.ts

@@ -172,6 +172,8 @@ export type { IWebhookPayload } from "./nodefony/contracts/IWebhookPayload.js";
 export type { IWebhookListQuery, IWebhookStore, } from "./nodefony/contracts/IWebhookStore.js";
 export { assertPublicUrl, isBlockedAddress, } from "./nodefony/src/net/ssrfGuard.js";
 export type { IAssertPublicUrlOptions, IPublicUrlResult, DnsResolver, } from "./nodefony/src/net/ssrfGuard.js";
+export { fetchPublic } from "./nodefony/src/net/fetchPublic.js";
+export type { IFetchPublicOptions, IFetchPublicResult, } from "./nodefony/src/net/fetchPublic.js";
 export { deriveKey, encryptSecret, decryptSecret, generateEphemeralKey, } from "./nodefony/src/crypto/secretCipher.js";
 export type { IKeyDerivation } from "./nodefony/src/crypto/secretCipher.js";
 export { defineSecurityConfig, securityConfigJsonSchema, } from "./nodefony/config/defineModuleConfig.js";
@@ -180,6 +182,7 @@ export { LoginThrottler } from "./nodefony/src/throttle/LoginThrottler.js";
 export type { ILoginThrottleOptions } from "./nodefony/src/throttle/LoginThrottler.js";
 export { CredentialTransportPolicy, shouldEnforceCredentialTransport, } from "./nodefony/src/transport/CredentialTransportPolicy.js";
 export type { ICredentialTransportContext, ICredentialTransportPolicyOptions, } from "./nodefony/src/transport/CredentialTransportPolicy.js";
-export { AuthenticationError, AccessDeniedError, ThrottledError, UnverifiableTokenError, InvalidTargetError, CsrfError, SsrfError, InsecureTransportError, } from "./nodefony/errors/index.js";
+export { AuthenticationError, AccessDeniedError, ThrottledError, UnverifiableTokenError, InvalidTargetError, CsrfError, SsrfError, FetchPublicError, InsecureTransportError, } from "./nodefony/errors/index.js";
+export type { FetchPublicFailure } from "./nodefony/errors/index.js";
 export { VoterVote } from "./nodefony/contracts/index.js";
 export type { IToken, IAuthenticator, ISecuredArea, IFirewall, IAccessVoter, IAuthorizationService, IAccessTokenRecord, ITokenStore, ITokenListQuery, ITokenUsage, IResourcePermission, TokenRevokeReason, TokenStatus, IJwtKeystore, IJwtSigningKey, } from "./nodefony/contracts/index.js";