@sofagent/rules 1.3.7 → 1.3.9

package/dist/ast/rules/asi04-sbom.js

@@ -0,0 +1,158 @@
+"use strict";
+// ============================================================
+// asi04-sbom.ts · OWASP ASI04 供应链 SBOM 检测
+// v1.3.9（一）：扫描依赖清单（package.json / go.mod）→ 生成 SBOM →
+// 查离线样例漏洞库（fixtures/vuln-db.json，不依赖 CI 联网）
+//
+// Microsoft AGT 启发：受损插件/子 agent 经由依赖清单注入恶意行为——
+// SBOM 是把「装了什么」变成可审计事实的第一步
+// ============================================================
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asi04SbomRule = void 0;
+exports.parsePackageLock = parsePackageLock;
+exports.parsePackageJson = parsePackageJson;
+exports.parseGoMod = parseGoMod;
+exports.buildSbom = buildSbom;
+const vuln_db_json_1 = __importDefault(require("../fixtures/vuln-db.json"));
+const semver_1 = require("./semver");
+/** 依赖清单文件匹配——lockfile 优先（精确版本），manifest 兜底（range 近似） */
+const MANIFEST_FILE = /(package-lock\.json|npm-shrinkwrap\.json|package\.json|go\.mod|go\.sum)$/;
+/** 剥离 npm 版本前缀（^1.2.3 → 1.2.3） */
+function stripPrefix(v) {
+    return v.replace(/^[\^~>=<\s]+/, '').split(' ')[0] ?? v;
+}
+/** 判断版本串是否带 range 前缀（^ / ~ / 区间），带则命中结果不确定 */
+function hasRangePrefix(v) {
+    return /^[\^~<>]/.test(v);
+}
+/**
+ * 解析 package-lock.json → SBOM 条目（精确锁定版本——v2/v3 的 packages 对象；v1 兜底 dependencies 嵌套）。
+ * v1.3.9 阶段四修复（fresh-eyes 视角7）：ASI04 此前只扫 manifest 的 range（^4.17.20），
+ * range 宽则误报、窄则漏报（注释自承「精确锁定版本在 lock 文件里」）。本函数用 lockfile
+ * 的精确版本做漏洞匹配——消除假阳/假阴；manifest 仅作无 lockfile 时的 fallback。
+ */
+function parsePackageLock(text) {
+    let lock;
+    try {
+        lock = JSON.parse(text);
+    }
+    catch {
+        return [];
+    }
+    const entries = [];
+    // v2/v3：packages 对象，key 如 "node_modules/foo" / ""（根）
+    if (lock.packages) {
+        for (const [key, meta] of Object.entries(lock.packages)) {
+            if (!key || key === '' || !meta?.version)
+                continue; // 跳过根包（""）与 workspace 链接（version 缺失）
+            entries.push({ name: key.replace(/^node_modules\//, ''), version: meta.version, ecosystem: 'npm', line: 1 });
+        }
+        return entries;
+    }
+    // v1：dependencies 嵌套（含 transitive）
+    const walk = (deps) => {
+        if (!deps)
+            return;
+        for (const [name, meta] of Object.entries(deps)) {
+            if (meta?.version)
+                entries.push({ name, version: meta.version, ecosystem: 'npm', line: 1 });
+            walk(meta?.dependencies);
+        }
+    };
+    walk(lock.dependencies);
+    return entries;
+}
+/**
+ * 解析 package.json → SBOM 条目。
+ * 版本声明形如 "^4.17.20"——无 lockfile 时剥离前缀近似（保守：命中漏洞标「range 不确定」）。
+ */
+function parsePackageJson(text) {
+    let manifest;
+    try {
+        manifest = JSON.parse(text);
+    }
+    catch {
+        return [];
+    }
+    const entries = [];
+    const sections = [
+        manifest.dependencies,
+        manifest.devDependencies,
+        manifest.optionalDependencies,
+    ];
+    for (const section of sections) {
+        if (!section)
+            continue;
+        for (const [name, version] of Object.entries(section)) {
+            entries.push({ name, version: stripPrefix(version), ecosystem: 'npm', line: 1 });
+        }
+    }
+    return entries;
+}
+/** 解析 go.mod → SBOM 条目（require 行 + require 块两种形态） */
+function parseGoMod(text) {
+    const entries = [];
+    const lines = text.split('\n');
+    let inRequireBlock = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i] ?? '';
+        const trimmed = line.trim();
+        if (trimmed === 'require (') {
+            inRequireBlock = true;
+            continue;
+        }
+        if (trimmed === ')') {
+            inRequireBlock = false;
+            continue;
+        }
+        const m = inRequireBlock
+            ? /^([\w./~-]+)\s+(v[\w.\-+]+)/.exec(trimmed)
+            : /^require\s+([\w./~-]+)\s+(v[\w.\-+]+)/.exec(trimmed);
+        if (m) {
+            // go.mod 版本带 v 前缀（v1.4.0）——剥掉再进区间比较
+            entries.push({ name: m[1] ?? '', version: (m[2] ?? '').replace(/^v/, ''), ecosystem: 'go', line: i + 1 });
+        }
+    }
+    return entries;
+}
+/** 生成 SBOM（按清单类型分派）——lockfile 优先（精确），manifest 兜底（range） */
+function buildSbom(path, text) {
+    if (path.endsWith('package-lock.json') || path.endsWith('npm-shrinkwrap.json'))
+        return parsePackageLock(text);
+    if (path.endsWith('package.json'))
+        return parsePackageJson(text);
+    if (path.endsWith('go.mod'))
+        return parseGoMod(text);
+    return [];
+}
+exports.asi04SbomRule = {
+    id: 'asi04-sbom',
+    name: 'OWASP ASI04 供应链 SBOM 检测',
+    severity: 'FAIL',
+    description: '扫描依赖清单（lockfile 优先精确版本，manifest 兜底）生成 SBOM 并查离线样例漏洞库（受损插件注入恶意行为的供应链面）',
+    filePattern: MANIFEST_FILE,
+    checkText(ctx) {
+        const sbom = buildSbom(ctx.path, ctx.text);
+        if (sbom.length === 0)
+            return;
+        const db = vuln_db_json_1.default;
+        for (const entry of sbom) {
+            const advisories = db[entry.ecosystem]?.[entry.name];
+            if (!advisories)
+                continue;
+            for (const adv of advisories) {
+                const hit = adv.ranges.some((range) => (0, semver_1.inRange)(entry.version, range));
+                if (hit) {
+                    // lockfile 精确命中 = 确定；manifest range 命中 = 不确定（区间内存在受影响版本，需核对 lockfile）
+                    const isLock = /package-lock\.json|npm-shrinkwrap\.json/.test(ctx.path);
+                    const qualifier = isLock ? '' : `（manifest range，受影响版本区间内；建议核对 ${entry.name.split('/')[0]}-lock 锁定版本）`;
+                    ctx.report(entry.line, `[ASI04] 依赖 ${entry.name}@${entry.version} 命中已知漏洞 ${adv.id}（${adv.summary}）${qualifier}`);
+                }
+            }
+        }
+    },
+};
+//# sourceMappingURL=asi04-sbom.js.map

package/dist/ast/rules/index.d.ts

@@ -0,0 +1,6 @@
+import type { AstRule } from '../types';
+/** 内置示范规则集（10 条：7 FAIL / 3 WARN） */
+export declare const builtinAstRules: readonly AstRule[];
+/** 按规则 ID 导出（规则集 JSON 生成与单测引用） */
+export declare const astRuleById: ReadonlyMap<string, AstRule>;
+//# sourceMappingURL=index.d.ts.map

package/dist/ast/rules/index.js

@@ -0,0 +1,34 @@
+"use strict";
+// ============================================================
+// rules/index.ts · 官方示范规则集注册表
+// v1.3.9（一）：10 条示范规则（8 条代码 AST + 2 条 OWASP 语义）
+// 社区照这个结构写自己的 sofagent-ruleset-* 引擎
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.astRuleById = exports.builtinAstRules = void 0;
+const no_eval_1 = require("./no-eval");
+const no_hardcoded_secret_1 = require("./no-hardcoded-secret");
+const no_child_process_shell_1 = require("./no-child-process-shell");
+const no_dynamic_require_1 = require("./no-dynamic-require");
+const no_insecure_url_1 = require("./no-insecure-url");
+const no_debugger_1 = require("./no-debugger");
+const no_sql_string_concat_1 = require("./no-sql-string-concat");
+const no_empty_catch_1 = require("./no-empty-catch");
+const asi01_prompt_injection_1 = require("./asi01-prompt-injection");
+const asi04_sbom_1 = require("./asi04-sbom");
+/** 内置示范规则集（10 条：7 FAIL / 3 WARN） */
+exports.builtinAstRules = [
+    no_eval_1.noEvalRule, // 禁止 eval() / new Function()
+    no_hardcoded_secret_1.noHardcodedSecretRule, // 禁止硬编码密钥（AST 语义级）
+    no_dynamic_require_1.noDynamicRequireRule, // 禁止动态 require（ASI04 关联）
+    no_debugger_1.noDebuggerRule, // 禁止 debugger 语句
+    no_child_process_shell_1.noChildProcessShellRule, // child_process shell 执行管控
+    no_sql_string_concat_1.noSqlStringConcatRule, // 禁止 SQL 字符串拼接
+    no_insecure_url_1.noInsecureUrlRule, // 禁止 http:// 明文端点
+    no_empty_catch_1.noEmptyCatchRule, // 禁止空 catch 块
+    asi01_prompt_injection_1.asi01PromptInjectionRule, // OWASP ASI01 目标劫持
+    asi04_sbom_1.asi04SbomRule,
+];
+/** 按规则 ID 导出（规则集 JSON 生成与单测引用） */
+exports.astRuleById = new Map(exports.builtinAstRules.map((r) => [r.id, r]));
+//# sourceMappingURL=index.js.map

package/dist/ast/rules/no-child-process-shell.d.ts

@@ -0,0 +1,3 @@
+import type { AstRule } from '../types';
+export declare const noChildProcessShellRule: AstRule;
+//# sourceMappingURL=no-child-process-shell.d.ts.map

package/dist/ast/rules/no-child-process-shell.js

@@ -0,0 +1,57 @@
+"use strict";
+// ============================================================
+// no-child-process-shell.ts · child_process shell 执行管控
+// v1.3.9（一）：exec/execSync 走 shell 解释器——参数拼接即命令注入。
+// 语法级检测：文件里 import 了 child_process 的 exec* 绑定后又被调用
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noChildProcessShellRule = void 0;
+const walk_1 = require("../walk");
+/** child_process 家族里走 shell 的入口（spawn/spawnSync/fork 不走 shell，不在列） */
+const SHELL_APIS = new Set(['exec', 'execSync']);
+/** shell 元字符——出现在参数字面量里即高危 */
+const SHELL_METACHARS = /[;&|`$><\n]/;
+exports.noChildProcessShellRule = {
+    id: 'no-child-process-shell',
+    name: 'child_process shell 执行管控',
+    severity: 'WARN',
+    description: 'exec/execSync 走 shell——字面量含元字符或动态拼接参数即命令注入入口（动态参数 FAIL / 静态参数 WARN）',
+    checkCode(ctx) {
+        // 第一步：收集来自 child_process 的 import 绑定
+        const imports = (0, walk_1.collectImports)(ctx);
+        const shellBindings = new Set();
+        for (const [name, mod] of imports) {
+            if (mod === 'child_process' && SHELL_APIS.has(name))
+                shellBindings.add(name);
+        }
+        (0, walk_1.walk)(ctx.sourceFile, (node) => {
+            if (!(0, walk_1.is)(ctx, node, 'CallExpression'))
+                return;
+            const callee = node.expression;
+            if (!(0, walk_1.is)(ctx, callee, 'Identifier'))
+                return;
+            const name = (0, walk_1.nodeText)(callee);
+            if (!name || !shellBindings.has(name))
+                return;
+            // 命中 exec*/execSync* 调用——按参数形态定级
+            const args = node.arguments ?? [];
+            const first = args[0];
+            if (!first)
+                return;
+            if ((0, walk_1.is)(ctx, first, 'StringLiteral')) {
+                const cmd = (0, walk_1.nodeText)(first) ?? '';
+                if (SHELL_METACHARS.test(cmd)) {
+                    ctx.report(node, `${name}() 的命令字面量含 shell 元字符——存在命令注入面`);
+                }
+                else {
+                    ctx.report(node, `${name}() 走 shell 执行——优先用 spawn(arg, { shell: false }) 传参数组`);
+                }
+            }
+            else {
+                // 模板字符串 / 变量拼接 → 动态命令
+                ctx.report(node, `${name}() 的命令是动态构造（非字符串字面量）——命令注入高危入口`);
+            }
+        });
+    },
+};
+//# sourceMappingURL=no-child-process-shell.js.map

package/dist/ast/rules/no-debugger.d.ts

@@ -0,0 +1,3 @@
+import type { AstRule } from '../types';
+export declare const noDebuggerRule: AstRule;
+//# sourceMappingURL=no-debugger.d.ts.map

package/dist/ast/rules/no-debugger.js

@@ -0,0 +1,22 @@
+"use strict";
+// ============================================================
+// no-debugger.ts · 禁止 debugger 语句
+// v1.3.9（一）：debugger 语句遗留在生产代码会冻结 Node 进程
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noDebuggerRule = void 0;
+const walk_1 = require("../walk");
+exports.noDebuggerRule = {
+    id: 'no-debugger',
+    name: '禁止 debugger 语句',
+    severity: 'FAIL',
+    description: 'debugger 语句遗留在生产代码会冻结 Node 进程',
+    checkCode(ctx) {
+        (0, walk_1.walk)(ctx.sourceFile, (node) => {
+            if ((0, walk_1.is)(ctx, node, 'DebuggerStatement')) {
+                ctx.report(node, '禁止遗留 debugger 语句——生产环境会冻结进程');
+            }
+        });
+    },
+};
+//# sourceMappingURL=no-debugger.js.map

package/dist/ast/rules/no-dynamic-require.d.ts

@@ -0,0 +1,3 @@
+import type { AstRule } from '../types';
+export declare const noDynamicRequireRule: AstRule;
+//# sourceMappingURL=no-dynamic-require.d.ts.map

package/dist/ast/rules/no-dynamic-require.js

@@ -0,0 +1,34 @@
+"use strict";
+// ============================================================
+// no-dynamic-require.ts · 禁止动态 require
+// v1.3.9（一）：require(变量) 使依赖来源在静态分析下不可见——
+// 供应链投毒（OWASP ASI04）的隐藏通道
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noDynamicRequireRule = void 0;
+const walk_1 = require("../walk");
+exports.noDynamicRequireRule = {
+    id: 'no-dynamic-require',
+    name: '禁止动态 require',
+    severity: 'FAIL',
+    description: 'require(非字面量) 的模块来源静态不可见——供应链投毒隐藏通道（ASI04 关联）',
+    checkCode(ctx) {
+        (0, walk_1.walk)(ctx.sourceFile, (node) => {
+            if (!(0, walk_1.is)(ctx, node, 'CallExpression'))
+                return;
+            const callee = node.expression;
+            if (!(0, walk_1.is)(ctx, callee, 'Identifier'))
+                return;
+            if ((0, walk_1.nodeText)(callee) !== 'require')
+                return;
+            const args = node.arguments ?? [];
+            const first = args[0];
+            if (!first)
+                return;
+            if (!(0, walk_1.is)(ctx, first, 'StringLiteral')) {
+                ctx.report(node, 'require() 参数不是字符串字面量——动态模块加载使依赖审计失效');
+            }
+        });
+    },
+};
+//# sourceMappingURL=no-dynamic-require.js.map

package/dist/ast/rules/no-empty-catch.d.ts

@@ -0,0 +1,3 @@
+import type { AstRule } from '../types';
+export declare const noEmptyCatchRule: AstRule;
+//# sourceMappingURL=no-empty-catch.d.ts.map

package/dist/ast/rules/no-empty-catch.js

@@ -0,0 +1,29 @@
+"use strict";
+// ============================================================
+// no-empty-catch.ts · 禁止空 catch 块
+// v1.3.9（一）：空 catch 吞异常——错误静默扩散是审计盲区的经典成因
+// （对齐 FORGE「空 catch 治理」工程纪律的语义级落地）
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noEmptyCatchRule = void 0;
+const walk_1 = require("../walk");
+exports.noEmptyCatchRule = {
+    id: 'no-empty-catch',
+    name: '禁止空 catch 块',
+    severity: 'WARN',
+    description: '空 catch 块吞掉异常——错误静默扩散；至少要留一行注释说明为什么可以忽略',
+    checkCode(ctx) {
+        (0, walk_1.walk)(ctx.sourceFile, (node) => {
+            if (!(0, walk_1.is)(ctx, node, 'CatchClause'))
+                return;
+            const block = node.block;
+            if (!(0, walk_1.is)(ctx, block, 'Block'))
+                return;
+            const stmts = block.statements ?? [];
+            if (stmts.length === 0) {
+                ctx.report(node, '空 catch 块——异常被静默吞掉；至少留一行注释说明忽略理由');
+            }
+        });
+    },
+};
+//# sourceMappingURL=no-empty-catch.js.map

package/dist/ast/rules/no-eval.d.ts

@@ -0,0 +1,3 @@
+import type { AstRule } from '../types';
+export declare const noEvalRule: AstRule;
+//# sourceMappingURL=no-eval.d.ts.map

package/dist/ast/rules/no-eval.js

@@ -0,0 +1,33 @@
+"use strict";
+// ============================================================
+// no-eval.ts · 禁止 eval() / new Function()
+// v1.3.9（一）：官方示范 AST 规则——动态代码执行是注入攻击的标准入口
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noEvalRule = void 0;
+const walk_1 = require("../walk");
+exports.noEvalRule = {
+    id: 'no-eval',
+    name: '禁止动态代码执行',
+    severity: 'FAIL',
+    description: 'eval() / new Function() 会执行任意字符串代码，是 prompt 注入与供应链攻击的放大器',
+    checkCode(ctx) {
+        (0, walk_1.walk)(ctx.sourceFile, (node) => {
+            // eval(...)：CallExpression，callee 是 Identifier "eval"
+            if ((0, walk_1.is)(ctx, node, 'CallExpression')) {
+                const callee = node.expression;
+                if (callee && callee.kind === ctx.kind('Identifier') && (0, walk_1.nodeText)(callee) === 'eval') {
+                    ctx.report(node, '禁止使用 eval()——动态代码执行入口');
+                }
+            }
+            // new Function(...)：NewExpression，callee 是 Identifier "Function"
+            if ((0, walk_1.is)(ctx, node, 'NewExpression')) {
+                const callee = node.expression;
+                if (callee && callee.kind === ctx.kind('Identifier') && (0, walk_1.nodeText)(callee) === 'Function') {
+                    ctx.report(node, '禁止 new Function()——动态代码执行入口');
+                }
+            }
+        });
+    },
+};
+//# sourceMappingURL=no-eval.js.map

package/dist/ast/rules/no-hardcoded-secret.d.ts

@@ -0,0 +1,3 @@
+import type { AstRule } from '../types';
+export declare const noHardcodedSecretRule: AstRule;
+//# sourceMappingURL=no-hardcoded-secret.d.ts.map

package/dist/ast/rules/no-hardcoded-secret.js

@@ -0,0 +1,59 @@
+"use strict";
+// ============================================================
+// no-hardcoded-secret.ts · 禁止硬编码密钥（AST 语义级）
+// v1.3.9（一）：与 pattern 规则（正则扫行）相比，AST 级检测只命中
+// 「赋值给密钥类变量名的字符串字面量」，误报率显著更低
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noHardcodedSecretRule = void 0;
+const walk_1 = require("../walk");
+/** 密钥类变量名模式 */
+const SECRET_NAME = /(secret|token|passwd|password|api[_-]?key|apikey|access[_-]?key|private[_-]?key|credential)/i;
+/** 占位符白名单——这些值不是真实密钥 */
+const PLACEHOLDER = /^(x+|<[^>]*>|\$\{[^}]*\}|your[_-].*|placeholder|changeme|redacted|test-?dummy)$/i;
+/** 疑似真实密钥的最小长度（短字符串多为业务常量） */
+const MIN_SECRET_LEN = 16;
+function isSecretLiteral(name, value) {
+    if (!SECRET_NAME.test(name))
+        return false;
+    if (value.length < MIN_SECRET_LEN)
+        return false;
+    if (PLACEHOLDER.test(value))
+        return false;
+    return true;
+}
+exports.noHardcodedSecretRule = {
+    id: 'no-hardcoded-secret',
+    name: '禁止硬编码密钥（AST 语义级）',
+    severity: 'FAIL',
+    description: '赋值给 secret/token/apiKey 等密钥类变量的长字符串字面量——比正则扫行误报率低',
+    checkCode(ctx) {
+        (0, walk_1.walk)(ctx.sourceFile, (node) => {
+            // const secret = "sk-..."：VariableDeclaration
+            if ((0, walk_1.is)(ctx, node, 'VariableDeclaration')) {
+                const decl = node;
+                const name = (0, walk_1.nodeText)(decl.name);
+                const init = decl.initializer;
+                if (name && (0, walk_1.is)(ctx, init, 'StringLiteral')) {
+                    const value = (0, walk_1.nodeText)(init) ?? '';
+                    if (isSecretLiteral(name, value)) {
+                        ctx.report(node, `变量 ${name} 被赋值为疑似真实密钥的字符串字面量`);
+                    }
+                }
+            }
+            // { apiKey: "sk-..." }：PropertyAssignment（对象字面量属性）
+            if ((0, walk_1.is)(ctx, node, 'PropertyAssignment')) {
+                const prop = node;
+                const name = (0, walk_1.nodeText)(prop.name);
+                const init = prop.initializer;
+                if (name && (0, walk_1.is)(ctx, init, 'StringLiteral')) {
+                    const value = (0, walk_1.nodeText)(init) ?? '';
+                    if (isSecretLiteral(name, value)) {
+                        ctx.report(node, `属性 ${name} 被赋值为疑似真实密钥的字符串字面量`);
+                    }
+                }
+            }
+        });
+    },
+};
+//# sourceMappingURL=no-hardcoded-secret.js.map

package/dist/ast/rules/no-insecure-url.d.ts

@@ -0,0 +1,3 @@
+import type { AstRule } from '../types';
+export declare const noInsecureUrlRule: AstRule;
+//# sourceMappingURL=no-insecure-url.d.ts.map

package/dist/ast/rules/no-insecure-url.js

@@ -0,0 +1,32 @@
+"use strict";
+// ============================================================
+// no-insecure-url.ts · 禁止 http:// 明文端点
+// v1.3.9（一）：AST 级扫字符串字面量——只报代码里的端点 URL，
+// 不碰注释与文档（pattern 规则会误伤）
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noInsecureUrlRule = void 0;
+const walk_1 = require("../walk");
+/** 本地/示例域名白名单——不是真实端点 */
+const SAFE_HOST = /^(localhost|127\.0\.0\.1|0\.0\.0\.0|example\.(com|org)|test|.*\.local)(:|$)/;
+exports.noInsecureUrlRule = {
+    id: 'no-insecure-url',
+    name: '禁止 http:// 明文端点',
+    severity: 'WARN',
+    description: '字符串字面量里的 http:// 端点（本地/示例域名除外）——明文传输可被中间人替换',
+    checkCode(ctx) {
+        (0, walk_1.walk)(ctx.sourceFile, (node) => {
+            if (!(0, walk_1.is)(ctx, node, 'StringLiteral'))
+                return;
+            const text = (0, walk_1.nodeText)(node) ?? '';
+            if (!/^http:\/\//.test(text))
+                return;
+            // 提取 host 部分做白名单
+            const host = text.replace(/^http:\/\//, '').split('/')[0] ?? '';
+            if (SAFE_HOST.test(host))
+                return;
+            ctx.report(node, `明文 http:// 端点（${host}）——生产端点应走 https`);
+        });
+    },
+};
+//# sourceMappingURL=no-insecure-url.js.map

package/dist/ast/rules/no-sql-string-concat.d.ts

@@ -0,0 +1,3 @@
+import type { AstRule } from '../types';
+export declare const noSqlStringConcatRule: AstRule;
+//# sourceMappingURL=no-sql-string-concat.d.ts.map

package/dist/ast/rules/no-sql-string-concat.js

@@ -0,0 +1,52 @@
+"use strict";
+// ============================================================
+// no-sql-string-concat.ts · 禁止 SQL 字符串拼接
+// v1.3.9（一）：query 类调用的参数若为「字面量 + 变量」拼接，
+// 即 SQL 注入入口（AST 级只报高危形态，比正则扫行准）
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noSqlStringConcatRule = void 0;
+const walk_1 = require("../walk");
+/** 查询类函数名模式 */
+const QUERY_FN = /(query|execute|exec|sql|raw)/i;
+/** 变量名提示来自用户输入（弱信号，仅用于 message 措辞） */
+const INPUT_HINT = /(req|input|param|user|body|query|ctx|data)/i;
+exports.noSqlStringConcatRule = {
+    id: 'no-sql-string-concat',
+    name: '禁止 SQL 字符串拼接',
+    severity: 'WARN',
+    description: 'query 类调用的参数含「字符串 + 非字面量」拼接——SQL 注入入口',
+    checkCode(ctx) {
+        (0, walk_1.walk)(ctx.sourceFile, (node) => {
+            if (!(0, walk_1.is)(ctx, node, 'CallExpression'))
+                return;
+            const callee = node.expression;
+            if (!(0, walk_1.is)(ctx, callee, 'Identifier') && !(0, walk_1.is)(ctx, callee, 'PropertyAccessExpression'))
+                return;
+            const fnName = (0, walk_1.nodeText)(callee.name)
+                ?? (0, walk_1.nodeText)(callee)
+                ?? '';
+            if (!QUERY_FN.test(fnName))
+                return;
+            const args = node.arguments ?? [];
+            for (const arg of args) {
+                if (!(0, walk_1.is)(ctx, arg, 'BinaryExpression'))
+                    continue;
+                const op = arg.operatorToken;
+                if (!(0, walk_1.is)(ctx, op, 'PlusToken'))
+                    continue;
+                // 操作数任一是非字面量 → 拼接变量
+                const hasDynamic = [arg].some(() => true);
+                void hasDynamic;
+                const left = arg.left;
+                const right = arg.right;
+                const dynamicSide = [left, right].find((side) => side && !(0, walk_1.is)(ctx, side, 'StringLiteral') && !(0, walk_1.is)(ctx, side, 'NumericLiteral'));
+                if (dynamicSide) {
+                    const hint = INPUT_HINT.test((0, walk_1.nodeText)(dynamicSide) ?? '') ? '（疑似用户输入）' : '';
+                    ctx.report(arg, `${fnName}() 的 SQL 由字符串拼接构造${hint}——改用参数化查询`);
+                }
+            }
+        });
+    },
+};
+//# sourceMappingURL=no-sql-string-concat.js.map

package/dist/ast/rules/semver.d.ts

@@ -0,0 +1,11 @@
+/** 解析版本串为可比数组（非法返回 null） */
+export declare function parseVersion(v: string): number[] | null;
+/** 比较两个版本：a<b 返回 -1，相等 0，a>b 返回 1（不可解析按相等处理） */
+export declare function compareVersions(a: string, b: string): number;
+/**
+ * 判断版本是否命中区间串。
+ * 区间语法：空格分隔的多个条件（AND），每条形如 <x / <=x / >x / >=x / =x / x（等于）。
+ * 例："=1.2.0" "<4.17.21" ">=1.3.0 <1.6.0"
+ */
+export declare function inRange(version: string, range: string): boolean;
+//# sourceMappingURL=semver.d.ts.map

package/dist/ast/rules/semver.js

@@ -0,0 +1,58 @@
+"use strict";
+// ============================================================
+// semver.ts · 最小语义化版本比较（ASI04 漏洞区间匹配用）
+// v1.3.9（一）：只支持 MAJOR.MINOR.PATCH 数字三元组 + 简单前缀
+// （如 1.2 / 1.x），prerelease/build 忽略——漏洞库区间足够用
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseVersion = parseVersion;
+exports.compareVersions = compareVersions;
+exports.inRange = inRange;
+/** 解析版本串为可比数组（非法返回 null） */
+function parseVersion(v) {
+    const m = /^(\d+)(?:\.(\d+))?(?:\.(\d+))?/.exec(v.trim());
+    if (!m)
+        return null;
+    return [Number(m[1]), Number(m[2] ?? 0), Number(m[3] ?? 0)];
+}
+/** 比较两个版本：a<b 返回 -1，相等 0，a>b 返回 1（不可解析按相等处理） */
+function compareVersions(a, b) {
+    const va = parseVersion(a);
+    const vb = parseVersion(b);
+    if (!va || !vb)
+        return 0;
+    for (let i = 0; i < 3; i++) {
+        const x = va[i] ?? 0;
+        const y = vb[i] ?? 0;
+        if (x !== y)
+            return x < y ? -1 : 1;
+    }
+    return 0;
+}
+/**
+ * 判断版本是否命中区间串。
+ * 区间语法：空格分隔的多个条件（AND），每条形如 <x / <=x / >x / >=x / =x / x（等于）。
+ * 例："=1.2.0" "<4.17.21" ">=1.3.0 <1.6.0"
+ */
+function inRange(version, range) {
+    const conditions = range.trim().split(/\s+/).filter(Boolean);
+    if (conditions.length === 0)
+        return false;
+    return conditions.every((cond) => {
+        const m = /^(<=|>=|<|>|=)?\s*(.+)$/.exec(cond);
+        if (!m || m[2] === undefined)
+            return false;
+        const op = m[1];
+        const ver = m[2];
+        const cmp = compareVersions(version, ver);
+        switch (op) {
+            case '<': return cmp < 0;
+            case '<=': return cmp <= 0;
+            case '>': return cmp > 0;
+            case '>=': return cmp >= 0;
+            case '=':
+            default: return cmp === 0;
+        }
+    });
+}
+//# sourceMappingURL=semver.js.map