@fudrouter/fsrouter 0.6.112 → 0.6.114

package/dist/lib/ssrfGuard.js

@@ -0,0 +1,54 @@
+// SSRF guard: block internal/private/metadata targets for server-side fetch.
+// Mirrors 9router's assertPublicUrl so custom provider nodes can't be pointed
+// at localhost / cloud metadata endpoints (e.g. 169.254.169.254).
+
+const BLOCKED_HOSTNAMES = new Set(["localhost", "ip6-localhost", "ip6-loopback"]);
+const BLOCKED_SUFFIXES = [".internal", ".local", ".localhost"];
+
+function ipv4ToInt(host) {
+  const parts = host.split(".");
+  if (parts.length !== 4) return null;
+  let value = 0;
+  for (const part of parts) {
+    if (!/^\d{1,3}$/.test(part)) return null;
+    const octet = Number(part);
+    if (octet > 255) return null;
+    value = value * 256 + octet;
+  }
+  return value >>> 0;
+}
+
+const BLOCKED_V4_RANGES = [
+  [ipv4ToInt("0.0.0.0"), 8],
+  [ipv4ToInt("10.0.0.0"), 8],
+  [ipv4ToInt("127.0.0.0"), 8],
+  [ipv4ToInt("169.254.0.0"), 16],
+  [ipv4ToInt("172.16.0.0"), 12],
+  [ipv4ToInt("192.168.0.0"), 16],
+];
+
+function isBlockedIpv4(host) {
+  const ip = ipv4ToInt(host);
+  if (ip === null) return false;
+  return BLOCKED_V4_RANGES.some(([base, bits]) => {
+    const mask = bits === 0 ? 0 : (0xffffffff << (32 - bits)) >>> 0;
+    return (ip & mask) === (base & mask);
+  });
+}
+
+function isBlockedIpv6(host) {
+  const h = host.replace(/^\[|\]$/g, "").toLowerCase();
+  const v4Mapped = h.match(/^::ffff:(\d+\.\d+\.\d+\.\d+)$/);
+  if (v4Mapped) return isBlockedIpv4(v4Mapped[1]);
+  if (h === "::1" || h === "::") return true;
+  return h.startsWith("fe80:") || h.startsWith("fc") || h.startsWith("fd");
+}
+
+// Throw if URL targets a non-public host. Caller should map to 400.
+export function assertPublicUrl(rawUrl) {
+  const parsed = new URL(rawUrl);
+  const host = parsed.hostname.toLowerCase();
+  if (BLOCKED_HOSTNAMES.has(host)) throw new Error("Blocked host");
+  if (BLOCKED_SUFFIXES.some((s) => host.endsWith(s))) throw new Error("Blocked host suffix");
+  if (isBlockedIpv4(host) || isBlockedIpv6(host)) throw new Error("Blocked private IP");
+}

package/dist/routes/provider-nodes/validate/route.js

@@ -1,9 +1,11 @@
-// Fetch with timeout wrapper
+import { assertPublicUrl } from "../../../lib/ssrfGuard.js";
+// Fetch with timeout wrapper — uses AbortController (reliably aborts the
+// underlying request instead of just racing a dangling promise that can hang
+// the whole HTTP handler / make the browser show "Network error").
 const fetchWithTimeout = (url, options, timeout = 10000) => {
-    return Promise.race([
-        fetch(url, options),
-        new Promise((_, reject) => setTimeout(() => reject(new Error("Request timeout")), timeout))
-    ]);
+    const controller = new AbortController();
+    const t = setTimeout(() => controller.abort(), timeout);
+    return fetch(url, { ...options, signal: controller.signal }).finally(() => clearTimeout(t));
 };
 // Validate URL format
 const isValidUrl = (url) => {
@@ -67,6 +69,13 @@ export async function POST_handler(req, res) {
         if (!isValidUrl(baseUrl)) {
             return res.status(400).json({ error: "Invalid URL format" });
         }
+        // SSRF guard: block localhost / private / cloud-metadata targets
+        try {
+            assertPublicUrl(baseUrl);
+        }
+        catch {
+            return res.status(400).json({ error: "URL not allowed (internal/private address)" });
+        }
         // Custom Embedding Validation - test POST /embeddings directly
         if (type === "custom-embedding") {
             const normalizedBase = baseUrl.trim().replace(/\/$/, "");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fudrouter/fsrouter",
-  "version": "0.6.112",
+  "version": "0.6.114",
   "private": false,
   "type": "module",
   "description": "9Router v2 — Express Backend (API, SSE, DB, Auth, MITM)",