penthera 1.7.0 → 1.8.0

package/src/cli/rules.js

@@ -0,0 +1,144 @@
+/**
+ * `penthera rules list|verify <dir>`, and loading `--rules <dir>` packs for a scan.
+ * Rule packs are data, verified before use; see docs/rule-packs.md.
+ */
+import { parseArgs } from "node:util";
+import { resolve } from "node:path";
+import { bold, dim, green, red, yellow } from "./ansi.js";
+
+const HELP = `
+${bold("penthera rules")}: signed, versioned detection rule packs (offline)
+
+  penthera rules list [--rules <dir>]...        Packs in effect: bundled, plus any given
+  penthera rules verify <dir> [--rules-signers <file>] [--json]
+                                                Check a pack: signature, file hashes,
+                                                schema, ReDoS guard. Exit 0 only if it
+                                                would load without --allow-unsigned-rules.
+
+  Add packs to a scan with --rules <dir> (repeatable). There is no download
+  command: packs arrive by path or by upgrading Penthera.
+`;
+
+const kindsSummary = (rules) => Object.entries(rules || {}).filter(([, v]) => v.length).map(([k, v]) => `${k} ${v.length}`).join(", ");
+
+/**
+ * Verify and activate --rules packs. Throws with a user-facing message on refusal.
+ * @returns {string[]} warnings to print
+ */
+export async function activateRules(opts) {
+  const dirs = [].concat(opts.rules || []);
+  if (dirs.length === 0) return [];
+  const { addRulePack, loadSigners } = await import("../../lib/rules/index.js");
+  const signers = loadSigners([].concat(opts["rules-signers"] || []).map((f) => resolve(f)));
+  const warnings = [];
+  for (const d of dirs) {
+    const r = addRulePack(resolve(d), { signers, allowUnsigned: !!opts["allow-unsigned-rules"] });
+    warnings.push(...r.warnings);
+  }
+  return warnings;
+}
+
+/** Print warnings from activateRules to stderr; unsigned-pack warnings are loud on purpose. */
+export function printRuleWarnings(warnings) {
+  for (const w of warnings) {
+    if (w.startsWith("LOADING AN UNTRUSTED")) {
+      process.stderr.write(`\n  ${red(bold("!! WARNING !!"))} ${bold(w)}\n\n`);
+    } else {
+      process.stderr.write(`  ${yellow("warn")} rules: ${w}\n`);
+    }
+  }
+}
+
+export async function runRules(argv) {
+  let parsed;
+  try {
+    parsed = parseArgs({
+      args: argv,
+      allowPositionals: true,
+      options: {
+        rules: { type: "string", multiple: true },
+        "rules-signers": { type: "string", multiple: true },
+        "allow-unsigned-rules": { type: "boolean", default: false },
+        json: { type: "boolean", default: false },
+        help: { type: "boolean", short: "h", default: false },
+      },
+    });
+  } catch (e) {
+    console.error(`  ${red("error")} ${e.message}`);
+    return 2;
+  }
+  const { values: opts, positionals } = parsed;
+  const [cmd, ...rest] = positionals;
+  if (opts.help || !cmd) {
+    console.log(HELP);
+    return opts.help ? 0 : 2;
+  }
+
+  const rules = await import("../../lib/rules/index.js");
+  let signers;
+  try {
+    signers = rules.loadSigners([].concat(opts["rules-signers"] || []).map((f) => resolve(f)));
+  } catch (e) {
+    console.error(`  ${red("error")} ${e.message}`);
+    return 2;
+  }
+
+  if (cmd === "verify") {
+    if (rest.length !== 1) {
+      console.error(`  ${red("error")} usage: penthera rules verify <dir>`);
+      return 2;
+    }
+    const v = rules.verifyPack(rest[0], { signers });
+    const trusted = v.ok && v.signature === "valid";
+    if (opts.json) {
+      const { rules: compiled, manifest, ...out } = v;
+      console.log(JSON.stringify({ ...out, trusted, kinds: Object.fromEntries(Object.entries(compiled || {}).map(([k, x]) => [k, x.length])) }, null, 2));
+      return trusted ? 0 : 1;
+    }
+    console.log(`\n  ${bold("Rule pack")} ${v.name ? `${v.name}@${v.version}` : rest[0]}  ${dim(v.dir)}`);
+    const sigLine = v.signature === "valid" ? green(`valid, signed by ${v.signer}`)
+      : v.signature === "invalid" ? red(`INVALID: ${v.signatureError}`)
+      : yellow("missing (no pack.json.sig)");
+    console.log(`  signature   ${sigLine}`);
+    if (v.ok) {
+      console.log(`  files       ${green("all SHA-256 hashes match pack.json")}`);
+      console.log(`  rules       ${green(`${v.count} valid`)} ${dim(`(${kindsSummary(v.rules)})`)}`);
+      console.log(`  regexes     ${green("all pass the ReDoS guard")}`);
+    }
+    for (const e of v.errors) console.log(`  ${red("error")}       ${e}`);
+    for (const w of v.warnings) console.log(`  ${yellow("warn")}        ${w}`);
+    console.log(trusted
+      ? `\n  ${green("OK")}: this pack loads with --rules ${rest[0]}\n`
+      : v.ok
+        ? `\n  ${yellow("NOT TRUSTED")}: well-formed, but it only loads with --allow-unsigned-rules.${rules.bundledPackDirs().includes(v.dir) ? " (Bundled packs load as part of the release; npm run rules:check refuses to publish them unsigned.)" : ""}\n`
+        : `\n  ${red("REFUSED")}: this pack does not load, with or without --allow-unsigned-rules.\n`);
+    return trusted ? 0 : 1;
+  }
+
+  if (cmd === "list") {
+    try {
+      printRuleWarnings(await activateRules({ ...opts, rules: opts.rules }));
+    } catch (e) {
+      console.error(`  ${red("error")} ${e.message}`);
+      return 1;
+    }
+    const packs = rules.activePacks();
+    if (opts.json) {
+      console.log(JSON.stringify(packs, null, 2));
+      return 0;
+    }
+    console.log(`\n  ${bold("Rule packs in effect")}\n`);
+    for (const p of packs) {
+      const sig = p.signature === "valid" ? green(`signed by ${p.signer}`)
+        : p.origin === "bundled" ? yellow(`${p.signature === "invalid" ? "signature invalid" : "unsigned"} (bundled; release check requires a signature)`)
+        : red("UNSIGNED (--allow-unsigned-rules)");
+      console.log(`  ${bold(`${p.name}@${p.version}`)}  ${dim(p.origin)}  ${p.count} rules  ${sig}`);
+      console.log(`    ${dim(p.dir)}`);
+    }
+    console.log("");
+    return 0;
+  }
+
+  console.error(`  ${red("error")} unknown rules command "${cmd}" (list, verify)`);
+  return 2;
+}

package/src/cli/ui.js

@@ -6,6 +6,9 @@
  */
 import { parseArgs } from "node:util";
 import { spawn } from "node:child_process";
+import { mkdtempSync, openSync, writeSync, closeSync, rmSync, constants as FS } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
 import { bold, dim, red, green } from "./ansi.js";
 
 const HELP = `
@@ -17,25 +20,55 @@ const HELP = `
 
   ${dim("Options")}
         --port <n>          Port to listen on (default: 0, a random free port)
-        --open              Open the one-time URL in your browser
+        --open              Open the one-time URL in your browser (through a
+                            private launcher file, so the token is not on a
+                            command line)
         --project <dir>     Folder the dashboard may read and run the agent loop in
                             (repeatable; default: the current folder)
         --reports <dir>     Report JSON folder (default: <first project>/reports)
         --demo              Seed fake data; nothing is read from disk
     -h, --help              Show this help
 
-  The URL holds a one-time token. Opening it sets a session cookie; the token
-  then stops working. Nothing outside the project folders and ~/.penthera is
-  read, and the server never contacts the network. Ctrl-C stops it.
+  The URL holds a one-time token after the #, which the browser never sends
+  over the network. The page swaps it for a session that lives in that tab
+  only; the token then stops working. Nothing outside the project folders and
+  ~/.penthera is read, and the server never contacts the network. Ctrl-C
+  stops it.
 `;
 
-function openBrowser(url) {
-  const [cmd, args] = process.platform === "darwin" ? ["open", [url]]
-    : process.platform === "win32" ? ["cmd", ["/c", "start", "", url]]
-      : ["xdg-open", [url]];
+/**
+ * Write a small page that forwards to `url`, in a folder only this user can
+ * read, and return its path. --open hands the browser this path instead of
+ * the URL, so the token never appears in a command line (`ps` shows every
+ * process's arguments to every local user).
+ */
+export function writeLauncher(url, dir = mkdtempSync(join(tmpdir(), "penthera-ui-"))) {
+  const file = join(dir, "open.html");
+  const safe = url.replace(/[^A-Za-z0-9:/#=._-]/g, "");
+  const html = `<!doctype html><meta charset="utf-8"><meta name="referrer" content="no-referrer">`
+    + `<meta http-equiv="refresh" content="0;url=${safe}"><title>penthera ui</title>`
+    + `<p>Opening penthera ui. If nothing happens, use the link printed in the terminal.</p>\n`;
+  const fd = openSync(file, FS.O_WRONLY | FS.O_CREAT | FS.O_EXCL | (FS.O_NOFOLLOW || 0), 0o600);
+  try { writeSync(fd, html); } finally { closeSync(fd); }
+  return { file, dir };
+}
+
+function openBrowser(url, session) {
+  let launcher;
+  try { launcher = writeLauncher(url); } catch { return; /* the URL is printed anyway */ }
+  const target = launcher.file;
+  const [cmd, args] = process.platform === "darwin" ? ["open", [target]]
+    : process.platform === "win32" ? ["cmd", ["/c", "start", "", target]]
+      : ["xdg-open", [target]];
   try {
     spawn(cmd, args, { stdio: "ignore", detached: true }).unref();
   } catch { /* the URL is printed anyway */ }
+  // The launcher is useless once the link is redeemed; remove it then, or after two minutes.
+  const cleanup = () => { clearInterval(poll); rmSync(launcher.dir, { recursive: true, force: true }); };
+  const poll = setInterval(() => { if (session.redeemed) cleanup(); }, 500);
+  poll.unref();
+  setTimeout(cleanup, 120_000).unref();
+  process.once("exit", cleanup);
 }
 
 export async function runUi(argv, { version }) {
@@ -76,9 +109,9 @@ export async function runUi(argv, { version }) {
 
   process.stdout.write(`\n  ${bold("penthera ui")}${opts.demo ? dim("  (demo data)") : ""}\n`);
   process.stdout.write(`  ${green(ui.url)}\n`);
-  process.stdout.write(dim(`  one-time link: it signs this browser in once, then stops working\n`));
+  process.stdout.write(dim(`  one-time link: it signs one browser tab in, then stops working\n`));
   process.stdout.write(dim(`  listening on 127.0.0.1:${ui.port} only. Ctrl-C to stop\n\n`));
-  if (opts.open) openBrowser(ui.url);
+  if (opts.open) openBrowser(ui.url, ui.session);
 
   await new Promise((resolve) => {
     const stop = () => { process.stdout.write("\n  Stopped.\n"); ui.close().then(resolve); };

package/src/cli.js

@@ -51,7 +51,7 @@ function shouldRunOnboarding(positionals, opts) {
 }
 
 const HELP = `
-  ${bold("penthera")} v${pkg.version}: Cyber Security Agent. Open-source security for the apps and AI systems you ship
+  ${bold("penthera")} v${pkg.version}: your open-source cyber security agent. The security review you never had time for
 
   ${dim("Usage")}
     $ penthera                        Setup wizard: detect, check, set up (TTY, no args)
@@ -66,6 +66,7 @@ const HELP = `
     $ penthera memory show|verify|forget  Local learning store (never leaves the machine)
     $ penthera fix --plan            Plan local fix recipes (penthera fix --help)
     $ penthera evidence verify <dir> Check an evidence bundle's hashes and signature
+    $ penthera rules list|verify <dir>  Signed detection rule packs (penthera rules --help)
     $ penthera agent --loop          Scan, fix, verify, learn; local commits only (--help)
     $ penthera ui [--open] [--demo]  Local dashboard on 127.0.0.1 (penthera ui --help)
 
@@ -78,6 +79,9 @@ const HELP = `
         --fuzz                  + Property-based API fuzzing
         --nuclei <path>         + Community Nuclei YAML templates (alias for --templates)
         --templates <paths>     Comma-separated dirs of Nuclei-compatible YAML templates
+        --rules <dir>           + Signed rule pack (repeatable; scans, agents, deps)
+        --rules-signers <file>  Also trust packs signed by these keys (allowed_signers)
+        --allow-unsigned-rules  Load a pack whose signature does not verify (warns)
         --adaptive              Knowledge-graph adaptive probes on discovered routes
         --all                   Enable all modes (recon + deep + fuzz)
         --machine               macOS machine audit (keyloggers, trojans, rootkits)
@@ -210,6 +214,11 @@ export async function run() {
     return runFix(process.argv.slice(3));
   }
 
+  if (process.argv[2] === "rules") {
+    const { runRules } = await import("./cli/rules.js");
+    process.exit(await runRules(process.argv.slice(3)));
+  }
+
   if (process.argv[2] === "ui") {
     const { runUi } = await import("./cli/ui.js");
     process.exit(await runUi(process.argv.slice(3), { version: pkg.version }));
@@ -268,6 +277,9 @@ export async function run() {
         fuzz:        { type: "boolean", default: false },
         nuclei:      { type: "string" },
         templates:   { type: "string" },
+        rules:       { type: "string", multiple: true },
+        "rules-signers": { type: "string", multiple: true },
+        "allow-unsigned-rules": { type: "boolean", default: false },
         adaptive:    { type: "boolean", default: false },
         all:         { type: "boolean", default: false },
         machine:     { type: "boolean", default: false },
@@ -299,6 +311,17 @@ export async function run() {
     process.exit(0);
   }
 
+  // --rules <dir>: verified rule packs, added before any engine runs.
+  if (opts.rules) {
+    const { activateRules, printRuleWarnings } = await import("./cli/rules.js");
+    try {
+      printRuleWarnings(await activateRules(opts));
+    } catch (e) {
+      printError(e.message);
+      process.exit(2);
+    }
+  }
+
   if (opts["assessment-init"]) {
     const path = resolve(opts["assessment-init"]);
     writeFileSync(path, JSON.stringify(blankAssessment(), null, 2) + "\n");

package/src/report/evidence.js

@@ -11,9 +11,10 @@
 import { createHash } from "node:crypto";
 import { spawnSync } from "node:child_process";
 import {
-  readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync, lstatSync,
+  readFileSync, mkdirSync, existsSync, readdirSync, lstatSync, mkdtempSync, realpathSync, renameSync, rmdirSync,
+  rmSync, chmodSync, openSync, writeSync, closeSync, fstatSync, readSync, constants as FS,
 } from "node:fs";
-import { join, resolve, relative, sep } from "node:path";
+import { join, resolve, relative, sep, dirname, basename } from "node:path";
 import { createGit } from "../agent/git.js";
 
 export const SCHEMA = "penthera-evidence/1";
@@ -21,6 +22,9 @@ export const NAMESPACE = "penthera-evidence";
 export const MANIFEST = "manifest.json";
 export const SIGNATURE = "manifest.json.sig";
 
+/** Largest artifact or manifest verify will read; a bundle holds reports, not data dumps. */
+export const MAX_VERIFY_BYTES = 64 * 1024 * 1024;
+
 const SAFE_PATH = /^[A-Za-z0-9][A-Za-z0-9._-]*(?:\/[A-Za-z0-9][A-Za-z0-9._-]*)*$/;
 const SECRET_FLAG = /^--?(?:auth-cookie|auth-bearer|cookie|[\w-]*(?:token|secret|password|passwd|api-key|apikey)[\w-]*)$/i;
 const SECRET_PARAM = /^(?:[\w-]*(?:token|secret|password|passwd|key|sig|signature|auth|session|code)[\w-]*)$/i;
@@ -106,26 +110,66 @@ export function assertEmptyDir(dir) {
   if (readdirSync(dir).length) throw new Error(`--evidence ${dir} is not empty; use a new directory per run`);
 }
 
+/** Create `file` and write `buf`: never over an existing file, never through a symlink. */
+function writeExclusive(file, buf) {
+  const fd = openSync(file, FS.O_WRONLY | FS.O_CREAT | FS.O_EXCL | (FS.O_NOFOLLOW || 0), 0o644);
+  try {
+    let off = 0;
+    while (off < buf.length) off += writeSync(fd, buf, off, buf.length - off);
+  } finally {
+    closeSync(fd);
+  }
+}
+
 /**
- * Write a bundle.
+ * Write a bundle. It is built in a private temp folder next to `dir` and
+ * renamed into place at the end, so a half-written bundle is never visible
+ * and no write lands outside that folder.
  * @param {string} dir
  * @param {{ path: string, content: string|Buffer, kind?: string }[]} artifacts
  * @param {{ version: string, argv: string[], target: string, generatedAt: string,
- *           scan?: object, repo?: string|null, signKey?: string|null }} meta
+ *           scan?: object, repo?: string|null, signKey?: string|null,
+ *           parentReal?: string|null }} meta  parentReal: the real path the
+ *           parent folder must still resolve to (the dashboard's reports/evidence)
  * @returns {{ manifest: object, signed: boolean, dir: string }}
  */
 export function writeEvidenceBundle(dir, artifacts, meta) {
   const root = resolve(dir);
   assertEmptyDir(root);
-  mkdirSync(root, { recursive: true });
+  for (const a of artifacts) {
+    if (!SAFE_PATH.test(a.path) || a.path === MANIFEST || a.path === SIGNATURE) throw new Error(`Bad artifact path ${a.path}`);
+  }
+  const parent = dirname(root);
+  mkdirSync(parent, { recursive: true });
+  const parentReal = realpathSync(parent);
+  const checkParent = () => {
+    const now = realpathSync(parent);
+    if (now !== parentReal || (meta.parentReal && now !== meta.parentReal)) {
+      throw new Error(`Refusing to write the bundle: ${parent} now resolves to ${now}`);
+    }
+  };
+  checkParent();
+  const tmp = mkdtempSync(join(parentReal, `.${basename(root)}.tmp-`));
+  try {
+    const out = buildBundle(tmp, artifacts, meta);
+    chmodSync(tmp, 0o755);
+    checkParent();
+    if (existsSync(root)) rmdirSync(root); // assertEmptyDir allowed an existing empty folder
+    renameSync(tmp, join(parentReal, basename(root)));
+    return { ...out, dir: root };
+  } catch (e) {
+    rmSync(tmp, { recursive: true, force: true });
+    throw e;
+  }
+}
 
+function buildBundle(root, artifacts, meta) {
   const entries = [];
   for (const a of artifacts) {
-    if (!SAFE_PATH.test(a.path) || a.path === MANIFEST || a.path === SIGNATURE) throw new Error(`Bad artifact path ${a.path}`);
     const buf = Buffer.isBuffer(a.content) ? a.content : Buffer.from(String(a.content), "utf-8");
     const file = join(root, ...a.path.split("/"));
-    mkdirSync(resolve(file, ".."), { recursive: true });
-    writeFileSync(file, buf);
+    mkdirSync(dirname(file), { recursive: true });
+    writeExclusive(file, buf);
     entries.push({ path: a.path, kind: a.kind || null, bytes: buf.length, sha256: sha256(buf) });
   }
   entries.sort((x, y) => x.path.localeCompare(y.path));
@@ -145,10 +189,10 @@ export function writeEvidenceBundle(dir, artifacts, meta) {
     signature: signKey ? { namespace: NAMESPACE, file: SIGNATURE, public_key: publicKeyFor(signKey) } : null,
   };
   const manifestPath = join(root, MANIFEST);
-  writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + "\n");
+  writeExclusive(manifestPath, Buffer.from(JSON.stringify(manifest, null, 2) + "\n", "utf-8"));
 
   if (signKey) signManifest(manifestPath, signKey);
-  return { manifest, signed: Boolean(signKey), dir: root };
+  return { manifest, signed: Boolean(signKey) };
 }
 
 /** ssh-keygen -Y sign; writes <manifest>.sig. A passphrase prompt goes to the terminal. */
@@ -161,6 +205,42 @@ export function signManifest(manifestPath, keyPath) {
   if (r.status !== 0) throw new Error(`ssh-keygen -Y sign failed: ${(r.stderr || "").trim()}`);
 }
 
+/**
+ * Read `rel` (a SAFE_PATH below `root`) only when every component is a real
+ * folder or, for the last, a regular file no larger than MAX_VERIFY_BYTES.
+ * Returns { buf } or { reason }.
+ */
+function readInside(root, rel, maxBytes = MAX_VERIFY_BYTES) {
+  let cur = root;
+  const parts = rel.split("/");
+  for (let i = 0; i < parts.length; i++) {
+    cur = join(cur, parts[i]);
+    let st;
+    try { st = lstatSync(cur); } catch { return { reason: "missing" }; }
+    const last = i === parts.length - 1;
+    if (st.isSymbolicLink()) return { reason: last ? "not a regular file" : "inside a symlinked folder" };
+    if (!last && !st.isDirectory()) return { reason: "missing" };
+    if (last && !st.isFile()) return { reason: "not a regular file" };
+    if (last && st.size > maxBytes) return { reason: `larger than ${maxBytes} bytes` };
+  }
+  let fd;
+  try { fd = openSync(cur, FS.O_RDONLY | (FS.O_NOFOLLOW || 0)); } catch { return { reason: "unreadable" }; }
+  try {
+    const size = fstatSync(fd).size;
+    if (size > maxBytes) return { reason: `larger than ${maxBytes} bytes` };
+    const buf = Buffer.alloc(size);
+    let off = 0;
+    while (off < size) {
+      const n = readSync(fd, buf, off, size - off, off);
+      if (!n) break;
+      off += n;
+    }
+    return { buf: buf.subarray(0, off) };
+  } finally {
+    closeSync(fd);
+  }
+}
+
 function listFiles(root, dir = root, out = []) {
   for (const name of readdirSync(dir)) {
     const p = join(dir, name);
@@ -218,17 +298,20 @@ function checkSignature(root, manifestBuf, manifest, allowedSigners) {
  * `warnings` carries the UNSIGNED notice for a bundle that passes without a
  * signature; `requireSignature` turns that into a failure.
  * @param {string} dir
- * @param {{ allowedSigners?: string, requireSignature?: boolean }} opts
+ * @param {{ allowedSigners?: string, requireSignature?: boolean, maxBytes?: number }} opts
+ *   maxBytes: largest file read (default MAX_VERIFY_BYTES); every path
+ *   component is lstat'ed, so a symlinked folder is never followed
  */
-export function verifyEvidence(dir, { allowedSigners = null, requireSignature = false } = {}) {
+export function verifyEvidence(dir, { allowedSigners = null, requireSignature = false, maxBytes = MAX_VERIFY_BYTES } = {}) {
   const root = resolve(dir);
   const problems = [];
   const files = [];
   const fail = (msg) => ({ ok: false, problems: [msg], warnings: [], files, unlisted: [], signature: null, manifest: null });
 
-  const manifestPath = join(root, MANIFEST);
-  if (!existsSync(manifestPath)) return fail(`${MANIFEST} not found in ${dir}`);
-  const manifestBuf = readFileSync(manifestPath);
+  const read = readInside(root, MANIFEST, maxBytes);
+  if (read.reason === "missing") return fail(`${MANIFEST} not found in ${dir}`);
+  if (!read.buf) return fail(`${MANIFEST}: ${read.reason}`);
+  const manifestBuf = read.buf;
   let manifest;
   try {
     manifest = JSON.parse(manifestBuf.toString("utf-8"));
@@ -238,18 +321,19 @@ export function verifyEvidence(dir, { allowedSigners = null, requireSignature =
   if (manifest?.schema !== SCHEMA || !Array.isArray(manifest.artifacts)) return fail(`${MANIFEST} is not a ${SCHEMA} manifest`);
 
   const listed = new Set();
+  const folded = new Set(); // case-insensitive file systems: REPORT.json is report.json
   for (const a of manifest.artifacts) {
     const path = a?.path;
-    if (typeof path !== "string" || !SAFE_PATH.test(path) || path === MANIFEST || path === SIGNATURE || listed.has(path)) {
+    const lower = typeof path === "string" ? path.toLowerCase() : null;
+    if (typeof path !== "string" || !SAFE_PATH.test(path) || lower === MANIFEST || lower === SIGNATURE || folded.has(lower)) {
       problems.push(`unsafe or duplicate artifact path ${JSON.stringify(path)}`);
       continue;
     }
     listed.add(path);
-    const file = join(root, ...path.split("/"));
-    const st = existsSync(file) ? lstatSync(file) : null;
-    if (!st) { files.push({ path, ok: false, reason: "missing" }); continue; }
-    if (!st.isFile()) { files.push({ path, ok: false, reason: "not a regular file" }); continue; }
-    const actual = sha256(readFileSync(file));
+    folded.add(lower);
+    const got = readInside(root, path, maxBytes);
+    if (!got.buf) { files.push({ path, ok: false, reason: got.reason }); continue; }
+    const actual = sha256(got.buf);
     if (typeof a.sha256 !== "string" || actual !== a.sha256.toLowerCase()) {
       files.push({ path, ok: false, reason: "hash mismatch", expected: a.sha256, actual });
     } else {

package/src/report/footer.js

@@ -3,7 +3,7 @@
  * report, audience reports, the PR comment and the evidence bundle README.
  * Never added to SARIF or JSON. `--no-footer` turns it off.
  */
-export const FOOTER = "Checked by Penthera, open-source security for the apps and AI systems you ship · https://github.com/danoszz/penthera";
+export const FOOTER = "Checked by Penthera, an open-source cyber security agent · https://github.com/danoszz/penthera";
 
 /** Lines to push at the very end of a Markdown document, or none when opted out. */
 export function footerLines({ footer = true } = {}) {

package/src/report/md-escape.js

@@ -14,3 +14,11 @@ export function mdInline(s) {
     .replace(/>/g, ">")
     .replace(/\|/g, "\\|");
 }
+
+/**
+ * A Markdown table cell for our own CI reports (text we wrote, not scanned
+ * input): backslashes first, then pipes, newlines folded to a space.
+ */
+export function mdCell(s) {
+  return String(s).replace(/\\/g, "\\\\").replace(/\|/g, "\\|").replace(/\r?\n|\r/g, " ");
+}

package/src/scan-repo.js

@@ -12,6 +12,7 @@ import { join } from "node:path";
 import { discoverAttackSurface, groupByTrustBoundary, findRiskyRoutes } from "../lib/attack-surface.js";
 import { scanSecrets } from "../lib/whitebox/secrets.js";
 import { discoverFrameworkRoutes } from "../lib/whitebox/frameworks.js";
+import { runtimeAdvisoriesForRepo } from "../lib/advisories/index.js";
 
 /** Auto-detect API routes directory (Next.js, Express-style, etc.). */
 function findApiRoot(repoPath) {
@@ -62,6 +63,11 @@ export async function scanRepo(repoPath, opts = {}) {
   result.findings.push(...scanSecrets(repoPath));
   result.executedProbes.push("secret-scanning");
 
+  // ── Phase 1b: Runtime pins (Dockerfile, .tool-versions, ...) vs advisories
+  progress("Checking pinned runtime versions against advisories...");
+  result.findings.push(...runtimeAdvisoriesForRepo(repoPath));
+  result.executedProbes.push("runtime-advisories");
+
   // ── Phase 2: Locate API root ───────────────────────────────────────────
   progress("Locating API routes directory...");
   const apiRoot = opts.apiRoot || findApiRoot(repoPath);

package/src/scan-url.js

@@ -51,12 +51,13 @@ import { scanOpenApi, probeAuthEndpoints } from "../lib/blackbox/openapi.js";
 import { probeIdorBola } from "../lib/blackbox/idor.js";
 import { probeOAuthMisconfig } from "../lib/blackbox/oauth.js";
 import { auditSecurityHeaders } from "../lib/blackbox/headers.js";
+import { runtimeAdvisoriesForResponse } from "../lib/advisories/index.js";
 import { probeClientSideAuth } from "../lib/blackbox/client-auth.js";
 import { probeJwt } from "../lib/blackbox/jwt.js";
 import { probeEmailDns } from "../lib/blackbox/email-dns.js";
 import { resolveAuth } from "./utils/auth.js";
 import { normalizeBaseUrl, isPrivateHost, joinUrl } from "./utils/url.js";
-import { safeFetch, createEgressContext, runWithEgress, egressSummary, probeErrors } from "./utils/http.js";
+import { safeFetch, readBody, createEgressContext, runWithEgress, egressSummary, probeErrors } from "./utils/http.js";
 import { RECON_HOSTS } from "../lib/recon.js";
 import { dedupeFindings } from "./cli/merge-results.js";
 
@@ -181,6 +182,13 @@ async function scanUrlInContext(target, opts) {
     result.findings.push(...auditSecurityHeaders(result.fingerprint.headers, target, { local }));
   }
 
+  // ── Phase 4b2: Runtime advisories (PHP, nginx, Apache, ... versions) ───
+  progress("Checking runtime and server versions against advisories...");
+  if (result.fingerprint?.headers) {
+    const phpPaths = filtered.filter((ep) => ep.status >= 200 && ep.status < 400 && /\.php(?:$|[?#])/i.test(ep.path)).map((ep) => ep.path);
+    result.findings.push(...runtimeAdvisoriesForResponse(result.fingerprint, { phpPaths, url: target }));
+  }
+
   // ── Phase 4c: OpenAPI / auth probes ────────────────────────────────────
   progress("Scanning OpenAPI spec and auth endpoints...");
   const openApiResult = await scanOpenApi(target, { timeout });
@@ -261,7 +269,7 @@ async function scanUrlInContext(target, opts) {
     unchecked.map(async (file) => {
       const res = await safeFetch(joinUrl(target, file.path), { timeout: 5_000, probe: "sensitive-files" });
       if (!res || res.status !== 200) return;
-      const text = await res.text().catch(() => "");
+      const text = await readBody(res).catch(() => "");
 
       if (file.severity === "info") {
         result.findings.push({
@@ -594,7 +602,7 @@ async function scanUrlInContext(target, opts) {
     "client-auth", "idor", "oauth", "sensitive-files", "cors", "cookie",
     ...(!local && !isIpHost ? ["email-dns"] : []),
     ...(result.tls ? ["tls"] : []),
-    ...(result.fingerprint?.headers ? ["security-headers"] : []),
+    ...(result.fingerprint?.headers ? ["security-headers", "runtime-advisories"] : []),
     ...(auth.bearer ? ["jwt"] : []),
     ...(!opts.skipRetireJs && retireJsRan ? ["retirejs"] : []),
     ...(!opts.skipParamDiscovery && hadEndpoints ? ["param-discovery"] : []),