@blamejs/blamejs-shop 0.5.3 → 0.5.5

package/lib/vendor/blamejs/lib/flag-targeting.js

@@ -27,6 +27,8 @@
  */
 
 var validateOpts = require("./validate-opts");
+var lazyRequire = require("./lazy-require");
+var guardRegex = lazyRequire(function () { return require("./guard-regex"); });
 var { defineClass } = require("./framework-error");
 var FlagError = defineClass("FlagError", { alwaysPermanent: true });
 
@@ -171,8 +173,19 @@ function validateRules(rules, label) {
           throw new FlagError("flag/bad-condition",
             clabel + ".value: regex pattern must be <= 200 chars (DoS defense)");
         }
+        // The compiled regex is .test()'d against runtime attribute values, so a
+        // catastrophic-backtracking (ReDoS) pattern is a DoS vector. A length
+        // bound does NOT defend ReDoS (`(a+)+$` is 6 chars); screen the pattern
+        // through b.guardRegex first — it refuses nested-quantifier / alternation-
+        // quantifier / lookaround-quantifier shapes before compilation.
         try {
-          // allow:dynamic-regex — operator-supplied targeting pattern, length-bounded to 200 chars above
+          guardRegex().sanitize(cond.value, { profile: "strict" });
+        } catch (ge) {
+          throw new FlagError("flag/bad-condition",
+            clabel + ".value: regex pattern rejected as unsafe (ReDoS shape) - " + ge.message);
+        }
+        try {
+          // allow:dynamic-regex — operator targeting pattern, ReDoS-screened via guardRegex.sanitize (strict) + length-bounded to 200 chars above
           validatedCond._compiledRegex = new RegExp(cond.value);
         } catch (e) {
           throw new FlagError("flag/bad-condition",

package/lib/vendor/blamejs/lib/guard-regex.js

@@ -128,19 +128,68 @@ var DEFAULTS = gateContract.strictDefaults(PROFILES);
 
 var COMPLIANCE_POSTURES = gateContract.compliancePostures(PROFILES, { base: 256 });
 
+// Structural nested-unbounded-quantifier detector. NESTED_QUANT_RE is paren-
+// blind (its `[^()]*` can't span a nested group), so it misses WRAPPED forms
+// like `((a)+)+` / `(([a-z]+)*)*` / `((a+))+` — adding one extra group around
+// the inner quantifier bypasses the regex while the pattern stays catastrophic.
+// This linear scan tracks group nesting and flags an unbounded-quantified group
+// (`)+`, `)*`, `){n,}`) whose body itself contains an unbounded quantifier — the
+// two-nested-unbounded-quantifier ReDoS class — at any group depth. Bounded
+// repeats (`{n}`, `{n,m}`, `?`) are not unbounded, so they don't trip it (the
+// large-bound case is handled separately by maxBoundedRepeat).
+function _hasNestedQuantifier(src) {
+  var stack = [];        // open groups: each { quant } — body has an unbounded quantifier
+  var inClass = false;   // inside a [...] character class
+  var i = 0;
+  var n = src.length;
+  var UNBOUNDED_AFTER_GROUP = /^(?:[*+]\??|\{\d*,\})/;   // )+ )* )+? )*? ){n,}
+  while (i < n) {
+    var c = src.charAt(i);
+    if (c === "\\") { i += 2; continue; }                          // escaped atom — skip both chars
+    if (inClass) { if (c === "]") inClass = false; i += 1; continue; }
+    if (c === "[") { inClass = true; i += 1; continue; }
+    if (c === "(") { stack.push({ quant: false }); i += 1; continue; }
+    if (c === ")") {
+      var grp = stack.pop() || { quant: false };
+      var qm = UNBOUNDED_AFTER_GROUP.exec(src.slice(i + 1));       // allow:regex-no-length-cap — bounded slice of a maxPatternBytes-capped input
+      var closeUnbounded = qm !== null;
+      if (grp.quant && closeUnbounded) return true;               // nested unbounded quantifier → catastrophic
+      // The closing group contributes an unbounded quantifier to its PARENT's
+      // body if its own body had one, or if it is itself unbounded-quantified.
+      if (stack.length && (grp.quant || closeUnbounded)) stack[stack.length - 1].quant = true;
+      i += 1 + (qm ? qm[0].length : 0);
+      continue;
+    }
+    if (c === "*" || c === "+") {                                  // unbounded quantifier on the preceding atom
+      if (stack.length) stack[stack.length - 1].quant = true;
+      i += 1; continue;
+    }
+    if (c === "{") {
+      var open = /^\{\d*,\}/.exec(src.slice(i));                  // allow:regex-no-length-cap — bounded slice // {n,} unbounded
+      if (open) { if (stack.length) stack[stack.length - 1].quant = true; i += open[0].length; continue; }
+      var bounded = /^\{\d+(?:,\d+)?\}/.exec(src.slice(i));       // allow:regex-no-length-cap — bounded slice // {n} / {n,m} bounded
+      if (bounded) { i += bounded[0].length; continue; }
+      i += 1; continue;                                            // literal `{`
+    }
+    i += 1;
+  }
+  return false;
+}
+
 
 function _detectIssues(input, opts) {
   var pre = gateContract.detectStringInput(input, opts, { name: "regex", noun: "regex pattern", cap: { bytes: opts.maxPatternBytes, kind: "pattern-cap", snippet: "regex pattern exceeds maxPatternBytes " + opts.maxPatternBytes } });
   if (pre.done) return pre.issues;
   var issues = pre.issues;
 
-  if (opts.nestedQuantPolicy !== "allow" && NESTED_QUANT_RE.test(input)) {       // allow:regex-no-length-cap — input bounded by maxPatternBytes
+  if (opts.nestedQuantPolicy !== "allow" &&
+      (NESTED_QUANT_RE.test(input) || _hasNestedQuantifier(input))) {            // allow:regex-no-length-cap — input bounded by maxPatternBytes
     issues.push({
       kind: "nested-quantifier", severity: "critical",
       ruleId: "regex.nested-quantifier",
       snippet: "pattern contains nested-quantifier shape (e.g. " +
-               "`(a+)+`) — canonical ReDoS catastrophic-backtracking " +
-               "class (CVE-2024-21538 cross-spawn / CVE-2022-25929)",
+               "`(a+)+` / `((a)+)+`) — canonical ReDoS catastrophic-" +
+               "backtracking class (CVE-2024-21538 cross-spawn / CVE-2022-25929)",
     });
   }
 

package/lib/vendor/blamejs/lib/mcp.js

@@ -37,6 +37,8 @@ var safeJson = require("./safe-json");
 var safeBuffer = require("./safe-buffer");
 var requestHelpers = require("./request-helpers");
 var audit = require("./audit");
+var lazyRequire = require("./lazy-require");
+var guardRegex = lazyRequire(function () { return require("./guard-regex"); });
 var { McpError } = require("./framework-error");
 
 var TOOL_NAME_MAX     = 64;                                                                  // string-length cap, not bytes
@@ -642,8 +644,14 @@ function _validateValueAgainstSchema(value, schema, path) {
       // cost scales with the number of code units the engine scans, so 4096
       // chars is the correct ReDoS bound regardless of UTF-8 byte size.
       if (value.length > 4096) return path + ": value exceeds 4096-char cap before regex test";    // ReDoS char cap (not bytes)
+      // The input-length cap above does NOT bound catastrophic backtracking
+      // (a `(a+)+$` pattern blows up at ~40 input chars). Screen the tool
+      // author's pattern through b.guardRegex so a ReDoS-shaped schema pattern
+      // can't pin a CPU when matched against request input.
+      try { guardRegex().sanitize(schema.pattern, { profile: "strict" }); }
+      catch (_ge) { return path + ": schema pattern rejected as unsafe (ReDoS shape)"; }
       try {
-        var pat = new RegExp(schema.pattern);                                                    // allow:dynamic-regex — schema.pattern from registered tool author, not request input; bounded above
+        var pat = new RegExp(schema.pattern);                                                    // allow:dynamic-regex — schema.pattern is ReDoS-screened via guardRegex.sanitize (strict) above + input length-capped
         if (!pat.test(value)) return path + ": does not match pattern";
       }
       catch (_e) { return path + ": invalid pattern in schema"; }

package/lib/vendor/blamejs/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blamejs/core",
-  "version": "0.15.37",
+  "version": "0.15.38",
   "description": "The Node framework that owns its stack.",
   "license": "Apache-2.0",
   "author": "blamejs contributors",

package/lib/vendor/blamejs/release-notes/v0.15.38.json

@@ -0,0 +1,26 @@
+{
+  "$schema": "../scripts/release-notes-schema.json",
+  "version": "0.15.38",
+  "date": "2026-06-27",
+  "headline": "Regex patterns supplied in feature-flag targeting rules and MCP tool input schemas are now screened for catastrophic-backtracking (ReDoS) shapes before compilation, so a pattern matched against request data can't pin a CPU",
+  "summary": "Two places compiled a caller-supplied regex pattern and `.test()`'d it against request-controlled input with only a length bound as the stated defense: a feature-flag targeting condition (`op: \"regex\"`) matched against runtime attribute values, and an MCP tool's input-schema `pattern` matched against tool-call arguments. A length bound is not a ReDoS defense — a catastrophic-backtracking pattern such as `(a+)+$` is six characters and pins a CPU on a crafted input. Both patterns now pass through `b.guardRegex` (strict profile) before compilation, which refuses nested-quantifier, alternation-with-quantifier, and quantifier-inside-lookaround shapes. A ReDoS-shaped flag pattern is refused when the rules are validated; a ReDoS-shaped MCP schema pattern fails tool-input validation. Patterns built from the framework's own static tables, operator-owned JSON Schema patterns, the Sieve glob translator (which cannot express nested quantifiers), and the I-Regexp translator (linear by dialect) are unchanged.",
+  "sections": [
+    {
+      "heading": "Security",
+      "items": [
+        {
+          "title": "Feature-flag regex targeting conditions are screened for ReDoS before compilation",
+          "body": "A flag targeting rule with `op: \"regex\"` compiled the operator-supplied pattern and `.test()`'d it against runtime attribute values, guarded only by a 200-character length cap. Length does not bound catastrophic backtracking, so a pattern like `(a+)+$` combined with an attacker-controlled attribute value could pin a CPU during flag evaluation. The pattern is now screened through b.guardRegex (strict) when the rules are validated, and a catastrophic-backtracking shape is refused with a clear error."
+        },
+        {
+          "title": "MCP tool input-schema patterns are screened for ReDoS before matching request input",
+          "body": "b.mcp.validateToolInput compiled a tool author's input-schema `pattern` and matched it against tool-call argument values; the 4096-character input cap does not bound backtracking (a `(a+)+$` pattern blows up at roughly forty input characters). The schema pattern is now screened through b.guardRegex (strict) before compilation, so a ReDoS-shaped pattern in a registered tool's schema fails input validation instead of letting hostile arguments hang the validator."
+        },
+        {
+          "title": "b.guardRegex now catches wrapped nested-quantifier patterns",
+          "body": "The nested-quantifier detector matched a quantified group whose body contained a quantifier, but its inner match was paren-blind, so wrapping the inner quantifier in an extra group — `((a)+)+`, `(([a-z]+)*)*`, `((a+))+` — slipped past it while remaining catastrophic. A structural scan now tracks group nesting and refuses an unbounded-quantified group whose body itself contains an unbounded quantifier at any depth, so the wrapped forms are rejected alongside the bare `(a+)+`. Bounded repeats (`{n}`, `{n,m}`) are unaffected. This strengthens every b.guardRegex caller, including the flag-targeting and MCP screening above."
+        }
+      ]
+    }
+  ]
+}

package/lib/vendor/blamejs/test/layer-0-primitives/flag.test.js

@@ -240,6 +240,30 @@ function run() {
     },
     /invalid regex/);
 
+  // ReDoS-shaped pattern (nested quantifier) refused. The compiled regex is
+  // .test()'d against runtime (request) attribute values, so a catastrophic-
+  // backtracking pattern is a DoS vector; the 200-char length bound is NOT a
+  // ReDoS defense (`(a+)+$` is 6 chars). The pattern is screened through
+  // b.guardRegex before compilation.
+  rejects("targeting: ReDoS-shaped regex (nested quantifier) refused",
+    function () {
+      t.validateRules([{ variant: "v", conditions: [{ attribute: "x", op: "regex", value: "(a+)+$" }] }]);
+    },
+    /unsafe|ReDoS|backtrack|quantifier/i);
+  // Wrapping the inner quantified atom in an extra group — `((a)+)+$` — is the
+  // same catastrophic-backtracking class; a paren-blind `[^()]*` detector misses
+  // it. The structural screener must still refuse these nested-group forms.
+  rejects("targeting: wrapped nested-quantifier regex refused",
+    function () {
+      t.validateRules([{ variant: "v", conditions: [{ attribute: "x", op: "regex", value: "((a)+)+$" }] }]);
+    },
+    /unsafe|ReDoS|backtrack|quantifier/i);
+  rejects("targeting: deeper wrapped nested-quantifier regex refused",
+    function () {
+      t.validateRules([{ variant: "v", conditions: [{ attribute: "x", op: "regex", value: "(([a-z]+)*)*$" }] }]);
+    },
+    /unsafe|ReDoS|backtrack|quantifier/i);
+
   // nested attribute path
   var pathRules = t.validateRules([
     { variant: "v1", conditions: [{ attribute: "user.role", op: "eq", value: "admin" }] },

package/lib/vendor/blamejs/test/layer-0-primitives/mcp.test.js

@@ -122,6 +122,21 @@ async function run() {
   } catch (e) { threw = /tool-input-invalid/.test(e.code); }
   check("mcp.validateToolInput: schema mismatch refused",            threw);
 
+  // A tool-author schema pattern with a catastrophic-backtracking (ReDoS) shape
+  // is compiled and .test()'d against request input — the 4096-char input cap
+  // does not bound backtracking. The pattern is screened through b.guardRegex
+  // and a ReDoS shape is refused. (`"aaa"` matches `(a+)+$` instantly, so the
+  // pre-fix path does not hang.)
+  threw = false; var redosMsg = "";
+  try {
+    b.mcp.validateToolInput("t", { x: "aaa" }, {
+      type: "object",
+      properties: { x: { type: "string", pattern: "(a+)+$" } },
+      required: ["x"],
+    });
+  } catch (e) { threw = true; redosMsg = e.message || ""; }
+  check("mcp.validateToolInput: ReDoS-shaped schema pattern refused", threw && /unsafe|ReDoS/i.test(redosMsg));
+
   // ---- v0.8.77: assertProtocolVersion / sampling / elicitation ----
   threw = false;
   try { b.mcp.assertProtocolVersion({ headers: {} }); }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blamejs/blamejs-shop",
-  "version": "0.5.3",
+  "version": "0.5.5",
   "description": "Open-source framework built on blamejs. Vendored stack, zero npm runtime deps, PQC-first crypto, security-on by default.",
   "main": "lib/index.js",
   "scripts": {