@zhuma4/cli 4.0.0-alpha.1 → 4.3.0

package/rules/unified/cwe-338/zm-go-cwe338-weak-prng.yaml

@@ -0,0 +1,118 @@
+# Source: common | Cluster: N/A
+# CWE-338: Go crypto/rand vs math/rand 误用检测
+# 逐码 ZhuMa V4.1 — Go 通用规则库
+# 检测: 安全场景使用 math/rand 而非 crypto/rand
+
+rules:
+
+# ZM-GO-RAND-001: 安全场景使用 math/rand
+- id: zm-go-weakrand-001
+  severity: ERROR
+  message: |
+    检测到在安全场景中使用了 math/rand 而非 crypto/rand。
+    math/rand 使用伪随机数生成器（PRNG），基于可预测的种子，不适用于
+    任何密码学安全场景。攻击者可预测生成的"随机"值。
+
+    安全场景包括但不限于：
+    - 生成 Session ID / CSRF Token / 密码重置 Token
+    - 生成 API Key / Access Token / 密钥
+    - 生成随机 nonce（加密随机数）
+    - 生成验证码 / OTP
+    - 随机排序/洗牌用于安全决策
+
+    math/rand 种子仅 64bit，枚举空间远小于现代密码学要求的 128bit+。
+
+    CVE参考:
+    - CVE-2020-28917: Go Web 应用使用 math/rand 生成会话Token可被预测
+    - CVE-2021-29923: Go 标准库 math/rand 种子可预测导致认证绕过
+
+    修复方案:
+    1. 替换: import "math/rand" → import "crypto/rand"
+    2. 生成随机字节: rand.Read(b) (crypto/rand)
+    3. 生成随机整数: rand.Int(rand.Reader, max) (crypto/rand)
+    4. 生成随机字符串: 使用 crypto/rand 读取字节后编码为 base64/hex
+       b := make([]byte, 32)
+       rand.Read(b)
+       token := hex.EncodeToString(b)
+    5. 使用 ulid.New() 或 uuid.NewRandom() 等基于 crypto/rand 的高级库
+  languages:
+    - go
+  pattern-either:
+    - pattern: rand.Intn($N)
+    - pattern: rand.Int63n($N)
+    - pattern: rand.Int31n($N)
+    - pattern: rand.Int()
+    - pattern: rand.Int63()
+    - pattern: rand.Int31()
+    - pattern: rand.Float64()
+    - pattern: rand.Float32()
+    - pattern: rand.Read($B)
+    - pattern: rand.Perm($N)
+    - pattern: rand.Shuffle($N, $FN)
+    - pattern: rand.Seed($SEED)
+    - pattern: rand.NewSource($SEED)
+  metadata:
+    cwe: "CWE-338: Use of Cryptographically Weak Pseudo-Random Number Generator (PRNG)"
+    severity: ERROR
+    precision: medium
+    category: crypto
+    likelihood: HIGH
+    impact: CRITICAL
+    cve: "CVE-2020-28917"
+    owasp: "A02:2021 - Cryptographic Failures"
+    references:
+      - "https://pkg.go.dev/crypto/rand"
+      - "https://pkg.go.dev/math/rand"
+      - "https://cwe.mitre.org/data/definitions/338.html"
+
+# ZM-GO-RAND-002: math/rand 用于 Token 生成
+- id: zm-go-weakrand-002
+  severity: CRITICAL
+  message: |
+    检测到使用 math/rand（而非 crypto/rand）配合字符串构建生成
+    Token/Session/Key 等安全敏感值。math/rand 的种子空间仅为 2^64，
+    现代硬件可轻松暴力枚举。攻击者可预测所有后续"随机"值。
+
+    典型危险模式:
+    import "math/rand"
+    const charset = "abcdefghijklmnopqrstuvwxyz0123456789"
+    func GenerateToken() string {
+      b := make([]byte, 32)
+      for i := range b {
+        b[i] = charset[rand.Intn(len(charset))]  // ← 可预测！
+      }
+      return string(b)
+    }
+
+    CVE参考:
+    - CVE-2020-28917: math/rand 产生的Session Token可预测
+    - CVE-2019-19886: Go 应用使用弱PRNG导致管理员Token被枚举
+
+    修复方案:
+    1. 使用 crypto/rand 生成随机字节:
+       b := make([]byte, 32)
+       if _, err := rand.Read(b); err != nil { panic(err) }
+       return base64.URLEncoding.EncodeToString(b)
+    2. 使用 google/uuid: uuid.Must(uuid.NewRandom())
+    3. 使用 oklog/ulid: ulid.MustNew(ulid.Timestamp(time.Now()), entropy)
+    4. 代码审查：搜索 math/rand 的 import，确认不在安全上下文中使用
+  languages:
+    - go
+  pattern-either:
+    - pattern: charset[rand.Intn(len(charset))]
+    - pattern: alphabet[rand.Intn(len(alphabet))]
+    - pattern: letters[rand.Intn(len(letters))]
+    - pattern: digits[rand.Intn(len(digits))]
+    - pattern: $CHARSET[rand.Intn(len($CHARSET))]
+  metadata:
+    cwe: "CWE-338: Use of Cryptographically Weak Pseudo-Random Number Generator (PRNG)"
+    severity: CRITICAL
+    precision: high
+    category: crypto
+    likelihood: HIGH
+    impact: CRITICAL
+    cve: "CVE-2020-28917"
+    owasp: "A02:2021 - Cryptographic Failures"
+    references:
+      - "https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-28917"
+      - "https://github.com/golang/go/issues"

package/rules/unified/cwe-338/zm-java-cwe338-weakrandom.yaml

@@ -0,0 +1,60 @@
+# Source: common | Cluster: N/A
+# CWE-338: 弱随机 — java.util.Random 替代 SecureRandom
+# 逐码 ZhuMa V4.3 — 密码学安全专项
+
+rules:
+
+# ZM-JAVA-CWE338-WEAKRANDOM-001: Random 用于安全场景
+- id: zm-java-cwe338-weakrandom-001
+  severity: WARNING
+  message: |
+    java.util.Random 用于生成 Token/密码/会话 ID 等安全敏感的随机数。
+    Random 使用线性同余算法（LCG），输出可被预测，不适合安全场景。
+    修复: 使用 java.security.SecureRandom 替代 Random，
+    SecureRandom 使用操作系统熵源（/dev/urandom）提供密码学安全的随机数。
+  languages:
+    - java
+  pattern-either:
+    - pattern: new Random().nextInt()
+    - pattern: new Random().nextLong()
+    - pattern: new Random().nextBytes($BUF)
+    - pattern: |
+        $R = new Random();
+        ...
+        $R.nextInt($BOUND);
+    - pattern: new Random($SEED)
+    - pattern: new Random(System.currentTimeMillis())
+  metadata:
+    cwe: "CWE-338: Use of Cryptographically Weak Pseudo-Random Number Generator (PRNG)"
+    severity: WARNING
+    precision: medium
+    category: crypto
+    owasp: "A02:2021 - Cryptographic Failures"
+    likelihood: HIGH
+    impact: HIGH
+    references:
+      - "https://cwe.mitre.org/data/definitions/338.html"
+
+# ZM-JAVA-CWE338-WEAKRANDOM-002: Math.random() 用于安全场景
+- id: zm-java-cwe338-weakrandom-002
+  severity: WARNING
+  message: |
+    Math.random() 使用与 java.util.Random 相同的算法（LCG），
+    不适合生成安全敏感的随机数（Token、验证码、密码重置链接等）。
+    修复: 使用 SecureRandom 或 ThreadLocalRandom(仅用于非安全场景)。
+    安全相关: byte[] token = new byte[32]; new SecureRandom().nextBytes(token);
+  languages:
+    - java
+  pattern-either:
+    - pattern: |
+        $TOKEN = String.valueOf(Math.random())
+    - pattern: |
+        (int)(Math.random() * $N)
+  metadata:
+    cwe: "CWE-338: Use of Cryptographically Weak Pseudo-Random Number Generator (PRNG)"
+    severity: WARNING
+    precision: medium
+    category: crypto
+    owasp: "A02:2021 - Cryptographic Failures"
+    likelihood: MEDIUM
+    impact: HIGH

package/rules/unified/cwe-345/zm-js-cwe345-postmessage.yaml

@@ -0,0 +1,76 @@
+# Source: common | Cluster: N/A
+# CWE-345: postMessage 无 origin 验证检测规则
+# 逐码 ZhuMa V4.1 Sprint 1 — JS/TS 通用规则库
+
+rules:
+
+# ZM-JS-POSTMSG-001: postMessage 监听器未校验 origin
+- id: zm-js-postmsg-001
+  severity: WARNING
+  message: |
+    检测到 window.addEventListener('message', ...) 或 window.onmessage
+    事件监听器，但未对 event.origin 进行校验。
+    攻击者可通过任意域的页面发送恶意消息，导致数据泄露或跨域操作。
+
+    修复建议:
+    1. 在校验 event.origin 白名单后再处理消息:
+       if (event.origin !== 'https://trusted.com') return;
+    2. 同时校验 event.source 来源窗口
+    3. 在 postMessage 发送时指定精确的 targetOrigin，避免使用 '*'
+    4. 对接收的消息数据进行结构校验
+  languages:
+    - javascript
+    - typescript
+  patterns:
+    - pattern-either:
+        - pattern: |
+            window.addEventListener('message', $CALLBACK)
+        - pattern: |
+            window.addEventListener("message", $CALLBACK)
+        - pattern: |
+            globalThis.addEventListener('message', $CALLBACK)
+        - pattern: |
+            window.onmessage = $CALLBACK
+    - pattern-not-inside: |
+        ...
+        event.origin === ...
+        ...
+    - pattern-not-inside: |
+        ...
+        event.origin !== ...
+        ...
+  metadata:
+    cwe: "CWE-345: Insufficient Verification of Data Authenticity"
+    owasp: "A08:2021 - Software and Data Integrity Failures"
+    category: xss
+    precision: medium
+    references:
+      - "https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage"
+      - "https://owasp.org/www-community/attacks/HTML5_Security_Cheat_Sheet#postmessage"
+
+# ZM-JS-POSTMSG-002: postMessage 使用通配符 targetOrigin
+- id: zm-js-postmsg-002
+  severity: WARNING
+  message: |
+    检测到 postMessage 调用使用了通配符 '*' 作为 targetOrigin。
+    这将导致消息可被任意域的页面接收，存在信息泄露风险。
+
+    修复建议:
+    1. 将 targetOrigin 设置为精确的目标 origin: $WINDOW.postMessage(data, 'https://trusted.com')
+    2. 如果确实需要发给多个域，校验接收方 origin 白名单后再发送
+    3. 避免在消息中携带敏感数据
+  languages:
+    - javascript
+    - typescript
+  pattern-either:
+    - pattern: $WINDOW.postMessage($DATA, '*')
+    - pattern: $WINDOW.postMessage($DATA, "*")
+    - pattern: $FRAME.contentWindow.postMessage($DATA, '*')
+    - pattern: $FRAME.contentWindow.postMessage($DATA, "*")
+  metadata:
+    cwe: "CWE-345: Insufficient Verification of Data Authenticity"
+    owasp: "A08:2021 - Software and Data Integrity Failures"
+    category: xss
+    precision: very-high
+    references:
+      - "https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage#security_concerns"

package/rules/unified/cwe-345/zm-js-cwe345-websocket-security.yaml

@@ -0,0 +1,91 @@
+# Source: common | Cluster: N/A
+# CWE-345 / CWE-306: WebSocket 安全检测规则
+# 逐码 ZhuMa V4.1 Sprint 3 — JS/TS 规则库
+# 覆盖: ws库、Socket.IO、SockJS 无认证/无Origin验证
+
+rules:
+
+# ZM-JS-WS-001: WebSocket服务器未验证Origin头 (跨站WebSocket劫持)
+- id: zm-js-ws-001
+  severity: ERROR
+  message: |
+    检测到 ws WebSocket 服务器可能未验证请求 Origin 头，可能导致跨站WebSocket劫持(CSWSH)。
+    攻击者可从恶意页面建立WebSocket连接，以受害者身份发送消息、窃取数据。
+
+    CVE-2019-1000002: ws <7.x 未默认验证Origin头。
+    CWE-345: Insufficient Verification of Data Authenticity。
+
+    修复:
+    1. 服务端验证 origin 头白名单:
+       const wss = new WebSocket.Server({ verifyClient: (info) => allowedOrigins.includes(info.origin) })
+    2. Socket.IO: 配置 cors.origin 白名单，设置 credentials: true + origin 校验
+    3. 使用 CSRF token 或自定义子协议(sub-protocol)进行二次认证
+    4. 生产环境禁止 origin: '*' 通配符
+  languages:
+    - javascript
+    - typescript
+  pattern-either:
+    - pattern: |
+        new WebSocket.Server({
+          ...
+        })
+    - pattern: |
+        new WebSocketServer({
+          ...
+        })
+    - pattern: http.createServer(...).on('upgrade', ...)
+    - pattern: socketio($SERVER, {...})
+    - pattern: new Server($SERVER, {...})
+  metadata:
+    cwe: "CWE-345: Insufficient Verification of Data Authenticity + CWE-346: Origin Validation Error"
+    owasp: "A01:2021 - Broken Access Control"
+    category: websocket
+    precision: medium
+    references:
+      - "https://nvd.nist.gov/vuln/detail/CVE-2019-1000002"
+      - "https://cheatsheetseries.owasp.org/cheatsheets/HTML5_Security_Cheat_Sheet.html#websocket-security"
+      - "https://christian-schneider.net/CrossSiteWebSocketHijacking.html"
+
+# ZM-JS-WS-002: WebSocket连接无认证/授权机制
+- id: zm-js-ws-002
+  severity: ERROR
+  message: |
+    检测到 WebSocket 服务器未实现连接级别的认证机制(token/cookie/session校验)。
+    WebSocket 本身不继承 HTTP 的同源策略和 Cookie 自动携带限制，
+    若无认证，任何客户端可连接并使用服务端资源。
+
+    CWE-306: Missing Authentication for Critical Function。
+    CWE-862: Missing Authorization。
+
+    修复:
+    1. 连接时验证 token/API Key: 在 upgrade 阶段检查 url query 或自定义 header
+    2. Socket.IO: 使用 auth middleware 在 connection 事件中验证
+       io.use((socket, next) => { const token = socket.handshake.auth.token; ... })
+    3. 使用 JWT/OAuth2 token 对每条消息签名
+    4. 禁止仅依赖客户端 IP 做认证
+    5. 连接后立刻发送 challenge-response 协议
+  languages:
+    - javascript
+    - typescript
+  pattern-either:
+    - pattern: |
+        io.on('connection', ($SOCKET) => {
+          ...
+        })
+    - pattern: |
+        $WSS.on('connection', ($WS, $REQ) => {
+          ...
+        })
+    - pattern: |
+        $SERVER.on('connection', ($SOCKET) => {
+          ...
+        })
+  metadata:
+    cwe: "CWE-306: Missing Authentication for Critical Function + CWE-862: Missing Authorization"
+    owasp: "A01:2021 - Broken Access Control"
+    category: websocket
+    precision: low
+    references:
+      - "https://socket.io/docs/v4/middlewares/"
+      - "https://cwe.mitre.org/data/definitions/306.html"
+      - "https://cheatsheetseries.owasp.org/cheatsheets/Authentication_Cheat_Sheet.html"

package/rules/unified/cwe-347/zm-go-cwe347-jwt.yaml

@@ -0,0 +1,148 @@
+# Source: common | Cluster: N/A
+# CWE-347: Go JWT 安全检测
+# 逐码 ZhuMa V4.1 — Go 通用规则库
+# 检测: JWT alg:none / 弱密钥 / 未验证签名 / 硬编码密钥
+
+rules:
+
+# ZM-GO-JWT-001: JWT alg=none 未禁用
+- id: zm-go-jwt-alg-none-001
+  severity: CRITICAL
+  message: |
+    检测到 JWT 解析使用了可能接受 alg=none 签名的配置。
+    若未显式验证签名算法，攻击者可构造 header 中 alg 为 "none"
+    的 JWT Token，伪造任意身份绕过认证。
+
+    攻击流程:
+    1. 攻击者构造 JWT: header={"alg":"none","typ":"JWT"}, payload={"sub":"admin"}
+    2. 签名部分置空: signature=""
+    3. 若服务端未禁用 none 算法，接受此Token为有效
+    4. 攻击者以管理员身份访问任意受保护资源
+
+    CVE参考:
+    - CVE-2015-9235: alg=none 导致JWT签名验证被绕过
+    - CVE-2018-1000531: JWT库未正确验证算法导致认证绕过
+    - CVE-2020-28042: golang-jwt v3 未安全处理算法验证
+
+    修复方案:
+    1. 使用 ParseWithClaims 时指定算法:
+       jwt.ParseWithClaims(tokenString, &claims, func(token *jwt.Token) (interface{}, error) {
+         if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
+           return nil, fmt.Errorf("unexpected signing method: %v", token.Header["alg"])
+         }
+         return []byte(secretKey), nil
+       })
+    2. 明确检查 token.Method.Alg() 是否在允许的算法列表中
+    3. 使用 jose2go 等更安全的JWT库（默认禁用 none）
+    4. 绝对禁止允许 alg=none 用于生产环境
+  languages:
+    - go
+  pattern-either:
+    - pattern: jwt.Parse($TOKEN, $KEYFUNC)
+    - pattern: jwt.ParseWithClaims($TOKEN, $CLAIMS, $KEYFUNC)
+    - pattern: jwt.NewParser().Parse($TOKEN, $KEYFUNC)
+    - pattern: jwt.NewParser().ParseWithClaims($TOKEN, $CLAIMS, $KEYFUNC)
+  metadata:
+    cwe: "CWE-347: Improper Verification of Cryptographic Signature"
+    severity: CRITICAL
+    precision: high
+    category: jwt
+    likelihood: HIGH
+    impact: CRITICAL
+    cve: "CVE-2015-9235"
+    owasp: "A01:2021 - Broken Access Control"
+    references:
+      - "https://auth0.com/blog/critical-vulnerabilities-in-json-web-token-libraries/"
+      - "https://pkg.go.dev/github.com/golang-jwt/jwt/v5"
+
+# ZM-GO-JWT-002: JWT 弱HMAC密钥
+- id: zm-go-jwt-weak-key-001
+  severity: CRITICAL
+  message: |
+    检测到 JWT HMAC 签名使用了弱密钥（长度 < 256bit 或硬编码字符串）。
+    攻击者可通过暴力破解或字典攻击恢复签名密钥，伪造任意用户的 JWT Token。
+
+    密钥强度要求:
+    - HS256: 最少 256 bit (32 字节) 随机密钥
+    - HS384: 最少 384 bit (48 字节)
+    - HS512: 最少 512 bit (64 字节)
+    - 禁止使用简短字符串如 "secret", "password123", "key" 等
+
+    CVE参考:
+    - CVE-2016-10555: RS/HS256 JWT 密钥混淆可导致算法降级攻击
+    - CVE-2018-0114: 弱JWT密钥导致认证绕过
+    - CVE-2022-39236: golang-jwt 弱密钥验证不足
+
+    修复方案:
+    1. 使用 crypto/rand 生成至少 256bit 随机密钥:
+       key := make([]byte, 32)
+       rand.Read(key)
+    2. 使用 RS256 (RSA) 或 ES256 (ECDSA) 替代 HMAC（可保护私钥）
+    3. 将密钥存储于环境变量或密钥管理服务，禁止硬编码
+    4. 定期轮换 JWT 签名密钥
+    5. 在处理密钥时始终验证 token.Method.Alg()
+  languages:
+    - go
+  pattern-either:
+    - pattern: jwt.SigningMethodHS256
+    - pattern: jwt.SigningMethodHS384
+    - pattern: jwt.SigningMethodHS512
+    - pattern: "jwt.SigningMethodRS256"
+  metadata:
+    cwe: "CWE-347: Improper Verification of Cryptographic Signature"
+    severity: CRITICAL
+    precision: high
+    category: jwt
+    likelihood: HIGH
+    impact: CRITICAL
+    cve: "CVE-2022-39236"
+    owasp: "A02:2021 - Cryptographic Failures"
+    references:
+      - "https://pkg.go.dev/github.com/golang-jwt/jwt/v5"
+      - "https://datatracker.ietf.org/doc/html/rfc7518#section-3.2"
+
+# ZM-GO-JWT-003: JWT 未验证过期/签发时间
+- id: zm-go-jwt-exp-001
+  severity: HIGH
+  message: |
+    检测到 JWT token 解析时未检查 exp（过期时间）或 nbf（生效时间）
+    声明。攻击者可能使用已过期的 Token 或未来将生效的 Token 进行
+    未授权访问。
+
+    JWT 关键时间声明:
+    - exp (Expires At): Token 过期时间，超过此时间应拒绝
+    - nbf (Not Before): Token 生效时间，早于此时间应拒绝
+    - iat (Issued At): Token 签发时间，用于检测异常签发时间
+    - jti (JWT ID): 用于防止重放攻击
+
+    CVE参考:
+    - CVE-2021-21309: Redis Labs 未验证 JWT 过期导致会话永不过期
+    - CVE-2020-15092: JWT 过期验证缺失导致认证绕过
+
+    修复方案:
+    1. 使用 jwt.RegisteredClaims（jwt/v5）而非 jwt.StandardClaims（v4已弃用）
+    2. 使用 ParseWithClaims 自动验证时间声明:
+       opts := []jwt.ParserOption{jwt.WithLeeway(30 * time.Second)}
+       token, err := jwt.ParseWithClaims(tokenStr, &jwt.RegisteredClaims{},
+         keyFunc, opts...)
+    3. 使用 jwt.WithValidMethods() 限制允许的算法
+    4. 实现 Token 黑名单或 jti 重放检测
+    5. 设置合理的过期时间（Access Token: 15-60分钟，Refresh Token: 7-30天）
+  languages:
+    - go
+  pattern-either:
+    - pattern: |
+        $TOKEN, $ERR := jwt.Parse($TOKENSTR, $KEYFUNC)
+    - pattern: |
+        $TOKEN, $ERR := jwt.ParseWithClaims($TOKENSTR, &$CLAIMS, $KEYFUNC)
+  metadata:
+    cwe: "CWE-613: Insufficient Session Expiration"
+    severity: HIGH
+    precision: high
+    category: jwt
+    likelihood: HIGH
+    impact: HIGH
+    owasp: "A01:2021 - Broken Access Control"
+    references:
+      - "https://pkg.go.dev/github.com/golang-jwt/jwt/v5"
+      - "https://datatracker.ietf.org/doc/html/rfc7519#section-4.1.4"

package/rules/unified/cwe-347/zm-java-cwe347-jwt-deep.yaml

@@ -0,0 +1,83 @@
+# Source: common | Cluster: N/A
+# CWE-347: JWT 深度检测 — none算法 / 弱HMAC / 无过期检查
+# 逐码 ZhuMa V4.3 — JWT 安全专项
+
+rules:
+
+# ZM-JAVA-CWE347-JWT-DEEP-001: JWT none 算法
+- id: zm-java-cwe347-jwt-deep-001
+  severity: CRITICAL
+  message: |
+    JWT 解析接受 "none" 算法签名的令牌，攻击者可以伪造任意 claims 的令牌而无需密钥。
+    修复: 1. 使用 parserBuilder().setAllowedAlgorithms() 明确指定算法列表
+    2. 排除 Algorithm.NONE 3. 升级到 jjwt >= 0.12.0
+  languages:
+    - java
+  pattern-either:
+    - pattern: |
+        Jwts.parser().setSigningKey($KEY).parse($TOKEN)
+    - pattern: |
+        Jwts.parserBuilder().build().parse($TOKEN)
+    - pattern: |
+        Jwts.parserBuilder().build().parseClaimsJws($TOKEN)
+  metadata:
+    cwe: "CWE-347: Improper Verification of Cryptographic Signature"
+    severity: CRITICAL
+    precision: medium
+    category: auth
+    owasp: "A02:2021 - Cryptographic Failures"
+    likelihood: HIGH
+    impact: CRITICAL
+    tags: [jwt, none-algorithm, auth-bypass]
+
+# ZM-JAVA-CWE347-JWT-DEEP-002: JWT 弱 HMAC 密钥 (HS256 短密钥)
+- id: zm-java-cwe347-jwt-deep-002
+  severity: ERROR
+  message: |
+    JWT HMAC 签名密钥（HS256）使用短字符串（< 256位）或硬编码字符串，
+    攻击者可通过暴力破解密钥伪造任意 JWT 令牌。
+    修复: 1. HS256 密钥至少 256 位 (32 字节) 2. 使用 Keys.secretKeyFor(SignatureAlgorithm.HS256)
+    生成安全密钥 3. 从环境变量或 KMS 获取密钥而非硬编码。
+  languages:
+    - java
+  pattern-either:
+    - pattern: Keys.hmacShaKeyFor("$SHORT_KEY".getBytes())
+    - pattern: Keys.hmacShaKeyFor($STR.getBytes())
+    - pattern: $KEY = "...".getBytes()
+  metadata:
+    cwe: "CWE-347: Improper Verification of Cryptographic Signature"
+    severity: ERROR
+    precision: medium
+    category: crypto
+    owasp: "A02:2021 - Cryptographic Failures"
+    likelihood: MEDIUM
+    impact: CRITICAL
+    tags: [jwt, weak-hmac]
+
+# ZM-JAVA-CWE347-JWT-DEEP-003: JWT 无过期时间检查
+- id: zm-java-cwe347-jwt-deep-003
+  severity: WARNING
+  message: |
+    JWT Parser 未调用 requireExpiration() 进行过期时间校验，
+    接受已过期的令牌，增加令牌被滥用窗口。
+    修复: 调用 Jwts.parserBuilder()...requireExpiration(Date)...build() 校验令牌过期时间。
+  languages:
+    - java
+  pattern-either:
+    - pattern: |
+        $PARSER = Jwts.parserBuilder().setSigningKey($KEY).build();
+        ...
+        $PARSER.parseClaimsJws($TOKEN);
+    - pattern: |
+        $PARSER = Jwts.parser().setSigningKey($KEY);
+        ...
+        $PARSER.parseClaimsJws($TOKEN);
+  metadata:
+    cwe: "CWE-347: Improper Verification of Cryptographic Signature"
+    severity: WARNING
+    precision: low
+    category: auth
+    owasp: "A02:2021 - Cryptographic Failures"
+    likelihood: MEDIUM
+    impact: MEDIUM
+    tags: [jwt, expired-token]

package/rules/unified/cwe-347/zm-java-cwe347-jwt.yaml

@@ -0,0 +1,31 @@
+# Source: common | Cluster: N/A
+# CWE-347: JWT 安全配置缺陷
+rules:
+- id: zm-java-jwt-01
+  severity: WARNING
+  message: JWT Parser 未调用 requireIssuer/requireAudience，可能接受任意发行者的令牌。
+  languages: [java]
+  pattern-either:
+    - pattern: Jwts.parser().setSigningKey($KEY).parseClaimsJws($TOKEN)
+    - pattern: Jwts.parserBuilder().setSigningKey($KEY).build().parseClaimsJws($TOKEN)
+  metadata: { cwe: "CWE-347", precision: medium, category: auth, owasp: "A02:2021 - Cryptographic Failures" }
+
+- id: zm-java-jwt-02
+  severity: ERROR
+  message: JWT 签名密钥硬编码为字符串，可被攻击者伪造令牌。
+  languages: [java]
+  pattern-either:
+    - pattern: Keys.hmacShaKeyFor("$KEY".getBytes())
+    - pattern: Keys.hmacShaKeyFor($STR.getBytes())
+    - pattern: Keys.secretKeyFor(SignatureAlgorithm.$ALG)
+  metadata: { cwe: "CWE-347", precision: medium, category: crypto, owasp: "A02:2021" }
+
+- id: zm-java-jwt-03
+  severity: WARNING
+  message: JWT 解析中接受过期令牌 acceptExpiredAt() / 允许宽松时间窗口。
+  languages: [java]
+  pattern-either:
+    - pattern: $PARSER.setAllowedClockSkewSeconds($N)
+    - pattern: $PARSER.setSigningKey($KEY).parseClaimsJws($TOKEN)
+    - pattern: Jwts.parserBuilder().setAllowedClockSkewSeconds($N).build()
+  metadata: { cwe: "CWE-347", precision: low, category: auth, owasp: "A02:2021" }