0sec-cli 0.15.0 → 0.17.0

package/chunks/chunk-RWONANDA.js

@@ -0,0 +1,973 @@
+#!/usr/bin/env node
+import { createRequire as __0secCreateRequire } from "node:module";
+const require = __0secCreateRequire(import.meta.url);
+
+// packages/core/dist/stages/npm-detectors/dedup.js
+function forkTwinFor(hints, name) {
+  return hints?.forkTwins?.[name];
+}
+async function dedupConfirmation(args) {
+  const { name, version, cwe, hints, advisoryLookup } = args;
+  if (hints?.priorReports?.includes(name)) {
+    return {
+      novel: false,
+      source: "prior-report",
+      advisories: [`${name}: previously reported by 0sec for this class`]
+    };
+  }
+  const twin = forkTwinFor(hints, name);
+  if (twin) {
+    return { novel: false, source: "fork-cve-twin", advisories: [`${name}: ${twin}`] };
+  }
+  if (!advisoryLookup) {
+    return { novel: true, source: "unknown", advisories: [] };
+  }
+  let advisories;
+  try {
+    advisories = await advisoryLookup(name, version, cwe);
+  } catch (e) {
+    return {
+      novel: true,
+      source: "unknown",
+      advisories: [`advisory-lookup-failed: ${e instanceof Error ? e.message.split("\n")[0] : String(e)}`]
+    };
+  }
+  if (advisories.length > 0) {
+    return { novel: false, source: "osv", advisories };
+  }
+  return { novel: true, source: "novel", advisories: [] };
+}
+
+// packages/core/dist/stages/npm-detectors/base.js
+function guardPackage(pkg, guards, now = Date.now()) {
+  if (!guards)
+    return { allowed: true };
+  if (guards.downloadsFloor !== void 0 && pkg.weeklyDownloads !== void 0 && pkg.weeklyDownloads < guards.downloadsFloor) {
+    return {
+      allowed: false,
+      reason: `weeklyDownloads ${pkg.weeklyDownloads} < floor ${guards.downloadsFloor}`
+    };
+  }
+  if (guards.maxAgeDays !== void 0 && pkg.lastPublishedAt) {
+    const published = Date.parse(pkg.lastPublishedAt);
+    if (Number.isFinite(published)) {
+      const ageDays = (now - published) / 864e5;
+      if (ageDays > guards.maxAgeDays) {
+        return { allowed: false, reason: `last publish ${Math.round(ageDays)}d ago > maxAgeDays ${guards.maxAgeDays}` };
+      }
+    }
+  }
+  return { allowed: true };
+}
+async function runDetectorOnPackage(detector, probe, opts = {}) {
+  const warnings = [];
+  const base = {
+    detectorId: detector.id,
+    ran: false,
+    candidates: 0,
+    leads: [],
+    warnings
+  };
+  const guard = guardPackage(probe.pkg, opts.guards, opts.now);
+  if (!guard.allowed)
+    return { ...base, skipReason: `guard: ${guard.reason}` };
+  let applies = false;
+  try {
+    applies = detector.appliesTo(probe.pkg);
+  } catch (e) {
+    warnings.push(`appliesTo threw: ${errMsg(e)}`);
+  }
+  if (!applies)
+    return { ...base, skipReason: "appliesTo=false" };
+  base.ran = true;
+  let candidates = [];
+  try {
+    candidates = await detector.identifyCandidates(probe);
+  } catch (e) {
+    warnings.push(`identifyCandidates threw: ${errMsg(e)}`);
+    return base;
+  }
+  base.candidates = candidates.length;
+  for (const cand of candidates) {
+    let conf;
+    try {
+      conf = await detector.confirm(cand, probe);
+    } catch (e) {
+      warnings.push(`confirm(${cand.id}) threw: ${errMsg(e)}`);
+      continue;
+    }
+    if (!conf.confirmed || !conf.evidence?.observation)
+      continue;
+    const dedup = await dedupConfirmation({
+      name: probe.pkg.name,
+      version: probe.pkg.version,
+      cwe: detector.cwe,
+      hints: detector.dedupHints,
+      advisoryLookup: opts.advisoryLookup
+    });
+    base.leads.push({
+      detectorId: detector.id,
+      candidateId: cand.id,
+      confirmation: {
+        ...conf,
+        severity: conf.severity ?? detector.severityFloor,
+        source: conf.source ?? cand.label
+      },
+      dedup
+    });
+  }
+  return base;
+}
+function errMsg(e) {
+  return e instanceof Error ? e.message.split("\n")[0].slice(0, 120) : String(e);
+}
+
+// packages/core/dist/stages/npm-detectors/sspp-fuzz.js
+var NAME_RE = new RegExp("^(" + [
+  "merge",
+  "mergeWith",
+  "mergeAll",
+  "mergeDeep",
+  "mergeDeepRight",
+  "mergeDeepLeft",
+  "deepmerge",
+  "deepMerge",
+  "mergeObjects",
+  "mergeAnything",
+  "set",
+  "setWith",
+  "setWithIn",
+  "setProperty",
+  "setValue",
+  "safeSet",
+  "deepSet",
+  "dset",
+  "update",
+  "updateWith",
+  "unset",
+  "defaults",
+  "defaultsDeep",
+  "defaultsdeep",
+  "defu",
+  "defuFn",
+  "assign",
+  "assignIn",
+  "assignInWith",
+  "assignWith",
+  "assignDeep",
+  "extend",
+  "extendDeep",
+  "deepExtend",
+  "deepAssign",
+  "mixin",
+  "mixinDeep",
+  "clone",
+  "cloneDeep",
+  // NB: recursive-WRITE/merge sinks only. Deliberately NOT `parse*` — a
+  // validator's `parse`/`parseAsync` (e.g. zod) is a read/validate export,
+  // not a merge sink, and matching it both over-flags and (for the async
+  // variant) floats a rejected Promise through the sync fuzz loop.
+  "expand"
+].join("|") + ")", "i");
+var FRAGMENTS = ["merge", "deep", "assign", "extend", "defaults", "setwith", "mixin", "defu"];
+function nameMatchesPpSink(key) {
+  if (typeof key !== "string" || !key)
+    return false;
+  if (NAME_RE.test(key))
+    return true;
+  const lk = key.toLowerCase();
+  return FRAGMENTS.some((f) => lk.includes(f));
+}
+function isRecord(v) {
+  return v !== null && (typeof v === "object" || typeof v === "function");
+}
+function collectFromModule(mod, via, out, seen) {
+  if (!isRecord(mod))
+    return;
+  const push = (key, val, viaLabel) => {
+    if (typeof val !== "function")
+      return;
+    if (!nameMatchesPpSink(key))
+      return;
+    const fn2 = val;
+    if (seen.has(fn2))
+      return;
+    seen.add(fn2);
+    out.push({ id: `${key}@${viaLabel}`, label: `${viaLabel}.${key}`, fn: fn2, via: viaLabel });
+  };
+  for (const key of Object.keys(mod)) {
+    let val;
+    try {
+      val = mod[key];
+    } catch {
+      continue;
+    }
+    push(key, val, via);
+  }
+  if (typeof mod === "function" && mod.name)
+    push(mod.name, mod, `${via}(default-fn)`);
+  for (const nsKey of ["default", "compat", "fp", "object", "lodash"]) {
+    let ns;
+    try {
+      ns = mod[nsKey];
+    } catch {
+      ns = void 0;
+    }
+    if (isRecord(ns) && ns !== mod) {
+      for (const key of Object.keys(ns)) {
+        let val;
+        try {
+          val = ns[key];
+        } catch {
+          continue;
+        }
+        push(key, val, `${via}.${nsKey}`);
+      }
+      if (typeof ns === "function" && ns.name)
+        push(ns.name, ns, `${via}.${nsKey}(fn)`);
+    }
+  }
+}
+function subpathCandidates(probe) {
+  const name = probe.pkg.name;
+  const subs = /* @__PURE__ */ new Set([name]);
+  const pj = probe.load(`${name}/package.json`);
+  if (isRecord(pj) && isRecord(pj.exports)) {
+    for (const k of Object.keys(pj.exports)) {
+      if (k === "." || k === "./package.json")
+        continue;
+      if (k.startsWith("./") && !k.includes("*"))
+        subs.add(name + k.slice(1));
+    }
+  }
+  subs.add(`${name}/compat`);
+  return [...subs];
+}
+var markerCounter = 0;
+function freshMarker() {
+  markerCounter += 1;
+  return `__sspp_${process.pid}_${Date.now().toString(36)}_${markerCounter}__`;
+}
+function pollutionSnapshot(marker) {
+  const objHit = {}[marker] !== void 0 || Object.prototype.hasOwnProperty.call(Object.prototype, marker);
+  const arrHit = [][marker] !== void 0 || Object.prototype.hasOwnProperty.call(Array.prototype, marker);
+  return { objHit, arrHit, any: objHit || arrHit };
+}
+function cleanup(marker) {
+  try {
+    delete Object.prototype[marker];
+  } catch {
+  }
+  try {
+    delete Array.prototype[marker];
+  } catch {
+  }
+}
+function buildBattery() {
+  const battery = [];
+  const objStyle = [
+    { tag: "src.__proto__", build: (m) => JSON.parse(`{"__proto__":{"${m}":"polluted"}}`) },
+    { tag: "src.constructor.prototype", build: (m) => JSON.parse(`{"constructor":{"prototype":{"${m}":"polluted"}}}`) },
+    { tag: "src.nested.__proto__", build: (m) => JSON.parse(`{"a":{"b":{"__proto__":{"${m}":"polluted"}}}}`) }
+  ];
+  for (const p of objStyle) {
+    battery.push({ label: `obj:${p.tag}:merge(target,src)`, make: (m) => [{}, p.build(m)] });
+    battery.push({ label: `obj:${p.tag}:fn(src)`, make: (m) => [p.build(m)] });
+    battery.push({ label: `obj:${p.tag}:merge(target,{},src)`, make: (m) => [{}, {}, p.build(m)] });
+  }
+  const paths = [
+    { tag: "path.str.constructor.prototype", p: (m) => `constructor.prototype.${m}` },
+    { tag: "path.arr.constructor.prototype", p: (m) => ["constructor", "prototype", m] },
+    { tag: "path.str.__proto__", p: (m) => `__proto__.${m}` },
+    { tag: "path.arr.__proto__", p: (m) => ["__proto__", m] },
+    { tag: "path.str.prototype", p: (m) => `prototype.${m}` }
+  ];
+  for (const pp of paths) {
+    battery.push({ label: `set:${pp.tag}:set(obj,path,val)`, make: (m) => [{}, pp.p(m), "polluted"] });
+    battery.push({ label: `set:${pp.tag}:update(obj,path,fn)`, make: (m) => [{}, pp.p(m), () => "polluted"] });
+  }
+  return battery;
+}
+var BATTERY = buildBattery();
+function fuzzCandidate(fn2, timeBudgetMs = 4e3) {
+  const started = Date.now();
+  const hits = [];
+  for (const payload of BATTERY) {
+    if (Date.now() - started > timeBudgetMs)
+      break;
+    const marker = freshMarker();
+    cleanup(marker);
+    try {
+      const ret = fn2(...payload.make(marker));
+      if (ret !== null && (typeof ret === "object" || typeof ret === "function") && typeof ret.then === "function") {
+        void ret.then(void 0, () => {
+        });
+      }
+    } catch {
+    }
+    const p = pollutionSnapshot(marker);
+    if (p.any)
+      hits.push({ payload: payload.label, objProto: p.objHit, arrProto: p.arrHit });
+    cleanup(marker);
+  }
+  return hits;
+}
+var ssppFuzzDetector = {
+  id: "sspp-fuzz",
+  title: "Server-Side Prototype Pollution (dynamic fuzz)",
+  cwe: "CWE-1321",
+  category: "prototype-pollution",
+  severityFloor: "high",
+  description: "LLM-proposes / harness-disposes SSPP miner: name-heuristic candidate recursive-write fns, confirmed ONLY on runtime Object/Array.prototype pollution; optional NODE_OPTIONS gadget escalates to RCE.",
+  appliesTo(_pkg) {
+    return true;
+  },
+  identifyCandidates(probe) {
+    const out = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const id of subpathCandidates(probe)) {
+      const mod = probe.load(id);
+      if (mod === void 0) {
+        probe.note?.(`sspp-fuzz: could not load ${id}`);
+        continue;
+      }
+      collectFromModule(mod, id, out, seen);
+    }
+    return out;
+  },
+  confirm(candidate) {
+    const hits = fuzzCandidate(candidate.fn);
+    if (hits.length === 0) {
+      return { confirmed: false, evidence: { observation: "" } };
+    }
+    const first = hits[0];
+    const which = first.objProto ? "Object.prototype" : "Array.prototype";
+    return {
+      confirmed: true,
+      severity: "high",
+      source: candidate.label,
+      evidence: {
+        observation: `${which} polluted at runtime via ${candidate.label} (payload ${first.payload})`,
+        payload: first.payload,
+        analysis: [
+          `Function ${candidate.via} recursively writes attacker-controlled keys without guarding`,
+          `__proto__ / constructor.prototype. ${hits.length} payload(s) fired; a truly empty {} then`,
+          `inherits the planted marker. SSPP/High; escalate to RCE only if a NODE_OPTIONS gadget`,
+          `fires in a spawned Node subprocess (sandbox-gated escalation, assume-FP otherwise).`
+        ].join(" "),
+        escalation: { kind: "NODE_OPTIONS\u2192RCE", achieved: false, note: "gadget not attempted in confirm (sandbox-gated)" }
+      }
+    };
+  },
+  dedupHints: {
+    // 0sec prior filing for this exact class.
+    priorReports: ["es-toolkit"],
+    // Fork-twin the prototype learned the hard way: npm audit gave a false
+    // all-clear because the advisory lives under the maintained fork's name.
+    forkTwins: {
+      radash: "CVE-2025-48054 / GHSA-2xv9-ghh9-xc69 (disclosed in fork `radashi`; no GHSA under `radash` \u2192 live advisory lookup misses it)"
+    }
+  }
+};
+
+// packages/core/dist/stages/npm-detectors/read-unstable.js
+var EVIL = "__0sec_toctou_forbidden__";
+function makePhasedField(clean, evil = EVIL) {
+  let phase = "validate";
+  return {
+    clean,
+    evil,
+    install(target, prop) {
+      Object.defineProperty(target, prop, {
+        enumerable: true,
+        configurable: true,
+        get() {
+          return phase === "validate" ? clean : evil;
+        }
+      });
+    },
+    useNow() {
+      phase = "use";
+    }
+  };
+}
+function confirmReadUnstable(candidate) {
+  const field = makePhasedField(candidate.allowed[0] ?? "allowed-1");
+  let accepted = false;
+  let appValue;
+  try {
+    const res = candidate.probe(field);
+    accepted = res.accepted;
+    field.useNow();
+    appValue = res.readAppValue();
+  } catch {
+    return { confirmed: false, evidence: { observation: "" } };
+  }
+  const bypass = accepted && appValue === field.evil;
+  if (!bypass)
+    return { confirmed: false, evidence: { observation: "" } };
+  return {
+    confirmed: true,
+    severity: "high",
+    source: candidate.label,
+    evidence: {
+      observation: `validator ACCEPTED input yet app-observed ${candidate.field}="${String(appValue)}" (\u2209 allowlist [${candidate.allowed.join(",")}])`,
+      payload: `getter on '${candidate.field}' returns '${field.clean}' at validate-time, '${field.evil}' at use-time`,
+      analysis: [
+        `${candidate.label} validates then returns/keeps the SAME live object, so a getter-backed`,
+        `(or Proxy / mutable-derived) property that changes between the validator's read and the`,
+        `app's read yields an unvalidated value the app trusts. TOCTOU allowlist bypass (CWE-367).`
+      ].join(" ")
+    }
+  };
+}
+var ALLOWED = ["allowed-1", "allowed-2"];
+function fn(mod, key) {
+  const v = mod[key];
+  return typeof v === "function" ? v : void 0;
+}
+var ADAPTERS = [
+  // superstruct: validate(input, Schema) → [err, output]; output === input.
+  {
+    id: "superstruct",
+    matches: (name, mod) => name === "superstruct" || !!fn(mod, "object") && !!fn(mod, "enums") && !!fn(mod, "validate"),
+    candidates(name, mod) {
+      const object = fn(mod, "object");
+      const enums = fn(mod, "enums");
+      const validate = fn(mod, "validate");
+      const assert = fn(mod, "assert");
+      if (!object || !enums || !validate)
+        return [];
+      const Schema = object({ role: enums(ALLOWED) });
+      const out = [
+        {
+          id: `${name}.validate`,
+          label: `${name}.validate`,
+          field: "role",
+          allowed: ALLOWED,
+          probe(field) {
+            const input = {};
+            field.install(input, "role");
+            const res = validate(input, Schema);
+            const err = Array.isArray(res) ? res[0] : void 0;
+            const output = Array.isArray(res) ? res[1] : input;
+            return { accepted: !err, readAppValue: () => (output ?? input)["role"] };
+          }
+        }
+      ];
+      if (assert) {
+        out.push({
+          id: `${name}.assert`,
+          label: `${name}.assert`,
+          field: "role",
+          allowed: ALLOWED,
+          probe(field) {
+            const input = {};
+            field.install(input, "role");
+            let ok = false;
+            try {
+              assert(input, Schema);
+              ok = true;
+            } catch {
+              ok = false;
+            }
+            return { accepted: ok, readAppValue: () => input["role"] };
+          }
+        });
+      }
+      return out;
+    }
+  },
+  // class-validator: validates class INSTANCES; getter accessors are idiomatic.
+  {
+    id: "class-validator",
+    matches: (name, mod) => name === "class-validator" || !!fn(mod, "IsIn") && !!fn(mod, "validateSync"),
+    candidates(name, mod) {
+      const IsIn = fn(mod, "IsIn");
+      const validateSync = fn(mod, "validateSync");
+      if (!IsIn || !validateSync)
+        return [];
+      return [
+        {
+          id: `${name}.validateSync`,
+          label: `${name}.validateSync`,
+          field: "role",
+          allowed: ALLOWED,
+          probe(field) {
+            class UserDto {
+            }
+            const decorate = IsIn(ALLOWED);
+            decorate(UserDto.prototype, "role");
+            const u = new UserDto();
+            field.install(u, "role");
+            const errors = validateSync(u);
+            return { accepted: Array.isArray(errors) && errors.length === 0, readAppValue: () => u["role"] };
+          }
+        }
+      ];
+    }
+  },
+  // joi (control): materialises a fresh value → SAFE. Kept so the detector
+  // proves it does NOT false-positive on read-stable validators.
+  {
+    id: "joi",
+    matches: (name, mod) => name === "joi" || !!fn(mod, "object") && !!fn(mod, "string"),
+    candidates(name, mod) {
+      const object = fn(mod, "object");
+      const string = fn(mod, "string");
+      if (!object || !string)
+        return [];
+      return [
+        {
+          id: `${name}.validate`,
+          label: `${name}.validate`,
+          field: "role",
+          allowed: ALLOWED,
+          probe(field) {
+            const input = {};
+            field.install(input, "role");
+            const schema = object({ role: string().valid(...ALLOWED) });
+            const res = schema.validate(input);
+            return { accepted: !res.error, readAppValue: () => res.value?.["role"] };
+          }
+        }
+      ];
+    }
+  },
+  // zod (control): safeParse materialises → SAFE.
+  {
+    id: "zod",
+    matches: (name, mod) => name === "zod" || !!fn(mod, "z") || !!fn(mod, "object"),
+    candidates(name, mod) {
+      const z = mod["z"] ?? mod;
+      const object = fn(z, "object");
+      const zenum = fn(z, "enum");
+      if (!object || !zenum)
+        return [];
+      return [
+        {
+          id: `${name}.safeParse`,
+          label: `${name}.safeParse`,
+          field: "role",
+          allowed: ALLOWED,
+          probe(field) {
+            const input = {};
+            field.install(input, "role");
+            const schema = object({ role: zenum(ALLOWED) });
+            const res = schema.safeParse(input);
+            return { accepted: res.success, readAppValue: () => res.data?.["role"] };
+          }
+        }
+      ];
+    }
+  }
+];
+var readUnstableDetector = {
+  id: "read-unstable",
+  title: "Validation Read-Stability TOCTOU",
+  cwe: "CWE-367",
+  category: "toctou",
+  severityFloor: "high",
+  description: "Confirms the validate-and-return-live-object read-stability class: a phased getter (allowed at validate-time, forbidden at use-time) that the validator accepts but the app then reads as forbidden. Materialising validators (joi/zod) are the negative controls.",
+  appliesTo(_pkg) {
+    return true;
+  },
+  identifyCandidates(probe) {
+    const mod = probe.load(probe.pkg.name);
+    if (mod === void 0 || typeof mod !== "object" && typeof mod !== "function") {
+      probe.note?.(`read-unstable: could not load ${probe.pkg.name}`);
+      return [];
+    }
+    const modRec = mod;
+    const out = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const adapter of ADAPTERS) {
+      let matched = false;
+      try {
+        matched = adapter.matches(probe.pkg.name, modRec);
+      } catch {
+        matched = false;
+      }
+      if (!matched)
+        continue;
+      try {
+        for (const c of adapter.candidates(probe.pkg.name, modRec)) {
+          const fp = `${adapter.id}:${c.field}:${c.allowed.join(",")}`;
+          if (seen.has(fp)) {
+            probe.note?.(`read-unstable: collapsed duplicate candidate ${c.id} (fingerprint ${fp})`);
+            continue;
+          }
+          seen.add(fp);
+          out.push(c);
+        }
+      } catch (e) {
+        probe.note?.(`read-unstable: adapter ${adapter.id} failed: ${e instanceof Error ? e.message : String(e)}`);
+      }
+    }
+    return out;
+  },
+  confirm(candidate) {
+    return confirmReadUnstable(candidate);
+  },
+  dedupHints: {
+    priorReports: ["class-validator", "superstruct"]
+  }
+};
+
+// packages/core/dist/stages/npm-detectors/parser-diff.js
+function parsePart(s) {
+  if (s === "")
+    return null;
+  let val;
+  let m;
+  if (m = /^0[xX]([0-9a-fA-F]+)$/.exec(s))
+    val = parseInt(m[1], 16);
+  else if (/^0[0-7]*$/.exec(s))
+    val = parseInt(s, 8);
+  else if (/^0[0-7]*[89]/.exec(s))
+    return null;
+  else if (/^[0-9]+$/.exec(s))
+    val = parseInt(s, 10);
+  else
+    return null;
+  if (!Number.isFinite(val) || val < 0)
+    return null;
+  return val;
+}
+function inetAton(input) {
+  if (typeof input !== "string")
+    return { ok: false };
+  const parts = input.split(".");
+  if (parts.length < 1 || parts.length > 4)
+    return { ok: false };
+  const nums = parts.map(parsePart);
+  if (nums.some((n2) => n2 === null))
+    return { ok: false };
+  const n = nums.length;
+  const v = nums;
+  let long;
+  if (n === 1) {
+    if (v[0] > 4294967295)
+      return { ok: false };
+    long = v[0] >>> 0;
+  } else if (n === 2) {
+    if (v[0] > 255 || v[1] > 16777215)
+      return { ok: false };
+    long = (v[0] << 24 | v[1]) >>> 0;
+  } else if (n === 3) {
+    if (v[0] > 255 || v[1] > 255 || v[2] > 65535)
+      return { ok: false };
+    long = (v[0] << 24 | v[1] << 16 | v[2]) >>> 0;
+  } else {
+    if (v.some((x) => x > 255))
+      return { ok: false };
+    long = (v[0] << 24 | v[1] << 16 | v[2] << 8 | v[3]) >>> 0;
+  }
+  const dotted = [long >>> 24, long >>> 16 & 255, long >>> 8 & 255, long & 255].join(".");
+  return { ok: true, long, dotted, cls: classify(long) };
+}
+function classify(long) {
+  const a = long >>> 24;
+  const b = long >>> 16 & 255;
+  if (a === 127)
+    return "loopback";
+  if (a === 10)
+    return "private";
+  if (a === 172 && b >= 16 && b <= 31)
+    return "private";
+  if (a === 192 && b === 168)
+    return "private";
+  if (a === 169 && b === 254)
+    return long === 2852039166 ? "metadata(169.254.169.254)" : "linklocal";
+  if (a === 100 && b >= 64 && b <= 127)
+    return "cgnat";
+  if (a === 0)
+    return "this-network";
+  return "PUBLIC";
+}
+function isUnsafe(cls) {
+  return !!cls && cls !== "PUBLIC";
+}
+var PARSER_DIFF_CORPUS = [
+  // octal / hex / decimal encodings of loopback + metadata
+  "0177.0.0.1",
+  "0177.00.00.01",
+  "0x7f.0.0.1",
+  "0x7f000001",
+  "0x7f.1",
+  "2130706433",
+  "017700000001",
+  "127.1",
+  "127.0.1",
+  // metadata (169.254.169.254) in many encodings
+  "169.254.169.254",
+  "0251.0376.0251.0376",
+  "0xa9.0xfe.0xa9.0xfe",
+  "169.254.43518",
+  "169.16689150",
+  "2852039166",
+  // private
+  "0300.0250.0.01",
+  "010.0.0.1",
+  "192.168.257",
+  // whitespace-wrapped loopback (clients trim, getaddrinfo does not)
+  " 127.0.0.1",
+  "127.0.0.1 ",
+  "0177.0.0.1 "
+];
+function scanDivergences(candidate, corpus = PARSER_DIFF_CORPUS) {
+  const hits = [];
+  for (const input of corpus) {
+    const oracle = inetAton(input);
+    if (!oracle.ok || !isUnsafe(oracle.cls))
+      continue;
+    let verdict;
+    try {
+      verdict = candidate.filterVerdict(input);
+    } catch {
+      continue;
+    }
+    if (verdict.treatedAsSafe) {
+      hits.push({ input, socketTarget: oracle.dotted, cls: oracle.cls, note: verdict.note });
+    }
+  }
+  return hits;
+}
+function confirmParserDiff(candidate) {
+  const hits = scanDivergences(candidate);
+  if (hits.length === 0)
+    return { confirmed: false, evidence: { observation: "" } };
+  const h = hits[0];
+  return {
+    confirmed: true,
+    severity: "high",
+    source: candidate.label,
+    evidence: {
+      observation: `oracle resolves ${JSON.stringify(h.input)} to ${h.socketTarget} [${h.cls}] but ${candidate.label} treats it as safe (${h.note})`,
+      payload: h.input,
+      analysis: [
+        `${candidate.label} disagrees with glibc getaddrinfo (inet_aton) semantics on ${hits.length}`,
+        `input(s). A real socket connect() targets the internal address while the filter classifies`,
+        `it public \u2192 SSRF allowlist bypass (CWE-918). Sample: ${hits.slice(0, 3).map((x) => `${x.input}\u2192${x.socketTarget}`).join(", ")}.`
+      ].join(" ")
+    }
+  };
+}
+function safe(f) {
+  try {
+    return f();
+  } catch {
+    return void 0;
+  }
+}
+function fnOf(mod, key) {
+  const v = mod[key];
+  return typeof v === "function" ? v : void 0;
+}
+var ADAPTERS2 = [
+  // `ip`: isPrivate / isPublic / isLoopback booleans.
+  {
+    id: "ip",
+    matches: (name, mod) => name === "ip" || !!fnOf(mod, "isPrivate") && !!fnOf(mod, "isPublic"),
+    candidate(name, mod) {
+      const isPublic = fnOf(mod, "isPublic");
+      const isPrivate = fnOf(mod, "isPrivate");
+      const isLoopback = fnOf(mod, "isLoopback");
+      if (!isPublic && !isPrivate)
+        return void 0;
+      return {
+        id: `${name}.isPublic`,
+        label: `${name}.isPublic`,
+        field: "",
+        filterVerdict(input) {
+          const pub = safe(() => isPublic?.(input));
+          if (pub === true)
+            return { treatedAsSafe: true, note: "ip.isPublic=true" };
+          const priv = safe(() => isPrivate?.(input));
+          const lo = safe(() => isLoopback?.(input));
+          if (priv === false && lo === false)
+            return { treatedAsSafe: true, note: "ip.isPrivate=false&isLoopback=false" };
+          return { treatedAsSafe: false, note: "blocked" };
+        }
+      };
+    }
+  },
+  // `ipaddr.js`: isValid + parse().range(); invalid ⇒ filter skips ⇒ bypass.
+  {
+    id: "ipaddr.js",
+    matches: (name, mod) => name === "ipaddr.js" || !!fnOf(mod, "isValid") && !!fnOf(mod, "parse"),
+    candidate(name, mod) {
+      const isValid = fnOf(mod, "isValid");
+      const parse = fnOf(mod, "parse");
+      if (!isValid || !parse)
+        return void 0;
+      const SAFE_RANGES = /loopback|private|linkLocal|carrierGradeNat|unspecified/;
+      return {
+        id: `${name}.range`,
+        label: `${name}.range`,
+        field: "",
+        filterVerdict(input) {
+          const valid = safe(() => isValid(input));
+          if (valid !== true)
+            return { treatedAsSafe: true, note: "ipaddr.isValid=false(filter-skips)" };
+          const range = safe(() => {
+            const p = parse(input);
+            return p.range ? p.range() : void 0;
+          });
+          if (typeof range === "string" && !SAFE_RANGES.test(range)) {
+            return { treatedAsSafe: true, note: `ipaddr.range=${range}(unsafe-as-safe)` };
+          }
+          return { treatedAsSafe: false, note: "blocked" };
+        }
+      };
+    }
+  },
+  // NB: an `is-ip`-style recognizer (`isIP(host) → boolean`) is deliberately NOT
+  // an adapter. `isIP("0177.0.0.1") === false` is CORRECT library behaviour —
+  // that string is not a canonical IP — and a bare `false` says nothing about a
+  // downstream connect()/resolve() ever happening. The old adapter ASSERTED
+  // "not-recognized ⇒ passed to DNS ⇒ SSRF", which fired on is-ip itself and on
+  // every package that re-exports `isIP` (e.g. class-validator) with no observed
+  // consequence — an assume-FP violation. A recognizer that never NORMALISES or
+  // RE-EMITS a different address cannot produce an observable parser divergence,
+  // so it has no confirm here. Only filters that make a connect/resolve decision
+  // (`ip`, `ipaddr.js`) or re-emit a different base (`cidr-tools`) get adapters.
+  //
+  // `cidr-tools`: normalizeCidr mis-normalization — the confirmed win. If the
+  // filter normalises the input to a base whose oracle class is public while the
+  // input's true target is internal, the allowlist is bypassed.
+  {
+    id: "cidr-tools",
+    matches: (name, mod) => name === "cidr-tools" || !!fnOf(mod, "normalizeCidr"),
+    candidate(name, mod) {
+      const normalizeCidr = fnOf(mod, "normalizeCidr");
+      if (!normalizeCidr)
+        return void 0;
+      return {
+        id: `${name}.normalizeCidr`,
+        label: `${name}.normalizeCidr`,
+        field: "",
+        filterVerdict(input) {
+          const norm = safe(() => normalizeCidr(input));
+          const normStr = Array.isArray(norm) ? String(norm[0] ?? "") : String(norm ?? "");
+          if (!normStr)
+            return { treatedAsSafe: true, note: "normalizeCidr=\u2205(filter-skips)" };
+          const base = normStr.split("/")[0].trim();
+          const baseOracle = inetAton(base);
+          if (baseOracle.ok && !isUnsafe(baseOracle.cls)) {
+            return { treatedAsSafe: true, note: `normalizeCidr\u2192${normStr}(base ${baseOracle.cls})` };
+          }
+          return { treatedAsSafe: false, note: "blocked" };
+        }
+      };
+    }
+  }
+];
+var parserDiffDetector = {
+  id: "parser-diff",
+  title: "SSRF Filter Parser Confusion (differential)",
+  cwe: "CWE-918",
+  category: "ssrf",
+  severityFloor: "high",
+  description: "Differential IP/host parser confusion: compares a package SSRF filter against a glibc inet_aton oracle; confirmed when the oracle resolves an input to an internal target the filter treats as public.",
+  appliesTo(_pkg) {
+    return true;
+  },
+  identifyCandidates(probe) {
+    const mod = probe.load(probe.pkg.name);
+    if (mod === void 0 || typeof mod !== "object" && typeof mod !== "function") {
+      probe.note?.(`parser-diff: could not load ${probe.pkg.name}`);
+      return [];
+    }
+    const modRec = mod;
+    const out = [];
+    for (const adapter of ADAPTERS2) {
+      let matched = false;
+      try {
+        matched = adapter.matches(probe.pkg.name, modRec);
+      } catch {
+        matched = false;
+      }
+      if (!matched)
+        continue;
+      const c = safe(() => adapter.candidate(probe.pkg.name, modRec));
+      if (c)
+        out.push(c);
+    }
+    return out;
+  },
+  confirm(candidate) {
+    return confirmParserDiff(candidate);
+  },
+  dedupHints: {
+    // parser-diff's OWN founding seed: `cidr-tools`
+    // `normalizeCidr("0177.0.0.1") → "177.0.0.1"` drops the leading-zero octal
+    // and re-emits a PUBLIC-looking base while glibc resolves the input to
+    // 127.0.0.1 (loopback) — the exact mis-normalization the prototype was
+    // ported from. OSV carries no named advisory for it, so a live lookup
+    // returns "novel" and the flywheel would otherwise re-surface its own seed
+    // as a fresh find. Route it as prior/known.
+    priorReports: ["cidr-tools"]
+  }
+};
+
+// packages/core/dist/stages/npm-detectors/registry.js
+function asAny(d) {
+  return d;
+}
+var DETECTOR_REGISTRY = Object.freeze([
+  asAny(ssppFuzzDetector),
+  asAny(readUnstableDetector),
+  asAny(parserDiffDetector)
+]);
+var DETECTOR_REGISTRY_BY_ID = Object.freeze(DETECTOR_REGISTRY.reduce((acc, d) => {
+  if (acc[d.id])
+    throw new Error(`Duplicate detector id "${d.id}" in DETECTOR_REGISTRY`);
+  acc[d.id] = d;
+  return acc;
+}, {}));
+function listDetectorIds() {
+  return DETECTOR_REGISTRY.map((d) => d.id);
+}
+function getDetectorById(id) {
+  return DETECTOR_REGISTRY_BY_ID[id];
+}
+function resolveDetectors(ids) {
+  if (!ids || ids.length === 0)
+    return { detectors: [...DETECTOR_REGISTRY], unknown: [] };
+  const detectors = [];
+  const unknown = [];
+  for (const id of ids) {
+    const d = getDetectorById(id);
+    if (d)
+      detectors.push(d);
+    else
+      unknown.push(id);
+  }
+  return { detectors, unknown };
+}
+
+export {
+  dedupConfirmation,
+  guardPackage,
+  runDetectorOnPackage,
+  nameMatchesPpSink,
+  pollutionSnapshot,
+  fuzzCandidate,
+  ssppFuzzDetector,
+  makePhasedField,
+  confirmReadUnstable,
+  readUnstableDetector,
+  inetAton,
+  classify,
+  isUnsafe,
+  PARSER_DIFF_CORPUS,
+  scanDivergences,
+  confirmParserDiff,
+  parserDiffDetector,
+  DETECTOR_REGISTRY,
+  DETECTOR_REGISTRY_BY_ID,
+  listDetectorIds,
+  getDetectorById,
+  resolveDetectors
+};