@zhuma4/cli 4.0.0-alpha.1

package/rules/common/zm-js-cwe611-xxe.yaml

@@ -0,0 +1,108 @@
+# CWE-611: Node.js XML外部实体注入(XXE)检测规则
+# 逐码 ZhuMa V4.1 Sprint 2 — JS/TS 规则库
+# 覆盖: libxmljs、xml2js、xml-js、fast-xml-parser
+
+rules:
+
+# ZM-JS-XXE-001: libxmljs.parseXml 未禁用 noent / xinclude
+- id: zm-js-xxe-001
+  severity: ERROR
+  message: |
+    检测到 libxmljs.parseXml() 可能未禁用外部实体解析。
+    若设置了 noent: true（展开实体）且未同时禁用外部资源加载，攻击者可通过
+    恶意XML读取任意文件（如 /etc/passwd）或发起SSRF。
+
+    修复:
+    1. libxmljs.parseXml(xml, { noent: false, noNet: true })
+    2. 或 libxmljs.parseXmlString(xml, { noent: false })
+    3. 禁用 DTD 加载: { dtdload: false, doctype: false }
+    4. 升级 libxmljs 到最新版本，检查安全公告
+  languages:
+    - javascript
+    - typescript
+  pattern-either:
+    - pattern: libxmljs.parseXml(...)
+    - pattern: $LIBXML.parseXml(...)
+    - pattern: libxmljs.parseXmlString(...)
+    - pattern: $LIBXML.parseXmlString(...)
+    - pattern: libxmljs.parseHtml(...)
+    - pattern: $LIBXML.parseHtml(...)
+    - pattern: $LIBXML.parseXml($REQ.body, ...)
+    - pattern: $LIBXML.parseXml($REQ.query, ...)
+    - pattern: $LIBXML.parseXmlString($REQ.body, ...)
+    - pattern: $LIBXML.parseXmlString($REQ.query, ...)
+  metadata:
+    cwe: "CWE-611: Improper Restriction of XML External Entity Reference"
+    owasp: "A05:2021 - Security Misconfiguration"
+    category: xxe
+    precision: medium
+    references:
+      - "https://owasp.org/www-community/vulnerabilities/XML_External_Entity_(XXE)_Processing"
+      - "https://github.com/libxmljs/libxmljs/wiki/Security"
+
+# ZM-JS-XXE-002: xml2js.Parser 默认配置不安全
+- id: zm-js-xxe-002
+  severity: ERROR
+  message: |
+    检测到 xml2js.Parser / xml2js.parseString 可能未禁用实体解析和外部DTD加载。
+    默认 xml2js 本身不解析实体，但底层 sax parser 可能受XXE影响。
+
+    修复:
+    1. new xml2js.Parser({ explicitCharkey: true, ... }) 本身较安全
+    2. 如使用 xml2js 配合其他XML解析器，需确保底层解析器禁用DTD/实体
+    3. 升级 xml2js 到 >=0.5.0 版本
+    4. 可选替代: fast-xml-parser (默认安全)
+  languages:
+    - javascript
+    - typescript
+  pattern-either:
+    - pattern: new xml2js.Parser(...)
+    - pattern: xml2js.parseString($REQ.body, ...)
+    - pattern: xml2js.parseString($REQ.query, ...)
+    - pattern: xml2js.parseString($REQ.params, ...)
+    - pattern: $PARSER.parseString($REQ.body, ...)
+    - pattern: $PARSER.parseString($REQ.query, ...)
+    - pattern: $PARSER.parseString($REQ.params, ...)
+  metadata:
+    cwe: "CWE-611: Improper Restriction of XML External Entity Reference"
+    owasp: "A05:2021 - Security Misconfiguration"
+    category: xxe
+    precision: medium
+    references:
+      - "https://owasp.org/www-community/vulnerabilities/XML_External_Entity_(XXE)_Processing"
+
+# ZM-JS-XXE-003: xml-js / fast-xml-parser 用户输入XML解析
+- id: zm-js-xxe-003
+  severity: WARNING
+  message: |
+    检测到使用 xml-js / fast-xml-parser 解析来自 req.body / req.query 的用户输入XML。
+    虽然 fast-xml-parser 默认不解析DTD/实体(xml-js类似)，但仍需注意:
+    - fast-xml-parser: 默认 processEntities: false, ignoreAttributes: false 基本安全
+    - xml-js: 纯JS实现不解析DTD，但Billion Laughs攻击可能仍影响内存
+
+    修复:
+    1. fast-xml-parser: 确认 options 中 processEntities 为 false
+    2. xml-js: 设置大小限制防止Billion Laughs/Quadratic Blowup
+    3. 所有XML解析器: 设置输入大小上限，使用流式解析
+  languages:
+    - javascript
+    - typescript
+  pattern-either:
+    - pattern: xmljs.xml2js($REQ.body, ...)
+    - pattern: xmljs.xml2js($REQ.query, ...)
+    - pattern: xmljs.xml2json($REQ.body, ...)
+    - pattern: xmljs.xml2json($REQ.query, ...)
+    - pattern: convert.xml2js($REQ.body, ...)
+    - pattern: convert.xml2json($REQ.body, ...)
+    - pattern: XMLParser.parse($REQ.body, ...)
+    - pattern: XMLParser.parse($REQ.query, ...)
+    - pattern: xmlParser.parse($REQ.body, ...)
+    - pattern: xmlParser.parse($REQ.query, ...)
+  metadata:
+    cwe: "CWE-611: Improper Restriction of XML External Entity Reference"
+    owasp: "A05:2021 - Security Misconfiguration"
+    category: xxe
+    precision: low
+    references:
+      - "https://owasp.org/www-community/vulnerabilities/XML_External_Entity_(XXE)_Processing"
+      - "https://github.com/NaturalIntelligence/fast-xml-parser"

package/rules/common/zm-js-cwe639-idor.yaml

@@ -0,0 +1,122 @@
+# CWE-639: Node.js 不安全直接对象引用 (IDOR) 检测
+# 逐码 ZhuMa V4.1 Sprint — JS/TS 规则库
+# 覆盖: req.params.id直传DB查询、express路由参数未校验所有权
+
+rules:
+
+# ZM-JS-IDOR-001: req.params.id 直接传入数据库查询无所有权校验
+- id: zm-js-idor-001
+  severity: WARNING
+  message: |
+    检测到 Express 路由中 req.params.id 直接传入数据库查询(如 findById / findOne)，
+    未发现所有权校验(如关联 currentUser.id 过滤)。
+
+    攻击者可通过遍历ID访问其他用户的资源(订单、文档、个人资料等):
+    GET /api/orders/123 → 修改为 GET /api/orders/124 可查看他人订单
+
+    修复:
+    1. 查询时关联当前用户: Model.findOne({ _id: id, userId: req.user.id })
+    2. 使用中间件校验资源所有权后再执行控制器
+    3. 使用 UUID/nanoid 替代自增ID
+    4. 在数据访问层统一添加所有权过滤
+  languages:
+    - javascript
+    - typescript
+  patterns:
+    - pattern-either:
+        # Mongoose
+        - pattern: |
+            $MODEL.findById($REQ.params.$ID, ...)
+        - pattern: |
+            $MODEL.findOne({_id: $REQ.params.$ID, ...}, ...)
+        - pattern: |
+            $MODEL.findByIdAndUpdate($REQ.params.$ID, ...)
+        - pattern: |
+            $MODEL.findByIdAndDelete($REQ.params.$ID, ...)
+        # Sequelize
+        - pattern: |
+            $MODEL.findByPk($REQ.params.$ID, ...)
+        - pattern: |
+            $MODEL.findOne({where: {id: $REQ.params.$ID, ...}}, ...)
+        - pattern: |
+            $MODEL.destroy({where: {id: $REQ.params.$ID, ...}}, ...)
+        # Knex
+        - pattern: |
+            $DB($TABLE).where('id', $REQ.params.$ID)
+        - pattern: |
+            $DB($TABLE).where({id: $REQ.params.$ID})
+    - pattern-not-inside: |
+        {...userId: ..., ...}
+    - pattern-not-inside: |
+        {...user: ..., ...}
+  metadata:
+    cwe: "CWE-639: Authorization Bypass Through User-Controlled Key"
+    owasp: "A01:2021 - Broken Access Control"
+    category: idor
+    precision: medium
+    confidence: high
+    references:
+      - "https://owasp.org/www-project-web-security-testing-guide/latest/4-Web_Application_Security_Testing/05-Authorization_Testing/04-Testing_for_Insecure_Direct_Object_References"
+
+# ZM-JS-IDOR-002: req.body.xxx 资源ID未校验所有权写入
+- id: zm-js-idor-002
+  severity: WARNING
+  message: |
+    检测到使用 req.body.xxx 中的资源ID进行更新/删除操作，未关联当前用户身份校验。
+    攻击者可修改请求体中的ID字段，越权操作他人的资源。
+
+    修复:
+    1. 从认证上下文获取当前用户ID，而非从请求体
+    2. 查询时添加所有权过滤条件
+    3. 使用 JWT token 中提取的用户身份做关联
+  languages:
+    - javascript
+    - typescript
+  patterns:
+    - pattern-either:
+        - pattern: |
+            $MODEL.updateOne({_id: $REQ.body.$ID, ...}, ...)
+        - pattern: |
+            $MODEL.updateMany({_id: $REQ.body.$ID, ...}, ...)
+        - pattern: |
+            $MODEL.deleteOne({_id: $REQ.body.$ID, ...})
+        - pattern: |
+            $MODEL.findOneAndUpdate({_id: $REQ.body.$ID, ...}, ...)
+    - pattern-not-inside: |
+        {...userId: ..., ...}
+    - pattern-not-inside: |
+        {...user: ..., ...}
+  metadata:
+    cwe: "CWE-639: Authorization Bypass Through User-Controlled Key"
+    owasp: "A01:2021 - Broken Access Control"
+    category: idor
+    precision: medium
+    confidence: high
+
+# ZM-JS-IDOR-003: GraphQL resolver 直接使用 args.id 无权限校验
+- id: zm-js-idor-003
+  severity: WARNING
+  message: |
+    检测到 GraphQL resolver 中直接使用 args.id 查询数据库，无所有权校验。
+    GraphQL 查询可任意指定ID参数，需在 resolver 中校验资源所属。
+
+    修复:
+    1. 在 resolver 中从 context 获取当前用户并关联查询
+    2. 使用 DataLoader 批量加载时自动注入所有权过滤
+    3. 实现 GraphQL shield / 自定义 directive 做权限控制
+  languages:
+    - javascript
+    - typescript
+  pattern-either:
+    - pattern: |
+        $MODEL.findById($ARGS.id, ...)
+    - pattern: |
+        $MODEL.findOne({_id: $ARGS.id, ...}, ...)
+    - pattern: |
+        $MODEL.findByPk($ARGS.id, ...)
+  metadata:
+    cwe: "CWE-639: Authorization Bypass Through User-Controlled Key"
+    owasp: "A01:2021 - Broken Access Control"
+    category: idor
+    precision: medium
+    confidence: high

package/rules/common/zm-js-cwe693-helmet-missing.yaml

@@ -0,0 +1,46 @@
+# CWE-693: Express Helmet 安全头缺失检测规则
+# 逐码 ZhuMa V4.1 Sprint 1 — JS/TS 通用规则库
+
+rules:
+
+# ZM-JS-SECHEADER-001: Express 应用未使用 helmet 中间件
+- id: zm-js-secheader-001
+  severity: INFO
+  message: |
+    检测到 Express 应用中未发现 helmet() 中间件的使用。
+    helmet 可自动设置多个安全相关 HTTP 响应头（X-Content-Type-Options、
+    X-Frame-Options、Content-Security-Policy 等），缺少这些头部降低了
+    应用的纵深防御能力。
+
+    修复建议:
+    1. 安装并全局使用 helmet: app.use(helmet())
+    2. 按需配置各中间件（如 helmet.contentSecurityPolicy()）
+    3. 至少设置以下头部:
+       - X-Content-Type-Options: nosniff
+       - X-Frame-Options: DENY
+       - Strict-Transport-Security: max-age=31536000
+  languages:
+    - javascript
+    - typescript
+  patterns:
+    - pattern-either:
+        - pattern: |
+            const $APP = express();
+            ...
+        - pattern: |
+            const $APP = express();
+            ...
+            $APP.use(...);
+            ...
+    - pattern-not-inside: |
+        ...
+        $APP.use(helmet(...));
+        ...
+  metadata:
+    cwe: "CWE-693: Protection Mechanism Failure"
+    owasp: "A05:2021 - Security Misconfiguration"
+    category: config
+    precision: low
+    references:
+      - "https://helmetjs.github.io/"
+      - "https://owasp.org/www-project-secure-headers/"

package/rules/common/zm-js-cwe78-exec.yaml

@@ -0,0 +1,37 @@
+# CWE-78: Node.js child_process exec/execSync 命令注入检测规则
+# 逐码 ZhuMa V4.1 Sprint 1 — JS/TS 通用规则库
+
+rules:
+
+# ZM-JS-OSCI-001: child_process exec/execSync 命令字符串拼接注入
+- id: zm-js-osci-001
+  severity: ERROR
+  message: |
+    检测到 child_process.exec() / execSync() 使用了字符串拼接或模板字符串构造命令。
+    攻击者可通过控制变量注入额外系统命令（如 ; rm -rf / 或 $(whoami)）。
+
+    修复建议:
+    1. 优先使用 execFile() / spawn() 替代 exec()，参数独立传入避免 Shell 解析
+    2. 如必须使用 exec()，对用户输入做严格白名单校验
+    3. 禁止将用户输入拼接到命令字符串中
+    4. 使用 shell-escape / shell-quote 库对参数进行转义
+  languages:
+    - javascript
+    - typescript
+  pattern-either:
+    - pattern: exec($X + ...)
+    - pattern: exec(... + $X)
+    - pattern: execSync($X + ...)
+    - pattern: execSync(... + $X)
+    - pattern: $CP.exec($X + ...)
+    - pattern: $CP.exec(... + $X)
+    - pattern: $CP.execSync($X + ...)
+    - pattern: $CP.execSync(... + $X)
+  metadata:
+    cwe: "CWE-78: Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection')"
+    owasp: "A03:2021 - Injection"
+    category: command-injection
+    precision: medium
+    references:
+      - "https://owasp.org/www-community/attacks/Command_Injection"
+      - "https://nodejs.org/api/child_process.html#child_processexeccommand-options-callback"

package/rules/common/zm-js-cwe78-spawn.yaml

@@ -0,0 +1,37 @@
+# CWE-78: Node.js child_process spawn 不安全参数检测规则
+# 逐码 ZhuMa V4.1 Sprint 1 — JS/TS 通用规则库
+
+rules:
+
+# ZM-JS-OSCI-002: spawn 命令来自变量且开启 shell 选项
+- id: zm-js-osci-002
+  severity: ERROR
+  message: |
+    检测到 child_process.spawn() 命令参数来自变量且配置了 shell: true 选项。
+    当 shell 选项开启时，命令字符串会被系统 Shell 解析（如 /bin/sh -c），
+    存在命令注入风险。
+
+    修复建议:
+    1. 关闭 shell 选项（默认值为 false）
+    2. 命令使用字面量字符串，参数通过 args 数组独立传入
+    3. 对用户输入做严格白名单校验
+  languages:
+    - javascript
+    - typescript
+  pattern-either:
+    - pattern: |
+        spawn($CMD, {..., shell: true, ...})
+    - pattern: |
+        spawn($CMD, $ARGS, {..., shell: true, ...})
+    - pattern: |
+        $CP.spawn($CMD, {..., shell: true, ...})
+    - pattern: |
+        $CP.spawn($CMD, $ARGS, {..., shell: true, ...})
+  metadata:
+    cwe: "CWE-78: Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection')"
+    owasp: "A03:2021 - Injection"
+    category: command-injection
+    precision: high
+    references:
+      - "https://nodejs.org/api/child_process.html#child_processspawncommand-args-options"
+      - "https://owasp.org/www-community/attacks/Command_Injection"

package/rules/common/zm-js-cwe79-domxss.yaml

@@ -0,0 +1,84 @@
+# CWE-79: DOM-based XSS 检测规则
+# 逐码 ZhuMa V4.1 Sprint 1 — JS/TS 通用规则库
+
+rules:
+
+# ZM-JS-DOMXSS-001: innerHTML / outerHTML 赋值
+- id: zm-js-domxss-001
+  severity: WARNING
+  message: |
+    检测到使用 innerHTML 或 outerHTML 赋值操作，可能引入 DOM-based XSS。
+    直接向 innerHTML 设置用户输入会导致浏览器解析并执行内嵌的 <script> 标签。
+
+    修复建议:
+    1. 使用 textContent 替代 innerHTML 设置纯文本
+    2. 使用 document.createElement() + appendChild() 安全构建 DOM
+    3. 如必须使用 innerHTML，先用 DOMPurify 对内容消毒
+    4. 使用 Content Security Policy (CSP) 作为纵深防御
+  languages:
+    - javascript
+    - typescript
+  pattern-either:
+    - pattern: $EL.innerHTML = $X
+    - pattern: $EL.outerHTML = $X
+    - pattern: $EL.innerHTML += $X
+    - pattern: $EL.outerHTML += $X
+  metadata:
+    cwe: "CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')"
+    owasp: "A03:2021 - Injection"
+    category: xss
+    precision: high
+    references:
+      - "https://owasp.org/www-community/attacks/DOM_Based_XSS"
+      - "https://cheatsheetseries.owasp.org/cheatsheets/DOM_based_XSS_Prevention_Cheat_Sheet.html"
+
+# ZM-JS-DOMXSS-002: document.write / document.writeln
+- id: zm-js-domxss-002
+  severity: WARNING
+  message: |
+    检测到使用 document.write() 或 document.writeln() 写入 DOM。
+    这些 API 会直接向文档写入原始 HTML，若内容由用户控制将导致 XSS。
+
+    修复建议:
+    1. 禁止使用 document.write()，使用安全的 DOM API 替代
+    2. document.createElement() + textContent 安全构建内容
+    3. 使用 insertAdjacentHTML 时也需 DOMPurify 消毒
+  languages:
+    - javascript
+    - typescript
+  pattern-either:
+    - pattern: document.write($X)
+    - pattern: document.writeln($X)
+  metadata:
+    cwe: "CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')"
+    owasp: "A03:2021 - Injection"
+    category: xss
+    precision: very-high
+    references:
+      - "https://developer.mozilla.org/en-US/docs/Web/API/Document/write"
+      - "https://owasp.org/www-community/attacks/DOM_Based_XSS"
+
+# ZM-JS-DOMXSS-003: insertAdjacentHTML
+- id: zm-js-domxss-003
+  severity: WARNING
+  message: |
+    检测到使用 insertAdjacentHTML() 方法插入 HTML 内容。
+    与 innerHTML 类似，插入的 HTML 字符串会被解析，存在 DOM XSS 风险。
+
+    修复建议:
+    1. 使用 insertAdjacentElement() 替代 insertAdjacentHTML()
+    2. 如必须使用 HTML 插入，用 DOMPurify 消毒后操作
+    3. 优先使用 DOM 创建 API (createElement / createTextNode)
+  languages:
+    - javascript
+    - typescript
+  pattern-either:
+    - pattern: $EL.insertAdjacentHTML($POS, $X)
+  metadata:
+    cwe: "CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')"
+    owasp: "A03:2021 - Injection"
+    category: xss
+    precision: high
+    references:
+      - "https://developer.mozilla.org/en-US/docs/Web/API/Element/insertAdjacentHTML"
+      - "https://owasp.org/www-community/attacks/DOM_Based_XSS"

package/rules/common/zm-js-cwe79-react-xss.yaml

@@ -0,0 +1,18 @@
+# CWE-79: React dangerouslySetInnerHTML XSS 检测规则
+# 逐码 ZhuMa V4.1 Sprint 1
+
+rules:
+
+- id: zm-js-rxss-001
+  severity: WARNING
+  message: |
+    dangerouslySetInnerHTML bypasses React XSS protection — sanitize with DOMPurify first.
+  languages:
+    - javascript
+    - typescript
+  pattern: dangerouslySetInnerHTML
+  metadata:
+    cwe: "CWE-79"
+    precision: very-high
+    category: xss
+    owasp: "A03:2021 - Injection"

package/rules/common/zm-js-cwe79-xss-ejs.yaml

@@ -0,0 +1,70 @@
+# CWE-79: Express XSS 模板注入检测规则
+# 逐码 ZhuMa V4.1 Sprint 1 — JS/TS 通用规则库
+
+rules:
+
+# ZM-JS-XSS-001: res.render 直接传入用户可控数据
+- id: zm-js-xss-001
+  severity: WARNING
+  message: |
+    检测到 res.render() 将 req.body / req.query / req.params 直接传入模板变量。
+    未经过 HTML 实体转义的用户输入在模板中渲染可能导致存储型/反射型 XSS 攻击。
+
+    修复建议:
+    1. 对用户输入进行 HTML 实体编码（如使用 DOMPurify / xss 库或模板引擎自动转义）
+    2. 使用 EJS 的 <%= %> 代替 <%- %>（前者自动转义）
+    3. 在模板中避免使用 raw / unescaped 输出模式
+    4. 设置 Content-Security-Policy 响应头作为纵深防御
+  languages:
+    - javascript
+    - typescript
+  pattern-either:
+    - pattern: |
+        res.render($TEMPLATE, {..., $KEY: $REQ.body, ...})
+    - pattern: |
+        res.render($TEMPLATE, {..., $KEY: $REQ.query, ...})
+    - pattern: |
+        res.render($TEMPLATE, {..., $KEY: $REQ.params, ...})
+    - pattern: |
+        res.render($TEMPLATE, $REQ.body)
+    - pattern: |
+        res.render($TEMPLATE, $REQ.query)
+    - pattern: |
+        res.render($TEMPLATE, $REQ.params)
+  metadata:
+    cwe: "CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')"
+    owasp: "A03:2021 - Injection"
+    category: xss
+    precision: medium
+    references:
+      - "https://owasp.org/www-community/attacks/xss/"
+      - "https://expressjs.com/en/4x/api.html#res.render"
+
+# ZM-JS-XSS-002: res.send 直接输出用户输入
+- id: zm-js-xss-002
+  severity: WARNING
+  message: |
+    检测到 res.send() 直接输出 req.body / req.query / req.params 中的值。
+    若 Content-Type 为 text/html，可能导致反射型 XSS。
+
+    修复建议:
+    1. 避免直接输出用户输入；如需要，使用 HTML 实体编码后输出
+    2. 显式设置 Content-Type: text/plain 防止浏览器解析 HTML
+    3. 使用 res.json() 代替 res.send() 输出 JSON 数据
+  languages:
+    - javascript
+    - typescript
+  pattern-either:
+    - pattern: res.send($REQ.body)
+    - pattern: res.send($REQ.query)
+    - pattern: res.send($REQ.params)
+    - pattern: res.send($REQ.body.$PROP)
+    - pattern: res.send($REQ.query.$PROP)
+    - pattern: res.send($REQ.params.$PROP)
+  metadata:
+    cwe: "CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')"
+    owasp: "A03:2021 - Injection"
+    category: xss
+    precision: medium
+    references:
+      - "https://owasp.org/www-community/attacks/xss/"

package/rules/common/zm-js-cwe89-sqli.yaml

@@ -0,0 +1,153 @@
+# CWE-89: Node.js SQL注入检测规则
+# 逐码 ZhuMa V4.1 Sprint 2 — JS/TS 规则库
+# 覆盖: mysql2.query、sequelize.query(raw)、knex.raw、pg.query、sqlite3
+
+rules:
+
+# ZM-JS-SQLI-001: SQL驱动字符串拼接查询（高精度）
+- id: zm-js-sqli-001
+  severity: ERROR
+  message: |
+    检测到SQL查询使用了字符串拼接或模板字符串构造SQL语句，存在SQL注入风险。
+    攻击者可通过控制拼接变量注入SQL命令，实现数据库脱库、篡改或RCE。
+
+    修复:
+    1. 使用参数化查询(Parameterized Query)替代字符串拼接
+    2. mysql2: connection.execute('SELECT * FROM users WHERE id = ?', [userId])
+    3. pg: client.query('SELECT * FROM users WHERE id = $1', [userId])
+    4. 如确实需要动态表名/列名，使用白名单校验
+    5. 禁止 ORDER BY / GROUP BY / LIMIT 使用用户输入直接拼接
+  languages:
+    - javascript
+    - typescript
+  pattern-either:
+    # mysql2 query/execute 拼接
+    - pattern: $CONN.query('SELECT' + $INPUT, ...)
+    - pattern: $CONN.query('INSERT' + $INPUT, ...)
+    - pattern: $CONN.query('UPDATE' + $INPUT, ...)
+    - pattern: $CONN.query('DELETE' + $INPUT, ...)
+    - pattern: $CONN.execute('SELECT' + $INPUT, ...)
+    - pattern: $CONN.execute('INSERT' + $INPUT, ...)
+    - pattern: $CONN.execute('UPDATE' + $INPUT, ...)
+    - pattern: $CONN.query($QUERY + $INPUT, ...)
+    - pattern: $CONN.execute($QUERY + $INPUT, ...)
+    # pg query 拼接
+    - pattern: $POOL.query('SELECT' + $INPUT, ...)
+    - pattern: $CLIENT.query('SELECT' + $INPUT, ...)
+    - pattern: $POOL.query('INSERT' + $INPUT, ...)
+    - pattern: $CLIENT.query('INSERT' + $INPUT, ...)
+    - pattern: $POOL.query('UPDATE' + $INPUT, ...)
+    - pattern: $CLIENT.query('UPDATE' + $INPUT, ...)
+    - pattern: $POOL.query('DELETE' + $INPUT, ...)
+    - pattern: $CLIENT.query('DELETE' + $INPUT, ...)
+    # sqlite3 拼接
+    - pattern: $DB.run('SELECT' + $INPUT, ...)
+    - pattern: $DB.run('INSERT' + $INPUT, ...)
+    - pattern: $DB.run('UPDATE' + $INPUT, ...)
+    - pattern: $DB.run('DELETE' + $INPUT, ...)
+    - pattern: $DB.get('SELECT' + $INPUT, ...)
+    - pattern: $DB.all('SELECT' + $INPUT, ...)
+    - pattern: $DB.exec('SELECT' + $INPUT, ...)
+    # 模板字符串拼接
+    - pattern: $CONN.query(`SELECT ... ${$INPUT}`, ...)
+    - pattern: $CLIENT.query(`SELECT ... ${$INPUT}`, ...)
+    - pattern: $POOL.query(`SELECT ... ${$INPUT}`, ...)
+    - pattern: $DB.run(`SELECT ... ${$INPUT}`, ...)
+    - pattern: $DB.all(`SELECT ... ${$INPUT}`, ...)
+  metadata:
+    cwe: "CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection')"
+    owasp: "A03:2021 - Injection"
+    category: sql-injection
+    precision: medium
+    references:
+      - "https://owasp.org/www-community/attacks/SQL_Injection"
+      - "https://cheatsheetseries.owasp.org/cheatsheets/SQL_Injection_Prevention_Cheat_Sheet.html"
+
+# ZM-JS-SQLI-002: Sequelize.query raw / knex.raw 拼接
+- id: zm-js-sqli-002
+  severity: ERROR
+  message: |
+    检测到 Sequelize.query(raw: true) 或 knex.raw() 使用了字符串拼接构造SQL。
+    这些方法会直接将字符串作为原始SQL执行，绕过ORM的参数化保护。
+
+    修复:
+    1. Sequelize: sequelize.query('SELECT * FROM users WHERE id = ?', { replacements: [userId] })
+    2. Sequelize: sequelize.query('SELECT * FROM users WHERE id = :id', { replacements: { id: userId } })
+    3. Knex: knex.raw('SELECT * FROM users WHERE id = ?', [userId])
+    4. 尽量避免使用 raw query，优先使用 ORM 的链式API
+  languages:
+    - javascript
+    - typescript
+  pattern-either:
+    - pattern: $SEQ.query($QUERY + $INPUT, ...)
+    - pattern: $SEQ.query('SELECT' + $INPUT, ...)
+    - pattern: $SEQ.query('INSERT' + $INPUT, ...)
+    - pattern: $SEQ.query('UPDATE' + $INPUT, ...)
+    - pattern: $SEQ.query('DELETE' + $INPUT, ...)
+    - pattern: knex.raw($QUERY + $INPUT, ...)
+    - pattern: knex.raw('SELECT' + $INPUT, ...)
+    - pattern: knex.raw('INSERT' + $INPUT, ...)
+    - pattern: knex.raw('UPDATE' + $INPUT, ...)
+    - pattern: knex.raw('DELETE' + $INPUT, ...)
+    - pattern: $KNEX.raw('SELECT' + $INPUT, ...)
+    - pattern: $KNEX.raw('INSERT' + $INPUT, ...)
+    - pattern: $KNEX.raw('UPDATE' + $INPUT, ...)
+    - pattern: $KNEX.raw('DELETE' + $INPUT, ...)
+    - pattern: $SEQ.query(`SELECT ... ${$INPUT}`, ...)
+    - pattern: knex.raw(`SELECT ... ${$INPUT}`, ...)
+  metadata:
+    cwe: "CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection')"
+    owasp: "A03:2021 - Injection"
+    category: sql-injection
+    precision: high
+    references:
+      - "https://sequelize.org/docs/v6/core-concepts/raw-queries/"
+      - "https://knexjs.org/guide/raw.html"
+
+# ZM-JS-SQLI-003: SQL查询中使用 req.query/params/body 拼接
+- id: zm-js-sqli-003
+  severity: ERROR
+  message: |
+    检测到SQL查询中直接拼接了 req.query / req.params / req.body 的用户输入。
+    这是SQL注入的最高风险模式。
+
+    修复:
+    1. 立即替换为参数化查询:
+       db.query('SELECT * FROM users WHERE name = ?', [req.query.name])
+    2. 使用查询构建器: knex.select().from('users').where('name', req.query.name)
+    3. 永远不要将用户输入拼接到SQL字符串中
+  languages:
+    - javascript
+    - typescript
+  pattern-either:
+    - pattern: $CONN.query($QUERY + $REQ.query.$FIELD, ...)
+    - pattern: $CONN.query($QUERY + $REQ.params.$FIELD, ...)
+    - pattern: $CONN.query($QUERY + $REQ.body.$FIELD, ...)
+    - pattern: $CLIENT.query($QUERY + $REQ.query.$FIELD, ...)
+    - pattern: $CLIENT.query($QUERY + $REQ.params.$FIELD, ...)
+    - pattern: $CLIENT.query($QUERY + $REQ.body.$FIELD, ...)
+    - pattern: $POOL.query($QUERY + $REQ.query.$FIELD, ...)
+    - pattern: $POOL.query($QUERY + $REQ.params.$FIELD, ...)
+    - pattern: $POOL.query($QUERY + $REQ.body.$FIELD, ...)
+    - pattern: $DB.run($QUERY + $REQ.query.$FIELD, ...)
+    - pattern: $DB.run($QUERY + $REQ.params.$FIELD, ...)
+    - pattern: $DB.run($QUERY + $REQ.body.$FIELD, ...)
+    - pattern: $DB.all($QUERY + $REQ.query.$FIELD, ...)
+    - pattern: $DB.all($QUERY + $REQ.params.$FIELD, ...)
+    - pattern: $DB.all($QUERY + $REQ.body.$FIELD, ...)
+    - pattern: $DB.get($QUERY + $REQ.query.$FIELD, ...)
+    - pattern: $DB.get($QUERY + $REQ.params.$FIELD, ...)
+    - pattern: $DB.get($QUERY + $REQ.body.$FIELD, ...)
+    - pattern: knex.raw($QUERY + $REQ.query.$FIELD, ...)
+    - pattern: knex.raw($QUERY + $REQ.params.$FIELD, ...)
+    - pattern: knex.raw($QUERY + $REQ.body.$FIELD, ...)
+    - pattern: $SEQ.query($QUERY + $REQ.query.$FIELD, ...)
+    - pattern: $SEQ.query($QUERY + $REQ.params.$FIELD, ...)
+    - pattern: $SEQ.query($QUERY + $REQ.body.$FIELD, ...)
+  metadata:
+    cwe: "CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection')"
+    owasp: "A03:2021 - Injection"
+    category: sql-injection
+    precision: high
+    references:
+      - "https://owasp.org/www-community/attacks/SQL_Injection"