penthera 1.7.0 → 1.8.0

package/lib/rules/sshsig.js

@@ -0,0 +1,205 @@
+/**
+ * Verify OpenSSH signatures (`ssh-keygen -Y sign`) in pure Node, so checking
+ * a rule pack needs no ssh-keygen binary and spawns nothing.
+ *
+ * Format: PROTOCOL.sshsig in the OpenSSH source tree. A signature is an
+ * armored blob:
+ *   "SSHSIG" | uint32 version | string publickey | string namespace |
+ *   string reserved | string hash_algorithm | string signature
+ * and what the key signs is:
+ *   "SSHSIG" | string namespace | string reserved | string hash_algorithm |
+ *   string H(message)
+ *
+ * Supported keys: ssh-ed25519 and RSA (rsa-sha2-256/512 signatures). Others
+ * (ECDSA, security keys, certificates) are refused with a clear reason rather
+ * than half-supported.
+ *
+ * allowed_signers: the format ssh-keygen reads (ALLOWED SIGNERS in
+ * ssh-keygen(1)): `principals [options] keytype base64-key [comment]`, with the
+ * options namespaces="...", valid-after=, valid-before= honoured and
+ * cert-authority refused.
+ */
+import { createHash, createPublicKey, verify } from "node:crypto";
+
+const MAGIC = Buffer.from("SSHSIG");
+
+class Reader {
+  constructor(buf) { this.buf = buf; this.off = 0; }
+  u32() {
+    if (this.off + 4 > this.buf.length) throw new Error("truncated");
+    const v = this.buf.readUInt32BE(this.off);
+    this.off += 4;
+    return v;
+  }
+  bytes() {
+    const n = this.u32();
+    if (n > this.buf.length - this.off) throw new Error("truncated");
+    const v = this.buf.subarray(this.off, this.off + n);
+    this.off += n;
+    return v;
+  }
+  str() { return this.bytes().toString("latin1"); }
+  done() { return this.off === this.buf.length; }
+}
+
+const sshString = (b) => {
+  const buf = Buffer.isBuffer(b) ? b : Buffer.from(b);
+  const len = Buffer.alloc(4);
+  len.writeUInt32BE(buf.length);
+  return Buffer.concat([len, buf]);
+};
+const b64url = (b) => Buffer.from(b).toString("base64url");
+const stripMpint = (b) => (b[0] === 0 ? b.subarray(1) : b);
+
+/** A KeyObject from an SSH public key blob, or throw. */
+export function keyFromBlob(blob) {
+  const r = new Reader(blob);
+  const type = r.str();
+  if (type === "ssh-ed25519") {
+    const pk = r.bytes();
+    if (pk.length !== 32 || !r.done()) throw new Error("malformed ed25519 key");
+    return { type, key: createPublicKey({ key: { kty: "OKP", crv: "Ed25519", x: b64url(pk) }, format: "jwk" }) };
+  }
+  if (type === "ssh-rsa") {
+    const e = stripMpint(r.bytes());
+    const n = stripMpint(r.bytes());
+    if (!r.done()) throw new Error("malformed RSA key");
+    if (n.length * 8 < 2048) throw new Error("RSA keys under 2048 bits are not accepted");
+    return { type, key: createPublicKey({ key: { kty: "RSA", n: b64url(n), e: b64url(e) }, format: "jwk" }) };
+  }
+  throw new Error(`unsupported key type ${type} (use ssh-ed25519 or ssh-rsa)`);
+}
+
+/** Decode an armored SSH signature into its fields, or throw. */
+export function parseSignature(armored) {
+  const text = String(armored);
+  const m = /-----BEGIN SSH SIGNATURE-----([\s\S]*?)-----END SSH SIGNATURE-----/.exec(text);
+  if (!m) throw new Error("not an SSH signature (missing armor)");
+  const raw = Buffer.from(m[1].replace(/\s+/g, ""), "base64");
+  if (!raw.subarray(0, 6).equals(MAGIC)) throw new Error("bad signature magic");
+  const r = new Reader(raw.subarray(6));
+  const version = r.u32();
+  if (version !== 1) throw new Error(`unsupported signature version ${version}`);
+  const publicKey = Buffer.from(r.bytes());
+  const namespace = r.str();
+  const reserved = Buffer.from(r.bytes());
+  const hashAlg = r.str();
+  const sig = new Reader(r.bytes());
+  if (!r.done()) throw new Error("trailing bytes after signature");
+  const sigType = sig.str();
+  const sigBytes = Buffer.from(sig.bytes());
+  return { publicKey, namespace, reserved, hashAlg, sigType, sigBytes };
+}
+
+/**
+ * Check that `armored` is a valid signature over `message` in `namespace`.
+ * Does not decide whether the key is trusted; see verifyWithSigners.
+ * @returns {{ ok: true, publicKey: Buffer } | { ok: false, reason: string }}
+ */
+export function verifySignature(message, armored, namespace) {
+  let s;
+  try { s = parseSignature(armored); } catch (e) { return { ok: false, reason: e.message }; }
+  if (s.namespace !== namespace) return { ok: false, reason: `signature namespace is "${s.namespace}", expected "${namespace}"` };
+  if (s.hashAlg !== "sha512" && s.hashAlg !== "sha256") return { ok: false, reason: `unsupported hash ${s.hashAlg}` };
+  let k;
+  try { k = keyFromBlob(s.publicKey); } catch (e) { return { ok: false, reason: e.message }; }
+  const digest = createHash(s.hashAlg).update(message).digest();
+  const signed = Buffer.concat([MAGIC, sshString(namespace), sshString(s.reserved), sshString(s.hashAlg), sshString(digest)]);
+  let good = false;
+  try {
+    if (k.type === "ssh-ed25519") {
+      good = s.sigType === "ssh-ed25519" && verify(null, signed, k.key, s.sigBytes);
+    } else if (s.sigType === "rsa-sha2-512" || s.sigType === "rsa-sha2-256") {
+      good = verify(s.sigType === "rsa-sha2-512" ? "sha512" : "sha256", signed, k.key, s.sigBytes);
+    } else {
+      return { ok: false, reason: `unsupported signature type ${s.sigType}` };
+    }
+  } catch (e) {
+    return { ok: false, reason: `signature check failed: ${e.message}` };
+  }
+  return good ? { ok: true, publicKey: s.publicKey } : { ok: false, reason: "signature does not match (file changed after signing, or wrong key)" };
+}
+
+// ── allowed_signers ───────────────────────────────────────────────────────
+
+function tokenize(line) {
+  const out = [];
+  let cur = "";
+  let quoted = false;
+  for (const ch of line) {
+    if (ch === '"') { quoted = !quoted; cur += ch; continue; }
+    if (!quoted && (ch === " " || ch === "\t")) { if (cur) out.push(cur); cur = ""; continue; }
+    cur += ch;
+  }
+  if (cur) out.push(cur);
+  return out;
+}
+
+/** "20260101", "202601011200", "20260101120000Z" -> epoch ms, or NaN. */
+function parseTime(s) {
+  const m = /^(\d{4})(\d{2})(\d{2})(?:(\d{2})(\d{2})(\d{2})?)?(Z?)$/.exec(s);
+  if (!m) return NaN;
+  const [, y, mo, d, h = "00", mi = "00", se = "00", z] = m;
+  const iso = `${y}-${mo}-${d}T${h}:${mi}:${se}${z ? "Z" : ""}`;
+  return Date.parse(iso);
+}
+
+const KEY_TYPES = new Set(["ssh-ed25519", "ssh-rsa", "ecdsa-sha2-nistp256", "ecdsa-sha2-nistp384", "ecdsa-sha2-nistp521", "sk-ssh-ed25519@openssh.com", "sk-ecdsa-sha2-nistp256@openssh.com"]);
+
+/**
+ * Parse an allowed_signers file.
+ * @returns {{ principals: string[], namespaces: string[]|null, validAfter?: number, validBefore?: number, keyType: string, key: Buffer, certAuthority: boolean }[]}
+ */
+export function parseAllowedSigners(text) {
+  const out = [];
+  for (const raw of String(text).split(/\r?\n/)) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#")) continue;
+    const t = tokenize(line);
+    if (t.length < 3) continue;
+    const entry = { principals: t[0].split(","), namespaces: null, certAuthority: false };
+    let k = 1;
+    if (!KEY_TYPES.has(t[k])) {
+      for (const opt of t[k].split(/,(?=(?:[^"]*"[^"]*")*[^"]*$)/)) {
+        const [name, ...rest] = opt.split("=");
+        const value = rest.join("=").replace(/^"|"$/g, "");
+        const lname = name.toLowerCase();
+        if (lname === "cert-authority") entry.certAuthority = true;
+        else if (lname === "namespaces") entry.namespaces = value.split(",").map((s) => s.trim()).filter(Boolean);
+        else if (lname === "valid-after") entry.validAfter = parseTime(value);
+        else if (lname === "valid-before") entry.validBefore = parseTime(value);
+      }
+      k++;
+    }
+    if (!KEY_TYPES.has(t[k]) || !t[k + 1]) continue;
+    entry.keyType = t[k];
+    entry.key = Buffer.from(t[k + 1], "base64");
+    out.push(entry);
+  }
+  return out;
+}
+
+/**
+ * Verify a signature and check its key against allowed_signers entries.
+ * @param {Buffer|string} message
+ * @param {string} armored
+ * @param {string} namespace
+ * @param {ReturnType<typeof parseAllowedSigners>} signers
+ * @param {{ now?: number }} [opts]
+ * @returns {{ ok: true, principal: string, keyType: string } | { ok: false, reason: string }}
+ */
+export function verifyWithSigners(message, armored, namespace, signers, opts = {}) {
+  const v = verifySignature(message, armored, namespace);
+  if (!v.ok) return v;
+  const now = opts.now ?? Date.now();
+  const matches = signers.filter((e) => e.key.equals(v.publicKey));
+  if (matches.length === 0) return { ok: false, reason: "valid signature, but the key is not in allowed_signers" };
+  for (const e of matches) {
+    if (e.certAuthority) continue;
+    if (e.namespaces && !e.namespaces.includes(namespace)) continue;
+    if (e.validAfter !== undefined && !(now >= e.validAfter)) continue;
+    if (e.validBefore !== undefined && !(now < e.validBefore)) continue;
+    return { ok: true, principal: e.principals[0], keyType: e.keyType };
+  }
+  return { ok: false, reason: `key is in allowed_signers but not valid for namespace "${namespace}" at this time` };
+}

package/lib/templates.js

@@ -5,8 +5,9 @@
  * Compatible with a subset of Nuclei's template format.
  */
 import { joinUrl } from "../src/utils/url.js";
-import { request } from "../src/utils/http.js";
-import { hasNestedQuantifier } from "./rules/regex-guard.js";
+import { request, readBody } from "../src/utils/http.js";
+import { checkRegex } from "./rules/regex-guard.js";
+import { rulesOf } from "./rules/index.js";
 
 /**
  * Execute a single template check against a target.
@@ -37,7 +38,7 @@ export async function executeTemplate(baseUrl, template) {
       }
 
       const res = await request(url, fetchOpts);
-      const body = await res.text().catch(() => "");
+      const body = await readBody(res).catch(() => "");
       const headerString = [...res.headers.entries()]
         .map(([k, v]) => `${k}: ${v}`).join("\n");
 
@@ -89,11 +90,22 @@ 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
-// hasNestedQuantifier lives in lib/rules/regex-guard.js. Templates from rule
-// packs pass the stricter checkRegex there when the pack loads.
+// Template regexes pass the same structural ReDoS guard as rule packs
+// (checkRegex in lib/rules/regex-guard.js); a refused pattern never runs.
+const guardCache = new Map();
+function regexAllowed(pattern, flags = "") {
+  const key = `${flags}\u0000${pattern}`;
+  let ok = guardCache.get(key);
+  if (ok === undefined) {
+    ok = checkRegex(pattern, flags).ok;
+    if (guardCache.size > 1000) guardCache.clear();
+    guardCache.set(key, ok);
+  }
+  return ok;
+}
 
 function safeRegexTest(pattern, target, flags = "") {
-  if (hasNestedQuantifier(pattern)) return false; // refuse the shape that blows up
+  if (!regexAllowed(pattern, flags)) return false; // refuse shapes that backtrack
   try {
     const input = target.length > REGEX_INPUT_CAP ? target.slice(0, REGEX_INPUT_CAP) : target;
     return new RegExp(pattern, flags).test(input);
@@ -151,7 +163,7 @@ export function runExtractor(extractor, ctx) {
   switch (extractor.type) {
     case "regex": {
       for (const pattern of extractor.regex || []) {
-        if (hasNestedQuantifier(pattern)) continue;
+        if (!regexAllowed(pattern)) continue;
         const capped = target.length > REGEX_INPUT_CAP ? target.slice(0, REGEX_INPUT_CAP) : target;
         let match;
         try {
@@ -187,18 +199,8 @@ export function runExtractor(extractor, ctx) {
  */
 export const BUILT_IN_TEMPLATES = [
   // ── Exposed sensitive files ──────────────────────────────────────────
-  {
-    id: "env-file-exposure",
-    info: { name: ".env file exposed", severity: "critical", tags: ["exposure", "config"] },
-    http: [{
-      method: "GET", path: "/.env",
-      matchers: [
-        { type: "status", status: [200] },
-        { type: "word", words: ["DB_", "API_KEY", "SECRET", "PASSWORD", "FIREBASE_", "STRIPE_"], condition: "or" },
-      ],
-      "matchers-condition": "and",
-    }],
-  },
+  // .env: lib/rules/core/templates.json.
+  ...rulesOf("nuclei-template", { pack: "core" }).map((r) => r.template),
   {
     id: "env-local-exposure",
     info: { name: ".env.local file exposed", severity: "critical", tags: ["exposure", "config"] },
@@ -387,7 +389,9 @@ export const BUILT_IN_TEMPLATES = [
  */
 export async function runBuiltInTemplates(baseUrl) {
   const allFindings = [];
-  for (const template of BUILT_IN_TEMPLATES) {
+  // Built-ins, then templates from other packs (bundled or --rules).
+  const packTemplates = rulesOf("nuclei-template", { exceptPack: "core" }).map((r) => r.template);
+  for (const template of [...BUILT_IN_TEMPLATES, ...packTemplates]) {
     const findings = await executeTemplate(baseUrl, template);
     allFindings.push(...findings);
   }

package/lib/tmp.js

@@ -0,0 +1,21 @@
+/** Temporary folders that are always removed. */
+import { mkdtempSync, realpathSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+/**
+ * Run `fn` with a fresh private folder (mkdtemp, real path) and remove it
+ * afterwards, whether `fn` returns or throws.
+ * @template T
+ * @param {string} prefix e.g. "penthera-hook-"
+ * @param {(dir: string) => Promise<T> | T} fn
+ * @returns {Promise<T>}
+ */
+export async function withTempDir(prefix, fn) {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), prefix)));
+  try {
+    return await fn(dir);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}

package/lib/whitebox/frameworks.js

@@ -1,7 +1,7 @@
 /**
  * Discover API routes in Express, Hono, and Fastify projects.
  */
-import { readdirSync, readFileSync, statSync, lstatSync, existsSync } from "node:fs";
+import { readdirSync, readFileSync, lstatSync, existsSync } from "node:fs";
 import { join, relative } from "node:path";
 
 const SKIP = new Set(["node_modules", ".git", "dist", "build", ".next", "coverage", "vendor"]);

package/lib/whitebox/secrets.js

@@ -1,8 +1,9 @@
 /**
  * Scan repository source for hardcoded secrets.
  */
-import { readdirSync, readFileSync, lstatSync, existsSync } from "node:fs";
+import { readdirSync, lstatSync, existsSync, openSync, fstatSync, readSync, closeSync, constants } from "node:fs";
 import { join, relative } from "node:path";
+import { rulesOf, rulesGeneration, PACK_INPUT_CAP } from "../rules/index.js";
 
 const SKIP_DIRS = new Set([
   "node_modules", ".git", "dist", "build", ".next", "coverage",
@@ -25,21 +26,9 @@ const SECRET_PATTERNS = [
   { name: "GitHub token", pattern: /ghp_[a-zA-Z0-9]{36,}/, severity: "critical" },
   // AI provider keys. Vibecoded apps leak these more than any other credential,
   // often via a NEXT_PUBLIC_/VITE_ variable or a committed notebook. Specific
-  // prefixes come first so a key is reported under its real provider.
-  { name: "Anthropic API key", pattern: /sk-ant-(?:api|admin)\d{2}-[A-Za-z0-9_-]{32,}/, severity: "critical" },
-  { name: "OpenRouter API key", pattern: /sk-or-v1-[a-f0-9]{64}/, severity: "critical" },
-  { name: "OpenAI API key", pattern: /sk-(?:proj|svcacct|admin)-[A-Za-z0-9_-]{20,}/, severity: "critical" },
-  { name: "OpenAI API key (legacy format)", pattern: /sk-[a-zA-Z0-9]{20,}/, severity: "critical" },
-  // AIza keys are also Firebase web keys, which are public by design, so this
-  // is high rather than critical: it matters if the key has Gemini/Vertex access.
-  { name: "Google API key (Gemini / Firebase / Maps)", pattern: /AIza[0-9A-Za-z_-]{35}/, severity: "high" },
-  { name: "Groq API key", pattern: /gsk_[A-Za-z0-9]{48,}/, severity: "critical" },
-  { name: "Hugging Face token", pattern: /hf_[A-Za-z0-9]{34,}/, severity: "critical" },
-  { name: "Replicate API token", pattern: /r8_[A-Za-z0-9]{37,}/, severity: "critical" },
-  { name: "xAI API key", pattern: /xai-[A-Za-z0-9]{70,}/, severity: "critical" },
-  { name: "Perplexity API key", pattern: /pplx-[A-Za-z0-9]{40,}/, severity: "critical" },
-  { name: "LangSmith API key", pattern: /lsv2_(?:pt|sk)_[a-f0-9]{32}_[a-f0-9]{10}/, severity: "high" },
-  { name: "Pinecone API key", pattern: /pcsk_[A-Za-z0-9_]{50,}/, severity: "high" },
+  // prefixes come first so a key is reported under its real provider. They
+  // live in the bundled core rule pack (lib/rules/core/secrets.json).
+  ...coreSecrets(),
   { name: "Stripe secret key", pattern: /sk_live_[a-zA-Z0-9]{20,}/, severity: "critical" },
   {
     name: "Generic API key assignment",
@@ -63,6 +52,31 @@ const SECRET_PATTERNS = [
   },
 ];
 
+function fromPack(r) {
+  return { name: r.name, pattern: r.pattern, severity: r.severity, ...(r.skipPlaceholders ? { skipIf: TEST_VALUE } : {}), rule: r };
+}
+
+function coreSecrets() {
+  return rulesOf("secret", { pack: "core" }).map(fromPack);
+}
+
+// Built-ins first, then rules from other packs (bundled or --rules), so a
+// pack can add detections but never shadow or reorder the built-in ones.
+let _patterns = null;
+let _generation = -1;
+function secretPatterns() {
+  if (_generation !== rulesGeneration()) {
+    _patterns = [...SECRET_PATTERNS, ...rulesOf("secret", { exceptPack: "core" }).map(fromPack)];
+    _generation = rulesGeneration();
+  }
+  return _patterns;
+}
+
+/** The secret rules in effect, in match order (built-ins, then packs). */
+export function activeSecretPatterns() {
+  return secretPatterns().map(({ name, pattern, severity, skipIf, rule }) => ({ name, pattern, severity, skipIf: !!skipIf, pack: rule?.pack || null }));
+}
+
 const SCAN_EXTENSIONS = new Set([
   ".js", ".ts", ".jsx", ".tsx", ".mjs", ".cjs", ".py", ".rb", ".go", ".java",
   ".env", ".yaml", ".yml", ".json", ".toml", ".cfg", ".ini", ".sh",
@@ -88,6 +102,11 @@ export function isNestedRepo(dir, root) {
   return dir !== root && existsSync(join(dir, ".git"));
 }
 
+// Per-file cap for the repo scan. Larger files are reported, not read.
+export const MAX_SCAN_BYTES = 16 * 1024 * 1024;
+
+// Regular files only: a FIFO, socket or device named `.env` would block the
+// read (or never end), and a symlink could point outside the repo.
 function walkFiles(dir, files = [], root = dir) {
   if (!existsSync(dir) || isNestedRepo(dir, root)) return files;
   for (const entry of readdirSync(dir)) {
@@ -97,7 +116,7 @@ function walkFiles(dir, files = [], root = dir) {
     if (st.isSymbolicLink()) continue;
     if (st.isDirectory()) {
       walkFiles(full, files, root);
-    } else if (!SKIP_FILES.test(entry)) {
+    } else if (st.isFile() && !SKIP_FILES.test(entry)) {
       const ext = entry.includes(".") ? entry.slice(entry.lastIndexOf(".")) : "";
       if (SCAN_EXTENSIONS.has(ext) || entry.startsWith(".env")) files.push(full);
     }
@@ -109,46 +128,103 @@ export function maskMatch(match) {
   return match.length <= 8 ? "***" : match.slice(0, 4) + "…" + match.slice(-4);
 }
 
+// A file can repeat one key shape thousands of times; past this many reported
+// hits per rule the file is already flagged, so stop looking for more.
+const MAX_HITS_PER_RULE = 50;
+
+/** Every match of a rule. Pack rules added by path see at most PACK_INPUT_CAP chars, as with packMatch(). */
+function* allMatches(rule, content) {
+  if (rule.rule) {
+    const input = rule.rule.origin === "bundled" || content.length <= PACK_INPUT_CAP ? content : content.slice(0, PACK_INPUT_CAP);
+    rule.globalPattern ??= new RegExp(rule.rule.pattern.source, rule.rule.pattern.flags.replace(/[gy]/g, "") + "g");
+    yield* input.matchAll(rule.globalPattern);
+    return;
+  }
+  rule.globalPattern ??= new RegExp(rule.pattern.source, rule.pattern.flags.replace(/[gy]/g, "") + "g");
+  yield* content.matchAll(rule.globalPattern);
+}
+
 /**
  * Find secrets in a string of text (a source file, a JS bundle, a config).
- * Returns one hit per rule: `{ name, severity, match }`, with the raw match so
- * callers decide how to mask it. At most one rule fires per provider key: once a
- * specific AI-provider rule matches a span, broader rules skip that span.
+ * Returns every hit: `{ name, severity, match, index }`, with the raw match so
+ * callers decide how to mask it. Placeholder values are skipped one match at a
+ * time, so a placeholder never hides a real secret of the same rule later in
+ * the text. At most one rule fires per span: once a specific AI-provider rule
+ * matches a span, broader rules skip that span.
  */
 export function findSecretsInText(content) {
   const hits = [];
   const claimed = [];
-  for (const rule of SECRET_PATTERNS) {
-    const match = content.match(rule.pattern);
-    if (!match) continue;
-    // For assignment-style rules, test the placeholder/dummy filter against
-    // the assigned value only (not the whole `key = "value"` match), so a
-    // variable named e.g. `testToken` can't mask a real secret.
-    const value = (match[0].match(/['"]([^'"]+)['"]/) || [, match[0]])[1];
-    if (rule.skipIf && rule.skipIf.test(value)) continue;
-    const start = match.index;
-    const end = start + match[0].length;
-    if (claimed.some(([a, b]) => start < b && end > a)) continue;
-    claimed.push([start, end]);
-    hits.push({ name: rule.name, severity: rule.severity, match: match[0] });
+  for (const rule of secretPatterns()) {
+    let found = 0;
+    for (const match of allMatches(rule, content)) {
+      // For assignment-style rules, test the placeholder/dummy filter against
+      // the assigned value only (not the whole `key = "value"` match), so a
+      // variable named e.g. `testToken` can't mask a real secret.
+      const value = (match[0].match(/['"]([^'"]+)['"]/) || [, match[0]])[1];
+      if (rule.skipIf && rule.skipIf.test(value)) continue;
+      const start = match.index;
+      const end = start + match[0].length;
+      if (claimed.some(([a, b]) => start < b && end > a)) continue;
+      claimed.push([start, end]);
+      hits.push({ name: rule.name, severity: rule.severity, match: match[0], index: start });
+      if (++found >= MAX_HITS_PER_RULE) break;
+    }
   }
   return hits;
 }
 
-export function scanSecrets(repoPath) {
+/** A regular file's text, or null when it is not one (anymore) or is larger than `max` bytes. */
+function readRegularFile(path, max) {
+  let fd;
+  try {
+    // O_NONBLOCK: if the file was swapped for a FIFO after the walk, open must not wait for a writer.
+    fd = openSync(path, constants.O_RDONLY | (constants.O_NONBLOCK || 0) | (constants.O_NOFOLLOW || 0));
+    const st = fstatSync(fd);
+    if (!st.isFile()) return null;
+    if (st.size > max) return { tooLarge: st.size };
+    const buf = Buffer.alloc(st.size);
+    let off = 0;
+    while (off < st.size) {
+      const n = readSync(fd, buf, off, st.size - off, off);
+      if (n === 0) break;
+      off += n;
+    }
+    return { text: buf.subarray(0, off).toString("utf-8") };
+  } catch {
+    return null;
+  } finally {
+    if (fd !== undefined) closeSync(fd);
+  }
+}
+
+export function scanSecrets(repoPath, { maxBytes = MAX_SCAN_BYTES } = {}) {
   const findings = [];
 
   for (const filePath of walkFiles(repoPath)) {
-    let content;
-    try {
-      content = readFileSync(filePath, "utf-8");
-    } catch {
-      continue;
-    }
+    const read = readRegularFile(filePath, maxBytes);
+    if (!read) continue;
 
     const rel = relative(repoPath, filePath);
 
-    for (const hit of findSecretsInText(content)) {
+    if (read.tooLarge) {
+      findings.push({
+        severity: "info",
+        title: "File too large to scan for secrets",
+        description: `\`${rel}\` is ${read.tooLarge} bytes, over the ${maxBytes}-byte secret-scan limit, so it was not checked.`,
+        url: rel,
+        category: "secrets",
+        source: "secret-scan",
+      });
+      continue;
+    }
+
+    // One finding per rule per file (the finding id is per rule and file);
+    // the first real hit is the one shown.
+    const seen = new Set();
+    for (const hit of findSecretsInText(read.text)) {
+      if (seen.has(hit.name)) continue;
+      seen.add(hit.name);
       findings.push({
         severity: hit.severity,
         title: `${hit.name} in source`,

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "penthera",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "type": "module",
-  "description": "Open-source security for the apps and AI systems you ship. Check it before you deploy, vet what you build with (dependencies, MCP servers, skills), keep watching after you ship. Offline, deterministic, free.",
+  "description": "Offline cyber security agent for your apps and AI coding tools. Open R&D: measured in public, improved every release.",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/danoszz/penthera.git"
@@ -20,7 +20,8 @@
     "src",
     "lib",
     "skills",
-    "docs",
+    "docs/examples",
+    "scripts/rules",
     "pentest.config.example.js",
     "CHANGELOG.md",
     "LICENSE",
@@ -37,6 +38,8 @@
   },
   "scripts": {
     "test": "vitest run --reporter=verbose",
+    "test:load": "node scripts/test-under-load.mjs",
+    "lint": "eslint .",
     "scan": "node bin/penthera.js",
     "scan:full": "node bin/scan.js",
     "pentest": "vitest run --reporter=verbose",
@@ -50,11 +53,12 @@
     "package:skill": "bash scripts/package-skill.sh",
     "refresh:popular": "node scripts/refresh-popular-packages.mjs",
     "refresh:popular-pypi": "node scripts/refresh-popular-pypi.mjs",
-    "prepack": "npm test",
     "mock-server": "node tests/fixtures/mock-server.js",
     "bench": "node bench/run.js",
     "docs:numbers": "node scripts/docs-numbers.mjs",
     "refresh:retire-db": "node scripts/refresh-retire-db.mjs",
+    "rules:build": "node scripts/rules/build-pack.mjs",
+    "rules:check": "node scripts/rules/check-bundled.mjs",
     "audit:internal": "node scripts/audit/run.mjs"
   },
   "keywords": [
@@ -81,8 +85,12 @@
   ],
   "license": "MIT",
   "devDependencies": {
+    "@eslint/js": "10.0.1",
     "ajv": "^8.20.0",
+    "eslint": "10.12.0",
     "fast-check": "^4.10.2",
+    "globals": "17.12.0",
+    "rolldown": "1.2.14",
     "vitest": "^5.0.5"
   },
   "dependencies": {