break-anything 0.0.0-stage → 0.2.0

package/src/image.js

@@ -0,0 +1,114 @@
+import { spawn } from "node:child_process";
+
+// 容器镜像扫描:封装 Trivy(行业标准)。装了 trivy 就能用,没装给出清晰安装提示。
+// 把 Trivy 的 JSON 归一化成 Break Anything 统一的发现结构。
+
+export async function scanImage(ref, { severityFilter } = {}) {
+  const trivy = await which("trivy");
+  if (!trivy) {
+    return {
+      target: ref,
+      ok: false,
+      engine: "trivy",
+      message:
+        "未找到 trivy。镜像扫描依赖 Trivy(Aqua Security)。安装:\n" +
+        "  macOS:  brew install trivy\n" +
+        "  Linux:  见 https://aquasecurity.github.io/trivy/latest/getting-started/installation/",
+      findings: [],
+      summary: { total: 0, bySeverity: {} },
+    };
+  }
+
+  const args = ["image", "--quiet", "--format", "json", "--scanners", "vuln"];
+  if (severityFilter) args.push("--severity", severityFilter);
+  args.push(ref);
+
+  let raw;
+  try {
+    raw = await run(trivy, args);
+  } catch (err) {
+    return {
+      target: ref,
+      ok: false,
+      engine: "trivy",
+      message: `trivy 执行失败:${err instanceof Error ? err.message : String(err)}`,
+      findings: [],
+      summary: { total: 0, bySeverity: {} },
+    };
+  }
+
+  return normalizeTrivy(raw, ref);
+}
+
+// 导出以便单测:把 trivy JSON 文本归一化
+export function normalizeTrivy(rawJson, ref) {
+  let data;
+  try { data = typeof rawJson === "string" ? JSON.parse(rawJson) : rawJson; }
+  catch { return { target: ref, ok: false, engine: "trivy", message: "无法解析 trivy 输出", findings: [], summary: { total: 0, bySeverity: {} } }; }
+
+  const findings = [];
+  for (const result of data.Results || []) {
+    const target = result.Target;
+    const cls = result.Class; // os-pkgs / lang-pkgs
+    for (const v of result.Vulnerabilities || []) {
+      findings.push({
+        package: v.PkgName,
+        version: v.InstalledVersion,
+        id: v.VulnerabilityID,
+        cve: /^CVE-/i.test(v.VulnerabilityID || "") ? v.VulnerabilityID : null,
+        severity: (v.Severity || "UNKNOWN").toUpperCase(),
+        fixedVersions: v.FixedVersion ? [v.FixedVersion] : [],
+        class: cls,
+        location: target,
+        summary: v.Title || (v.Description ? v.Description.slice(0, 160) : ""),
+        references: (v.References || []).slice(0, 5),
+      });
+    }
+  }
+  findings.sort((a, b) => sevRank(b.severity) - sevRank(a.severity));
+
+  return {
+    target: ref,
+    ok: true,
+    engine: "trivy",
+    findings,
+    summary: {
+      total: findings.length,
+      fixable: findings.filter((f) => f.fixedVersions.length).length,
+      bySeverity: countBy(findings, "severity"),
+    },
+  };
+}
+
+function which(cmd) {
+  return new Promise((resolve) => {
+    const p = spawn(process.platform === "win32" ? "where" : "which", [cmd], { stdio: ["ignore", "pipe", "ignore"] });
+    let out = "";
+    p.stdout.on("data", (d) => (out += d));
+    p.on("close", (code) => resolve(code === 0 ? out.trim().split("\n")[0] : null));
+    p.on("error", () => resolve(null));
+  });
+}
+
+function run(cmd, args) {
+  return new Promise((resolve, reject) => {
+    const p = spawn(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
+    let out = "";
+    let err = "";
+    p.stdout.on("data", (d) => (out += d));
+    p.stderr.on("data", (d) => (err += d));
+    p.on("close", (code) => {
+      if (code === 0 || out.trim().startsWith("{")) resolve(out);
+      else reject(new Error(err.trim().slice(0, 300) || `exit ${code}`));
+    });
+    p.on("error", reject);
+  });
+}
+
+const SEV = { CRITICAL: 4, HIGH: 3, MEDIUM: 2, LOW: 1, UNKNOWN: 0 };
+function sevRank(s) { return SEV[s] ?? 0; }
+function countBy(arr, key) {
+  const m = {};
+  for (const x of arr) m[x[key]] = (m[x[key]] || 0) + 1;
+  return m;
+}

package/src/lockfiles.js

@@ -0,0 +1,118 @@
+import { readFile, stat } from "node:fs/promises";
+import path from "node:path";
+
+// 探测目标路径下支持的 lockfile,返回 { ecosystem, file, packages, manifestDirect }
+// packages: [{ name, version, ecosystem, direct }]
+// manifestDirect: Set<string> 直接依赖名(用于可达性判断)
+export async function loadLockfiles(targetPath) {
+  const dir = await resolveDir(targetPath);
+  const out = [];
+
+  const npmLock = path.join(dir, "package-lock.json");
+  if (await exists(npmLock)) out.push(await parseNpmLock(npmLock, dir));
+
+  const composerLock = path.join(dir, "composer.lock");
+  if (await exists(composerLock)) out.push(await parseComposerLock(composerLock, dir));
+
+  const reqTxt = path.join(dir, "requirements.txt");
+  if (await exists(reqTxt)) out.push(await parseRequirements(reqTxt));
+
+  return { dir, sources: out.filter(Boolean) };
+}
+
+async function resolveDir(p) {
+  const s = await stat(p);
+  return s.isDirectory() ? p : path.dirname(p);
+}
+
+async function exists(p) {
+  try { await stat(p); return true; } catch { return false; }
+}
+
+// ---- npm: package-lock.json(v2/v3 的 packages,回退 v1 的 dependencies)----
+async function parseNpmLock(file, dir) {
+  const raw = JSON.parse(await readFile(file, "utf8"));
+  const direct = await readNpmDirect(dir);
+  const map = new Map();
+
+  if (raw.packages && typeof raw.packages === "object") {
+    for (const [key, info] of Object.entries(raw.packages)) {
+      if (!key || !info?.version) continue; // "" 是根项目,跳过
+      const name = key.startsWith("node_modules/")
+        ? key.slice(key.lastIndexOf("node_modules/") + "node_modules/".length)
+        : key;
+      if (!name) continue;
+      map.set(`${name}@${info.version}`, { name, version: info.version });
+    }
+  } else if (raw.dependencies && typeof raw.dependencies === "object") {
+    walkV1(raw.dependencies, map);
+  }
+
+  const packages = [...map.values()].map((p) => ({
+    ...p,
+    ecosystem: "npm",
+    direct: direct.has(p.name),
+  }));
+  return { ecosystem: "npm", file, packages, manifestDirect: direct };
+}
+
+function walkV1(deps, map) {
+  for (const [name, info] of Object.entries(deps)) {
+    if (info?.version) map.set(`${name}@${info.version}`, { name, version: info.version });
+    if (info?.dependencies) walkV1(info.dependencies, map);
+  }
+}
+
+async function readNpmDirect(dir) {
+  const pkgPath = path.join(dir, "package.json");
+  const set = new Set();
+  if (!(await exists(pkgPath))) return set;
+  try {
+    const pkg = JSON.parse(await readFile(pkgPath, "utf8"));
+    for (const field of ["dependencies", "devDependencies", "optionalDependencies", "peerDependencies"]) {
+      for (const name of Object.keys(pkg[field] || {})) set.add(name);
+    }
+  } catch { /* 忽略损坏的 package.json */ }
+  return set;
+}
+
+// ---- PHP: composer.lock ----
+async function parseComposerLock(file, dir) {
+  const raw = JSON.parse(await readFile(file, "utf8"));
+  const direct = await readComposerDirect(dir);
+  const packages = [];
+  for (const group of ["packages", "packages-dev"]) {
+    for (const p of raw[group] || []) {
+      if (!p.name || !p.version) continue;
+      const version = String(p.version).replace(/^v/, "");
+      packages.push({ name: p.name, version, ecosystem: "Packagist", direct: direct.has(p.name) });
+    }
+  }
+  return { ecosystem: "Packagist", file, packages, manifestDirect: direct };
+}
+
+async function readComposerDirect(dir) {
+  const p = path.join(dir, "composer.json");
+  const set = new Set();
+  if (!(await exists(p))) return set;
+  try {
+    const json = JSON.parse(await readFile(p, "utf8"));
+    for (const field of ["require", "require-dev"]) {
+      for (const name of Object.keys(json[field] || {})) set.add(name);
+    }
+  } catch { /* 忽略 */ }
+  return set;
+}
+
+// ---- Python: requirements.txt(只取用 == 钉死的版本)----
+async function parseRequirements(file) {
+  const text = await readFile(file, "utf8");
+  const packages = [];
+  for (const line of text.split(/\r?\n/)) {
+    const s = line.trim();
+    if (!s || s.startsWith("#") || s.startsWith("-")) continue;
+    const m = s.match(/^([A-Za-z0-9._-]+)\s*==\s*([A-Za-z0-9._-]+)/);
+    if (m) packages.push({ name: m[1], version: m[2], ecosystem: "PyPI", direct: true });
+  }
+  return { ecosystem: "PyPI", file, packages, manifestDirect: new Set(packages.map((p) => p.name)) };
+}

package/src/mcp.js

@@ -0,0 +1,121 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { ListToolsRequestSchema, CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { scanDependencies } from "./scan.js";
+import { scanSecrets } from "./secrets.js";
+import { scanImage } from "./image.js";
+import { scanSast } from "./sast.js";
+
+const TOOLS = [
+  {
+    name: "deps_scan",
+    description:
+      "Scan a project's dependency lockfiles (npm package-lock.json, PHP composer.lock, " +
+      "Python requirements.txt) for known vulnerabilities via OSV. Returns findings ranked by " +
+      "severity, reachability (is the package actually imported in the project source), and EPSS " +
+      "exploit probability, with fix versions. Point this only at code you own or are authorized " +
+      "to test.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Absolute path to the project directory (or a lockfile) to scan.",
+        },
+        reachability: {
+          type: "boolean",
+          description: "Compute import-based reachability heuristic from project source. Default true.",
+        },
+      },
+      required: ["path"],
+    },
+  },
+  {
+    name: "secrets_scan",
+    description:
+      "Scan a project for leaked secrets (API keys, tokens, private keys) in the working tree " +
+      "and, optionally, the full git history. Matches are redacted in the output. Runs locally. " +
+      "Point this only at repositories you own or are authorized to test.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Absolute path to the repository to scan." },
+        history: { type: "boolean", description: "Also scan git history (git log -p). Default false." },
+      },
+      required: ["path"],
+    },
+  },
+  {
+    name: "image_scan",
+    description:
+      "Scan a container image for known vulnerabilities using Trivy. Returns OS and application " +
+      "package CVEs ranked by severity, with fix versions. Requires Trivy to be installed. " +
+      "Scan only images you own or are authorized to test.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        ref: { type: "string", description: "Image reference, e.g. nginx:1.21 or my-service:latest." },
+      },
+      required: ["ref"],
+    },
+  },
+  {
+    name: "sast_scan",
+    description:
+      "Static application security testing (SAST) on a source tree using Semgrep. Finds injection, " +
+      "broken access control, insecure deserialization, SSRF, hardcoded secrets and more, each with " +
+      "file/line, CWE/OWASP tags, and the offending snippet. Requires Semgrep to be installed. " +
+      "Scan only code you own or are authorized to test.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Absolute path to the source tree to scan." },
+        config: { type: "string", description: "Semgrep ruleset (default p/security-audit)." },
+      },
+      required: ["path"],
+    },
+  },
+];
+
+export async function startMcpServer() {
+  const server = new Server(
+    { name: "break-anything", version: "0.2.0" },
+    { capabilities: { tools: {} } },
+  );
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+
+  server.setRequestHandler(CallToolRequestSchema, async (req) => {
+    const { name, arguments: args = {} } = req.params;
+    try {
+      let result;
+      if (name === "deps_scan") {
+        if (!strArg(args.path)) return bad("缺少必填参数 path。");
+        result = await scanDependencies(args.path, { reachability: args.reachability !== false });
+      } else if (name === "secrets_scan") {
+        if (!strArg(args.path)) return bad("缺少必填参数 path。");
+        result = await scanSecrets(args.path, { history: !!args.history });
+      } else if (name === "image_scan") {
+        if (!strArg(args.ref)) return bad("缺少必填参数 ref。");
+        result = await scanImage(args.ref);
+      } else if (name === "sast_scan") {
+        if (!strArg(args.path)) return bad("缺少必填参数 path。");
+        result = await scanSast(args.path, args.config ? { config: args.config } : {});
+      } else {
+        return bad(`Unknown tool: ${name}`);
+      }
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return { isError: true, content: [{ type: "text", text: `扫描失败:${msg}` }] };
+    }
+  });
+
+  function strArg(v) { return typeof v === "string" && v.length > 0; }
+  function bad(text) { return { isError: true, content: [{ type: "text", text }] }; }
+
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  // stdio 模式下不要往 stdout 写任何非协议内容;日志走 stderr
+  process.stderr.write("break-anything MCP server 已启动(stdio)。\n");
+}

package/src/osv.js

@@ -0,0 +1,92 @@
+import { fetchJson, mapPool } from "./http.js";
+
+const OSV_QUERY = "https://api.osv.dev/v1/query";
+
+// 对单个「包@版本」查询 OSV 已知漏洞
+async function queryOne(pkg) {
+  const data = await fetchJson(OSV_QUERY, {
+    method: "POST",
+    body: { version: pkg.version, package: { name: pkg.name, ecosystem: pkg.ecosystem } },
+  });
+  const vulns = Array.isArray(data.vulns) ? data.vulns : [];
+  return vulns.map((v) => normalizeVuln(v, pkg));
+}
+
+// 把 OSV 的原始漏洞记录归一化成我们统一的发现结构
+function normalizeVuln(v, pkg) {
+  const aliases = Array.isArray(v.aliases) ? v.aliases : [];
+  const cve = aliases.find((a) => /^CVE-/i.test(a)) || null;
+  return {
+    id: v.id,
+    cve,
+    aliases,
+    summary: v.summary || (v.details ? v.details.slice(0, 160) : ""),
+    severity: extractSeverity(v),
+    fixedVersions: extractFixedVersions(v, pkg),
+    references: (v.references || []).map((r) => r.url).slice(0, 5),
+  };
+}
+
+// 严重度:优先用 database_specific.severity(GHSA 的 HIGH/MODERATE…),否则从 CVSS 推
+function extractSeverity(v) {
+  const label = v.database_specific?.severity;
+  if (typeof label === "string" && label) return label.toUpperCase();
+  const cvss = (v.severity || []).find((s) => /CVSS/i.test(s.type));
+  if (cvss?.score) {
+    const base = parseBaseFromVector(cvss.score);
+    if (base != null) return scoreToLabel(base);
+  }
+  return "UNKNOWN";
+}
+
+function parseBaseFromVector(vectorOrScore) {
+  const num = Number(vectorOrScore);
+  if (!Number.isNaN(num)) return num;
+  return null; // 不在 MVP 里完整解析 CVSS 向量
+}
+
+function scoreToLabel(base) {
+  if (base >= 9) return "CRITICAL";
+  if (base >= 7) return "HIGH";
+  if (base >= 4) return "MEDIUM";
+  if (base > 0) return "LOW";
+  return "UNKNOWN";
+}
+
+// 从 affected[].ranges[].events[] 里抽出匹配本包的「fixed」版本
+function extractFixedVersions(v, pkg) {
+  const out = new Set();
+  for (const aff of v.affected || []) {
+    if (aff.package?.name !== pkg.name) continue;
+    if (aff.package?.ecosystem && pkg.ecosystem && aff.package.ecosystem !== pkg.ecosystem) continue;
+    for (const range of aff.ranges || []) {
+      for (const ev of range.events || []) {
+        if (ev.fixed) out.add(ev.fixed);
+      }
+    }
+  }
+  return [...out];
+}
+
+const SEVERITY_ORDER = { CRITICAL: 4, HIGH: 3, MEDIUM: 2, LOW: 1, UNKNOWN: 0 };
+export function severityRank(label) {
+  return SEVERITY_ORDER[label] ?? 0;
+}
+
+// 批量查询:对一组包并发查 OSV,返回「有漏洞的包 + 其漏洞列表」
+export async function scanPackages(packages, { concurrency = 8 } = {}) {
+  const results = await mapPool(packages, concurrency, async (pkg) => {
+    const vulns = await queryOne(pkg);
+    return { pkg, vulns };
+  });
+  const findings = [];
+  const errors = [];
+  results.forEach((r, i) => {
+    if (r?.__error) {
+      errors.push({ pkg: packages[i], error: r.__error });
+      return;
+    }
+    if (r.vulns.length) findings.push(r);
+  });
+  return { findings, errors };
+}

package/src/reachability.js

@@ -0,0 +1,66 @@
+import { readdir, readFile } from "node:fs/promises";
+import path from "node:path";
+
+// 可达性初判(启发式,非证明):
+//   imported  —— 源码里确实 import/require 了这个包 → 最高优先级
+//   direct    —— 清单里声明为直接依赖,但没在源码里发现引用
+//   transitive—— 既非直接依赖、也没在源码里发现引用(传递依赖)
+// 诚实地标注这是启发式:它判断"是否被引用",不等于"漏洞函数被调用"。
+
+const SOURCE_EXT = new Set([".js", ".mjs", ".cjs", ".jsx", ".ts", ".tsx", ".vue", ".php", ".py"]);
+const SKIP_DIR = new Set(["node_modules", ".git", "dist", "build", "vendor", ".venv", "venv", "__pycache__"]);
+
+export async function buildReachability(dir, packageNames) {
+  const imported = new Set();
+  const files = [];
+  await collect(dir, files, 0);
+
+  // npm 包可能是 scope 形式 @scope/name;只取用于匹配的词根
+  const patterns = packageNames.map((name) => ({ name, re: importRegex(name) }));
+
+  for (const f of files) {
+    let text;
+    try { text = await readFile(f, "utf8"); } catch { continue; }
+    for (const { name, re } of patterns) {
+      if (imported.has(name)) continue;
+      if (re.test(text)) imported.add(name);
+    }
+  }
+  return imported;
+}
+
+async function collect(dir, out, depth) {
+  if (depth > 8 || out.length > 5000) return;
+  let entries;
+  try { entries = await readdir(dir, { withFileTypes: true }); } catch { return; }
+  for (const e of entries) {
+    if (e.name.startsWith(".") && e.name !== ".") continue;
+    const full = path.join(dir, e.name);
+    if (e.isDirectory()) {
+      if (SKIP_DIR.has(e.name)) continue;
+      await collect(full, out, depth + 1);
+    } else if (SOURCE_EXT.has(path.extname(e.name))) {
+      out.push(full);
+    }
+  }
+}
+
+function importRegex(name) {
+  const esc = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  // 命中 import 'x' / from 'x' / require('x') / use X\...(PHP) / import x(py)
+  return new RegExp(
+    `(require\\(\\s*['"\`]${esc}|from\\s+['"\`]${esc}|import\\s+['"\`]${esc}|import\\s+[^'"\`\\n]*['"\`]${esc})`,
+    "m",
+  );
+}
+
+export function classify(pkg, imported) {
+  if (imported.has(pkg.name)) return "imported";
+  if (pkg.direct) return "direct";
+  return "transitive";
+}
+
+const REACH_ORDER = { imported: 3, direct: 2, transitive: 1 };
+export function reachRank(label) {
+  return REACH_ORDER[label] ?? 0;
+}