@patchstack/connect 0.3.8 → 0.3.10

package/dist/protect.js

@@ -117,10 +117,50 @@ var RequestResolver = class {
         return this.#resolveServer(key);
       case "files":
         return this.#resolveFiles(key);
+      case "response":
+        return this.#resolveResponse(key);
+      case "egress":
+        return this.#resolveEgress(key);
       default:
         return [];
     }
   }
+  // Response-phase sources (req._response = { status, headers, body }). Lets rules inspect
+  // what the app is about to SEND — e.g. a leaked secret in the body — regardless of route.
+  #resolveResponse(key) {
+    const resp = this.#req._response;
+    if (!resp) {
+      return [];
+    }
+    if (key === "status") {
+      return resp.status !== void 0 ? [String(resp.status)] : [];
+    }
+    if (key === "body") {
+      return resp.body != null && resp.body !== "" ? [resp.body] : [];
+    }
+    if (key === "headers") {
+      const headers = resp.headers ?? {};
+      return [Object.entries(headers).map(([k, v]) => `${k}: ${v}`).join("\n")];
+    }
+    if (key.startsWith("header.")) {
+      const name = key.slice("header.".length).toLowerCase();
+      const value = (resp.headers ?? {})[name];
+      return value !== void 0 ? [value] : [];
+    }
+    return [];
+  }
+  // Egress-phase sources (req._egress = { url, host, method }). Lets rules inspect an
+  // OUTBOUND request the app is about to make — SSRF at the egress boundary.
+  #resolveEgress(key) {
+    const eg = this.#req._egress;
+    if (!eg) {
+      return [];
+    }
+    if (key === "url") return eg.url ? [eg.url] : [];
+    if (key === "host") return eg.host ? [eg.host] : [];
+    if (key === "method") return eg.method ? [eg.method] : [];
+    return [];
+  }
   applyMutations(mutations, value) {
     if (!mutations || !Array.isArray(mutations)) {
       return value;
@@ -613,6 +653,24 @@ function warnUnsupportedMatchType(type) {
     `[patchstack] Unsupported rule_v2 match type "${type}" \u2014 condition treated as no-match. Rules relying on it are not enforced by this engine.`
   );
 }
+function isInternalHost(hostname) {
+  if (!hostname) return false;
+  const host = String(hostname).toLowerCase().replace(/^\[|\]$/g, "");
+  if (host === "localhost" || host.endsWith(".localhost") || host.endsWith(".local")) return true;
+  if (host === "metadata.google.internal") return true;
+  if (host === "::1" || host === "::") return true;
+  if (host.startsWith("fe80:") || host.startsWith("fc") || host.startsWith("fd")) return true;
+  const v4 = host.match(/(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
+  if (v4) {
+    const a = Number(v4[1]);
+    const b = Number(v4[2]);
+    if (a === 127 || a === 10 || a === 0) return true;
+    if (a === 169 && b === 254) return true;
+    if (a === 172 && b >= 16 && b <= 31) return true;
+    if (a === 192 && b === 168) return true;
+  }
+  return false;
+}
 function matchValue(type, value, matchVal, matchObj) {
   if (value === null || value === void 0) {
     if (type === "isset") {
@@ -679,6 +737,8 @@ function matchValue(type, value, matchVal, matchObj) {
         return false;
       }
     }
+    case "internal_host":
+      return isInternalHost(strValue);
     case "quotes":
     // engine-php exposes `inline_js_xss` as an alias of `quotes`.
     case "inline_js_xss":
@@ -790,7 +850,8 @@ var RuleEngine = class {
     if (parameter === "rules" && Array.isArray(condition.rules)) {
       return this.#evaluateRule(condition.rules, resolver);
     }
-    const values = resolver.resolve(parameter);
+    const params = Array.isArray(parameter) ? parameter : [parameter];
+    const values = params.flatMap((p) => resolver.resolve(p));
     if (values.length === 0) {
       return false;
     }
@@ -972,6 +1033,98 @@ function parseCookies2(header) {
   return cookies;
 }
 
+// src/protect/egress.js
+function installEgressGuard({ shouldBlock, onBlock } = {}) {
+  const original = globalThis.fetch;
+  if (typeof original !== "function" || original.__patchstackGuarded || typeof shouldBlock !== "function") {
+    return () => {
+    };
+  }
+  const guarded = async (input, init) => {
+    const url = typeof input === "string" ? input : input && input.url || String(input);
+    let host = null;
+    try {
+      host = new URL(url).hostname;
+    } catch {
+      host = null;
+    }
+    const method = init && init.method || input && input.method || "GET";
+    if (shouldBlock(url, host, method)) {
+      onBlock?.({ url, host, method });
+      throw new Error(`Patchstack blocked an outbound request to a disallowed address: ${host ?? url}`);
+    }
+    return original(input, init);
+  };
+  guarded.__patchstackGuarded = true;
+  globalThis.fetch = guarded;
+  return () => {
+    if (globalThis.fetch === guarded) {
+      globalThis.fetch = original;
+    }
+  };
+}
+
+// src/protect/defaults.js
+var DEFAULT_RESPONSE_RULES = [
+  {
+    id: "resp-private-key",
+    title: "Private key in response body",
+    phase: "response",
+    category: "secret-exposure",
+    action: "redact",
+    rule_v2: [{ parameter: "response.body", match: { type: "regex", value: "/-----BEGIN (?:RSA |EC |OPENSSH |DSA |PGP )?PRIVATE KEY-----/" } }]
+  },
+  {
+    id: "resp-aws-access-key",
+    title: "AWS access key id in response body",
+    phase: "response",
+    category: "secret-exposure",
+    action: "redact",
+    rule_v2: [{ parameter: "response.body", match: { type: "regex", value: "/\\b(?:AKIA|ASIA)[0-9A-Z]{16}\\b/" } }]
+  },
+  {
+    id: "resp-gcp-api-key",
+    title: "Google API key in response body",
+    phase: "response",
+    category: "secret-exposure",
+    action: "redact",
+    rule_v2: [{ parameter: "response.body", match: { type: "regex", value: "/\\bAIza[0-9A-Za-z_-]{35}\\b/" } }]
+  },
+  {
+    id: "resp-jwt",
+    title: "JWT in response body",
+    phase: "response",
+    category: "secret-exposure",
+    action: "redact",
+    rule_v2: [{ parameter: "response.body", match: { type: "regex", value: "/\\beyJ[A-Za-z0-9_-]{8,}\\.eyJ[A-Za-z0-9_-]{8,}\\.[A-Za-z0-9_-]{8,}\\b/" } }]
+  },
+  {
+    id: "resp-db-connection-string",
+    title: "Database connection string with credentials in response body",
+    phase: "response",
+    category: "secret-exposure",
+    action: "redact",
+    rule_v2: [{ parameter: "response.body", match: { type: "regex", value: "/\\b(?:mongodb(?:\\+srv)?|postgres(?:ql)?|mysql|redis|amqps?):\\/\\/[^\\s:@\\/]+:[^\\s:@\\/]+@/i" } }]
+  },
+  {
+    id: "resp-stack-trace",
+    title: "Node stack trace leaking in response body",
+    phase: "response",
+    category: "info-exposure",
+    action: "redact",
+    rule_v2: [{ parameter: "response.body", match: { type: "regex", value: "/\\n\\s+at\\s+.+\\(.+:\\d+:\\d+\\)/" } }]
+  }
+];
+var DEFAULT_EGRESS_RULES = [
+  {
+    id: "egress-internal-address",
+    title: "Outbound request to an internal / metadata address (SSRF)",
+    phase: "egress",
+    category: "ssrf",
+    rule_v2: [{ parameter: "egress.host", match: { type: "internal_host" } }]
+  }
+];
+
 // src/protect/runtime.js
 import { readFileSync, writeFileSync, mkdirSync } from "fs";
 import { join } from "path";
@@ -1050,16 +1203,75 @@ async function createProtection(options = {}) {
   const onError = options.onError;
   const onDetect = options.onDetect ?? defaultOnDetect;
   const bundle = await resolveRules(options);
-  const engine = new RuleEngine({ ...bundle, onError });
-  const decide = (result, block, allow) => {
-    if (!result || !result.blocked) return allow();
-    onDetect({ mode, rule: result.rule, message: result.message });
-    return mode === "block" ? block() : allow();
+  const incoming = bundle.firewall ?? [];
+  const requestRules = byPhase(incoming, "request");
+  const responseRules = [...options.responseRules ?? DEFAULT_RESPONSE_RULES, ...byPhase(incoming, "response")];
+  const egressRules = [...options.egressRules ?? DEFAULT_EGRESS_RULES, ...byPhase(incoming, "egress")];
+  const engine = new RuleEngine({
+    firewall: requestRules,
+    whitelists: bundle.whitelists,
+    whitelist_keys: bundle.whitelist_keys,
+    onError
+  });
+  const responseRuleSet = responseRules.map((rule) => ({
+    rule,
+    engine: new RuleEngine({ firewall: [rule], onError }),
+    redactors: rule.action === "redact" ? extractRedactors(rule) : null
+  }));
+  const egressEngine = new RuleEngine({ firewall: egressRules, onError });
+  const maskFn = typeof options.maskWith === "function" ? options.maskWith : () => typeof options.maskWith === "string" ? options.maskWith : "[REDACTED]";
+  const decide = (phase, result, block, allow2) => {
+    if (!result || !result.blocked) return allow2();
+    onDetect({ phase, mode, category: result.rule?.category, rule: result.rule, message: result.message });
+    return mode === "block" ? block() : allow2();
+  };
+  const screenFetchResponse = async (response) => {
+    const text = await readTextResponse(response);
+    if (text == null) return response;
+    const meta = { status: response.status, headers: headerObject(response.headers) };
+    let blockRule = null;
+    const redactions = [];
+    for (const { rule, engine: re, redactors } of responseRuleSet) {
+      let result;
+      try {
+        result = re.evaluate({ _response: { ...meta, body: text } });
+      } catch (err) {
+        onError?.(err);
+        continue;
+      }
+      if (!result.blocked) continue;
+      onDetect({ phase: "response", mode, category: rule.category, rule, message: result.message });
+      if (mode !== "block") continue;
+      if (redactors && redactors.length) redactions.push({ rule, redactors });
+      else if (!blockRule) blockRule = rule;
+    }
+    if (mode !== "block") return response;
+    if (blockRule) return leakResponse();
+    if (redactions.length) {
+      let body = text;
+      for (const { rule, redactors } of redactions) body = applyRedactors(body, redactors, maskFn(rule.category));
+      return rebuildResponse(response, body);
+    }
+    return response;
+  };
+  const allow = new Set((options.allowHosts ?? []).map((h) => String(h).toLowerCase()));
+  const egressShouldBlock = (url, host, method) => {
+    if (host && allow.has(host.toLowerCase())) return false;
+    let result;
+    try {
+      result = egressEngine.evaluate({ _egress: { url, host, method } });
+    } catch (err) {
+      onError?.(err);
+      return false;
+    }
+    if (!result.blocked) return false;
+    onDetect({ phase: "egress", mode, category: result.rule?.category, rule: result.rule, message: result.message });
+    return mode === "block";
   };
   const protection = {
     mode,
-    rules: bundle,
-    // (request) => Response | null   (null = allow, caller proceeds)
+    rules: { request: requestRules, response: responseRules, egress: egressRules },
+    // (request) => Response | null   (null = allow, caller proceeds). Request phase only.
     fetchGuard() {
       return async (request) => {
         let result;
@@ -1069,15 +1281,20 @@ async function createProtection(options = {}) {
           onError?.(err);
           return null;
         }
-        return decide(result, () => blockResponse(result), () => null);
+        return decide("request", result, () => blockResponse(result), () => null);
       };
     },
-    // Wrap a fetch handler: export default { fetch: protection.fetch(app.fetch) }
+    // Wrap a fetch handler: screens the request, then the response (redact/block).
     fetch(handler) {
       const guard = protection.fetchGuard();
-      return async (request, ...rest) => await guard(request) ?? handler(request, ...rest);
+      return async (request, ...rest) => {
+        const blocked = await guard(request);
+        if (blocked) return blocked;
+        const response = await handler(request, ...rest);
+        return screenFetchResponse(response);
+      };
     },
-    // Express middleware (expects express-parsed req.query/req.body).
+    // Express middleware (request phase; expects express-parsed req.query/req.body).
     express() {
       return (req, res, next) => {
         let result;
@@ -1087,10 +1304,10 @@ async function createProtection(options = {}) {
           onError?.(err);
           return next();
         }
-        decide(result, () => res.status(403).json(blockBody(result)), () => next());
+        decide("request", result, () => res.status(403).json(blockBody(result)), () => next());
       };
     },
-    // Node / Connect middleware — buffers the body itself (no body-parser needed).
+    // Node / Connect middleware — buffers the body itself (request phase).
     node(nodeOptions = {}) {
       const maxBytes = nodeOptions.maxBodyBytes ?? 1024 * 1024;
       return (req, res, next) => {
@@ -1111,28 +1328,104 @@ async function createProtection(options = {}) {
         });
         req.on("end", () => {
           const rawBody = overflow ? "" : Buffer.concat(chunks).toString("utf8");
+          let shaped;
           let result;
           try {
-            result = engine.evaluate(fromNodeRequest(req, rawBody));
+            shaped = fromNodeRequest(req, rawBody);
+            result = engine.evaluate(shaped);
           } catch (err) {
             onError?.(err);
             return next();
           }
           decide(
+            "request",
             result,
             () => {
               res.statusCode = 403;
               res.setHeader("content-type", "application/json");
               res.end(JSON.stringify(blockBody(result)));
             },
-            () => next()
+            () => {
+              if (req.body === void 0) req.body = shaped.body;
+              next();
+            }
           );
         });
       };
     }
   };
+  if (options.egress) {
+    protection.uninstallEgress = installEgressGuard({ shouldBlock: egressShouldBlock, onBlock: options.onEgressBlock });
+  }
   return protection;
 }
+function byPhase(rules, phase) {
+  return (rules ?? []).filter((r) => (r.phase ?? "request") === phase);
+}
+async function readTextResponse(response) {
+  if (!response || typeof response.clone !== "function") return null;
+  const ct = (response.headers?.get?.("content-type") || "").toLowerCase();
+  const isText = ct === "" || /(json|text|xml|html|javascript|csv|yaml|x-www-form-urlencoded)/.test(ct);
+  if (!isText) return null;
+  const len = Number(response.headers?.get?.("content-length") || 0);
+  if (len && len > 512 * 1024) return null;
+  try {
+    const text = await response.clone().text();
+    return text.length > 512 * 1024 ? null : text;
+  } catch {
+    return null;
+  }
+}
+function headerObject(headers) {
+  const out = {};
+  headers?.forEach?.((v, k) => {
+    out[k.toLowerCase()] = v;
+  });
+  return out;
+}
+function extractRedactors(rule) {
+  const out = [];
+  const walk = (conds) => {
+    for (const c of conds ?? []) {
+      if (Array.isArray(c.rules)) walk(c.rules);
+      const m = c.match;
+      if (!m) continue;
+      if (m.type === "regex" && typeof m.value === "string") {
+        const parsed = m.value.match(/^\/(.+)\/([a-z]*)$/is);
+        if (parsed) {
+          const flags = parsed[2].includes("g") ? parsed[2] : parsed[2] + "g";
+          try {
+            out.push({ re: new RegExp(parsed[1], flags) });
+          } catch {
+          }
+        }
+      } else if ((m.type === "contains" || m.type === "stripos") && m.value != null) {
+        out.push({ literal: String(m.value) });
+      }
+    }
+  };
+  walk(rule.rule_v2);
+  return out;
+}
+function applyRedactors(body, redactors, mask) {
+  let out = body;
+  for (const r of redactors) {
+    if (r.re) out = out.replace(r.re, mask);
+    else if (r.literal) out = out.split(r.literal).join(mask);
+  }
+  return out;
+}
+function rebuildResponse(response, body) {
+  const headers = new Headers(response.headers);
+  headers.delete("content-length");
+  return new Response(body, { status: response.status, statusText: response.statusText, headers });
+}
+function leakResponse() {
+  return new Response(JSON.stringify({ error: "Response withheld by Patchstack (sensitive data detected)" }), {
+    status: 500,
+    headers: { "content-type": "application/json" }
+  });
+}
 async function resolveRules(options) {
   if (options.rules) {
     return normalizeBundle(options.rules);
@@ -1197,9 +1490,9 @@ function blockResponse(result) {
     headers: { "content-type": "application/json" }
   });
 }
-function defaultOnDetect({ mode, rule, message }) {
+function defaultOnDetect({ phase, mode, category, rule, message }) {
   const tag = mode === "block" ? "BLOCK" : "DETECT (dry-run)";
-  console.warn(`[patchstack] ${tag} rule=${rule?.id ?? "?"} ${message ?? ""}`.trim());
+  console.warn(`[patchstack] ${tag} phase=${phase ?? "request"} category=${category ?? "?"} rule=${rule?.id ?? "?"} ${message ?? ""}`.trim());
 }
 export {
   GUARD_PATH,