Go标准库安全红线清单（含crypto、net/url等6大包的CVE规避实践）

第一章：Go标准库安全红线总览与风险认知

Go标准库以“少而精”著称，但其部分包在默认行为下隐含安全陷阱——这些并非漏洞，而是设计权衡所留下的“安全红线”。越过红线不会导致编译失败，却可能引发拒绝服务、信息泄露、路径遍历或逻辑绕过等生产级风险。

常见高危包及其默许风险模式

• net/http：ServeMux 默认不校验 Host 头，易受虚拟主机混淆攻击；http.FileServer 若未显式封装，直接暴露目录遍历能力
• path/filepath：Clean() 和 Join() 在 Windows 下对 ..\ 处理宽松，配合用户输入可突破根路径限制
• encoding/json：Unmarshal 默认允许重复键覆盖、支持 interface{} 反序列化任意结构，易触发无限递归或类型混淆
• os/exec：Command 若拼接用户输入至 args 参数（尤其含 shell 元字符），将绕过命令隔离机制

关键防御实践示例

使用 http.StripPrefix + 自定义 http.Handler 替代裸 FileServer，强制路径规范化并拦截越界访问：

func safeFileServer(root http.FileSystem, prefix string) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // 强制移除前缀并清理路径
        path := strings.TrimPrefix(r.URL.Path, prefix)
        cleanPath := filepath.Clean("/" + path) // 归一化为绝对路径
        if cleanPath != "/"+path || strings.Contains(cleanPath, "..") {
            http.Error(w, "Forbidden", http.StatusForbidden)
            return
        }
        http.FileServer(root).ServeHTTP(w, r)
    })
}

安全配置速查表

包名	危险函数/类型	安全替代方案
net/url	Parse()（未校验）	配合 url.Userinfo 检查认证字段合法性
strings	ReplaceAll()	使用正则 regexp.MustCompile 限定替换范围
encoding/xml	Unmarshal	启用 DisallowUnknownFields() 选项

所有标准库安全边界均依赖开发者主动启用防护层，而非运行时自动拦截。忽视初始化参数、忽略文档中标注的“security note”、或过度信任 Clean() 类函数的“安全性”，是多数线上事故的共同起点。

第二章：crypto包的加密安全实践

2.1 crypto/aes与crypto/cipher：避免ECB模式与弱IV的工程化规避

为什么ECB是密码学反模式

ECB（Electronic Codebook）对相同明文块始终生成相同密文块，暴露数据结构。图像加密后仍可辨轮廓即为典型例证。

安全实践三原则

• ✅ 强制使用CBC、GCM等带IV/nonce的模式
• ✅ IV必须随机且唯一（crypto/rand.Read(iv)）
• ❌ 禁止硬编码IV或复用IV

正确使用AES-GCM示例

// 生成12字节随机nonce（GCM推荐长度）
nonce := make([]byte, 12)
rand.Read(nonce) // 必须每次加密都新生成

block, _ := aes.NewCipher(key)
aesgcm, _ := cipher.NewGCM(block)
ciphertext := aesgcm.Seal(nil, nonce, plaintext, nil) // 认证加密

nonce不可重复；Seal自动追加认证标签（16字节），Open时校验完整性。GCM兼具机密性与完整性，替代CBC+HMAC组合。

模式	是否需IV	抗重放	认证能力
ECB	否	❌	❌
CBC	是	❌	❌
GCM	是	✅	✅

graph TD
    A[原始明文] --> B[随机Nonce + 密钥]
    B --> C[AES-GCM加密]
    C --> D[密文+Tag]
    D --> E[网络传输]

2.2 crypto/tls：禁用不安全协议版本与证书验证绕过的代码级防御

安全 TLS 配置的核心原则

必须显式禁用 TLS 1.0/1.1，强制启用 TLS 1.2+；同时杜绝 InsecureSkipVerify: true 的生产使用。

关键配置代码示例

config := &tls.Config{
    MinVersion: tls.VersionTLS12,
    MaxVersion: tls.VersionTLS13,
    InsecureSkipVerify: false, // 绝不允许设为 true
    VerifyPeerCertificate: func(rawCerts [][]byte, verifiedChains [][]*x509.Certificate) error {
        // 自定义证书链校验逻辑（如 OCSP stapling 验证）
        return nil
    },
}

逻辑分析：MinVersion 和 MaxVersion 硬性约束协议范围，规避 POODLE、BEAST 等旧版漏洞；InsecureSkipVerify: false 是默认值，但显式声明可防止误配；VerifyPeerCertificate 提供扩展点，替代脆弱的 InsecureSkipVerify。

常见错误配置对比

风险项	不安全写法	安全写法
协议版本	MinVersion: tls.VersionTLS10	MinVersion: tls.VersionTLS12
证书验证	InsecureSkipVerify: true	InsecureSkipVerify: false + 自定义校验

graph TD
    A[Client Hello] --> B{Server Config<br>MinVersion ≥ TLS1.2?}
    B -->|否| C[拒绝握手]
    B -->|是| D[执行证书链验证]
    D -->|失败| E[终止连接]
    D -->|通过| F[建立加密通道]

2.3 crypto/rand：区分math/rand与crypto/rand的熵源误用场景及修复方案

常见误用场景

• 使用 math/rand 生成 API Token、加密密钥或会话 ID
• 在 init() 中仅调用 rand.Seed(time.Now().UnixNano()) 后复用全局 *rand.Rand
• 将 math/rand.Intn(1<<32) 用于生成一次性密码（TOTP）种子

熵源本质差异

维度	math/rand	crypto/rand
设计目标	快速伪随机数（统计均匀）	密码学安全随机数（不可预测）
熵源	用户态种子（易被推测）	操作系统 CSPRNG（/dev/urandom, BCryptGenRandom）
并发安全	❌ 需显式加锁	✅ 全局线程安全

// ❌ 危险：math/rand 生成 JWT 密钥
var badKey = []byte(fmt.Sprintf("secret-%d", rand.Int63())) // 种子可被爆破，序列可重现

// ✅ 正确：crypto/rand 读取系统熵池
key := make([]byte, 32)
_, err := rand.Read(key) // 参数 key 为输出缓冲区；返回实际读取字节数与错误
if err != nil {
    log.Fatal(err) // 如 /dev/urandom 不可用则 panic
}

rand.Read(key) 直接从 OS 熵源填充切片，无中间伪随机算法，避免状态泄露风险。

graph TD
    A[应用请求随机字节] --> B{选择熵源}
    B -->|crypto/rand| C[OS 内核 CSPRNG]
    B -->|math/rand| D[用户态 LCG 算法]
    C --> E[不可预测、抗侧信道]
    D --> F[可重现、易被逆向]

2.4 crypto/hmac与crypto/sha256：防范长度扩展攻击与密钥派生不当的实战检测

HMAC 不是简单地 sha256(key + data)，而是通过两次哈希与密钥掩码（ipad/opad）隔离内部状态，从根本上阻断长度扩展攻击。

为什么裸 SHA256(k||m) 危险？

// ❌ 危险模式：攻击者可利用 SHA256 的 Merkle-Damgård 结构，
// 在已知 hash = sha256(k||m) 的前提下，构造 hash' = sha256(k||m||padding||m')，
// 无需知道 k —— 这就是长度扩展攻击
h := sha256.Sum256()
h = sha256.Sum256(append([]byte(k), m...)) // 绝对禁止！

逻辑分析：sha256 是迭代压缩函数，初始状态可被恢复；k 长度未知导致 padding 位置不可控，攻击面完全暴露。

正确实践：始终使用 crypto/hmac

// ✅ 安全模式：HMAC-SHA256 内置密钥混淆与双重哈希
h := hmac.New(sha256.New, []byte("secret-key"))
h.Write([]byte("message"))
mac := h.Sum(nil) // 输出32字节，抗长度扩展

参数说明：hmac.New 将密钥通过 opad ⊕ (ipad ⊕ key) 映射为两个独立伪随机密钥，确保内部状态不可推导。

风险类型	裸 SHA256(k		m)	HMAC-SHA256
长度扩展攻击	✅ 可行	❌ 不可能
密钥短于块长（64B）	未填充 → 弱熵	自动密钥扩展
侧信道泄露密钥长度	可能	恒定时间比较支持

graph TD
    A[原始密钥 k] --> B[Key Expansion<br>ipad ⊕ k / opad ⊕ k]
    B --> C[Inner Hash: H[k⊕ipad || msg]]
    C --> D[Outer Hash: H[k⊕opad || inner_hash]]
    D --> E[固定长度 MAC]

2.5 crypto/x509：证书链验证缺失、Name Constraints绕过及自签名证书滥用治理

常见验证漏洞模式

crypto/x509 默认不强制执行完整证书链验证，易导致中间CA绕过或信任锚误设。关键风险点包括：

• VerifyOptions.Roots == nil 时回退至系统根证书池，但忽略 NameConstraints 检查
• VerifyOptions.KeyUsages 未显式指定时，ExtKeyUsageServerAuth 等用途校验失效
• 自签名证书若被错误加入 VerifyOptions.Roots，将跳过签名验证（仅校验有效期与基本约束）

Name Constraints 绕过示例

// ❌ 危险：未启用 NameConstraints 验证
opts := x509.VerifyOptions{
    Roots:         rootPool,
    CurrentTime:   time.Now(),
    // 缺失：DNSName 或 IPAddresses 字段未传入，导致 constraints 被跳过
}
_, err := cert.Verify(opts) // 可能接受 *.evil.com 签发的子域证书

逻辑分析：x509.Certificate.Verify() 仅在 opts.DNSName != "" || opts.IPAddresses != nil 时触发 nameConstraintsValid() 校验；否则直接跳过约束检查，使恶意子CA可签发任意域名证书。

治理建议对照表

风险类型	安全配置方式	是否默认启用
证书链完整性	显式设置 VerifyOptions.Roots	否
Name Constraints	必须传入 DNSName 或 IPAddresses	否
自签名证书信任	禁止将 cert.IsSelfSigned() 证书加入 Roots	否

graph TD
    A[客户端调用 Verify] --> B{opts.DNSName/IPAddresses 是否非空？}
    B -->|是| C[执行 nameConstraintsValid]
    B -->|否| D[跳过约束检查]
    C --> E[校验通过？]
    D --> F[仅校验签名/有效期]

第三章：net/url与net/http的安全边界控制

3.1 URL解析歧义与Open Redirect漏洞的标准化校验流程

URL解析歧义常源于协议头截断、Unicode规范化差异及路径归一化不一致，为Open Redirect漏洞埋下隐患。

核心校验维度

• 协议白名单（https?://, ftp://）
• 主机名严格匹配（禁止@绕过、IDN homograph）
• 路径绝对化校验（拒绝//evil.com、/\\google.com等混合分隔符）

标准化解析流程

from urllib.parse import urlparse, urlunparse

def normalize_redirect_url(url: str) -> str:
    parsed = urlparse(url)
    # 强制小写协议 + 规范化主机名（ASCII-only）
    scheme = parsed.scheme.lower()
    netloc = parsed.netloc.encode('idna').decode('ascii').lower()
    # 清除空路径、标准化斜杠
    path = parsed.path.rstrip('/') or '/'
    return urlunparse((scheme, netloc, path, parsed.params, parsed.query, ''))

逻辑分析：encode('idna')将Unicode域名转为Punycode，杜绝homograph攻击；path.rstrip('/') or '/'确保路径非空且无冗余尾斜杠，避免/path//redirect被中间件误解析。

检查项	合规示例	危险模式
协议头	https://a.com	javascript:alert(1)
主机名	example.com	evil.com@trusted.com
路径归一化	/login	/%2e%2e//admin

graph TD
    A[原始URL] --> B{协议白名单？}
    B -->|否| C[拒绝]
    B -->|是| D{主机ASCII化成功？}
    D -->|否| C
    D -->|是| E[路径绝对化+归一化]
    E --> F[返回标准化URL]

3.2 net/http/httputil反向代理中的请求走私（HTTP Smuggling）防护策略

HTTP Smuggling 利用前后端对 Transfer-Encoding 与 Content-Length 解析不一致发起攻击。net/http/httputil.ReverseProxy 默认不校验请求头一致性，需主动加固。

关键防护措施

• 禁用模糊编码：移除 Transfer-Encoding: chunked 以外的所有 TE 值
• 强制头标准化：统一归一化 Content-Length 和 Transfer-Encoding
• 请求头预检：在 Director 中拦截非法组合

请求头一致性校验代码

func sanitizeRequest(req *http.Request) error {
    if req.TransferEncoding != nil && len(req.TransferEncoding) > 0 {
        if len(req.TransferEncoding) > 1 || req.TransferEncoding[0] != "chunked" {
            return fmt.Errorf("multiple or non-chunked Transfer-Encoding disallowed")
        }
    }
    if req.ContentLength < 0 && req.TransferEncoding == nil {
        return fmt.Errorf("neither Content-Length nor chunked encoding present")
    }
    return nil
}

该函数在代理转发前校验：若存在非 chunked 的 Transfer-Encoding，或两者均缺失，则拒绝请求，阻断 CL-TE/TE-CL smuggling 路径。

风险头组合	是否允许	原因
Content-Length: 0 + Transfer-Encoding: chunked	✅	标准兼容，后端按 chunked 处理
Content-Length: 5 + Transfer-Encoding: gzip, chunked	❌	多重编码违反 HTTP/1.1 规范

graph TD
    A[Client Request] --> B{SanitizeRequest}
    B -->|Valid| C[Forward to Backend]
    B -->|Invalid| D[Return 400 Bad Request]

3.3 http.Request.Host与http.Request.URL.Scheme的可信源判定机制重构

传统 HTTP 请求中，r.Host 和 r.URL.Scheme 均可能被客户端伪造，直接用于反向代理或重定向逻辑将导致 Host 头攻击或混合内容漏洞。

可信源判定核心原则

• Host 必须经由 TLS SNI 或负载均衡器 X-Forwarded-Host（需白名单校验）确认；
• Scheme 应严格依据终止 TLS 的边界设备（如 ingress controller）注入的 X-Forwarded-Proto，而非解析 r.URL。

重构后的校验流程

func trustedHostAndScheme(r *http.Request, cfg Config) (host, scheme string) {
    host = r.Header.Get("X-Forwarded-Host")
    if !cfg.HostWhitelist.Contains(host) {
        host = r.Host // fallback only if not in trusted reverse proxy chain
    }
    scheme = r.Header.Get("X-Forwarded-Proto")
    if scheme != "http" && scheme != "https" {
        scheme = "https" // default to TLS-terminated assumption
    }
    return host, scheme
}

此函数弃用 r.URL.Scheme 和原始 r.Host，强制通过可信 HTTP 头 + 白名单双因子校验。cfg.HostWhitelist 为预置域名集合，防止 DNS rebinding；X-Forwarded-Proto 由入口网关统一注入，不可绕过。

来源字段	是否可信	依据
r.Host	❌	客户端可控
r.URL.Scheme	❌	解析自请求行，易被篡改
X-Forwarded-Host	✅（条件）	需匹配白名单
X-Forwarded-Proto	✅	仅允许入口网关写入

graph TD
    A[Client Request] --> B{Ingress Controller}
    B -->|Injects X-Forwarded-*| C[App Server]
    C --> D[Validate Host against Whitelist]
    C --> E[Enforce Scheme from X-Forwarded-Proto]
    D --> F[Trusted Host]
    E --> G[Trusted Scheme]

第四章：encoding/json与encoding/xml的反序列化防线

4.1 json.Unmarshal的类型混淆与DoS风险：深度嵌套与超长键名的限流熔断实现

json.Unmarshal 在解析恶意构造的 JSON 时，可能因无限递归嵌套或超长键名触发栈溢出、内存耗尽或哈希碰撞，导致服务拒绝（DoS）。

风险场景示例

• 深度嵌套对象（{"a":{"b":{"c":{...}}}}，嵌套千层）
• 超长键名（如 {"a" + "x" * 10MB: "val"}）
• 类型混淆：同一字段在不同请求中交替为 string/object，破坏结构体绑定逻辑

熔断限流策略

type SafeUnmarshaler struct {
    MaxDepth    int
    MaxKeyLen   int
    MaxTotalLen int
}

func (s *SafeUnmarshaler) Unmarshal(data []byte, v interface{}) error {
    if len(data) > s.MaxTotalLen {
        return errors.New("JSON too large")
    }
    // 使用 jsoniter 配置限深 & 键长校验钩子
    return jsoniter.ConfigCompatibleWithStandardLibrary.
        DisallowUnknownFields().
        ValidateJsonRawMessage().
        NewDecoderBytes(data).Decode(v)
}

该实现通过预检字节长度与定制解码器，在解析前拦截非法输入；MaxDepth 控制递归层级，MaxKeyLen 防御哈希洪水攻击。

风险类型	触发条件	防御手段
深度嵌套	嵌套 > 100 层	Decoder.SetLimit()
超长键名	单 key > 1024 字符	自定义 UnmarshalJSON
类型混淆	动态字段类型不一致	启用 DisallowUnknownFields

graph TD
    A[原始JSON] --> B{长度/深度预检}
    B -->|超限| C[返回ErrBadRequest]
    B -->|合规| D[安全Decoder解析]
    D --> E[结构体绑定]
    E --> F[类型一致性校验]

4.2 xml.Unmarshal的XXE（XML External Entity）攻击禁用与安全解码器封装

XML解析默认启用外部实体（XXE），xml.Unmarshal若直接处理不可信输入，可能触发文件读取、SSRF或DoS攻击。

安全解码器封装原则

• 禁用DTD解析
• 禁用外部实体加载
• 设置自定义EntityReader为nil

func SafeUnmarshal(data []byte, v interface{}) error {
    dec := xml.NewDecoder(bytes.NewReader(data))
    dec.Entity = nil                    // 清空实体映射表
    dec.Strict = false                  // 允许宽松语法（非关键，但避免因格式拒收）
    dec.DefaultSpace = ""               // 防止命名空间污染
    return dec.Decode(v)
}

dec.Entity = nil强制忽略所有<!ENTITY>声明；Strict=false避免因非标准XML结构panic，但不降低XXE防护等级。

XXE防护能力对比

方式	DTD解析	外部实体	内存爆炸风险
默认 xml.Unmarshal	✅	✅	高
xml.NewDecoder + Entity=nil	❌	❌	低

graph TD
    A[原始XML输入] --> B{含<!DOCTYPE>?}
    B -->|是| C[触发Entity解析]
    B -->|否| D[安全进入字段映射]
    C --> E[阻断：Entity=nil]

4.3 struct tag安全约束：omitempty滥用导致敏感字段泄露的静态分析与运行时拦截

omitempty 本用于 JSON 序列化时跳过零值字段，但若误用于 password, token, api_key 等敏感字段，将导致空字符串或零值被静默忽略——反序列化后字段仍为零值，而业务逻辑可能误判为“未提供”，进而跳过校验，造成越权访问。

常见危险模式

• 敏感字段声明为 string 且带 omitempty（如 Password stringjson:”password,omitempty”`）
• 结构体嵌套中父级 omitempty 传导至子敏感字段
• 使用 map[string]interface{} 动态解码时绕过结构体约束

静态检测规则示例

// 检测敏感字段是否错误使用 omitempty
type User struct {
    ID       int    `json:"id"`
    Password string `json:"password,omitempty"` // ⚠️ 危险：空密码被忽略，校验失效
}

分析：Password 字段类型为 string，零值为 ""；当客户端传 {"password":""}，omitempty 使其从输出中消失，json.Unmarshal 后仍为 ""，但服务端可能因字段“不存在”跳过非空校验。参数 omitempty 在此处破坏了数据完整性语义。

运行时拦截方案对比

方案	拦截时机	覆盖场景	性能开销
json.Unmarshal Hook	解码后	所有反射路径	中（需遍历字段）
Validator 中间件	业务入口前	HTTP/GRPC 层	低（仅校验标记字段）
unsafe 字段写保护	内存层	极端场景（如 WASM）	高（需 patch runtime）

graph TD
    A[HTTP Request] --> B{JSON Body}
    B --> C[json.Unmarshal]
    C --> D[字段零值检查]
    D -->|含敏感tag且为零值| E[panic/err: “password omitted”]
    D -->|合规| F[继续业务流程]

4.4 自定义UnmarshalJSON方法中的反射逃逸与循环引用陷阱规避指南

反射导致的堆逃逸问题

json.Unmarshal 默认使用反射解析，当结构体字段含指针或接口时，Go 编译器常将临时值分配到堆，引发性能损耗。

循环引用引发的无限递归

若 A 持有 *B，B 又持有 *A，且 UnmarshalJSON 未做访问标记，将触发栈溢出。

安全解码模式（带缓存检测）

func (a *A) UnmarshalJSON(data []byte) error {
    type Alias A // 防止递归调用自身
    aux := &struct {
        *Alias
        BRef *B `json:"b,omitempty"`
    }{Alias: (*Alias)(a)}

    if err := json.Unmarshal(data, aux); err != nil {
        return err
    }

    // 手动处理 B 的反序列化，跳过已见实例
    if aux.BRef != nil && seenObjects.Contains(aux.BRef) {
        return errors.New("circular reference detected")
    }
    seenObjects.Add(aux.BRef)
    a.B = aux.BRef
    return nil
}

逻辑说明：通过 type Alias A 断开嵌入式递归；seenObjects 是 map[uintptr]bool，键为 uintptr(unsafe.Pointer(obj))，避免反射逃逸的同时实现循环检测。

问题类型	触发条件	规避策略
反射逃逸	字段含 interface{} 或未导出字段	使用 type Alias T + 显式字段映射
循环引用	结构体间双向指针引用	引入地址级访问缓存（unsafe.Pointer）

graph TD
    A[UnmarshalJSON] --> B{是否已见该指针?}
    B -- 是 --> C[报错退出]
    B -- 否 --> D[记录地址]
    D --> E[执行字段赋值]

第五章：Go标准库安全演进趋势与长期维护建议

标准库加密模块的渐进式淘汰路径

Go 1.22起，crypto/rc4 和 crypto/md5 包被标记为 Deprecated，但未强制移除。某金融中间件项目在升级至 Go 1.23 后遭遇 CI 失败：其自定义 TLS 握手扩展仍调用 md5.Sum() 计算非敏感会话标识符。修复方案并非简单替换为 sha256，而是结合 crypto/hmac 与随机盐值重构签名逻辑，并通过 go vet -tags=security 自定义检查器捕获残留调用。该实践已沉淀为团队 gosec 规则集中的 G107 扩展项。

HTTP 安全头默认行为的版本分水岭

下表对比不同 Go 版本中 net/http 对关键安全头的默认处理：

Go 版本	X-Content-Type-Options	Strict-Transport-Security	Content-Security-Policy 默认注入
1.19	❌ 不设置	❌ 需手动配置	❌ 无
1.21	✅ nosniff（仅 ServeFile）	✅ max-age=31536000（HTTPS）	❌
1.23	✅ 全局 Handler 响应默认启用	✅ 支持 includeSubDomains 参数	✅ default-src 'self'（开发模式）

某政务 API 网关在迁移至 Go 1.23 后，因 CSP 默认策略阻断了内联 SVG 渲染，最终通过 http.ServeMux 中间件动态清除 Content-Security-Policy 头（仅限白名单路径）解决。

crypto/tls 配置陷阱与自动化检测

以下代码片段曾导致某支付 SDK 在 TLS 1.0 环境下静默降级：

config := &tls.Config{
    MinVersion: tls.VersionTLS10, // ❌ 旧版兼容陷阱
    CurvePreferences: []tls.CurveID{tls.CurveP256},
}

实际应强制禁用弱协议并启用 CurvePreferences 安全基线：

config := &tls.Config{
    MinVersion:         tls.VersionTLS12,
    MaxVersion:         tls.VersionTLS13,
    CurvePreferences:   []tls.CurveID{tls.X25519, tls.CurveP256},
    CipherSuites:       []uint16{tls.TLS_AES_256_GCM_SHA384},
}

团队已将此规则集成至 CI 流程，使用 goast 解析 AST 并校验 tls.Config 字段赋值。

长期维护的依赖锚点策略

为规避标准库安全补丁引发的语义变更风险，采用「锚定版本+灰度验证」机制：

• 在 go.mod 中显式声明 go 1.22（而非 1.23）作为构建基准
• 每月首个周五执行自动化回归测试：拉取最新 golang:alpine 镜像，运行包含 crypto/ed25519 签名验证、net/http/httputil.ReverseProxy 请求头透传等 17 个安全敏感用例
• 发现 net/textproto 的 CanonicalMIMEHeaderKey 行为变更（Go 1.23.1 修复 CVE-2023-45288）后，立即冻结该镜像标签并同步更新内部 mime.Header 封装层

构建时安全加固流水线

flowchart LR
    A[go mod download] --> B[go list -json -deps ./...]
    B --> C[扫描 stdlib import 路径]
    C --> D{是否含 crypto/bcrypt?}
    D -->|是| E[触发 bcrypt cost=12 强制校验]
    D -->|否| F[跳过]
    E --> G[生成 SBOM 并注入 Trivy 扫描]