residoo 0.3.1 → 0.3.3

package/README.md

@@ -292,7 +292,7 @@ As a GitHub Action (this repository doubles as a composite action):
 ```yaml
 steps:
   - uses: actions/checkout@v4
-  - uses: dandovdub/residoo@v0.3.0
+  - uses: dandovdub/residoo@v0.3.3
 ```
 
 As a pre-commit hook:
@@ -300,7 +300,7 @@ As a pre-commit hook:
 ```yaml
 repos:
   - repo: https://github.com/dandovdub/residoo
-    rev: v0.3.0
+    rev: v0.3.3
     hooks:
       - id: residoo
 ```

package/SECURITY.md

@@ -45,8 +45,19 @@ just asserted. See the git history for the actual commands run:
 - **Not vulnerable to regex denial-of-service.** Every pattern checked
   against the nested-quantifier shape behind real, dated CVEs in adjacent
   tooling (e.g. CVE-2026-0621, a ReDoS in Anthropic's own MCP SDK from
-  catastrophic backtracking on an exploded template pattern). Also stress-
-  tested directly against multi-megabyte adversarial inputs.
+  catastrophic backtracking on an exploded template pattern). A second,
+  distinct failure mode was found and fixed during a pre-launch audit: an
+  open-ended quantifier (`{n,}`) matching a multi-megabyte same-charset run
+  can overflow V8's regex engine on stack depth alone, independent of
+  catastrophic backtracking. The raw-match, base64-decode, and split-line
+  passes shared one try/catch at the time, so a crash partway through the
+  rule list could silently skip every rule after it for that line. Every
+  rule's quantifier is now explicitly bounded to its format's real maximum
+  length (a credential shape has a knowable ceiling), each of the three
+  passes has its own try/catch as a second, independent layer, and a
+  regression test asserts a real secret placed immediately after a
+  multi-megabyte adversarial run is still found. Stress-tested directly
+  against multi-megabyte adversarial inputs, including that exact shape.
 - **No supply-chain surface.** Zero runtime dependencies, zero
   pre/post-install lifecycle scripts. Check `package.json` yourself;
   there's nothing to hide behind a `postinstall` hook.

package/package.json

@@ -1,19 +1,45 @@
 {
   "name": "residoo",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "Find secrets leaking through your AI coding agent's session history. Zero network calls in the scan path, zero dependencies.",
   "license": "MIT",
   "author": "CloudRoam (https://cloudroam.io)",
-  "repository": { "type": "git", "url": "git+https://github.com/dandovdub/residoo.git" },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dandovdub/residoo.git"
+  },
   "homepage": "https://github.com/dandovdub/residoo#readme",
-  "bugs": { "url": "https://github.com/dandovdub/residoo/issues" },
-  "bin": { "residoo": "bin/residoo.js" },
+  "bugs": {
+    "url": "https://github.com/dandovdub/residoo/issues"
+  },
+  "bin": {
+    "residoo": "bin/residoo.js"
+  },
   "main": "src/cli.js",
-  "engines": { "node": ">=18" },
-  "scripts": { "test": "node tests/smoke.js" },
-  "files": ["bin", "src", "README.md", "SECURITY.md", "LICENSE"],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "test": "node tests/smoke.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md",
+    "SECURITY.md",
+    "LICENSE"
+  ],
   "keywords": [
-    "security", "secrets", "secret-scanning", "ai-agent", "claude-code",
-    "cursor", "copilot", "mcp", "privacy", "cli", "encryption"
+    "security",
+    "secrets",
+    "secret-scanning",
+    "ai-agent",
+    "claude-code",
+    "cursor",
+    "copilot",
+    "mcp",
+    "privacy",
+    "cli",
+    "encryption"
   ]
 }

package/src/decode.js

@@ -49,9 +49,14 @@
 //    is recovered by retrying the decode with ONE edge chunk dropped — but
 //    only one, and only at an edge: junk on both edges, or prose merged into
 //    the middle of a blob, still loses the whole candidate.
-//  - At most B64_MAX_CANDIDATES candidates are decoded per line; a line with
-//    more encoded runs than that is reported by the caller as only partially
-//    checked rather than silently truncated.
+//  - There is deliberately NO per-line candidate cap. Real transcript lines
+//    routinely hold hundreds of decode-sized alnum runs (uuids, hashes,
+//    request ids), so any cap either silently starves a genuine blob
+//    sitting past it or flags nearly every real file as partially checked.
+//    None is needed for cost: each character belongs to at most one
+//    candidate and decoding is a few linear passes, so total work per line
+//    is O(line length) with small constants, and line length is already
+//    bounded by the sources' own file-read caps.
 
 // A run is made of characters that can appear in base64 or base64url:
 // A-Z a-z 0-9 + / = _ - (see isB64Code). Wrap separators between chunks of
@@ -74,7 +79,6 @@ const B64_MIN_CHUNK = 4;
 
 const B64_MIN_CHARS = 24;          // fewer chars cannot hide a real credential
 const B64_MAX_ENCODED = 90000;     // ~64KB decoded ceiling; skip bigger runs
-const B64_MAX_CANDIDATES = 256;    // per line, so a pathological line stays bounded
 const PRINTABLE_MIN = 0.85;        // decoded bytes must be mostly text to rescan
 
 /** JSON whitespace escapes -> the real line breaks they stand for. */
@@ -91,9 +95,10 @@ function normalizeEscapes(line) {
  *
  * Each candidate is returned as its ARRAY of chunks, not pre-joined: the
  * decode step needs the chunk boundaries to retry with an edge chunk dropped
- * (see findDecodedMatches). `truncated` is true when the per-line candidate
- * cap cut the list short, so the caller can surface the partial coverage
- * instead of silently dropping the rest.
+ * (see findDecodedMatches). Candidates shorter than B64_MIN_CHARS joined are
+ * discarded here for free: they can never decode (decodeToText rejects them
+ * by length), and most base64-charset runs on a line are exactly such short
+ * prose words and ids.
  */
 function isB64Code(c) {
   return (c >= 48 && c <= 57) || (c >= 65 && c <= 90) || (c >= 97 && c <= 122) ||
@@ -123,14 +128,13 @@ function splitAtPadding(chunk) {
 
 function b64Candidates(norm) {
   const candidates = []; // array of chunk arrays
-  let truncated = false;
   let current = null;   // chunk array of the candidate in progress
   let runStart = -1;    // start of the b64 run in progress, -1 when not in one
   let gapClean = true;  // gap since the last chunk held only \r \n
   const push = (cand) => {
-    if (candidates.length >= B64_MAX_CANDIDATES) { truncated = true; return false; }
-    candidates.push(cand);
-    return true;
+    let len = 0;
+    for (const c of cand) len += c.length;
+    if (len >= B64_MIN_CHARS) candidates.push(cand);
   };
   const n = norm.length;
   for (let i = 0; i <= n; i++) {
@@ -147,13 +151,13 @@ function b64Candidates(norm) {
         for (let p = 0; p < parts.length; p++) {
           if (p === 0 && current !== null && gapClean) current.push(parts[p]);
           else {
-            if (current !== null && !push(current)) return { candidates, truncated };
+            if (current !== null) push(current);
             current = [parts[p]];
           }
           // A part ending in padding is a complete value: nothing after it —
           // not even across a clean wrap gap — can belong to the same blob.
           if (parts[p].charCodeAt(parts[p].length - 1) === 61) {
-            if (!push(current)) return { candidates, truncated };
+            push(current);
             current = null;
           }
         }
@@ -168,7 +172,7 @@ function b64Candidates(norm) {
     if (c !== -1 && c !== 10 && c !== 13) gapClean = false;
   }
   if (current !== null) push(current);
-  return { candidates, truncated };
+  return candidates;
 }
 
 /**
@@ -211,19 +215,15 @@ function decodeToText(cleaned) {
 /**
  * Find credentials that appear only base64-encoded on one line. `rules` MUST
  * be the high-confidence subset (see LIMITS above). Returns
- * { matches, truncated } where matches is
  * [{ ruleId, label, confidence, value, encoding }] with `value` the DECODED
  * secret (caller redacts), deduped by rule+value so a blob echoed twice on
- * one line (content plus tool-result mirror) is one entry, and `truncated`
- * is true when the per-line candidate cap left runs unchecked (the caller
- * surfaces that as partial coverage, never silently).
+ * one line (content plus tool-result mirror) is one entry.
  */
 function findDecodedMatches(line, rules) {
   const out = [];
   const seen = new Set();
   const norm = normalizeEscapes(line);
-  const { candidates, truncated } = b64Candidates(norm);
-  for (const chunks of candidates) {
+  for (const chunks of b64Candidates(norm)) {
     // A wrap-merged candidate can carry one glued-on neighbor token: a word
     // or filename sitting directly above or below the blob across the wrap
     // newline merges into the candidate and breaks the decode (alignment
@@ -254,7 +254,7 @@ function findDecodedMatches(line, rules) {
       }
     }
   }
-  return { matches: out, truncated };
+  return out;
 }
 
 // ── Feature 2: split-line boundary join ─────────────────────────────────────

package/src/patterns.js

@@ -21,13 +21,13 @@ const PATTERNS = [
   { id: "private_key_block", label: "Private key block", confidence: "high",
     re: /-----BEGIN [A-Z0-9 ]*PRIVATE KEY-----/g },
   { id: "github_pat", label: "GitHub personal access token", confidence: "high",
-    re: /\bgh[pousr]_[A-Za-z0-9]{36,}\b/g },
+    re: /\bgh[pousr]_[A-Za-z0-9]{36,255}\b/g },
   { id: "gitlab_pat", label: "GitLab personal access token", confidence: "high",
-    re: /\bglpat-[A-Za-z0-9_-]{20,}\b/g },
+    re: /\bglpat-[A-Za-z0-9_-]{20,100}\b/g },
   { id: "slack_token", label: "Slack token", confidence: "high",
-    re: /\bxox[baprs]-[0-9A-Za-z-]{10,}\b/g },
+    re: /\bxox[baprs]-[0-9A-Za-z-]{10,500}\b/g },
   { id: "stripe_key", label: "Stripe API key (live mode)", confidence: "high",
-    re: /\b(sk|rk)_live_[A-Za-z0-9]{20,}\b/g },
+    re: /\b(sk|rk)_live_[A-Za-z0-9]{20,250}\b/g },
   // The sandbox-mode twin of the rule above, same body charset and the same
   // 20-char floor. Format verified against two production detectors plus the
   // vendor (2026-09-02): gitleaks' stripe-access-token rule matches
@@ -45,34 +45,34 @@ const PATTERNS = [
   // transcript that pastes sk_test today is the same workflow that will
   // paste sk_live at go-live.
   { id: "stripe_test_key", label: "Stripe API key (test mode)", confidence: "high",
-    re: /\b(sk|rk)_test_[A-Za-z0-9]{20,}\b/g },
+    re: /\b(sk|rk)_test_[A-Za-z0-9]{20,250}\b/g },
   // The negative lookahead keeps this rule mutually exclusive with anthropic_key
   // and openrouter_key below — without it, "sk-ant-..." or "sk-or-v1-..." match
   // BOTH this pattern and the more specific one, and get reported twice under
   // two different (one wrong) provider labels. Verified: all three regexes
   // independently matched their overlapping synthetic keys before this fix.
   { id: "openai_key", label: "OpenAI API key", confidence: "high",
-    re: /\bsk-(?!ant-|or-)(proj-)?[A-Za-z0-9_-]{20,}\b/g },
+    re: /\bsk-(?!ant-|or-)(proj-)?[A-Za-z0-9_-]{20,300}\b/g },
   { id: "anthropic_key", label: "Anthropic API key", confidence: "high",
-    re: /\bsk-ant-[A-Za-z0-9_-]{20,}\b/g },
+    re: /\bsk-ant-[A-Za-z0-9_-]{20,300}\b/g },
   { id: "google_api_key", label: "Google / Firebase API key", confidence: "high",
     re: /\bAIza[0-9A-Za-z_-]{35}\b/g },
   { id: "npm_token", label: "npm access token", confidence: "high",
     re: /\bnpm_[A-Za-z0-9]{36}\b/g },
   { id: "sendgrid_key", label: "SendGrid API key", confidence: "high",
-    re: /\bSG\.[A-Za-z0-9_-]{16,}\.[A-Za-z0-9_-]{16,}\b/g },
+    re: /\bSG\.[A-Za-z0-9_-]{16,100}\.[A-Za-z0-9_-]{16,100}\b/g },
   { id: "twilio_key", label: "Twilio API key", confidence: "high",
     re: /\bSK[a-f0-9]{32}\b/g },
   { id: "jwt", label: "JWT-shaped token", confidence: "medium",
-    re: /\beyJ[A-Za-z0-9_-]{10,}\.eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/g },
+    re: /\beyJ[A-Za-z0-9_-]{10,2000}\.eyJ[A-Za-z0-9_-]{10,20000}\.[A-Za-z0-9_-]{10,2000}\b/g },
   { id: "connection_string_with_password", label: "Database connection string with embedded password", confidence: "high",
-    re: /\b(postgres(?:ql)?|mysql|mongodb(?:\+srv)?):\/\/[^\s:@\/]+:[^\s@\/]{3,}@[^\s\/]+/g },
+    re: /\b(postgres(?:ql)?|mysql|mongodb(?:\+srv)?):\/\/[^\s:@\/]{1,255}:[^\s@\/]{3,255}@[^\s\/]{1,255}/g },
   { id: "bearer_header", label: "Authorization: Bearer header with a real-looking token", confidence: "medium",
-    re: /\bauthorization["']?\s*[:=]\s*["']?bearer\s+[A-Za-z0-9._-]{16,}/gi },
+    re: /\bauthorization["']?\s*[:=]\s*["']?bearer\s+[A-Za-z0-9._-]{16,1000}/gi },
   { id: "refresh_token_field", label: "refresh_token field", confidence: "medium",
-    re: /"refresh_token"\s*:\s*"[^"\s]{20,}"/gi },
+    re: /"refresh_token"\s*:\s*"[^"\s]{20,4000}"/gi },
   { id: "access_token_field", label: "access_token field", confidence: "medium",
-    re: /"access_token"\s*:\s*"[^"\s]{20,}"/gi },
+    re: /"access_token"\s*:\s*"[^"\s]{20,4000}"/gi },
 
   // ── AI / LLM providers (added: competitive gap-close, see project history) ─
   // Every regex body below was checked against a production, field-tested
@@ -102,7 +102,7 @@ const PATTERNS = [
   // "pplx-" + a >=40-char body — consistent across independent sources even
   // without one canonical spec page.
   { id: "perplexity_key", label: "Perplexity API key", confidence: "high",
-    re: /\bpplx-[A-Za-z0-9]{40,}\b/g },
+    re: /\bpplx-[A-Za-z0-9]{40,200}\b/g },
   { id: "replicate_token", label: "Replicate API token", confidence: "high",
     re: /\br8_[0-9A-Za-z_-]{37}\b/g },
 
@@ -121,7 +121,7 @@ const PATTERNS = [
     // Confirmed against 1Password's own developer docs (developer.1password.com
     // -> 1password.dev/service-accounts/security): the token is "ops_" plus a
     // base64-encoded JWT, so it always continues "eyJ" (base64 of `{"`).
-    re: /\bops_eyJ[A-Za-z0-9+/=_-]{40,}\b/g },
+    re: /\bops_eyJ[A-Za-z0-9+/=_-]{40,2000}\b/g },
 
   // ── Comms / SaaS ───────────────────────────────────────────────────────
   { id: "discord_webhook", label: "Discord webhook URL", confidence: "high",
@@ -138,13 +138,13 @@ const PATTERNS = [
   // but Notion has not published an exact body length for it, so its bound
   // below is a floor, not a verified exact count.
   { id: "notion_token", label: "Notion integration token", confidence: "high",
-    re: /\b(?:secret_[A-Za-z0-9]{43}|ntn_[A-Za-z0-9]{20,})\b/g },
+    re: /\b(?:secret_[A-Za-z0-9]{43}|ntn_[A-Za-z0-9]{20,200})\b/g },
   { id: "linear_key", label: "Linear API key", confidence: "high",
     re: /\blin_api_[0-9A-Za-z]{40}\b/g },
   { id: "sentry_token", label: "Sentry auth token", confidence: "high",
     // Covers both current Sentry token shapes: org-scoped (sntrys_, base64
     // JWT-like body) and user-scoped (sntryu_, hex body).
-    re: /\b(?:sntrys_eyJ[A-Za-z0-9+/=_]{100,}|sntryu_[a-f0-9]{64})\b/g },
+    re: /\b(?:sntrys_eyJ[A-Za-z0-9+/=_]{100,4000}|sntryu_[a-f0-9]{64})\b/g },
 ];
 
 /**
@@ -154,9 +154,9 @@ const PATTERNS = [
  */
 const NOISY_PATTERNS = [
   { id: "generic_password_assignment", label: "password / pwd assignment", confidence: "low",
-    re: /\b(password|passwd|pwd)\s*[:=]\s*["']?[^\s"']{6,}["']?/gi },
+    re: /\b(password|passwd|pwd)\s*[:=]\s*["']?[^\s"']{6,500}["']?/gi },
   { id: "generic_secret_assignment", label: "generic secret / apikey assignment", confidence: "low",
-    re: /\b(api[_-]?key|secret)\s*[:=]\s*["']?[A-Za-z0-9_\-\/+=]{12,}["']?/gi },
+    re: /\b(api[_-]?key|secret)\s*[:=]\s*["']?[A-Za-z0-9_\-\/+=]{12,500}["']?/gi },
 ];
 
 /**

package/src/scan.js

@@ -196,12 +196,9 @@ async function scan({ sources, includeNoisy = false, includeSuppressed = false,
   // was present only encoded on this line. It redacts from the DECODED value
   // (the encoded run is treated as secret material and never appears in the
   // preview), and carries an `encoding` marker the report renders as
-  // "base64-wrapped". Returns true when the per-line candidate cap left
-  // encoded runs on this line unchecked, so the caller can flag the file as
-  // only partially checked instead of staying silent about the gap.
+  // "base64-wrapped".
   const decodeLine = (line, file, relFile, lineNo, mtimeMs) => {
-    const { matches, truncated } = findDecodedMatches(line, highRules);
-    for (const d of matches) {
+    for (const d of findDecodedMatches(line, highRules)) {
       const suppressedReason = suppressionReason(d.value, null);
       if (suppressedReason && !includeSuppressed) {
         suppressedCount++;
@@ -210,7 +207,6 @@ async function scan({ sources, includeNoisy = false, includeSuppressed = false,
       record({ id: d.ruleId, label: d.label }, d.value, relFile, file, lineNo,
         mtimeMs, suppressedReason ? "low" : "high", suppressedReason, { encoding: d.encoding });
     }
-    return truncated;
   };
 
   // Feature 2: split-line boundary join. A finding here means one credential
@@ -291,23 +287,39 @@ async function scan({ sources, includeNoisy = false, includeSuppressed = false,
       // Content projection of the PREVIOUS line, kept so each line is
       // projected once and reused for both pairs it belongs to.
       let prevContent = null;
-      // Per-file degradation flags, each surfaced at most once so a
-      // pathological file produces one visible entry, not thousands.
+      // Per-file degradation flag, surfaced at most once so a pathological
+      // file produces one visible entry, not thousands.
       let lineMatchFailed = false;
-      let decodeTruncated = false;
+      // Each pass gets its own try/catch: every rule quantifier is bounded
+      // (see patterns.js) so none of these should throw on adversarial input
+      // any more, but this is the second, independent layer against that
+      // failure mode — a throw in one pass must never suppress the other
+      // two for the same line. Without this, a bug reintroduced in any one
+      // pass silently blinds the other two for that line rather than
+      // degrading loudly on its own. One unmatched line must degrade to a
+      // visible per-file flag, never abort the scan and discard every
+      // finding already collected (same contract as the readLines catch
+      // above).
+      const flagFailed = () => {
+        if (!lineMatchFailed) {
+          lineMatchFailed = true;
+          unreadableFiles.push({ file: safeName(file), reason: "some lines could not be matched" });
+        }
+      };
       for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
         if (line) {
-          // A rule regex itself can throw on adversarial input: V8's
-          // backtrack stack overflows (RangeError) when an open-ended
-          // quantifier meets a prefix followed by a multi-megabyte
-          // same-charset run — real transcripts contain such lines. One
-          // unmatched line must degrade to a visible per-file flag, never
-          // abort the scan and discard every finding already collected
-          // (same contract as the readLines catch above).
           try {
             matchLine(line, file, relFile, i + 1, mtimeMs);
-            decodeTruncated = decodeLine(line, file, relFile, i + 1, mtimeMs) || decodeTruncated;
+          } catch (err) {
+            flagFailed();
+          }
+          try {
+            decodeLine(line, file, relFile, i + 1, mtimeMs);
+          } catch (err) {
+            flagFailed();
+          }
+          try {
             const content = contentProjection(line);
             // Boundary join with the previous line (2-way splits only; see
             // decode.js). Both lines must be non-empty so a blank separator
@@ -317,19 +329,13 @@ async function scan({ sources, includeNoisy = false, includeSuppressed = false,
             }
             prevContent = content;
           } catch (err) {
-            if (!lineMatchFailed) {
-              lineMatchFailed = true;
-              unreadableFiles.push({ file: safeName(file), reason: "some lines could not be matched" });
-            }
+            flagFailed();
             prevContent = null;
           }
         } else {
           prevContent = null;
         }
       }
-      if (decodeTruncated) {
-        unreadableFiles.push({ file: safeName(file), reason: "some lines held more encoded runs than the per-line bound; checked partially" });
-      }
     }
 
     if (sourceScannedAnything) sourcesScanned.push(source.id());