@hostwebhook/node-sdk 0.1.0

package/dist/ssrf-guard.js

@@ -0,0 +1,917 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.URI_SCHEMES = exports.URI_GUARD_FAMILY = void 0;
+exports.assertSafeMongoUri = assertSafeMongoUri;
+exports.maskMongoUri = maskMongoUri;
+exports.assertSafeMongoUriUnlessTunneled = assertSafeMongoUriUnlessTunneled;
+exports.assertSafePostgresUri = assertSafePostgresUri;
+exports.assertSafePostgresUriUnlessTunneled = assertSafePostgresUriUnlessTunneled;
+exports.isGuardedUriCredential = isGuardedUriCredential;
+exports.assertUriSchemeMatchesType = assertUriSchemeMatchesType;
+exports.assertSafeCredentialUri = assertSafeCredentialUri;
+exports.assertSafeCredentialUriUnlessTunneled = assertSafeCredentialUriUnlessTunneled;
+exports.maskPostgresUri = maskPostgresUri;
+exports.parseFirstMongoHost = parseFirstMongoHost;
+exports.rewriteMongoUriHost = rewriteMongoUriHost;
+exports.parseFirstPostgresHost = parseFirstPostgresHost;
+exports.baseDeLaUri = baseDeLaUri;
+exports.rewritePostgresUriDatabase = rewritePostgresUriDatabase;
+exports.rewritePostgresUriHost = rewritePostgresUriHost;
+exports.isPrivateAddress = isPrivateAddress;
+exports.assertSafeHttpUrl = assertSafeHttpUrl;
+exports.agentesDeEntrega = agentesDeEntrega;
+exports.despachadorDeSalida = despachadorDeSalida;
+exports.fetchSeguro = fetchSeguro;
+const common_1 = require("@nestjs/common");
+const node_dns_1 = require("node:dns");
+const node_net_1 = require("node:net");
+const http = __importStar(require("node:http"));
+const https = __importStar(require("node:https"));
+const undici_1 = require("undici");
+/**
+ * SSRF guard for user-supplied connection URIs (MongoDB, HTTP outbound, etc).
+ *
+ * Refuses any host that resolves to an internal / private / loopback IP
+ * range. Without this, a tenant could point a connection string at our
+ * own infra (`mongodb://localhost:27017/admin`, the metadata service IP
+ * `169.254.169.254` on cloud VMs, an internal `10.0.x.y` Mongo, etc.)
+ * and use the credential decrypt + connect path to read or write into
+ * resources that don't belong to them. We also re-resolve at runtime
+ * so a DNS-rebinding attack — host that resolves to a public IP at
+ * save time and a private one at use time — gets caught.
+ */
+const PRIVATE_V4_RANGES = [
+    /^10\./,
+    /^127\./,
+    /^169\.254\./,
+    /^172\.(1[6-9]|2\d|3[0-1])\./,
+    /^192\.168\./,
+    /^0\./,
+];
+/**
+ * The IPv6 ranges that must never be a connection target, as real CIDRs.
+ *
+ * This used to be a list of string prefixes — `['::1', 'fc', 'fd', 'fe80']`
+ * matched with `startsWith`. That let two things through. Link-local is
+ * fe80::/10, i.e. fe80 through febf, so every `fe90:`/`fea0:`/`feb0:`
+ * address read as public. And any spelling that did not literally begin
+ * with those characters missed entirely — `0:0:0:0:0:0:0:1` is the expanded
+ * form of `::1` and passed the check.
+ */
+const PRIVATE_V6_CIDRS = [
+    ['::', 128], // unspecified — routes to localhost on most stacks
+    ['::1', 128], // loopback
+    ['fc00::', 7], // unique local (covers the old 'fc' and 'fd' prefixes)
+    ['fe80::', 10], // link-local
+];
+const BLOCKED_HOSTNAMES = new Set([
+    'localhost',
+    'localhost.localdomain',
+    'ip6-localhost',
+    'ip6-loopback',
+    'metadata.google.internal',
+    'metadata',
+]);
+/**
+ * Expand any IPv6 spelling to its 128-bit value, so ranges can be tested by
+ * containment instead of by how the address happens to be written.
+ * Returns null when the text is not a well-formed IPv6 literal.
+ */
+function ipv6ToBigInt(ip) {
+    let s = ip.toLowerCase();
+    // Zone index (fe80::1%eth0) names an interface, not part of the address.
+    const zone = s.indexOf('%');
+    if (zone >= 0)
+        s = s.slice(0, zone);
+    // A trailing dotted-quad is the low 32 bits written in IPv4 notation.
+    const v4 = /(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$/.exec(s);
+    if (v4) {
+        const octets = v4[1].split('.').map(Number);
+        if (octets.some((o) => !Number.isInteger(o) || o < 0 || o > 255))
+            return null;
+        const hi = ((octets[0] << 8) | octets[1]).toString(16);
+        const lo = ((octets[2] << 8) | octets[3]).toString(16);
+        s = s.slice(0, v4.index) + hi + ':' + lo;
+    }
+    const halves = s.split('::');
+    if (halves.length > 2)
+        return null;
+    const head = halves[0] ? halves[0].split(':') : [];
+    const tail = halves.length === 2 && halves[1] ? halves[1].split(':') : [];
+    let groups;
+    if (halves.length === 2) {
+        const missing = 8 - head.length - tail.length;
+        if (missing < 0)
+            return null;
+        groups = [...head, ...Array(missing).fill('0'), ...tail];
+    }
+    else {
+        if (head.length !== 8)
+            return null;
+        groups = head;
+    }
+    let out = 0n;
+    for (const g of groups) {
+        if (!/^[0-9a-f]{1,4}$/.test(g))
+            return null;
+        out = (out << 16n) | BigInt(parseInt(g, 16));
+    }
+    return out;
+}
+/** Is `addr` inside `base/bits`? */
+function inV6Cidr(addr, base, bits) {
+    const baseInt = ipv6ToBigInt(base);
+    if (baseInt === null)
+        return false;
+    const mask = bits === 0 ? 0n : ((1n << BigInt(bits)) - 1n) << BigInt(128 - bits);
+    return (addr & mask) === (baseInt & mask);
+}
+function isPrivateV4(ip) {
+    return PRIVATE_V4_RANGES.some((re) => re.test(ip));
+}
+function intToIpv4(n) {
+    return [
+        (n >>> 24) & 0xff,
+        (n >>> 16) & 0xff,
+        (n >>> 8) & 0xff,
+        n & 0xff,
+    ].join('.');
+}
+function isPrivateIp(ip) {
+    const family = (0, node_net_1.isIP)(ip);
+    if (family === 4)
+        return isPrivateV4(ip);
+    if (family !== 6)
+        return false;
+    const addr = ipv6ToBigInt(ip);
+    // node's isIP accepted it but this parser did not. Refuse rather than
+    // treat an address we cannot read as safe.
+    if (addr === null)
+        return true;
+    // IPv4-mapped (::ffff:a.b.c.d) and IPv4-compatible (::a.b.c.d) carry an
+    // IPv4 address in their low 32 bits and reach exactly that address, so
+    // they have to face the IPv4 test. This is done on the parsed value, not
+    // on the text: `::ffff:127.0.0.1` and `::ffff:7f00:1` are the same
+    // address, and node's URL parser hands back the second spelling — so
+    // unwrapping by regex would have missed the very form the platform sees.
+    const high96 = addr >> 32n;
+    const low32 = Number(addr & 0xffffffffn);
+    // `::` and `::1` sit in ::/96 too, but they are addresses in their own
+    // right rather than embedded IPv4 — the CIDR list below owns them.
+    if (high96 === 0xffffn || (high96 === 0n && low32 > 1)) {
+        return isPrivateV4(intToIpv4(low32));
+    }
+    return PRIVATE_V6_CIDRS.some(([base, bits]) => inV6Cidr(addr, base, bits));
+}
+/**
+ * Parse the bare hostnames + the SRV flag out of a `mongodb://` or
+ * `mongodb+srv://` URI. Returns array of hostnames (no port) plus a
+ * boolean telling the caller whether to use SRV-style DNS lookup.
+ *
+ * `mongodb+srv://` URIs name a SINGLE hostname that itself has no
+ * A/AAAA record — Atlas-style. The SRV record at
+ * `_mongodb._tcp.<host>` returns the actual cluster nodes that we
+ * have to validate. Legacy `mongodb://` URIs may have a comma-
+ * separated host list for replica sets.
+ */
+function extractMongoHosts(uri) {
+    const match = /^mongodb(\+srv)?:\/\/(?:[^@/]*@)?([^/?]+)/i.exec(uri);
+    if (!match)
+        throw new common_1.ForbiddenException('Connection string is not a valid mongodb:// URI');
+    const srv = !!match[1];
+    const hostList = match[2];
+    const hosts = hostList
+        .split(',')
+        .map((h) => h.trim())
+        .map((h) => {
+        // Bracket-aware: `[::1]:27017` is an IPv6 literal plus a port, and the
+        // brackets are what say where the address ends. Strip the port only
+        // once they are gone — and never from a bare IPv6 literal, or `::1`
+        // would lose its last group and stop looking like an address at all.
+        const bracketed = /^\[([^\]]+)\](?::\d+)?$/.exec(h);
+        if (bracketed)
+            return bracketed[1];
+        if ((0, node_net_1.isIP)(h) === 6)
+            return h;
+        return h.replace(/:\d+$/, '');
+    })
+        .filter(Boolean);
+    return { hosts, srv };
+}
+/**
+ * Resolve a hostname to its real cluster nodes. For `mongodb+srv://`
+ * the host itself (e.g. `cluster0.abc123.mongodb.net`) typically has
+ * NO A record — Atlas only publishes the SRV at
+ * `_mongodb._tcp.<host>`. Look that up first; fall back to a direct
+ * A/AAAA lookup on the bare hostname for legacy `mongodb://` URIs and
+ * self-hosted clusters that publish SRV anyway.
+ */
+async function resolveMongoHost(host, srv) {
+    const ips = [];
+    if (srv) {
+        try {
+            const srvRecords = await node_dns_1.promises.resolveSrv(`_mongodb._tcp.${host}`);
+            const targetHosts = srvRecords.map((r) => r.name);
+            for (const target of targetHosts) {
+                const v4 = await node_dns_1.promises.resolve4(target).catch(() => []);
+                const v6 = await node_dns_1.promises.resolve6(target).catch(() => []);
+                ips.push(...v4, ...v6);
+            }
+            // SRV worked — return what we got, even if the per-node A/AAAA
+            // lookups all failed (mongoose driver will surface a clearer
+            // error than us at connect time).
+            return ips;
+        }
+        catch {
+            // SRV lookup failed — fall through to direct A/AAAA below. Some
+            // self-hosted setups use mongodb+srv:// for the URI shape but
+            // don't actually publish SRV records.
+        }
+    }
+    const v4 = await node_dns_1.promises.resolve4(host).catch(() => []);
+    const v6 = await node_dns_1.promises.resolve6(host).catch(() => []);
+    return [...v4, ...v6];
+}
+/**
+ * Throw if the URI's host(s) point at private / loopback / link-local
+ * addresses, OR if their DNS resolves there. mongodb+srv URIs are
+ * handled via SRV record lookup (the `<host>.mongodb.net` pattern
+ * Atlas uses doesn't have A/AAAA records — only the SRV at
+ * `_mongodb._tcp.<host>` does).
+ */
+async function assertSafeMongoUri(uri) {
+    const { hosts, srv } = extractMongoHosts(uri);
+    for (const host of hosts) {
+        const lowered = host.toLowerCase();
+        if (BLOCKED_HOSTNAMES.has(lowered)) {
+            throw new common_1.ForbiddenException(`Connection to ${host} is not allowed`);
+        }
+        // Literal IP in the URI — check directly, no DNS needed.
+        if ((0, node_net_1.isIP)(host)) {
+            if (isPrivateIp(host)) {
+                throw new common_1.ForbiddenException(`Connection to private IP ${host} is not allowed`);
+            }
+            continue;
+        }
+        // DNS lookup — guards against rebinding attacks (host resolves to
+        // a public IP at save time and a private one when we actually
+        // connect later). For mongodb+srv URIs we resolve via SRV first.
+        let resolved;
+        try {
+            resolved = await resolveMongoHost(host, srv);
+        }
+        catch {
+            throw new common_1.ForbiddenException(`Could not resolve host ${host}`);
+        }
+        if (resolved.length === 0) {
+            throw new common_1.ForbiddenException(`Could not resolve host ${host}${srv ? ' (no SRV record at _mongodb._tcp.' + host + ' and no A record on the host either)' : ''}`);
+        }
+        for (const ip of resolved) {
+            if (isPrivateIp(ip)) {
+                throw new common_1.ForbiddenException(`Host ${host} resolves to private IP ${ip} — refusing to connect`);
+            }
+        }
+    }
+}
+/** Mask the credentials portion of a Mongo URI for logs / UI. */
+function maskMongoUri(uri) {
+    return uri.replace(/^(mongodb(?:\+srv)?:\/\/)([^:]+):([^@]+)@/i, '$1$2:***@');
+}
+/**
+ * Tunnel-aware variant: when `tunnelId` is set, the connection is going to
+ * route through a customer-installed agent (`hostwh expose-tcp`), so the
+ * URI's host is the customer's local network — `localhost` / `127.0.0.1` /
+ * `192.168.x.x` are all expected and safe (they're THEIR localhost, not
+ * ours). Skip the SSRF check entirely.
+ *
+ * Without a tunnel, behave exactly like assertSafeMongoUri.
+ */
+async function assertSafeMongoUriUnlessTunneled(uri, tunnelId) {
+    if (tunnelId)
+        return;
+    await assertSafeMongoUri(uri);
+}
+/**
+ * Parse the host out of a `postgres://` or `postgresql://` URI. Postgres
+ * URIs are simpler than mongo — single host, optional port, no SRV.
+ */
+function extractPostgresHost(uri) {
+    let url;
+    try {
+        url = new URL(uri);
+    }
+    catch {
+        throw new common_1.ForbiddenException('Connection string is not a valid postgres:// URI');
+    }
+    if (url.protocol !== 'postgres:' && url.protocol !== 'postgresql:') {
+        throw new common_1.ForbiddenException('Connection string is not a valid postgres:// URI');
+    }
+    if (!url.hostname) {
+        throw new common_1.ForbiddenException('Connection string is missing a host');
+    }
+    // WHATWG URL keeps the brackets on an IPv6 host (`[::1]`), and with them
+    // the string is not an IP literal any more — it fell through to the DNS
+    // path, where it could only ever fail to resolve. Strip them so an IPv6
+    // postgres host is actually classified.
+    return url.hostname.replace(/^\[(.+)\]$/, '$1');
+}
+/**
+ * Throw if the postgres URI's host points at private / loopback /
+ * link-local addresses, OR if its DNS resolves there. Mirrors
+ * assertSafeMongoUri but with the simpler postgres URI grammar.
+ */
+async function assertSafePostgresUri(uri) {
+    const host = extractPostgresHost(uri);
+    const lowered = host.toLowerCase();
+    if (BLOCKED_HOSTNAMES.has(lowered)) {
+        throw new common_1.ForbiddenException(`Connection to ${host} is not allowed`);
+    }
+    if ((0, node_net_1.isIP)(host)) {
+        if (isPrivateIp(host)) {
+            throw new common_1.ForbiddenException(`Connection to private IP ${host} is not allowed`);
+        }
+        return;
+    }
+    let resolved;
+    try {
+        const v4 = await node_dns_1.promises.resolve4(host).catch(() => []);
+        const v6 = await node_dns_1.promises.resolve6(host).catch(() => []);
+        resolved = [...v4, ...v6];
+    }
+    catch {
+        throw new common_1.ForbiddenException(`Could not resolve host ${host}`);
+    }
+    if (resolved.length === 0) {
+        throw new common_1.ForbiddenException(`Could not resolve host ${host}`);
+    }
+    for (const ip of resolved) {
+        if (isPrivateIp(ip)) {
+            throw new common_1.ForbiddenException(`Host ${host} resolves to private IP ${ip} — refusing to connect`);
+        }
+    }
+}
+/**
+ * Tunnel-aware variant for postgres — same semantics as the mongo one.
+ * When tunnelId is set, the URI describes the customer's own network
+ * reachable through their `hostwh expose --tcp` agent, so private IPs
+ * are intentional and we skip the SSRF check.
+ */
+async function assertSafePostgresUriUnlessTunneled(uri, tunnelId) {
+    if (tunnelId)
+        return;
+    await assertSafePostgresUri(uri);
+}
+exports.URI_GUARD_FAMILY = {
+    mongodb: 'mongo',
+    memory_mongodb: 'mongo',
+    postgres: 'postgres',
+};
+/** True when this credential type carries a connection string we must guard. */
+function isGuardedUriCredential(type) {
+    return type in exports.URI_GUARD_FAMILY;
+}
+/**
+ * Los esquemas que puede llevar la URI de cada familia.
+ *
+ * Va aquí, junto a `URI_GUARD_FAMILY`, y no en un `if` suelto dentro del
+ * servicio: el tipo `Record<UriGuardFamily, …>` obliga a que una familia
+ * nueva declare los suyos o no compila, que es la misma disciplina que ya
+ * aplica el registro de guardias.
+ */
+exports.URI_SCHEMES = {
+    mongo: ['mongodb:', 'mongodb+srv:'],
+    postgres: ['postgres:', 'postgresql:'],
+};
+/** Cómo se llama cada familia cuando hay que decírselo a una persona. */
+const NOMBRE_DE_FAMILIA = {
+    mongo: 'MongoDB',
+    postgres: 'PostgreSQL',
+};
+/**
+ * El esquema tal y como está escrito, sin construir un `URL`.
+ *
+ * Se lee a mano a propósito: `new URL()` acepta cosas que aquí no queremos
+ * dar por buenas y, sobre todo, LANZA con una cadena sin esquema, y ese
+ * fallo hay que contarlo con nuestras palabras y no con las del motor.
+ */
+function esquemaDe(uri) {
+    /* Se exige el `://` entero, no sólo los dos puntos: sin eso, `localhost:27017`
+       hacía pasar `localhost` por esquema y el error hablaba de un inexistente
+       `localhost://` en vez de decir que ahí falta el esquema. Lo cazó su test. */
+    const encontrado = /^([a-zA-Z][a-zA-Z0-9+.-]*):[/][/]/.exec(uri.trim());
+    return encontrado ? `${encontrado[1].toLowerCase()}:` : null;
+}
+/**
+ * Que la cadena de conexión sea del producto que dice el tipo de credencial.
+ *
+ * Faltaba, y no se notaba porque los dos sitios que miraban la URI se
+ * rinden antes en el caso más común:
+ *
+ *  - el guardia SSRF vuelve en cuanto la credencial lleva `tunnelId`, porque
+ *    entonces la URI describe la red del propio cliente;
+ *  - la comprobación de la base de Mongo vuelve si no se tecleó ninguna.
+ *
+ * Con las dos condiciones a la vez —una credencial con túnel y sin base, que
+ * es justo lo que sale del flujo de túneles— NADIE llegaba a mirar la cadena.
+ * Una `postgres://` se guardaba como MongoDB sin una palabra, y el error
+ * aparecía mucho después dentro de un nodo, en boca del driver:
+ * «Connection string is not a valid mongodb:// URI», que no nombra lo único
+ * que hacía falta saber: que eso era de Postgres.
+ *
+ * Por eso esto NO mira el túnel ni la base: corre siempre.
+ */
+function assertUriSchemeMatchesType(type, uri) {
+    const familia = exports.URI_GUARD_FAMILY[type];
+    if (!familia)
+        return;
+    const esperados = exports.URI_SCHEMES[familia];
+    const comoSeEscribe = esperados.map((e) => `${e}//`).join(' or ');
+    const esquema = esquemaDe(uri);
+    if (!esquema) {
+        throw new common_1.BadRequestException(`That connection string has no scheme — a ${NOMBRE_DE_FAMILIA[familia]} credential starts with ${comoSeEscribe}`);
+    }
+    if (esperados.includes(esquema))
+        return;
+    /* Si el esquema es de otra familia que conocemos, se dice CUÁL y a dónde
+       llevarlo. Un «no vale» a secas deja a quien lo pegó buscando el error en
+       la contraseña o en el host, que es donde nadie lo tenía. */
+    const otra = Object.keys(exports.URI_SCHEMES).find((f) => f !== familia && exports.URI_SCHEMES[f].includes(esquema));
+    if (otra) {
+        throw new common_1.BadRequestException(`That is a ${NOMBRE_DE_FAMILIA[otra]} connection string (${esquema}//), but this credential is ${NOMBRE_DE_FAMILIA[familia]}. Create it as a ${NOMBRE_DE_FAMILIA[otra]} credential instead.`);
+    }
+    throw new common_1.BadRequestException(`"${esquema}//" is not a ${NOMBRE_DE_FAMILIA[familia]} connection string — expected ${comoSeEscribe}`);
+}
+/** Apply the right guard for a credential type. No-op for unguarded types. */
+async function assertSafeCredentialUri(type, uri) {
+    const family = exports.URI_GUARD_FAMILY[type];
+    if (!family)
+        return;
+    if (family === 'mongo')
+        await assertSafeMongoUri(uri);
+    else
+        await assertSafePostgresUri(uri);
+}
+/** As above, but a tunnelled credential describes the customer's own network. */
+async function assertSafeCredentialUriUnlessTunneled(type, uri, tunnelId) {
+    if (tunnelId)
+        return;
+    await assertSafeCredentialUri(type, uri);
+}
+/** Mask the password portion of a postgres URI for logs / UI. */
+function maskPostgresUri(uri) {
+    return uri.replace(/^(postgres(?:ql)?:\/\/)([^:]+):([^@]+)@/i, '$1$2:***@');
+}
+/**
+ * Parse the first host:port pair out of a `mongodb://` or
+ * `mongodb+srv://` URI. Used by the TCP forwarder + URI rewriter to
+ * know what target to register and what host:port to substitute with
+ * the local forwarder address.
+ *
+ * Returns the bare host (no port) plus the explicit port — defaulting
+ * to 27017 for `mongodb://` and to a synthetic 27017 for `mongodb+srv://`
+ * (SRV resolution is bypassed entirely when tunnelled, the agent talks
+ * to its target directly).
+ */
+function parseFirstMongoHost(uri) {
+    const match = /^mongodb(\+srv)?:\/\/(?:[^@/]*@)?([^/?]+)/i.exec(uri);
+    if (!match)
+        throw new Error('Connection string is not a valid mongodb:// URI');
+    const isSrv = !!match[1];
+    const firstHost = match[2]
+        .split(',')[0]
+        .trim()
+        .replace(/^\[/, '')
+        .replace(/\].*$/, '');
+    const portIdx = firstHost.lastIndexOf(':');
+    if (portIdx > 0 && /^\d+$/.test(firstHost.slice(portIdx + 1))) {
+        return {
+            host: firstHost.slice(0, portIdx),
+            port: Number(firstHost.slice(portIdx + 1)),
+        };
+    }
+    return { host: firstHost, port: isSrv ? 27017 : 27017 };
+}
+/**
+ * Replace the host(s) section of a Mongo URI with a single host:port.
+ * Preserves user:pass, path (database), and querystring. Forces the
+ * scheme to `mongodb://` (drops `+srv`) because the rewritten URI
+ * points at our local forwarder, not an SRV-resolvable hostname.
+ *
+ * Also drops the `tls`, `ssl`, and `replicaSet` query params — they
+ * would cause the driver to negotiate TLS with our local plaintext
+ * forwarder. The agent talks to its real Atlas with TLS on its end.
+ */
+function rewriteMongoUriHost(uri, host, port) {
+    // Match: scheme://[user:pass@]hosts[/db?query]
+    const m = /^mongodb(?:\+srv)?:\/\/(?:([^@/]*)@)?([^/?]+)(\/[^?]*)?(\?.*)?$/i.exec(uri);
+    if (!m)
+        throw new Error('Connection string is not a valid mongodb:// URI');
+    const userInfo = m[1];
+    const path = m[3] ?? '';
+    let query = m[4] ?? '';
+    if (query) {
+        // Drop tls/ssl/replicaSet — incompatible with our plaintext forwarder.
+        const params = new URLSearchParams(query.slice(1));
+        for (const k of [
+            'tls',
+            'ssl',
+            'replicaSet',
+            'tlsCAFile',
+            'tlsCertificateKeyFile',
+        ]) {
+            params.delete(k);
+        }
+        const remaining = params.toString();
+        query = remaining ? `?${remaining}` : '';
+    }
+    const auth = userInfo ? `${userInfo}@` : '';
+    return `mongodb://${auth}${host}:${port}${path}${query}`;
+}
+/**
+ * Parse the first host:port pair out of a `postgres://` /
+ * `postgresql://` URI. Same role as `parseFirstMongoHost` — the TCP
+ * forwarder needs to know what host:port to register against the
+ * tunnel, and the URI rewriter needs to know what to swap out.
+ *
+ * Postgres URIs only ever name one host (no comma list, no `+srv`
+ * sibling), but we still parse the userinfo correctly so passwords
+ * containing `@` (URL-encoded as `%40`) don't get treated as host
+ * delimiters.
+ */
+function parseFirstPostgresHost(uri) {
+    const match = /^postgres(?:ql)?:\/\/(?:[^@/]*@)?([^/?]+)/i.exec(uri);
+    if (!match)
+        throw new Error('Connection string is not a valid postgres:// URI');
+    const firstHost = match[1].trim().replace(/^\[/, '').replace(/\].*$/, '');
+    const portIdx = firstHost.lastIndexOf(':');
+    if (portIdx > 0 && /^\d+$/.test(firstHost.slice(portIdx + 1))) {
+        return {
+            host: firstHost.slice(0, portIdx),
+            port: Number(firstHost.slice(portIdx + 1)),
+        };
+    }
+    return { host: firstHost, port: 5432 };
+}
+/**
+ * Replace the host:port of a Postgres URI with the local forwarder
+ * address. Same idea as `rewriteMongoUriHost`: the local forwarder is
+ * plaintext (the agent restores TLS on its end of the wire), so any
+ * SSL-related query params would cause the driver to negotiate TLS
+ * against the wrong webhook and fail. Drop them.
+ *
+ * Preserves userinfo + path (the database name lives in the path) +
+ * remaining querystring. Also forces scheme to `postgres://` (drops
+ * `postgresql://` to one canonical form).
+ */
+/**
+ * Qué base declara una URI de Postgres en su ruta, o `null` si no declara
+ * ninguna —en ese caso el driver cae a la base con el nombre del usuario—.
+ *
+ * Se decodifica porque `rewritePostgresUriDatabase` codifica al escribir: sin
+ * esto, comparar «lo que había» con «lo que se pide» diría que `mi base` y
+ * `mi%20base` son distintas y registraría un cambio que no existe.
+ */
+function baseDeLaUri(uri) {
+    const m = /^postgres(?:ql)?:\/\/(?:[^@/]*@)?[^/?]+\/([^?]*)/i.exec(uri);
+    if (!m || !m[1])
+        return null;
+    try {
+        return decodeURIComponent(m[1]) || null;
+    }
+    catch {
+        return m[1] || null;
+    }
+}
+/**
+ * Cambiar la base de datos de una URI de Postgres — la que va en la ruta.
+ *
+ * En Mongo la base se elige con `client.db(nombre)` sobre una conexión ya
+ * abierta. En Postgres **no existe eso**: la base se decide al conectarse y
+ * viene en la URI, así que respetar el `databaseName` de un nodo obliga a
+ * reescribirla aquí. Ésa es la razón de que `databaseName` estuviera muerto en
+ * `postgres-actions.service.ts` — se calculaba y no se podía aplicar sin esto.
+ *
+ * Se conserva el esquema tal cual llegó (`postgres://` o `postgresql://`), el
+ * userinfo, el host y el querystring; sólo cambia la ruta. El nombre se
+ * codifica porque una base puede llevar caracteres que en una URI significan
+ * otra cosa, y sin codificar `mi base` o `a/b` producirían una URI distinta de
+ * la que se pidió.
+ *
+ * Con `database` vacío devuelve la URI intacta: quien llama decide si hay algo
+ * que aplicar.
+ */
+function rewritePostgresUriDatabase(uri, database) {
+    const nombre = (database ?? '').trim();
+    if (!nombre)
+        return uri;
+    const m = /^(postgres(?:ql)?):\/\/(?:([^@/]*)@)?([^/?]+)(\/[^?]*)?(\?.*)?$/i.exec(uri);
+    if (!m)
+        throw new Error('Connection string is not a valid postgres:// URI');
+    const esquema = m[1];
+    const auth = m[2] ? `${m[2]}@` : '';
+    const hostPuerto = m[3];
+    const query = m[5] ?? '';
+    return `${esquema}://${auth}${hostPuerto}/${encodeURIComponent(nombre)}${query}`;
+}
+function rewritePostgresUriHost(uri, host, port) {
+    const m = /^postgres(?:ql)?:\/\/(?:([^@/]*)@)?([^/?]+)(\/[^?]*)?(\?.*)?$/i.exec(uri);
+    if (!m)
+        throw new Error('Connection string is not a valid postgres:// URI');
+    const userInfo = m[1];
+    const path = m[3] ?? '';
+    let query = m[4] ?? '';
+    if (query) {
+        const params = new URLSearchParams(query.slice(1));
+        for (const k of [
+            'sslmode',
+            'sslrootcert',
+            'sslcert',
+            'sslkey',
+            'sslpassword',
+            'sslcrl',
+            'sslcrldir',
+        ]) {
+            params.delete(k);
+        }
+        const remaining = params.toString();
+        query = remaining ? `?${remaining}` : '';
+    }
+    const auth = userInfo ? `${userInfo}@` : '';
+    return `postgres://${auth}${host}:${port}${path}${query}`;
+}
+/* ── Salida HTTP ────────────────────────────────────────────────────────── */
+/**
+ * El guard para las URLs de entrega, que hasta ahora no tenía ninguno.
+ *
+ * ## El fallo que cierra
+ *
+ * `webhook.targetUrl` llegaba al POST saliente sin tocar. Su única validación
+ * era `@IsUrl({ require_tld: false })`, y el validador instalado acepta una IP
+ * pelada sin lista negra, así que loopback, link-local y privadas pasaban.
+ * `fallbackUrls` llevaba sólo `@IsString({ each: true })` y llegaba al mismo
+ * sitio sin ninguna comprobación de URL. Este fichero existía, pero estaba
+ * cableado únicamente a las rutas de credenciales Mongo y Postgres.
+ *
+ * Con `validateStatus: () => true` la respuesta interna se conservaba, se
+ * persistía en el registro de entrega y —en modo `sync`— volvía inline a quien
+ * publicó. Eso es descubrimiento de red interna con lectura de vuelta, desde
+ * una cuenta de alta libre.
+ *
+ * ## Por qué se puede bloquear sin romper a nadie
+ *
+ * La entrega a la red local del cliente ya tiene su propio camino: el
+ * procesador comprueba `hasTunnel(webhookId)` y entrega por el túnel; el POST
+ * directo es la rama `else`. Así que el destino privado legítimo va por
+ * `hostwh expose` y no por aquí.
+ */
+/** Sólo estos esquemas. `file:`, `gopher:` y compañía no son destinos de
+ *  entrega, y algunos son primitivas de lectura local. */
+const ESQUEMAS_DE_ENTREGA = new Set(['http:', 'https:']);
+/** Igual que `isPrivateIp`, expuesto para quien tenga ya la IP resuelta. */
+function isPrivateAddress(ip) {
+    return isPrivateIp(ip);
+}
+/**
+ * Rechaza una URL de entrega que apunte adentro.
+ *
+ * Comprueba esquema, nombres bloqueados, IP literal y —cuando es un nombre— lo
+ * que resuelve AHORA. Esa resolución es la foto previa; lo que de verdad ata la
+ * dirección comprobada a la dirección marcada es el hook de `agentesDeEntrega`,
+ * porque entre esta consulta y el socket cabe un cambio de DNS.
+ */
+async function assertSafeHttpUrl(rawUrl) {
+    let url;
+    try {
+        url = new URL(rawUrl);
+    }
+    catch {
+        throw new common_1.ForbiddenException(`Delivery URL is not a valid URL: ${rawUrl}`);
+    }
+    if (!ESQUEMAS_DE_ENTREGA.has(url.protocol)) {
+        throw new common_1.ForbiddenException(`Delivery URL scheme "${url.protocol}" is not allowed — use http or https`);
+    }
+    // WHATWG URL conserva los corchetes de un host IPv6; con ellos la cadena no
+    // es una IP literal y caería al camino de DNS.
+    const host = url.hostname.replace(/^\[(.+)\]$/, '$1');
+    if (!host)
+        throw new common_1.ForbiddenException('Delivery URL is missing a host');
+    if (BLOCKED_HOSTNAMES.has(host.toLowerCase())) {
+        throw new common_1.ForbiddenException(`Delivery to ${host} is not allowed`);
+    }
+    if ((0, node_net_1.isIP)(host)) {
+        if (isPrivateIp(host)) {
+            throw new common_1.ForbiddenException(`Delivery to private IP ${host} is not allowed`);
+        }
+        return;
+    }
+    const v4 = await node_dns_1.promises.resolve4(host).catch(() => []);
+    const v6 = await node_dns_1.promises.resolve6(host).catch(() => []);
+    const resueltas = [...v4, ...v6];
+    if (resueltas.length === 0) {
+        throw new common_1.ForbiddenException(`Could not resolve delivery host ${host}`);
+    }
+    for (const ip of resueltas) {
+        if (isPrivateIp(ip)) {
+            throw new common_1.ForbiddenException(`Delivery host ${host} resolves to private IP ${ip} — refusing to connect`);
+        }
+    }
+}
+/**
+ * Agentes cuyo `lookup` vuelve a comprobar cada dirección resuelta.
+ *
+ * Ésta es la parte que cierra el rebinding: entre la comprobación de arriba y
+ * el socket cabe un cambio de DNS, así que la dirección se valida **en el
+ * momento de marcarla**, dentro del propio `lookup`.
+ *
+ * OJO con lo que este `lookup` NO cubre: sólo corre cuando hay un nombre que
+ * resolver. Si el host ya es una IP literal, Node se salta el DNS y esto no
+ * llega a ejecutarse — de ahí `conectorQueRechazaPrivadas`, más abajo, que
+ * mira todas las conexiones. Aquí decía que valía «para cada salto de una
+ * redirección»; no era verdad, y por ahí se colaba un 302 hacia una literal.
+ *
+ * Se comprueba aquí y no resolviendo a mano para conectar a la IP: conectar a
+ * la IP obliga a rehacer SNI y la cabecera Host, y eso rompe cualquier destino
+ * en hosting compartido o detrás de un CDN.
+ */
+function lookupQueRechazaPrivadas(hostname, options, callback) {
+    node_dns_1.lookup(hostname, options, (err, address, family) => {
+        if (err)
+            return callback(err, address, family);
+        const direcciones = Array.isArray(address)
+            ? address.map((a) => a.address)
+            : [String(address)];
+        const adentro = direcciones.find((ip) => isPrivateIp(ip));
+        if (adentro) {
+            return callback(Object.assign(new Error(`refusing to connect to private address ${adentro} for ${hostname}`), { code: 'ESSRFBLOCKED' }), address, family);
+        }
+        callback(null, address, family);
+    });
+}
+/**
+ * Mira el host de UNA conexión, y lanza si es una privada literal.
+ *
+ * ## El agujero que tapa, que es el mismo que ya tenía `fetch`
+ *
+ * `lookupQueRechazaPrivadas` sólo corre cuando hay un nombre que resolver. Si
+ * el host ya es una IP literal, Node se salta el DNS entero y el `lookup` no
+ * llega a ejecutarse. Para `fetch` eso lo cierra `conectorQueRechazaPrivadas`
+ * (undici), y desde entonces este fichero decía que estaba cubierto — pero
+ * **sólo para undici**. Los agentes de `node:http`, que son los que usan axios
+ * y por tanto el nodo HTTP y el procesador de entregas, se quedaron sin
+ * equivalente.
+ *
+ * Por ahí entra lo de siempre:
+ *
+ *     el atacante pide  https://loquesea.suyo/x   (público, pasa el chequeo)
+ *     su servidor responde  302 Location: http://169.254.169.254/latest/...
+ *
+ * y ese salto abre su propia conexión, contra una literal, sin DNS. También
+ * entra un endpoint escrito a mano que YA sea una IP privada en cualquier
+ * cliente que use estos agentes sin llamar antes a `assertSafeHttpUrl`.
+ *
+ * ## Por qué envolver `createConnection` y no pasar una opción
+ *
+ * `http.Agent` no tiene un gancho de «antes de conectar»: `lookup` es lo más
+ * parecido y ya vimos que no basta. `createConnection` es el único punto por
+ * el que pasan TODAS las conexiones del agente, con o sin nombre, y es
+ * público y documentado. Se envuelve el del prototipo en vez de reescribirlo
+ * para no perder el manejo de sesiones TLS de `https.Agent`.
+ */
+function conConectorQueRechazaPrivadas(agente) {
+    const original = agente.createConnection.bind(agente);
+    agente.createConnection = ((opciones, callback) => {
+        // Node conserva los corchetes de un host IPv6; con ellos la cadena no es
+        // una IP literal y el `isIP` diría que no. Mismo detalle que en undici.
+        const host = String(opciones?.host ?? '').replace(/^\[(.+)\]$/, '$1');
+        if ((0, node_net_1.isIP)(host) && isPrivateIp(host)) {
+            const fallo = Object.assign(new Error(`Delivery to private IP ${host} is not allowed`), { code: 'ESSRFBLOCKED' });
+            /* Por el callback cuando lo hay: es como `Agent.createSocket` espera el
+               fallo, y lanzar ahí dentro lo convertiría en una excepción sin
+               capturar en vez de en un error de la petición. */
+            if (callback) {
+                callback(fallo);
+                return undefined;
+            }
+            throw fallo;
+        }
+        return original(opciones, callback);
+    });
+    return agente;
+}
+let agentes = null;
+/** Los agentes de salida de la entrega. Se crean una vez: llevan pool de
+ *  conexiones y uno por petición lo tiraría.
+ *
+ *  Llevan las DOS capas: el `lookup` para los nombres y el conector para todo
+ *  lo demás. Ninguna sobra — ver `conConectorQueRechazaPrivadas`. */
+function agentesDeEntrega() {
+    if (!agentes) {
+        const opciones = {
+            keepAlive: true,
+            lookup: lookupQueRechazaPrivadas,
+        };
+        agentes = {
+            httpAgent: conConectorQueRechazaPrivadas(new http.Agent(opciones)),
+            httpsAgent: conConectorQueRechazaPrivadas(new https.Agent(opciones)),
+        };
+    }
+    return agentes;
+}
+/**
+ * Lo mismo que `agentesDeEntrega`, pero para `fetch`.
+ *
+ * `agentesDeEntrega` devuelve agentes de `node:http`, que es lo que usa axios.
+ * El `fetch` global no los mira: va por undici, que tiene su propio
+ * despachador. Sin esto, los sitios escritos con `fetch` se quedaban fuera del
+ * guardia — que es exactamente lo que pasaba, y por eso este fichero llevaba
+ * meses cableado sólo al procesador de entregas.
+ *
+ * El `lookup` es EL MISMO que el de los agentes, así que la regla de qué es
+ * una dirección de adentro se escribe una sola vez.
+ */
+let despachador = null;
+/**
+ * El conector que mira CADA conexión, también cuando el host ya es una IP.
+ *
+ * El `lookup` de arriba sólo se consulta cuando hay un nombre que resolver:
+ * si el host ya es una IP literal, Node se salta el DNS entero y el `lookup`
+ * no llega a correr. Eso dejaba abierto el salto de una redirección, que es
+ * donde más duele, porque la primera URL sí pasa por `assertSafeHttpUrl` pero
+ * las siguientes las elige quien conteste:
+ *
+ *     el atacante pide  https://loquesea.suyo/x   (público de verdad, pasa)
+ *     su servidor responde  302 Location: http://169.254.169.254/latest/...
+ *     y ese salto entraba, porque no hay nombre que resolver.
+ *
+ * El conector, en cambio, corre una vez por conexión y cada salto abre la
+ * suya, así que aquí sí se ve. Para los nombres sigue mandando el `lookup`
+ * de siempre — misma regla, un solo sitio donde se escribe.
+ */
+const conectorQueRechazaPrivadas = (() => {
+    let base = null;
+    return (opciones, callback) => {
+        base ??= (0, undici_1.buildConnector)({ lookup: lookupQueRechazaPrivadas });
+        // undici conserva los corchetes de un host IPv6; sin quitarlos la cadena
+        // no es una IP literal y el `isIP` de abajo diría que no.
+        const host = String(opciones.hostname ?? '').replace(/^\[(.+)\]$/, '$1');
+        if ((0, node_net_1.isIP)(host) && isPrivateIp(host)) {
+            callback(Object.assign(new Error(`Delivery to private IP ${host} is not allowed`), { code: 'ESSRFBLOCKED' }), null);
+            return;
+        }
+        return base(opciones, callback);
+    };
+})();
+function despachadorDeSalida() {
+    if (!despachador) {
+        despachador = new undici_1.Agent({ connect: conectorQueRechazaPrivadas });
+    }
+    return despachador;
+}
+/**
+ * `fetch` con el guardia puesto: comprueba la URL antes de salir y resuelve
+ * por el despachador que rechaza direcciones privadas, así que un DNS que
+ * cambie entre la comprobación y el socket tampoco entra.
+ *
+ * Es el reemplazo de una palabra para cualquier `fetch` que salga a una URL
+ * que haya elegido un inquilino.
+ */
+async function fetchSeguro(url, init) {
+    await assertSafeHttpUrl(url);
+    return fetch(url, {
+        ...init,
+        dispatcher: despachadorDeSalida(),
+    });
+}