progmune-runtime 3.7.41 → 3.7.42

package/CHANGELOG.md

@@ -1,5 +1,65 @@
 # Changelog
 
+## [3.7.42] — 2026-09-20
+
+### C4f：名字级传播的精度收窄（形参-实参位置对齐 + 返回值依赖分析）
+
+前三轮（C4c/C4d/C4e）都在补召回，这一轮反过来**收精度**。
+
+传播此前是**名字级**的：赋值右侧出现污点名、且右侧看起来像塑形 ⇒ 新变量判为
+污染。它不看「这个 helper 的返回值到底依不依赖那个实参」：
+
+```ts
+const dropParam = (n: string): string => "fixed.md";   // 形参被丢掉
+const rel = dropParam(k);                                // k 流不出来，仍被判污染
+```
+
+现在给每个纯塑形 helper 多算一份 `deps` = **返回值真正依赖的形参集**，调用点按
+形参-实参位置对齐后才认证据：`dropParam(k)` ⇒ 无证据；`pickFirst("safe", k)`
+（只依赖第一个形参）⇒ 只留 `"safe"`。
+
+| 形态 | 收窄前 | 语义 |
+|---|---|---|
+| `dropParam(k)`（return 常量） | 误标 → 不标 | 依赖集为空 |
+| `pickFirst("safe", k)` | 误标 → 不标 | 位置不对齐 |
+| `path.join("out", dropParam(k))` | 误标 → 不标 | 该按支路算，不该整行一锅端 |
+| `wrapDrop(k)`（= dropParam(n)） | 误标 → 不标 | 依赖集跨函数传递后为空 |
+| `wrapPick("safe", k)` | 误标 → 不标 | 跨函数位置不对齐 |
+| `swapPick(k, "safe")`（= pickFirst(y, x)） | 误标 → 不标 | 换序后真正被依赖的是 y |
+
+换序那条最能说明价值：`swapPick("safe", k)` 该标、`swapPick(k, "safe")` 不该标 ——
+只看「实参里有没有污点名」两条都标，只看「形参有没有被用到」两条也都标，
+必须按位置穿过一次换序才分得开。
+
+`shaped`（右侧像不像塑形）仍看原式：helper 是不是塑形，与它的返回值依不依赖
+实参是两件事，不能互相替代。依赖分析有次序依赖（helper 若在它依赖的 helper 之前
+被接受，那一刻 deps 会偏宽），名录定稿后按完整的 info 再算两轮消掉 —— 偏宽是
+保守侧（继续传播），不会造成漏报。
+
+### 验收
+
+| 门 | 结果 |
+|---|---|
+| taintpath 闸门 | **81/81**（新增 G 族 12 条：4 mark / 7 no-taint / 1 suppressed） |
+| fr-007 真实语料 | pre 5 / post 0 **维持** |
+| fr-016 真实语料 | pre 7 / post 0 **维持** —— 收窄没有丢正例 |
+| 定向用例 | **164 passed / 7 个测试文件**（新增 C4f 组 11 条：4 正 7 负；taint-guard、structural、ssrf-loop、project-ir、C/Go/Java 提取组全绿） |
+| TS 盲测 | 107 项目，path_traversal **LOST 0 / ADDED 20**（G 4 + E 9 + F 6 + D 1），基线那 104 个项目**零漂移零丢失** |
+| tsc | 零错误 |
+
+### 门的方向也反过来了（R14 的一次镜像使用）
+
+前四轮 R7 咬的都是「语料零覆盖 ⇒ 门空过」。收窄轮最该防的是另外两件事：
+收窄过头把真阳性收掉（看 LOST）；以及那批 no-taint 用例其实空转（它们本来就不该
+标，旧代码也不会让它们红）。反向验证切了三刀：
+
+- **刀 A**：调用点退回「不按依赖抹实参」（等价收窄前）⇒ G 族 6 条 no-taint 全部
+  转红 —— 证明这批对照真的咬得住；
+- **刀 B**：只关掉跨函数传递（deps 只算直接依赖）⇒ 只有两跳相关的 3 条转红，
+  直接依赖那 3 条不动 —— 归因清晰；
+- **刀 C**：把收窄做得更激进（一律抹空）⇒ 3 条位置对齐正例转漏报，而
+  `emitPlainShaper`（常规塑形）不受影响 —— 正说明收窄没波及常规路径。
+
 ## [3.7.41] — 2026-09-20
 
 ### C4e：helper 的现代写法（箭头 / 函数表达式 / 模块常量）

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

@@ -1314,3 +1314,69 @@ const WRITE_LAYER = [
         }, 150000);
     }
 });
+(0, vitest_1.describe)("C4f：只有落在「返回值真依赖的形参位」上的污点才算流过去", () => {
+    // 与 C4e 同源的隔离写法：sink 实参里不出现污点变量 k，污点只能经 helper 返回值进来。
+    const emit = (relExpr) => [
+        'import * as fs from "fs";',
+        'import { dropParam, pickFirst, withExt, wrapDrop, wrapPick, swapPick } from "./helpers";',
+        "export function emit(doc: Record<string, any>, outDir: string) {",
+        "  Object.keys(doc).forEach((k) => {",
+        `    const rel = ${relExpr};`,
+        '    fs.writeFileSync(outDir + "/" + rel, "x");',
+        "  });",
+        "}",
+    ].join("\n");
+    const HELPERS = [
+        '// 依赖集为空：丢弃形参，返回常量',
+        'export const dropParam = (n: string): string => "fixed.md";',
+        '// 只依赖第一个形参',
+        'export const pickFirst = (a: string, b: string): string => a + ".md";',
+        '// 常规塑形（正对照）',
+        'export const withExt = (name: string): string => name + ".md";',
+        '// 两跳丢弃',
+        'export const wrapDrop = (n: string): string => dropParam(n);',
+        '// 两跳对齐',
+        'export const wrapPick = (a: string, b: string): string => pickFirst(a, b);',
+        '// 换序两跳：真正被依赖的是第二个形参',
+        'export const swapPick = (x: string, y: string): string => pickFirst(y, x);',
+    ].join("\n");
+    const cases = [
+        { name: "正例·常规塑形", fn: "emit", files: { "helpers.ts": HELPERS, "it.ts": emit("withExt(k)") },
+            expectMark: true, why: "收精度不得收过头 —— 这条必须照标" },
+        { name: "正例·污点在被依赖的形参位", fn: "emit", files: { "helpers.ts": HELPERS, "it.ts": emit('pickFirst(k, "safe")') },
+            expectMark: true, why: "第一个形参真的影响返回值" },
+        { name: "正例·两跳仍在被依赖的位置", fn: "emit", files: { "helpers.ts": HELPERS, "it.ts": emit('wrapPick(k, "safe")') },
+            expectMark: true, why: "依赖集要能跨函数传递" },
+        { name: "正例·换序两跳", fn: "emit", files: { "helpers.ts": HELPERS, "it.ts": emit('swapPick("safe", k)') },
+            expectMark: true, why: "swapPick 真正依赖的是 y（第二个形参），位置对齐要跟着换" },
+        { name: "负对照·helper 丢弃形参", fn: "emit", files: { "helpers.ts": HELPERS, "it.ts": emit("dropParam(k)") },
+            expectMark: false, why: "return 常量 —— 实参带污点也流不出来；这是收窄前的真实误报" },
+        { name: "负对照·污点在不被依赖的形参位", fn: "emit", files: { "helpers.ts": HELPERS, "it.ts": emit('pickFirst("safe", k)') },
+            expectMark: false, why: "第二个形参进了函数也出不来；正对照 = 正例·污点在被依赖的形参位" },
+        { name: "负对照·嵌套在 concat 里", fn: "emit", files: { "helpers.ts": HELPERS, "it.ts": emit('path.join("out", dropParam(k))') },
+            expectMark: false, why: "整条 rhs 含 k，但那条支路不流出 —— 证据必须按支路算，不能整行一锅端" },
+        { name: "负对照·两跳后依赖集为空", fn: "emit", files: { "helpers.ts": HELPERS, "it.ts": emit("wrapDrop(k)") },
+            expectMark: false, why: "wrapDrop(n) = dropParam(n)，依赖集同样为空（跨函数对齐）" },
+        { name: "负对照·两跳位置不对齐", fn: "emit", files: { "helpers.ts": HELPERS, "it.ts": emit('wrapPick("safe", k)') },
+            expectMark: false, why: "正对照 = 正例·两跳仍在被依赖的位置" },
+        { name: "负对照·换序的反向", fn: "emit", files: { "helpers.ts": HELPERS, "it.ts": emit('swapPick(k, "safe")') },
+            expectMark: false, why: "k 落在不被依赖的 x 位；正对照 = 正例·换序两跳" },
+        { name: "负对照·实参本身无污点", fn: "emit", files: { "helpers.ts": HELPERS, "it.ts": emit('dropParam("lit")') },
+            expectMark: false, why: "无污点流入" },
+    ];
+    for (const c of cases) {
+        (0, vitest_1.it)(`${c.name} —— ${c.why}`, () => {
+            const dir = makeProject(c.files);
+            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

@@ -772,6 +772,117 @@ function pathModuleAliases(project) {
     }
     return out;
 }
+/** 按顶层逗号切分实参串（跳过字符串与已配平的括号，后者由调用方保证不含嵌套） */
+function splitTopLevelArgs(argText) {
+    const out = [];
+    let depth = 0;
+    let quote = "";
+    let cur = "";
+    for (let i = 0; i < argText.length; i++) {
+        const ch = argText[i];
+        if (quote) {
+            cur += ch;
+            if (ch === quote && argText[i - 1] !== "\\")
+                quote = "";
+            continue;
+        }
+        if (ch === '"' || ch === "'" || ch === "`") {
+            quote = ch;
+            cur += ch;
+            continue;
+        }
+        if (ch === "(" || ch === "[" || ch === "{")
+            depth++;
+        else if (ch === ")" || ch === "]" || ch === "}")
+            depth--;
+        if (ch === "," && depth === 0) {
+            out.push(cur);
+            cur = "";
+            continue;
+        }
+        cur += ch;
+    }
+    if (cur.trim() !== "" || out.length > 0)
+        out.push(cur);
+    return out;
+}
+/**
+ * C4f：把 helper 调用里【返回值不依赖的那些实参】抹掉。
+ *
+ * 名字级传播的老问题是：`discard(k) { return "fixed.md"; }` 明明把形参丢了，
+ * 只要 `k` 出现在赋值右侧就会被当成污点证据 ⇒ 误标。返回值既然不依赖那个形参，
+ * 那条支路就没有数据流。按形参-实参位置对齐后：
+ *
+ *   discard(k)          ⇒ `""`          （不依赖任何形参）
+ *   pick("safe", k)     ⇒ `("safe")`    （只依赖第一个形参）
+ *
+ * 只处理实参里不再嵌套括号的调用（最内层优先），有界 3 轮向外。
+ * 抹掉的是**证据**，`shaped` 判定仍看原式 —— helper 是不是塑形，与它的返回值
+ * 依不依赖实参是两件事。
+ */
+function maskNonDependentArgs(text, info) {
+    if (info.size === 0)
+        return text;
+    let cur = text;
+    for (let round = 0; round < 3; round++) {
+        const next = maskNonDependentArgsOnce(cur, info);
+        if (next === null)
+            break;
+        cur = next;
+    }
+    return cur;
+}
+/** 抹掉**一个**最内层调用；没有任何调用需要抹时返回 null（供调用方收敛） */
+function maskNonDependentArgsOnce(text, info) {
+    for (const [name, si] of info) {
+        const re = new RegExp(`(?:^|[^\\w$.])${escapeRe(name)}\\s*\\(`, "g");
+        let m;
+        while ((m = re.exec(text)) !== null) {
+            const nameStart = m.index + (m[0].startsWith(name) ? 0 : 1);
+            const open = m.index + m[0].length - 1; // 开括号位置
+            let depth = 0;
+            let close = -1;
+            for (let i = open; i < text.length; i++) {
+                if (text[i] === "(")
+                    depth++;
+                else if (text[i] === ")") {
+                    depth--;
+                    if (depth === 0) {
+                        close = i;
+                        break;
+                    }
+                }
+            }
+            if (close < 0)
+                continue;
+            const argText = text.slice(open + 1, close);
+            if (/[([{]/.test(argText))
+                continue; // 还嵌着别的调用 —— 下一轮再处理
+            const args = splitTopLevelArgs(argText);
+            const kept = args.filter((_, i) => si.params[i] !== undefined && si.deps.has(si.params[i]));
+            if (kept.length === args.length)
+                continue; // 每个形参都被依赖 ⇒ 无需抹
+            const replacement = kept.length > 0 ? `(${kept.join(" + ")})` : `""`;
+            return text.slice(0, nameStart) + replacement + text.slice(close + 1);
+        }
+    }
+    return null;
+}
+/**
+ * return 表达式真正依赖哪些形参：把「已知 helper 调用里不被依赖的实参」抹掉后，
+ * 剩下的形参名就是会流进返回值的那些。`wrap(n) { return discard(n); }` ⇒ 空集。
+ */
+function returnDeps(exprs, params, info) {
+    const deps = new Set();
+    for (const raw of exprs) {
+        const masked = maskNonDependentArgs(raw, info);
+        for (const p of params) {
+            if (new RegExp(`(?:^|[^\\w$.])${escapeRe(p)}(?:[^\\w$]|$)`).test(masked))
+                deps.add(p);
+        }
+    }
+    return deps;
+}
 /** return 表达式列表：块体取 return 语句，箭头简洁体把整个体当作返回值 */
 function returnExprsOf(body) {
     if (!ts_morph_1.Node.isBlock(body))
@@ -784,13 +895,14 @@ function returnExprsOf(body) {
     }
     return rets;
 }
-/** 扫描全项目，收集「纯塑形」helper 的名字（有界两轮不动点） */
+/** 扫描全项目，收集「纯塑形」helper 的名字 + 返回值依赖（有界两轮不动点） */
 function pureShaperFunctionNames(project) {
     const sinkRe = tsSinkCallRegex();
     const cands = [];
     /** 登记一个候选：三条判据 —— 有形参 / 有返回值 / 体内无 sink */
     const consider = (name, paramNodes, declText, bodyNode) => {
-        const params = new Set(paramNodes.filter(Boolean));
+        const paramList = paramNodes.filter(Boolean);
+        const params = new Set(paramList);
         if (params.size === 0)
             return;
         sinkRe.lastIndex = 0;
@@ -801,7 +913,9 @@ function pureShaperFunctionNames(project) {
         const rets = returnExprsOf(bodyNode);
         if (rets.length === 0)
             return; // ①
-        cands.push({ name, params, rets });
+        if (cands.some((c) => c.name === name))
+            return; // 同名重复登记：先到先得
+        cands.push({ name, params, paramList, rets });
     };
     for (const sf of project.getSourceFiles()) {
         // (a) 函数声明
@@ -836,22 +950,43 @@ function pureShaperFunctionNames(project) {
     const extraIdents = moduleLiteralConstNames(project);
     for (const a of pathModuleAliases(project))
         extraIdents.add(a);
-    const shapers = new Set();
+    const names = new Set();
+    const info = new Map();
     for (let round = 0; round < 2; round++) {
         let added = false;
         for (const c of cands) {
-            if (shapers.has(c.name))
+            if (names.has(c.name))
                 continue;
-            const ok = c.rets.every((e) => isPureShaperExpr(e, c.params, shapers, extraIdents));
+            const ok = c.rets.every((e) => isPureShaperExpr(e, c.params, names, extraIdents));
             if (!ok)
                 continue;
-            shapers.add(c.name);
+            names.add(c.name);
+            info.set(c.name, { params: c.paramList, deps: returnDeps(c.rets, c.paramList, info) });
             added = true;
         }
         if (!added)
             break;
     }
-    return shapers;
+    // C4f：依赖分析有次序依赖 —— `wrap(n) { return discard(n); }` 若在 discard 之前
+    // 被接受，那一刻 info 里还没有 discard ⇒ deps 偏宽（偏宽 = 继续传播 = 保守侧，
+    // 不会误报，但收不紧）。名录定稿后按完整的 info 再算两轮，把次序依赖消掉。
+    const byName = new Map(cands.map((c) => [c.name, c]));
+    for (let round = 0; round < 2; round++) {
+        let changed = false;
+        for (const [name, si] of info) {
+            const c = byName.get(name);
+            if (!c)
+                continue;
+            const d = returnDeps(c.rets, si.params, info);
+            if (d.size !== si.deps.size || [...d].some((x) => !si.deps.has(x))) {
+                si.deps = d;
+                changed = true;
+            }
+        }
+        if (!changed)
+            break;
+    }
+    return { names, info };
 }
 const TS_FILE_SINK_NAMES = [
     "readFile", "readFileSync", "writeFile", "writeFileSync",
@@ -1075,9 +1210,11 @@ function collectTaintedNames(text, shapers) {
 function taintedViaShaper(text, tainted, shapers) {
     // C4b：项目自有「纯塑形」helper 的调用也算子（如 getFileNamePath(dir, name, ext)）。
     // 见 pureShaperFunctionNames —— 只认三条判据全部成立的函数，认不出就不传播。
-    const localShaperRe = shapers && shapers.size > 0
-        ? new RegExp(`(?:^|[^\\w$.])(?:${[...shapers].map(escapeRe).join("|")})\\s*\\(`)
+    const localShaperRe = shapers && shapers.names.size > 0
+        ? new RegExp(`(?:^|[^\\w$.])(?:${[...shapers.names].map(escapeRe).join("|")})\\s*\\(`)
         : null;
+    // C4f：helper 调用里【返回值不依赖的实参】不构成污点证据。
+    const shaperInfo = shapers?.info;
     let grewAny = false;
     for (let depth = 0; depth < 3; depth++) {
         // 注意：这里**不能**以 `tainted.size === 0` 提前退出 —— 种子是根模式
@@ -1099,7 +1236,11 @@ function taintedViaShaper(text, tainted, shapers) {
             const shaped = TS_PATH_SHAPER_RE.test(rhs) ||
                 TS_CONCAT_RE.test(rhs) ||
                 (localShaperRe !== null && localShaperRe.test(rhs));
-            if (taintRe.test(rhs) && shaped) {
+            // 证据看的是【抹掉不被依赖的实参之后】的 rhs：`discard(k)` 里 k 不流出，
+            // 那条支路就不该算证据。`shaped` 仍看原式 —— helper 是不是塑形，与它的
+            // 返回值依不依赖实参是两件事。
+            const evidence = shaperInfo ? maskNonDependentArgs(rhs, shaperInfo) : rhs;
+            if (taintRe.test(evidence) && shaped) {
                 tainted.add(name);
                 added = true;
             }

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.41";
+exports.RUNTIME_VERSION = "3.7.42";
 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.41",
+  "version": "3.7.42",
   "description": "Progmune — AI Trust Decision Engine. Verify AI-generated code before it reaches production. Outputs APPROVED / NEEDS_REVIEW / BLOCKED with evidence.",
   "files": [
     "dist/",