@zhuma4/cli 4.0.0-alpha.1 → 4.3.0

package/rules/unified/cwe-74/zm-java-cwe74-host-header-injection.yaml

@@ -0,0 +1,64 @@
+# Source: common | Cluster: N/A
+# CWE-74: Host Header 注入检测
+# 逐码 ZhuMa V4.3 — 输入验证专项
+
+rules:
+
+# ZM-JAVA-CWE74-HOSTHEADER-001: Host Header 注入
+- id: zm-java-cwe74-hostheader-001
+  severity: WARNING
+  message: |
+    使用 request.getServerName() 或 request.getHeader("Host") 构造 URL，
+    Host Header 可被攻击者伪造，导致密码重置邮件中的链接指向攻击者控制的域名。
+    修复: 1. 不要在业务逻辑中使用 Host Header 构造 URL
+    2. 使用配置的域名常量替代 request.getServerName()
+    3. 若必须使用，对 Host Header 做白名单校验
+  languages:
+    - java
+  pattern-either:
+    - pattern: |
+        $URL = "http://" + $REQ.getServerName() + $PATH
+    - pattern: |
+        $URL = "https://" + $REQ.getServerName() + $PATH
+    - pattern: |
+        $URL = "http://" + $REQ.getHeader("Host") + $PATH
+    - pattern: |
+        $URL = $REQ.getScheme() + "://" + $REQ.getServerName() + $PATH
+    - pattern: |
+        $URL = $SCHEME + "://" + $REQ.getHeader("Host") + $PATH
+  metadata:
+    cwe: "CWE-74: Improper Neutralization of Special Elements in Output Used by a Downstream Component ('Injection')"
+    severity: WARNING
+    precision: high
+    category: injection
+    owasp: "A03:2021 - Injection"
+    likelihood: MEDIUM
+    impact: HIGH
+    tags: [host-header-injection, password-reset]
+
+# ZM-JAVA-CWE74-HOSTHEADER-002: X-Forwarded-Host Header 注入
+- id: zm-java-cwe74-hostheader-002
+  severity: WARNING
+  message: |
+    使用 X-Forwarded-Host 请求头构造 URL，攻击者可通过反向代理注入该 Header
+    篡改生成的链接指向恶意站点。
+    修复: 1. 不使用 X-Forwarded-Host 构造 URL 2. 对 Header 值做白名单校验
+    3. 使用 server.forward-headers-strategy=framework (Spring Boot 2.2+) 统一处理。
+  languages:
+    - java
+  pattern-either:
+    - pattern: |
+        $URL = $SCHEME + $REQ.getHeader("X-Forwarded-Host") + $PATH
+    - pattern: |
+        $URL = "https://" + $REQ.getHeader("X-Forwarded-Host") + $PATH
+    - pattern: |
+        $URL = $REQ.getHeader("X-Forwarded-Host") + $PATH
+  metadata:
+    cwe: "CWE-74: Improper Neutralization of Special Elements in Output Used by a Downstream Component ('Injection')"
+    severity: WARNING
+    precision: very-high
+    category: injection
+    owasp: "A03:2021 - Injection"
+    likelihood: MEDIUM
+    impact: HIGH
+    tags: [host-header-injection]

package/rules/unified/cwe-770/cwe-770-resource-exhaustion.yaml

@@ -0,0 +1,45 @@
+# Source: common | Cluster: N/A
+# CWE-770: 资源耗尽 (DoS) 检测规则
+# 逐码 ZhuMa V4.0 Alpha — 通用规则库
+
+rules:
+
+# ZM-JAVA-RE-001: 无限循环无超时/退出条件
+- id: zm-java-re-001
+  severity: MEDIUM
+  message: |
+    检测到 while(true) 循环未设置超时或退出条件。
+    可能导致 CPU 资源耗尽造成拒绝服务。
+    应添加最大迭代次数限制或超时退出机制。
+  languages:
+    - java
+  pattern-either:
+    - pattern: |
+        while (true) {
+          ...
+        }
+    - pattern: |
+        while (1 == 1) {
+          ...
+        }
+  metadata:
+    cwe: "CWE-770: Allocation of Resources Without Limits or Throttling"
+    owasp: "A05:2021 - Security Misconfiguration"
+    precision: low
+
+# ZM-JAVA-RE-002: 无限制读取输入流
+- id: zm-java-re-002
+  severity: LOW
+  message: |
+    检测到未限制大小的输入流读取，可能导致内存溢出 DoS。
+    应限制读取字节数或使用缓冲区分块处理。
+  languages:
+    - java
+  pattern-either:
+    - pattern: |
+        byte[] $BUF = new byte[$INPUT.available()];
+        $INPUT.read($BUF);
+  metadata:
+    cwe: "CWE-770: Allocation of Resources Without Limits or Throttling"
+    owasp: "A05:2021 - Security Misconfiguration"
+    precision: medium

package/rules/unified/cwe-770/zm-go-cwe770-redos.yaml

@@ -0,0 +1,79 @@
+# Source: common | Cluster: N/A
+# CWE-770: Go regexp/syntax ReDoS 检测
+# 逐码 ZhuMa V4.3 — Go 通用规则库
+# 检测: regexp无长度限制、regexp.Compile/Match含用户输入
+
+rules:
+
+# ZM-GO-REDOS-001: regexp 无输入长度限制 (ReDoS)
+- id: zm-go-redos-001
+  severity: WARNING
+  message: |
+    检测到使用 regexp.Match / regexp.Compile 进行正则匹配，
+    但未对输入长度做限制。恶意构造的超长字符串配合回溯量词
+    (如 (a+)+b) 可导致指数级回溯，造成CPU耗尽(ReDoS)。
+
+    修复方案:
+    1. 对输入长度做限制: if len(input) > 1000 { return error }
+    2. 使用 regexp.MatchString + 限制输入大小
+    3. 使用 RE2 风格的正则(Go默认)避免嵌套量词: (a+)+ → a+
+    4. 设置超时: 使用 context.WithTimeout 包装正则操作
+    5. 对用户提供的正则表达式做 ReDoS 检测(如使用 rxxr2 库)
+  languages:
+    - go
+  pattern-either:
+    - pattern: regexp.MatchString($PATTERN, $INPUT)
+    - pattern: regexp.Match($PATTERN, []byte($INPUT))
+    - pattern: $RE.MatchString($INPUT)
+    - pattern: $RE.FindAllString($INPUT, -1)
+    - pattern: regexp.MustCompile($PATTERN).MatchString($INPUT)
+    - pattern: regexp.MustCompile($PATTERN).FindAllString($INPUT, -1)
+    - pattern: regexp.Compile($PATTERN)
+  metadata:
+    cwe: "CWE-770: Allocation of Resources Without Limits or Throttling"
+    severity: WARNING
+    precision: medium
+    category: redos
+    likelihood: MEDIUM
+    impact: HIGH
+    owasp: "A05:2021 - Security Misconfiguration"
+    references:
+      - "https://pkg.go.dev/regexp"
+
+# ZM-GO-REDOS-002: 用户提供正则表达式
+- id: zm-go-redos-002
+  severity: WARNING
+  message: |
+    检测到 regexp.Compile / regexp.MustCompile 使用来自HTTP请求的模式。
+    攻击者可传入恶意正则表达式(如 (a+)+b)造成ReDoS。
+
+    修复方案:
+    1. 禁止用户提供正则表达式模式
+    2. 对用户提供的模式做长度限制和复杂度检测
+    3. 使用预编译的正则表达式白名单，不允许用户自定义模式
+    4. 使用 rsc.io/regexp2 或 golang.org/x/exp/regexp 提供超时控制
+  languages:
+    - go
+  pattern-either:
+    - pattern: regexp.Compile(c.Query($KEY))
+    - pattern: regexp.Compile(c.Param($KEY))
+    - pattern: regexp.Compile(c.PostForm($KEY))
+    - pattern: regexp.Compile(ctx.QueryParam($KEY))
+    - pattern: regexp.Compile(ctx.Param($KEY))
+    - pattern: regexp.Compile(ctx.FormValue($KEY))
+    - pattern: regexp.MustCompile(c.Query($KEY))
+    - pattern: regexp.MustCompile(c.Param($KEY))
+    - pattern: regexp.MustCompile(ctx.QueryParam($KEY))
+    - pattern: regexp.Compile(r.URL.Query().Get($KEY))
+    - pattern: regexp.Compile(r.FormValue($KEY))
+    - pattern: regexp.MustCompile(r.URL.Query().Get($KEY))
+  metadata:
+    cwe: "CWE-770: Allocation of Resources Without Limits or Throttling"
+    severity: WARNING
+    precision: high
+    category: redos
+    likelihood: MEDIUM
+    impact: HIGH
+    owasp: "A03:2021 - Injection"
+    references:
+      - "https://pkg.go.dev/regexp"

package/rules/unified/cwe-770/zm-js-cwe770-nestjs-validator.yaml

@@ -0,0 +1,27 @@
+# Source: common | Cluster: N/A
+# CWE-770: NestJS class-validator 缺少类型校验装饰器
+# 逐码 ZhuMa V4.3 — JS/TS NestJS 规则库
+
+rules:
+
+- id: zm-js-nestjs-dto-001
+  severity: WARNING
+  message: >
+    NestJS DTO 类中属性缺少 @IsString()/@IsInt()/@IsNumber() 等 class-validator
+    类型校验装饰器，可能导致资源耗尽(如超大字符串)。
+    修复: 为每个 DTO 属性添加 @IsString()/@IsInt()/@MaxLength() 等校验装饰器。
+  languages:
+    - javascript
+    - typescript
+  pattern: |
+    class $DTO {
+      ...
+      $FIELD: string;
+      ...
+    }
+  metadata:
+    cwe: "CWE-770: Allocation of Resources Without Limits or Throttling"
+    owasp: "A05:2021 - Security Misconfiguration"
+    category: security
+    precision: low
+    confidence: low

package/rules/unified/cwe-78/cwe-78-os-command-injection.yaml

@@ -0,0 +1,44 @@
+# Source: common | Cluster: N/A
+# CWE-78: OS 命令注入检测规则
+# 逐码 ZhuMa V4.0 Alpha — 通用规则库
+
+rules:
+
+# ZM-JAVA-OSCI-001: Runtime.exec 字符串拼接或用户输入
+- id: zm-java-osci-001
+  severity: CRITICAL
+  message: |
+    检测到 Runtime.getRuntime().exec() 使用字符串拼接构造系统命令。
+    攻击者可注入额外命令 (如 ; rm -rf /) 导致任意代码执行。
+    应使用 ProcessBuilder + 参数数组，避免 Shell 解析。
+  languages:
+    - java
+  pattern-either:
+    - pattern: |
+        String $CMD = ... + $PARAM;
+        ...
+        Runtime.getRuntime().exec($CMD);
+    - pattern: |
+        Runtime.getRuntime().exec($CMD + $PARAM);
+    - pattern: |
+        Runtime.getRuntime().exec($VAR);
+  metadata:
+    cwe: "CWE-78: OS Command Injection"
+    owasp: "A03:2021 - Injection"
+    precision: medium
+
+# ZM-JAVA-OSCI-002: ProcessBuilder 参数拼接
+- id: zm-java-osci-002
+  severity: HIGH
+  message: |
+    ProcessBuilder 使用了字符串拼接构造命令参数。
+    应使用参数数组传入独立参数，避免命令注入。
+  languages:
+    - java
+  pattern-either:
+    - pattern: |
+        new ProcessBuilder($CMD + $PARAM);
+  metadata:
+    cwe: "CWE-78: OS Command Injection"
+    owasp: "A03:2021 - Injection"
+    precision: medium

package/rules/unified/cwe-78/zm-ansible-cwe78-command-injection.yaml

@@ -0,0 +1,68 @@
+# Source: iac | Cluster: N/A
+# 逐码 ZhuMa IaC 规则 — Ansible Shell/Command 注入检测
+# V4.1 Sprint — CWE-78: OS Command Injection
+
+rules:
+  # ZM-ANSIBLE-CWE78-001: shell 模块 + 未经 quote 的变量
+  - id: zm-ansible-cwe78-cmdi-001
+    severity: CRITICAL
+    message: |
+      Ansible `shell` 模块中使用了未经 `quote` 过滤的变量 `{{ user_input }}` — 攻击者可通过变量注入任意 Shell 命令。
+      对所有用户可控变量使用 `{{ var | quote }}` 过滤器，或将命令重构为 `command` 模块（天然不调用 Shell）。
+      示例修复:
+      ```yaml
+      shell: echo {{ user_input | quote }}
+      ```
+    languages:
+      - generic
+    pattern-either:
+      - pattern: |
+          shell: "{{ $VAR }}"
+      - pattern: |
+          shell: "...{{ $VAR }}..."
+    metadata:
+      cwe: "CWE-78: OS Command Injection"
+      category: iac-ansible
+      precision: medium
+      confidence: high
+      tags: [ansible, command-injection, shell, variable]
+
+  # ZM-ANSIBLE-CWE78-002: command 模块 + 直接变量拼接
+  - id: zm-ansible-cwe78-cmdi-002
+    severity: HIGH
+    message: |
+      Ansible `command` 模块中直接拼接用户变量 `{{ user_input }}` — 虽然不经过 Shell，但攻击者仍可注入命令参数。
+      使用 `{{ var | quote }}` 或将变量作为 `args` 传递以限制注入面。
+    languages:
+      - generic
+    pattern-either:
+      - pattern: |
+          command: "...{{ $VAR }}..."
+      - pattern: |
+          command: "{{ $VAR }}"
+    metadata:
+      cwe: "CWE-78: OS Command Injection"
+      category: iac-ansible
+      precision: medium
+      confidence: high
+      tags: [ansible, command-injection, command, variable]
+
+  # ZM-ANSIBLE-CWE78-003: raw 模块 + 变量
+  - id: zm-ansible-cwe78-cmdi-003
+    severity: CRITICAL
+    message: |
+      Ansible `raw` 模块直接执行 SSH 命令，并将变量 `{{ user_input }}` 直接拼入命令 — 等同于远程命令执行。
+      `raw` 模块应避免使用用户变量。如必须使用，请用 `{{ var | quote }}` 并在任务文档中记录理由。
+    languages:
+      - generic
+    pattern-either:
+      - pattern: |
+          raw: "...{{ $VAR }}..."
+      - pattern: |
+          raw: "{{ $VAR }}"
+    metadata:
+      cwe: "CWE-78: OS Command Injection"
+      category: iac-ansible
+      precision: medium
+      confidence: high
+      tags: [ansible, command-injection, raw, rce]

package/rules/unified/cwe-78/zm-cpp-cwe78-command-injection.yaml

@@ -0,0 +1,86 @@
+# Source: common | Cluster: N/A
+# CWE-78: C/C++ OS 命令注入检测规则
+# 逐码 ZhuMa V4.3 — C/C++ 规则库
+#
+# 检测 C/C++ 代码中通过 system()、popen()、exec*() 函数族
+# 使用用户可控输入执行系统命令的注入漏洞。
+
+rules:
+
+# ZM-CPP-CWE78-001: system() 直接调用 (高风险)
+- id: zm-cpp-cwe78-command-injection-001
+  severity: ERROR
+  message: |
+    检测到 system() 函数调用。该函数将参数传递给 /bin/sh (Unix) 或 cmd.exe (Windows) 解析，
+    如果参数包含未净化的用户输入，攻击者可注入任意命令（如 `; rm -rf /`）。
+    
+    修复方案：
+    - 避免使用 system()，改用 fork()+exec*() 系列并传递参数数组
+    - 如必须使用，对输入进行严格白名单校验并转义 Shell 元字符
+    - Windows: 使用 CreateProcess() API 替代
+  languages:
+    - c
+    - cpp
+  patterns:
+    - pattern: system(...)
+    - pattern-not: system("$LITERAL")
+  metadata:
+    cwe: "CWE-78: OS Command Injection"
+    owasp: "A03:2021 - Injection"
+    category: security
+    precision: low
+    references:
+      - "https://cwe.mitre.org/data/definitions/78.html"
+      - "https://wiki.sei.cmu.edu/confluence/pages/viewpage.action?pageId=87152177"
+
+# ZM-CPP-CWE78-002: popen() 命令注入
+- id: zm-cpp-cwe78-command-injection-002
+  severity: ERROR
+  message: |
+    检测到 popen() 函数调用。该函数通过 Shell 执行命令并返回管道，
+    参数中的用户可控输入可能导致命令注入攻击。
+
+    修复方案：
+    - 优先使用 fork()+exec*() + pipe() 组合代替 popen()
+    - 对命令参数使用白名单校验，禁止包含 Shell 元字符
+    - 对输入使用 execv() 的参数数组形式绕过 Shell 解析
+  languages:
+    - c
+    - cpp
+  patterns:
+    - pattern: popen(...)
+    - pattern-not: popen("$LITERAL")
+  metadata:
+    cwe: "CWE-78: OS Command Injection"
+    owasp: "A03:2021 - Injection"
+    category: security
+    precision: low
+    references:
+      - "https://cwe.mitre.org/data/definitions/78.html"
+
+# ZM-CPP-CWE78-003: exec*() 族函数用户输入
+- id: zm-cpp-cwe78-command-injection-003
+  severity: ERROR
+  message: |
+    检测到 execlp/execvp 函数调用。execlp/execvp 使用 PATH 环境变量搜索可执行文件，
+    如果 PATH 被攻击者控制或程序名依赖用户输入，可能导致恶意程序执行。
+
+    修复方案：
+    - 使用 execv()/execve() 并指定完整路径
+    - 调用前清空或重置 PATH 环境变量
+    - 对传入的程序名和参数进行严格白名单校验
+  languages:
+    - c
+    - cpp
+  pattern-either:
+    - pattern: execlp(...)
+    - pattern: execvp(...)
+    - pattern: execvpe(...)
+  metadata:
+    cwe: "CWE-78: OS Command Injection"
+    owasp: "A03:2021 - Injection"
+    category: security
+    precision: high
+    references:
+      - "https://cwe.mitre.org/data/definitions/78.html"
+      - "https://wiki.sei.cmu.edu/confluence/display/c/ENV03-C.+Sanitize+the+environment+when+invoking+external+programs"

package/rules/unified/cwe-78/zm-cs-cwe78-command-injection.yaml

@@ -0,0 +1,94 @@
+# Source: common | Cluster: N/A
+# CWE-78: C# 命令注入检测规则
+# 逐码 ZhuMa V4.3 — C# 规则库
+#
+# 检测 .NET 中通过 Process.Start() 等执行外部命令时使用用户输入
+# 导致的命令注入漏洞。
+
+rules:
+
+# ZM-CS-CWE78-001: Process.Start 用户输入命令
+- id: zm-cs-cwe78-command-injection-001
+  severity: ERROR
+  message: |
+    检测到 Process.Start() 的参数来源于变量或用户输入。
+    如果启动进程的文件名或参数未经过严格验证，攻击者可注入
+    恶意命令参数实现任意代码执行。
+
+    修复方案：
+    - 使用 Process.Start() 的 ProcessStartInfo + Arguments 参数列表方式
+    - 避免将用户输入直接放入 FileName 参数
+    - 对 Arguments 参数进行白名单校验或转义
+    - 优先使用 .NET API 而不是调用外部可执行文件
+  languages:
+    - csharp
+  pattern-either:
+    - pattern: Process.Start($VAR)
+    - pattern: Process.Start($VAR, $ARGS)
+    - pattern: new ProcessStartInfo($VAR)
+    - pattern: new ProcessStartInfo($VAR, $ARGS)
+    - pattern: $PSI.FileName = $VAR
+    - pattern: $PSI.Arguments = $VAR
+  metadata:
+    cwe: "CWE-78: OS Command Injection"
+    owasp: "A03:2021 - Injection"
+    category: security
+    precision: low
+    references:
+      - "https://cwe.mitre.org/data/definitions/78.html"
+      - "https://learn.microsoft.com/en-us/dotnet/api/system.diagnostics.process.start"
+
+# ZM-CS-CWE78-002: cmd.exe / shell 调用
+- id: zm-cs-cwe78-command-injection-002
+  severity: ERROR
+  message: |
+    检测到通过 cmd.exe 或 /bin/sh 执行命令的模式。
+    通过 Shell 解释器执行命令尤其危险，因为 Shell 会解析
+    管道、重定向和命令分隔符（&, |, &&, ||），扩大命令注入面。
+
+    修复方案：
+    - 不要使用 cmd.exe / sh 包装命令
+    - 直接使用目标可执行文件创建进程
+    - 使用 Process.Start(exePath, argumentsList) 参数数组形式
+    - 对程序路径进行白名单验证
+  languages:
+    - csharp
+  pattern-either:
+    - pattern: Process.Start("cmd.exe", $ARGS)
+    - pattern: Process.Start("cmd", $ARGS)
+    - pattern: Process.Start("/bin/sh", $ARGS)
+    - pattern: Process.Start("/bin/bash", $ARGS)
+    - pattern: Process.Start("powershell.exe", $ARGS)
+  metadata:
+    cwe: "CWE-78: OS Command Injection"
+    owasp: "A03:2021 - Injection"
+    category: security
+    precision: high
+    references:
+      - "https://cwe.mitre.org/data/definitions/78.html"
+
+# ZM-CS-CWE78-003: ProcessStartInfo Arguments 拼接
+- id: zm-cs-cwe78-command-injection-003
+  severity: WARNING
+  message: |
+    检测到 ProcessStartInfo.Arguments 使用字符串拼接或格式化构造。
+    当参数包含未净化的用户输入时，攻击者可注入额外的命令行参数
+    改变程序行为或执行恶意操作。
+
+    修复方案：
+    - 使用独立的参数数组/列表代替拼接字符串
+    - 对用户输入进行转义（CommandLineArgBuilder 或类似）
+    - 限制允许的参数格式，拒绝包含特殊字符的输入
+  languages:
+    - csharp
+  pattern-either:
+    - pattern: $PSI.Arguments = $STR + $VAR
+    - pattern: $PSI.Arguments = String.Format($STR, $VAR)
+    - pattern: $PSI.Arguments = $"{$STR}{$VAR}"
+  metadata:
+    cwe: "CWE-78: OS Command Injection"
+    owasp: "A03:2021 - Injection"
+    category: security
+    precision: medium
+    references:
+      - "https://cwe.mitre.org/data/definitions/78.html"

package/rules/unified/cwe-78/zm-go-cwe78-command-injection.yaml

@@ -0,0 +1,96 @@
+# Source: common | Cluster: N/A
+# CWE-78: Go OS 命令注入检测
+# 逐码 ZhuMa V4.1 — Go 通用规则库
+# 检测: os/exec.Command 启动Shell执行用户输入、syscall.Exec
+
+rules:
+
+# ZM-GO-OSCI-001: exec.Command 调用Shell执行变量参数
+- id: zm-go-osci-001
+  severity: CRITICAL
+  message: |
+    检测到 os/exec 的 Command() 使用 "sh"/"bash"/"cmd" 等Shell解释器
+    且参数中包含变量。攻击者可通过用户输入注入额外命令
+    （如 ; id、| nc、$(cat /etc/passwd) 等），实现远程代码执行。
+
+    修复方案:
+    1. 使用 exec.Command() 直接调用二进制文件，不通过Shell: 
+       exec.Command("git", "log", "--oneline") 而非 exec.Command("sh", "-c", "git log")
+    2. 避免将用户输入拼入命令字符串或Shell参数
+    3. 对必须传入Shell的命令，使用 shell-quote 库转义用户输入
+    4. 优先使用 Go 标准库函数替代外部命令（如 os.ReadFile 代替 cat）
+  languages:
+    - go
+  pattern-either:
+    - pattern: exec.Command("sh", "-c", $INPUT)
+    - pattern: exec.Command("bash", "-c", $INPUT)
+    - pattern: exec.Command("zsh", "-c", $INPUT)
+    - pattern: exec.Command("/bin/sh", "-c", $INPUT)
+    - pattern: exec.Command("/bin/bash", "-c", $INPUT)
+    - pattern: exec.Command("cmd", "/C", $INPUT)
+    - pattern: exec.Command("cmd", "/c", $INPUT)
+    - pattern: exec.Command("cmd.exe", "/C", $INPUT)
+    - pattern: exec.Command("powershell", "-Command", $INPUT)
+    - pattern: exec.Command("pwsh", "-Command", $INPUT)
+    - pattern: exec.Command("powershell.exe", "-Command", $INPUT)
+  metadata:
+    cwe: "CWE-78: Improper Neutralization of Special Elements used in an OS Command (OS Command Injection)"
+    severity: CRITICAL
+    precision: high
+    category: command-injection
+    likelihood: HIGH
+    impact: CRITICAL
+    owasp: "A03:2021 - Injection"
+    references:
+      - "https://pkg.go.dev/os/exec"
+      - "https://owasp.org/www-community/attacks/Command_Injection"
+
+# ZM-GO-OSCI-002: syscall.Exec 执行用户可控路径
+- id: zm-go-osci-002
+  severity: CRITICAL
+  message: |
+    检测到 syscall.Exec() 使用变量作为可执行文件路径。
+    syscall.Exec 直接替换当前进程镜像，若路径可控将导致任意代码执行。
+
+    修复方案:
+    1. 校验可执行文件路径必须在白名单目录内
+    2. 使用绝对路径替代相对路径
+    3. 迁移至 os/exec 包（syscall 已弃用，Go 1.17+）
+  languages:
+    - go
+  pattern-either:
+    - pattern: syscall.Exec($PATH, $ARGS, $ENV)
+    - pattern: syscall.Exec($PATH, nil, nil)
+  metadata:
+    cwe: "CWE-78: Improper Neutralization of Special Elements used in an OS Command (OS Command Injection)"
+    severity: CRITICAL
+    precision: high
+    category: command-injection
+    likelihood: MEDIUM
+    impact: CRITICAL
+    owasp: "A03:2021 - Injection"
+
+# ZM-GO-OSCI-003: exec.Command 命令名来自变量
+- id: zm-go-osci-003
+  severity: HIGH
+  message: |
+    检测到 os/exec 的 Command() 第一个参数（命令名）来自变量。
+    若该变量由用户输入控制，攻击者可指定任意可执行文件路径实现代码执行。
+
+    修复方案:
+    1. 命令名使用字面量字符串，参数通过后续参数传入
+    2. 对命令名做严格白名单校验
+    3. 避免从用户输入直接构造命令路径
+  languages:
+    - go
+  pattern-either:
+    - pattern: exec.Command($CMD, $ARGS)
+    - pattern: exec.CommandContext($CTX, $CMD, $ARGS)
+  metadata:
+    cwe: "CWE-78: Improper Neutralization of Special Elements used in an OS Command (OS Command Injection)"
+    severity: HIGH
+    precision: medium
+    category: command-injection
+    likelihood: MEDIUM
+    impact: HIGH
+    owasp: "A03:2021 - Injection"

package/rules/unified/cwe-78/zm-go-cwe78-osci-advanced.yaml

@@ -0,0 +1,39 @@
+# Source: common | Cluster: N/A
+# CWE-78: Go os/exec 命令注入补充变体
+# 逐码 ZhuMa V4.3 — Go 通用规则库
+# 检测: Command含用户输入变量拼接
+
+rules:
+
+# ZM-GO-OSCI-004: exec.Command 参数含用户输入拼接
+- id: zm-go-osci-004
+  severity: CRITICAL
+  message: |
+    检测到 os/exec Command 的参数使用 fmt.Sprintf 或字符串拼接。
+    即使不通过shell，若命令参数由用户输入拼接也可能导致参数注入。
+    例如: exec.Command("git", "clone", userRepo) 中 userRepo 可为 "--help && rm -rf /"
+
+    修复方案:
+    1. 将每个参数独立传入: exec.Command("git", "clone", userRepo)
+    2. 对用户输入做严格校验(如仅允许字母数字)
+    3. 使用 -- 分隔符防止选项注入: exec.Command("git", "clone", "--", userRepo)
+    4. 避免 exec.Command 参数列表中使用 fmt.Sprintf
+  languages:
+    - go
+  pattern-either:
+    - pattern: exec.Command(fmt.Sprintf($FMT, $VAR), $ARGS)
+    - pattern: exec.Command($STR + $VAR, $ARGS)
+    - pattern: exec.Command($CMD, fmt.Sprintf($FMT, $VAR))
+    - pattern: exec.Command($CMD, $STR + $VAR)
+    - pattern: exec.CommandContext($CTX, $STR + $VAR, $ARGS)
+    - pattern: exec.CommandContext($CTX, $CMD, $STR + $VAR)
+  metadata:
+    cwe: "CWE-78: Improper Neutralization of Special Elements used in an OS Command (OS Command Injection)"
+    severity: CRITICAL
+    precision: high
+    category: command-injection
+    likelihood: HIGH
+    impact: CRITICAL
+    owasp: "A03:2021 - Injection"
+    references:
+      - "https://pkg.go.dev/os/exec"