@patchstack/connect 0.3.10 → 0.3.12

package/dist/protect/templates/guard.ts

@@ -5,7 +5,9 @@
 //     through handleGuardRequest (registered as request middleware in src/start.ts).
 //   - browser → TanStack server function → Supabase: inspectServerFn checks the server-fn args
 //     (registered as function middleware in src/start.ts) before anything is written.
-// Either way Patchstack sees the traffic and runs the same policy.
+// Either way Patchstack sees the traffic and runs the same policy. It also screens the app's own
+// OUTBOUND calls for SSRF (egress: true wraps the global fetch) — blocking requests to internal /
+// cloud-metadata addresses while allowing the app's own Supabase project.
 //
 // Always-on by default (blocks). Rules come from the Patchstack API per-site (cached); the
 // bundled rules.json is only a fallback for before a token is configured. The engine ships
@@ -27,10 +29,19 @@ async function getProtection() {
     // Always-on: block by default. An explicit PATCHSTACK_MODE=dry-run downgrades to log-only.
     const mode = process.env.PATCHSTACK_MODE === "dry-run" ? "dry-run" : "block";
     const token = process.env.PATCHSTACK_WAF_TOKEN;
+    // Egress SSRF screening: block the app's outbound calls to internal / metadata addresses,
+    // but never its own Supabase project.
+    let allowHosts: string[] = [];
+    try {
+      if (process.env.SUPABASE_URL) allowHosts = [new URL(process.env.SUPABASE_URL).host];
+    } catch {
+      /* ignore a malformed SUPABASE_URL — just don't add an allow entry */
+    }
+    const common = { mode, egress: true, allowHosts };
     _protection = await createProtection(
       token
-        ? { token, mode, cacheDir: ".patchstack" } // live per-site rules from the Patchstack API (cached)
-        : { rules: fallbackRules as never, mode }, // demo fallback until a token is set
+        ? { ...common, token, cacheDir: ".patchstack" } // live per-site rules from the Patchstack API (cached)
+        : { ...common, rules: fallbackRules as never }, // demo fallback until a token is set
     );
   }
   return _protection;

package/dist/protect/templates/rules.json

@@ -1,17 +1,44 @@
 {
-  "_comment": "Demo fallback rules — used only when PATCHSTACK_WAF_TOKEN is unset. In production the guard fetches per-site rules from the Patchstack API (api.patchstack.com/api/get-rules/3, cached to disk). CVE id is representative until aligned with the real corpus.",
+  "_comment": "Starter fallback rules — used ONLY when PATCHSTACK_WAF_TOKEN is unset. The guard blocks by default, so these are deliberately HIGH-PRECISION signatures (structural markers legitimate traffic doesn't carry) to avoid false positives before a token is configured. Once a token is set the guard fetches the per-site, version-scoped corpus from the Patchstack API (api.patchstack.com/api/get-rules/3, cached to disk) and this file is no longer used. For a broad, many-class DEMONSTRATION (SQLi/XSS/XXE/SSRF/PII/…), seed this file from examples/protect/demo-rules.json — see that folder's README.",
   "firewall": [
     {
-      "id": "rm-npm-0001",
-      "title": "Block stored XSS via vulnerable markdown renderer (marked)",
-      "vulnerability_id": "CVE-2022-21681",
+      "id": "ps-fallback-proto-pollution",
+      "title": "Prototype pollution in request body",
+      "category": "prototype-pollution",
       "rule_v2": [
+        { "parameter": "raw", "mutations": ["urldecode"], "match": { "type": "contains", "value": "__proto__" } },
         {
-          "parameter": "post.title",
-          "mutations": ["urldecode"],
-          "match": { "type": "inline_xss" }
+          "parameter": "rules",
+          "rules": [
+            { "parameter": "raw", "mutations": ["urldecode"], "match": { "type": "contains", "value": "constructor" }, "inclusive": true },
+            { "parameter": "raw", "mutations": ["urldecode"], "match": { "type": "contains", "value": "prototype" }, "inclusive": true }
+          ]
         }
       ]
+    },
+    {
+      "id": "ps-fallback-path-traversal",
+      "title": "Path traversal in a file/path parameter",
+      "category": "lfi",
+      "rule_v2": [
+        { "parameter": ["get.file", "post.file", "raw.file", "get.path", "post.path"], "mutations": ["urldecode"], "match": { "type": "contains", "value": ".." } }
+      ]
+    },
+    {
+      "id": "ps-fallback-ssrf-internal",
+      "title": "SSRF via a url parameter pointing at an internal/metadata address",
+      "category": "ssrf",
+      "rule_v2": [
+        { "parameter": ["get.url", "post.url", "raw.url"], "mutations": ["urldecode"], "match": { "type": "regex", "value": "/localhost|127\\.0\\.0\\.1|169\\.254\\.169\\.254|::1|metadata\\.google/i" } }
+      ]
+    },
+    {
+      "id": "ps-fallback-xss",
+      "title": "Stored/reflected XSS in a text field",
+      "category": "xss",
+      "rule_v2": [
+        { "parameter": ["post.title", "post.comment", "post.body"], "mutations": ["urldecode", "htmlentitydecode"], "match": { "type": "regex", "value": "/<script\\b|onerror\\s*=|javascript:/i" } }
+      ]
     }
   ],
   "whitelists": [],

package/dist/protect.cjs

@@ -1199,7 +1199,8 @@ function createSupabaseGuard({ protection, supabaseUrl, fetchImpl = fetch }) {
       if (!HOP_BY_HOP.has(key.toLowerCase())) outHeaders.set(key, value);
     });
     const buf = await upstream.arrayBuffer();
-    return new Response(buf, { status: upstream.status, statusText: upstream.statusText, headers: outHeaders });
+    const forwarded = new Response(buf, { status: upstream.status, statusText: upstream.statusText, headers: outHeaders });
+    return protection.screenResponse ? protection.screenResponse(forwarded) : forwarded;
   };
 }
 
@@ -1254,10 +1255,11 @@ async function createProtection(options = {}) {
     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) };
+  const isTextCT = (ct) => {
+    ct = (ct || "").toLowerCase();
+    return ct === "" || /(json|text|xml|html|javascript|csv|yaml|x-www-form-urlencoded)/.test(ct);
+  };
+  const screenText = (text, meta) => {
     let blockRule = null;
     const redactions = [];
     for (const { rule, engine: re, redactors } of responseRuleSet) {
@@ -1274,15 +1276,92 @@ async function createProtection(options = {}) {
       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);
-    }
+    if (mode !== "block" || !blockRule && !redactions.length) return { verdict: "pass" };
+    if (blockRule) return { verdict: "block" };
+    let body = text;
+    for (const { rule, redactors } of redactions) body = applyRedactors(body, redactors, maskFn(rule.category));
+    return { verdict: "redact", body };
+  };
+  const screenResp = async (response) => {
+    const text = await readTextResponse(response);
+    if (text == null) return response;
+    const r = screenText(text, { status: response.status, headers: headerObject(response.headers) });
+    if (r.verdict === "block") return leakResponse();
+    if (r.verdict === "redact") return rebuildResponse(response, r.body);
     return response;
   };
+  const wrapNodeResponse = (res) => {
+    const origWrite = res.write.bind(res);
+    const origEnd = res.end.bind(res);
+    const chunks = [];
+    let size = 0;
+    let overflow = false;
+    const MAX = 512 * 1024;
+    const collect = (chunk, enc) => {
+      if (chunk == null) return;
+      const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, typeof enc === "string" ? enc : "utf8");
+      size += buf.length;
+      if (size > MAX) {
+        overflow = true;
+        return;
+      }
+      chunks.push(buf);
+    };
+    res.write = function(chunk, enc, cb) {
+      if (overflow) return origWrite(chunk, enc, cb);
+      collect(chunk, enc);
+      if (typeof enc === "function") enc();
+      else if (typeof cb === "function") cb();
+      return true;
+    };
+    res.end = function(chunk, enc, cb) {
+      if (typeof chunk === "function") {
+        cb = chunk;
+        chunk = void 0;
+        enc = void 0;
+      } else if (typeof enc === "function") {
+        cb = enc;
+        enc = void 0;
+      }
+      if (overflow) {
+        if (chunk != null) origWrite(chunk, enc);
+        return origEnd(cb);
+      }
+      collect(chunk, enc);
+      const text = Buffer.concat(chunks).toString("utf8");
+      let ct = res.getHeader ? res.getHeader("content-type") : void 0;
+      if (Array.isArray(ct)) ct = ct[0];
+      if (!isTextCT(ct)) {
+        for (const c of chunks) origWrite(c);
+        return origEnd(cb);
+      }
+      let r;
+      try {
+        r = screenText(text, { status: res.statusCode, headers: {} });
+      } catch (err) {
+        onError?.(err);
+        for (const c of chunks) origWrite(c);
+        return origEnd(cb);
+      }
+      if (r.verdict === "block") {
+        res.statusCode = 500;
+        try {
+          res.setHeader("content-type", "application/json");
+        } catch {
+        }
+        return origEnd(JSON.stringify({ error: "Response withheld by Patchstack (sensitive data detected)" }), cb);
+      }
+      if (r.verdict === "redact") {
+        try {
+          res.removeHeader && res.removeHeader("content-length");
+        } catch {
+        }
+        return origEnd(r.body, cb);
+      }
+      for (const c of chunks) origWrite(c);
+      return origEnd(cb);
+    };
+  };
   const allow = new Set((options.allowHosts ?? []).map((h) => String(h).toLowerCase()));
   const egressShouldBlock = (url, host, method) => {
     if (host && allow.has(host.toLowerCase())) return false;
@@ -1300,6 +1379,9 @@ async function createProtection(options = {}) {
   const protection = {
     mode,
     rules: { request: requestRules, response: responseRules, egress: egressRules },
+    // Screen a fetch Response through the response-phase rules (redact/block). Used by
+    // .fetch(), and by the Supabase guard on its forwarded upstream response.
+    screenResponse: (response) => screenResp(response),
     // (request) => Response | null   (null = allow, caller proceeds). Request phase only.
     fetchGuard() {
       return async (request) => {
@@ -1320,23 +1402,34 @@ async function createProtection(options = {}) {
         const blocked = await guard(request);
         if (blocked) return blocked;
         const response = await handler(request, ...rest);
-        return screenFetchResponse(response);
+        return screenResp(response);
       };
     },
     // Express middleware (request phase; expects express-parsed req.query/req.body).
-    express() {
+    // Pass { screenResponses: true } to also screen the outgoing response (buffers it).
+    express(exprOptions = {}) {
       return (req, res, next) => {
         let result;
         try {
           result = engine.evaluate(req);
         } catch (err) {
           onError?.(err);
+          if (exprOptions.screenResponses) wrapNodeResponse(res);
           return next();
         }
-        decide("request", result, () => res.status(403).json(blockBody(result)), () => next());
+        decide(
+          "request",
+          result,
+          () => res.status(403).json(blockBody(result)),
+          () => {
+            if (exprOptions.screenResponses) wrapNodeResponse(res);
+            next();
+          }
+        );
       };
     },
     // Node / Connect middleware — buffers the body itself (request phase).
+    // Pass { screenResponses: true } to also screen the outgoing response (buffers it).
     node(nodeOptions = {}) {
       const maxBytes = nodeOptions.maxBodyBytes ?? 1024 * 1024;
       return (req, res, next) => {
@@ -1376,6 +1469,7 @@ async function createProtection(options = {}) {
             },
             () => {
               if (req.body === void 0) req.body = shaped.body;
+              if (nodeOptions.screenResponses) wrapNodeResponse(res);
               next();
             }
           );