一、为什么需要跨云镜像来源治理?

在云原生时代,容器镜像是应用交付的核心载体。随着企业多云架构的普及,团队往往需要同时从 Google Container Registry (GCR)、Amazon Elastic Container Registry (ECR)、Azure Container Registry (ACR) 等多个公有云 registry 拉取镜像。然而,这种便利性也带来了严峻的安全挑战:

供应链攻击面扩张:2024 年 CISA 报告显示,超过 60% 的容器漏洞源于不受信任的镜像来源。恶意镜像可能包含后门、挖矿程序或数据窃取逻辑,一旦进入生产环境,后果不堪设想。

合规与审计需求:金融、医疗等行业强制要求所有外部依赖来源可审计、可追溯。GDPR、HIPAA、PCI-DSS 均对白名单机制有明确约束。

隐蔽依赖风险:开发者在 Dockerfile 中随意引用 image: tag 格式,如果没有治理机制,任何一个外部 registry 被攻陷都可能导致生产集群被渗透。

跨云来源治理的核心目标是:确保所有进入生产环境的容器镜像仅来自经过审批的可信 registry 和命名空间,实现零信任供应链。

二、跨云 Registry 架构全景

典型的多云容器镜像架构涉及以下关键组件:

镜像来源层:提供容器镜像的外部 registry 服务。

  • GCR / Artifact Registry:Google Cloud 的托管容器镜像服务,地址格式 gcr.io/PROJECT/IMAGE:TAG 或 REGION-docker.pkg.dev/PROJECT/REPO/IMAGE:TAG
  • ECR:Amazon 的私有容器 registry,地址格式 ACCOUNT_ID.dkr.ecr.REGION.amazonaws.com/REPO:tag
  • ACR:Azure 的容器 registry 服务,地址格式 NAME.azurecr.io/IMAGE:TAG
  • Docker Hub:公共镜像仓库,官方镜像地址格式 docker.io/library/IMAGE:TAG
  • 私有 Harbor:企业内部自建的镜像仓库

治理控制层:在镜像进入集群前进行来源校验。

  • 准入控制器 (Admission Controller):Kubernetes Validating/Mutating Webhook
  • OPA/Gatekeeper:基于 Rego 的策略引擎
  • Kyverno:Kubernetes 原生策略引擎
  • CI/CD 流水线检查:在构建阶段即拦截不受信任的来源

运行监控层:对生产环境中运行的容器进行持续审计。

  • Falco / Tracee:eBPF 驱动的运行时可观测性
  • kube-bench / Trivy:定期合规扫描
  • SIEM 集成:将审计日志汇聚到统一平台

三、白名单治理模型设计

3.1 核心数据模型

白名单治理的核心是定义「谁可以拉取什么」。我们设计如下的多维度假分模型:

// ==================== 核心类型定义 ====================

/**
 * 镜像引用:完整描述一个容器镜像的来源
 */
interface ImageRef {
  host: string;          // registry 主机名,如 gcr.io
  namespace: string;     // 命名空间/项目/repo,如 my-project
  name: string;          // 镜像名称,如 my-app
  tag: string;           // 标签或 digest,如 v1.2.3 或 sha256:abc...
}

/**
 * 治理策略规则
 */
interface GovernanceRule {
  id: string;            // 规则唯一标识
  priority: number;      // 优先级,数字越小优先级越高
  hostPattern: string;   // 主机名模式(支持通配符和正则)
  namespacePattern: string; // 命名空间模式
  action: 'allow' | 'deny' | 'quarantine';  // 处置动作
  requireDigest: boolean;    // 是否要求使用 digest 固定
  requireSignature: boolean; // 是否要求签名验证
  approver: string;      // 审批人
  expiryDate?: string;   // 规则过期时间
  auditLevel: 'log' | 'alert' | 'block';  // 审计级别
}

/**
 * 治理决策结果
 */
interface GovernanceDecision {
  allowed: boolean;
  rule?: GovernanceRule;
  reason: string;
  riskLevel: 'low' | 'medium' | 'high' | 'critical';
  remediation?: string;  // 修复建议(被拒绝时提供)
  auditId: string;       // 审计追踪 ID
}

// ==================== 白名单引擎实现 ====================

class ArtifactRegistryGoveror {
  private rules: GovernanceRule[] = [];
  private auditLog: AuditLogger;

  constructor(auditLog: AuditLogger) {
    this.auditLog = auditLog;
  }

  /**
   * 添加策略规则(带审批流程)
   */
  addRule(rule: GovernanceRule, approvalToken: string): Result<void, Error> {
    // 1. 验证审批令牌
    if (!this.verifyApproval(approvalToken, rule)) {
      return Err(new Error('审批令牌无效或已过期'));
    }

    // 2. 检测规则冲突
    const conflicts = this.detectConflicts(rule);
    if (conflicts.length > 0) {
      return Err(new Error(`规则冲突: ${conflicts.map(c => c.id).join(', ')}`));
    }

    // 3. 插入规则并排序
    this.rules.push(rule);
    this.rules.sort((a, b) => a.priority - b.priority);

    // 4. 记录审计日志
    this.auditLog.record({
      type: 'RULE_ADDED',
      ruleId: rule.id,
      approver: rule.approver,
      timestamp: new Date().toISOString(),
      details: rule
    });

    return Ok(undefined);
  }

  /**
   * 核心治理决策函数
   */
  evaluate(imageRef: ImageRef, context?: EvaluationContext): GovernanceDecision {
    const auditId = generateUUID();

    // 1. 基本格式校验
    if (!this.validateFormat(imageRef)) {
      return {
        allowed: false,
        reason: '镜像引用格式无效',
        riskLevel: 'high',
        remediation: '请确保镜像引用符合 host/namespace/name:tag 格式',
        auditId
      };
    }

    // 2. 匹配规则链
    for (const rule of this.rules) {
      if (this.matchRule(rule, imageRef)) {
        const decision: GovernanceDecision = {
          allowed: rule.action === 'allow',
          rule,
          reason: rule.action === 'allow'
            ? `允许: 匹配规则 [${rule.id}]`
            : rule.action === 'quarantine'
              ? `隔离: 匹配规则 [${rule.id}],需要人工审核`
              : `拒绝: 匹配规则 [${rule.id}]`,
          riskLevel: this.calculateRisk(imageRef, rule),
          auditId
        };

        if (!decision.allowed) {
          decision.remediation = this.generateRemediation(imageRef, rule);
        }

        // 记录决策日志
        this.auditLog.record({
          type: 'GOVERNANCE_DECISION',
          auditId,
          imageRef,
          decision,
          context,
          timestamp: new Date().toISOString()
        });

        return decision;
      }
    }

    // 3. 默认拒绝(零信任原则)
    return {
      allowed: false,
      reason: '无匹配规则,默认拒绝(零信任策略)',
      riskLevel: 'critical',
      remediation: '请联系安全团队申请白名单,' +
        '提供镜像来源、用途说明、安全扫描报告',
      auditId
    };
  }

  /**
   * 规则匹配逻辑(支持通配符和正则)
   */
  private matchRule(rule: GovernanceRule, ref: ImageRef): boolean {
    const hostMatch = this.patternMatch(rule.hostPattern, ref.host);
    const nsMatch = this.patternMatch(rule.namespacePattern, ref.namespace);
    return hostMatch && nsMatch;
  }

  /**
   * 模式匹配(支持精确匹配、通配符 *, 正则表达式)
   */
  private patternMatch(pattern: string, value: string): boolean {
    // 精确匹配
    if (pattern === value) return true;
    
    // 正则表达式模式(以 ~ 开头)
    if (pattern.startsWith('~')) {
      const regex = new RegExp(pattern.slice(1));
      return regex.test(value);
    }
    
    // 通配符匹配
    const wildcardRegex = new RegExp(
      '^' + pattern.replace(/\*/g, '.*').replace(/\?/g, '.') + '$'
    );
    return wildcardRegex.test(value);
  }

  /**
   * 计算风险等级
   */
  private calculateRisk(ref: ImageRef, rule: GovernanceRule): RiskLevel {
    // tag 而非 digest 固定,风险更高
    if (!ref.tag.startsWith('sha256:')) {
      if (rule.requireDigest) return 'medium';
    }
    // latest 标签风险最高
    if (ref.tag === 'latest') return 'high';
    // 生产命名空间风险加权
    if (ref.namespace.includes('production')) return 'medium';
    return 'low';
  }

  /**
   * 生成修复建议
   */
  private generateRemediation(ref: ImageRef, rule: GovernanceRule): string {
    const suggestions: string[] = [];
    
    if (ref.tag === 'latest') {
      suggestions.push('使用明确的版本标签(如 v1.2.3)或 digest 替代 latest');
    }
    
    if (rule.requireDigest && !ref.tag.startsWith('sha256:')) {
      suggestions.push(`使用此命令获取 digest: docker pull ${ref.host}/${ref.name}:${ref.tag} | grep "Digest:"`);
    }
    
    if (rule.requireSignature) {
      suggestions.push('使用 cosign 或 notation 对镜像进行签名验证');
    }

    return `镜像 ${ref.host}/${ref.namespace}/${ref.name}:${ref.tag}。` +
      `规则 ${rule.id} 要求的处置动作: ${rule.action}。` +
      `修复建议: ${suggestions.length > 0 ? suggestions.join(';') : '申请白名单审批'}`;
  }
}

3.2 默认白名单配置

以下是一个生产级白名单的示例配置,覆盖主流公有云 registry 和常见内部源:

# artifact-registry-governance.yaml
# Artifact Registry 跨云来源治理配置文件

version: "2.0"
lastUpdated: "2026-10-14"
maintainer: [email protected]

# ========== 默认白名单规则(按优先级排序)==========
rules:
  # --- 最高优先级:拒绝已知恶意源 ---
  - id: "DENY-001"
    priority: 0
    hostPattern: "*~.*(malware| phishing| hacked)\\..*"
    namespacePattern: "*"
    action: deny
    auditLevel: alert
    description: "拒绝已知恶意域名模式"

  # --- Google Artifact Registry ---
  - id: "GAR-001"
    priority: 10
    hostPattern: "us-docker.pkg.dev"
    namespacePattern: "my-project-prod/*"
    action: allow
    requireDigest: true
    requireSignature: true
    approver: "[email protected]"
    auditLevel: log
    description: "Google Artifact Registry 生产项目"

  - id: "GAR-002"
    priority: 11
    hostPattern: "us-docker.pkg.dev"
    namespacePattern: "my-project-staging/*"
    action: allow
    requireDigest: false
    requireSignature: false
    approver: "[email protected]"
    auditLevel: log
    description: "Google Artifact Registry 预发项目"

  # --- Google Container Registry (Legacy) ---
  - id: "GCR-001"
    priority: 20
    hostPattern: "gcr.io"
    namespacePattern: "my-gcp-project/*"
    action: allow
    requireDigest: true
    approver: "[email protected]"
    expiryDate: "2027-06-30"
    auditLevel: alert
    description: "GCR 迁移过渡期白名单"

  # --- Amazon ECR ---
  - id: "ECR-001"
    priority: 30
    hostPattern: "~.*\\.ecr\\..*\\.amazonaws\\.com"
    namespacePattern: "production/*"
    action: allow
    requireDigest: true
    requireSignature: true
    approver: "[email protected]"
    auditLevel: alert
    description: "AWS ECR 生产命名空间"

  - id: "ECR-002"
    priority: 31
    hostPattern: "~.*\\.ecr\\..*\\.amazonaws\\.com"
    namespacePattern: "shared-base-images/*"
    action: allow
    requireDigest: true
    approver: "[email protected]"
    auditLevel: log
    description: "AWS ECR 共享基础镜像"

  # --- Azure Container Registry ---
  - id: "ACR-001"
    priority: 40
    hostPattern: "mycompany.azurecr.io"
    namespacePattern: "prod/*"
    action: allow
    requireDigest: true
    requireSignature: true
    approver: "[email protected]"
    auditLevel: alert
    description: "Azure 生产镜像仓库"

  # --- Docker Hub 官方镜像 ---
  - id: "DH-001"
    priority: 50
    hostPattern: "docker.io"
    namespacePattern: "library/*"
    action: allow
    requireDigest: true
    approver: "[email protected]"
    auditLevel: log
    description: "Docker 官方 Library 镜像(nginx, redis, postgres等)"

  - id: "DH-002"
    priority: 51
    hostPattern: "docker.io"
    namespacePattern: "verified-publisher/*"
    action: allow
    requireDigest: true
    approver: "[email protected]"
    auditLevel: alert
    description: "Docker 认证发布者镜像"

  # --- 内部 Harbor ---
  - id: "HARBOR-001"
    priority: 60
    hostPattern: "harbor.internal.company.com"
    namespacePattern: "*"
    action: allow
    requireDigest: false
    approver: "[email protected]"
    auditLevel: log
    description: "内部 Harbor(全部允许,但需审计)"

  # --- 隔离区规则(需要人工审批) ---
  - id: "QUARANTINE-001"
    priority: 999
    hostPattern: "*"
    namespacePattern: "*"
    action: quarantine
    auditLevel: alert
    description: "未列入白名单的源进入隔离区,通知安全团队审批"

四、Kubernetes 准入控制集成

白名单治理的最终执行点是在 Kubernetes 集群中阻止不受信任的镜像被调度。以下是两种主流实现方案:

4.1 OPA/Gatekeeper 策略实现

# gatekeeper-policy.rego
# OPA Gatekeeper 策略:约束容器镜像来源

package imagewhitelist

# 默认拒绝
default allow = false

# 允许的 registry 主机名正则
allowed_host_patterns := [
  "^gcr\\.io$",
  "^.*\\.ecr\\..*\\.amazonaws\\.com$",
  "^[a-zA-Z0-9]+\\.azurecr\\.io$",
  "^us-docker\\.pkg\\.dev$",
  "^docker\\.io$",
  "^harbor\\.internal\\.company\\.com$",
  "^registry\\.k8s\\.io$",
  "^quay\\.io$",
]

# 匹配逻辑
allow {
  some i
  container := input.review.object.spec.containers[i]
  image := container.image
  
  # 解析镜像引用
  parts := split(image, "/")
  host := parts[0]
  
  # 验证 host 匹配至少一个允许的模式
  some pattern
  allowed_host_patterns[pattern]
  regex.match(pattern, host)
}

allow {
  some i
  container := input.review.object.spec.initContainers[i]
  image := container.image
  parts := split(image, "/")
  host := parts[0]
  some pattern
  allowed_host_patterns[pattern]
  regex.match(pattern, host)
}

# 拒绝消息
deny[msg] {
  not allow
  msg := sprintf("镜像来源不在白名单中。请确保镜像来自已批准的 registry: %v", [
    [c.image | c := input.review.object.spec.containers[_]]
  ])
}

# 豁免命名空间(如 kube-system)
allow {
  input.review.object.metadata.namespace == "kube-system"
}

4.2 自定义 Webhook 准入控制器

对于更复杂的治理策略,可以使用自定义 Webhook 配合前文的 TypeScript 规则引擎。部署架构如下:

# governance-webhook-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: image-governance-webhook
  namespace: security
spec:
  replicas: 3
  selector:
    matchLabels:
      app: image-governance-webhook
  template:
    metadata:
      labels:
        app: image-governance-webhook
    spec:
      containers:
      - name: webhook
        image: harbor.internal.company.com/security/image-governance-webhook:v2.1.0
        ports:
        - containerPort: 8443
        env:
        - name: GOVERNANCE_CONFIG_PATH
          value: /etc/governance/config.yaml
        - name: TLS_CERT_PATH
          value: /etc/certs/tls.crt
        - name: TLS_KEY_PATH
          value: /etc/certs/tls.key
        volumeMounts:
        - name: config
          mountPath: /etc/governance
          readOnly: true
        - name: certs
          mountPath: /etc/certs
          readOnly: true
        resources:
          requests:
            cpu: 100m
            memory: 128Mi
          limits:
            cpu: 500m
            memory: 256Mi
      volumes:
      - name: config
        configMap:
          name: image-governance-config
      - name: certs
        secret:
          secretName: image-governance-tls
---
apiVersion: v1
kind: Service
metadata:
  name: image-governance-webhook
  namespace: security
spec:
  ports:
  - port: 443
    targetPort: 8443
  selector:
    app: image-governance-webhook
---
apiVersion: admissionregistration.k8s.io/v1
kind: ValidatingWebhookConfiguration
metadata:
  name: image-governance
webhooks:
- name: image-governance.company.com
  rules:
  - apiGroups: [""]
    apiVersions: ["v1"]
    operations: ["CREATE", "UPDATE"]
    resources: ["pods"]
    scope: "*"
  - apiGroups: ["apps"]
    apiVersions: ["v1"]
    operations: ["CREATE", "UPDATE"]
    resources: ["deployments", "statefulsets", "daemonsets", "replicasets"]
    scope: "*"
  clientConfig:
    service:
      name: image-governance-webhook
      namespace: security
      path: "/validate"
    caBundle: ${CA_BUNDLE}
  admissionReviewVersions: ["v1"]
  sideEffects: None
  timeoutSeconds: 10
  failurePolicy: Fail
  namespaceSelector:
    matchExpressions:
    - key: governance
      operator: NotIn
      values: ["disabled"]

五、CI/CD 流水线集成

Kubernetes 准入控制是最后一道防线,最佳实践是在 CI/CD 流水线的多个阶段植入镜像来源检查:

5.1 GitLab CI 集成示例

# .gitlab-ci.yml - 镜像来源治理 stages:
  - validate
  - build
  - security-scan
  - publish

variables:
  GOVERNANCE_ENDPOINT: "https://image-governance-webhook.security.svc:443"
  ALLOWED_REGISTRIES: "gcr.io,us-docker.pkg.dev,*.ecr.*.amazonaws.com,azurecr.io"

# ========== 阶段1: Dockerfile 静态扫描 ==========
validate:image-sources:
  stage: validate
  image: harbor.internal.company.com/ci/image-linter:v1.2
  script:
    - echo "=== 扫描 Dockerfile 中的镜像来源 ==="
    - |
      # 提取所有 FROM 指令的基镜像
      FROM_IMAGES=$(grep -i "^FROM" Dockerfile | awk '{print $2}' | sort -u)
      echo "发现基镜像:"
      echo "$FROM_IMAGES"
      
      # 逐一验证
      for img in $FROM_IMAGES; do
        HOST=$(echo "$img" | cut -d'/' -f1)
        # 检查是否在允许列表
        if echo "$ALLOWED_REGISTRIES" | tr ',' '\n' | grep -qE "^${HOST}$"; then
          echo "✓ 允许: $img"
        else
          echo "✗ 拒绝: $img (来源 $HOST 不在白名单中)"
          echo "  修复建议: 将 $img 迁移到内部 Harbor 或申请白名单"
          exit 1
        fi
      done
  rules:
    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
    - changes:
        - Dockerfile

# ========== 阶段2: 镜像构建与发布 ==========
build:push:
  stage: build
  image: gcr.io/kaniko-project/executor:v1.19.0-debug
  script:
    - /kaniko/executor
      --context "${CI_PROJECT_DIR}"
      --dockerfile "${CI_PROJECT_DIR}/Dockerfile"
      --destination "${CI_REGISTRY_IMAGE}:${CI_COMMIT_SHA}"
      --digest-file "${CI_PROJECT_DIR}/image-digest.txt"
  artifacts:
    paths:
      - image-digest.txt

security:trivy:
  stage: security-scan
  image:
    name: aquasec/trivy:0.47.0
  script:
    - trivy image --input "${CI_REGISTRY_IMAGE}:${CI_COMMIT_SHA}"
      --severity HIGH,CRITICAL
      --exit-code 1
      --ignore-unfixed

5.2 镜像 Digest 固定与签名

白名单治理的高级实践要求不仅控制来源,还要确保镜像内容不可被篡改:

#!/bin/bash
# image-sign-and-pin.sh - 镜像签名与 Digest 固定脚本

set -euo pipefail

IMAGE_REF="$1"  # 如 gcr.io/my-project/my-app:v1.2.3

echo "=== 步骤1: 获取镜像 Digest ==="
DIGEST=$(docker pull "$IMAGE_REF" > /dev/null 2>&1 && \
  docker inspect --format='{{index .RepoDigests 0}}' "$IMAGE_REF")
echo "Digest: $DIGEST"

echo "=== 步骤2: cosign 签名验证 ==="
# 如果镜像已有签名,验证之
if cosign verify --key /etc/cosign/pubkey.pem "$DIGEST" 2>/dev/null; then
  echo "✓ 签名验证通过"
else
  echo "✗ 签名验证失败或镜像未签名"
  echo "  正在签名镜像..."
  cosign sign --key /etc/cosign/private.pem "$DIGEST"
fi

echo "=== 步骤3: 生成 SBOM (软件物料清单) ==="
syft "$DIGEST" -o spdx-json > "sbom-${IMAGE_REF//[\/:]/-}.spdx.json"
echo "✓ SBOM 已生成"

echo "=== 步骤4: 更新 K8s manifest 使用 Digest 固定 ==="
# 将 deployment.yaml 中的 image: tag 替换为 image@digest
sed -i "s|image: ${IMAGE_REF}$|image: ${DIGEST}|g" deployment.yaml
echo "✓ Manifest 已更新为 Digest 固定"

六、审计与运行治理

治理不仅在入口处,运行时同样需要持续审计。以下是完整的审计体系设计:

6.1 审计事件模型

// 审计事件定义
interface AuditEvent {
  eventId: string;         // 全局唯一事件 ID
  eventType: 'RULE_ADDED' | 'RULE_REMOVED' | 'GOVERNANCE_DECISION' |
             'POLICY_VIOLATION' | 'QUARANTINE_RELEASE' | 'SOURCE_DRIFT';
  timestamp: string;       // ISO 8601
  actor: string;           // 操作者/服务账号
  resource: string;        // 受影响的镜像引用
  decision: 'allow' | 'deny' | 'quarantine';
  ruleId?: string;         // 匹配的规则
  riskLevel: RiskLevel;
  clusterInfo?: {          // 运行时上下文
    cluster: string;
    namespace: string;
    pod?: string;
    node?: string;
  };
  sourceIp?: string;       // 请求来源
  metadata: Record<string, unknown>;
}

// 审计存储接口
interface AuditStore {
  record(event: AuditEvent): Promise<void>
  query(filter: AuditFilter): Promise<AuditEvent[]>
  export(format: 'json' | 'csv' | 'splunk'): Promise<Buffer>
}

// 告警引擎
class AlertEngine {
  private rules: AlertRule[] = [];
  
  evaluate(event: AuditEvent): void {
    const alerts = this.rules.filter(rule => rule.matches(event));
    for (const alert of alerts) {
      this.send(alert.channel, {
        title: `[${event.riskLevel}] 镜像治理事件`,
        message: `${event.eventType}: ${event.resource} by ${event.actor}`,
        details: event
      });
    }
  }

  private send(channel: AlertChannel, message: AlertMessage): void {
    switch (channel.type) {
      case 'slack':
        slackNotifier.send(channel.webhook, message);
        break;
      case 'pagerduty':
        pagerduty.triggerIncident(channel.serviceKey, message);
        break;
      case 'email':
        emailService.send(channel.recipients, message);
        break;
      case 'splunk':
        splunkHEC.send(channel.endpoint, message);
        break;
    }
  }
}

6.2 运行监控 Dashboard 关键指标

治理体系的有效性需要通过可量化的指标来衡量,以下是在 Grafana 中应该监控的核心面板:

来源合规率(Source Compliance Rate)= 白名单内镜像事件 / 总事件 × 100%。目标值 ≥ 99.9%。低于 99% 说明存在大量遗漏配置或影子部署,需要排查。

规则覆盖率 = 被匹配的规则数 / 活跃 Pod 使用的唯一镜像数。反映策略的完备性。

平均拒绝响应时间(MTTD)= 从准入请求到生成审计事件的延迟。Webhook 模式下应 < 100ms,Fail-Open 策略下可容忍 500ms。

白名单漂移(Whitelist Drift)= 新增但未走审批流程的白名单条目。应该为零,非零即代表流程被绕过。

悬空规则(Orphan Rules)= 30 天内无任何命中记录的规则。应定期清理以保持策略集精简。

6.3 运行巡检脚本

#!/bin/bash
# audit-registry-usage.sh - 集群运行时镜像来源巡检

echo "=== Kubernetes 集群镜像来源巡检报表 ==="
echo "巡检时间: $(date -u +%Y-%m-%dT%H:%M:%SZ)"
echo "集群: $(kubectl config current-context)"
echo "==========================================="

# 1. 收集所有命名空间中正在使用的唯一镜像
echo ""
echo "--- [1] 唯一镜像列表 ---"
ALL_IMAGES=$(kubectl get pods --all-namespaces \
  -o jsonpath='{.items[*].spec.containers[*].image}' | \
  tr ' ' '\n' | sort -u)

echo "$ALL_IMAGES" | while read -r img; do
  if [ -n "$img" ]; then
    HOST=$(echo "$img" | cut -d'/' -f1)
    # 检查是否在白名单中
    if echo "$ALLOWED_REGISTRIES" | tr ',' '\n' | \
       grep -qE "^${HOST}$"; then
      echo "✓ [允许] $img"
    else
      echo "✗ [异常] $img  <-- 不在白名单中!"
    fi
  fi
done

# 2. 统计命名空间合规率
echo ""
echo "--- [2] 命名空间合规率 ---"
for ns in $(kubectl get ns -o jsonpath='{.items[*].metadata.name}'); do
  if [[ "$ns" =~ ^(kube-|security) ]]; then
    continue
  fi
  total=$(kubectl get pods -n "$ns" \
    -o jsonpath='{.items[*].spec.containers[*].image}' | \
    tr ' ' '\n' | grep -v '^$' | wc -l)
  non_compliant=$(kubectl get pods -n "$ns" \
    -o jsonpath='{.items[*].spec.containers[*].image}' | \
    tr ' ' '\n' | grep -v '^$' | while read -r img; do
      HOST=$(echo "$img" | cut -d'/' -f1)
      if ! echo "$ALLOWED_REGISTRIES" | tr ',' '\n' | \
         grep -qE "^${HOST}$"; then
        echo "$img"
      fi
    done | wc -l)
  
  if [ "$total" -gt 0 ]; then
    compliant=$((total - non_compliant))
    rate=$((compliant * 100 / total))
    echo "  $ns: ${rate}% (${compliant}/${total})"
  fi
done

# 3. 查找最新标签风险
echo ""
echo "--- [3] 使用 latest 标签的容器 ---"
kubectl get pods --all-namespaces \
  -o jsonpath='{range .items[*]}{.metadata.namespace}{"\t"}{.metadata.name}{"\t"}{.spec.containers[*].image}{"\n"}{end}' | \
  grep ':latest$' || echo "  无"

# 4. 未使用 digest 固定的生产容器
echo ""
echo "--- [4] 生产环境未使用 Digest 固定的容器 ---"
kubectl get pods -n production \
  -o jsonpath='{range .items[*]}{.metadata.name}{"\t"}{.spec.containers[*].image}{"\n"}{end}' | \
  while IFS=$'\t' read -r pod images; do
    for img in $images; do
      if [[ "$img" != *"sha256:"* ]]; then
        echo "  ⚠ ${pod}: ${img}"
      fi
    done
  done

echo ""
echo "=== 巡检完成 ==="

七、应急响应:白名单被绕过时的处置流程

当安全审计发现有未授权镜像进入生产环境时,按以下 SOP 处置:

第一步:隔离(0-15分钟)。立即将受影响 Pod 所在节点的网络策略切换为拒绝所有出站流量,阻止潜在的 C2 通信。同时 cordon 节点防止新 Pod 调度。

第二步:取证(15-60分钟)。通过 kubectl describe pod 提取完整镜像信息,保存容器快照(kubectl debug 或 crictl export),记录节点审计日志。

第三步:根因分析。检查是否存在规则绕过(如 initContainer 注入、ephemeralContainer 注入)、权限泄露(RBAC 滥用)、或 webhook 配置错误。

第四步:修复与预防。在规则引擎中新增针对性规则,修复 RBAC 权限,补全准入控制器覆盖范围,并在全集群执行新的巡检。

八、总结:构建纵深防御的镜像治理体系

有效的 Artifact Registry 跨云来源治理不是单一工具能完成的,而是纵深防御体系的一部分:

设计原则:

  • 零信任默认拒绝:任何未在白名单中的来源一律拒绝
  • 多层防御:CI/CD 静态检查 → 准入控制 → 运行时审计
  • 不可变引用:强制使用 digest 固定,杜绝 tag 伪造风险
  • 签名验证:对生产镜像强制要求签名(cosign / notation)
  • 最小权限:按命名空间、团队、环境细分白名单粒度
    • 完整的审计追溯:所有决策事件均记录、可查询、可告警

技术栈推荐:

  • 策略引擎:OPA Gatekeeper 或 Kyverno(轻量场景)、自定义 Webhook(复杂场景)
  • 签名工具:Sigstore cosign(通用)、Notation(Azure生态)
  • SBOM生成:Syft、Trivy
  • 运行时审计:Falco + Tracee(eBPF 驱动)
  • SIEM集成:Splunk / Elastic Security
  • 密钥管理:Vault 或云厂商 KMS(签名密钥托管)

通过系统化的白名单治理,企业可以将容器镜像供应链攻击面从"不可控"压缩到"可枚举、可审批、可审计、可阻断",真正实现生产环境的零信任安全。

点赞(0) 打赏

评论列表 共有 0 条评论

暂无评论
立即
投稿

微信公众账号

微信扫一扫加关注

发表
评论
返回
顶部