progmune-runtime 3.7.31 → 3.7.35

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

@@ -0,0 +1,289 @@
+"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);
+    }
+});