penthera 1.4.0 → 1.6.0

package/lib/jurisdictions/nl.json

@@ -38,6 +38,15 @@
       "content": "Final report: detailed description, root cause, applied and ongoing mitigations, and any cross-border impact."
     }
   ],
+  "cra": {
+    "law": "Cyber Resilience Act, Regulation (EU) 2024/2847, Article 14 (reporting applies from 11 September 2026)",
+    "csirtCoordinator": "NCSC-NL (Nationaal Cyber Security Centrum)",
+    "csirtContact": "https://www.ncsc.nl/contact",
+    "srp": "https://portal.cra-srp.enisa.europa.eu/",
+    "timezone": "Europe/Amsterdam",
+    "source": "https://www.enisa.europa.eu/topics/product-security/vulnerability-services/eu-incident-response-and-cyber-crisis-management/single-reporting-platform-srp/list-of-csirts-designated-as-coordinators",
+    "note": "NCSC-NL is the Dutch CSIRT designated as coordinator on ENISA's list (checked 2026-10-19). It applies if your main establishment is in the Netherlands, i.e. where cybersecurity decisions about your products are predominantly taken (Art. 14(7))."
+  },
   "penalties": "Up to €10M or 2% of global annual turnover. Management can be held personally accountable.",
   "pointers": [
     "Determine whether you are an essential or important entity, and your sector's competent authority.",

package/lib/memory/repo-suppress.js

@@ -25,15 +25,23 @@ const MAX_ENTRIES = 500;
  * entries are dropped with a warning, never guessed at.
  */
 export function loadRepoSuppressions(repoPath, { now = new Date().toISOString() } = {}) {
-  const warnings = [];
   const path = join(repoPath, REPO_SUPPRESS_FILE);
-  if (!existsSync(path)) return { entries: [], warnings, path: null };
+  if (!existsSync(path)) return { entries: [], warnings: [], path: null };
   const st = statSync(path);
   if (!st.isFile()) return { entries: [], warnings: [`${REPO_SUPPRESS_FILE} is not a regular file, ignored`], path };
   if (st.size > MAX_BYTES) return { entries: [], warnings: [`${REPO_SUPPRESS_FILE} is larger than 64 KB, ignored`], path };
+  return parseRepoSuppressions(readFileSync(path), { now, path });
+}
 
+/**
+ * Validate the file's bytes (from disk, or from the git index for the
+ * pre-commit hook). Same rules and result shape as loadRepoSuppressions().
+ */
+export function parseRepoSuppressions(buf, { now = new Date().toISOString(), path = REPO_SUPPRESS_FILE } = {}) {
+  const warnings = [];
+  if (buf.length > MAX_BYTES) return { entries: [], warnings: [`${REPO_SUPPRESS_FILE} is larger than 64 KB, ignored`], path };
   let doc;
-  try { doc = JSON.parse(readFileSync(path, "utf-8")); } catch (e) {
+  try { doc = JSON.parse(buf.toString("utf-8")); } catch (e) {
     return { entries: [], warnings: [`${REPO_SUPPRESS_FILE} is not valid JSON (${e.message}), ignored`], path };
   }
   if (!doc || typeof doc !== "object" || doc.version !== 1 || !Array.isArray(doc.suppress)) {

package/lib/references.json

@@ -127,6 +127,78 @@
     ],
     "attack-chain": [
       "shostack2014threat"
+    ],
+    "dependency-risk": [
+      "ladisa2023sok",
+      "ohm2020backstabber",
+      "zimmermann2019small"
+    ],
+    "license": [
+      "spdxlicenselist"
+    ],
+    "agent-config": [
+      "owasp2025agentic",
+      "owasp2025mcptop10",
+      "greshake2023signed"
+    ],
+    "machine": [
+      "scarfone2008sp800115",
+      "saltzer1975protection"
+    ],
+    "machine-integrity": [
+      "scarfone2008sp800115",
+      "thompson1984reflections"
+    ],
+    "machine-config": [
+      "scarfone2008sp800115",
+      "saltzer1975protection"
+    ],
+    "suspicious-process": [
+      "scarfone2008sp800115"
+    ],
+    "ssh-config": [
+      "scarfone2008sp800115",
+      "saltzer1975protection"
+    ],
+    "rootkit": [
+      "scarfone2008sp800115",
+      "thompson1984reflections"
+    ],
+    "persistence": [
+      "scarfone2008sp800115"
+    ],
+    "network": [
+      "scarfone2008sp800115"
+    ],
+    "system-commands": [
+      "scarfone2008sp800115"
+    ],
+    "suspicious-files": [
+      "scarfone2008sp800115"
+    ],
+    "rkhunter": [
+      "scarfone2008sp800115"
+    ],
+    "permissions": [
+      "scarfone2008sp800115",
+      "saltzer1975protection"
+    ],
+    "malware": [
+      "scarfone2008sp800115"
+    ],
+    "kernel": [
+      "scarfone2008sp800115",
+      "saltzer1975protection"
+    ],
+    "hidden-files": [
+      "scarfone2008sp800115"
+    ],
+    "code-signing": [
+      "scarfone2008sp800115",
+      "thompson1984reflections"
+    ],
+    "browser-extensions": [
+      "scarfone2008sp800115"
     ]
   },
   "sources": {
@@ -369,6 +441,11 @@
       "cite": "MITRE CWE",
       "title": "CWE: Common Weakness Enumeration",
       "url": "https://cwe.mitre.org/"
+    },
+    "spdxlicenselist": {
+      "cite": "SPDX License List",
+      "title": "SPDX License List",
+      "url": "https://spdx.org/licenses/"
     }
   }
 }

package/lib/remediation/index.js

@@ -111,6 +111,15 @@ const RULES = [
     effort: "quick",
     ownerAction: false,
   },
+  {
+    id: "license",
+    match: (f) => f.category === "license",
+    action: "Replace or approve the dependency whose license breaks your policy",
+    why: "A dependency under a license your policy does not allow (strong copyleft such as AGPL in a closed product, or no license at all, which means no rights to use it) is a legal exposure that ships with every release.",
+    fix: "Swap the package for one under an allowed license, or, if legal has reviewed it, add it to `allowPackages` in the `licenses` section of penthera.policy.json with a reason. An UNLICENSED or missing license needs the author to publish one; until then treat it as not usable.",
+    effort: "moderate",
+    ownerAction: true, // a legal call, not a code change
+  },
   {
     id: "dependency-risk",
     match: (f) => f.category === "dependency-risk",

package/lib/retirejs.js

@@ -139,31 +139,83 @@ function extractVersion(text, patterns) {
 
 /**
  * Extract <script src="..."> URLs and inline script blocks from HTML.
+ *
+ * A small tokenizer rather than regexes: the HTML comes from the scanned
+ * target, so tag names match case-insensitively, attributes may use either
+ * quote or none, and a closing tag may carry whitespace or junk before its `>`
+ * (`</script >`, `</SCRIPT foo>`), as browsers accept. This only reads; it
+ * never rewrites or "sanitises" HTML.
  */
 export function extractScripts(html, baseUrl) {
   const scripts = { external: [], inline: [] };
-
-  // External scripts
-  const srcRe = /<script[^>]+src=["']([^"']+)["']/gi;
-  let match;
-  while ((match = srcRe.exec(html))) {
-    let src = match[1];
-    // Resolve relative URLs
-    if (src.startsWith("//")) src = "https:" + src;
-    else if (src.startsWith("/")) src = baseUrl + src;
-    else if (!src.startsWith("http")) src = baseUrl + "/" + src;
-    scripts.external.push(src);
+  const lower = String(html ?? "").toLowerCase();
+  const src0 = String(html ?? "");
+  let pos = 0;
+  while ((pos = lower.indexOf("<script", pos)) !== -1) {
+    const after = lower[pos + 7];
+    // `<scripts>` or `<script-x>` is a different tag.
+    if (after !== undefined && after !== ">" && after !== "/" && !/\s/.test(after)) { pos += 7; continue; }
+    const { attrs, end } = readTag(src0, pos + 7);
+    if (end === -1) break;
+    const src = attrs.src;
+    if (src) {
+      let url = src;
+      if (url.startsWith("//")) url = "https:" + url;
+      else if (url.startsWith("/")) url = baseUrl + url;
+      else if (!url.startsWith("http")) url = baseUrl + "/" + url;
+      scripts.external.push(url);
+    }
+    const close = findScriptClose(lower, end);
+    const body = src0.slice(end, close.start);
+    if (body.trim().length > 10) scripts.inline.push(body);
+    pos = close.end;
   }
+  return scripts;
+}
 
-  // Inline scripts (for version detection)
-  const inlineRe = /<script(?:\s[^>]*)?>([\s\S]*?)<\/script>/gi;
-  while ((match = inlineRe.exec(html))) {
-    if (match[1].trim().length > 10) {
-      scripts.inline.push(match[1]);
+/** Read attributes from just after `<script` to the tag's `>`. */
+function readTag(s, i) {
+  const attrs = Object.create(null);
+  const n = s.length;
+  while (i < n) {
+    while (i < n && (/\s/.test(s[i]) || s[i] === "/")) i++;
+    if (i >= n) return { attrs, end: -1 };
+    if (s[i] === ">") return { attrs, end: i + 1 };
+    let name = "";
+    while (i < n && !/[\s=>/]/.test(s[i])) name += s[i++];
+    while (i < n && /\s/.test(s[i])) i++;
+    let value = "";
+    if (s[i] === "=") {
+      i++;
+      while (i < n && /\s/.test(s[i])) i++;
+      const q = s[i];
+      if (q === '"' || q === "'") {
+        const close = s.indexOf(q, i + 1);
+        if (close === -1) return { attrs, end: -1 };
+        value = s.slice(i + 1, close);
+        i = close + 1;
+      } else {
+        while (i < n && !/[\s>]/.test(s[i])) value += s[i++];
+      }
     }
+    name = name.toLowerCase();
+    if (name && !(name in attrs)) attrs[name] = value;
   }
+  return { attrs, end: -1 };
+}
 
-  return scripts;
+/** Find `</script ...>` (any case, anything up to `>`); unclosed runs to EOF. */
+function findScriptClose(lower, from) {
+  let i = from;
+  while ((i = lower.indexOf("</script", i)) !== -1) {
+    const c = lower[i + 8];
+    if (c === undefined || c === ">" || c === "/" || /\s/.test(c)) {
+      const gt = lower.indexOf(">", i + 8);
+      return { start: i, end: gt === -1 ? lower.length : gt + 1 };
+    }
+    i += 8;
+  }
+  return { start: lower.length, end: lower.length };
 }
 
 // ── Main scanner ─────────────────────────────────────────────────────────

package/lib/rules/regex-guard.js

@@ -0,0 +1,368 @@
+/**
+ * Static ReDoS guard for regexes that come from data: rule packs, community
+ * Nuclei templates. Rule packs scan hostile input (dependency source, agent
+ * configs, response bodies), so a pack must not be able to hang the scanner
+ * by shipping a pattern that backtracks catastrophically.
+ *
+ * V8's regex engine backtracks, and its linear-time engine (the `l` flag)
+ * refuses ordinary bounded repeats like `{64}`, so the guard is structural:
+ * it parses the pattern and refuses the shapes that blow up.
+ *
+ *   1. Length cap (MAX_LENGTH).
+ *   2. No backreferences and no lookaround. Detection rules do not need them,
+ *      and both defeat simple reasoning about cost.
+ *   3. Star height 1: a quantified group may not contain a quantifier
+ *      (`(a+)+`, `(\w*\s?)*`). The exponential case.
+ *   4. A group under an unbounded quantifier may not contain alternation
+ *      (`(a|aa)+`, `(a|a)*`). The other exponential case.
+ *   5. Bounded repeats are capped at MAX_REPEAT.
+ *   6. An unbounded quantifier that is followed by something mandatory may
+ *      not be reachable from every start position (`\s*x`, `[a-z]+@`): each
+ *      start would rescan the rest of the input. Something mandatory before
+ *      it that cannot occur inside its run (`x\s*:`) breaks the chain.
+ *   7. Two quantifiers that can match the same characters, with nothing
+ *      mandatory between them that the first cannot also match (`.*b.*`,
+ *      `\s*\s*`), multiply their cost. A chain with an unbounded member is
+ *      refused; a bounded chain must stay under CHAIN_BUDGET.
+ *
+ * The guard is conservative: it refuses some safe patterns. That is the right
+ * trade for data that arrives from outside the codebase. tests/rule-packs.test.js
+ * fuzzes it: every pattern it accepts must run in bounded time on adversarial
+ * input.
+ */
+
+export const MAX_LENGTH = 512;
+export const MAX_REPEAT = 256;
+export const CHAIN_BUDGET = 1024;
+export const ALLOWED_FLAGS = /^[imsu]*$/;
+
+// The narrower check for community templates (lib/templates.js, added in
+// v1.1.1 as a regex): refuse a quantifier applied to a group that contains a
+// quantifier, at any depth, or a quantifier stacked on another (`a+*`). It
+// keeps user templates working that the strict checkRegex below would refuse.
+// A linear scan rather than a regex, because a regex inspecting a pattern
+// string is itself open to backtracking on input like "((((((".
+const QUANT_START = (src, i) => src[i] === "*" || src[i] === "+" || (src[i] === "{" && /^\{\d+(,\d*)?\}/.test(src.slice(i, i + 24)));
+
+export function hasNestedQuantifier(pattern) {
+  const src = String(pattern);
+  const groups = []; // per open group: does it contain a quantifier?
+  let prevQuant = false;
+  for (let i = 0; i < src.length; i++) {
+    const c = src[i];
+    if (c === "\\") { i++; prevQuant = false; continue; }
+    if (c === "[") {
+      for (i++; i < src.length && src[i] !== "]"; i++) if (src[i] === "\\") i++;
+      prevQuant = false;
+      continue;
+    }
+    if (c === "(") { groups.push(false); prevQuant = false; continue; }
+    if (c === ")") {
+      const inner = groups.pop() || false;
+      if (inner && QUANT_START(src, i + 1)) return true;
+      if (inner && groups.length) groups[groups.length - 1] = true;
+      prevQuant = false;
+      continue;
+    }
+    if (QUANT_START(src, i) || c === "?") {
+      const isQ = c !== "?" || (i > 0 && src[i - 1] !== "(" && !prevQuant);
+      if (c !== "?" && prevQuant) return true; // a+* / a{2}+
+      if (isQ && c !== "?" && groups.length) groups[groups.length - 1] = true;
+      if (c === "{") i = src.indexOf("}", i);
+      prevQuant = c !== "?" ? true : prevQuant;
+      continue;
+    }
+    prevQuant = false;
+  }
+  return false;
+}
+
+class GuardError extends Error {}
+const refuse = (msg) => { throw new GuardError(msg); };
+
+// ── Parser ────────────────────────────────────────────────────────────────
+// A small parser for the subset of JS regex syntax a detection rule needs.
+// Nodes: { type: "alt", branches: Item[][] }, items are { atom, min, max, src }
+// where atom is { type: "char"|"class"|"any"|"anchor"|"group", src, alt? }.
+
+function parse(src, unicode) {
+  let i = 0;
+  const peek = () => src[i];
+
+  function parseAlt(depth) {
+    if (depth > 8) refuse("groups nested deeper than 8");
+    const branches = [[]];
+    while (i < src.length) {
+      const c = peek();
+      if (c === ")") break;
+      if (c === "|") { i++; branches.push([]); continue; }
+      const start = i;
+      const atom = parseAtom(depth);
+      const q = parseQuantifier(atom);
+      branches[branches.length - 1].push({ atom, ...q, src: src.slice(start, i) });
+    }
+    return { type: "alt", branches };
+  }
+
+  function parseAtom(depth) {
+    const c = src[i];
+    if (c === "(") {
+      i++;
+      if (src.startsWith("?:", i)) i += 2;
+      else if (src.startsWith("?=", i) || src.startsWith("?!", i) || src.startsWith("?<=", i) || src.startsWith("?<!", i)) refuse("lookaround is not allowed");
+      else if (src.startsWith("?<", i)) {
+        const end = src.indexOf(">", i);
+        if (end < 0) refuse("unterminated group name");
+        i = end + 1;
+      } else if (c === "(" && src[i] === "?") refuse("unsupported group syntax");
+      const alt = parseAlt(depth + 1);
+      if (src[i] !== ")") refuse("unterminated group");
+      i++;
+      return { type: "group", alt };
+    }
+    if (c === "[") return parseClass();
+    if (c === "\\") return parseEscape();
+    if (c === ".") { i++; return { type: "any", src: "." }; }
+    if (c === "^" || c === "$") { i++; return { type: "anchor", src: c }; }
+    if (c === "*" || c === "+" || c === "?" || c === "{" && /^\{\d/.test(src.slice(i))) refuse("quantifier with nothing to repeat");
+    if (c === "]" || c === "}") { if (unicode) refuse(`lone ${c}`); }
+    i++;
+    return { type: "char", src: c };
+  }
+
+  function parseEscape() {
+    const start = i;
+    i++;
+    const c = src[i];
+    if (c === undefined) refuse("trailing backslash");
+    if (/[1-9]/.test(c)) refuse("backreferences are not allowed");
+    if (c === "k" && src[i + 1] === "<") refuse("backreferences are not allowed");
+    if (c === "b" || c === "B") { i++; return { type: "anchor", src: src.slice(start, i) }; }
+    if (c === "x") i += 3;
+    else if (c === "u" && src[i + 1] === "{") i = src.indexOf("}", i) + 1 || refuse("bad \\u{} escape");
+    else if (c === "u") i += 5;
+    else if ((c === "p" || c === "P") && src[i + 1] === "{") i = src.indexOf("}", i) + 1 || refuse("bad \\p{} escape");
+    else if (c === "c") i += 2;
+    else i++;
+    const s = src.slice(start, i);
+    return { type: /^\\[dDwWsSpP]/.test(s) ? "class" : "char", src: s };
+  }
+
+  function parseClass() {
+    const start = i;
+    i++;
+    if (src[i] === "^") i++;
+    if (src[i] === "]") i++;
+    while (i < src.length && src[i] !== "]") {
+      if (src[i] === "\\") {
+        if (/[1-9]/.test(src[i + 1] || "")) refuse("backreferences are not allowed");
+        i += 2;
+      } else if (src[i] === "[" && unicode) refuse("nested classes are not allowed");
+      else i++;
+    }
+    if (src[i] !== "]") refuse("unterminated character class");
+    i++;
+    return { type: "class", src: src.slice(start, i) };
+  }
+
+  function parseQuantifier(atom) {
+    let min = 1;
+    let max = 1;
+    const c = src[i];
+    if (c === "*") { min = 0; max = Infinity; i++; }
+    else if (c === "+") { min = 1; max = Infinity; i++; }
+    else if (c === "?") { min = 0; max = 1; i++; }
+    else if (c === "{") {
+      const m = /^\{(\d+)(,(\d*))?\}/.exec(src.slice(i));
+      if (!m) return { min, max };
+      min = Number(m[1]);
+      max = m[2] ? (m[3] === "" ? Infinity : Number(m[3])) : min;
+      if (max < min) refuse("quantifier range out of order");
+      if (min > MAX_REPEAT || (max !== Infinity && max > MAX_REPEAT)) refuse(`repeat count above ${MAX_REPEAT}`);
+      i += m[0].length;
+    } else return { min, max };
+    if (atom.type === "anchor") refuse("quantified anchor");
+    if (src[i] === "?") i++; // lazy: same cost bound as greedy
+    if (src[i] === "*" || src[i] === "+" || src[i] === "?" || (src[i] === "{" && /^\{\d+(,\d*)?\}/.test(src.slice(i)))) refuse("stacked quantifiers");
+    return { min, max };
+  }
+
+  const ast = parseAlt(0);
+  if (i < src.length) refuse("unbalanced parenthesis");
+  return ast;
+}
+
+// ── Character sets ────────────────────────────────────────────────────────
+// Approximated by membership over a sample alphabet: all of ASCII plus
+// representatives of the Unicode classes rules tend to touch. Two atoms
+// "overlap" if some sample character matches both.
+
+const SAMPLE = (() => {
+  const out = [];
+  for (let c = 0; c < 128; c++) out.push(String.fromCharCode(c));
+  out.push(" ", "é", "ß", "İ", "
", "​", "中", "а", "", "\u{1F600}");
+  return out;
+})();
+
+const setCache = new Map();
+function charSet(src, flags) {
+  const key = `${flags}\u0000${src}`;
+  let set = setCache.get(key);
+  if (set) return set;
+  const re = new RegExp(`^(?:${src})$`, flags.replace(/[gy]/g, ""));
+  set = new Uint8Array(SAMPLE.length);
+  for (let k = 0; k < SAMPLE.length; k++) set[k] = re.test(SAMPLE[k]) ? 1 : 0;
+  if (setCache.size > 5000) setCache.clear();
+  setCache.set(key, set);
+  return set;
+}
+const overlaps = (a, b) => a.some((v, k) => v && b[k]);
+const subset = (a, b) => a.every((v, k) => !v || b[k]);
+const union = (sets) => sets.reduce((acc, s) => acc.map((v, k) => v | s[k]), new Uint8Array(SAMPLE.length));
+
+/** Characters an item can consume (any one position), or null for anchors. */
+function itemSet(item, flags) {
+  const a = item.atom;
+  if (a.type === "anchor") return null;
+  if (a.type !== "group") return charSet(a.src, flags);
+  const sets = [];
+  for (const br of a.alt.branches) for (const it of br) { const s = itemSet(it, flags); if (s) sets.push(s); }
+  return union(sets);
+}
+
+function hasQuantifier(alt) {
+  return alt.branches.some((br) => br.some((it) => it.max > 1 || (it.atom.type === "group" && hasQuantifier(it.atom.alt))));
+}
+
+/** Largest max among quantifiers inside a group (Infinity if any unbounded). */
+function innerMax(alt) {
+  let m = 1;
+  for (const br of alt.branches) for (const it of br) {
+    m = Math.max(m, it.max);
+    if (it.atom.type === "group") m = Math.max(m, innerMax(it.atom.alt));
+  }
+  return m;
+}
+
+// ── Rules ─────────────────────────────────────────────────────────────────
+
+function checkStructure(alt) {
+  for (const br of alt.branches) for (const it of br) {
+    if (it.atom.type !== "group") continue;
+    const g = it.atom.alt;
+    if (it.max > 1 && hasQuantifier(g)) refuse(`nested quantifier in \`${it.src}\``);
+    if (it.max === Infinity && g.branches.length > 1) refuse(`alternation under an unbounded quantifier in \`${it.src}\``);
+    checkStructure(g);
+  }
+}
+
+const MAX_PATHS = 256;
+
+/**
+ * Expand a branch into the linear sequences of leaf items it can match.
+ * A group that is not repeated (`(?:a|b)`, `(?:sudo\s+)?`) is inlined once
+ * per alternative, plus a "skipped" path when it is optional, so quantifiers
+ * on either side of it are compared along each real path. A repeated group
+ * becomes one leaf (rule 3 guarantees it holds no quantifier). Past MAX_PATHS
+ * the remaining groups collapse to one conservative leaf each.
+ */
+function expand(branch, flags) {
+  let seqs = [[]];
+  for (const it of branch) {
+    const a = it.atom;
+    if (a.type === "anchor") continue;
+    if (a.type === "group" && it.max <= 1) {
+      const alts = a.alt.branches.flatMap((b) => expand(b, flags));
+      if (it.min === 0) alts.push([]);
+      if (seqs.length * alts.length <= MAX_PATHS) {
+        seqs = seqs.flatMap((s) => alts.map((x) => s.concat(x)));
+        continue;
+      }
+      const leaf = { set: itemSet(it, flags), min: it.min, max: innerMax(a.alt), src: it.src };
+      seqs = seqs.map((s) => s.concat([leaf]));
+      continue;
+    }
+    const leaf = { set: itemSet(it, flags), min: it.min, max: it.max, src: it.src };
+    seqs = seqs.map((s) => s.concat([leaf]));
+  }
+  return seqs;
+}
+
+/**
+ * Rule 6. An unanchored search tries every start position. An unbounded
+ * quantifier followed by something mandatory rescans its run from each start
+ * that can reach it, which is quadratic when everything mandatory before it
+ * can also sit inside that run (`\s*x`, `[^a]{1,40}\S[ab]* ` on "bbbb").
+ * A greedy quantifier with nothing mandatory after it succeeds at once.
+ */
+function checkRescan(seq, anchored) {
+  if (anchored) return;
+  for (let q = 0; q < seq.length; q++) {
+    const it = seq[q];
+    if (it.max !== Infinity) continue;
+    if (!seq.slice(q + 1).some((x) => x.min > 0)) continue;
+    if (seq.slice(0, q).every((x) => x.min === 0 || overlaps(x.set, it.set))) {
+      refuse(q === 0 || seq.slice(0, q).every((x) => x.min === 0)
+        ? `pattern starts with an unbounded quantifier (\`${it.src}\`)`
+        : `unbounded quantifier \`${it.src}\` can be rescanned from every start position`);
+    }
+  }
+}
+
+function checkChains(alt, flags) {
+  for (const br of alt.branches) for (const seq of expand(br, flags)) {
+    checkRescan(seq, br[0]?.atom.type === "anchor" && br[0].atom.src === "^" && !flags.includes("m"));
+    for (let a = 0; a < seq.length; a++) {
+      const head = seq[a];
+      if (head.max <= 1) continue;
+      let cost = head.max;
+      const mids = []; // mandatory atoms between head and the current item
+      for (let b = a + 1; b < seq.length; b++) {
+        const it = seq[b];
+        // The costs multiply when the head can stop inside the item's run:
+        // they share characters, and every mandatory atom in between can sit
+        // in that run too (`.*b.*` on "bbbb"). `[^\n]*\|\s*` stays linear,
+        // because `|` cannot occur inside a run of spaces.
+        if (it.max > 1 && overlaps(head.set, it.set) && mids.every((m) => overlaps(m, it.set))) {
+          cost = cost * it.max;
+          if (cost === Infinity) refuse(`overlapping quantifiers \`${head.src}\` … \`${it.src}\` (polynomial backtracking)`);
+          if (cost > CHAIN_BUDGET) refuse(`overlapping quantifiers \`${head.src}\` … \`${it.src}\` exceed the backtracking budget`);
+        }
+        // A mandatory atom the head cannot match ends the head's reach.
+        if (it.min > 0) {
+          if (!subset(it.set, head.set)) break;
+          mids.push(it.set);
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Check a regex from data. Returns { ok: true } or { ok: false, reason }.
+ * Never throws.
+ * @param {string} source pattern source (no slashes)
+ * @param {string} [flags] only i, m, s, u are accepted
+ */
+export function checkRegex(source, flags = "") {
+  try {
+    if (typeof source !== "string" || source.length === 0) refuse("pattern must be a non-empty string");
+    if (typeof flags !== "string" || !ALLOWED_FLAGS.test(flags)) refuse(`flags must be a subset of "imsu" (got "${flags}")`);
+    if (source.length > MAX_LENGTH) refuse(`pattern longer than ${MAX_LENGTH} characters`);
+    try { new RegExp(source, flags); } catch (e) { refuse(`invalid regex: ${e.message}`); }
+    const ast = parse(source, flags.includes("u"));
+    checkStructure(ast);
+    checkChains(ast, flags);
+    return { ok: true };
+  } catch (e) {
+    if (e instanceof GuardError) return { ok: false, reason: e.message };
+    return { ok: false, reason: `guard error: ${e.message}` };
+  }
+}
+
+/** Compile a regex from data, or throw with the guard's reason. */
+export function compileSafe(source, flags = "") {
+  const r = checkRegex(source, flags);
+  if (!r.ok) throw new Error(`unsafe regex /${String(source).slice(0, 80)}/: ${r.reason}`);
+  return new RegExp(source, flags);
+}

package/lib/templates.js

@@ -6,6 +6,7 @@
  */
 import { joinUrl } from "../src/utils/url.js";
 import { request } from "../src/utils/http.js";
+import { hasNestedQuantifier } from "./rules/regex-guard.js";
 
 /**
  * Execute a single template check against a target.
@@ -88,10 +89,11 @@ export async function executeTemplate(baseUrl, template) {
 // the input and the pattern. This is a mitigation, not an immunity proof: real
 // guarantees need a non-backtracking engine or a killable worker.
 const REGEX_INPUT_CAP = 256 * 1024; // 256 KB is far past any real matcher's needs
-const NESTED_QUANTIFIER = /(\([^)]*[+*][^)]*\)|\[[^\]]*\][^)]*)[+*]\s*[+*]|\((?:\?:)?[^)]*[+*]\)[+*]/;
+// hasNestedQuantifier lives in lib/rules/regex-guard.js. Templates from rule
+// packs pass the stricter checkRegex there when the pack loads.
 
 function safeRegexTest(pattern, target, flags = "") {
-  if (NESTED_QUANTIFIER.test(String(pattern))) return false; // refuse the shape that blows up
+  if (hasNestedQuantifier(pattern)) return false; // refuse the shape that blows up
   try {
     const input = target.length > REGEX_INPUT_CAP ? target.slice(0, REGEX_INPUT_CAP) : target;
     return new RegExp(pattern, flags).test(input);
@@ -100,7 +102,7 @@ function safeRegexTest(pattern, target, flags = "") {
   }
 }
 
-function runMatcher(matcher, ctx) {
+export function runMatcher(matcher, ctx) {
   const part = matcher.part || "body";
   const target = part === "header" ? ctx.headers : ctx.body;
 
@@ -142,16 +144,21 @@ function runMatcher(matcher, ctx) {
 /**
  * Run a single extractor against response data.
  */
-function runExtractor(extractor, ctx) {
+export function runExtractor(extractor, ctx) {
   const part = extractor.part || "body";
   const target = part === "header" ? ctx.headers : ctx.body;
 
   switch (extractor.type) {
     case "regex": {
       for (const pattern of extractor.regex || []) {
-        if (NESTED_QUANTIFIER.test(String(pattern))) continue;
+        if (hasNestedQuantifier(pattern)) continue;
         const capped = target.length > REGEX_INPUT_CAP ? target.slice(0, REGEX_INPUT_CAP) : target;
-        const match = capped.match(new RegExp(pattern));
+        let match;
+        try {
+          match = capped.match(new RegExp(pattern));
+        } catch {
+          continue; // invalid pattern in a template must not abort the scan
+        }
         if (match) return match[extractor.group || 0];
       }
       return null;