@patchstack/connect 0.3.15 → 0.3.17

package/dist/protect/templates/astro-middleware.ts

@@ -0,0 +1,35 @@
+// Patchstack runtime guard for Astro — middleware. Managed by `patchstack-connect protect`.
+// Runs the request-phase WAF (+ egress SSRF) and screens the response body/headers for every request.
+// If you already have middleware, compose them with `sequence()` from "astro:middleware".
+import type { MiddlewareHandler } from "astro";
+import { createProtection } from "@patchstack/connect/protect";
+import fallbackRules from "./patchstack.rules.json";
+
+const PS_SITE_UUID = "__PATCHSTACK_SITE_UUID__";
+
+let _protection: Awaited<ReturnType<typeof createProtection>> | undefined;
+async function getProtection() {
+  if (!_protection) {
+    const mode = process.env.PATCHSTACK_MODE === "dry-run" ? "dry-run" : "block";
+    const token = process.env.PATCHSTACK_WAF_TOKEN;
+    const siteUuid = PS_SITE_UUID.startsWith("__") ? process.env.PATCHSTACK_SITE_UUID : PS_SITE_UUID;
+    const common = { mode, egress: true } as const;
+    _protection = await createProtection(
+      siteUuid
+        ? { ...common, siteUuid, rules: fallbackRules as never, cacheDir: ".patchstack" }
+        : token
+          ? { ...common, token, cacheDir: ".patchstack" }
+          : { ...common, rules: fallbackRules as never },
+    );
+  }
+  return _protection;
+}
+
+// #region patchstack-astro (managed by patchstack-connect protect — do not edit)
+export const onRequest: MiddlewareHandler = async (context, next) => {
+  const protection = await getProtection();
+  const blocked = await protection.fetchGuard()(context.request);
+  if (blocked) return blocked; // 403 — blocked before it reaches your route
+  return protection.screenResponse(await next());
+};
+// #endregion patchstack-astro

package/dist/protect/templates/demo-rules.json

@@ -0,0 +1,238 @@
+{
+  "_comment": "DEMO sample rules scaffolded by `patchstack-connect protect --demo` — a broad, many-class set (SQLi/XSS/XXE/SSRF/PII/…) for demonstrations, NOT the production corpus. In production, rules come from the Patchstack API per site (via a baked site UUID / token). Kept in sync with examples/protect/demo-rules.json (minus its _demo test vectors).",
+  "firewall": [
+    {
+      "id": "demo-prototype-pollution",
+      "title": "Prototype pollution in request body",
+      "category": "prototype-pollution",
+      "rule_v2": [
+        {
+          "parameter": "raw",
+          "mutations": [
+            "urldecode"
+          ],
+          "match": {
+            "type": "contains",
+            "value": "__proto__"
+          }
+        },
+        {
+          "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": "demo-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": "demo-sqli",
+      "title": "SQL injection in a query parameter",
+      "category": "sqli",
+      "rule_v2": [
+        {
+          "parameter": [
+            "get.q",
+            "post.q",
+            "get.id",
+            "post.id",
+            "raw"
+          ],
+          "mutations": [
+            "urldecode"
+          ],
+          "match": {
+            "type": "regex",
+            "value": "/union\\s+select|;\\s*drop\\s+table|\\bor\\s+1\\s*=\\s*1\\b/i"
+          }
+        }
+      ]
+    },
+    {
+      "id": "demo-xss",
+      "title": "Reflected/stored XSS in a text field",
+      "category": "xss",
+      "rule_v2": [
+        {
+          "parameter": [
+            "get.q",
+            "post.comment",
+            "post.title",
+            "raw"
+          ],
+          "mutations": [
+            "urldecode",
+            "htmlentitydecode"
+          ],
+          "match": {
+            "type": "regex",
+            "value": "/<script\\b|onerror\\s*=|javascript:/i"
+          }
+        }
+      ]
+    },
+    {
+      "id": "demo-command-injection",
+      "title": "OS command injection in a host/cmd parameter",
+      "category": "command-injection",
+      "rule_v2": [
+        {
+          "parameter": [
+            "get.host",
+            "post.host",
+            "get.cmd",
+            "post.cmd"
+          ],
+          "mutations": [
+            "urldecode"
+          ],
+          "match": {
+            "type": "regex",
+            "value": "/[;&|`$()<>]/"
+          }
+        }
+      ]
+    },
+    {
+      "id": "demo-nosql-injection",
+      "title": "NoSQL operator injection in request body",
+      "category": "nosqli",
+      "rule_v2": [
+        {
+          "parameter": "raw",
+          "match": {
+            "type": "regex",
+            "value": "/\"\\$(?:ne|gt|lt|gte|lte|where|regex|in|nin)\"\\s*:/i"
+          }
+        }
+      ]
+    },
+    {
+      "id": "demo-xxe",
+      "title": "XML external entity (XXE) in request body",
+      "category": "xxe",
+      "rule_v2": [
+        {
+          "parameter": "raw",
+          "match": {
+            "type": "regex",
+            "value": "/<!ENTITY|<!DOCTYPE[^>]*SYSTEM/i"
+          }
+        }
+      ]
+    },
+    {
+      "id": "demo-ssrf-request",
+      "title": "SSRF via a url parameter (request-side)",
+      "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": "demo-resp-pii-email",
+      "title": "Email address leaking in response body",
+      "phase": "response",
+      "category": "pii-exposure",
+      "action": "redact",
+      "rule_v2": [
+        {
+          "parameter": "response.body",
+          "match": {
+            "type": "regex",
+            "value": "/[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}/"
+          }
+        }
+      ]
+    },
+    {
+      "id": "demo-resp-credit-card",
+      "title": "Credit-card number leaking in response body",
+      "phase": "response",
+      "category": "pii-exposure",
+      "action": "redact",
+      "rule_v2": [
+        {
+          "parameter": "response.body",
+          "match": {
+            "type": "regex",
+            "value": "/(?:\\d[ -]?){13,16}/"
+          }
+        }
+      ]
+    },
+    {
+      "id": "demo-egress-blocklist-host",
+      "title": "Outbound request to a known exfiltration host",
+      "phase": "egress",
+      "category": "exfiltration",
+      "rule_v2": [
+        {
+          "parameter": "egress.host",
+          "match": {
+            "type": "equals",
+            "value": "evil.example.com"
+          }
+        }
+      ]
+    }
+  ],
+  "whitelists": [],
+  "whitelist_keys": {}
+}

package/dist/protect/templates/fastify-plugin.ts

@@ -0,0 +1,48 @@
+// Patchstack runtime guard for Fastify — plugin. Managed by `patchstack-connect protect`.
+// Register it once (`app.register(patchstackFastify)`); it adds a preHandler hook that runs the
+// request-phase WAF (+ egress SSRF) on every request. Fastify's request/reply aren't Web-Fetch
+// shaped, so we reconstruct a Request from the parsed fastify request and run the fetch guard.
+import { createProtection } from "@patchstack/connect/protect";
+import fallbackRules from "./rules.json";
+
+const PS_SITE_UUID = "__PATCHSTACK_SITE_UUID__";
+
+let _protection: Awaited<ReturnType<typeof createProtection>> | undefined;
+async function getProtection() {
+  if (!_protection) {
+    const mode = process.env.PATCHSTACK_MODE === "dry-run" ? "dry-run" : "block";
+    const token = process.env.PATCHSTACK_WAF_TOKEN;
+    const siteUuid = PS_SITE_UUID.startsWith("__") ? process.env.PATCHSTACK_SITE_UUID : PS_SITE_UUID;
+    const common = { mode, egress: true } as const;
+    _protection = await createProtection(
+      siteUuid
+        ? { ...common, siteUuid, rules: fallbackRules as never, cacheDir: ".patchstack" }
+        : token
+          ? { ...common, token, cacheDir: ".patchstack" }
+          : { ...common, rules: fallbackRules as never },
+    );
+  }
+  return _protection;
+}
+
+// #region patchstack-fastify (managed by patchstack-connect protect — do not edit)
+export async function patchstackFastify(fastify: any) {
+  const protection = await getProtection();
+  const guard = protection.fetchGuard();
+  fastify.addHook("preHandler", async (request: any, reply: any) => {
+    const method = (request.method ?? "GET").toUpperCase();
+    const host = request.headers?.host ?? "localhost";
+    const url = `http://${host}${request.url ?? "/"}`;
+    const hasBody = method !== "GET" && method !== "HEAD" && request.body != null;
+    const body = hasBody ? (typeof request.body === "string" ? request.body : JSON.stringify(request.body)) : undefined;
+    const blocked = await guard(new Request(url, { method, headers: request.headers as HeadersInit, body }));
+    if (blocked) {
+      const contentType = blocked.headers.get("content-type");
+      reply.code(blocked.status);
+      if (contentType) reply.header("content-type", contentType);
+      reply.send(await blocked.text());
+      return reply; // stop the request here
+    }
+  });
+}
+// #endregion patchstack-fastify

package/dist/protect/templates/generic-guard.ts

@@ -0,0 +1,51 @@
+// Patchstack runtime protection — GENERIC guard (framework-agnostic).
+//
+// Scaffolded by `patchstack-connect protect` when no built-in adapter matched your stack. Wire
+// whichever helper below fits your server into your request path (see the plan the CLI printed),
+// then run `patchstack-connect protect --check` to confirm it's hooked up. The engine ships inside
+// @patchstack/connect — nothing else to install.
+import { createProtection } from "@patchstack/connect/protect";
+import fallbackRules from "./rules.json";
+
+// Baked by `patchstack-connect protect` from .patchstackrc.json when available.
+const PS_SITE_UUID = "__PATCHSTACK_SITE_UUID__";
+
+let _protection: Awaited<ReturnType<typeof createProtection>> | undefined;
+
+/** One memoized protection policy. Rules come from the Patchstack API per-site (cached); the
+ *  bundled rules.json is the fallback until a site UUID / token is configured. */
+export async function getProtection() {
+  if (!_protection) {
+    const mode = process.env.PATCHSTACK_MODE === "dry-run" ? "dry-run" : "block";
+    const token = process.env.PATCHSTACK_WAF_TOKEN;
+    const siteUuid = PS_SITE_UUID.startsWith("__") ? process.env.PATCHSTACK_SITE_UUID : PS_SITE_UUID;
+    const common = { mode, egress: true } as const;
+    _protection = await createProtection(
+      siteUuid
+        ? { ...common, siteUuid, rules: fallbackRules as never, cacheDir: ".patchstack" }
+        : token
+          ? { ...common, token, cacheDir: ".patchstack" }
+          : { ...common, rules: fallbackRules as never },
+    );
+  }
+  return _protection;
+}
+
+// --- Web Fetch (Cloudflare Workers, Bun, Deno, Hono, Next edge, TanStack server.ts) ---------
+// Wrap your fetch handler:  export default { fetch: protectFetch(originalFetch) }
+export function protectFetch<H extends (request: Request, ...rest: unknown[]) => unknown>(handler: H): H {
+  return (async (request: Request, ...rest: unknown[]) => {
+    const protection = await getProtection();
+    const blocked = await protection.fetchGuard()(request);
+    if (blocked) return blocked;
+    return protection.screenResponse(await handler(request, ...rest) as Response);
+  }) as H;
+}
+
+// --- Node / Express -------------------------------------------------------------------------
+// Add before your routes:  app.use(patchstackMiddleware)
+export function patchstackMiddleware(req: unknown, res: unknown, next: (err?: unknown) => void) {
+  getProtection()
+    .then((protection) => (protection.node() as (a: unknown, b: unknown, c: (e?: unknown) => void) => void)(req, res, next))
+    .catch(() => next()); // fail open
+}

package/dist/protect/templates/guard.ts

@@ -30,7 +30,7 @@ let _protection: Awaited<ReturnType<typeof createProtection>> | undefined;
 async function getProtection() {
   if (!_protection) {
     // 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 mode: "block" | "dry-run" = process.env.PATCHSTACK_MODE === "dry-run" ? "dry-run" : "block";
     const token = process.env.PATCHSTACK_WAF_TOKEN;
     const siteUuid = PS_SITE_UUID.startsWith("__") ? process.env.PATCHSTACK_SITE_UUID : PS_SITE_UUID;
     // Egress SSRF screening: block the app's outbound calls to internal / metadata addresses,
@@ -80,12 +80,26 @@ export async function inspectServerFn(data: unknown): Promise<{ rule?: string; m
 // src/start.ts (the browser→Supabase tunnel screens its own forwarded response). Only acts on a
 // web Response (text/JSON/HTML) — anything else, or any error, passes through untouched (fail-open,
 // never breaks a response).
-export async function screenResponse(response: unknown): Promise<unknown> {
+export async function screenResponse<T>(response: T): Promise<T> {
   try {
     if (!(response instanceof Response)) return response;
     const protection = await getProtection();
-    return protection.screenResponse ? await protection.screenResponse(response) : response;
+    return (protection.screenResponse ? await protection.screenResponse(response) : response) as T;
   } catch {
     return response; // fail open
   }
 }
+
+// Optional route-level WAF: evaluate the request-phase rules on EVERY incoming request (not just
+// the Supabase tunnel / server functions) and return a 403 on a match. Off unless the app sets
+// PATCHSTACK_ROUTE_WAF=1 — enabling it runs the request rules on all traffic, which is a classic
+// WAF false-positive surface, so it is opt-in. `request.clone()` so the app can still read the body.
+let _reqGuard: ((request: Request) => Promise<Response | null>) | undefined;
+export async function guardRequest(request: Request): Promise<Response | null> {
+  try {
+    if (!_reqGuard) _reqGuard = (await getProtection()).fetchGuard();
+    return await _reqGuard(request.clone());
+  } catch {
+    return null; // fail open
+  }
+}

package/dist/protect/templates/next-middleware.ts

@@ -0,0 +1,37 @@
+// Patchstack runtime guard for Next.js — edge middleware. Managed by `patchstack-connect protect`.
+// Runs the request-phase WAF (+ egress SSRF) on every request before it reaches your route.
+// Note: response-body redaction isn't available in Next middleware (it runs before the response);
+// wire the connect runtime in your route handlers if you also need response screening there.
+import { createProtection } from "@patchstack/connect/protect";
+import fallbackRules from "./patchstack.rules.json";
+
+const PS_SITE_UUID = "__PATCHSTACK_SITE_UUID__";
+
+let _protection: Awaited<ReturnType<typeof createProtection>> | undefined;
+async function getProtection() {
+  if (!_protection) {
+    const mode = process.env.PATCHSTACK_MODE === "dry-run" ? "dry-run" : "block";
+    const token = process.env.PATCHSTACK_WAF_TOKEN;
+    const siteUuid = PS_SITE_UUID.startsWith("__") ? process.env.PATCHSTACK_SITE_UUID : PS_SITE_UUID;
+    const common = { mode, egress: true } as const;
+    _protection = await createProtection(
+      siteUuid
+        ? { ...common, siteUuid, rules: fallbackRules as never, cacheDir: ".patchstack" }
+        : token
+          ? { ...common, token, cacheDir: ".patchstack" }
+          : { ...common, rules: fallbackRules as never },
+    );
+  }
+  return _protection;
+}
+
+// #region patchstack-next (managed by patchstack-connect protect — do not edit)
+export async function middleware(request: Request) {
+  const protection = await getProtection();
+  const blocked = await protection.fetchGuard()(request);
+  if (blocked) return blocked; // 403 — blocked before it reaches your route
+  // otherwise fall through (Next continues to the route)
+}
+
+export const config = { matcher: "/:path*" };
+// #endregion patchstack-next

package/dist/protect/templates/sveltekit-hooks.ts

@@ -0,0 +1,35 @@
+// Patchstack runtime guard for SvelteKit — server hook. Managed by `patchstack-connect protect`.
+// Runs the request-phase WAF (+ egress SSRF) and screens the response body/headers for every request.
+// If you already have a `handle`, compose them with `sequence()` from "@sveltejs/kit/hooks".
+import type { Handle } from "@sveltejs/kit";
+import { createProtection } from "@patchstack/connect/protect";
+import fallbackRules from "./patchstack.rules.json";
+
+const PS_SITE_UUID = "__PATCHSTACK_SITE_UUID__";
+
+let _protection: Awaited<ReturnType<typeof createProtection>> | undefined;
+async function getProtection() {
+  if (!_protection) {
+    const mode = process.env.PATCHSTACK_MODE === "dry-run" ? "dry-run" : "block";
+    const token = process.env.PATCHSTACK_WAF_TOKEN;
+    const siteUuid = PS_SITE_UUID.startsWith("__") ? process.env.PATCHSTACK_SITE_UUID : PS_SITE_UUID;
+    const common = { mode, egress: true } as const;
+    _protection = await createProtection(
+      siteUuid
+        ? { ...common, siteUuid, rules: fallbackRules as never, cacheDir: ".patchstack" }
+        : token
+          ? { ...common, token, cacheDir: ".patchstack" }
+          : { ...common, rules: fallbackRules as never },
+    );
+  }
+  return _protection;
+}
+
+// #region patchstack-sveltekit (managed by patchstack-connect protect — do not edit)
+export const handle: Handle = async ({ event, resolve }) => {
+  const protection = await getProtection();
+  const blocked = await protection.fetchGuard()(event.request);
+  if (blocked) return blocked; // 403 — blocked before it reaches your route
+  return protection.screenResponse(await resolve(event));
+};
+// #endregion patchstack-sveltekit