容器安全扫描：Trivy 漏洞检测原理

深度解析开源容器安全工具 Trivy 的漏洞检测机制、架构设计与最佳实践

📋 目录

• 一、Trivy 概述
• 二、核心架构设计
• 三、漏洞检测原理
• 四、数据库机制
• 五、扫描模式详解
• 六、源码深度分析
• 七、实战应用场景
• 八、性能优化策略
• 九、与工具对比
• 十、最佳实践

---

一、Trivy 概述

1.1 什么是 Trivy

Trivy（ pronounced trih-vee ）是一个全面的安全扫描工具，由 Aqua Security 开源并维护。作为云原生计算基金会（CNCF）的沙箱项目，Trivy 专门设计用于检测容器镜像、文件系统、Git 仓库、Kubernetes 集群等目标中的安全漏洞和配置问题。

1.2 核心特性

特性类别	功能描述
多目标支持	容器镜像、文件系统、Git 仓库、Kubernetes、配置文件
全面覆盖	操作系统软件包（Alpine、Debian、RHEL 等）、语言特定依赖（npm、pip、maven 等）、基础设施即代码（IaC）
漏洞数据库	实时同步 NVD、GitHub Advisories、Red Hat、SUSE 等多个漏洞源
SBOM 支持	生成软件物料清单（SBOM）并基于其进行漏洞扫描
零配置	开箱即用，无需复杂配置
高精度	误报率低，支持二进制级别分析
快速扫描	并行扫描、缓存机制、增量更新

1.3 应用场景

---

二、核心架构设计

2.1 整体架构

Trivy 采用模块化架构，核心组件包括：

2.2 核心模块职责

2.2.1 Scanner 模块

• 文件位置: pkg/scanner/scanner.go (v0.50.0)
• 职责: 扫描任务协调器，负责目标解析和扫描器路由

2.2.2 Detector 模块

• 文件位置: pkg/detector/detector.go
• 职责: 实现具体的漏洞检测逻辑，支持多种包管理器

2.2.3 Database 模块

• 文件位置: pkg/db/db.go
• 职责: 漏洞数据库管理，包括下载、更新、查询

2.2.4 Types 模块

• 文件位置: pkg/types/types.go
• 职责: 定义核心数据结构，统一抽象

2.3 数据流转

// 数据流简化示意（伪代码）
func Scan(ctx context.Context, target ScanTarget) (results *Result, err error) {
    // 1. 解析目标
    artifacts := ParseTarget(target)
    
    // 2. 检测已安装的包
    packages := DetectPackages(artifacts)
    
    // 3. 从数据库加载漏洞数据
    vulns := LoadVulnerabilities(packages)
    
    // 4. 匹配漏洞与包
    results := MatchPackagesWithVulnerabilities(packages, vulns)
    
    // 5. 应用过滤器和误报处理
    filtered := ApplyFilters(results)
    
    return filtered, nil
}

---

三、漏洞检测原理

3.1 检测流程详解

Trivy 的漏洞检测是一个多阶段流程，其核心是将已安装的软件包与已知漏洞数据库进行精确匹配。

3.2 包管理器检测

Trivy 支持 20+ 种包管理器，通过特征文件自动识别：

包管理器	特征文件路径	检测逻辑
dpkg (Debian/Ubuntu)	/var/lib/dpkg/status	解析已安装包列表
apk (Alpine)	/lib/apk/db/installed	读取 Alpine 包数据库
rpm (RHEL/CentOS/Fedora)	/var/lib/rpm/Packages	使用 RPM 库读取
npm (Node.js)	package-lock.json	解析锁文件中的依赖树
pip (Python)	requirements.txt, Pipfile.lock	解析 Python 依赖
maven (Java)	pom.xml, .classpath	解析 Maven 坐标
go (Go)	go.sum	解析 Go 模块校验和

3.3 版本匹配算法

Trivy 使用语义化版本（SemVer）和版本范围比较来确定漏洞是否影响特定包版本：

// pkg/vulnerability/version.go (v0.50.0)
// 版本比较逻辑

// VersionInterface 定义版本比较接口
type VersionInterface interface {
    Compare(version string) (int, error)
}

// 版本匹配核心算法
func matchVersion(versions []AffectedVersion, installedVersion string) bool {
    for _, v := range versions {
        // 遍历受影响的版本范围
        if v.Introduced != "" && v.Fixed != "" {
            // 情况1: 引入版本 <= 安装版本 < 修复版本
            if compare(installedVersion, v.Introduced) >= 0 &&
               compare(installedVersion, v.Fixed) < 0 {
                return true
            }
        } else if v.Introduced != "" {
            // 情况2: 引入版本 <= 安装版本
            if compare(installedVersion, v.Introduced) >= 0 {
                return true
            }
        } else if v.Fixed != "" {
            // 情况3: 安装版本 < 修复版本
            if compare(installedVersion, v.Fixed) < 0 {
                return true
            }
        }
    }
    return false
}

3.4 实战示例：解析 Alpine APK

#!/bin/bash
# Alpine Linux APK 数据库解析实战
# 文件位置: /lib/apk/db/installed

# 1. 查看安装包数据库格式
cat > /tmp/apk_parser.sh << 'EOF'
#!/bin/bash
# Alpine APK 数据库解析器
# 参考: pkg/detector/apk/apk.go (v0.50.0)

APK_DB="/lib/apk/db/installed"

parse_apk_db() {
    local db_file=$1
    local pkg_name=""
    local pkg_version=""
    local pkg_arch=""
    
    echo "解析 Alpine APK 数据库: $db_file"
    echo "======================================"
    
    while IFS= read -r line; do
        # APK 数据库格式：每个包以空行分隔
        # 字段格式: KEY:VALUE
        
        if [[ -z "$line" ]]; then
            # 空行表示一个包的结束
            if [[ -n "$pkg_name" ]]; then
                echo "发现包: $pkg_name"
                echo "  版本: $pkg_version"
                echo "  架构: $pkg_arch"
                echo "---"
            fi
            # 重置变量
            pkg_name=""
            pkg_version=""
            pkg_arch=""
        else
            # 解析键值对
            key="${line%%:*}"
            value="${line#*:}"
            
            case "$key" in
                P) pkg_name="$value" ;;       # Package name
                V) pkg_version="$value" ;;    # Version
                A) pkg_arch="$value" ;;       # Architecture
                T) ;;                         # Tag (skip)
                I) ;;                         # Installed size (skip)
                S) ;;                         # Size (skip)
                D) ;;                         # Description (skip)
                o) ;;                         # Origin (skip)
                m) ;;                         // Maintainer (skip)
                U) ;;                         # URL (skip)
                L) ;;                         # License (skip)
            esac
        fi
    done < "$db_file"
}

# 使用示例
if [[ -f "$APK_DB" ]]; then
    parse_apk_db "$APK_DB"
else
    echo "APK 数据库不存在: $APK_DB"
    echo "请在 Alpine 容器中运行此脚本"
fi
EOF

chmod +x /tmp/apk_parser.sh

# 2. 在 Alpine 容器中测试
docker run --rm -v /tmp/apk_parser.sh:/apk_parser.sh alpine:3.18 sh /apk_parser.sh

---

四、数据库机制

4.1 数据库架构

Trivy 维护三个独立的数据库：

4.2 数据库下载与更新

// pkg/db/db.go (v0.50.0)
// 数据库下载与更新逻辑

// Client 数据库客户端
type Client struct {
    dbc      db.Operation
    cacheDir string
    batch    db.Config
}

// Download 下载数据库
func (c *Client) Download(ctx context.Context, opts types.DBOption) error {
    // 1. 确定数据库类型和目录
    dbDir := c.cacheDir
    
    // 2. 下载指定数据库
    for _, target := range []struct {
        name string
        path string
    }{
        {"vulnerability", vulnerabilityPath},
        {"java", javaPath},
    } {
        if err := downloadDB(ctx, dbDir, target.path, opts); err != nil {
            return fmt.Errorf("下载 %s 数据库失败: %w", target.name, err)
        }
    }
    
    return nil
}

// downloadDB 实际下载函数
func downloadDB(ctx context.Context, cacheDir, dbPath string, opts types.DBOption) error {
    // 1. 检查本地缓存
    if opts.SkipUpdate && dbExists(cacheDir, dbPath) {
        return nil
    }
    
    // 2. 从 GitHub Releases 下载
    url := fmt.Sprintf("https://github.com/aquasecurity/trivy-db/releases/latest/download/%s", dbPath)
    
    // 3. 下载并解压到缓存目录
    if err := downloadAndExtract(ctx, url, cacheDir); err != nil {
        return err
    }
    
    return nil
}

4.3 数据库格式

Trivy 使用 boltDB 作为嵌入式数据库引擎：

// pkg/db/types.go (v0.50.0)
// 数据库键值对结构

// VulnerabilityDetail 漏洞详情
type VulnerabilityDetail struct {
    ID          string            `json:"id"`          // CVE ID
    DataSource  string            `json:"source"`      // NVD, GHSA, etc.
    CvssScore   float64           `json:"cvss"`        // CVSS 评分
    CvssVector  string            `json:"vector"`      // CVSS 向量
    Severity    types.Severity    `json:"severity"`    // 严重程度
    Title       string            `json:"title"`       // 标题
    Description string            `json:"description"` // 描述
    References  []string          `json:"references"`  // 参考链接
}

// Adversary 受影响版本
type Adversary struct {
    Module    string `json:"module"`     // 模块名（Java）
    Introduced string `json:"introduced"` // 引入版本
    Fixed     string `json:"fixed"`      // 修复版本
}

// boltDB 键值设计
// Key:   [ecosystem] + [package_name]
// Value: []VulnerabilityDetail
//
// 示例:
// Key: "alpine:openssl"
// Value: [
//   {
//     "id": "CVE-2023-0286",
//     "severity": "CRITICAL",
//     "fixed_version": "3.0.8-r3"
//   }
// ]

4.4 数据库更新策略

#!/bin/bash
# Trivy 数据库更新策略

# 策略1: 手动更新数据库
trivy image --download-db-only

# 策略2: 定期自动更新（每小时）
trivy image --skip-db-update  # 跳过本次更新
export TRIVY_SKIP_DB_UPDATE=true  # 环境变量控制

# 策略3: 指定数据库下载位置
export TRIVY_CACHE_DIR=/custom/cache/dir
trivy image python:3.9

# 策略4: 空气间隙环境（离线扫描）
# 在有网络的机器上:
trivy image --download-db-only
# 然后将 $HOME/.cache/trivy 复制到离线机器

# 策略5: 自定义数据库源（私有镜像）
export TRIVY_DB_REPOSITORY="my-registry.com/trivy-db"
trivy image --download-db-only

# 策略6: 数据库版本控制
trivy image --db-repository "ghcr.io/aquasecurity/trivy-db:0.10.0"

4.5 数据库对比

特性	Vulnerability DB	Java DB	Compliance DB
数据源	NVD, GHSA, 厂商 Advisory	Maven Central, GHSA	自定义规则
更新频率	每日	每日	手动
文件大小	~100MB	~500MB	~1MB
覆盖范围	OS 包, 语言依赖	仅 Java	IaC, 配置
用途	漏洞扫描	Java 特定漏洞	配置审计

---

五、扫描模式详解

5.1 容器镜像扫描

镜像扫描是 Trivy 最常用的功能，支持多种扫描策略：

#!/bin/bash
# 容器镜像扫描实战示例

# 基础扫描（扫描所有层）
trivy image python:3.9

# 仅扫描严重漏洞
trivy image --severity HIGH,CRITICAL python:3.9

# 扫描并忽略未修复漏洞
trivy image --ignore-unfixed python:3.9

# 输出 JSON 格式（CI/CD 集成）
trivy image --format json --output results.json nginx:latest

# 使用缓存加速
trivy image --cache-dir /tmp/trivy-cache redis:7

# 扫描特定架构
trivy image --arch arm64 ubuntu:22.04

# 扫描本地镜像（不联网）
docker pull alpine:3.18
trivy image --skip-db-update alpine:3.18

# 扫描镜像 tar 包
docker save nginx:latest -o nginx.tar
trivy image --input nginx.tar

5.2 文件系统扫描

扫描宿主机文件系统，适用于服务器安全审计：

#!/bin/bash
# 文件系统扫描实战

# 扫描当前目录
trivy fs .

# 扫描指定目录
trivy fs /var/www/html

# 扫描并排除目录
trivy fs --skip-dirs "/tmp,/dev,/proc" /

# 扫描项目依赖
cd /path/to/python-project
trivy fs .

# 结合管道
trivy fs --format json . | jq '.Results[].Vulnerabilities | length'

5.3 Git 仓库扫描

扫描代码库中的依赖漏洞：

#!/bin/bash
# Git 仓库扫描实战

# 克隆并扫描仓库
git clone https://github.com/user/project.git
cd project
trivy repo .

# 扫描特定分支
trivy repo --branch develop .

# 扫描特定提交
trivy repo --commit abc123def .

# 扫描远程仓库（无需克隆）
trivy repo https://github.com/user/project.git

# 仅扫描特定依赖文件
trivy repo --skip-files "*/test/*" .

5.4 Kubernetes 集群扫描

扫描运行中的 Kubernetes 集群：

#!/bin/bash
# Kubernetes 集群扫描实战

# 扫描当前上下文的所有命名空间
trivy k8s --all-namespaces

# 扫描特定命名空间
trivy k8s --namespace production

# 扫描特定资源类型
trivy k8s --resource pod,deployment

# 输出详细报告
trivy k8s --format table --output k8s-report.txt

# 扫描并自动修复（experimental）
trivy k8s --namespace dev --dry-run

5.5 扫描模式对比

扫描模式	目标类型	使用场景	速度	准确性
image	容器镜像	CI/CD 流水线	⭐⭐⭐⭐	⭐⭐⭐⭐⭐
filesystem	文件系统	主机审计	⭐⭐⭐⭐⭐	⭐⭐⭐⭐
repository	Git 仓库	开发阶段	⭐⭐⭐	⭐⭐⭐⭐
k8s	K8s 集群	运行时保护	⭐⭐	⭐⭐⭐⭐
config	配置文件	IaC 扫描	⭐⭐⭐⭐⭐	⭐⭐⭐

---

六、源码深度分析

6.1 核心数据结构

// pkg/types/types.go (v0.50.0)
// Trivy 核心数据结构定义

// Result 扫描结果
type Result struct {
    Target          string          `json:"Target"`           // 扫描目标
    Class           string          `json:"Class"`            // 目标类型
    Type            string          `json:"Type"`             // 具体类型
    Vulnerabilities []DetectedVuln  `json:"Vulnerabilities"`  // 检测到的漏洞
    Packages        []Package       `json:"Packages"`         // 扫描的包
}

// DetectedVuln 检测到的漏洞
type DetectedVuln struct {
    VulnerabilityID  string            `json:"VulnerabilityID"`  // CVE ID
    PkgName          string            `json:"PkgName"`          // 包名
    InstalledVersion string            `json:"InstalledVersion"` // 安装版本
    FixedVersion     string            `json:"FixedVersion"`     // 修复版本
    Status           string            `json:"Status"`           // 状态
    PrimaryURL       string            `json:"PrimaryURL"`       // 主链接
    DataSource       *VulnDataSource   `json:"DataSource"`       // 数据源
    Title            string            `json:"Title"`            // 标题
    Description      string            `json:"Description"`      // 描述
    Severity         string            `json:"Severity"`         // 严重程度
    CVSS             map[string]CVSS   `json:"Cvss"`             // CVSS 评分
    References       []string          `json:"References"`       // 参考
    Layer            *Layer            `json:"Layer"`            // 镜像层
}

// Package 软件包
type Package struct {
    Name        string          `json:"name"`        // 包名
    Version     string          `json:"version"`     // 版本
    License     string          `json:"license"`     // 许可证
    SrcName     string          `json:"srcName"`     // 源包名
    SrcVersion  string          `json:"srcVersion"`  // 源版本
    PkgIdentifier PkgIdentifier `json:"identifier"`  // 标识符
    Maintainers []Maintainer    `json:"maintainers"` // 维护者
}

6.2 扫描器实现

// pkg/scanner/scanner.go (v0.50.0)
// 扫描器核心逻辑

// Scanner 扫描器接口
type Scanner interface {
    Scan(ctx context.Context, target interface{}, opt types.ScanOptions) (types.Result, error)
}

// FullScanner 完整扫描器实现
type FullScanner struct {
    vs     vulndb.Client
    jc     javadb.Client
    cc     compliance.Client
    logger *log.Logger
}

// Scan 执行扫描
func (s *FullScanner) Scan(ctx context.Context, target interface{}, opt types.ScanOptions) (types.Result, error) {
    var results types.Result
    
    // 1. 根据目标类型解析
    switch t := target.(type) {
    case types.Image:
        result, err := s.scanImage(ctx, t, opt)
        if err != nil {
            return types.Result{}, err
        }
        results = result
    case types.Filesystem:
        result, err := s.scanFS(ctx, t, opt)
        if err != nil {
            return types.Result{}, err
        }
        results = result
    // ... 其他目标类型
    }
    
    return results, nil
}

// scanImage 扫描容器镜像
func (s *FullScanner) scanImage(ctx context.Context, image types.Image, opt types.ScanOptions) (types.Result, error) {
    // 1. 解析镜像
    ref, err := reference.Parse(image.Name)
    if err != nil {
        return types.Result{}, err
    }
    
    // 2. 下载镜像清单
    desc, err := s.docker.Inspect(ctx, ref)
    if err != nil {
        return types.Result{}, err
    }
    
    // 3. 提取文件系统
    fs, err := s.docker.Export(ctx, ref)
    if err != nil {
        return types.Result{}, err
    }
    defer os.RemoveAll(fs)
    
    // 4. 扫描文件系统
    return s.scanFS(ctx, types.Filesystem{Dir: fs}, opt)
}

// scanFS 扫描文件系统
func (s *FullScanner) scanFS(ctx context.Context, fs types.Filesystem, opt types.ScanOptions) (types.Result, error) {
    // 1. 检测系统包
    osPackages, err := detector.DetectOSPkg(fs.Dir, opt)
    if err != nil {
        return types.Result{}, err
    }
    
    // 2. 检测语言包
    langPackages, err := detector.DetectLangPkg(fs.Dir, opt)
    if err != nil {
        return types.Result{}, err
    }
    
    // 3. 查询漏洞
    vulns, err := s.vs.Get(ctx, append(osPackages, langPackages...), opt)
    if err != nil {
        return types.Result{}, err
    }
    
    // 4. 格式化结果
    return types.Result{
        Target:          fs.Dir,
        Packages:        append(osPackages, langPackages...),
        Vulnerabilities: vulns,
    }, nil
}

6.3 检测器实现

// pkg/detector/detector.go (v0.50.0)
// 检测器核心逻辑

// DetectOSPkg 检测操作系统包
func DetectOSPkg(dir string, opt types.ScanOptions) ([]types.Package, error) {
    // 1. 自动检测操作系统类型
    osType := detectOS(dir)
    
    // 2. 根据操作系统选择对应的检测器
    var packages []types.Package
    var err error
    
    switch osType {
    case types.Alpine:
        packages, err = detectApk(dir)
    case types.Debian, types.Ubuntu:
        packages, err = detectDpkg(dir)
    case types.RedHat, types.CentOS, types.Fedora:
        packages, err = detectRpm(dir)
    case types.AmazonLinux:
        packages, err = detectRpm(dir)
    default:
        return nil, fmt.Errorf("不支持的操作系统类型: %s", osType)
    }
    
    return packages, err
}

// detectApk 检测 Alpine 包
func detectApk(rootDir string) ([]types.Package, error) {
    // APK 数据库位置
    installedPath := filepath.Join(rootDir, "lib/apk/db/installed")
    
    // 解析 APK 数据库
    f, err := os.Open(installedPath)
    if err != nil {
        return nil, err
    }
    defer f.Close()
    
    scanner := bufio.NewScanner(f)
    var packages []types.Package
    var currentPkg *types.Package
    
    for scanner.Scan() {
        line := scanner.Text()
        if line == "" {
            // 包结束
            if currentPkg != nil {
                packages = append(packages, *currentPkg)
                currentPkg = nil
            }
            continue
        }
        
        key := line[:1]
        value := line[2:]
        
        switch key {
        case "P": // Package name
            currentPkg = &types.Package{Name: value}
        case "V": // Version
            if currentPkg != nil {
                currentPkg.Version = value
            }
        case "A": // Architecture
            if currentPkg != nil {
                currentPkg.Identifier = types.PkgIdentifier{
                    Pkg: types.PkgIdentifierMetadata{
                        Arch: value,
                    },
                }
            }
        }
    }
    
    return packages, nil
}

6.4 漏洞匹配算法

// pkg/vulnerability/vulnerability.go (v0.50.0)
// 漏洞匹配核心算法

// Match 匹配包与漏洞
func Match(pkg types.Package, advisories []Advisory) []Vulnerability {
    var vulns []Vulnerability
    
    for _, advisory := range advisories {
        // 1. 检查包名是否匹配
        if advisory.PkgName != pkg.Name {
            continue
        }
        
        // 2. 检查版本是否匹配
        if !isAffected(pkg, advisory) {
            continue
        }
        
        // 3. 构造漏洞对象
        vulns = append(vulns, Vulnerability{
            VulnerabilityID:  advisory.VulnerabilityID,
            PkgName:          pkg.Name,
            InstalledVersion: pkg.Version,
            FixedVersion:     advisory.FixedVersion,
            Severity:         advisory.Severity,
            // ... 其他字段
        })
    }
    
    return vulns
}

// isAffected 检查包是否受漏洞影响
func isAffected(pkg types.Package, advisory Advisory) bool {
    // 1. 如果没有版本范围，则认为所有版本都受影响
    if len(advisory.AffectedVersions) == 0 {
        return true
    }
    
    // 2. 遍历受影响的版本范围
    for _, av := range advisory.AffectedVersions {
        affected := true
        
        // 2.1 检查引入版本
        if av.Introduced != "" {
            if compareVersion(pkg.Version, av.Introduced) < 0 {
                affected = false
            }
        }
        
        // 2.2 检查修复版本
        if av.Fixed != "" {
            if compareVersion(pkg.Version, av.Fixed) >= 0 {
                affected = false
            }
        }
        
        if affected {
            return true
        }
    }
    
    return false
}

// compareVersion 版本比较（简化版）
func compareVersion(v1, v2 string) int {
    // 移除 'v' 前缀
    v1 = strings.TrimPrefix(v1, "v")
    v2 = strings.TrimPrefix(v2, "v")
    
    // 使用版本比较库
    result, err := semver.Compare(v1, v2)
    if err != nil {
        // Fallback to string compare
        if v1 < v2 {
            return -1
        } else if v1 > v2 {
            return 1
        }
        return 0
    }
    
    return result
}

6.5 并发控制

// pkg/scanner/scanner.go (v0.50.0)
// 并发扫描控制

// ScanMultiple 并发扫描多个目标
func (s *FullScanner) ScanMultiple(ctx context.Context, targets []types.ScanTarget, opt types.ScanOptions) ([]types.Result, error) {
    // 1. 创建工作池
    workerCount := opt.SlowWorkers // 默认 4 个并发
    if workerCount == 0 {
        workerCount = 4
    }
    
    // 2. 创建结果通道
    results := make(chan types.Result, len(targets))
    errors := make(chan error, len(targets))
    
    // 3. 启动 worker
    var wg sync.WaitGroup
    targetChan := make(chan types.ScanTarget, len(targets))
    
    for i := 0; i < workerCount; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for target := range targetChan {
                result, err := s.Scan(ctx, target, opt)
                if err != nil {
                    errors <- err
                    continue
                }
                results <- result
            }
        }()
    }
    
    // 4. 分发任务
    go func() {
        for _, target := range targets {
            targetChan <- target
        }
        close(targetChan)
    }()
    
    // 5. 等待完成
    wg.Wait()
    close(results)
    close(errors)
    
    // 6. 收集结果
    var allResults []types.Result
    for result := range results {
        allResults = append(allResults, result)
    }
    
    // 7. 检查错误
    select {
    case err := <-errors:
        return nil, err
    default:
    }
    
    return allResults, nil
}

---

七、实战应用场景

7.1 CI/CD 集成

7.1.1 GitHub Actions

# .github/workflows/trivy-scan.yml
name: Trivy 安全扫描

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]
  schedule:
    - cron: '0 0 * * *'  # 每天扫描

jobs:
  scan:
    runs-on: ubuntu-latest
    steps:
      - name: 检出代码
        uses: actions/checkout@v4
      
      - name: 构建 Docker 镜像
        run: |
          docker build -t ${{ github.repository }}:${{ github.sha }} .
      
      - name: 运行 Trivy 漏洞扫描
        uses: aquasecurity/trivy-action@master
        with:
          image-ref: ${{ github.repository }}:${{ github.sha }}
          format: 'sarif'
          output: 'trivy-results.sarif'
          severity: 'CRITICAL,HIGH'
      
      - name: 上传扫描结果到 GitHub Security
        uses: github/codeql-action/upload-sarif@v2
        if: always()
        with:
          sarif_file: 'trivy-results.sarif'
      
      - name: 生成报告
        if: always()
        run: |
          trivy image --format json ${{ github.repository }}:${{ github.sha }} > report.json
          cat report.json | jq '.Results[].Vulnerabilities | length'
      
      - name: 发布到 Artifact
        uses: actions/upload-artifact@v3
        if: always()
        with:
          name: trivy-report
          path: report.json

7.1.2 GitLab CI

# .gitlab-ci.yml
stages:
  - build
  - test
  - security

variables:
  IMAGE_NAME: $CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA
  TRIVY_CACHE_DIR: /cache/trivy

# 构建镜像
build:
  stage: build
  script:
    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
    - docker build -t $IMAGE_NAME .
    - docker push $IMAGE_NAME

# Trivy 扫描
trivy_scan:
  stage: security
  image: aquasec/trivy:latest
  script:
    # 缓存数据库
    - trivy image --download-db-only
    
    # 扫描镜像
    - trivy image --exit-code 1 --severity CRITICAL,HIGH $IMAGE_NAME
    
    # 生成报告
    - trivy image --format json --output trivy-report.json $IMAGE_NAME
  
  allow_failure: true  # 允许失败，但会记录
  
  artifacts:
    reports:
      container_scanning: trivy-report.json
    paths:
      - trivy-report.json
    expire_in: 30 days
  
  cache:
    paths:
      - /cache/trivy

7.1.3 Jenkins Pipeline

// Jenkinsfile
pipeline {
    agent any
    
    environment {
        IMAGE_NAME = "myapp:${env.BUILD_ID}"
        TRIVY_CACHE = "${env.WORKSPACE}/.trivy-cache"
    }
    
    stages {
        stage('Build') {
            steps {
                script {
                    sh "docker build -t ${IMAGE_NAME} ."
                }
            }
        }
        
        stage('Trivy Scan') {
            steps {
                script {
                    // 下载 Trivy
                    sh '''
                        wget -qO - https://aquasecurity.github.io/trivy-repo/deb/public.key | sudo apt-key add -
                        echo "deb https://aquasecurity.github.io/trivy-repo/deb $(lsb_release -sc) main" | sudo tee -a /etc/apt/sources.list.d/trivy.list
                        sudo apt-get update
                        sudo apt-get install trivy -y
                    '''
                    
                    // 执行扫描
                    sh """
                        trivy image --cache-dir ${TRIVY_CACHE} \
                            --severity HIGH,CRITICAL \
                            --format json \
                            --output trivy-report.json \
                            ${IMAGE_NAME}
                    """
                    
                    // 解析结果
                    script {
                        def report = readJSON file: 'trivy-report.json'
                        def vulnCount = 0
                        report.Results.each { result ->
                            vulnCount += result.Vulnerabilities.size()
                        }
                        
                        if (vulnCount > 0) {
                            println("发现 ${vulnCount} 个漏洞")
                            currentBuild.result = 'UNSTABLE'
                        } else {
                            println("未发现严重漏洞")
                        }
                    }
                }
            }
            
            post {
                always {
                    archiveArtifacts artifacts: 'trivy-report.json', fingerprint: true
                }
            }
        }
    }
}

7.2 Kubernetes 准入控制

使用 Trivy 扫描镜像并阻止漏洞镜像部署：

# admission-control-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: trivy-admission-controller
  namespace: kube-system
spec:
  replicas: 3
  selector:
    matchLabels:
      app: trivy-admission
  template:
    metadata:
      labels:
        app: trivy-admission
    spec:
      containers:
      - name: trivy
        image: aquasec/trivy:latest
        command:
          - /trivy
          - server
          - --port
          - "8080"
          - --cache-dir
          - /cache
        ports:
        - containerPort: 8080
        volumeMounts:
        - name: cache
          mountPath: /cache
        livenessProbe:
          httpGet:
            path: /healthz
            port: 8080
          initialDelaySeconds: 5
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /ready
            port: 8080
          initialDelaySeconds: 5
          periodSeconds: 10
      volumes:
      - name: cache
        emptyDir: {}

---
# admission-webhook.yaml
apiVersion: admissionregistration.k8s.io/v1
kind: ValidatingWebhookConfiguration
metadata:
  name: trivy-admission-webhook
webhooks:
- name: trivy-scan.container-images
  rules:
  - apiGroups: [""]
    apiVersions: ["v1"]
    operations: ["CREATE", "UPDATE"]
    resources: ["pods"]
  admissionReviewVersions: ["v1"]
  sideEffects: None
  clientConfig:
    service:
      namespace: kube-system
      name: trivy-admission-service
      path: /scan

// admission-controller.go
// Kubernetes 准入控制器实现（简化版）

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "net/http"
    "os"
    
    admissionv1 "k8s.io/api/admission/v1"
    corev1 "k8s.io/api/core/v1"
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

// TrivyClient Trivy 客户端
type TrivyClient struct {
    baseURL string
}

// ScanResult 扫描结果
type ScanResult struct {
    Vulnerabilities []Vulnerability `json:"Vulnerabilities"`
}

// Vulnerability 漏洞
type Vulnerability struct {
    Severity string `json:"Severity"`
}

// admitHandler 准入处理函数
func admitHandler(w http.ResponseWriter, r *http.Request) {
    // 1. 解析 AdmissionReview
    var admissionReview admissionv1.AdmissionReview
    if err := json.NewDecoder(r.Body).Decode(&admissionReview); err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }
    
    // 2. 解析 Pod 对象
    pod := &corev1.Pod{}
    if err := json.Unmarshal(admissionReview.Request.Object.Raw, pod); err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }
    
    // 3. 获取镜像列表
    var images []string
    for _, container := range pod.Spec.Containers {
        images = append(images, container.Image)
    }
    
    // 4. 调用 Trivy 扫描
    trivy := &TrivyClient{baseURL: "http://trivy:8080"}
    hasCriticalVuln := false
    
    for _, image := range images {
        result, err := trivy.Scan(context.Background(), image)
        if err != nil {
            http.Error(w, err.Error(), http.StatusInternalServerError)
            return
        }
        
        // 5. 检查是否有严重漏洞
        for _, vuln := range result.Vulnerabilities {
            if vuln.Severity == "CRITICAL" {
                hasCriticalVuln = true
                break
            }
        }
    }
    
    // 6. 构造响应
    admissionResponse := &admissionv1.AdmissionResponse{
        UID: admissionReview.Request.UID,
    }
    
    if hasCriticalVuln {
        admissionResponse.Allowed = false
        admissionResponse.Result = &metav1.Status{
            Reason: metav1.StatusReason("镜像存在严重漏洞，拒绝部署"),
        }
    } else {
        admissionResponse.Allowed = true
    }
    
    admissionReview.Response = admissionResponse
    
    // 7. 返回响应
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(admissionReview)
}

// Scan 扫描镜像
func (t *TrivyClient) Scan(ctx context.Context, image string) (*ScanResult, error) {
    url := fmt.Sprintf("%s/scan?image=%s", t.baseURL, image)
    req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
    if err != nil {
        return nil, err
    }
    
    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    
    var result ScanResult
    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        return nil, err
    }
    
    return &result, nil
}

func main() {
    http.HandleFunc("/scan", admitHandler)
    fmt.Println("准入控制器启动，监听 :8443")
    if err := http.ListenAndServeTLS(":8443", "/certs/tls.crt", "/certs/tls.key", nil); err != nil {
        fmt.Fprintf(os.Stderr, "启动失败: %v\n", err)
        os.Exit(1)
    }
}

7.3 监控与告警

# prometheus-trivy-exporter.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: trivy-exporter-config
data:
  config.yaml: |
    targets:
      - name: nginx
        image: nginx:latest
      - name: redis
        image: redis:7
      - name: postgres
        image: postgres:15
    
    scan_interval: 1h
    
    metrics:
      enabled: true
      port: 9090
      
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: trivy-exporter
spec:
  replicas: 1
  selector:
    matchLabels:
      app: trivy-exporter
  template:
    metadata:
      labels:
        app: trivy-exporter
    spec:
      containers:
      - name: exporter
        image: myregistry/trivy-exporter:latest
        args:
          - --config=/etc/trivy/config.yaml
        volumeMounts:
          - name: config
            mountPath: /etc/trivy
        ports:
          - containerPort: 9090
      volumes:
        - name: config
          configMap:
            name: trivy-exporter-config

---
apiVersion: v1
kind: Service
metadata:
  name: trivy-exporter
spec:
  selector:
    app: trivy-exporter
  ports:
    - port: 9090
      targetPort: 9090

---
apiVersion: monitoring.coreos.com/v1
kind: ServiceMonitor
metadata:
  name: trivy-exporter
spec:
  selector:
    matchLabels:
      app: trivy-exporter
  endpoints:
    - port: http
      interval: 1m

// metrics_exporter.go
// Prometheus 指标导出器

package main

import (
    "github.com/prometheus/client_golang/prometheus"
    "github.com/prometheus/client_golang/prometheus/promhttp"
    "net/http"
)

// Metrics 指标结构
type Metrics struct {
    VulnsTotal      *prometheus.GaugeVec
    VulnsBySeverity *prometheus.GaugeVec
    LastScanTime    *prometheus.GaugeVec
}

// NewMetrics 创建指标
func NewMetrics() *Metrics {
    return &Metrics{
        VulnsTotal: prometheus.NewGaugeVec(
            prometheus.GaugeOpts{
                Name: "trivy_vulnerabilities_total",
                Help: "总漏洞数量",
            },
            []string{"image", "target"},
        ),
        VulnsBySeverity: prometheus.NewGaugeVec(
            prometheus.GaugeOpts{
                Name: "trivy_vulnerabilities_by_severity",
                Help: "按严重程度分类的漏洞数量",
            },
            []string{"image", "severity"},
        ),
        LastScanTime: prometheus.NewGaugeVec(
            prometheus.GaugeOpts{
                Name: "trivy_last_scan_timestamp",
                Help: "上次扫描时间戳",
            },
            []string{"image"},
        ),
    }
}

// RecordScan 记录扫描结果
func (m *Metrics) RecordScan(image string, result *ScanResult) {
    // 统计总漏洞数
    total := float64(len(result.Vulnerabilities))
    m.VulnsTotal.WithLabelValues(image, "all").Set(total)
    
    // 按严重程度统计
    severityCount := make(map[string]int)
    for _, vuln := range result.Vulnerabilities {
        severityCount[vuln.Severity]++
    }
    
    for severity, count := range severityCount {
        m.VulnsBySeverity.WithLabelValues(image, severity).Set(float64(count))
    }
}

func main() {
    // 注册指标
    metrics := NewMetrics()
    prometheus.MustRegister(
        metrics.VulnsTotal,
        metrics.VulnsBySeverity,
        metrics.LastScanTime,
    )
    
    // 暴露指标
    http.Handle("/metrics", promhttp.Handler())
    http.ListenAndServe(":9090", nil)
}

7.4 批量扫描与报告

#!/bin/bash
# batch-scan.sh - 批量镜像扫描脚本

# 配置
IMAGE_LIST="images.txt"
OUTPUT_DIR="reports"
DATE=$(date +%Y%m%d_%H%M%S)
REPORT_FILE="${OUTPUT_DIR}/report_${DATE}.html"
SUMMARY_FILE="${OUTPUT_DIR}/summary_${DATE}.json"

# 创建输出目录
mkdir -p "${OUTPUT_DIR}"

# 初始化汇总报告
cat > "${SUMMARY_FILE}" << EOF
{
  "scan_time": "$(date -Iseconds)",
  "total_images": 0,
  "total_vulnerabilities": 0,
  "images": []
}
EOF

# 扫描计数器
TOTAL_IMAGES=0
TOTAL_VULNS=0

# 逐行读取镜像列表
while IFS= read -r image; do
    echo "扫描镜像: ${image}"
    
    # 跳过空行和注释
    [[ -z "$image" || "$image" =~ ^#.* ]] && continue
    
    # 执行扫描
    JSON_FILE="${OUTPUT_DIR}/$(echo $image | tr '/:' '_').json"
    trivy image --format json --output "${JSON_FILE}" "${image}"
    
    # 提取统计数据
    VULN_COUNT=$(jq '[.Results[].Vulnerabilities[]] | length' "${JSON_FILE}")
    CRITICAL_COUNT=$(jq '[.Results[].Vulnerabilities[] | select(.Severity == "CRITICAL")] | length' "${JSON_FILE}")
    HIGH_COUNT=$(jq '[.Results[].Vulnerabilities[] | select(.Severity == "HIGH")] | length' "${JSON_FILE}")
    
    echo "  发现 ${VULN_COUNT} 个漏洞 (CRITICAL: ${CRITICAL_COUNT}, HIGH: ${HIGH_COUNT})"
    
    # 更新统计
    TOTAL_IMAGES=$((TOTAL_IMAGES + 1))
    TOTAL_VULNS=$((TOTAL_VULNS + VULN_COUNT))
    
    # 生成单个镜像的 HTML 报告
    trivy image --format template --template "@html.tpl" "${image}" > "${OUTPUT_DIR}/$(echo $image | tr '/:' '_').html"
    
    # 添加到汇总
    jq --arg image "$image" \
       --argjson vuln "$VULN_COUNT" \
       --argjson critical "$CRITICAL_COUNT" \
       --argjson high "$HIGH_COUNT" \
       '.images += [{"name": $image, "vulnerabilities": $vuln, "critical": $critical, "high": $high}] | .total_images += 1' \
       "${SUMMARY_FILE}" > "${SUMMARY_FILE}.tmp" && mv "${SUMMARY_FILE}.tmp" "${SUMMARY_FILE}"
    
done < "${IMAGE_LIST}"

# 更新总漏洞数
jq --argjson total "$TOTAL_VULNS" '.total_vulnerabilities = $total' "${SUMMARY_FILE}" > "${SUMMARY_FILE}.tmp" && mv "${SUMMARY_FILE}.tmp" "${SUMMARY_FILE}"

# 生成 HTML 报告
cat > "${REPORT_FILE}" << EOF
<!DOCTYPE html>
<html>
<head>
    <title>Trivy 批量扫描报告 - ${DATE}</title>
    <style>
        body { font-family: Arial, sans-serif; margin: 20px; }
        h1 { color: #333; }
        .summary { background: #f0f0f0; padding: 15px; border-radius: 5px; }
        table { border-collapse: collapse; width: 100%; margin-top: 20px; }
        th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
        th { background-color: #4CAF50; color: white; }
        .critical { background-color: #ffcccc; }
        .high { background-color: #ffebcc; }
    </style>
</head>
<body>
    <h1>容器安全批量扫描报告</h1>
    <div class="summary">
        <h2>扫描概览</h2>
        <p>扫描时间: $(date)</p>
        <p>扫描镜像数: ${TOTAL_IMAGES}</p>
        <p>发现漏洞总数: ${TOTAL_VULNS}</p>
    </div>
    
    <h2>镜像详情</h2>
    <table>
        <tr>
            <th>镜像名称</th>
            <th>总漏洞数</th>
            <th>严重</th>
            <th>高危</th>
            <th>报告链接</th>
        </tr>
$(jq -r '.images[] | "<tr><td>\(.name)</td><td>\(.vulnerabilities)</td><td class=\"critical\">\(.critical)</td><td class=\"high\">\(.high)</td><td><a href=\"\(.name | gsub("/"; "_") | gsub(":"; "_") | . + ".html")\">查看</a></td></tr>"' "${SUMMARY_FILE}")
    </table>
</body>
</html>
EOF

echo "扫描完成！"
echo "汇总报告: ${SUMMARY_FILE}"
echo "HTML 报告: ${REPORT_FILE}"

---

八、性能优化策略

8.1 缓存机制

#!/bin/bash
# Trivy 缓存优化策略

# 策略1: 持久化缓存目录
export TRIVY_CACHE_DIR=/data/trivy-cache
mkdir -p "${TRIVY_CACHE_DIR}"

# 策略2: 使用卷挂载（Docker/Kubernetes）
docker run -v /data/trivy-cache:/root/.cache/trivy:rw \
    aquasec/trivy image nginx:latest

# 策略3: 预热缓存
trivy image --download-db-only

# 策略4: 缓存分层（数据库 + 扫描结果）
# 数据库缓存
export TRIVY_CACHE_DIR=/data/trivy-cache/db
# 镜像层缓存
export TRIVY_IMAGE_CACHE_DIR=/data/trivy-cache/images

# 策略5: Redis 缓存（分布式场景）
# 使用 Redis 共享缓存
trivy server --cache-backend redis --cache-redis-addr redis:6379

8.2 并发优化

#!/bin/bash
# 并发控制示例

# 模式1: 慢速模式（默认）
trivy image --slow  nginx:latest

# 模式2: 快速模式
trivy image --fast nginx:latest

# 模式3: 自定义并发数
trivy image --slow-workers 2 nginx:latest

# 模式4: 禁用并行
trivy image --disable-vcs nginx:latest

# 模式5: 限制数据库更新并发
trivy image --db-retry 5 nginx:latest

8.3 增量扫描

#!/bin/bash
# 增量扫描策略

# 仅扫描变更的层
trivy image --cache-dir /cache image:tag

# 跳过数据库更新
trivy image --skip-db-update image:tag

# 只扫描特定层
trivy image --layer-id sha256:abc123... image:tag

# 扫描器选择
trivy image --scanners vuln,config image:tag
trivy image --scanners vuln --skip-secret-scan image:tag

# 包管理器选择
trivy image --package-managementers npm,pip image:tag

8.4 性能对比

优化策略	扫描时间	内存占用	磁盘占用	适用场景
无缓存	基准	低	低	一次性扫描
数据库缓存	-60%	中	~100MB	日常使用
镜像层缓存	-80%	高	~1GB	CI/CD 流水线
快速模式	-50%	高	低	本地开发
增量扫描	-90%	中	低	重复扫描
分布式缓存	-70%	中	中	大规模部署

8.5 性能基准测试

#!/bin/bash
# 性能基准测试脚本

IMAGES=(
    "nginx:1.24"
    "node:18-alpine"
    "python:3.11-slim"
    "openjdk:17-jdk"
    "ubuntu:22.04"
)

echo "镜像名称,镜像大小(MB),扫描时间(秒),漏洞数" > benchmark.csv

for image in "${IMAGES[@]}"; do
    echo "测试镜像: ${image}"
    
    # 获取镜像大小
    size=$(docker images "${image}" --format "{{.Size}}")
    size_mb=$(echo "$size" | sed 's/MB//' | awk '{print int($1)}')
    
    # 执行扫描计时
    start=$(date +%s)
    json_output=$(trivy image --format json --quiet "${image}")
    end=$(date +%s)
    
    duration=$((end - start))
    vuln_count=$(echo "$json_output" | jq '[.Results[].Vulnerabilities[]] | length')
    
    echo "${image},${size_mb},${duration},${vuln_count}" >> benchmark.csv
    echo "  耗时: ${duration}秒, 漏洞: ${vuln_count}"
done

echo "测试完成，结果保存在 benchmark.csv"

---

九、与工具对比

9.1 容器安全工具对比

特性	Trivy	Clair	Snyk	Grype
开源	✅	✅	❌	✅
多目标支持	✅	❌	✅	✅
部署难度	低（单二进制）	高（需数据库）	低	低
扫描速度	⭐⭐⭐⭐⭐	⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐
数据库更新	每日	每日	实时	每日
误报率	低	中	低	中
社区活跃度	⭐⭐⭐⭐⭐	⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐
Kubernetes 集成	✅	❌	✅	❌
SBOM 支持	✅	❌	✅	✅
离线扫描	✅	✅	❌	✅
企业支持	Aqua Security	Red Hat Quay	Snyk Inc.	Anchore

9.2 架构对比

9.3 使用场景推荐

9.4 功能对比矩阵

功能	Trivy	Clair	Snyk	Grype
容器镜像扫描	✅	✅	✅	✅
文件系统扫描	✅	❌	✅	✅
Git 仓库扫描	✅	❌	✅	❌
Kubernetes 扫描	✅	❌	✅	❌
IaC 扫描	✅	❌	✅	❌
配置检查	✅	❌	✅	❌
机密检测	✅	❌	✅	❌
许可证合规	❌	❌	✅	❌
补丁建议	✅	❌	✅	✅
导出 SBOM	✅	❌	✅	✅
漏洞评分	CVSS	CVSS	CVSS + 自有	CVSS
自定义策略	✅	❌	✅	❌

---

十、最佳实践

10.1 安全左移

10.2 分级策略

#!/bin/bash
# 分级扫描策略

# 策略1: 开发环境（宽松）
trivy image --severity HIGH,CRITICAL \
    --ignore-unfixed \
    image:dev

# 策略2: 测试环境（中等）
trivy image --severity MEDIUM,HIGH,CRITICAL \
    --ignore-unfixed \
    image:testing

# 策略3: 生产环境（严格）
trivy image --severity LOW,MEDIUM,HIGH,CRITICAL \
    --exit-code 1 \
    image:production

# 策略4: 金融/医疗环境（最严格）
trivy image --severity LOW,MEDIUM,HIGH,CRITICAL \
    --exit-code 1 \
    --ignore-file .trivyignore-production \
    --security-checks vuln,config,secret \
    image:critical

10.3 误报处理

# .trivyignore 文件示例
# 用于过滤误报或暂时忽略的漏洞

# 格式: 漏洞ID
CVE-2021-1234

# 或指定包和版本
CVE-2021-5678:libopenssl1.1

# 或使用通配符
# 忽略所有测试相关的漏洞
*:*-test-*

# 忽略特定组件
CVE-2022-0001:nodejs

# 注释示例
# CVE-2021-44228 暂时无法升级，等待官方补丁
CVE-2021-44228

10.4 CI/CD 门禁策略

# .trivy.yaml - Trivy 配置文件
# 全局配置
severity:
  - UNKNOWN
  - LOW
  - MEDIUM
  - HIGH
  - CRITICAL

# 忽略未修复漏洞
ignore-unfixed: true

# 跳过目录
skip-dirs:
  - /usr/local
  - /var/lib

# 跳过文件
skip-files:
  - "**/*.test.js"
  - "**/test/*"

# 包管理器选择
package-managers:
  - npm
  - pip
  - maven
  - go_modules

# 漏洞数据库配置
db:
  repository: ghcr.io/aquasecurity/trivy-db
  # no-progress: true
  # skip-update: false

# 报告格式
output:
  format: json
  file: trivy-report.json

# 扫描器配置
scanners:
  - vuln
  - config
  - secret

# 并发控制
slow: true
slow-workers: 4

10.5 安全基线

#!/bin/bash
# security-baseline.sh - 安全基线检查脚本

# 基线配置
MAX_CRITICAL_VULNS=0
MAX_HIGH_VULNS=5
MAX_MEDIUM_VULNS=20

# 执行扫描
OUTPUT=$(trivy image --format json "$1")

# 提取统计数据
CRITICAL=$(echo "$OUTPUT" | jq '[.Results[].Vulnerabilities[] | select(.Severity == "CRITICAL")] | length')
HIGH=$(echo "$OUTPUT" | jq '[.Results[].Vulnerabilities[] | select(.Severity == "HIGH")] | length')
MEDIUM=$(echo "$OUTPUT" | jq '[.Results[].Vulnerabilities[] | select(.Severity == "MEDIUM")] | length')

# 检查基线
PASSED=true
if [[ $CRITICAL -gt $MAX_CRITICAL_VULNS ]]; then
    echo "❌ CRITICAL 漏洞超标: ${CRITICAL} > ${MAX_CRITICAL_VULNS}"
    PASSED=false
fi

if [[ $HIGH -gt $MAX_HIGH_VULNS ]]; then
    echo "⚠️  HIGH 漏洞超标: ${HIGH} > ${MAX_HIGH_VULNS}"
    PASSED=false
fi

if [[ $MEDIUM -gt $MAX_MEDIUM_VULNS ]]; then
    echo "⚠️  MEDIUM 漏洞超标: ${MEDIUM} > ${MAX_MEDIUM_VULNS}"
    PASSED=false
fi

# 返回结果
if [[ "$PASSED" == "true" ]]; then
    echo "✅ 安全基线检查通过"
    exit 0
else
    echo "❌ 安全基线检查失败"
    exit 1
fi

10.6 运营最佳实践清单

# Trivy 运维检查清单

## 日常运维
- [ ] 定期更新数据库（每日）
- [ ] 检查缓存目录磁盘空间
- [ ] 监控扫描执行时间
- [ ] 审查误报白名单

## CI/CD 集成
- [ ] 所有镜像构建流程集成扫描
- [ ] 设置漏洞阈值门禁
- [ ] 配置扫描失败通知
- [ ] 归档扫描结果用于审计

## 安全策略
- [ ] 根据环境设置不同严重等级阈值
- [ ] 定期审查和更新 .trivyignore
- [ ] 建立漏洞响应流程
- [ ] 记录漏洞修复决策原因

## 监控告警
- [ ] 配置 Prometheus 指标导出
- [ ] 设置严重漏洞告警
- [ ] 监控数据库更新状态
- [ ] 跟踪扫描趋势变化

## 合规要求
- [ ] 定期导出合规报告
- [ ] 保留扫描历史记录
- [ ] 建立审计追踪
- [ ] 满足行业标准要求

## 性能优化
- [ ] 使用持久化缓存
- [ ] 配置合适的并发数
- [ ] 实施增量扫描
- [ ] 分布式缓存部署

---

总结

Trivy 作为开源容器安全领域的领军工具，通过其简洁的架构、全面的功能覆盖和活跃的社区支持，为 DevSecOps 实践提供了强大的漏洞检测能力。

核心优势

1. 零配置使用: 开箱即用，无需复杂设置
2. 全面覆盖: 支持容器镜像、文件系统、Git 仓库、Kubernetes 等多种目标
3. 高精度: 基于多源漏洞数据库，误报率低
4. 灵活集成: 易于集成到 CI/CD 流水线
5. 持续更新: 每日同步最新的漏洞数据

架构亮点

• 模块化设计: 清晰的扫描器、检测器、数据库分层
• 高效并发: 支持多目标并行扫描
• 智能缓存: 数据库和镜像层缓存显著提升性能
• 标准输出: 支持多种格式（JSON、SARIF、HTML、SBOM）

实践建议

1. 安全左移: 在开发早期引入扫描，降低修复成本
2. 分级策略: 根据环境风险等级设置不同的漏洞阈值
3. 自动化门禁: 在 CI/CD 流水线中强制执行安全检查
4. 持续监控: 定期扫描运行中的容器和 Kubernetes 集群
5. 定期维护: 更新数据库、审查误报白名单、优化配置

随着云原生技术的发展，Trivy 持续演进，从单一漏洞扫描工具发展为综合安全平台，为容器化应用的全生命周期安全保驾护航。

---