progmune-runtime 3.7.35 → 3.7.36

package/CHANGELOG.md

@@ -1,5 +1,53 @@
 # Changelog
 
+## [3.7.36] — 2026-09-19
+
+### C4：污点经路径塑形表达式包装后仍传播
+
+缺口实证（taintpath_A，measured）：`readBasename` / `readResolveOnly` /
+`readJoinWrapped` / `readNormalizeWrapped` 四条语义上应标记、实测不标记——
+传播只认 `x = <污点>` 直赋，而 `path.join/resolve/normalize/basename` 是真实
+工程构造路径的**默认写法**，这条断链等于把最常见形态整片漏掉。
+
+政策是**白名单传播**，不是「RHS 含污点就传播」：
+- 只经 path.* 家族与保值的字符串方法（trim/replace/…）传播；拼接与模板字面量
+  同样只塑形、不改来源；有界迭代 3 跳（`normalize → join` 这类链式能接上）
+- **认不出的调用不传播** ⇒ `const safe = sanitizeName(p)` 天然不污染。
+  未知函数默认站在精度一侧——这是白名单相对黑名单的决定性优势
+- 代价（记为缺口 C4b）：项目自有 helper（如 `buildPath(p)`）仍不传播
+
+### 两处必须一并改的「假通过」（C4 把它们顶出来了）
+
+C4 之前，下列用例的「不标记」**不是因为判别力对，而是污点根本没走到 sink**
+——方法学规则 R7 的第二种形态。C4 一放开它们就会翻成误报：
+
+1. **G-A2 漏 `startsWith(base)`**：原正则要求标识符在 base/root/dir 之外还有
+   前导字符，最朴素的 `target.startsWith(base)` 匹配不上。改为取出整个实参再
+   判定，并加 `database` 等反例名单（`database` 以 base 结尾但与目录无关）
+2. **G-A2 漏字符串字面量形态**：`startsWith("/srv/data")` 同样匹配不上。
+   现支持绝对路径字面量（长度 >1，排除 `startsWith("/")`——那只是判绝对路径）
+
+### 闸门改为实时提取（第二处空过）
+
+`check-taintpath.ts` 原默认读 `reports/batch-scan-results.json`——那是别人跑
+batch-scan 留下的**陈旧产物**。实测踩到：C4 落地后 4 条 known-gap 已翻正，
+闸门仍报「未标记，符合预期」。已改为默认对 `generated/taintpath_*` 实时跑
+extractIR（需走报告时显式 `--report`）。
+
+### 验收
+
+- taintpath 闸门 **24/24，失败 0、缺口闭合待更新 0**；4 条 known-gap 转 mark
+- fr-007 openhop 真实语料维持 **pre 5 / post 0** —— C4 只补召回，未削弱 G1 判别力
+- `extract-ir-taint-structural.test.ts` 新增 C4 组 11 条（7 正 + 4 负对照，R6）
+- 反向验证：回退 v3.7.35 后 **7 条正例全失败**，4 条负对照仍绿
+- 全组回归 72 passed；`tsc -p tsconfig.json` 零错误
+
+### 实现期踩的一个坑（已入注释）
+
+`taintedViaShaper` 最初写了 `if (tainted.size === 0) return`——而这 4 条
+known-gap 的共同形态恰恰是「全函数没有任何直赋污点」，等于整条 C4 不生效。
+种子是根模式（taintPattern 恒定并入 UNTRUSTED_ROOT_SRC），不该依赖已有污点。
+
 ## [3.7.35] — 2026-09-19
 
 ### 重建盲测覆盖：taintpath 语料族（TS 795 空过的终结）

package/dist/extract-ir-taint-structural.test.js

@@ -287,3 +287,159 @@ export function seedFlow() {
         }, 150000);
     }
 });
+// ═══════════════════════════════════════════════════════════════
+// C4（2026-09-19）：污点经「路径塑形表达式」包装后仍应传播
+//
+// 缺口实证：taintpath_A 的 readBasename / readResolveOnly / readJoinWrapped /
+// readNormalizeWrapped 四条，语义上应标记、实测不标记 —— 传播只认 `x = <污点>`
+// 直赋，而 `path.join/resolve/normalize/basename` 是真实工程构造路径的**默认
+// 写法**，这条断链等于把最常见的形态整片漏掉。
+//
+// 政策是**白名单传播**：只经 path.* 家族与保值的字符串方法传播，认不出的调用
+// 不传播。于是 `const safe = sanitizeName(p)` 天然不污染 —— 未知函数默认站在
+// 精度一侧。代价是项目自有 helper（buildPath(p)）仍不传播（缺口 C4b）。
+// ═══════════════════════════════════════════════════════════════
+(0, vitest_1.describe)("C4：污点经路径塑形表达式包装后仍传播", () => {
+    const cases = [
+        {
+            name: "path.join 包装",
+            fn: "readJoin",
+            code: `export function readJoin(req: any) {
+  const target = path.join("/data", req.params.name);
+  return fs.readFileSync(target, "utf-8");
+}`,
+            expectMark: true,
+            why: "最基础的塑形包装：join(root, taint) 不得断链",
+        },
+        {
+            name: "path.normalize 包装",
+            fn: "readNormalize",
+            code: `export function readNormalize(req: any) {
+  const target = path.normalize(req.params.name);
+  return fs.readFileSync(target, "utf-8");
+}`,
+            expectMark: true,
+            why: "normalize 只规范化、不改变来源",
+        },
+        {
+            name: "path.basename 包装（N-A）",
+            fn: "readBasename",
+            code: `export function readBasename(req: any) {
+  const name = path.basename(req.params.name);
+  return fs.readFileSync("/data/" + name, "utf-8");
+}`,
+            expectMark: true,
+            why: "N-A：basename 不算守卫（fr-012 pre 实测反例），包装后污点仍须流动",
+        },
+        {
+            name: "resolve 无包含性比较（N-C）",
+            fn: "readResolveOnly",
+            code: `export function readResolveOnly(req: any) {
+  const base = path.resolve("/data");
+  const target = path.resolve(base, req.params.name);
+  return fs.readFileSync(target, "utf-8");
+}`,
+            expectMark: true,
+            why: "N-C：只有 resolve、没有 startsWith(base) 比较，不算守卫",
+        },
+        {
+            name: "链式两跳塑形",
+            fn: "readChained",
+            code: `export function readChained(req: any) {
+  const norm = path.normalize(req.params.dir);
+  const target = path.join(norm, "index.html");
+  return fs.readFileSync(target, "utf-8");
+}`,
+            expectMark: true,
+            why: "fr-012 下载侧就是这个形状：normalize → join 两跳，须接上",
+        },
+        {
+            name: "模板字面量拼接",
+            fn: "readTemplate",
+            code: `export function readTemplate(req: any) {
+  const target = \`/data/\${req.params.name}\`;
+  return fs.readFileSync(target, "utf-8");
+}`,
+            expectMark: true,
+            why: "模板字面量只塑形、不改来源",
+        },
+        {
+            name: "字符串方法 trim（须先经 C4 才能到这一步）",
+            fn: "readTrim",
+            // 注意形态：不能写成 `const n = req.params.name.trim()` —— 那样根就在
+            // 开头、旧版也能标记，用例就失去判别力了（反向验证时实测通过，白锁一场）。
+            // 必须先经一次塑形调用，trim 才是 C4 链条上的第二跳。
+            code: `export function readTrim(req: any) {
+  const normalized = path.normalize(req.params.name);
+  const trimmed = normalized.trim();
+  return fs.readFileSync("/data/" + trimmed, "utf-8");
+}`,
+            expectMark: true,
+            why: "保值的字符串方法不得断链；本条同时验证 C4 的迭代（normalize → trim 两跳）",
+        },
+        // ── 负向：每一条都有同形状的正对照（方法学规则 R6）──
+        {
+            name: "负对照：守卫仍在（startsWith(base) 形态）",
+            fn: "readGuardWithinBase",
+            code: `export function readGuardWithinBase(req: any) {
+  const base = path.resolve("/data");
+  const target = path.resolve(base, req.params.name);
+  if (!target.startsWith(base)) throw new Error("outside");
+  return fs.readFileSync(target, "utf-8");
+}`,
+            expectMark: false,
+            why: "正对照 = readResolveOnly（同形状去掉 startsWith 必须重新报出）",
+        },
+        {
+            name: "负对照：常量路径不因塑形而标记",
+            fn: "readConstantJoin",
+            code: `export function readConstantJoin() {
+  const target = path.join("/data", "index.html");
+  return fs.readFileSync(target, "utf-8");
+}`,
+            expectMark: false,
+            why: "正对照 = readJoin（把 \"index.html\" 换成 req.params.name 必须报出）",
+        },
+        {
+            name: "负对照：未知 helper 不传播（白名单的精度代价，缺口 C4b）",
+            fn: "readUnknownHelper",
+            code: `function buildPath(name: string): string {
+  return "/data/" + name;
+}
+export function readUnknownHelper(req: any) {
+  const target = buildPath(req.params.name);
+  return fs.readFileSync(target, "utf-8");
+}`,
+            expectMark: false,
+            why: "白名单外一律不传播（精度优先）；正对照 = readJoin 必须报出",
+        },
+        {
+            name: "负对照：净化函数不传播",
+            fn: "readSanitized",
+            code: `function sanitizeName(name: string): string {
+  return name.replace(/[^a-z0-9]/gi, "");
+}
+export function readSanitized(req: any) {
+  const safe = sanitizeName(req.params.name);
+  return fs.readFileSync("/data/" + safe, "utf-8");
+}`,
+            expectMark: false,
+            why: "未知（疑似净化）调用默认不传播——这是白名单相对黑名单的决定性优势",
+        },
+    ];
+    for (const c of cases) {
+        (0, vitest_1.it)(`${c.name} —— ${c.why}`, () => {
+            const dir = makeProject({ "a.ts": `import * as fs from "fs";\nimport * as path from "path";\n\n${c.code}\n` });
+            try {
+                const marks = marksFor(dir, c.fn);
+                if (c.expectMark)
+                    (0, vitest_1.expect)(marks).toContain(PATH_MARK);
+                else
+                    (0, vitest_1.expect)(marks).not.toContain(PATH_MARK);
+            }
+            finally {
+                fs.rmSync(dir, { recursive: true, force: true });
+            }
+        }, 150000);
+    }
+});

package/dist/extract-ir.js

@@ -378,6 +378,21 @@ function extractDirectCalls(func, preText) {
 // 与 protocol-detector 的同名规则（source-level benchmark 路径）。
 // ═══════════════════════════════════════════════════════════════
 const PATH_TRAVERSAL_MARKER = "__progmune_path_traversal__";
+/**
+ * 标识符是否「看起来像基目录」—— G-A2 的定案依据。
+ *
+ * 判定：以 base / root / dir 结尾（大小写与 camel、下划线均可），
+ * 前缀任意（`base` / `baseDir` / `allowedRoot` / `root_dir` 都算）。
+ *
+ * 反例名单是实证加的：`database` 以 base 结尾但与目录无关，若不排除，
+ * 一旦有人写 `p.startsWith(database)` 就会被当成守卫 —— 那是精度漏洞。
+ */
+const BASE_DIR_IDENT_DENY = /^(?:database|databases|codebase|knowledgebase|base64|basename|dirname|basenames)$/i;
+function isBaseDirIdent(id) {
+    if (BASE_DIR_IDENT_DENY.test(id))
+        return false;
+    return /^(?:[A-Za-z_$][\w$]*)?(?:base|root|dir)$/i.test(id);
+}
 const PATH_GUARD_RULES = [
     {
         id: "G-A",
@@ -388,9 +403,35 @@ const PATH_GUARD_RULES = [
     },
     {
         id: "G-A2",
-        re: /\.\s*startsWith\s*\(\s*[A-Za-z_$][\w$]*(?:[Bb]ase|[Rr]oot|[Dd]ir|Dir|Root|Base)[\w$]*\s*\)/,
-        why: "目录包含性校验（基目录名形态）：startsWith(baseDir/rootDir/...)",
-        source: "设计形态，canonical",
+        // 粗筛：任意 `.startsWith(<ident>)`；定案交给 decide —— 实参名是否像基目录。
+        re: /\.\s*startsWith\s*\(\s*([^)]*?)\s*\)/,
+        // 2026-09-19 两次修订，都是被 C4「顶出来」的真问题（C4 之前相关用例
+        // 的「不标记」是空过——污点根本没走到 sink，见方法学规则 R7）：
+        //  ① 原正则 `[A-Za-z_$][\w$]*(?:[Bb]ase|…)` 要求标识符在 base/root/dir
+        //     **之外**还至少有一个前导字符，于是最朴素的 `startsWith(base)`
+        //     （taintpath_A readGuardWithin）匹配不上；
+        //  ② `startsWith("/srv/data")` —— 基目录写成**字符串字面量**——同样匹配
+        //     不上（C5 负对照 readInlineGuarded 就是这形态）。
+        // 故改为：先取出 startsWith 的整个实参，再判定它是「基目录名」还是
+        // 「绝对路径字面量」。
+        decide: (text) => {
+            const re = /\.\s*startsWith\s*\(\s*([^)]*?)\s*\)/g;
+            let m;
+            while ((m = re.exec(text)) !== null) {
+                const arg = m[1] || "";
+                // 形参里的标识符：`base` / `base + path.sep` / `rootDir + "/"`
+                const idm = /([A-Za-z_$][\w$]*)/.exec(arg);
+                if (idm && isBaseDirIdent(idm[1]))
+                    return true;
+                // 绝对路径字面量：`"/srv/data"`。长度 >1 是为了排除 `startsWith("/")`
+                // —— 那只是「是否绝对路径」，不构成包含性。
+                if (/["'`]\/[^"'`]+["'`]/.test(arg))
+                    return true;
+            }
+            return false;
+        },
+        why: "目录包含性校验（基目录名或绝对路径字面量）：startsWith(base / baseDir / \"/srv/data\" / base + sep）",
+        source: "设计形态，canonical；2026-09-19 补 `base` 单标识符（taintpath_A readGuardWithin）与绝对路径字面量（C5 负对照 readInlineGuarded）",
     },
     {
         id: "G-B1",
@@ -456,7 +497,7 @@ function callsPathGuardFn(text) {
 /** 返回命中的守卫规则 id；无校验证据返回 null。 */
 function hasPathGuardEvidence(text) {
     for (const r of PATH_GUARD_RULES) {
-        if (r.re.test(text))
+        if (r.decide ? r.decide(text) : r.re.test(text))
             return r.id;
     }
     if (callsPathGuardFn(text))
@@ -569,7 +610,29 @@ function hasRequestRootedExpr(text) {
 function tsSinkCallRegex() {
     return new RegExp(`(?:^|[^\\w.$])(?:await\\s+)?(?:[\\w$]+\\.)?(${TS_FILE_SINK_NAMES.join("|")})\\s*\\(([\\s\\S]{0,250}?)\\)`, "g");
 }
-/** 函数体内被不可信根污染的局部名（含解构与单跳赋值，深度 ≤2） */
+/**
+ * C4（2026-09-19）：污点经「路径塑形表达式」包装后仍然传播。
+ *
+ * 缺口实证（taintpath_A，2026-09-19 measured）：
+ *   `const target = path.join(ROOT, req.params.name); fs.readFileSync(target)`
+ * 不标记 —— 因为传播只认 `x = <污点>` 直赋，`path.join(...)` 把流掐断了。
+ * 真实工程里 `join/resolve/normalize/basename` 是路径构造的**默认写法**，
+ * 这条断链等于把最常见的形态整片漏掉。
+ *
+ * 政策：**白名单传播**，不是「RHS 含污点就传播」。
+ *   - 只经【路径塑形】的调用传播（path.* 家族 + 保值的字符串方法）；
+ *   - 字符串拼接与模板字面量同样只塑形、不改来源，故一并传播；
+ *   - 认不出的调用**不传播** —— 于是 `const safe = sanitizeName(p)` 天然
+ *     不污染。这是白名单相对黑名单的决定性优势：未知函数默认站在精度一侧。
+ *   代价：项目自有 helper（如 `buildPath(p)`）仍不传播，记为 C4b 缺口。
+ *
+ * 已知限制：只扫单行赋值（`const x = …;` 一行写完）。跨行书写的调用
+ * 链不传播——保持简单，等 C4b 一并处理。
+ */
+const TS_PATH_SHAPER_RE = /(?:path\s*\.\s*(?:posix|win32)\s*\.\s*|path\s*\.\s*)?\b(?:join|resolve|normalize|basename|dirname|extname|relative|format|toNamespacedPath)\s*\(|\.\s*(?:trim|trimStart|trimEnd|replace|replaceAll|toLowerCase|toUpperCase|toString|slice|substring|substr|padStart|padEnd|concat|normalize)\s*\(/;
+/** 拼接形态：`+` 或反引号（模板字面量）—— 同样只是塑形 */
+const TS_CONCAT_RE = /\+|`/;
+/** 函数体内被不可信根污染的局部名（含解构、单跳赋值与 C4 塑形传播，深度 ≤3） */
 function collectTaintedNames(text) {
     const tainted = new Set();
     let m;
@@ -588,6 +651,7 @@ function collectTaintedNames(text) {
     const bareAssign = new RegExp(`(?:^|[^\\w$.])([\\w$]+)\\s*=\\s*(?:await\\s+)?(?:${root})`, "g");
     while ((m = bareAssign.exec(text)) !== null)
         tainted.add(m[1]);
+    taintedViaShaper(text, tainted);
     // 单跳传播（深度 ≤2）
     for (let depth = 0; depth < 2; depth++) {
         if (tainted.size === 0)
@@ -606,6 +670,41 @@ function collectTaintedNames(text) {
     }
     return tainted;
 }
+/**
+ * C4：把「经路径塑形表达式包装」的赋值名补进污点集合（有界迭代 ≤3 轮）。
+ *
+ * 按行扫描 `[(const|let|var)] NAME = RHS`：RHS 含污点证据 且
+ * （含塑形调用 或 含拼接/模板）⇒ NAME 污染。迭代是为了让
+ * `normalized = path.normalize(p)` → `savePath = path.join(normalized, f)`
+ * 这类链式构造能接上（fr-012 下载侧守卫块就是这个形状）。
+ */
+function taintedViaShaper(text, tainted) {
+    for (let depth = 0; depth < 3; depth++) {
+        // 注意：这里**不能**以 `tainted.size === 0` 提前退出 —— 种子是根模式
+        // （taintPattern 恒定并入 UNTRUSTED_ROOT_SRC）。本轮这 4 条 known-gap
+        // 的共同形态恰恰是「全函数没有任何直赋污点，根只出现在塑形调用里」，
+        // 加这道闸门等于整条 C4 不生效（2026-09-19 实测踩到）。
+        const taintRe = taintPattern(tainted);
+        if (!taintRe)
+            return;
+        let added = false;
+        for (const line of text.split("\n")) {
+            const m = /^\s*(?:const|let|var)?\s*([\w$]+)\s*=\s*(?:await\s+)?(.+)$/.exec(line);
+            if (!m)
+                continue;
+            const name = m[1];
+            const rhs = m[2];
+            if (tainted.has(name))
+                continue;
+            if (taintRe.test(rhs) && (TS_PATH_SHAPER_RE.test(rhs) || TS_CONCAT_RE.test(rhs))) {
+                tainted.add(name);
+                added = true;
+            }
+        }
+        if (!added)
+            return;
+    }
+}
 function taintPattern(tainted) {
     const parts = [UNTRUSTED_ROOT_SRC];
     if (tainted.size > 0) {

package/dist/sdk.js

@@ -20,7 +20,7 @@ const risk_model_1 = require("./risk-model");
 const protocol_knowledge_1 = require("./protocol-knowledge");
 const evidence_repository_1 = require("./evidence-repository");
 /** Runtime version — stable public identifier. Internal layers evolve underneath. */
-exports.RUNTIME_VERSION = "3.7.35";
+exports.RUNTIME_VERSION = "3.7.36";
 function verify(filePath) {
     const cert = (0, certify_1.certify)(filePath);
     const kb = (0, protocol_knowledge_1.buildKnowledgeBase)();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "progmune-runtime",
-  "version": "3.7.35",
+  "version": "3.7.36",
   "description": "Progmune — AI Trust Decision Engine. Verify AI-generated code before it reaches production. Outputs APPROVED / NEEDS_REVIEW / BLOCKED with evidence.",
   "files": [
     "dist/",