@zhuma4/cli 4.0.0-alpha.1 → 4.3.0

package/rules/unified/cwe-134/zm-cpp-cwe134-format-string.yaml

@@ -0,0 +1,106 @@
+# Source: common | Cluster: N/A
+# CWE-134: C/C++ 格式化字符串漏洞检测规则
+# 逐码 ZhuMa V4.3 — C/C++ 规则库
+#
+# 检测 printf 系列函数中用户输入直接作为格式字符串参数传递，
+# 攻击者可通过 %n 写入任意地址或 %s/%x 泄露内存。
+
+rules:
+
+# ZM-CPP-CWE134-001: printf 用户可控格式字符串
+- id: zm-cpp-cwe134-format-string-001
+  severity: ERROR
+  message: |
+    检测到 printf 系列函数将变量/用户输入直接作为格式字符串参数，
+    而不是作为格式化参数传递。攻击者可通过 %n（写入任意地址）、
+    %s（读取栈）或 %x（泄露内存）进行攻击。
+
+    例如危险用法: printf(user_input) 而非 printf("%s", user_input)
+
+    修复方案：
+    - 始终使用字面量字符串作为格式参数: printf("%s", user_input)
+    - 永远不要将用户可控的数据作为 format 参数
+    - 编译器可启用 -Wformat-security 告警辅助检测
+  languages:
+    - c
+    - cpp
+  pattern-either:
+    - pattern: printf($FMT)
+    - pattern: fprintf($FP, $FMT)
+    - pattern: sprintf($BUF, $FMT)
+    - pattern: snprintf($BUF, $N, $FMT)
+    - pattern: dprintf($FD, $FMT)
+    - pattern: syslog($LEVEL, $FMT)
+  metadata:
+    cwe: "CWE-134: Uncontrolled Format String"
+    owasp: "A03:2021 - Injection"
+    category: security
+    precision: low
+    references:
+      - "https://cwe.mitre.org/data/definitions/134.html"
+      - "https://owasp.org/www-community/attacks/Format_string_attack"
+
+# ZM-CPP-CWE134-002: 用户输入直接作为格式参数
+- id: zm-cpp-cwe134-format-string-002
+  severity: ERROR
+  message: |
+    检测到用户输入变量直接作为 printf 系列函数的格式字符串参数。
+    即使经过了部分处理，只要用户输入仍可控制格式说明符（%s/%n/%x），
+    就存在格式化字符串漏洞。
+
+    修复方案：
+    - 硬编码格式字符串: printf("%s", user_input)
+    - 使用 puts() 或 fputs() 输出纯文本（不需要格式化）
+    - 验证和清理用户输入中的 % 字符
+  languages:
+    - c
+    - cpp
+  pattern-either:
+    - pattern: |
+        char $BUF[...];
+        ...
+        printf($BUF);
+    - pattern: |
+        char $BUF[...];
+        ...
+        fprintf($FP, $BUF);
+    - pattern: |
+        char $BUF[...];
+        ...
+        sprintf($DST, $BUF);
+  metadata:
+    cwe: "CWE-134: Uncontrolled Format String"
+    owasp: "A03:2021 - Injection"
+    category: security
+    precision: medium
+    references:
+      - "https://cwe.mitre.org/data/definitions/134.html"
+
+# ZM-CPP-CWE134-003: vprintf 系列格式字符串
+- id: zm-cpp-cwe134-format-string-003
+  severity: ERROR
+  message: |
+    检测到 vprintf/vfprintf/vsprintf 系列函数使用变量作为格式字符串。
+    这些可变参数版本的函数同样存在格式字符串注入风险。
+    如果格式字符串来源于用户输入或网络数据，攻击者可以读取栈内存、
+    写入任意地址甚至执行任意代码。
+
+    修复方案：
+    - 确保 format 参数始终是编译期确定的字面量字符串
+    - 如必须动态选择格式，使用白名单预定义的格式字符串集合
+    - 启用 -Wformat=2 编译器告警
+  languages:
+    - c
+    - cpp
+  pattern-either:
+    - pattern: vprintf($FMT, $AP)
+    - pattern: vfprintf($FP, $FMT, $AP)
+    - pattern: vsprintf($BUF, $FMT, $AP)
+    - pattern: vsnprintf($BUF, $N, $FMT, $AP)
+  metadata:
+    cwe: "CWE-134: Uncontrolled Format String"
+    owasp: "A03:2021 - Injection"
+    category: security
+    precision: low
+    references:
+      - "https://cwe.mitre.org/data/definitions/134.html"

package/rules/unified/cwe-190/zm-cpp-cwe190-integer-overflow.yaml

@@ -0,0 +1,93 @@
+# Source: common | Cluster: N/A
+# CWE-190: C/C++ 整数溢出检测规则
+# 逐码 ZhuMa V4.3 — C/C++ 规则库
+#
+# 检测可能导致整数溢出的算术运算、类型转换和内存分配计算。
+
+rules:
+
+# ZM-CPP-CWE190-001: malloc 整数溢出导致不足分配
+- id: zm-cpp-cwe190-integer-overflow-001
+  severity: WARNING
+  message: |
+    检测到 malloc/calloc 的参数涉及算术运算（乘/加），可能发生整数溢出。
+    如果 n * sizeof(T) 的结果溢出为小值，
+    malloc 将分配不足的内存，后续写入将导致堆缓冲区溢出。
+
+    修复方案：
+    - 使用 calloc(nmemb, size) 代替 malloc(n * sizeof(T))，calloc 内部检查溢出
+    - 在乘法前检查溢出: if (n > SIZE_MAX / sizeof(T)) { /* 错误 */ }
+    - 使用 __builtin_mul_overflow() (GCC/Clang) 检测溢出
+    - C++: 使用 std::vector<T>(n) 自动管理
+  languages:
+    - c
+    - cpp
+  pattern-either:
+    - pattern: malloc($A * $B)
+    - pattern: malloc($A + $B)
+    - pattern: calloc($A, $B)
+  metadata:
+    cwe: "CWE-190: Integer Overflow or Wraparound"
+    owasp: "A06:2021 - Vulnerable and Outdated Components"
+    category: security
+    precision: low
+    references:
+      - "https://cwe.mitre.org/data/definitions/190.html"
+      - "https://wiki.sei.cmu.edu/confluence/display/c/INT30-C.+Ensure+that+unsigned+integer+operations+do+not+wrap"
+
+# ZM-CPP-CWE190-002: 有符号整数溢出 (C++)
+- id: zm-cpp-cwe190-integer-overflow-002
+  severity: WARNING
+  message: |
+    检测到有符号整数进行加/减/乘运算，可能发生未定义行为的溢出。
+    C/C++ 标准规定有符号整数溢出是未定义行为 (UB)，
+    编译器可能基于"不会溢出"的假设进行优化，导致意外行为和安全漏洞。
+
+    修复方案：
+    - 使用无符号类型进行模运算（行为定义明确）
+    - 运算前检查范围: if (a > INT_MAX - b) { /* 溢出 */ }
+    - C23/C++23: 使用 ckd_add/ckd_mul 等内置溢出检查函数
+    - 使用编译器内置 __builtin_add_overflow() 系列
+  languages:
+    - c
+    - cpp
+  patterns:
+    - pattern: $A + $B
+    - pattern: $A * $B
+    - pattern: $A - $B
+  metadata:
+    cwe: "CWE-190: Integer Overflow or Wraparound"
+    owasp: "A06:2021 - Vulnerable and Outdated Components"
+    category: security
+    precision: very-low
+    references:
+      - "https://cwe.mitre.org/data/definitions/190.html"
+
+# ZM-CPP-CWE190-003: 宽类型到窄类型隐式截断
+- id: zm-cpp-cwe190-integer-overflow-003
+  severity: WARNING
+  message: |
+    检测到较大整数类型隐式截断为较小类型（如 size_t → int、uint32_t → uint16_t）。
+    截断可能丢失高位数据，导致逻辑错误或缓冲区大小计算错误。
+    在安全敏感的代码中（如分配大小计算、循环边界），截断可引发缓冲区溢出。
+
+    修复方案：
+    - 显式类型转换并检查范围
+    - 使用 static_cast 并在转换前做范围检查
+    - 使用相同或更大的类型避免截断
+    - 启用编译器告警: -Wconversion -Wsign-conversion
+  languages:
+    - c
+    - cpp
+  pattern-either:
+    - pattern: (int)$LONG_VAR
+    - pattern: (unsigned short)$LONG_VAR
+    - pattern: (char)$INT_VAR
+  metadata:
+    cwe: "CWE-190: Integer Overflow or Wraparound"
+    owasp: "A06:2021 - Vulnerable and Outdated Components"
+    category: security
+    precision: very-low
+    references:
+      - "https://cwe.mitre.org/data/definitions/190.html"
+      - "https://cwe.mitre.org/data/definitions/192.html"

package/rules/unified/cwe-20/zm-cpp-cwe20-input-validation.yaml

@@ -0,0 +1,92 @@
+# Source: common | Cluster: N/A
+# CWE-20: C/C++ 输入验证缺失检测规则
+# 逐码 ZhuMa V4.3 — C/C++ 规则库
+#
+# 检测用户输入未经验证直接使用的模式，
+# 包括网络数据、环境变量、命令行参数等未检查边界。
+
+rules:
+
+# ZM-CPP-CWE20-001: recv/read返回值未检查
+- id: zm-cpp-cwe20-input-validation-001
+  severity: WARNING
+  message: |
+    检测到 recv()/read() 的返回值未用于验证实际读取的字节数。
+    未验证接收长度可能导致缓冲区溢出（数据超预期）
+    或不完整数据处理（数据量不足）。
+
+    修复方案：
+    - 检查返回值: ssize_t n = recv(sock, buf, sizeof(buf), 0); if (n < 0 || n > sizeof(buf)) { /* 错误 */ }
+    - 对于流式协议，循环读取直到收到完整消息
+    - 验证返回值不大于目标缓冲区大小
+    - 使用 recv() 返回的 n 作为后续处理的数据长度
+  languages:
+    - c
+    - cpp
+  pattern-either:
+    - pattern: recv($SOCK, $BUF, $LEN, $FLAGS)
+    - pattern: recvfrom($SOCK, $BUF, $LEN, $FLAGS, $FROM, $FROMLEN)
+    - pattern: read($FD, $BUF, $N)
+  metadata:
+    cwe: "CWE-20: Improper Input Validation"
+    owasp: "A03:2021 - Injection"
+    category: security
+    precision: very-low
+    references:
+      - "https://cwe.mitre.org/data/definitions/20.html"
+      - "https://wiki.sei.cmu.edu/confluence/display/c/STR31-C.+Guarantee+that+storage+for+strings+has+sufficient+space+for+character+data+and+the+null+terminator"
+
+# ZM-CPP-CWE20-002: atoi/atol/atof无错误检测
+- id: zm-cpp-cwe20-input-validation-002
+  severity: WARNING
+  message: |
+    检测到使用 atoi()/atol()/atof() 转换用户输入。这些函数在输入无法解析时
+    返回 0 或产生未定义行为，无法区分 "0" 和错误输入。可能导致安全逻辑绕过。
+
+    修复方案：
+    - 使用 strtol()/strtoul()/strtod() 并检查 endptr 和 errno
+    - 使用 sscanf() 并检查返回值是否为 1（成功解析 1 个值）
+    - C++: 使用 std::stoi()/std::stol() 捕获异常
+    - C++17: 使用 std::from_chars() 获得明确错误信息
+  languages:
+    - c
+    - cpp
+  pattern-either:
+    - pattern: atoi($STR)
+    - pattern: atol($STR)
+    - pattern: atof($STR)
+    - pattern: atoll($STR)
+  metadata:
+    cwe: "CWE-20: Improper Input Validation"
+    owasp: "A03:2021 - Injection"
+    category: security
+    precision: high
+    references:
+      - "https://cwe.mitre.org/data/definitions/20.html"
+      - "https://wiki.sei.cmu.edu/confluence/display/c/ERR34-C.+Detect+errors+when+converting+a+string+to+a+number"
+
+# ZM-CPP-CWE20-003: memcpy长度来源于不可信源
+- id: zm-cpp-cwe20-input-validation-003
+  severity: WARNING
+  message: |
+    检测到 memcpy() 调用使用了变量作为长度参数。如果该长度值来源于
+    不可信输入（网络数据、用户输入、文件内容等）且未验证，
+    可能导致缓冲区溢出。
+
+    修复方案：
+    - 验证长度参数不超过目标缓冲区大小: if (n > sizeof(dst)) { /* 错误 */ }
+    - 使用 memcpy_s() (C11 Annex K) 自动检查
+    - 验证长度参数不超过源缓冲区大小
+    - 使用 memmove() 如果源和目标可能重叠
+  languages:
+    - c
+    - cpp
+  patterns:
+    - pattern: memcpy($DST, $SRC, $N)
+  metadata:
+    cwe: "CWE-20: Improper Input Validation"
+    owasp: "A03:2021 - Injection"
+    category: security
+    precision: very-low
+    references:
+      - "https://cwe.mitre.org/data/definitions/20.html"

package/rules/unified/cwe-20/zm-js-cwe20-websocket-validation.yaml

@@ -0,0 +1,25 @@
+# Source: common | Cluster: N/A
+# CWE-20: WebSocket ws.on('message') 无输入验证
+# 逐码 ZhuMa V4.3 — JS/TS 通用规则库
+
+rules:
+
+- id: zm-js-websocket-001
+  severity: WARNING
+  message: >
+    WebSocket ws.on('message') 事件处理器中直接使用消息数据而未做输入验证，
+    攻击者可发送恶意格式数据导致注入、拒绝服务或未预期行为。
+    修复: 对 WebSocket 消息做 JSON Schema 验证、类型检查或长度限制。
+  languages:
+    - javascript
+    - typescript
+  pattern: |
+    $WS.on('message', ($DATA) => {
+      ...
+    })
+  metadata:
+    cwe: "CWE-20: Improper Input Validation"
+    owasp: "A03:2021 - Injection"
+    category: security
+    precision: low
+    confidence: low

package/rules/unified/cwe-20/zm-rust-cwe20-input-validation.yaml

@@ -0,0 +1,124 @@
+# Source: common | Cluster: N/A
+# CWE-20: Rust 输入验证缺失检测
+# 逐码 ZhuMa V4.3 — Rust 通用规则库
+# 检测: 用户输入未经验证直接使用、unwrap/expect 在用户输入上
+
+rules:
+
+# ZM-RUST-INPUT-001: unwrap() 用于用户输入处理
+- id: zm-rust-cwe20-input-validation-001
+  severity: ERROR
+  message: |
+    检测到对用户可控输入（如 env::args、stdin、HTTP 请求参数）
+    直接调用 .unwrap()。用户输入可能为 None/Err，unwrap() 会导致 panic，
+    造成拒绝服务（DoS），且未处理错误暴露内部信息。
+
+    修复方案:
+    1. 使用 ? 操作符传播错误:
+       let value = parse_input()?;
+    2. 使用 match 或 unwrap_or_else 优雅处理:
+       let value = parse_input().unwrap_or_else(|e| {
+           eprintln!("Invalid input: {}", e);
+           std::process::exit(1);
+       });
+    3. 对用户输入进行格式和范围校验后再处理
+    4. 不要在生产代码中对用户输入使用 unwrap()/expect()
+  languages:
+    - rust
+  pattern-either:
+    - pattern: std::env::args().nth(...).unwrap()
+    - pattern: env::args().nth(...).unwrap()
+    - pattern: $INPUT.unwrap()
+  metadata:
+    cwe: "CWE-20: Improper Input Validation"
+    severity: ERROR
+    precision: low
+    category: input-validation
+    likelihood: HIGH
+    impact: MEDIUM
+    owasp: "A03:2021 - Injection"
+
+# ZM-RUST-INPUT-002: expect() 用于用户输入处理
+- id: zm-rust-cwe20-input-validation-002
+  severity: WARNING
+  message: |
+    检测到对用户输入调用 .expect()。expect() 失败时 panic 并输出自定义消息，
+    可能暴露内部逻辑细节（如数据库名、路径结构）。
+
+    修复方案:
+    1. 使用 ? 操作符传播错误
+    2. 使用 match/if let 处理，提供安全的错误消息
+    3. 避免错误消息中包含内部实现细节
+  languages:
+    - rust
+  pattern: $INPUT.expect(...)
+  metadata:
+    cwe: "CWE-20: Improper Input Validation"
+    severity: WARNING
+    precision: low
+    category: input-validation
+    likelihood: HIGH
+    impact: LOW
+    owasp: "A03:2021 - Injection"
+
+# ZM-RUST-INPUT-003: parse() 结果未校验直接使用
+- id: zm-rust-cwe20-input-validation-003
+  severity: ERROR
+  message: |
+    检测到从用户输入解析后调用 .unwrap() 直接使用结果。
+    如 parse::<i32>().unwrap() 在遇到非数字字符串时会 panic，
+    攻击者可构造恶意输入触发 crash 实现 DoS。
+
+    修复方案:
+    1. 使用 match 处理 parse 结果:
+       let value = match input.parse::<i32>() {
+           Ok(v) if v > 0 => v,
+           _ => return Err("Invalid number"),
+       };
+    2. 使用 .ok() 或 .unwrap_or() 提供默认值
+    3. 对输入做范围校验
+  languages:
+    - rust
+  pattern-either:
+    - pattern: $INPUT.parse::<$TYPE>().unwrap()
+    - pattern: $INPUT.parse().unwrap()
+  metadata:
+    cwe: "CWE-20: Improper Input Validation"
+    severity: ERROR
+    precision: medium
+    category: input-validation
+    likelihood: HIGH
+    impact: MEDIUM
+    owasp: "A03:2021 - Injection"
+
+# ZM-RUST-INPUT-004: read_line() 结果未校验
+- id: zm-rust-cwe20-input-validation-004
+  severity: WARNING
+  message: |
+    检测到 stdin().read_line() 后直接使用结果，未校验读取是否成功
+    或内容是否合法。read_line 可能返回 I/O 错误。
+
+    修复方案:
+    1. 检查 read_line 的结果: 
+       io::stdin().read_line(&mut input)?;
+    2. 使用 trim() 去除换行符
+    3. 对读取内容进行长度和内容校验
+  languages:
+    - rust
+  pattern-either:
+    - pattern: |
+        $IO.stdin().read_line(&mut $BUF)
+        ...
+        $BUF
+    - pattern: |
+        io::stdin().read_line(&mut $BUF)
+    - pattern: |
+        std::io::stdin().read_line(&mut $BUF)
+  metadata:
+    cwe: "CWE-20: Improper Input Validation"
+    severity: WARNING
+    precision: low
+    category: input-validation
+    likelihood: MEDIUM
+    impact: MEDIUM
+    owasp: "A03:2021 - Injection"

package/rules/unified/cwe-200/zm-js-cwe200-nestjs-env.yaml

@@ -0,0 +1,22 @@
+# Source: common | Cluster: N/A
+# CWE-200: NestJS ConfigModule.forRoot 导入 .env 文件
+# 逐码 ZhuMa V4.3 — JS/TS NestJS 规则库
+
+rules:
+
+- id: zm-js-nestjs-env-001
+  severity: WARNING
+  message: >
+    NestJS ConfigModule.forRoot() 导入 .env 文件，可能将敏感环境变量暴露或误提交。
+    修复: 确保 .env 文件在 .gitignore 中，使用 ConfigService 按需注入而非全局暴露。
+  languages:
+    - javascript
+    - typescript
+  pattern: |
+    ConfigModule.forRoot({..., envFilePath: ..., ...})
+  metadata:
+    cwe: "CWE-200: Exposure of Sensitive Information to an Unauthorized Actor"
+    owasp: "A04:2021 - Insecure Design"
+    category: security
+    precision: medium
+    confidence: medium

package/rules/unified/cwe-200/zm-py-cwe200-info-leak-redirect.yaml

@@ -0,0 +1,77 @@
+# Source: common | Cluster: N/A
+# CWE-200: Flask jsonify 含敏感数据 / HttpResponseRedirect 含用户输入
+# 逐码 ZhuMa V4.3 — Python 信息泄露/开放重定向规则库
+# 检测: jsonify泄露敏感对象、redirect用户可控参数
+
+rules:
+
+# ZM-PY-FLASK-INFOLK-001: jsonify含敏感数据
+- id: zm-py-flask-info-leak-001
+  severity: WARNING
+  message: |
+    检测到 Flask jsonify() 返回了整个对象或异常信息，可能泄露敏感数据。
+    直接返回ORM对象可能包含密码哈希、内部ID、关联用户数据等。
+
+    修复方案:
+    1. 使用 marshmallow / pydantic 序列化，显式声明暴露的字段
+    2. 对ORM对象使用 to_dict() 方法手动选择字段
+    3. 生产环境关闭 DEBUG 和 TRAP_HTTP_EXCEPTIONS
+    4. 自定义错误处理器返回通用错误信息，不暴露堆栈
+  languages:
+    - python
+  pattern-either:
+    - pattern: flask.jsonify($OBJ.__dict__)
+    - pattern: jsonify($OBJ.__dict__)
+    - pattern: flask.jsonify(vars($OBJ))
+    - pattern: jsonify(vars($OBJ))
+    - pattern: flask.jsonify(str(e))
+    - pattern: jsonify(str(e))
+  metadata:
+    cwe: "CWE-200: Exposure of Sensitive Information to an Unauthorized Actor"
+    severity: WARNING
+    precision: high
+    category: information-leak
+    framework: flask
+    likelihood: MEDIUM
+    impact: MEDIUM
+    owasp: "A01:2021 - Broken Access Control"
+    references:
+      - "https://flask.palletsprojects.com/en/stable/api/#flask.json.jsonify"
+
+# ZM-PY-REDIRECT-001: HttpResponseRedirect含用户输入(开放重定向)
+- id: zm-py-redirect-open-001
+  severity: WARNING
+  message: |
+    检测到 HttpResponseRedirect / redirect() 的URL参数来自HTTP请求。
+    攻击者可构造恶意URL实现钓鱼攻击: /login?next=http://evil.com/login。
+
+    修复方案:
+    1. 使用白名单域名校验: url_has_allowed_host_and_scheme()
+    2. Django: from django.utils.http import url_has_allowed_host_and_scheme
+    3. Flask: 使用url_for()生成URL而非用户输入
+    4. 若必须支持redirect，做域名白名单校验
+  languages:
+    - python
+  pattern-either:
+    - pattern: HttpResponseRedirect(request.args.get(...))
+    - pattern: HttpResponseRedirect(request.GET.get(...))
+    - pattern: HttpResponseRedirect(request.POST.get(...))
+    - pattern: HttpResponseRedirect(request.build_absolute_uri())
+    - pattern: django.http.HttpResponseRedirect(request.args.get(...))
+    - pattern: django.http.HttpResponseRedirect(request.GET.get(...))
+    - pattern: redirect(request.args.get(...))
+    - pattern: redirect(request.form.get(...))
+    - pattern: redirect(request.values.get(...))
+    - pattern: flask.redirect(request.args.get(...))
+    - pattern: flask.redirect(request.form.get(...))
+    - pattern: flask.redirect(request.values.get(...))
+  metadata:
+    cwe: "CWE-601: URL Redirection to Untrusted Site (Open Redirect)"
+    severity: WARNING
+    precision: high
+    category: open-redirect
+    likelihood: MEDIUM
+    impact: MEDIUM
+    owasp: "A01:2021 - Broken Access Control"
+    references:
+      - "https://docs.djangoproject.com/en/stable/ref/utils/#django.utils.http.url_has_allowed_host_and_scheme"

package/rules/unified/cwe-22/cwe-22-path-traversal.yaml

@@ -0,0 +1,48 @@
+# Source: common | Cluster: N/A
+# CWE-22: 路径遍历检测规则
+# 逐码 ZhuMa V4.0 Alpha — 通用规则库
+
+rules:
+
+# ZM-JAVA-PT-001: File 构造含用户输入 + 无 validateFilename
+- id: zm-java-pt-001
+  severity: HIGH
+  message: |
+    检测到使用用户输入构造文件路径，但未校验路径 (未调用 getCanonicalPath 或 contains("..") 检查)。
+    攻击者可注入 ../ 进行路径遍历访问任意文件。
+    应使用 Path.normalize() + 检查路径前缀是否在允许目录内。
+  languages:
+    - java
+  pattern-either:
+    - pattern: |
+        new FileInputStream($BASE + $PARAM);
+    - pattern: |
+        new FileReader($BASE + $PARAM);
+    - pattern: |
+        new File($BASE + $PARAM);
+    - pattern: |
+        Files.readAllBytes(Paths.get($BASE + $PARAM));
+    - pattern: |
+        Files.newInputStream(Paths.get($BASE + $PARAM));
+  metadata:
+    cwe: "CWE-22: Path Traversal"
+    owasp: "A01:2021 - Broken Access Control"
+    precision: medium
+
+# ZM-JAVA-PT-002: 直接使用用户输入作为文件路径
+- id: zm-java-pt-002
+  severity: MEDIUM
+  message: |
+    直接使用用户输入作为文件路径参数，存在路径遍历风险。
+    应对输入进行白名单校验或规范化路径后验证前缀。
+  languages:
+    - java
+  pattern-either:
+    - pattern: |
+        new FileInputStream($REQ.getParameter(...));
+    - pattern: |
+        new FileReader($REQ.getParameter(...));
+  metadata:
+    cwe: "CWE-22: Path Traversal"
+    owasp: "A01:2021 - Broken Access Control"
+    precision: high

package/rules/unified/cwe-22/zm-cs-cwe22-path-traversal.yaml

@@ -0,0 +1,92 @@
+# Source: common | Cluster: N/A
+# CWE-22: C# 路径穿越检测规则
+# 逐码 ZhuMa V4.3 — C# 规则库
+#
+# 检测 .NET 中用户输入用于文件路径构造导致的路径穿越漏洞。
+
+rules:
+
+# ZM-CS-CWE22-001: Path.Combine 与用户输入 (路径穿越)
+- id: zm-cs-cwe22-path-traversal-001
+  severity: ERROR
+  message: |
+    检测到 Path.Combine() 接受用户可控参数构造文件路径。
+    攻击者可传入 "../" 序列穿越目录边界，读取/写入任意文件。
+
+    例如: Path.Combine(basePath, "../../etc/passwd") 
+    可能解析为 /etc/passwd，完全绕过目录限制。
+
+    修复方案：
+    - 使用 Path.GetFullPath() 解析规范化路径后验证是否在允许的基目录内
+    - 验证解析后的路径以基目录开始: resolvedPath.StartsWith(basePath)
+    - 对文件名进行白名单字符校验（禁止 "../"、"\\"等）
+    - 使用 PhysicalFileProvider 的 GetFileInfo() 限制访问范围
+  languages:
+    - csharp
+  pattern-either:
+    - pattern: Path.Combine($BASE, $USERPARAM)
+    - pattern: Path.Combine($BASE, $REQ[...])
+    - pattern: $PATH = Path.Combine($BASE, $USERPARAM)
+    - pattern: Path.Combine($BASE, ... + $USERPARAM)
+  metadata:
+    cwe: "CWE-22: Path Traversal"
+    owasp: "A01:2021 - Broken Access Control"
+    category: security
+    precision: medium
+    references:
+      - "https://cwe.mitre.org/data/definitions/22.html"
+      - "https://learn.microsoft.com/en-us/dotnet/standard/io/file-path-formats"
+
+# ZM-CS-CWE22-002: File.ReadAllText 路径来自输入
+- id: zm-cs-cwe22-path-traversal-002
+  severity: ERROR
+  message: |
+    检测到文件操作函数使用变量或参数作为文件路径参数。
+    如果该变量来源于用户输入（HTTP 请求、URL 参数等）且未验证，
+    攻击者可通过路径穿越读取任意文件（如 web.config、appsettings.json）。
+
+    修复方案：
+    - 对用户输入的文件名进行白名单验证
+    - 使用 Path.GetFileName() 仅提取文件名部分
+    - 验证 Path.GetFullPath(path).StartsWith(allowedBasePath)
+    - 使用 IFileProvider 限制文件访问范围
+  languages:
+    - csharp
+  pattern-either:
+    - pattern: File.ReadAllText($PATH)
+    - pattern: File.ReadAllBytes($PATH)
+    - pattern: File.OpenRead($PATH)
+    - pattern: File.Open($PATH, ...)
+    - pattern: System.IO.File.ReadAllText($PATH)
+  metadata:
+    cwe: "CWE-22: Path Traversal"
+    owasp: "A01:2021 - Broken Access Control"
+    category: security
+    precision: very-low
+    references:
+      - "https://cwe.mitre.org/data/definitions/22.html"
+
+# ZM-CS-CWE22-003: Server.MapPath 路径穿越
+- id: zm-cs-cwe22-path-traversal-003
+  severity: ERROR
+  message: |
+    检测到 Server.MapPath() 接受用户输入。Server.MapPath 将虚拟路径
+    映射为物理路径，如果接收用户可控的相对路径，攻击者可能映射到
+    应用程序目录外的敏感文件。
+
+    修复方案：
+    - 验证输入不包含 ".." 或 URL 编码的 ".." (如 %2e%2e)
+    - 对路径进行规范化后验证: Path.GetFullPath(Server.MapPath(input))
+    - 使用 AllowVideo/AllowImage 等 IIS 请求过滤规则
+  languages:
+    - csharp
+  pattern-either:
+    - pattern: Server.MapPath($INPUT)
+    - pattern: HttpContext.Current.Server.MapPath($INPUT)
+  metadata:
+    cwe: "CWE-22: Path Traversal"
+    owasp: "A01:2021 - Broken Access Control"
+    category: security
+    precision: medium
+    references:
+      - "https://cwe.mitre.org/data/definitions/22.html"