@clear-capabilities/agentic-security-scanner 0.127.0 → 0.130.0

package/dist/178.index.js

@@ -13,7 +13,7 @@ export const modules = {
 /* harmony import */ var node_child_process__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1421);
 /* harmony import */ var node_fs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(3024);
 /* harmony import */ var node_path__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(6760);
-/* harmony import */ var _engine_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(3793);
+/* harmony import */ var _engine_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(4660);
 // Time-travel + counterfactual scanning (v0.68).
 //
 // Two new modes that exploit the pure-input shape of runFullScan:

package/dist/207.index.js

@@ -0,0 +1,217 @@
+export const id = 207;
+export const ids = [207];
+export const modules = {
+
+/***/ 9207:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   computeRunAttestation: () => (/* binding */ computeRunAttestation)
+/* harmony export */ });
+/* unused harmony exports ATTESTATION_CANONICALISATION, verifyRunAttestation */
+/* harmony import */ var node_crypto__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(7598);
+/* harmony import */ var _integrity_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(1130);
+// R4 — determinism as a contract.
+//
+// Determinism has been an implementation property of this engine (stable sorts,
+// no Date.now() in ids, `--deterministic`) with no way for a third party to
+// VERIFY it. This module turns it into something checkable: a stable digest
+// over the finding set, bound to the engine version, ruleset version, and
+// bundle hash that produced it.
+//
+// WHAT THE DIGEST IS INDEPENDENT OF (by construction):
+//   - the ORDER findings were emitted in (entries are canonicalised, then sorted)
+//   - run ids, timestamps, durations, and every other field not on the
+//     identity allowlist below — canonicalisation is an ALLOWLIST, not a
+//     denylist, so a new non-deterministic field cannot silently leak in
+//   - path separator style, and the absolute prefix when `root` is supplied
+//
+// WHAT IT IS NOT INDEPENDENT OF (all of these are real differences):
+//   - a changed severity, file, line, rule id, cwe, or vuln title
+//   - a finding appearing or disappearing (including a duplicate — multiplicity
+//     is preserved; two identical findings are not collapsed into one)
+//   - the engine version, ruleset version, or bundle sha
+//
+// WHAT THIS PROVES, AND WHAT IT DOES NOT (read before quoting it at anyone):
+//   PROVES — two finding sets carrying the same digest under the same
+//   canonicalisation are the same set of findings, modulo emission order and
+//   the excluded volatile fields; and (when signed) that the attestation was
+//   produced on an install holding this HMAC key.
+//   DOES NOT PROVE — cross-machine reproducibility. Nothing here demonstrates
+//   that a different host, OS, Node version, or toolchain produces the same
+//   finding set; several detectors are environment-sensitive (e.g. the Python
+//   AST path is used when python3 is available and falls back to regex when it
+//   is not, which can change what is found). Two runs on two machines agreeing
+//   would be evidence FOR reproducibility, but that experiment has not been
+//   run here and this module does not assert its outcome. The signature is a
+//   symmetric per-install HMAC, so it is tamper-evidence for the operator, not
+//   third-party non-repudiation.
+//
+// Identity fields deliberately EXCLUDE `parser` and `family`: `parser` records
+// which analysis engine fired, which is environment-sensitive (see the python3
+// case above), so including it would make the digest report an environment
+// difference as a findings difference. The finding's identity — where it is
+// and what it is — is fully captured without it.
+//
+// SIGNING: reuses `integrity.js`'s per-install HMAC key handling verbatim
+// (`signLastScan`, keyed from $AGENTIC_SECURITY_HMAC_KEY or the 0600 key file
+// at $XDG_CONFIG_HOME/agentic-security/scan-key). No second key mechanism is
+// introduced. `integrity.verifyLastScan` is NOT reused because it verifies a
+// body against a sibling `.sig` FILE; an attestation carries its signature
+// inline, so verification re-signs and compares in constant time here.
+//
+// NO THROWING (posture/CLAUDE.md convention): malformed input yields an empty
+// canonical set or an `{ok:false, reason}` refusal, never an exception.
+
+
+
+
+const ATTESTATION_CANONICALISATION = 'agentic-security/run-attestation-canon-v1';
+
+const PROVES =
+  'Two finding sets with this digest, under this canonicalisation, are the same findings ' +
+  '(same rule id, severity, file, line, cwe, vuln, and multiplicity) produced by the same ' +
+  'engine version, ruleset version, and bundle — regardless of emission order.';
+const DOES_NOT_PROVE =
+  'It does not prove cross-machine reproducibility: no run on a second machine, OS, or Node ' +
+  'version is compared here, and some detectors are environment-sensitive. A signature, when ' +
+  'present, is a symmetric per-install HMAC — tamper-evidence for this install, not ' +
+  'third-party non-repudiation.';
+
+function _str(v) { return v === undefined || v === null ? '' : String(v); }
+
+// Normalise a file path: separators to '/', drop a supplied absolute root,
+// drop a leading './'. Everything else is left alone — guessing at a root we
+// were not given would make two genuinely different files collide.
+function _normPath(file, root) {
+  let p = _str(file).replace(/\\/g, '/');
+  if (root) {
+    let r = String(root).replace(/\\/g, '/').replace(/\/+$/, '');
+    if (r && p.startsWith(r + '/')) p = p.slice(r.length + 1);
+    else if (r && p === r) p = '';
+  }
+  return p.replace(/^\.\//, '');
+}
+
+/**
+ * The canonical, order-independent representation of a finding set: one
+ * tab-joined record per finding over the identity allowlist, sorted.
+ * Multiplicity is preserved (duplicates are NOT deduped).
+ */
+function canonicaliseFindings(findings, { root } = {}) {
+  const list = Array.isArray(findings) ? findings : [];
+  const rows = [];
+  for (const f of list) {
+    if (!f || typeof f !== 'object') continue;
+    rows.push([
+      _str(f.id),
+      _str(f.severity),
+      _normPath(f.file, root),
+      _str(f.line),
+      _str(f.cwe),
+      _str(f.vuln),
+    ].join('\t'));
+  }
+  return rows.sort();
+}
+
+/**
+ * Compute the run attestation.
+ *
+ * @param {object[]} findings     the finding set (any order)
+ * @param {string}   engineVersion
+ * @param {string}   rulesetVersion
+ * @param {string}   bundleSha
+ * @param {string}  [root]        scan root, used to relativise absolute paths
+ * @param {boolean} [sign]        attach a per-install HMAC over the digest
+ */
+function computeRunAttestation({
+  findings, engineVersion, rulesetVersion, bundleSha, root, sign = false,
+} = {}) {
+  const entries = canonicaliseFindings(findings, { root });
+  const payload = JSON.stringify({
+    canonicalisation: ATTESTATION_CANONICALISATION,
+    engineVersion: _str(engineVersion),
+    rulesetVersion: _str(rulesetVersion),
+    bundleSha: _str(bundleSha),
+    findingCount: entries.length,
+    entries,
+  });
+  const digest = node_crypto__WEBPACK_IMPORTED_MODULE_0__.createHash('sha256').update(payload).digest('hex');
+  const att = {
+    digest,
+    algorithm: 'sha256',
+    findingCount: entries.length,
+    engineVersion: _str(engineVersion),
+    rulesetVersion: _str(rulesetVersion),
+    bundleSha: _str(bundleSha),
+    canonicalisation: ATTESTATION_CANONICALISATION,
+    proves: PROVES,
+    doesNotProve: DOES_NOT_PROVE,
+  };
+  if (sign) {
+    try {
+      att.signature = (0,_integrity_js__WEBPACK_IMPORTED_MODULE_1__/* .signLastScan */ .lU)(digest);
+      att.signatureScope = 'per-install-hmac';
+    } catch { /* signing is best-effort; an unsigned attestation is still valid */ }
+  }
+  return att;
+}
+
+/**
+ * Re-derive the attestation from a finding set and compare.
+ * @returns {{ok: boolean, reason: string}}
+ */
+function verifyRunAttestation(attestation, inputs = {}) {
+  if (!attestation || typeof attestation !== 'object') {
+    return { ok: false, reason: 'no attestation supplied' };
+  }
+  if (attestation.canonicalisation !== ATTESTATION_CANONICALISATION) {
+    return {
+      ok: false,
+      reason: `unknown canonicalisation "${_str(attestation.canonicalisation)}" — ` +
+              `this build verifies "${ATTESTATION_CANONICALISATION}" only`,
+    };
+  }
+  if (typeof attestation.digest !== 'string' || !/^[0-9a-f]{64}$/.test(attestation.digest)) {
+    return { ok: false, reason: 'attestation carries no sha256 digest' };
+  }
+  for (const k of ['engineVersion', 'rulesetVersion', 'bundleSha']) {
+    if (_str(inputs[k]) !== _str(attestation[k])) {
+      return { ok: false, reason: `${k} mismatch: attested "${_str(attestation[k])}", got "${_str(inputs[k])}"` };
+    }
+  }
+  const recomputed = computeRunAttestation({
+    findings: inputs.findings,
+    engineVersion: inputs.engineVersion,
+    rulesetVersion: inputs.rulesetVersion,
+    bundleSha: inputs.bundleSha,
+    root: inputs.root,
+  });
+  if (recomputed.findingCount !== attestation.findingCount) {
+    return {
+      ok: false,
+      reason: `finding count mismatch: attested ${attestation.findingCount}, got ${recomputed.findingCount}`,
+    };
+  }
+  if (recomputed.digest !== attestation.digest) {
+    return { ok: false, reason: 'digest mismatch — the finding set is not the one attested' };
+  }
+  if (attestation.signature) {
+    let expected;
+    try { expected = signLastScan(attestation.digest); }
+    catch { return { ok: false, reason: 'signature present but no key material available to check it' }; }
+    const a = Buffer.from(String(attestation.signature), 'hex');
+    const b = Buffer.from(expected, 'hex');
+    if (a.length !== b.length || !crypto.timingSafeEqual(a, b)) {
+      return { ok: false, reason: 'signature does not verify under this install key' };
+    }
+    return { ok: true, reason: 'digest and per-install signature verify' };
+  }
+  return { ok: true, reason: 'digest verifies (unsigned attestation)' };
+}
+
+
+/***/ })
+
+};

package/dist/384.index.js

@@ -8,7 +8,7 @@ export const modules = {
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   scanCredentials: () => (/* reexport safe */ _engine_js__WEBPACK_IMPORTED_MODULE_0__.Sv)
 /* harmony export */ });
-/* harmony import */ var _engine_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3793);
+/* harmony import */ var _engine_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(4660);
 // Secrets submodule view of the engine — credential + entropy + TODO scanning.
 
 

package/dist/415.index.js

@@ -2,7 +2,7 @@ export const id = 415;
 export const ids = [415];
 export const modules = {
 
-/***/ 5796:
+/***/ 3415:
 /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
 
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {

package/dist/435.index.js

@@ -472,12 +472,12 @@ const cve_lookup_internals = { CACHE_DIR, CVE_RE, _stalenessTier };
 // the import only runs when a tool that needs them is actually called.
 let _runScan;
 async function getRunScan() {
-  if (!_runScan) _runScan = (await Promise.resolve(/* import() */).then(__webpack_require__.bind(__webpack_require__, 9099))).runScan;
+  if (!_runScan) _runScan = (await Promise.resolve(/* import() */).then(__webpack_require__.bind(__webpack_require__, 454))).runScan;
   return _runScan;
 }
 let _verifyFixCore;
 async function getVerifyFixCore() {
-  if (!_verifyFixCore) _verifyFixCore = (await __webpack_require__.e(/* import() */ 838).then(__webpack_require__.bind(__webpack_require__, 7838))).verifyFix;
+  if (!_verifyFixCore) _verifyFixCore = (await __webpack_require__.e(/* import() */ 526).then(__webpack_require__.bind(__webpack_require__, 3526))).verifyFix;
   return _verifyFixCore;
 }
 
@@ -993,12 +993,23 @@ const apply_fix = {
       // Inline re-verify — the load-bearing gate. Must pass to write.
       let verdict;
       try {
-        const verifyFixCore = await getVerifyFixCore();
-        verdict = await verifyFixCore({
-          scanRoot: ctx.sessionRoot,
-          originalFindingStableId: f.stableId,
-          files: Object.fromEntries(Object.entries(confinedAbs).map(([rel, v]) => [rel, v.content])),
-        });
+        const _files = Object.fromEntries(Object.entries(confinedAbs).map(([rel, v]) => [rel, v.content]));
+        if (process.env.AGENTIC_SECURITY_FIX_RUN_TESTS === '1') {
+          // Addition #7 — connect the closed-loop verifier: add the project test
+          // suite as a fourth verification leg (scan + lint + tests). Opt-in
+          // because many repos have no runner and we must not fail-closed by
+          // default. Normalized to the scan+lint verdict shape used below.
+          const { verifyFixWithTests } = await __webpack_require__.e(/* import() */ 113).then(__webpack_require__.bind(__webpack_require__, 4113));
+          const t = await verifyFixWithTests({ scanRoot: ctx.sessionRoot, originalFindingStableId: f.stableId, files: _files });
+          verdict = { ok: t.ok, summary: t.summary, rescan: t.legs?.scan?.detail, lint: t.legs?.lint?.detail, tests: t.legs?.tests, testVerdict: t.verdict };
+        } else {
+          const verifyFixCore = await getVerifyFixCore();
+          verdict = await verifyFixCore({
+            scanRoot: ctx.sessionRoot,
+            originalFindingStableId: f.stableId,
+            files: _files,
+          });
+        }
       } catch (e) {
         return { _meta: META, applied: false, reason: `patch verification failed: ${e.message}` };
       }