컨테이너 이미지 보안 파이프라인: Trivy·Sigstore·Cosign으로 구축하는 Supply Chain Security

┌─────────────────────────────────────────────────────────────────┐
│                   Supply Chain Security Pipeline                │
├─────────┬──────────────┬──────────────┬────────────────────────┤
│  Build  │    Scan      │    Sign      │    Enforce             │
│         │              │              │                        │
│ Docker  │ Trivy        │ Cosign       │ Kyverno /              │
│ Build   │ (CVE Scan)   │ (Keyless     │ OPA Gatekeeper         │
│         │              │  Signing)    │ (Admission Controller) │
│ SBOM    │ Grype        │ Sigstore     │                        │
│ 생성    │ (대안 도구)  │ (Rekor Log)  │ Policy Engine          │
│         │              │              │                        │
│ Distro- │ Secret Scan  │ Fulcio       │ Image Digest           │
│ less    │              │ (인증서 발급)│ Pinning                │
│ Base    │ IaC Scan     │              │                        │
└─────────┴──────────────┴──────────────┴────────────────────────┘
     │            │              │                │
     ▼            ▼              ▼                ▼
  Registry    Report /       Signature        Allow / Deny
  Push        Gate CI/CD     in Registry       Pod Creation

# macOS 설치
brew install trivy

# Linux 설치 (deb 패키지)
sudo apt-get install -y wget apt-transport-https gnupg lsb-release
wget -qO - https://aquasecurity.github.io/trivy-repo/deb/public.key | \
  gpg --dearmor | sudo tee /usr/share/keyrings/trivy.gpg > /dev/null
echo "deb [signed-by=/usr/share/keyrings/trivy.gpg] \
  https://aquasecurity.github.io/trivy-repo/deb $(lsb_release -sc) main" | \
  sudo tee /etc/apt/sources.list.d/trivy.list
sudo apt-get update && sudo apt-get install -y trivy

# Docker로 실행 (설치 없이)
docker run --rm -v /var/run/docker.sock:/var/run/docker.sock \
  aquasec/trivy:latest image python:3.12-slim

# 기본 이미지 스캔
trivy image nginx:1.27

# 심각도 필터링: CRITICAL과 HIGH만 표시
trivy image --severity CRITICAL,HIGH myapp:v1.2.3

# 수정 가능한 취약점만 표시 (실제 조치 가능한 항목에 집중)
trivy image --ignore-unfixed --severity CRITICAL,HIGH myapp:v1.2.3

# JSON 포맷 출력 (CI/CD 파이프라인에서 파싱용)
trivy image --format json --output results.json myapp:v1.2.3

# SARIF 포맷 출력 (GitHub Security Tab 연동)
trivy image --format sarif --output trivy-results.sarif myapp:v1.2.3

# 종료 코드를 활용한 CI 게이트 (CRITICAL 발견 시 빌드 실패)
trivy image --exit-code 1 --severity CRITICAL myapp:v1.2.3

# 포괄적 탐지 모드로 스캔
trivy image --detection-priority comprehensive myapp:v1.2.3

# trivy.yaml
scan:
  security-checks:
    - vuln
    - secret
    - misconfig
  severity:
    - CRITICAL
    - HIGH
  ignore-unfixed: true

vulnerability:
  type:
    - os
    - library

image:
  removed-pkgs: true
  input: []
# 특정 CVE 예외 처리 (승인된 위험 수용)
# .trivyignore 파일에서 관리

# .trivyignore
# 2026-06-30까지 유예: 패치 미제공, 영향 범위 제한적
CVE-2024-12345  # libfoo: 로컬 권한 상승, 네트워크 접근 불가
CVE-2025-67890  # openssl: DoS 가능성, WAF에서 차단 중

# CycloneDX 포맷으로 SBOM 생성
trivy image --format cyclonedx --output sbom.cdx.json myapp:v1.2.3

# SPDX 포맷으로 SBOM 생성
trivy image --format spdx-json --output sbom.spdx.json myapp:v1.2.3

# SBOM 기반 취약점 재스캔 (이미지 없이도 가능)
trivy sbom sbom.cdx.json

# Syft를 사용한 SBOM 생성 (Grype 연동 시)
syft myapp:v1.2.3 -o cyclonedx-json > sbom.cdx.json
grype sbom:sbom.cdx.json

# OCI 레지스트리에 SBOM을 아티팩트로 첨부 (Cosign 활용)
cosign attach sbom --sbom sbom.cdx.json myregistry.io/myapp:v1.2.3

# SBOM을 이미지와 함께 레지스트리에 저장하면
# 이미지를 pull하는 쪽에서 SBOM도 함께 가져올 수 있음
cosign download sbom myregistry.io/myapp:v1.2.3

# macOS
brew install cosign

# Linux (Go Install)
go install github.com/sigstore/cosign/v2/cmd/cosign@latest

# GitHub Actions에서는 sigstore/cosign-installer 사용
# (아래 CI/CD 통합 섹션에서 상세 설명)

# 키리스 서명 (OIDC 기반)
# 로컬에서 실행 시 브라우저가 열리며 OIDC 인증 진행
cosign sign myregistry.io/myapp@sha256:abc123def456...

# 중요: 태그가 아닌 다이제스트로 서명해야 함
# 태그는 변경 가능하므로 다이제스트를 사용해야 Tag Mutability 공격을 방지
IMAGE_DIGEST=$(docker inspect --format='{{index .RepoDigests 0}}' myapp:v1.2.3)
cosign sign "${IMAGE_DIGEST}"

# 서명 검증
cosign verify \
  --certificate-identity=ci-pipeline@myorg.iam.gserviceaccount.com \
  --certificate-oidc-issuer=https://accounts.google.com \
  myregistry.io/myapp@sha256:abc123def456...

# 특정 GitHub Actions 워크플로에서 빌드된 이미지만 신뢰
cosign verify \
  --certificate-identity-regexp="https://github.com/myorg/myrepo/.github/workflows/.*" \
  --certificate-oidc-issuer=https://token.actions.githubusercontent.com \
  myregistry.io/myapp@sha256:abc123def456...

# 키페어 생성
cosign generate-key-pair

# 생성된 키로 서명
cosign sign --key cosign.key myregistry.io/myapp@sha256:abc123...

# 공개키로 검증
cosign verify --key cosign.pub myregistry.io/myapp@sha256:abc123...

# KMS 연동 서명 (AWS KMS 예시)
cosign generate-key-pair --kms awskms:///alias/cosign-key
cosign sign --key awskms:///alias/cosign-key myregistry.io/myapp@sha256:abc123...

# .github/workflows/container-security.yml
name: Container Security Pipeline

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

env:
  REGISTRY: ghcr.io
  IMAGE_NAME: ${{ github.repository }}

permissions:
  contents: read
  packages: write
  id-token: write # Cosign 키리스 서명에 필요
  security-events: write # SARIF 업로드에 필요

jobs:
  build-scan-sign:
    runs-on: ubuntu-latest
    steps:
      # 1. 체크아웃
      - name: Checkout repository
        uses: actions/checkout@v4

      # 2. Cosign 설치
      - name: Install Cosign
        uses: sigstore/cosign-installer@v3.8.2

      # 3. Docker Buildx 설정
      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v3

      # 4. 레지스트리 로그인
      - name: Log in to GHCR
        uses: docker/login-action@v3
        with:
          registry: ${{ env.REGISTRY }}
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}

      # 5. 이미지 빌드 및 푸시
      - name: Build and push image
        id: build-push
        uses: docker/build-push-action@v6
        with:
          context: .
          push: true
          tags: |
            ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ github.sha }}
            ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:latest
          cache-from: type=gha
          cache-to: type=gha,mode=max

      # 6. Trivy 취약점 스캔 (CI 게이트)
      - name: Scan image with Trivy
        uses: aquasecurity/trivy-action@0.28.0
        with:
          image-ref: '${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ github.sha }}'
          format: 'table'
          exit-code: '1'
          ignore-unfixed: true
          severity: 'CRITICAL,HIGH'

      # 7. Trivy SARIF 리포트 (GitHub Security Tab)
      - name: Generate Trivy SARIF report
        uses: aquasecurity/trivy-action@0.28.0
        if: always()
        with:
          image-ref: '${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ github.sha }}'
          format: 'sarif'
          output: 'trivy-results.sarif'
          severity: 'CRITICAL,HIGH,MEDIUM'

      - name: Upload SARIF to GitHub Security
        uses: github/codeql-action/upload-sarif@v3
        if: always()
        with:
          sarif_file: 'trivy-results.sarif'

      # 8. SBOM 생성
      - name: Generate SBOM
        uses: aquasecurity/trivy-action@0.28.0
        with:
          image-ref: '${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ github.sha }}'
          format: 'cyclonedx'
          output: 'sbom.cdx.json'

      # 9. Cosign 키리스 서명 (스캔 통과 후에만 실행)
      - name: Sign container image
        run: |
          cosign sign --yes \
            ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}@${{ steps.build-push.outputs.digest }}

      # 10. SBOM을 이미지에 첨부
      - name: Attach SBOM to image
        run: |
          cosign attach sbom \
            --sbom sbom.cdx.json \
            ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}@${{ steps.build-push.outputs.digest }}

      # 11. 서명 검증 (파이프라인 내 검증)
      - name: Verify signature
        run: |
          cosign verify \
            --certificate-identity-regexp="https://github.com/${{ github.repository }}/.github/workflows/.*" \
            --certificate-oidc-issuer=https://token.actions.githubusercontent.com \
            ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}@${{ steps.build-push.outputs.digest }}

# .gitlab-ci.yml
stages:
  - build
  - scan
  - sign

variables:
  IMAGE_TAG: '${CI_REGISTRY_IMAGE}:${CI_COMMIT_SHA}'

build:
  stage: build
  image: docker:24
  services:
    - docker:24-dind
  script:
    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
    - docker build -t $IMAGE_TAG .
    - docker push $IMAGE_TAG
    - |
      DIGEST=$(docker inspect --format='{{index .RepoDigests 0}}' $IMAGE_TAG)
      echo "IMAGE_DIGEST=${DIGEST}" >> build.env
  artifacts:
    reports:
      dotenv: build.env

scan:
  stage: scan
  image:
    name: aquasec/trivy:latest
    entrypoint: ['']
  script:
    - trivy image --exit-code 1 --severity CRITICAL,HIGH --ignore-unfixed $IMAGE_TAG
    - trivy image --format cyclonedx --output sbom.cdx.json $IMAGE_TAG
  artifacts:
    paths:
      - sbom.cdx.json
    when: always

sign:
  stage: sign
  image: bitnami/cosign:latest
  id_tokens:
    SIGSTORE_ID_TOKEN:
      aud: sigstore
  script:
    - cosign sign --yes ${IMAGE_DIGEST}
  needs:
    - job: build
      artifacts: true
    - job: scan

# ---- 보안 강화 멀티 스테이지 Dockerfile ----

# Stage 1: 빌드 (빌드 의존성은 최종 이미지에 포함되지 않음)
FROM golang:1.23-alpine AS builder

# 보안: 루트가 아닌 사용자로 빌드
RUN adduser -D -u 10001 appuser

WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download && go mod verify
COPY . .

# CGO 비활성화로 정적 바이너리 생성 (외부 C 라이브러리 의존성 제거)
RUN CGO_ENABLED=0 GOOS=linux go build \
    -ldflags='-w -s -extldflags "-static"' \
    -o /app/server ./cmd/server

# Stage 2: 최종 이미지 (Distroless 사용)
FROM gcr.io/distroless/static-debian12:nonroot

# 빌드 스테이지에서 바이너리만 복사
COPY --from=builder /app/server /server

# 비루트 사용자로 실행
USER 10001:10001

# 헬스체크용 포트만 노출
EXPOSE 8080

ENTRYPOINT ["/server"]

# kyverno-verify-image-policy.yaml
apiVersion: kyverno.io/v1
kind: ClusterPolicy
metadata:
  name: verify-container-image-signatures
  annotations:
    policies.kyverno.io/title: Verify Image Signatures
    policies.kyverno.io/description: >-
      서명되지 않은 컨테이너 이미지의 배포를 차단합니다.
      Cosign keyless 서명이 확인된 이미지만 허용합니다.
spec:
  validationFailureAction: Enforce # Audit(경고만) 또는 Enforce(차단)
  background: false
  webhookTimeoutSeconds: 30
  rules:
    - name: verify-cosign-signature
      match:
        any:
          - resources:
              kinds:
                - Pod
              namespaces:
                - production
                - staging
      verifyImages:
        - imageReferences:
            - 'ghcr.io/myorg/*'
            - 'myregistry.io/myorg/*'
          attestors:
            - entries:
                - keyless:
                    subject: 'https://github.com/myorg/myrepo/.github/workflows/*'
                    issuer: 'https://token.actions.githubusercontent.com'
                    rekor:
                      url: https://rekor.sigstore.dev
          mutateDigest: true # 태그를 다이제스트로 자동 변환
          verifyDigest: true # 다이제스트 일치 검증
          required: true

# Kyverno 설치 (Helm)
helm repo add kyverno https://kyverno.github.io/kyverno/
helm repo update
helm install kyverno kyverno/kyverno \
  --namespace kyverno \
  --create-namespace \
  --set replicaCount=3

# 정책 적용
kubectl apply -f kyverno-verify-image-policy.yaml

# 정책 테스트: 서명되지 않은 이미지로 Pod 생성 시도
kubectl run test --image=nginx:latest -n production
# 결과: Error from server: admission webhook denied the request:
# resource Pod/production/test was blocked due to the following policies:
# verify-container-image-signatures

# ConstraintTemplate 정의
apiVersion: templates.gatekeeper.sh/v1
kind: ConstraintTemplate
metadata:
  name: k8sallowedregistries
spec:
  crd:
    spec:
      names:
        kind: K8sAllowedRegistries
      validation:
        openAPIV3Schema:
          type: object
          properties:
            registries:
              type: array
              items:
                type: string
  targets:
    - target: admission.k8s.gatekeeper.sh
      rego: |
        package k8sallowedregistries
        violation[{"msg": msg}] {
          container := input.review.object.spec.containers[_]
          not startswith(container.image, input.parameters.registries[_])
          msg := sprintf(
            "컨테이너 이미지 '%v'는 허용된 레지스트리에서 가져온 것이 아닙니다. 허용 목록: %v",
            [container.image, input.parameters.registries]
          )
        }
---
# Constraint 적용
apiVersion: constraints.gatekeeper.sh/v1beta1
kind: K8sAllowedRegistries
metadata:
  name: allowed-registries
spec:
  match:
    kinds:
      - apiGroups: ['']
        kinds: ['Pod']
    namespaces: ['production', 'staging']
  parameters:
    registries:
      - 'ghcr.io/myorg/'
      - 'myregistry.io/myorg/'

# 증상
FATAL  failed to download vulnerability DB

# 원인: GitHub API Rate Limit, 네트워크 제한
# 복구 절차:

# 1. DB를 수동 다운로드하여 캐싱
trivy image --download-db-only
# DB 위치: ~/.cache/trivy/db/

# 2. CI에서 DB 캐시 활용 (GitHub Actions 예시)
# - name: Cache Trivy DB
#   uses: actions/cache@v4
#   with:
#     path: ~/.cache/trivy
#     key: trivy-db-${{ hashFiles('.trivy-db-timestamp') }}

# 3. 에어갭 환경에서 OCI 아티팩트로 DB 미러링
oras pull ghcr.io/aquasecurity/trivy-db:2 -o ./trivy-db/
trivy image --cache-dir ./trivy-db/ --skip-db-update myapp:v1.2.3

# 증상
Error: getting identity token: oauth2/google: ...

# GitHub Actions에서 발생하는 경우:
# 원인 1: permissions에 id-token: write 누락
# 원인 2: fork된 PR에서는 OIDC 토큰 발급 불가 (보안 정책)
# 원인 3: Fulcio/Rekor 서비스 장애

# 복구 절차:
# 1. permissions 확인
permissions:
  id-token: write    # 이 줄이 반드시 필요

# 2. Sigstore 서비스 상태 확인
curl -s https://status.sigstore.dev/ | jq .

# 3. 폴백: 키 기반 서명으로 전환
cosign sign --key env://COSIGN_PRIVATE_KEY \
  myregistry.io/myapp@sha256:abc123...

# 증상: 서명된 이미지인데 배포가 거부됨
# Error: failed to verify image signature

# 디버깅 절차:
# 1. 로컬에서 서명 검증 먼저 확인
cosign verify \
  --certificate-identity-regexp="..." \
  --certificate-oidc-issuer="..." \
  myregistry.io/myapp@sha256:abc123...

# 2. Kyverno 로그 확인
kubectl logs -n kyverno -l app.kubernetes.io/component=admission-controller

# 3. 정책의 issuer/subject 패턴이 실제 인증서와 일치하는지 확인
cosign verify myregistry.io/myapp@sha256:abc123... 2>&1 | \
  grep -E "(Issuer|Subject)"

# 4. 긴급 복구: 정책을 Audit 모드로 전환 (차단 -> 경고)
kubectl patch clusterpolicy verify-container-image-signatures \
  --type='json' \
  -p='[{"op": "replace", "path": "/spec/validationFailureAction", "value": "Audit"}]'

# 증상: 서명은 성공했지만 검증 시 서명을 찾을 수 없음
# Error: no matching signatures found

# 원인: 서명이 별도 저장소에 저장되었거나 레지스트리가 OCI 1.1 미지원
# 복구 절차:

# 1. 서명이 저장된 위치 확인
crane ls myregistry.io/myapp | grep sha256-

# 2. 수동으로 서명 저장소 지정
cosign verify \
  --certificate-identity-regexp="..." \
  --certificate-oidc-issuer="..." \
  --registry-referrers-mode=oci-1-1 \
  myregistry.io/myapp@sha256:abc123...

Dev 빌드 완료 → [Trivy Scan] → [CI 서명 부착]
                                    │
                                    ▼
              Staging 배포 ← [CI 서명 검증] → QA 테스트 통과
                                                    │
                                                    ▼
              Production 배포 ← [CI 서명 + QA 서명 검증]

# 1. CI 파이프라인에서 빌드 후 서명 (위의 GitHub Actions 참조)

# 2. QA 팀이 테스트 통과 후 추가 서명
cosign sign --key env://QA_COSIGN_KEY \
  -a "qa-approved=true" \
  -a "qa-tester=jane.doe" \
  -a "test-suite=integration-v3" \
  myregistry.io/myapp@sha256:abc123...

# 3. Production Kyverno 정책: CI 서명 + QA 서명 모두 필수
# verifyImages에 attestors를 AND 조건으로 구성

# 취약점 스캔 결과를 Attestation으로 부착
trivy image --format cosign-vuln --output vuln-att.json myapp:v1.2.3
cosign attest --predicate vuln-att.json \
  --type vuln \
  myregistry.io/myapp@sha256:abc123...

# SBOM을 Attestation으로 부착
cosign attest --predicate sbom.cdx.json \
  --type cyclonedx \
  myregistry.io/myapp@sha256:abc123...

# Attestation 검증
cosign verify-attestation \
  --certificate-identity-regexp="..." \
  --certificate-oidc-issuer="..." \
  --type vuln \
  myregistry.io/myapp@sha256:abc123...

# 1. DB 캐싱으로 반복 다운로드 방지
# CI에서 캐시 디렉토리를 persist
trivy image --cache-dir /shared-cache/trivy myapp:v1.2.3

# 2. 불필요한 스캔 타입 비활성화
# 취약점만 필요할 때 secret, misconfig 스캔 제외
trivy image --scanners vuln myapp:v1.2.3

# 3. 병렬 스캐닝 (Trivy v0.68+ 동시 DB 접근 지원)
# 여러 이미지를 동시에 스캔할 때 DB lock 이슈 해소
parallel -j4 trivy image --cache-dir /shared-cache/trivy {} ::: \
  myapp-api:v1.2.3 myapp-web:v1.2.3 myapp-worker:v1.2.3 myapp-cron:v1.2.3