0sec-cli 0.15.0 → 0.17.0

package/chunks/chunk-7DQEV5QI.js

@@ -0,0 +1,287 @@
+#!/usr/bin/env node
+import { createRequire as __0secCreateRequire } from "node:module";
+const require = __0secCreateRequire(import.meta.url);
+import {
+  allowlistedChildEnv
+} from "./chunk-KLTNTE2Z.js";
+
+// packages/core/dist/stages/npm-detectors/osv-lookup.js
+var DEFAULT_ENDPOINT = "https://api.osv.dev/v1/querybatch";
+var DEFAULT_TIMEOUT_MS = 8e3;
+var DEFAULT_RETRIES = 1;
+var RETRY_BACKOFF_MS = 400;
+var OsvLookupError = class extends Error {
+  cause;
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "OsvLookupError";
+  }
+};
+function deriveForkSiblings(name) {
+  const out = /* @__PURE__ */ new Set();
+  const dotted = /^([a-z0-9][a-z0-9-]*)\.[a-z0-9.-]+$/.exec(name);
+  if (dotted)
+    out.add(dotted[1]);
+  const scoped = /^@([a-z0-9][a-z0-9-]*)\/([a-z0-9][a-z0-9._-]*)$/.exec(name);
+  if (scoped && scoped[1] !== "types")
+    out.add(scoped[2]);
+  out.delete(name);
+  return [...out];
+}
+function createOsvAdvisoryLookup(options = {}) {
+  const endpoint = options.endpoint ?? DEFAULT_ENDPOINT;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const retries = options.retries ?? DEFAULT_RETRIES;
+  const deriveSiblings = options.deriveSiblings ?? deriveForkSiblings;
+  return async (name, version, _cwe) => {
+    const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+    if (typeof fetchImpl !== "function") {
+      throw new OsvLookupError("no fetch implementation available for OSV lookup");
+    }
+    const siblings = deriveSiblings(name).filter((s) => s && s !== name);
+    const queries = [
+      { package: { ecosystem: "npm", name }, ...version ? { version } : {} },
+      ...siblings.map((s) => ({ package: { ecosystem: "npm", name: s } }))
+    ];
+    const data = await postBatch(fetchImpl, endpoint, { queries }, timeoutMs, retries);
+    const results = data.results ?? [];
+    const advisories = [];
+    for (const v of results[0]?.vulns ?? []) {
+      if (v?.id)
+        advisories.push(v.id);
+    }
+    siblings.forEach((sib, i) => {
+      for (const v of results[i + 1]?.vulns ?? []) {
+        if (v?.id)
+          advisories.push(`sibling:${sib}:${v.id}`);
+      }
+    });
+    return [...new Set(advisories)];
+  };
+}
+async function postBatch(fetchImpl, endpoint, body, timeoutMs, retries) {
+  let lastErr;
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const res = await fetchImpl(endpoint, {
+        method: "POST",
+        headers: { "content-type": "application/json", accept: "application/json" },
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
+      if (res.status === 429 || res.status >= 500) {
+        lastErr = new OsvLookupError(`OSV transient status ${res.status}`);
+        if (attempt < retries) {
+          await delay(RETRY_BACKOFF_MS * (attempt + 1));
+          continue;
+        }
+        throw lastErr;
+      }
+      if (!res.ok) {
+        throw new OsvLookupError(`OSV lookup failed: HTTP ${res.status}`);
+      }
+      const json = await res.json();
+      if (!json || typeof json !== "object" || !("results" in json)) {
+        throw new OsvLookupError("OSV lookup returned a malformed response (no `results`)");
+      }
+      return json;
+    } catch (err) {
+      lastErr = err;
+      const transient = isAbortOrNetwork(err);
+      if (transient && attempt < retries) {
+        await delay(RETRY_BACKOFF_MS * (attempt + 1));
+        continue;
+      }
+      if (err instanceof OsvLookupError)
+        throw err;
+      throw new OsvLookupError(`OSV lookup errored: ${errMsg(err)}`, err);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  throw new OsvLookupError(`OSV lookup exhausted retries: ${errMsg(lastErr)}`, lastErr);
+}
+function isAbortOrNetwork(err) {
+  if (err instanceof OsvLookupError)
+    return false;
+  const name = err?.name;
+  return name === "AbortError" || name === "TypeError" || err instanceof Error;
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function errMsg(e) {
+  return e instanceof Error ? e.message.split("\n")[0].slice(0, 160) : String(e);
+}
+
+// packages/core/dist/stages/npm-detectors/probe.js
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+function inProcessProbe(pkg, baseDir, note) {
+  const req = createRequire(pathToFileURL(baseDir.endsWith("/") ? baseDir : `${baseDir}/`).href);
+  return {
+    pkg,
+    baseDir,
+    load(moduleId) {
+      try {
+        return req(moduleId);
+      } catch {
+        return void 0;
+      }
+    },
+    note
+  };
+}
+function staticProbe(pkg, modules, note) {
+  return {
+    pkg,
+    baseDir: "/dev/null",
+    load(moduleId) {
+      return Object.prototype.hasOwnProperty.call(modules, moduleId) ? modules[moduleId] : void 0;
+    },
+    note
+  };
+}
+
+// packages/core/dist/stages/npm-detectors/sandbox-probe.js
+import { execFile } from "node:child_process";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+var DEFAULT_INSTALL_TIMEOUT_MS = 18e4;
+var DEFAULT_RUN_TIMEOUT_MS = 12e4;
+function defaultHarnessPath() {
+  return fileURLToPath(new URL("./sandbox-harness.js", import.meta.url));
+}
+function localSandboxProvider() {
+  return {
+    async create() {
+      const workdir = await mkdtemp(join(tmpdir(), "0sec-npm-dyn-"));
+      return {
+        workdir,
+        run(cmd, args, runOpts) {
+          return new Promise((resolve, reject) => {
+            execFile(cmd, args, {
+              cwd: runOpts?.cwd ?? workdir,
+              timeout: runOpts?.timeoutMs ?? DEFAULT_RUN_TIMEOUT_MS,
+              maxBuffer: 64 * 1024 * 1024,
+              // This child runs UNTRUSTED npm package code (install + harness
+              // exec). Inheriting process.env would hand every provider /
+              // cloud credential to attacker-authored package code via one
+              // `process.env` read. Build from the allowlist instead; a fresh
+              // npm install needs only PATH/HOME/TMPDIR, all carried there.
+              env: allowlistedChildEnv(runOpts?.env ?? {})
+            }, (err, stdout, stderr) => {
+              const anyErr = err;
+              if (anyErr && typeof anyErr.code !== "number") {
+                reject(anyErr);
+                return;
+              }
+              resolve({
+                stdout: stdout?.toString() ?? "",
+                stderr: stderr?.toString() ?? "",
+                exitCode: typeof anyErr?.code === "number" ? anyErr.code : 0
+              });
+            });
+          });
+        },
+        async dispose() {
+          await rm(workdir, { recursive: true, force: true });
+        }
+      };
+    }
+  };
+}
+function parseHarnessResult(stdout) {
+  const lines = stdout.split("\n").map((l) => l.trim()).filter(Boolean);
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i];
+    if (!line.startsWith("{"))
+      continue;
+    try {
+      const parsed = JSON.parse(line);
+      if (parsed && Array.isArray(parsed.outcomes)) {
+        return { outcomes: parsed.outcomes, warnings: Array.isArray(parsed.warnings) ? parsed.warnings : [] };
+      }
+    } catch {
+    }
+  }
+  return void 0;
+}
+function createSandboxPackageRunner(options = {}) {
+  const provider = options.provider ?? localSandboxProvider();
+  const harnessPath = options.harnessPath ?? defaultHarnessPath();
+  const nodeBin = options.nodeBin ?? process.execPath;
+  const installTimeoutMs = options.installTimeoutMs ?? DEFAULT_INSTALL_TIMEOUT_MS;
+  const runTimeoutMs = options.runTimeoutMs ?? DEFAULT_RUN_TIMEOUT_MS;
+  const log = options.log ?? (() => {
+  });
+  return async function sandboxRunner(pkg, detectorIds) {
+    let session;
+    try {
+      session = await provider.create();
+    } catch (e) {
+      log(`SKIP ${pkg.name}: sandbox create failed: ${errMsg2(e)}`);
+      return void 0;
+    }
+    let result;
+    try {
+      const spec = pkg.version ? `${pkg.name}@${pkg.version}` : pkg.name;
+      const install = await session.run("npm", ["install", "--ignore-scripts", "--no-audit", "--no-fund", "--no-package-lock", "--prefix", session.workdir, spec], { cwd: session.workdir, timeoutMs: installTimeoutMs });
+      if (install.exitCode !== 0) {
+        log(`SKIP ${pkg.name}: npm install exited ${install.exitCode}: ${firstLine(install.stderr)}`);
+        return void 0;
+      }
+      const config = JSON.stringify({
+        installDir: session.workdir,
+        pkg,
+        detectorIds,
+        offlineDedup: options.offlineDedup ?? false
+      });
+      const harness = await session.run(nodeBin, [harnessPath, config], {
+        cwd: session.workdir,
+        timeoutMs: runTimeoutMs
+      });
+      if (harness.exitCode !== 0) {
+        log(`SKIP ${pkg.name}: harness exited ${harness.exitCode}: ${firstLine(harness.stderr)}`);
+        return void 0;
+      }
+      const parsed = parseHarnessResult(harness.stdout);
+      if (!parsed) {
+        log(`SKIP ${pkg.name}: harness produced no parseable result`);
+        return void 0;
+      }
+      result = parsed;
+    } catch (e) {
+      log(`SKIP ${pkg.name}: sandbox run threw: ${errMsg2(e)}`);
+      result = void 0;
+    } finally {
+      try {
+        await session.dispose();
+      } catch (e) {
+        log(`WARN ${pkg.name}: sandbox dispose failed: ${errMsg2(e)}`);
+      }
+    }
+    return result;
+  };
+}
+function errMsg2(e) {
+  return e instanceof Error ? e.message.split("\n")[0].slice(0, 200) : String(e);
+}
+function firstLine(s) {
+  return (s.split("\n").find(Boolean) ?? "").slice(0, 200);
+}
+
+export {
+  OsvLookupError,
+  deriveForkSiblings,
+  createOsvAdvisoryLookup,
+  inProcessProbe,
+  staticProbe,
+  localSandboxProvider,
+  createSandboxPackageRunner
+};

package/chunks/chunk-A6CLR72I.js

@@ -0,0 +1,235 @@
+#!/usr/bin/env node
+import { createRequire as __0secCreateRequire } from "node:module";
+const require = __0secCreateRequire(import.meta.url);
+import {
+  LlmApiRuntime
+} from "./chunk-2SANI5RH.js";
+
+// packages/core/dist/stages/variant-candidates.js
+import { execFileSync } from "node:child_process";
+
+// packages/core/dist/stages/hunt-reachability.js
+var UNREACHABLE_PATH_PREFIXES = [
+  // ── Not built on COS (kernelctf-config.ts COS_CONFIG_STATE) ──
+  "net/kcm/",
+  // CONFIG_AF_KCM not-built — the original "kcm lesson"
+  "net/bluetooth/",
+  // CONFIG_BT not-built
+  "net/can/",
+  // CONFIG_CAN not-built
+  "fs/f2fs/",
+  // CONFIG_F2FS_FS not-built
+  // ── Exotic/unbuilt drivers (observed this session; same story, not yet
+  //    in kernelctf-config.ts's token map) ──
+  "drivers/infiniband/",
+  // RXE/infiniband — not built on COS
+  "drivers/net/wireless/",
+  // mwifiex etc. — not built on COS
+  "drivers/media/",
+  // exotic media drivers — not built on COS
+  "drivers/hid/",
+  // hidraw — not built on COS
+  "drivers/usb/gadget/",
+  // USB gadget — not built / not a zero-cap network path
+  "drivers/usb/atm/",
+  // uea/ueagle-atm — not built on COS
+  "drivers/xen/",
+  // xen paravirt — COS is not a Xen guest
+  "drivers/staging/",
+  // staging tree — not built on COS, churny/unstable
+  // ── Exotic filesystems: the trigger is mount(2), which needs
+  //    CAP_SYS_ADMIN a zero-cap kernelCTF attacker doesn't have (mirrors
+  //    kernelctf-config.ts's ext4/xfs/btrfs/ntfs3/fuse `needsCap:
+  //    CAP_SYS_ADMIN` entries); these ones aren't built on COS at all either ──
+  "fs/reiserfs/",
+  "fs/hpfs/",
+  "fs/sysv/",
+  "fs/ntfs/",
+  // legacy ntfs (distinct from the ntfs3 module)
+  "fs/jfs/"
+];
+var REACHABLE_PATH_PREFIXES = [
+  "crypto/",
+  // CONFIG_CRYPTO_USER_API_{AEAD,SKCIPHER,HASH} — AF_ALG, zero-cap
+  "net/unix/",
+  // CONFIG_UNIX — AF_UNIX, zero-cap
+  "net/core/",
+  // core socket/skb plumbing, zero-cap from any AF_* socket
+  "net/ipv4/",
+  // core IPv4, zero-cap
+  "net/ipv6/",
+  // core IPv6, zero-cap
+  // CONFIG_PACKET — kernelctf-config.ts marks needsCap CAP_NET_RAW for
+  // AF_PACKET itself; still listed reachable here (worth the finder budget).
+  "net/packet/",
+  "net/vmw_vsock/",
+  // CONFIG_VSOCKETS(+_LOOPBACK) — AF_VSOCK loopback, zero-cap
+  "net/tls/",
+  // CONFIG_TLS — kTLS, zero-cap
+  "net/xfrm/",
+  // IPsec policy/state — reachable via standard AF_INET{,6} sockets
+  "net/netlink/",
+  // AF_NETLINK core — zero-cap socket family
+  "ipc/",
+  // CONFIG_SYSVIPC — System-V IPC (msg/sem/shm), zero-cap
+  // CONFIG_EXT4_FS / CONFIG_XFS_FS — kernelctf-config.ts marks needsCap
+  // CAP_SYS_ADMIN for the *mount* trigger; still listed reachable here (core
+  // FS code is real audit surface, worth the finder budget).
+  "fs/ext4/",
+  "fs/xfs/",
+  // unprivileged_bpf_disabled is commonly runtime-off; listed reachable here
+  // rather than dropped outright (flag the caveat in the finder hint instead).
+  "kernel/bpf/",
+  "security/keys/"
+  // CONFIG_KEYS — keyrings / add_key(2), zero-cap
+];
+function hasPathSegmentPrefix(path, prefix) {
+  const idx = path.indexOf(prefix);
+  if (idx === -1)
+    return false;
+  return idx === 0 || path[idx - 1] === "/";
+}
+function classifyPathReachability(path) {
+  const norm = path.replace(/\\/g, "/");
+  for (const prefix of UNREACHABLE_PATH_PREFIXES)
+    if (hasPathSegmentPrefix(norm, prefix))
+      return "unreachable";
+  for (const prefix of REACHABLE_PATH_PREFIXES)
+    if (hasPathSegmentPrefix(norm, prefix))
+      return "reachable";
+  return "unknown";
+}
+function applyReachabilityGate(paths, opts) {
+  if (!opts.reachableOnly && !opts.reachablePrefer)
+    return { paths, unreachableCount: 0 };
+  const classified = paths.map((path) => ({ path, cls: classifyPathReachability(path) }));
+  const unreachableCount = classified.filter((c) => c.cls === "unreachable").length;
+  if (opts.reachableOnly) {
+    return { paths: classified.filter((c) => c.cls === "reachable").map((c) => c.path), unreachableCount };
+  }
+  const rank = { reachable: 0, unknown: 1, unreachable: 2 };
+  const sorted = [...classified].sort((a, b) => rank[a.cls] - rank[b.cls]).map((c) => c.path);
+  return { paths: sorted, unreachableCount };
+}
+
+// packages/core/dist/stages/variant-candidates.js
+var clip = (s, n) => s.length > n ? s.slice(0, n) + `
+...[truncated ${s.length - n} chars]` : s;
+function fixedPathsFromDiff(diff) {
+  const out = [];
+  for (const line of diff.split("\n")) {
+    const m = /^\+\+\+ b\/(.+)$/.exec(line);
+    if (m && m[1] !== "/dev/null")
+      out.push(m[1].trim());
+  }
+  return [...new Set(out)];
+}
+function grepFiles(pattern, sourceRoot, includeGlobs) {
+  const args = ["-rlE", ...includeGlobs.map((g) => `--include=${g}`), "--", pattern, "."];
+  try {
+    const out = execFileSync("grep", args, { cwd: sourceRoot, encoding: "utf8", maxBuffer: 32 * 1024 * 1024, timeout: 6e4 });
+    return out.split("\n").map((s) => s.replace(/^\.\//, "").trim()).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+async function generateVariantCandidates(input) {
+  const log = input.log ?? (() => {
+  });
+  const warnings = [];
+  const maxCandidates = input.maxCandidates ?? 40;
+  const includeGlobs = input.includeGlobs ?? ["*.c", "*.h", "*.cc", "*.cpp"];
+  let diff = input.fix.diff ?? "";
+  if (!diff && input.fix.commit) {
+    try {
+      diff = execFileSync("git", ["-C", input.sourceRoot, "show", "--no-color", input.fix.commit], {
+        encoding: "utf8",
+        maxBuffer: 16 * 1024 * 1024,
+        timeout: 3e4
+      });
+    } catch (e) {
+      throw new Error(`could not read fix commit ${input.fix.commit}: ${String(e).slice(0, 160)}`);
+    }
+  }
+  if (!diff.trim())
+    throw new Error("variant hunt needs fix.diff or fix.commit");
+  const fixedPaths = fixedPathsFromDiff(diff);
+  const tool = {
+    name: "emit_variant_plan",
+    description: "Emit the variant-hunt plan derived from the fix diff.",
+    input_schema: {
+      type: "object",
+      properties: {
+        bugClass: { type: "string", description: "The bug class the fix closed, e.g. 'missing bounds check before a TLV copy'." },
+        pattern: { type: "string", description: "The exact unguarded code shape (the sink) and how the fix guarded it." },
+        grepPatterns: {
+          type: "array",
+          items: { type: "string" },
+          description: "2-6 grep ERE patterns that locate the SAME sink shape at OTHER call-sites/files (the variant sites where the fix was NOT applied). Match the sink/call, not the added guard."
+        }
+      },
+      required: ["bugClass", "pattern", "grepPatterns"]
+    }
+  };
+  const system = "You are a kernel/security VARIANT-HUNT analyst. Given a security fix diff, identify the bug class and the unguarded code SHAPE (the sink) the fix added a guard around. Then write grep EXTENDED-REGEX patterns that find the SAME bug CLASS at OTHER call-sites across the tree \u2014 where an INCOMPLETE fix or an independent instance lives.\nCRITICAL \u2014 match the CLASS, not the original site: the patched file is EXCLUDED from results, so a pattern that hardcodes the original's specific identifiers (field names like `sensf_res`, struct names like `digital_*`, the variable `resp`) will match ONLY the original and yield ZERO variants. WILDCARD the identifiers. Match the dangerous SHAPE \u2014 e.g. a length-controlled copy into a fixed buffer regardless of names: `memcpy\\([^,]+,[^,]+,[^)]*->len\\)`, or an unchecked `->len`/`->size` used as a copy/index bound. Match the sink, NOT the guard that was added.\nEmit 3-6 patterns ranging from moderately specific (the same struct-field-copy shape with wildcarded names) to general (any length-bounded memcpy/copy_from of that family). Aim for tens of hits to triage, not zero and not thousands. Call emit_variant_plan.";
+  const messages = [{ role: "user", content: [{ type: "text", text: `## Fix diff
+${clip(diff, 24e3)}` }] }];
+  const rt = new LlmApiRuntime({ type: "api", ...input.model ? { model: input.model } : {}, timeout: 24e4 });
+  let plan = null;
+  try {
+    const res = await rt.executeNative(system, messages, [tool], { onThinking() {
+    }, onDelta() {
+    }, onText() {
+    }, onUsage() {
+    } });
+    const call = (res.content ?? []).find((b) => b.type === "tool_use" && b.name === "emit_variant_plan");
+    if (call?.input)
+      plan = call.input;
+  } catch (e) {
+    throw new Error(`variant-plan LLM call failed: ${String(e).slice(0, 200)}`);
+  }
+  if (!plan || !Array.isArray(plan.grepPatterns) || plan.grepPatterns.length === 0) {
+    throw new Error("model did not emit a usable variant plan");
+  }
+  log(`[variant] bug class: ${plan.bugClass}`);
+  log(`[variant] ${plan.grepPatterns.length} grep pattern(s): ${plan.grepPatterns.join(" | ")}`);
+  const fixedSet = new Set(fixedPaths);
+  const hits = /* @__PURE__ */ new Map();
+  for (const pat of plan.grepPatterns) {
+    const files = grepFiles(pat, input.sourceRoot, includeGlobs);
+    if (files.length === 0)
+      warnings.push(`pattern matched nothing (or invalid): ${pat}`);
+    for (const f of files)
+      if (!fixedSet.has(f))
+        hits.set(f, (hits.get(f) ?? 0) + 1);
+  }
+  const ranked = [...hits.entries()].sort((a, b) => b[1] - a[1]).map(([path]) => path);
+  const gated = input.reachableOnly || input.reachablePrefer ? applyReachabilityGate(ranked, { reachableOnly: input.reachableOnly, reachablePrefer: input.reachablePrefer }) : { paths: ranked, unreachableCount: 0 };
+  if (gated.unreachableCount > 0) {
+    const verb = input.reachableOnly ? "dropped" : "deprioritized";
+    const msg = `${verb} ${gated.unreachableCount} unreachable candidate(s) (not built/zero-cap on kernelCTF COS \u2014 see hunt-reachability.ts)`;
+    warnings.push(msg);
+    log(`[variant] ${msg}`);
+  }
+  if (gated.paths.length > maxCandidates) {
+    warnings.push(`capped candidates ${gated.paths.length} -> ${maxCandidates} (raise maxCandidates to widen)`);
+  }
+  const candidates = gated.paths.slice(0, maxCandidates).map((path) => ({
+    path,
+    hint: `Variant site for: ${plan.bugClass}. Check whether ${plan.pattern} is guarded here.`
+  }));
+  log(`[variant] ${candidates.length} candidate site(s) after dedup/exclude`);
+  return {
+    brief: { bugClass: plan.bugClass, pattern: plan.pattern, fixReference: input.fix.reference ?? input.fix.commit },
+    candidates,
+    grepPatterns: plan.grepPatterns,
+    fixedPaths,
+    warnings
+  };
+}
+
+export {
+  classifyPathReachability,
+  applyReachabilityGate,
+  generateVariantCandidates
+};