whale-code 6.5.4 → 6.5.6

package/dist/server/lib/ssrf-guard.js

@@ -2,38 +2,47 @@
 //
 // Used by workflow steps (webhook_out, custom), email attachments, and any other
 // user-controlled URL fetching. Centralizes all IP blocking logic in one place.
+
 import { resolve as dnsResolve } from "node:dns/promises";
+
 // Private/internal IPv4 ranges
-const PRIVATE_IPV4_RANGES = [
-    /^127\./, // Loopback
-    /^10\./, // RFC 1918
-    /^172\.(1[6-9]|2\d|3[01])\./, // RFC 1918
-    /^192\.168\./, // RFC 1918
-    /^169\.254\./, // Link-local / cloud metadata
-    /^0\./, // "This" network
-    /^100\.(6[4-9]|[7-9]\d|1[0-1]\d|12[0-7])\./, // CGNAT (RFC 6598)
-    /^198\.18\./, // Benchmarking (RFC 2544)
+const PRIVATE_IPV4_RANGES = [/^127\./,
+// Loopback
+/^10\./,
+// RFC 1918
+/^172\.(1[6-9]|2\d|3[01])\./,
+// RFC 1918
+/^192\.168\./,
+// RFC 1918
+/^169\.254\./,
+// Link-local / cloud metadata
+/^0\./,
+// "This" network
+/^100\.(6[4-9]|[7-9]\d|1[0-1]\d|12[0-7])\./,
+// CGNAT (RFC 6598)
+/^198\.18\./ // Benchmarking (RFC 2544)
 ];
+
 // IPv6-mapped IPv4 patterns
 // Dotted decimal form: ::ffff:127.0.0.1
 const IPV6_MAPPED_V4 = /^::ffff:(\d+\.\d+\.\d+\.\d+)$/i;
 // Hex form (URL parser normalizes to this): ::ffff:7f00:1
 const IPV6_MAPPED_V4_HEX = /^::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/i;
+
 // Private/internal IPv6 ranges
-const PRIVATE_IPV6_PATTERNS = [
-    /^::1$/, // Loopback
-    /^fe80:/i, // Link-local
-    /^fc00:/i, // Unique local
-    /^fd/i, // Unique local
-    /^::$/, // Unspecified address
+const PRIVATE_IPV6_PATTERNS = [/^::1$/,
+// Loopback
+/^fe80:/i,
+// Link-local
+/^fc00:/i,
+// Unique local
+/^fd/i,
+// Unique local
+/^::$/ // Unspecified address
 ];
-const BLOCKED_HOSTS = new Set([
-    "localhost",
-    "0.0.0.0",
-    "metadata.google.internal",
-    "metadata.internal",
-]);
+const BLOCKED_HOSTS = new Set(["localhost", "0.0.0.0", "metadata.google.internal", "metadata.internal"]);
 const BLOCKED_TLDS = [".internal", ".local", ".localhost"];
+
 /**
  * P0 FIX: Normalize alternative IP encodings to standard dotted-decimal.
  * Catches bypass attempts via decimal, hex, octal, and mixed representations:
@@ -46,107 +55,109 @@ const BLOCKED_TLDS = [".internal", ".local", ".localhost"];
  * Returns the normalized dotted-decimal string, or null if not a recognizable IP.
  */
 function normalizeIp(input) {
-    const cleaned = input.trim();
-    // Case 1: Pure decimal integer (e.g. 2130706433 = 127.0.0.1)
-    if (/^\d{1,10}$/.test(cleaned) && !cleaned.startsWith("0")) {
-        const num = parseInt(cleaned, 10);
-        if (num >= 0 && num <= 0xffffffff) {
-            return `${(num >>> 24) & 0xff}.${(num >>> 16) & 0xff}.${(num >>> 8) & 0xff}.${num & 0xff}`;
-        }
-    }
-    // Case 2: Pure hex integer (e.g. 0x7f000001)
-    if (/^0x[0-9a-f]+$/i.test(cleaned)) {
-        const num = parseInt(cleaned, 16);
-        if (num >= 0 && num <= 0xffffffff) {
-            return `${(num >>> 24) & 0xff}.${(num >>> 16) & 0xff}.${(num >>> 8) & 0xff}.${num & 0xff}`;
-        }
-    }
-    // Case 3: Dotted form with octal/hex/decimal octets (e.g. 0177.0.0.01, 0x7f.0.0.1)
-    const parts = cleaned.split(".");
-    if (parts.length === 4) {
-        const octets = [];
-        for (const part of parts) {
-            let val;
-            if (/^0x[0-9a-f]+$/i.test(part)) {
-                // Hex octet
-                val = parseInt(part, 16);
-            }
-            else if (/^0\d+$/.test(part)) {
-                // Octal octet (leading zero)
-                val = parseInt(part, 8);
-            }
-            else if (/^\d+$/.test(part)) {
-                // Decimal octet
-                val = parseInt(part, 10);
-            }
-            else {
-                return null; // Not a valid octet
-            }
-            if (isNaN(val) || val < 0 || val > 255)
-                return null;
-            octets.push(val);
-        }
-        return octets.join(".");
-    }
-    return null;
+  const cleaned = input.trim();
+
+  // Case 1: Pure decimal integer (e.g. 2130706433 = 127.0.0.1)
+  if (/^\d{1,10}$/.test(cleaned) && !cleaned.startsWith("0")) {
+    const num = parseInt(cleaned, 10);
+    if (num >= 0 && num <= 0xffffffff) {
+      return `${num >>> 24 & 0xff}.${num >>> 16 & 0xff}.${num >>> 8 & 0xff}.${num & 0xff}`;
+    }
+  }
+
+  // Case 2: Pure hex integer (e.g. 0x7f000001)
+  if (/^0x[0-9a-f]+$/i.test(cleaned)) {
+    const num = parseInt(cleaned, 16);
+    if (num >= 0 && num <= 0xffffffff) {
+      return `${num >>> 24 & 0xff}.${num >>> 16 & 0xff}.${num >>> 8 & 0xff}.${num & 0xff}`;
+    }
+  }
+
+  // Case 3: Dotted form with octal/hex/decimal octets (e.g. 0177.0.0.01, 0x7f.0.0.1)
+  const parts = cleaned.split(".");
+  if (parts.length === 4) {
+    const octets = [];
+    for (const part of parts) {
+      let val;
+      if (/^0x[0-9a-f]+$/i.test(part)) {
+        // Hex octet
+        val = parseInt(part, 16);
+      } else if (/^0\d+$/.test(part)) {
+        // Octal octet (leading zero)
+        val = parseInt(part, 8);
+      } else if (/^\d+$/.test(part)) {
+        // Decimal octet
+        val = parseInt(part, 10);
+      } else {
+        return null; // Not a valid octet
+      }
+      if (isNaN(val) || val < 0 || val > 255) return null;
+      octets.push(val);
+    }
+    return octets.join(".");
+  }
+  return null;
 }
+
 /**
  * Check if an IP address is in a private/internal range.
  * P0 FIX: Now normalizes alternative IP encodings before checking.
  */
 function isPrivateIp(ip) {
-    // Strip brackets from IPv6
-    const cleaned = ip.replace(/^\[|\]$/g, "");
-    // Check IPv6-mapped IPv4 — dotted decimal form (::ffff:x.x.x.x)
-    const mapped = cleaned.match(IPV6_MAPPED_V4);
-    if (mapped) {
-        const v4 = mapped[1];
-        const normalized = normalizeIp(v4) || v4;
-        return PRIVATE_IPV4_RANGES.some((r) => r.test(normalized));
-    }
-    // Check IPv6-mapped IPv4 — hex form (::ffff:7f00:1, as normalized by URL parser)
-    const mappedHex = cleaned.match(IPV6_MAPPED_V4_HEX);
-    if (mappedHex) {
-        const hi = parseInt(mappedHex[1], 16);
-        const lo = parseInt(mappedHex[2], 16);
-        const v4 = `${(hi >> 8) & 0xff}.${hi & 0xff}.${(lo >> 8) & 0xff}.${lo & 0xff}`;
-        return PRIVATE_IPV4_RANGES.some((r) => r.test(v4));
-    }
-    // P0 FIX: Normalize alternative encodings (decimal, hex, octal, mixed)
-    const normalized = normalizeIp(cleaned);
-    if (normalized) {
-        return PRIVATE_IPV4_RANGES.some((r) => r.test(normalized));
-    }
-    // Check plain IPv4 (standard dotted decimal — no leading zeros)
-    if (/^\d+\.\d+\.\d+\.\d+$/.test(cleaned)) {
-        return PRIVATE_IPV4_RANGES.some((r) => r.test(cleaned));
-    }
-    // Check IPv6
-    return PRIVATE_IPV6_PATTERNS.some((r) => r.test(cleaned));
+  // Strip brackets from IPv6
+  const cleaned = ip.replace(/^\[|\]$/g, "");
+
+  // Check IPv6-mapped IPv4 — dotted decimal form (::ffff:x.x.x.x)
+  const mapped = cleaned.match(IPV6_MAPPED_V4);
+  if (mapped) {
+    const v4 = mapped[1];
+    const normalized = normalizeIp(v4) || v4;
+    return PRIVATE_IPV4_RANGES.some(r => r.test(normalized));
+  }
+
+  // Check IPv6-mapped IPv4 — hex form (::ffff:7f00:1, as normalized by URL parser)
+  const mappedHex = cleaned.match(IPV6_MAPPED_V4_HEX);
+  if (mappedHex) {
+    const hi = parseInt(mappedHex[1], 16);
+    const lo = parseInt(mappedHex[2], 16);
+    const v4 = `${hi >> 8 & 0xff}.${hi & 0xff}.${lo >> 8 & 0xff}.${lo & 0xff}`;
+    return PRIVATE_IPV4_RANGES.some(r => r.test(v4));
+  }
+
+  // P0 FIX: Normalize alternative encodings (decimal, hex, octal, mixed)
+  const normalized = normalizeIp(cleaned);
+  if (normalized) {
+    return PRIVATE_IPV4_RANGES.some(r => r.test(normalized));
+  }
+
+  // Check plain IPv4 (standard dotted decimal — no leading zeros)
+  if (/^\d+\.\d+\.\d+\.\d+$/.test(cleaned)) {
+    return PRIVATE_IPV4_RANGES.some(r => r.test(cleaned));
+  }
+
+  // Check IPv6
+  return PRIVATE_IPV6_PATTERNS.some(r => r.test(cleaned));
 }
+
 /**
  * Check if a hostname looks like a direct IP address (v4, v6, or alternative encoding).
  * Used to decide whether DNS failure should block or allow.
  */
 function looksLikeIp(host) {
-    const cleaned = host.replace(/^\[|\]$/g, "");
-    // Standard dotted decimal
-    if (/^\d+\.\d+\.\d+\.\d+$/.test(cleaned))
-        return true;
-    // Pure decimal integer
-    if (/^\d{1,10}$/.test(cleaned))
-        return true;
-    // Hex integer
-    if (/^0x[0-9a-f]+$/i.test(cleaned))
-        return true;
-    // Dotted with octal/hex octets
-    if (/^[\d.x]+$/i.test(cleaned) && cleaned.split(".").length === 4)
-        return true;
-    // IPv6 (contains colons)
-    if (cleaned.includes(":"))
-        return true;
-    return false;
+  const cleaned = host.replace(/^\[|\]$/g, "");
+  // Standard dotted decimal
+  if (/^\d+\.\d+\.\d+\.\d+$/.test(cleaned)) return true;
+  // Pure decimal integer
+  if (/^\d{1,10}$/.test(cleaned)) return true;
+  // Hex integer
+  if (/^0x[0-9a-f]+$/i.test(cleaned)) return true;
+  // Dotted with octal/hex octets
+  if (/^[\d.x]+$/i.test(cleaned) && cleaned.split(".").length === 4) return true;
+  // IPv6 (contains colons)
+  if (cleaned.includes(":")) return true;
+  return false;
 }
+
 /**
  * Validate a URL is safe to fetch (not targeting internal/private addresses).
  * Does basic hostname checks first, then resolves DNS to catch rebinding attacks.
@@ -154,87 +165,85 @@ function looksLikeIp(host) {
  * @returns null if safe, or a string error message if blocked.
  */
 export async function validateUrl(urlStr) {
-    let u;
-    try {
-        u = new URL(urlStr);
-    }
-    catch {
-        return "Malformed URL";
-    }
-    // Block non-HTTP(S) schemes
-    if (u.protocol !== "http:" && u.protocol !== "https:") {
-        return `Blocked scheme: ${u.protocol}`;
-    }
-    const host = u.hostname.toLowerCase();
-    // Block known internal hostnames
-    if (BLOCKED_HOSTS.has(host)) {
-        return "URL targets a blocked internal host";
-    }
-    // Block internal TLDs
-    for (const tld of BLOCKED_TLDS) {
-        if (host.endsWith(tld)) {
-            return "URL targets a blocked internal domain";
-        }
-    }
-    // Block .fly.dev (our own infrastructure)
-    if (host.endsWith(".fly.dev")) {
-        return "URL targets internal infrastructure";
-    }
-    // Block bare IPs that resolve to private ranges (including alternative encodings)
-    if (isPrivateIp(host)) {
-        return "URL targets a private/internal IP address";
-    }
-    // DNS resolve-then-check: catch DNS rebinding attacks
-    try {
-        const addresses = await dnsResolve(host);
-        for (const addr of addresses) {
-            if (isPrivateIp(addr)) {
-                return `DNS resolved to private address: ${addr}`;
-            }
-        }
-    }
-    catch {
-        // P0 FIX: DNS resolution failed — only allow through if host is already a
-        // validated direct IP (which was checked above). If it's a hostname that
-        // failed DNS, block it: we can't verify where it points.
-        if (!looksLikeIp(host)) {
-            return "DNS resolution failed — cannot verify target is safe";
-        }
-        // Direct IP that passed isPrivateIp check above — safe to proceed
-    }
-    return null;
+  let u;
+  try {
+    u = new URL(urlStr);
+  } catch {
+    return "Malformed URL";
+  }
+
+  // Block non-HTTP(S) schemes
+  if (u.protocol !== "http:" && u.protocol !== "https:") {
+    return `Blocked scheme: ${u.protocol}`;
+  }
+  const host = u.hostname.toLowerCase();
+
+  // Block known internal hostnames
+  if (BLOCKED_HOSTS.has(host)) {
+    return "URL targets a blocked internal host";
+  }
+
+  // Block internal TLDs
+  for (const tld of BLOCKED_TLDS) {
+    if (host.endsWith(tld)) {
+      return "URL targets a blocked internal domain";
+    }
+  }
+
+  // Block .fly.dev (our own infrastructure)
+  if (host.endsWith(".fly.dev")) {
+    return "URL targets internal infrastructure";
+  }
+
+  // Block bare IPs that resolve to private ranges (including alternative encodings)
+  if (isPrivateIp(host)) {
+    return "URL targets a private/internal IP address";
+  }
+
+  // DNS resolve-then-check: catch DNS rebinding attacks
+  try {
+    const addresses = await dnsResolve(host);
+    for (const addr of addresses) {
+      if (isPrivateIp(addr)) {
+        return `DNS resolved to private address: ${addr}`;
+      }
+    }
+  } catch {
+    // P0 FIX: DNS resolution failed — only allow through if host is already a
+    // validated direct IP (which was checked above). If it's a hostname that
+    // failed DNS, block it: we can't verify where it points.
+    if (!looksLikeIp(host)) {
+      return "DNS resolution failed — cannot verify target is safe";
+    }
+    // Direct IP that passed isPrivateIp check above — safe to proceed
+  }
+  return null;
 }
+
 /**
  * Synchronous fast-path check (no DNS resolution).
  * Use this when you can't await, or for backward compatibility.
  * For full protection (including DNS rebinding), use validateUrl().
  */
 export function isBlockedUrl(urlStr) {
-    try {
-        const u = new URL(urlStr);
-        const host = u.hostname.toLowerCase();
-        if (BLOCKED_HOSTS.has(host) || host === "127.0.0.1" || host === "::1" || host === "[::1]")
-            return true;
-        if (PRIVATE_IPV4_RANGES.some((r) => r.test(host)))
-            return true;
-        if (PRIVATE_IPV6_PATTERNS.some((r) => r.test(host.replace(/^\[|\]$/g, ""))))
-            return true;
-        // P0 FIX: Check alternative IP encodings (decimal, hex, octal)
-        if (isPrivateIp(host))
-            return true;
-        if (host === "169.254.169.254")
-            return true;
-        for (const tld of BLOCKED_TLDS) {
-            if (host.endsWith(tld))
-                return true;
-        }
-        if (host.endsWith(".fly.dev"))
-            return true;
-        if (u.protocol !== "http:" && u.protocol !== "https:")
-            return true;
-        return false;
-    }
-    catch {
-        return true;
+  try {
+    const u = new URL(urlStr);
+    const host = u.hostname.toLowerCase();
+    if (BLOCKED_HOSTS.has(host) || host === "127.0.0.1" || host === "::1" || host === "[::1]") return true;
+    if (PRIVATE_IPV4_RANGES.some(r => r.test(host))) return true;
+    if (PRIVATE_IPV6_PATTERNS.some(r => r.test(host.replace(/^\[|\]$/g, "")))) return true;
+
+    // P0 FIX: Check alternative IP encodings (decimal, hex, octal)
+    if (isPrivateIp(host)) return true;
+    if (host === "169.254.169.254") return true;
+    for (const tld of BLOCKED_TLDS) {
+      if (host.endsWith(tld)) return true;
     }
+    if (host.endsWith(".fly.dev")) return true;
+    if (u.protocol !== "http:" && u.protocol !== "https:") return true;
+    return false;
+  } catch {
+    return true;
+  }
 }
+//# sourceMappingURL=ssrf-guard.js.map

package/dist/server/lib/ssrf-guard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ssrf-guard.js","names":["resolve","dnsResolve","PRIVATE_IPV4_RANGES","IPV6_MAPPED_V4","IPV6_MAPPED_V4_HEX","PRIVATE_IPV6_PATTERNS","BLOCKED_HOSTS","Set","BLOCKED_TLDS","normalizeIp","input","cleaned","trim","test","startsWith","num","parseInt","parts","split","length","octets","part","val","isNaN","push","join","isPrivateIp","ip","replace","mapped","match","v4","normalized","some","r","mappedHex","hi","lo","looksLikeIp","host","includes","validateUrl","urlStr","u","URL","protocol","hostname","toLowerCase","has","tld","endsWith","addresses","addr","isBlockedUrl"],"sources":["../../../src/server/lib/ssrf-guard.ts"],"sourcesContent":["// server/lib/ssrf-guard.ts — Shared SSRF validation with DNS resolve-then-check\n//\n// Used by workflow steps (webhook_out, custom), email attachments, and any other\n// user-controlled URL fetching. Centralizes all IP blocking logic in one place.\n\nimport { resolve as dnsResolve } from \"node:dns/promises\";\n\n// Private/internal IPv4 ranges\nconst PRIVATE_IPV4_RANGES = [\n  /^127\\./, // Loopback\n  /^10\\./, // RFC 1918\n  /^172\\.(1[6-9]|2\\d|3[01])\\./, // RFC 1918\n  /^192\\.168\\./, // RFC 1918\n  /^169\\.254\\./, // Link-local / cloud metadata\n  /^0\\./, // \"This\" network\n  /^100\\.(6[4-9]|[7-9]\\d|1[0-1]\\d|12[0-7])\\./, // CGNAT (RFC 6598)\n  /^198\\.18\\./, // Benchmarking (RFC 2544)\n];\n\n// IPv6-mapped IPv4 patterns\n// Dotted decimal form: ::ffff:127.0.0.1\nconst IPV6_MAPPED_V4 = /^::ffff:(\\d+\\.\\d+\\.\\d+\\.\\d+)$/i;\n// Hex form (URL parser normalizes to this): ::ffff:7f00:1\nconst IPV6_MAPPED_V4_HEX = /^::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/i;\n\n// Private/internal IPv6 ranges\nconst PRIVATE_IPV6_PATTERNS = [\n  /^::1$/, // Loopback\n  /^fe80:/i, // Link-local\n  /^fc00:/i, // Unique local\n  /^fd/i, // Unique local\n  /^::$/,    // Unspecified address\n];\n\nconst BLOCKED_HOSTS = new Set([\n  \"localhost\",\n  \"0.0.0.0\",\n  \"metadata.google.internal\",\n  \"metadata.internal\",\n]);\n\nconst BLOCKED_TLDS = [\".internal\", \".local\", \".localhost\"];\n\n/**\n * P0 FIX: Normalize alternative IP encodings to standard dotted-decimal.\n * Catches bypass attempts via decimal, hex, octal, and mixed representations:\n *   - Decimal:  2130706433        → 127.0.0.1\n *   - Hex:      0x7f000001        → 127.0.0.1\n *   - Octal:    0177.0.0.01       → 127.0.0.1\n *   - Mixed:    0x7f.0.0.1        → 127.0.0.1\n *   - Leading zeros: 0127.0.0.01  → 87.0.0.1 (octal interpretation)\n *\n * Returns the normalized dotted-decimal string, or null if not a recognizable IP.\n */\nfunction normalizeIp(input: string): string | null {\n  const cleaned = input.trim();\n\n  // Case 1: Pure decimal integer (e.g. 2130706433 = 127.0.0.1)\n  if (/^\\d{1,10}$/.test(cleaned) && !cleaned.startsWith(\"0\")) {\n    const num = parseInt(cleaned, 10);\n    if (num >= 0 && num <= 0xffffffff) {\n      return `${(num >>> 24) & 0xff}.${(num >>> 16) & 0xff}.${(num >>> 8) & 0xff}.${num & 0xff}`;\n    }\n  }\n\n  // Case 2: Pure hex integer (e.g. 0x7f000001)\n  if (/^0x[0-9a-f]+$/i.test(cleaned)) {\n    const num = parseInt(cleaned, 16);\n    if (num >= 0 && num <= 0xffffffff) {\n      return `${(num >>> 24) & 0xff}.${(num >>> 16) & 0xff}.${(num >>> 8) & 0xff}.${num & 0xff}`;\n    }\n  }\n\n  // Case 3: Dotted form with octal/hex/decimal octets (e.g. 0177.0.0.01, 0x7f.0.0.1)\n  const parts = cleaned.split(\".\");\n  if (parts.length === 4) {\n    const octets: number[] = [];\n    for (const part of parts) {\n      let val: number;\n      if (/^0x[0-9a-f]+$/i.test(part)) {\n        // Hex octet\n        val = parseInt(part, 16);\n      } else if (/^0\\d+$/.test(part)) {\n        // Octal octet (leading zero)\n        val = parseInt(part, 8);\n      } else if (/^\\d+$/.test(part)) {\n        // Decimal octet\n        val = parseInt(part, 10);\n      } else {\n        return null; // Not a valid octet\n      }\n      if (isNaN(val) || val < 0 || val > 255) return null;\n      octets.push(val);\n    }\n    return octets.join(\".\");\n  }\n\n  return null;\n}\n\n/**\n * Check if an IP address is in a private/internal range.\n * P0 FIX: Now normalizes alternative IP encodings before checking.\n */\nfunction isPrivateIp(ip: string): boolean {\n  // Strip brackets from IPv6\n  const cleaned = ip.replace(/^\\[|\\]$/g, \"\");\n\n  // Check IPv6-mapped IPv4 — dotted decimal form (::ffff:x.x.x.x)\n  const mapped = cleaned.match(IPV6_MAPPED_V4);\n  if (mapped) {\n    const v4 = mapped[1];\n    const normalized = normalizeIp(v4) || v4;\n    return PRIVATE_IPV4_RANGES.some((r) => r.test(normalized));\n  }\n\n  // Check IPv6-mapped IPv4 — hex form (::ffff:7f00:1, as normalized by URL parser)\n  const mappedHex = cleaned.match(IPV6_MAPPED_V4_HEX);\n  if (mappedHex) {\n    const hi = parseInt(mappedHex[1], 16);\n    const lo = parseInt(mappedHex[2], 16);\n    const v4 = `${(hi >> 8) & 0xff}.${hi & 0xff}.${(lo >> 8) & 0xff}.${lo & 0xff}`;\n    return PRIVATE_IPV4_RANGES.some((r) => r.test(v4));\n  }\n\n  // P0 FIX: Normalize alternative encodings (decimal, hex, octal, mixed)\n  const normalized = normalizeIp(cleaned);\n  if (normalized) {\n    return PRIVATE_IPV4_RANGES.some((r) => r.test(normalized));\n  }\n\n  // Check plain IPv4 (standard dotted decimal — no leading zeros)\n  if (/^\\d+\\.\\d+\\.\\d+\\.\\d+$/.test(cleaned)) {\n    return PRIVATE_IPV4_RANGES.some((r) => r.test(cleaned));\n  }\n\n  // Check IPv6\n  return PRIVATE_IPV6_PATTERNS.some((r) => r.test(cleaned));\n}\n\n/**\n * Check if a hostname looks like a direct IP address (v4, v6, or alternative encoding).\n * Used to decide whether DNS failure should block or allow.\n */\nfunction looksLikeIp(host: string): boolean {\n  const cleaned = host.replace(/^\\[|\\]$/g, \"\");\n  // Standard dotted decimal\n  if (/^\\d+\\.\\d+\\.\\d+\\.\\d+$/.test(cleaned)) return true;\n  // Pure decimal integer\n  if (/^\\d{1,10}$/.test(cleaned)) return true;\n  // Hex integer\n  if (/^0x[0-9a-f]+$/i.test(cleaned)) return true;\n  // Dotted with octal/hex octets\n  if (/^[\\d.x]+$/i.test(cleaned) && cleaned.split(\".\").length === 4) return true;\n  // IPv6 (contains colons)\n  if (cleaned.includes(\":\")) return true;\n  return false;\n}\n\n/**\n * Validate a URL is safe to fetch (not targeting internal/private addresses).\n * Does basic hostname checks first, then resolves DNS to catch rebinding attacks.\n *\n * @returns null if safe, or a string error message if blocked.\n */\nexport async function validateUrl(urlStr: string): Promise<string | null> {\n  let u: URL;\n  try {\n    u = new URL(urlStr);\n  } catch {\n    return \"Malformed URL\";\n  }\n\n  // Block non-HTTP(S) schemes\n  if (u.protocol !== \"http:\" && u.protocol !== \"https:\") {\n    return `Blocked scheme: ${u.protocol}`;\n  }\n\n  const host = u.hostname.toLowerCase();\n\n  // Block known internal hostnames\n  if (BLOCKED_HOSTS.has(host)) {\n    return \"URL targets a blocked internal host\";\n  }\n\n  // Block internal TLDs\n  for (const tld of BLOCKED_TLDS) {\n    if (host.endsWith(tld)) {\n      return \"URL targets a blocked internal domain\";\n    }\n  }\n\n  // Block .fly.dev (our own infrastructure)\n  if (host.endsWith(\".fly.dev\")) {\n    return \"URL targets internal infrastructure\";\n  }\n\n  // Block bare IPs that resolve to private ranges (including alternative encodings)\n  if (isPrivateIp(host)) {\n    return \"URL targets a private/internal IP address\";\n  }\n\n  // DNS resolve-then-check: catch DNS rebinding attacks\n  try {\n    const addresses = await dnsResolve(host);\n    for (const addr of addresses) {\n      if (isPrivateIp(addr)) {\n        return `DNS resolved to private address: ${addr}`;\n      }\n    }\n  } catch {\n    // P0 FIX: DNS resolution failed — only allow through if host is already a\n    // validated direct IP (which was checked above). If it's a hostname that\n    // failed DNS, block it: we can't verify where it points.\n    if (!looksLikeIp(host)) {\n      return \"DNS resolution failed — cannot verify target is safe\";\n    }\n    // Direct IP that passed isPrivateIp check above — safe to proceed\n  }\n\n  return null;\n}\n\n/**\n * Synchronous fast-path check (no DNS resolution).\n * Use this when you can't await, or for backward compatibility.\n * For full protection (including DNS rebinding), use validateUrl().\n */\nexport function isBlockedUrl(urlStr: string): boolean {\n  try {\n    const u = new URL(urlStr);\n    const host = u.hostname.toLowerCase();\n\n    if (BLOCKED_HOSTS.has(host) || host === \"127.0.0.1\" || host === \"::1\" || host === \"[::1]\") return true;\n    if (PRIVATE_IPV4_RANGES.some((r) => r.test(host))) return true;\n    if (PRIVATE_IPV6_PATTERNS.some((r) => r.test(host.replace(/^\\[|\\]$/g, \"\")))) return true;\n\n    // P0 FIX: Check alternative IP encodings (decimal, hex, octal)\n    if (isPrivateIp(host)) return true;\n\n    if (host === \"169.254.169.254\") return true;\n    for (const tld of BLOCKED_TLDS) {\n      if (host.endsWith(tld)) return true;\n    }\n    if (host.endsWith(\".fly.dev\")) return true;\n    if (u.protocol !== \"http:\" && u.protocol !== \"https:\") return true;\n\n    return false;\n  } catch {\n    return true;\n  }\n}\n"],"mappings":"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","ignoreList":[]}