progmune-runtime 3.7.32 → 3.7.36

package/CHANGELOG.md

@@ -1,5 +1,148 @@
 # 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 空过的终结）
+
+TS 795 盲测对「路径穿越标记」**连续三次零覆盖**——语料里没有任何
+`不可信根 → 文件 sink` 的流，`__progmune_path_traversal__` 出现次数前 0 后 0。
+于是「3086 flags LOST 0 / ADDED 0」这道硬门在这项能力上一直是空过（3.7.32/33/34
+三次验收都把它当作证据）。
+
+- 新增语料族 `generated/taintpath_A`（HTTP 请求面）与 `taintpath_B`
+  （MCP 工具实参面 + 跨文件/跨函数传播），共 24 条期望
+- 新增生成器 `blind-benchmark/generate-projects-taintpath.ts`
+  （**只写自己前缀**，不像 generate-projects.ts 那样清理含 `_` 的目录）
+- 新增闸门 `blind-benchmark/check-taintpath.ts` + 期望表
+  `blind-benchmark/taintpath-expectations.json`：逐函数断言
+  mark / suppressed / no-taint / known-gap 四类，退出码非 0 即失败
+- 覆盖力：`__progmune_path_traversal__` **0 → 15 次**；24/24 符合期望
+- 已有 100 个项目零漂移：LOST 0 / ADDED 0（总数 3086 → 3109，增量全部来自新语料）
+- 升级为方法学规则 **R7-no-vacuous-gate**
+
+### C5：不可信根可以直连 sink（召回）
+
+此前外层要求 `collectTaintedNames` 非空，因此
+`fs.readFileSync("/data/" + req.params.name)` —— 真实 Express 工程最常见的形态
+——不标记，只有先赋给局部变量才标记。SSRF 侧从来不要求中间变量，这是同一条
+数据流上的又一处口径不一致，与 G1 同类。改为：先看 sink 实参窗口有没有污点证据（taint 模式本来就含不可信根），
+跨函数传播仍须有具名污点。
+
+- `src/extract-ir-taint-structural.test.ts` 新增 6 条（4 正 + 2 负对照）
+- 反向验证：回退 v3.7.34 后其中 4 条失败、2 条负对照仍绿
+- fr-007 真实语料维持 pre 5 / post **0**（C5 只补召回，未削弱 G1 判别力）
+
+### 本次暴露、尚未修的两处缺口（已进语料，作为下一轮的验收对象）
+
+- **C4**：污点经表达式包装（`path.join/resolve/normalize/basename`）后不传播。
+  语料里 readBasename / readResolveOnly / readJoinWrapped / readNormalizeWrapped
+  四条语义上应标记、实测不标记，记为 known-gap（闸门会盯着，一旦补上就提醒更新）
+- **G2**（反向）：自定义校验函数名不含路径语义后缀时调用点不被抑制。语料里
+  `dispatchToolGuarded` 调了 `assertTemplateName()`（函数体内有字符集白名单），
+  仍被标记——因为 `Name` 后缀在修 ensureDir 误判时被移出了守卫词表
+
+## [3.7.34] — 2026-09-19
+
+### G1 PATH_GUARD_EVIDENCE —— 路径穿越的「校验识别」
+
+路径穿越标记此前是 `taint → 文件 sink ⇒ 标记`，**不看中间有没有校验**；SSRF 侧
+不是这样（`taint → fetch sink 且无 SSRF_GUARD_EVIDENCE ⇒ 标记`）。两侧数据流同构、
+判别力差一档——这正是根集合不敢放宽的真正原因（fr-012/fr-015 的 MISS 由此从
+「词表缺口」升级为「机制缺口」）。本版把路径侧改成与 SSRF 对齐：
+**`taint → 文件 sink 且无校验证据 ⇒ 标记`**。
+
+守卫形态的种子全部来自语料真实修复，逐条可追溯：
+
+- **G-A 目录包含性**：`resolve(p).startsWith(resolve(root))`、`x.startsWith(baseDir)`
+- **G-B 上跳/绝对路径拒绝**：`path.isAbsolute`、`startsWith(".."+sep)`、`=== ".."`
+  （种子 = fr-012 gitlab-mcp 下载侧 `localPath` 既有守卫块，index.ts:7968-7977）
+- **G-C 独立校验函数**：`assertValidFlowId`（fr-007 openhop）/ `assertWithinDir`（fr-016 Redocly）
+  —— 含向调用方**有界传播 3 跳**：校验被抽进被调用函数时，调用方一个校验词汇都没有
+- **G-D 锚定字符集白名单**：`/^[A-Za-z0-9_-]+$/`（fr-007 `FLOW_ID_PATTERN`）
+
+明确**不算**守卫：`path.basename`（fr-012 pre 实测反例，漏洞态就有它）、
+单独出现的 `join`/`resolve`、长度检查、`if (!p) throw`。
+
+**验收**
+
+- fr-007 openhop 真实语料：**pre 5 条 / post 0 条** —— 真实语料上首次出现
+  「修复后流消失」的判别力证据（G1 之前是 5 / 5）
+- `src/extract-ir-taint-guard.test.ts` 14 passed；反向验证回退 3.7.33 后 5 条失败
+- TS 795 盲测 3086 flags LOST 0 / ADDED 0 —— ⚠️ **空过**：盲测语料里
+  `__progmune_path_traversal__` 出现 0 次，无覆盖；真正的门是 fr-007 与定向用例
+- `tsc -p tsconfig.json` 零错误
+
+**实现期修掉的两个反例**（都写进代码注释与方法学规则）：
+
+1. `ensureDir()` / `isDirectory()` 曾被 G-C 误判为守卫（后缀 `Dir`），导致 fr-007
+   pre 侧 5 条被压成 0、召回归零。已移除 `Dir`/`Name` 后缀并加显式反例名单
+2. 「不得标记」类断言会**假通过**：污点经 `path.join(x)` 包装后不再传播，
+   sink 处根本没污点。已定为方法学规则 **R6**：负向断言必须配同形状正对照
+
+## [3.7.33] — 2026-09-19
+
+### 污点标记管线三处结构性修复（C1/C2/C3，正确性修复，不改变判别逻辑）
+
+从「污点源数据流试点 V1」拆出的**独立正确性条目**——它们只解决「看得见」，
+不解决「看得懂」（判别力是 `PATH_GUARD_EVIDENCE`，另一个条目，尚未实现）。
+
+- **C3 污点根按传输面声明**（`UNTRUSTED_ROOTS`）：此前整条链路只锚 Express 形态的 `req|request.(params|query|body|headers|cookies)`，即**根集合只有一种来源**。MCP 工具实参（`params.arguments`）、CLI 参数等来源天然不可见（fr-012 的 `args.file_path`）。改为按传输面声明根，每条附 `why`，不再靠补变量名清单打地鼠
+- **C1 sink 形参表纳入顶层函数**：`methodSinkParamMap` 此前只遍历 `sf.getClasses()`，真实 TS 工程大量使用顶层函数声明（MCP handler / Nuxt runtime binding），跨函数一跳对它们完全不生效——fr-012 的 `markdownUpload` 正因如此从未入表
+- **C2 跨函数传播识别裸调用**：调用匹配此前要求 `obj.sink(`（成员调用），新增 `directCallRe` 覆盖 `func(` 形态
+- **验收**：
+  - TS 795 盲测 **3086 flags LOST 0 / ADDED 0**
+  - ⚠️ **但这是空过（vacuous pass）**：实测整份 generated 语料重跑后 per-function calls 差异 **0**、`__progmune` 标记 **826 vs 826**——盲测语料根本走不到这三个分支。真正的门是新增的定向用例
+  - 新增 `src/extract-ir-taint-structural.test.ts` **6 green**；**反向验证**：把 `src/extract-ir.ts` 回退到 3.7.32 后其中 **3 项失败**（MCP 根 / 顶层函数 / 裸调用），确认这三个用例真的锁住了行为，而非同义反复。另 3 项（Express 旧语义仍标记、常量路径不标记、常量裸调用不标记）在修复前后均通过——它们锁的是「不得回归 / 不得过度标记」
+- **行为边界**：本条目**不**改变判别逻辑。路径穿越侧仍无「校验识别」，因此放宽根集合后对已校验流同样会标记——这正是试点 V1 记录为未过验收的原因，由后续 `PATH_GUARD_EVIDENCE` 解决
+
 ## [3.7.32] — 2026-09-19
 
 ### IR 陈旧性判定（两次会话级误判的根因修复）

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

@@ -0,0 +1,372 @@
+"use strict";
+/**
+ * G1 PATH_GUARD_EVIDENCE —— 路径穿越「校验识别」的定向回归（2026-09-19）。
+ *
+ * 立项背景：路径穿越标记此前是 `taint → file sink ⇒ 标记`，**不看中间有没有
+ * 校验**；SSRF 侧不是这样（无 SSRF_GUARD_EVIDENCE 才标记）。两侧数据流同构、
+ * 判别力差一档——这正是根集合不敢放宽的真正原因（fr-012/fr-015 的 MISS 由此
+ * 从「词表缺口」升级为「机制缺口」）。
+ *
+ * G1 把路径侧改成与 SSRF 对齐：`taint → file sink 且无校验证据 ⇒ 标记`。
+ *
+ * 本文件的每条正例/反例都锚定到**语料里真实存在的一段代码**，不是凭空造的词表：
+ *   - fr-007 openhop  `assertValidFlowId(id)`（fix 才出现，G-C）
+ *   - fr-012 gitlab-mcp  下载侧 localPath 守卫块（pre/post 同一段，G-B）
+ *   - fr-016 Redocly  `assertWithinDir(openapiDir, pathFile, pathName)`（G-C）
+ *   - fr-012 pre 实测反例：`path.basename` 在漏洞态就在（N-A）
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const extract_ir_1 = require("./extract-ir");
+const TSCONFIG = JSON.stringify({
+    compilerOptions: {
+        target: "ES2020",
+        module: "commonjs",
+        moduleResolution: "node",
+        strict: false,
+        skipLibCheck: true,
+        noEmit: true,
+    },
+    include: ["**/*.ts"],
+});
+function makeProject(files) {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pm-taint-guard-"));
+    fs.writeFileSync(path.join(dir, "tsconfig.json"), TSCONFIG);
+    fs.writeFileSync(path.join(dir, "package.json"), JSON.stringify({ name: "fixture", version: "0.0.0", private: true }));
+    for (const [rel, body] of Object.entries(files)) {
+        const abs = path.join(dir, rel);
+        fs.mkdirSync(path.dirname(abs), { recursive: true });
+        fs.writeFileSync(abs, body);
+    }
+    return dir;
+}
+function marksFor(dir, fnName) {
+    const fns = (0, extract_ir_1.extractIR)(dir);
+    const f = fns.find((x) => x.name === fnName);
+    return f ? (f.calls ?? []) : [];
+}
+const PATH_MARK = "__progmune_path_traversal__";
+(0, vitest_1.describe)("G1 基线：无校验证据时必须照旧标记（不得因加判别力而失召回）", () => {
+    (0, vitest_1.it)("taint → 文件 sink，全程无校验 → 标记", () => {
+        const dir = makeProject({
+            "a.ts": `
+import * as fs from "fs";
+export function read(req: any) {
+  const name = req.params.name;
+  return fs.readFileSync("/data/" + name, "utf-8");
+}
+`,
+        });
+        try {
+            (0, vitest_1.expect)(marksFor(dir, "read")).toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+});
+(0, vitest_1.describe)("G-B：上跳/绝对路径拒绝（种子=fr-012 gitlab-mcp 下载侧 localPath 守卫块）", () => {
+    // index.ts:7968-7977 —— pre 与 post 完全一致的一段既有守卫。
+    // 它不能当「修复形态种子」，但它是真实世界的「已校验」样本。
+    //
+    // ⚠️ 写法约束（踩过坑）：污点必须**直接出现在 sink 实参窗口里**。
+    // 「污点经 path.normalize(x) / path.join(x) 包装后仍传播」是另一条独立的
+    // 传播缺口（C4，见文末已知边界）—— 若让污点先被包装再进 sink，
+    // 「不得标记」会**假通过**（污点压根没到 sink，与守卫无关）。
+    // 故本组用例让 sink 直接使用污点名，守卫块则照抄真实代码。
+    const GUARD_BLOCK = `
+    const normalizedLocalPath = path.normalize(localPath);
+    if (
+      path.isAbsolute(normalizedLocalPath) ||
+      normalizedLocalPath === ".." ||
+      normalizedLocalPath.startsWith(".." + path.sep) ||
+      normalizedLocalPath.includes(path.sep + ".." + path.sep)
+    ) {
+      throw new Error("Invalid local_path: directory traversal is not allowed.");
+    }
+`;
+    const wrap = (guard) => `
+import * as fs from "fs";
+import * as path from "path";
+export function save(req: any, buffer: any) {
+  const localPath = req.params.local_path;
+${guard}  fs.writeFileSync(localPath, buffer);
+}
+`;
+    (0, vitest_1.it)("去掉守卫块后必须标记（正对照：证明这条用例真的锁住了判别力）", () => {
+        const dir = makeProject({ "a.ts": wrap("") });
+        try {
+            (0, vitest_1.expect)(marksFor(dir, "save")).toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    (0, vitest_1.it)("真实守卫块存在时不得标记", () => {
+        const dir = makeProject({ "a.ts": wrap(GUARD_BLOCK) });
+        try {
+            (0, vitest_1.expect)(marksFor(dir, "save")).not.toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+});
+(0, vitest_1.describe)("G-C：独立校验函数（种子=fr-007 openhop / fr-016 Redocly）", () => {
+    // fr-007 的修复形态：把 assertValidFlowId(id) 放进 filePath()，
+    // 真正含 sink 的 get/save 与外层 flowRoutes 里一个校验词汇都没有
+    // —— 只看函数体等于没做，必须向调用方传播。
+    const BASE = `
+import * as fs from "fs";
+import * as path from "path";
+export class FlowStore {
+  private dir = "/data";
+  private filePath(id: string): string {
+    PATHIDGUARD
+    return path.join(this.dir, id + ".yaml");
+  }
+  async get(id: string) {
+    return fs.readFileSync(this.filePath(id), "utf-8");
+  }
+}
+export function flowRoutes(req: any, store: FlowStore) {
+  const id = req.params.id;
+  return store.get(id);
+}
+`;
+    (0, vitest_1.it)("pre（无校验函数）：含 sink 的方法与外层调用点都要标记", () => {
+        const dir = makeProject({ "a.ts": BASE.replace("PATHIDGUARD", "") });
+        try {
+            (0, vitest_1.expect)(marksFor(dir, "flowRoutes")).toContain(PATH_MARK);
+            (0, vitest_1.expect)(marksFor(dir, "FlowStore.get")).toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    (0, vitest_1.it)("post（fr-007 真修复形态 assertValidFlowId）：两侧都不得标记", () => {
+        const dir = makeProject({
+            "flow-id.ts": `
+export function assertValidFlowId(id: string): void {
+  if (!/^[A-Za-z0-9_-]+$/.test(id)) { throw new Error("Invalid flow id: " + id); }
+}
+`,
+            "a.ts": BASE.replace("PATHIDGUARD", "assertValidFlowId(id);"),
+        });
+        try {
+            (0, vitest_1.expect)(marksFor(dir, "flowRoutes")).not.toContain(PATH_MARK);
+            (0, vitest_1.expect)(marksFor(dir, "FlowStore.get")).not.toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    (0, vitest_1.it)("fr-016 Redocly 形态 assertWithinDir：不得标记", () => {
+        const dir = makeProject({
+            "a.ts": `
+import * as fs from "fs";
+import * as path from "path";
+// 同上：让污点直接进 sink 实参窗口，避免假通过
+export function iteratePathItems(req: any, openapiDir: string, outDir: string) {
+  const pathName = req.params.name;
+  assertWithinDir(openapiDir, path.join(outDir, pathName) + ".yaml", pathName);
+  fs.writeFileSync(path.join(outDir, pathName) + ".yaml", "x");
+}
+`,
+        });
+        try {
+            (0, vitest_1.expect)(marksFor(dir, "iteratePathItems")).not.toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+});
+(0, vitest_1.describe)("G-A：目录包含性校验（canonical 形态）", () => {
+    const wrap = (guard) => `
+import * as fs from "fs";
+import * as path from "path";
+export function read(req: any) {
+  const name = req.params.name;
+  const baseDir = path.resolve("/data");
+  const target = path.resolve(baseDir, name);
+${guard}  return fs.readFileSync(path.join(baseDir, name), "utf-8");
+}
+`;
+    (0, vitest_1.it)("去掉包含性判断后必须标记（正对照）", () => {
+        const dir = makeProject({ "a.ts": wrap("") });
+        try {
+            (0, vitest_1.expect)(marksFor(dir, "read")).toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    (0, vitest_1.it)("resolve + startsWith(baseDir) → 不得标记", () => {
+        const dir = makeProject({
+            "a.ts": wrap(`  if (!target.startsWith(baseDir)) { throw new Error("outside"); }\n`),
+        });
+        try {
+            (0, vitest_1.expect)(marksFor(dir, "read")).not.toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+});
+(0, vitest_1.describe)("G-D：锚定字符集白名单（种子=fr-007 FLOW_ID_PATTERN）", () => {
+    const wrap = (guard) => `
+import * as fs from "fs";
+export function read(req: any) {
+  const name = req.params.name;
+${guard}  return fs.readFileSync("/data/" + name, "utf-8");
+}
+`;
+    (0, vitest_1.it)("去掉白名单校验后必须标记（正对照）", () => {
+        const dir = makeProject({ "a.ts": wrap("") });
+        try {
+            (0, vitest_1.expect)(marksFor(dir, "read")).toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    (0, vitest_1.it)("/^[A-Za-z0-9_-]+$/ 参与校验 → 不得标记", () => {
+        const dir = makeProject({
+            "a.ts": wrap(`  if (!/^[A-Za-z0-9_-]+$/.test(name)) { throw new Error("bad id"); }\n`),
+        });
+        try {
+            (0, vitest_1.expect)(marksFor(dir, "read")).not.toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+});
+(0, vitest_1.describe)("反例清单：这些形态**不算**守卫（N-A 是头号陷阱）", () => {
+    (0, vitest_1.it)("N-A path.basename —— fr-012 pre 实测反例：漏洞态就有 basename，必须照旧标记", () => {
+        // 注意：污点直接写进 sink 实参窗口（不经 `const x = path.basename(...)` 赋值），
+        // 因为「污点经表达式包装后仍传播」是另一条独立的传播缺口（见文末已知边界），
+        // 本用例只锁「basename 是否算守卫」这一件事。
+        const dir = makeProject({
+            "a.ts": `
+import * as fs from "fs";
+import * as path from "path";
+export function read(req: any) {
+  const name = req.params.name;
+  return fs.readFileSync("/data/" + path.basename(name), "utf-8");
+}
+`,
+        });
+        try {
+            (0, vitest_1.expect)(marksFor(dir, "read")).toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    (0, vitest_1.it)("N-B 单独出现的 join/resolve —— 拼接本身不阻止上跳，必须标记", () => {
+        const dir = makeProject({
+            "a.ts": `
+import * as fs from "fs";
+import * as path from "path";
+export function read(req: any) {
+  const name = req.params.name;
+  return fs.readFileSync(path.resolve("/data", name), "utf-8");
+}
+`,
+        });
+        try {
+            (0, vitest_1.expect)(marksFor(dir, "read")).toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    (0, vitest_1.it)("N-C 长度检查 —— 无法阻止上跳，必须标记", () => {
+        const dir = makeProject({
+            "a.ts": `
+import * as fs from "fs";
+export function read(req: any) {
+  const name = req.params.name;
+  if (name.length > 100) { throw new Error("too long"); }
+  return fs.readFileSync("/data/" + name, "utf-8");
+}
+`,
+        });
+        try {
+            (0, vitest_1.expect)(marksFor(dir, "read")).toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    (0, vitest_1.it)("N-D 空值检查 —— 空值检查 ≠ 路径包含性检查，必须标记", () => {
+        const dir = makeProject({
+            "a.ts": `
+import * as fs from "fs";
+export function read(req: any) {
+  const name = req.params.name;
+  if (!name) { throw new Error("missing"); }
+  return fs.readFileSync("/data/" + name, "utf-8");
+}
+`,
+        });
+        try {
+            (0, vitest_1.expect)(marksFor(dir, "read")).toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+});
+/**
+ * ── 已知边界（本次写用例时实测踩到，记录以免后人重复踩）──
+ *
+ * C4：污点经表达式包装后不再传播。
+ *   `const q = path.normalize(x)` / `path.join(x)` / `path.basename(x)` 之后，
+ *   q **不在** tainted 集合里（collectTaintedNames 的单跳只认 `= <name>` 直赋）。
+ *   后果有二：
+ *     ① 召回缺口（这是 C 组的事，本条目不修）；
+ *     ② **测试陷阱**：写「不得标记」类用例时，若污点被包装后再进 sink，
+ *        用例会**假通过**——不是守卫生效，是污点压根没到 sink。
+ *   因此本文件所有 `not.toContain` 用例都配了一条同形状的正对照
+ *   （去掉守卫后必须重新标记），缺了正对照的负向断言一律视为无效。
+ *   本轮就有 3 条用例最初因此假通过（G-A / G-D / fr-016 形态）。
+ */

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

@@ -0,0 +1,445 @@
+"use strict";
+/**
+ * 污点标记管线三处结构性修复（C1/C2/C3）的定向回归（2026-09-19）。
+ *
+ * 立项背景：这三处是从「污点源数据流试点 V1」里拆出来的**正确性修复**——
+ * 它们让标记管线对真实 TS 工程「看得见」，但不改变判别逻辑（判别力是 G1
+ * PATH_GUARD_EVIDENCE 的事，另一个条目）。
+ *
+ * 为什么必须有本文件（重要）：
+ *   TS 795 盲测对这三处【零覆盖】——实测把整份 generated 语料重跑后，
+ *   per-function calls 差异 0、__progmune 标记 826 vs 826、flags 3086 LOST 0/ADDED 0。
+ *   即「TS 795 零漂移」在这里是**空过**（vacuous pass）：它不是说这三处没风险，
+ *   而是说盲测语料根本走不到这些分支。因此真正的门是本文件的定向用例。
+ *
+ * 三处修复：
+ *   C3 UNTRUSTED_ROOTS   —— 污点根由「Express 专属变量名」改为「按传输面声明」
+ *   C1 methodSinkParamMap—— 除类方法外，纳入**顶层函数**的 sink 形参
+ *   C2 directCallRe      —— 跨函数传播除成员调用外，识别**裸调用** func(x)
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const extract_ir_1 = require("./extract-ir");
+const TSCONFIG = JSON.stringify({
+    compilerOptions: {
+        target: "ES2020",
+        module: "commonjs",
+        moduleResolution: "node",
+        strict: false,
+        skipLibCheck: true,
+        noEmit: true,
+    },
+    include: ["**/*.ts"],
+});
+function makeProject(files) {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pm-taint-struct-"));
+    fs.writeFileSync(path.join(dir, "tsconfig.json"), TSCONFIG);
+    fs.writeFileSync(path.join(dir, "package.json"), JSON.stringify({ name: "fixture", version: "0.0.0", private: true }));
+    for (const [rel, body] of Object.entries(files)) {
+        const abs = path.join(dir, rel);
+        fs.mkdirSync(path.dirname(abs), { recursive: true });
+        fs.writeFileSync(abs, body);
+    }
+    return dir;
+}
+function marksFor(dir, fnName) {
+    const fns = (0, extract_ir_1.extractIR)(dir);
+    const f = fns.find((x) => x.name === fnName);
+    return f ? (f.calls ?? []) : [];
+}
+const PATH_MARK = "__progmune_path_traversal__";
+(0, vitest_1.describe)("C3：污点根按传输面声明（不再只认 Express 的 req.*）", () => {
+    (0, vitest_1.it)("Express 形态仍必须标记（不得因改表回归）", () => {
+        const dir = makeProject({
+            "legacy.ts": `
+import * as fs from "fs";
+export function read(req: any) {
+  const name = req.params.name;
+  return fs.readFileSync("/data/" + name, "utf-8");
+}
+`,
+        });
+        try {
+            (0, vitest_1.expect)(marksFor(dir, "read")).toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    }, 150000);
+    (0, vitest_1.it)("MCP 工具实参 params.arguments 作为根（fr-012 形态）", () => {
+        const dir = makeProject({
+            "mcp.ts": `
+import * as fs from "fs";
+export function uploadMarkdown(args: any) {
+  const filePath = params.arguments.file_path;
+  return fs.readFileSync(filePath, "utf-8");
+}
+`,
+        });
+        try {
+            (0, vitest_1.expect)(marksFor(dir, "uploadMarkdown")).toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    }, 150000);
+    (0, vitest_1.it)("反例：常量路径不得标记（防止根表放宽后过度标记）", () => {
+        const dir = makeProject({
+            "benign.ts": `
+import * as fs from "fs";
+export function readDocs() {
+  return fs.readFileSync("/data/terms.md", "utf-8");
+}
+`,
+        });
+        try {
+            (0, vitest_1.expect)(marksFor(dir, "readDocs")).not.toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    }, 150000);
+});
+(0, vitest_1.describe)("C1：顶层函数的 sink 形参必须入表（此前只登记类方法）", () => {
+    (0, vitest_1.it)("顶层函数 + 污点实参 → 跨函数传导后被标记", () => {
+        const dir = makeProject({
+            "handler.ts": `
+import * as fs from "fs";
+export function markdownUpload(filePath: string) {
+  return fs.readFileSync(filePath, "utf-8");
+}
+export function dispatchTool(args: any) {
+  const target = params.arguments.file_path;
+  return markdownUpload(target);
+}
+`,
+        });
+        try {
+            (0, vitest_1.expect)(marksFor(dir, "markdownUpload")).toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    }, 150000);
+});
+(0, vitest_1.describe)("C2：裸调用形态的跨函数传播（此前只匹配 obj.sink(...)）", () => {
+    (0, vitest_1.it)("顶层函数被裸调用且传入污点 → 标记（fr-012 的 markdownUpload 形态）", () => {
+        const dir = makeProject({
+            "store.ts": `
+import * as fs from "fs";
+export function save(name: string, content: string) {
+  fs.writeFileSync("/flows/" + name, content);
+}
+`,
+            "route.ts": `
+import { save } from "./store";
+export function createFlow(req: any) {
+  const name = req.body.name;
+  save(name, "{}");
+}
+`,
+        });
+        try {
+            (0, vitest_1.expect)(marksFor(dir, "createFlow")).toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    }, 150000);
+    (0, vitest_1.it)("反例：给裸调用传常量不得标记", () => {
+        const dir = makeProject({
+            "store.ts": `
+import * as fs from "fs";
+export function save(name: string, content: string) {
+  fs.writeFileSync("/flows/" + name, content);
+}
+`,
+            "route.ts": `
+import { save } from "./store";
+export function seedFlow() {
+  save("default.json", "{}");
+}
+`,
+        });
+        try {
+            (0, vitest_1.expect)(marksFor(dir, "seedFlow")).not.toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    }, 150000);
+});
+/**
+ * C5（2026-09-19）：不可信根**直接写在 sink 实参里**（无中间变量）此前不标记。
+ *
+ * 发现途径：新建的 blind-benchmark taintpath 语料族里有两条最朴素的用例
+ * （`readFileSync("/d/" + req.params.name)`、模板字符串形态）跑出「不标记」。
+ * 根因是外层 `tainted.size > 0` 的闸门——而 SSRF 侧从来不要求中间变量。
+ *
+ * 按 R6：**每条「不得标记」都要配正对照**。这里的负对照是同形状无污点的常量路径。
+ */
+(0, vitest_1.describe)("C5：内联不可信根（不经中间变量）必须标记", () => {
+    const cases = [
+        {
+            name: "字符串拼接直连",
+            fn: "readInline",
+            code: `export function readInline(req: any) {
+  return fs.readFileSync("/srv/data/" + req.params.name, "utf-8");
+}`,
+            expectMark: true,
+            why: "真实 Express 工程最常见的写法",
+        },
+        {
+            name: "模板字符串直连",
+            fn: "readTemplate",
+            code: "export function readTemplate(req: any) {\n  return fs.readFileSync(`/srv/data/${req.query.name}`, \"utf-8\");\n}",
+            expectMark: true,
+            why: "query 根 + 模板插值",
+        },
+        {
+            name: "写侧 header 根",
+            fn: "writeHeader",
+            code: `export function writeHeader(request: any, data: any) {
+  return fs.writeFileSync("/srv/data/" + request.headers["x-name"], data);
+}`,
+            expectMark: true,
+            why: "写 sink + request.headers 根",
+        },
+        {
+            name: "MCP 实参直连",
+            fn: "writeMcp",
+            code: `export function writeMcp(params: any, data: any) {
+  return fs.writeFileSync(params.arguments.path, data);
+}`,
+            expectMark: true,
+            why: "传输面里的第二个根：MCP 工具实参",
+        },
+        {
+            name: "负对照：常量路径不得标记",
+            fn: "readConstant",
+            code: `export function readConstant() {
+  return fs.readFileSync("/srv/data/index.html", "utf-8");
+}`,
+            expectMark: false,
+            why: "R6：证明前面的用例不是靠「只要有 fs sink 就标记」蒙对",
+        },
+        {
+            name: "负对照：有守卫时内联根仍不标记",
+            fn: "readInlineGuarded",
+            code: `export function readInlineGuarded(req: any) {
+  const target = path.resolve("/srv/data", req.params.name);
+  if (!target.startsWith("/srv/data")) throw new Error("outside");
+  return fs.readFileSync(target, "utf-8");
+}`,
+            expectMark: false,
+            why: "C5 只补召回，不得绕过 G1 的判别力",
+        },
+    ];
+    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);
+    }
+});
+// ═══════════════════════════════════════════════════════════════
+// 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,197 @@ 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",
+        // resolve(p).startsWith(resolve(root)+sep) / x.startsWith(baseDir)
+        re: /(?:resolve|realpath|normalize)\s*\([^()]*\)\s*\.\s*startsWith\s*\(/,
+        why: "目录包含性校验（canonical 形态）：规范化后判断是否落在基目录内",
+        source: "设计形态，canonical；fr-016 Redocly 修复的同族（见 G-C）",
+    },
+    {
+        id: "G-A2",
+        // 粗筛：任意 `.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",
+        re: /\b(?:path\.)?isAbsolute\s*\(/,
+        why: "绝对路径拒绝：绝对路径不受 join(root, p) 约束",
+        source: "fr-012 gitlab-mcp 下载侧 localPath 既有守卫块（pre/post 同一段，@ index.ts:7968）",
+    },
+    {
+        id: "G-B2",
+        // startsWith(".." + sep) / includes(sep + ".." + sep) / === ".."
+        re: /\.\s*(?:startsWith|includes)\s*\(\s*(?:[^()]*["'`]\.\.)/,
+        why: "上跳拒绝：显式检测 .. 段",
+        source: "fr-012 gitlab-mcp 下载侧 localPath 既有守卫块（index.ts:7968-7977）",
+    },
+    {
+        id: "G-B3",
+        re: /(?:===?|!==)\s*["'`]\.\.["'`]/,
+        why: "上跳拒绝：与 .. 字面量直接比较",
+        source: "fr-012 gitlab-mcp 下载侧 localPath 既有守卫块（normalizedLocalPath === \"..\"）",
+    },
+    // 注：G-C 不放在本数组里——它是「按函数名判定」，需要配反例名单
+    // （见 PATH_GUARD_FN_CALL_RE / PATH_GUARD_FN_DENY 与下方注释）。
+    {
+        id: "G-D",
+        // /^[A-Za-z0-9_-]+$/ —— 锚定的字符集白名单，天然排除 / \ .
+        re: /\/\^\[[^\]]*\]\s*[+*?]\$\//,
+        why: "锚定字符集白名单：^…$ 且字符类不含 ./\\ 时无法构造上跳",
+        source: "fr-007 openhop `FLOW_ID_PATTERN = /^[A-Za-z0-9_-]+$/`（flow-id.ts）",
+    },
+];
+/**
+ * 明确**不算**守卫的形态（反例清单）。
+ *
+ * N-A `path.basename` 是这张表里最重要的一行：它只去目录、不去 `..`，
+ * 却极常被当成「已经 sanitize 过」。fr-012 pre 的实测反例：漏洞态代码里
+ * 就有 `path.basename`，漏洞依然成立。一旦把 basename 算作守卫，
+ * fr-012 的真值会被自己压掉 —— 见 src/extract-ir-taint-guard.test.ts。
+ */
+const PATH_NON_GUARD_NOTE = "N-A path.basename / N-B 单独出现的 join·resolve / N-C 长度或字符数检查 / N-D if (!p) throw —— 均不计入守卫";
+/**
+ * G-C：独立校验函数被调用（项目自有命名）。
+ *
+ * 后缀刻意**不收** `Dir` / `Name` / 裸的 `Valid` —— 实证代价：
+ *   - `ensureDir()`（fr-007 openhop store.ts:46）与 `s.isDirectory()` 都会被
+ *     `…Dir(` 命中，而它们是**建目录 / 类型判断**，与校验无关；第一版词表
+ *     因此把 fr-007 的 pre 侧 5 条全部误压成 0（召回归零）。
+ *   - `isValid(x)` / `isSub(a,b)` 同理，会把判别力稀释成猜函数名。
+ * 保留 `Id`（fr-007 `assertValidFlowId`）、`Within`（fr-016 `assertWithinDir`）、
+ * `Safe|Path|Inside|InDir|Contained|Traversal|Root|Base`。
+ */
+const PATH_GUARD_FN_CALL_RE = /\b(?:assert|ensure|check|validate|verify|sanitize|is)[A-Za-z$]*(?:Safe|Path|Paths|Within|Inside|InDir|Contained|Traversal|Id|Root|Base)[A-Za-z0-9_$]*(?=\s*\()/g;
+/** 形态上会命中 G-C 但**确定不是**路径校验的名字（实证反例，逐个加） */
+const PATH_GUARD_FN_DENY = /^(?:ensureDir|isDirectory|isDir|assertDir|makeDir|mkdir|checkExists|isValid|isRoot|ensureId|getId)$/i;
+function callsPathGuardFn(text) {
+    PATH_GUARD_FN_CALL_RE.lastIndex = 0;
+    let m;
+    while ((m = PATH_GUARD_FN_CALL_RE.exec(text)) !== null) {
+        if (!PATH_GUARD_FN_DENY.test(m[0]))
+            return true;
+    }
+    return false;
+}
+/** 返回命中的守卫规则 id；无校验证据返回 null。 */
+function hasPathGuardEvidence(text) {
+    for (const r of PATH_GUARD_RULES) {
+        if (r.decide ? r.decide(text) : r.re.test(text))
+            return r.id;
+    }
+    if (callsPathGuardFn(text))
+        return "G-C";
+    return null;
+}
+function escapeRe(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+ * 项目内「自身含校验证据」的函数名集合，并向调用方传播一跳（有界）。
+ *
+ * 为什么必须传播：fr-007 的修复是把 `assertValidFlowId(id)` 放进 `filePath()`，
+ * 真正含 sink 的 `FlowStore.get/save/...` 与外层 `flowRoutes` 里**一个校验词汇都没有**——
+ * 只看函数体等于没做。传播上限 3 轮（防止公共函数名导致的无限扩散）。
+ */
+function pathGuardFunctionNames(project) {
+    const guarded = new Set();
+    const bodies = [];
+    const note = (names, text) => {
+        if (!text)
+            return;
+        bodies.push({ names, text });
+        if (hasPathGuardEvidence(text))
+            for (const n of names)
+                if (n)
+                    guarded.add(n);
+    };
+    for (const sf of project.getSourceFiles()) {
+        for (const cls of sf.getClasses()) {
+            const cn = cls.getName();
+            if (!cn)
+                continue;
+            for (const m of cls.getMethods()) {
+                const mn = m.getName();
+                if (!mn)
+                    continue;
+                note([mn, `${cn}.${mn}`], m.getText());
+            }
+        }
+        for (const fn of sf.getFunctions()) {
+            const fnName = fn.getName();
+            if (!fnName)
+                continue;
+            note([fnName], fn.getText());
+        }
+    }
+    // 向调用方传播：调用了一个已校验函数 ⇒ 这条流已被拦截（有界 3 轮）
+    for (let round = 0; round < 3; round++) {
+        const names = [...guarded].filter((n) => !n.includes("."));
+        if (names.length === 0)
+            break;
+        const re = new RegExp(`\\b(?:${names.map(escapeRe).join("|")})\\s*\\(`, "g");
+        let added = false;
+        for (const b of bodies) {
+            if (b.names.every((n) => guarded.has(n)))
+                continue;
+            re.lastIndex = 0;
+            if (re.test(b.text)) {
+                for (const n of b.names)
+                    if (n && !guarded.has(n)) {
+                        guarded.add(n);
+                        added = true;
+                    }
+            }
+        }
+        if (!added)
+            break;
+    }
+    return guarded;
+}
 const TS_FILE_SINK_NAMES = [
     "readFile", "readFileSync", "writeFile", "writeFileSync",
     "appendFile", "appendFileSync", "unlink", "unlinkSync", "rm", "rmSync",
@@ -419,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;
@@ -438,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)
@@ -456,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) {
@@ -584,12 +833,22 @@ function collectUrlParamNames(params) {
  *   项目方法体内的文件 sink（跨函数一跳，onMethodHit 回调登记方法条目）
  * - SSRF：URL 形参/request 污点 → HTTP fetch sink，无守卫词汇
  */
-function computeMarkerCalls(text, paramNames, sinkParams, onMethodHit) {
+function computeMarkerCalls(text, paramNames, sinkParams, onMethodHit, guardFns) {
     const markers = [];
     // ── 路径穿越 ──
+    // G1（2026-09-19）：有流还不够，必须【没有校验证据】才标记——
+    // 与 SSRF 侧「无 SSRF_GUARD_EVIDENCE 才标记」对齐。
+    // 未传 guardFns（旧调用点/单测）时按「不做校验识别」的旧语义处理。
     if (hasRequestRootedExpr(text)) {
         const tainted = collectTaintedNames(text);
-        if (tainted.size > 0) {
+        const selfGuarded = guardFns ? hasPathGuardEvidence(text) !== null : false;
+        // C5（2026-09-19）：不可信根可以直接写在 sink 实参里，不需要中间变量。
+        // 此前外层要求 collectTaintedNames 非空，于是
+        //   `fs.readFileSync("/data/" + req.params.name)` —— 真实工程里最常见的形态
+        // 不标记；只有写成 `const n = req.params.name; readFileSync("/data/" + n)` 才标。
+        // SSRF 侧从来不是这样（它把 UNTRUSTED_ROOT_SRC 并进 taint 模式去匹配实参窗口），
+        // 这是同一条数据流上的又一处口径不一致。
+        if (!selfGuarded) {
             if (hasTaintedSinkCall(text, tainted)) {
                 markers.push("__progmune_path_traversal__");
             }
@@ -609,6 +868,9 @@ function computeMarkerCalls(text, paramNames, sinkParams, onMethodHit) {
                             const rec = sinkParams.get(m[1]);
                             if (!rec || rec.idxs.size === 0)
                                 continue;
+                            // G1：被调用方自身已校验 ⇒ 这条跨函数流已被拦截，不标记
+                            if (guardFns && guardFns.has(m[1]))
+                                continue;
                             const args = splitArgWindow(m[2] || "");
                             const hit = args.some((arg, i) => rec.idxs.has(i) && taint.test(arg));
                             if (hit) {
@@ -727,6 +989,8 @@ function _extractSingleProject(absRoot, tsconfigPath) {
     // sinkParams = 项目方法名 → 方法体内流入文件 sink 的形参下标 + 方法条目；
     // pendingMethodMarks = 跨函数命中待标记的方法条目（主循环后统一应用）
     const sinkParams = methodSinkParamMap(project, absRoot);
+    // G1（2026-09-19）：路径校验识别。自身含校验证据的函数名 + 向调用方传播一跳。
+    const guardFns = pathGuardFunctionNames(project);
     const pendingMethodMarks = new Set();
     const onMethodHit = (rec) => {
         for (const me of rec.entries)
@@ -744,7 +1008,7 @@ function _extractSingleProject(absRoot, tsconfigPath) {
             const fParams = f.getParameters();
             const fText = f.getText();
             const fCalls = extractDirectCalls(f, fText);
-            fCalls.push(...computeMarkerCalls(fText, fParams.map((p) => p.getName()), sinkParams, onMethodHit));
+            fCalls.push(...computeMarkerCalls(fText, fParams.map((p) => p.getName()), sinkParams, onMethodHit, guardFns));
             funcs.push({
                 name,
                 params: fParams.map(p => ({
@@ -774,7 +1038,7 @@ function _extractSingleProject(absRoot, tsconfigPath) {
                 const initParams = init.getParameters();
                 const initText = init.getText();
                 const initCalls = extractDirectCalls(init, initText);
-                initCalls.push(...computeMarkerCalls(initText, initParams.map((p) => p.getName()), sinkParams, onMethodHit));
+                initCalls.push(...computeMarkerCalls(initText, initParams.map((p) => p.getName()), sinkParams, onMethodHit, guardFns));
                 funcs.push({
                     name,
                     params: initParams.map(p => ({
@@ -800,7 +1064,7 @@ function _extractSingleProject(absRoot, tsconfigPath) {
                         const argParams = arg.getParameters();
                         const argText = arg.getText();
                         const argCalls = extractDirectCalls(arg, argText);
-                        argCalls.push(...computeMarkerCalls(argText, argParams.map((p) => p.getName()), sinkParams, onMethodHit));
+                        argCalls.push(...computeMarkerCalls(argText, argParams.map((p) => p.getName()), sinkParams, onMethodHit, guardFns));
                         funcs.push({
                             name,
                             params: argParams.map(p => ({
@@ -834,7 +1098,7 @@ function _extractSingleProject(absRoot, tsconfigPath) {
                     continue;
                 const mParams = m.getParameters();
                 const mText = m.getText();
-                const mCalls = computeMarkerCalls(mText, mParams.map((p) => p.getName()), sinkParams, onMethodHit);
+                const mCalls = computeMarkerCalls(mText, mParams.map((p) => p.getName()), sinkParams, onMethodHit, guardFns);
                 funcs.push({
                     name: `${cn}.${mn}`,
                     params: mParams.map((p) => ({ name: p.getName(), type: getParamType(p), typeDetail: getParamTypeDetail(p) })),

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.32";
+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.32",
+  "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/",