fullshield 0.0.0-stage → 0.1.0

package/dist/runtime/auto.js

@@ -0,0 +1,1163 @@
+import dns from 'dns';
+import { createRequire } from 'module';
+import { AsyncLocalStorage } from 'async_hooks';
+
+// src/runtime/rasp/nosql.ts
+function isOperatorObject(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  return Object.keys(value).some((k) => k.startsWith("$"));
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null || typeof a !== "object" || typeof b !== "object") return false;
+  if (Array.isArray(a) || Array.isArray(b)) {
+    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+    return a.every((v, i) => deepEqual(v, b[i]));
+  }
+  const ak = Object.keys(a);
+  const bk = Object.keys(b);
+  if (ak.length !== bk.length) return false;
+  return ak.every((k) => deepEqual(a[k], b[k]));
+}
+function collect(value, out, depth) {
+  if (depth > 8 || value === null || typeof value !== "object") return;
+  out.push(value);
+  if (Array.isArray(value)) {
+    for (const item of value) collect(item, out, depth + 1);
+    return;
+  }
+  for (const child of Object.values(value)) collect(child, out, depth + 1);
+}
+function nosqlUserOperators(sink, ctx) {
+  const userObjects = [];
+  for (const obj of ctx.objects) collect(obj, userObjects, 0);
+  const userOps = userObjects.filter(isOperatorObject);
+  if (userOps.length === 0) return false;
+  const seen = /* @__PURE__ */ new Set();
+  const walk2 = (value, depth) => {
+    if (depth > 8 || value === null || typeof value !== "object") return false;
+    if (seen.has(value)) return false;
+    seen.add(value);
+    if (isOperatorObject(value) && userOps.some((u) => u === value || deepEqual(u, value))) {
+      return true;
+    }
+    if (Array.isArray(value)) return value.some((item) => walk2(item, depth + 1));
+    return Object.values(value).some((child) => walk2(child, depth + 1));
+  };
+  return walk2(sink, 0);
+}
+
+// src/runtime/rasp/path.ts
+function logicalResolve(p) {
+  const isAbs = p.startsWith("/") || /^[A-Za-z]:[\\/]/.test(p);
+  const parts = [];
+  for (const seg of p.split(/[\\/]+/)) {
+    if (seg === "" || seg === ".") continue;
+    if (seg === "..") {
+      parts.pop();
+      continue;
+    }
+    parts.push(seg);
+  }
+  return (isAbs ? "/" : "") + parts.join("/");
+}
+function isInside(base, target) {
+  const b = logicalResolve(base).replace(/\/+$/, "");
+  const t = logicalResolve(target);
+  if (b === "") return !t.startsWith("/") && !t.split("/").includes("..");
+  return t === b || t.startsWith(`${b}/`);
+}
+function inferBase(sink, input) {
+  const idx = sink.indexOf(input);
+  if (idx <= 0) return "";
+  return sink.slice(0, idx);
+}
+function lastSeg(p) {
+  const parts = logicalResolve(p).split("/").filter(Boolean);
+  return parts[parts.length - 1];
+}
+function pathInputEscapes(sink, input, base) {
+  if (!input) return false;
+  if (input.includes("\0") || sink.includes("\0")) return true;
+  if (sink.includes(input)) {
+    if (input.includes("..")) return true;
+    const intended = base !== void 0 && base.length > 0 ? base : inferBase(sink, input);
+    if (intended === "") {
+      return input.startsWith("/") || /^[A-Za-z]:[\\/]/.test(input) || input.includes("..");
+    }
+    return !isInside(intended, sink);
+  }
+  if (input.includes("..") || input.startsWith("/") || /^[A-Za-z]:[\\/]/.test(input)) {
+    const a = lastSeg(input);
+    const b = lastSeg(sink);
+    if (a && a === b) return true;
+  }
+  return false;
+}
+
+// src/runtime/rasp/proto.ts
+var DANGEROUS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function walk(value, depth, seen) {
+  if (depth > 8 || value === null || typeof value !== "object") return false;
+  if (seen.has(value)) return false;
+  seen.add(value);
+  for (const key of Object.getOwnPropertyNames(value)) {
+    if (DANGEROUS.has(key)) return true;
+  }
+  if (Array.isArray(value)) return value.some((item) => walk(item, depth + 1, seen));
+  return Object.values(value).some((child) => walk(child, depth + 1, seen));
+}
+function protoPolluted(ctx) {
+  const seen = /* @__PURE__ */ new Set();
+  return ctx.objects.some((obj) => walk(obj, 0, seen));
+}
+
+// src/runtime/rasp/shell.ts
+function tokenizeShell(command) {
+  const tokens = [];
+  let i = 0;
+  const n = command.length;
+  while (i < n) {
+    const c = command[i];
+    if (c === " " || c === "	" || c === "\n") {
+      const start2 = i;
+      while (i < n && (command[i] === " " || command[i] === "	" || command[i] === "\n")) i += 1;
+      tokens.push({ kind: "space", start: start2, end: i });
+      continue;
+    }
+    if (c === "'" || c === '"') {
+      const quote = c;
+      const start2 = i;
+      i += 1;
+      while (i < n && command[i] !== quote) {
+        if (quote === '"' && command[i] === "\\") i += 1;
+        i += 1;
+      }
+      if (i < n) i += 1;
+      tokens.push({ kind: "word", start: start2, end: i });
+      continue;
+    }
+    if (c === "`") {
+      const start2 = i;
+      i += 1;
+      while (i < n && command[i] !== "`") i += 1;
+      if (i < n) i += 1;
+      tokens.push({ kind: "op", start: start2, end: i });
+      continue;
+    }
+    if (c === "$" && (command[i + 1] === "(" || command[i + 1] === "{")) {
+      const open = command[i + 1];
+      const close = open === "(" ? ")" : "}";
+      const start2 = i;
+      i += 2;
+      let depth = 1;
+      while (i < n && depth > 0) {
+        if (command[i] === open) depth += 1;
+        else if (command[i] === close) depth -= 1;
+        i += 1;
+      }
+      tokens.push({ kind: "op", start: start2, end: i });
+      continue;
+    }
+    if (command.startsWith("||", i) || command.startsWith("&&", i) || command.startsWith(">>", i) || command.startsWith("<<", i)) {
+      tokens.push({ kind: "op", start: i, end: i + 2 });
+      i += 2;
+      continue;
+    }
+    if (";|&<>()".includes(c)) {
+      tokens.push({ kind: "op", start: i, end: i + 1 });
+      i += 1;
+      continue;
+    }
+    const start = i;
+    while (i < n && !/[\s;|&$`<>()]/.test(command[i])) i += 1;
+    tokens.push({ kind: "word", start, end: i });
+  }
+  return tokens;
+}
+function shellInputChangesStructure(command, input) {
+  if (!input) return false;
+  const tokens = tokenizeShell(command);
+  let from = 0;
+  while (from <= command.length) {
+    const idx = command.indexOf(input, from);
+    if (idx === -1) return false;
+    const end = idx + input.length;
+    const hit = tokens.filter((t) => t.kind !== "space" && t.start < end && t.end > idx);
+    if (!(hit.length === 1 && hit[0].kind === "word" && hit[0].start <= idx && hit[0].end >= end)) {
+      return true;
+    }
+    from = idx + Math.max(input.length, 1);
+  }
+  return false;
+}
+
+// src/runtime/rasp/sql.ts
+function tokenizeSql(sql) {
+  const tokens = [];
+  let i = 0;
+  const n = sql.length;
+  while (i < n) {
+    const c = sql[i];
+    if (c <= " ") {
+      const start2 = i;
+      while (i < n && sql[i] <= " ") i += 1;
+      tokens.push({ kind: "space", start: start2, end: i });
+      continue;
+    }
+    if (c === "'" || c === '"' || c === "`") {
+      const quote = c;
+      const start2 = i;
+      i += 1;
+      while (i < n) {
+        if (sql[i] === quote) {
+          if (sql[i + 1] === quote) {
+            i += 2;
+            continue;
+          }
+          i += 1;
+          break;
+        }
+        i += 1;
+      }
+      tokens.push({ kind: "string", start: start2, end: i });
+      continue;
+    }
+    if (c === "-" && sql[i + 1] === "-") {
+      const start2 = i;
+      i += 2;
+      while (i < n && sql[i] !== "\n") i += 1;
+      tokens.push({ kind: "comment", start: start2, end: i });
+      continue;
+    }
+    if (c === "/" && sql[i + 1] === "*") {
+      const start2 = i;
+      i += 2;
+      while (i < n && !(sql[i] === "*" && sql[i + 1] === "/")) i += 1;
+      if (i + 1 < n) i += 2;
+      tokens.push({ kind: "comment", start: start2, end: i });
+      continue;
+    }
+    if (c === "#") {
+      const start2 = i;
+      while (i < n && sql[i] !== "\n") i += 1;
+      tokens.push({ kind: "comment", start: start2, end: i });
+      continue;
+    }
+    if (c >= "0" && c <= "9" || c === "." && i + 1 < n && sql[i + 1] >= "0" && sql[i + 1] <= "9") {
+      const start2 = i;
+      while (i < n && /[0-9.eE+-]/.test(sql[i])) i += 1;
+      tokens.push({ kind: "number", start: start2, end: i });
+      continue;
+    }
+    if (/[A-Za-z_]/.test(c)) {
+      const start2 = i;
+      while (i < n && /[A-Za-z0-9_$]/.test(sql[i])) i += 1;
+      tokens.push({ kind: "ident", start: start2, end: i });
+      continue;
+    }
+    const start = i;
+    if (sql.startsWith("<=", i) || sql.startsWith(">=", i) || sql.startsWith("<>", i) || sql.startsWith("!=", i) || sql.startsWith("||", i) || sql.startsWith("&&", i)) {
+      i += 2;
+    } else {
+      i += 1;
+    }
+    tokens.push({ kind: "op", start, end: i });
+  }
+  return tokens;
+}
+function spanUnsafe(tokens, start, end) {
+  const hit = tokens.filter((t) => t.kind !== "space" && t.start < end && t.end > start);
+  if (hit.length === 1) {
+    const t = hit[0];
+    const safe = t.kind === "string" || t.kind === "number" || t.kind === "comment";
+    return !safe || t.start > start || t.end < end;
+  }
+  return hit.length > 0;
+}
+function sqlInputChangesStructure(query, input) {
+  if (!input) return false;
+  const tokens = tokenizeSql(query);
+  let from = 0;
+  while (from <= query.length) {
+    const idx = query.indexOf(input, from);
+    if (idx === -1) return false;
+    if (spanUnsafe(tokens, idx, idx + input.length)) return true;
+    from = idx + Math.max(input.length, 1);
+  }
+  return false;
+}
+function normalizeHost(host) {
+  let h = host.trim().toLowerCase();
+  h = h.replace(/\.+$/, "");
+  if (h.startsWith("[") && h.endsWith("]")) h = h.slice(1, -1);
+  if (h.startsWith("::ffff:")) h = h.slice(7);
+  if (h.startsWith("[") && h.endsWith("]")) h = h.slice(1, -1);
+  return h;
+}
+function parseIpv4Part(part) {
+  if (/^0x[0-9a-f]+$/i.test(part)) {
+    const n = Number.parseInt(part, 16);
+    return Number.isFinite(n) ? n : void 0;
+  }
+  if (/^0[0-7]+$/.test(part)) {
+    const n = Number.parseInt(part, 8);
+    return Number.isFinite(n) ? n : void 0;
+  }
+  if (/^\d+$/.test(part)) {
+    const n = Number(part);
+    return Number.isFinite(n) ? n : void 0;
+  }
+  return void 0;
+}
+function parseIpv4(host) {
+  const h = normalizeHost(host);
+  if (!h || h.includes(":")) return void 0;
+  const parts = h.split(".");
+  if (parts.length === 0 || parts.length > 4) return void 0;
+  const nums = parts.map(parseIpv4Part);
+  if (nums.some((n) => n === void 0)) return void 0;
+  const a = nums[0];
+  if (parts.length === 1) {
+    if (a > 4294967295) return void 0;
+    return [a >>> 24 & 255, a >>> 16 & 255, a >>> 8 & 255, a & 255];
+  }
+  if (parts.length === 2) {
+    const b2 = nums[1];
+    if (a > 255 || b2 > 16777215) return void 0;
+    return [a, b2 >>> 16 & 255, b2 >>> 8 & 255, b2 & 255];
+  }
+  if (parts.length === 3) {
+    const b2 = nums[1];
+    const c2 = nums[2];
+    if (a > 255 || b2 > 255 || c2 > 65535) return void 0;
+    return [a, b2, c2 >>> 8 & 255, c2 & 255];
+  }
+  const b = nums[1];
+  const c = nums[2];
+  const d = nums[3];
+  if ([a, b, c, d].some((n) => n > 255)) return void 0;
+  return [a, b, c, d];
+}
+function isPrivateV4(octets) {
+  const [a, b] = octets;
+  if (a === 127 || a === 0 || a === 10) return true;
+  if (a === 169 && b === 254) return true;
+  if (a === 192 && b === 168) return true;
+  if (a === 172 && b >= 16 && b <= 31) return true;
+  return false;
+}
+function isPrivateIpv6(h) {
+  if (h === "::1" || h === "::" || h === "0:0:0:0:0:0:0:1") return true;
+  if (h.startsWith("fc") || h.startsWith("fd") || h.startsWith("fe80:")) return true;
+  return false;
+}
+function isPrivateOrMetadata(host) {
+  const h = normalizeHost(host);
+  if (h === "localhost" || h.endsWith(".localhost") || h === "metadata.google.internal") return true;
+  const v4 = parseIpv4(h);
+  if (v4) return isPrivateV4(v4);
+  if (h.includes(":")) return isPrivateIpv6(h);
+  return false;
+}
+function defaultLookup(host) {
+  const h = normalizeHost(host);
+  if (parseIpv4(h) || h.includes(":")) return [h];
+  try {
+    const lookupSync = dns.lookupSync;
+    if (typeof lookupSync === "function") {
+      return lookupSync(h, { all: true }).map((row) => row.address);
+    }
+  } catch {
+  }
+  return [];
+}
+function resolveHostAddresses(host) {
+  try {
+    return defaultLookup(host);
+  } catch {
+    return [];
+  }
+}
+function hostIsBlocked(host) {
+  if (isPrivateOrMetadata(host)) return true;
+  for (const addr of resolveHostAddresses(host)) {
+    if (isPrivateOrMetadata(addr)) return true;
+  }
+  return false;
+}
+function ssrfHostFromUser(url, input) {
+  if (!input || !url.includes(input)) return false;
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return false;
+  }
+  const host = parsed.hostname;
+  if (!host) return false;
+  const rawAuth = /^https?:\/\/([^/?#]+)/i.exec(url)?.[1] ?? host;
+  const rawHost = rawAuth.replace(/:\d+$/, "");
+  const inputTouchesHost = input === url || input.includes(host) || input.includes(rawHost) || rawHost.includes(input) && input.length >= 3;
+  if (!inputTouchesHost) return false;
+  return hostIsBlocked(host) || hostIsBlocked(rawHost);
+}
+function urlFromHttpArgs(args) {
+  const first = args[0];
+  if (typeof first === "string") return first;
+  if (first instanceof URL) return first.href;
+  if (first && typeof first === "object") {
+    const o = first;
+    if (typeof o.href === "string") return o.href;
+    const proto = o.protocol ?? "http:";
+    const host = o.hostname ?? o.host ?? "";
+    const path = o.path ?? "/";
+    return `${proto}//${host}${path}`;
+  }
+  return "";
+}
+function fetchUrl(input) {
+  if (typeof input === "string") return input;
+  if (input instanceof URL) return input.href;
+  if (input && typeof input === "object" && "url" in input && typeof input.url === "string") {
+    return input.url;
+  }
+  return "";
+}
+
+// src/runtime/rasp/types.ts
+var RASP_RULE = {
+  sql: "RASP-SQL-001",
+  shell: "RASP-SHELL-001",
+  path: "RASP-PATH-001",
+  nosql: "RASP-NOSQL-001",
+  ssrf: "RASP-SSRF-001",
+  proto: "RASP-PROTO-001"
+};
+var RASP_FAIL_OPEN = "RASP-FAIL-OPEN-001";
+var RaspBlockedError = class extends Error {
+  ruleId;
+  constructor(ruleId) {
+    super(`fullshield rasp blocked ${ruleId}`);
+    this.name = "RaspBlockedError";
+    this.ruleId = ruleId;
+  }
+};
+
+// src/runtime/rasp/decide.ts
+function sinkTexts(sink) {
+  if (typeof sink === "string") return [sink];
+  if (typeof sink === "number" || typeof sink === "boolean") return [String(sink)];
+  return [];
+}
+function detectStructureChange(kind, sink, ctx, base) {
+  if (kind === "proto") return protoPolluted(ctx);
+  if (kind === "nosql") return nosqlUserOperators(sink, ctx);
+  for (const text of sinkTexts(sink)) {
+    for (const input of ctx.strings) {
+      if (!input) continue;
+      if (kind === "sql" && sqlInputChangesStructure(text, input)) return true;
+      if (kind === "shell" && shellInputChangesStructure(text, input)) return true;
+      if (kind === "path" && pathInputEscapes(text, input, base)) return true;
+      if (kind === "ssrf" && ssrfHostFromUser(text, input)) return true;
+    }
+  }
+  return false;
+}
+function decideSink(kind, sink, ctx, base) {
+  const hit = detectStructureChange(kind, sink, ctx, base);
+  if (hit) return { block: true, ruleId: RASP_RULE[kind] };
+  return { block: false };
+}
+var SKIP_HEADERS = /* @__PURE__ */ new Set([
+  "host",
+  "connection",
+  "user-agent",
+  "accept",
+  "accept-encoding",
+  "accept-language",
+  "content-type",
+  "content-length",
+  "transfer-encoding",
+  "cookie"
+]);
+var storage = new AsyncLocalStorage();
+function flatten(value, out, depth) {
+  if (depth > 8 || out.length > 200) return;
+  if (typeof value === "string") {
+    out.push(value);
+    return;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    out.push(String(value));
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) flatten(item, out, depth + 1);
+    return;
+  }
+  if (value !== null && typeof value === "object") {
+    for (const child of Object.values(value)) flatten(child, out, depth + 1);
+  }
+}
+function collectObjects(value, out, depth) {
+  if (depth > 8 || value === null || typeof value !== "object") return;
+  out.push(value);
+  if (Array.isArray(value)) {
+    for (const item of value) collectObjects(item, out, depth + 1);
+    return;
+  }
+  for (const child of Object.values(value)) collectObjects(child, out, depth + 1);
+}
+function contextFromRequest(req) {
+  const strings = [];
+  const objects = [];
+  for (const value of [req.query, req.body, req.params, req.cookies]) {
+    flatten(value, strings, 0);
+    collectObjects(value, objects, 0);
+  }
+  if (req.headers && typeof req.headers === "object") {
+    for (const [key, value] of Object.entries(req.headers)) {
+      if (SKIP_HEADERS.has(key.toLowerCase())) continue;
+      flatten(value, strings, 0);
+    }
+    collectObjects(req.headers, objects, 0);
+  }
+  return {
+    path: req.path ?? req.url?.split("?")[0] ?? "/",
+    ip: req.ip ?? "unknown",
+    strings,
+    objects
+  };
+}
+function enterRaspContext(ctx, fn) {
+  return storage.run(ctx, fn);
+}
+function currentRaspContext() {
+  return storage.getStore();
+}
+
+// src/runtime/rasp/egress.ts
+function egressAllowed(host, allow) {
+  const h = host.toLowerCase().replace(/\.+$/, "");
+  for (const rule of allow) {
+    const r = rule.toLowerCase();
+    if (r.startsWith("*.")) {
+      const suffix = r.slice(1);
+      if (h.endsWith(suffix) && h !== r.slice(2)) return true;
+    } else if (h === r) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// src/runtime/rasp/threat.ts
+var scores = /* @__PURE__ */ new Map();
+var blockUntil = /* @__PURE__ */ new Map();
+var WEIGHT = {
+  block: 2,
+  honey: 5,
+  anomaly: 1
+};
+var DEFAULT_MAX_BLOCK_MS = 15 * 60 * 1e3;
+var autoBlock = false;
+var maxBlockMs = DEFAULT_MAX_BLOCK_MS;
+function configureThreat(opts = {}) {
+  autoBlock = opts.autoBlock === true;
+  if (typeof opts.maxBlockMs === "number" && opts.maxBlockMs > 0) maxBlockMs = opts.maxBlockMs;
+}
+function addThreat(ip, kind, now = Date.now()) {
+  const next = (scores.get(ip) ?? 0) + WEIGHT[kind];
+  scores.set(ip, next);
+  if (autoBlock && next >= 10) {
+    blockUntil.set(ip, now + maxBlockMs);
+  }
+  return next;
+}
+function isIpBlocked(ip, now = Date.now()) {
+  if (!autoBlock) return false;
+  const until = blockUntil.get(ip);
+  if (until === void 0) return false;
+  if (now >= until) {
+    blockUntil.delete(ip);
+    return false;
+  }
+  return true;
+}
+
+// src/runtime/rasp/honey.ts
+var DECOY_ROUTES = ["/admin.php", "/.git/config", "/wp-login.php"];
+var registered = /* @__PURE__ */ new Set();
+var ROUTE_WINDOW_MS = 6e4;
+var routeHits = /* @__PURE__ */ new Map();
+function isHoneyRoute(path) {
+  const p = path.split("?")[0] ?? path;
+  return DECOY_ROUTES.includes(p);
+}
+function isHoneyCanary(text) {
+  if (!text) return false;
+  for (const c of registered) {
+    if (c && text.includes(c)) return true;
+  }
+  return false;
+}
+function noteHoneyRouteHit(ip, now = Date.now()) {
+  const prev = routeHits.get(ip);
+  if (prev === void 0 || now - prev.start > ROUTE_WINDOW_MS) {
+    routeHits.set(ip, { count: 1, start: now });
+    return 1;
+  }
+  prev.count += 1;
+  return prev.count;
+}
+
+// src/runtime/rasp/middleware.ts
+function raspContext() {
+  return function raspContextMiddleware(req, res, next) {
+    const ctx = contextFromRequest(req);
+    try {
+      const credHit = ctx.strings.some((s) => isHoneyCanary(s));
+      const routeHit = isHoneyRoute(ctx.path);
+      if (routeHit && !credHit) {
+        const count = noteHoneyRouteHit(ctx.ip);
+        addThreat(ctx.ip, "honey");
+        emitRaspEvent({
+          ruleId: "RASP-HONEY-001",
+          path: ctx.path,
+          ip: ctx.ip,
+          sample: "honeytoken",
+          severity: "low",
+          count
+        });
+      } else if (credHit) {
+        addThreat(ctx.ip, "honey");
+        emitRaspEvent({
+          ruleId: "RASP-HONEY-001",
+          path: ctx.path,
+          ip: ctx.ip,
+          sample: "canary-credential",
+          severity: "critical"
+        });
+        if (isIpBlocked(ctx.ip)) {
+          if (typeof res.status === "function") {
+            res.status(403).json({ error: "blocked", ruleId: "RASP-HONEY-001" });
+            return;
+          }
+          res.statusCode = 403;
+          res.end?.(JSON.stringify({ error: "blocked", ruleId: "RASP-HONEY-001" }));
+          return;
+        }
+      }
+      const proto = runDecide("proto", null, ctx);
+      if (proto.block && proto.ruleId) {
+        emitRaspEvent({
+          ruleId: proto.ruleId,
+          path: ctx.path,
+          ip: ctx.ip,
+          sample: "prototype-key"
+        });
+        if (raspModeFor(ctx.path, "proto") === "block") {
+          if (typeof res.status === "function") {
+            res.status(403).json({ error: "blocked", ruleId: proto.ruleId });
+            return;
+          }
+          res.statusCode = 403;
+          res.end?.(JSON.stringify({ error: "blocked", ruleId: proto.ruleId }));
+          return;
+        }
+      }
+    } catch (err) {
+      if (err instanceof RaspBlockedError) {
+        if (typeof res.status === "function") {
+          res.status(403).json({ error: "blocked", ruleId: err.ruleId });
+          return;
+        }
+        throw err;
+      }
+      emitRaspEvent({
+        ruleId: RASP_FAIL_OPEN,
+        path: ctx.path,
+        ip: ctx.ip,
+        sample: "hook-error"
+      });
+    }
+    enterRaspContext(ctx, () => {
+      next();
+    });
+  };
+}
+
+// src/runtime/rasp/hooks.ts
+var require2 = createRequire(import.meta.url);
+var restorers = [];
+var wrappedPackages = /* @__PURE__ */ new WeakSet();
+var hooksLive = false;
+var sqliteHookRegistered = false;
+function sampleOf(sink) {
+  if (typeof sink === "string") return sink.slice(0, 40);
+  if (sink === null || sink === void 0) return "";
+  return "[object]";
+}
+function inferPathBase(p) {
+  const ctx = currentRaspContext();
+  if (!ctx) return void 0;
+  for (const s of ctx.strings) {
+    if (!s) continue;
+    const idx = p.indexOf(s);
+    if (idx > 0) return p.slice(0, idx);
+  }
+  return void 0;
+}
+function guardSink(kind, sink, base) {
+  try {
+    const ctx = currentRaspContext();
+    if (ctx) {
+      const decision = runDecide(kind, sink, ctx, base);
+      if (decision.block && decision.ruleId) {
+        emitRaspEvent({
+          ruleId: decision.ruleId,
+          path: ctx.path,
+          ip: ctx.ip,
+          sample: sampleOf(sink)
+        });
+        addThreat(ctx.ip, "block");
+        if (raspModeFor(ctx.path, kind) === "block") throw new RaspBlockedError(decision.ruleId);
+      }
+    }
+  } catch (err) {
+    if (err instanceof RaspBlockedError) throw err;
+    const ctx = currentRaspContext();
+    emitRaspEvent({
+      ruleId: RASP_FAIL_OPEN,
+      path: ctx?.path ?? "/",
+      ip: ctx?.ip ?? "unknown",
+      sample: "hook-error"
+    });
+  }
+}
+function applySink(kind, sink, base, original) {
+  guardSink(kind, sink, base);
+  return original();
+}
+function patchMethod(obj, key, wrapper) {
+  const record = obj;
+  const orig = record[key];
+  if (typeof orig !== "function") return;
+  const wrapped = wrapper(orig);
+  try {
+    Object.defineProperty(wrapped, "name", { value: orig.name });
+  } catch {
+  }
+  record[key] = wrapped;
+  restorers.push(() => {
+    record[key] = orig;
+  });
+}
+function wrapSqlMethod(obj, key) {
+  patchMethod(obj, key, (orig) => {
+    return function(sql, ...rest) {
+      const text = typeof sql === "string" ? sql : sql && typeof sql === "object" && "text" in sql && typeof sql.text === "string" ? sql.text : "";
+      return applySink("sql", text, void 0, () => orig.call(this, sql, ...rest));
+    };
+  });
+}
+function wrapShellCommand(obj, key, shellAlways) {
+  patchMethod(obj, key, (orig) => {
+    return function(...args) {
+      const opts = args[1] && typeof args[1] === "object" ? args[1] : args[2] && typeof args[2] === "object" ? args[2] : void 0;
+      const useShell = shellAlways || opts?.shell === true;
+      if (!useShell) return orig.call(this, ...args);
+      const cmd = typeof args[0] === "string" ? args[0] : "";
+      return applySink("shell", cmd, void 0, () => orig.call(this, ...args));
+    };
+  });
+}
+function wrapFsPath(obj, key) {
+  patchMethod(obj, key, (orig) => {
+    return function(pathArg, ...rest) {
+      const p = typeof pathArg === "string" ? pathArg : Buffer.isBuffer(pathArg) ? pathArg.toString() : pathArg instanceof URL ? pathArg.pathname : typeof pathArg === "number" || typeof pathArg === "boolean" ? String(pathArg) : "";
+      return applySink("path", p, inferPathBase(p), () => orig.call(this, pathArg, ...rest));
+    };
+  });
+}
+function checkEgress(url) {
+  const allow = raspEgressAllow();
+  if (!allow || allow.length === 0) return;
+  let host = "";
+  try {
+    host = new URL(url).hostname;
+  } catch {
+    return;
+  }
+  if (host && !egressAllowed(host, allow)) {
+    const ctx = currentRaspContext();
+    emitRaspEvent({
+      ruleId: "RASP-EGRESS-001",
+      path: ctx?.path ?? "/",
+      ip: ctx?.ip ?? "unknown",
+      sample: host.slice(0, 40)
+    });
+    if (ctx) addThreat(ctx.ip, "block");
+    if (raspModeFor(ctx?.path ?? "/", "ssrf") === "block") throw new RaspBlockedError("RASP-EGRESS-001");
+  }
+}
+function wrapSsrf(obj, key, urlOf) {
+  patchMethod(obj, key, (orig) => {
+    return function(...args) {
+      const url = urlOf(args);
+      checkEgress(url);
+      return applySink("ssrf", url, void 0, () => orig.call(this, ...args));
+    };
+  });
+}
+var WRAP_SQLITE = /* @__PURE__ */ Symbol.for("fullshield.rasp.wrapSqlite");
+var SQLITE_WRAPPED = /* @__PURE__ */ Symbol.for("fullshield.rasp.sqliteWrapped");
+var origModuleLoad;
+function protoFrom(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const proto = value.DatabaseSync?.prototype;
+  if (proto && typeof proto === "object") return proto;
+  return void 0;
+}
+function sqlitePrototype(hint) {
+  const fromHint = protoFrom(hint);
+  if (fromHint) return fromHint;
+  const getBuiltin = process.getBuiltinModule;
+  if (typeof getBuiltin === "function") {
+    try {
+      const fromBuiltin = protoFrom(getBuiltin.call(process, "node:sqlite") ?? getBuiltin.call(process, "sqlite"));
+      if (fromBuiltin) return fromBuiltin;
+    } catch {
+    }
+  }
+  if (origModuleLoad) {
+    try {
+      return protoFrom(origModuleLoad("node:sqlite", void 0, false));
+    } catch {
+    }
+  }
+  return void 0;
+}
+function sqliteAlreadyLoaded() {
+  const list = process.moduleLoadList;
+  return Array.isArray(list) && list.some((entry) => /(?:^| )sqlite$/i.test(entry));
+}
+function wrapSqliteNow(hint) {
+  try {
+    const proto = sqlitePrototype(hint);
+    if (!proto || proto[SQLITE_WRAPPED]) return;
+    Object.defineProperty(proto, SQLITE_WRAPPED, { value: true, configurable: true });
+    wrapSqlMethod(proto, "exec");
+    wrapSqlMethod(proto, "prepare");
+    restorers.push(() => {
+      delete proto[SQLITE_WRAPPED];
+    });
+  } catch {
+  }
+}
+function wrapBuiltins() {
+  globalThis[WRAP_SQLITE] = wrapSqliteNow;
+  const cp = require2("node:child_process");
+  const cpAlias = require2("child_process");
+  for (const mod of /* @__PURE__ */ new Set([cp, cpAlias])) {
+    wrapShellCommand(mod, "exec", true);
+    wrapShellCommand(mod, "execSync", true);
+    wrapShellCommand(mod, "spawn", false);
+    wrapShellCommand(mod, "spawnSync", false);
+    wrapShellCommand(mod, "execFile", false);
+    wrapShellCommand(mod, "execFileSync", false);
+  }
+  const fsNames = [
+    "readFile",
+    "readFileSync",
+    "writeFile",
+    "writeFileSync",
+    "appendFile",
+    "appendFileSync",
+    "open",
+    "openSync",
+    "createReadStream",
+    "createWriteStream",
+    "stat",
+    "statSync",
+    "lstat",
+    "lstatSync",
+    "access",
+    "accessSync",
+    "readdir",
+    "readdirSync",
+    "unlink",
+    "unlinkSync",
+    "rm",
+    "rmSync"
+  ];
+  const fs = require2("node:fs");
+  const fsAlias = require2("fs");
+  for (const mod of /* @__PURE__ */ new Set([fs, fsAlias])) {
+    for (const name of fsNames) wrapFsPath(mod, name);
+  }
+  try {
+    const fsp = require2("node:fs/promises");
+    for (const name of ["readFile", "writeFile", "appendFile", "open", "stat", "lstat", "access", "readdir", "unlink", "rm"]) {
+      wrapFsPath(fsp, name);
+    }
+  } catch {
+  }
+  const http = require2("node:http");
+  const https = require2("node:https");
+  wrapSsrf(http, "request", urlFromHttpArgs);
+  wrapSsrf(http, "get", urlFromHttpArgs);
+  wrapSsrf(https, "request", urlFromHttpArgs);
+  wrapSsrf(https, "get", urlFromHttpArgs);
+  if (typeof globalThis.fetch === "function") {
+    const origFetch = globalThis.fetch;
+    globalThis.fetch = function(input, init) {
+      const start = fetchUrl(input);
+      checkEgress(start);
+      const mode = init?.redirect ?? "follow";
+      if (mode !== "follow") {
+        return applySink("ssrf", start, void 0, () => origFetch.call(this, input, init));
+      }
+      guardSink("ssrf", start);
+      return (async () => {
+        let current = start;
+        let nextInput = input;
+        for (let hop = 0; hop < 8; hop += 1) {
+          const res = await origFetch.call(this, nextInput, { ...init, redirect: "manual" });
+          if (res.status < 300 || res.status >= 400) return res;
+          const loc = res.headers.get("location");
+          if (!loc) return res;
+          current = new URL(loc, current).href;
+          guardSink("ssrf", current);
+          nextInput = current;
+        }
+        return origFetch.call(this, current, init);
+      })();
+    };
+    restorers.push(() => {
+      globalThis.fetch = origFetch;
+    });
+  }
+  const vm = require2("node:vm");
+  for (const name of ["runInNewContext", "runInThisContext", "runInContext", "compileFunction"]) {
+    patchMethod(vm, name, (orig) => {
+      return function(code, ...rest) {
+        return applySink(
+          "sql",
+          typeof code === "string" ? code : "",
+          void 0,
+          () => orig.call(this, code, ...rest)
+        );
+      };
+    });
+  }
+  const Module = require2("node:module");
+  origModuleLoad = Module._load.bind(Module);
+  const origLoad = Module._load;
+  Module._load = function(request, parent, isMain) {
+    const exported = origLoad.call(this, request, parent, isMain);
+    try {
+      return wrapKnownPackage(String(request), exported);
+    } catch {
+      emitRaspEvent({
+        ruleId: RASP_FAIL_OPEN,
+        path: currentRaspContext()?.path ?? "/",
+        ip: currentRaspContext()?.ip ?? "unknown",
+        sample: "hook-error"
+      });
+      return exported;
+    }
+  };
+  restorers.push(() => {
+    Module._load = origLoad;
+    origModuleLoad = void 0;
+  });
+  const registerHooks = Module.registerHooks;
+  if (typeof registerHooks === "function" && !sqliteHookRegistered) {
+    sqliteHookRegistered = true;
+    registerHooks({
+      load(url, context, nextLoad) {
+        const result = nextLoad(url, context);
+        if (hooksLive && typeof url === "string" && (url === "node:sqlite" || url.startsWith("node:sqlite"))) {
+          wrapSqliteNow();
+        }
+        return result;
+      }
+    });
+  }
+  if (sqliteAlreadyLoaded()) wrapSqliteNow();
+}
+function wrapExpressLike(exported) {
+  if (typeof exported !== "function") return;
+  const orig = exported;
+  if (wrappedPackages.has(orig)) return;
+  function patched(...args) {
+    const app = orig.apply(this, args);
+    try {
+      if (app && typeof app.use === "function" && !app.__fullshieldRasp) {
+        app.use(raspContext());
+        app.__fullshieldRasp = true;
+      }
+    } catch {
+      emitRaspEvent({
+        ruleId: RASP_FAIL_OPEN,
+        path: "/",
+        ip: "unknown",
+        sample: "hook-error"
+      });
+    }
+    return app;
+  }
+  Object.assign(patched, orig);
+  Object.setPrototypeOf(patched, orig);
+  wrappedPackages.add(orig);
+  exported.__fullshieldExpressPatch = patched;
+}
+function wrapKnownPackage(request, exported) {
+  if (exported === null || typeof exported !== "object" && typeof exported !== "function") return exported;
+  const obj = exported;
+  if (wrappedPackages.has(obj)) return exported;
+  const name = request.replace(/^node:/, "");
+  if (name === "sqlite") {
+    wrapSqliteNow(exported);
+    return exported;
+  }
+  if (name === "pg" || name.endsWith("/pg")) {
+    const pg = exported;
+    if (pg.Client?.prototype) wrapSqlMethod(pg.Client.prototype, "query");
+    if (pg.Pool?.prototype) wrapSqlMethod(pg.Pool.prototype, "query");
+    wrappedPackages.add(obj);
+    return exported;
+  }
+  if (name === "mysql2" || name.endsWith("/mysql2") || name.includes("mysql2/")) {
+    const mysql = exported;
+    const proto = mysql.Connection?.prototype ?? mysql.prototype;
+    if (proto) {
+      wrapSqlMethod(proto, "query");
+      wrapSqlMethod(proto, "execute");
+    }
+    wrappedPackages.add(obj);
+    return exported;
+  }
+  if (name === "better-sqlite3" || name.endsWith("/better-sqlite3")) {
+    const proto = exported.prototype;
+    if (proto) {
+      wrapSqlMethod(proto, "exec");
+      wrapSqlMethod(proto, "prepare");
+    }
+    wrappedPackages.add(obj);
+    return exported;
+  }
+  if (name === "mongodb" || name.includes("mongodb")) {
+    const col = exported.Collection?.prototype;
+    if (col) {
+      patchMethod(col, "find", (orig) => {
+        return function(query, ...rest) {
+          return applySink("nosql", query ?? {}, void 0, () => orig.call(this, query, ...rest));
+        };
+      });
+    }
+    wrappedPackages.add(obj);
+    return exported;
+  }
+  if (name === "mongoose" || name.includes("mongoose")) {
+    const q = exported.Query?.prototype;
+    if (q) {
+      patchMethod(q, "find", (orig) => {
+        return function(query, ...rest) {
+          return applySink("nosql", query ?? {}, void 0, () => orig.call(this, query, ...rest));
+        };
+      });
+    }
+    wrappedPackages.add(obj);
+    return exported;
+  }
+  if (name === "axios") {
+    const ax = exported;
+    const urlOf = (args) => {
+      const a = args[0];
+      if (typeof a === "string") return a;
+      if (a && typeof a === "object" && "url" in a && typeof a.url === "string") return a.url;
+      return "";
+    };
+    wrapSsrf(ax, "request", urlOf);
+    wrapSsrf(ax, "get", urlOf);
+    wrapSsrf(ax, "post", urlOf);
+    wrappedPackages.add(obj);
+    return exported;
+  }
+  if (name === "express") {
+    wrapExpressLike(exported);
+    const patched = exported.__fullshieldExpressPatch;
+    if (typeof patched === "function") {
+      const resp = exported.response;
+      if (resp && typeof resp.redirect === "function") {
+        patchMethod(resp, "redirect", (orig) => {
+          return function(...args) {
+            const url = typeof args[0] === "string" ? args[0] : typeof args[1] === "string" ? args[1] : "";
+            return applySink("ssrf", url, void 0, () => orig.call(this, ...args));
+          };
+        });
+      }
+      wrappedPackages.add(obj);
+      return patched;
+    }
+  }
+  return exported;
+}
+function installHooks() {
+  hooksLive = true;
+  wrapBuiltins();
+}
+
+// src/runtime/rasp/vpatch.ts
+function patchForcesBlock(patches, route, kind) {
+  return patches.some((p) => {
+    const routeHit = p.route === void 0 || p.route === route;
+    const sinkHit = p.sink === void 0 || p.sink === kind;
+    return routeHit && sinkHit;
+  });
+}
+
+// src/runtime/rasp/enable.ts
+var enabled = false;
+var options = {};
+function raspMode() {
+  return options.mode ?? "monitor";
+}
+function raspModeFor(route, kind) {
+  if (patchForcesBlock(options.virtualPatches ?? [], route, kind)) return "block";
+  return raspMode();
+}
+function raspEgressAllow() {
+  return options.egress?.allow;
+}
+function runDecide(kind, sink, ctx, base) {
+  if (options.decide) return options.decide(kind, sink, ctx);
+  return decideSink(kind, sink, ctx, base);
+}
+function emitRaspEvent(event) {
+  options.onEvent?.(event);
+}
+function enableRasp(opts = {}) {
+  if (!opts.experimental && process.env.FULLSHIELD_EXPERIMENTAL_RASP !== "1") {
+    return;
+  }
+  options = { ...opts, experimental: true };
+  configureThreat({ autoBlock: opts.threatAutoBlock === true, maxBlockMs: opts.threatMaxBlockMs });
+  if (!enabled) {
+    installHooks();
+    enabled = true;
+  }
+}
+function enableRaspFromEnv() {
+  if (process.env.FULLSHIELD_EXPERIMENTAL_RASP !== "1") return;
+  enableRasp({
+    experimental: true,
+    mode: process.env.FULLSHIELD_RASP_MODE === "block" ? "block" : "monitor"
+  });
+}
+
+// src/runtime/auto.ts
+enableRaspFromEnv();