name: helm-catalog-cve-edge-post

# manifests/helm 카탈로그의 컨테이너 이미지 취약점을 스캔해 단일 JSON 요약으로 출력한다.
#   [{"catalog": "airflow", "version": "1.0.0", "image": "...",
#     "low": 0, "high": 0, "medium": 0, "critical": 0,
#     "scanned_at": "2026-07-13T06:19:44Z",
#     "summary": "CVE-xxxx-xxxxx: short description; CVE-yyyy-yyyyy: ..."}, ...]
# 배열 원소는 (catalog, version) 기준이다 — 하나의 이미지가 여러 chart/version
# (manifests/helm/<name>/<version>/)에서 재사용되면 그 조합 수만큼 항목이 중복 생성된다.
# summary 는 CRITICAL 취약점만 대상이며, CVE ID 별로 trivy 가 제공하는 Title(또는
# Description 첫 문장)을 짧은 설명으로 붙인다.
# 생성된 JSON 은 POST https://edge.gke.paasup.io/api/v1/cve-scans 로 전송한다.
# (X-CVE-API-Key 헤더 필요 — Repo Secret CVE_API_KEY, SSL 검증은 --insecure 로 스킵)
#
# workflow_dispatch 의 chart 입력으로 특정 카탈로그(manifests/helm/<chart>/)만 대상으로
# 스캔할 수 있다. 빈 값이면 전체 카탈로그를 스캔한다(스케줄 실행 시 항상 전체).

on:
  workflow_dispatch:
    inputs:
      chart:
        description: '대상 차트명 (manifests/helm/ 하위 디렉토리명, 빈 값=전체)'
        required: false
        default: ''
      limit:
        description: '대상 이미지 수 상한 (0=전체). 테스트 시 예: 3'
        required: false
        default: '0'
  schedule:
    - cron: '0 10 * * 0'

permissions:
  contents: read

jobs:
  cve-json:
    runs-on: ubuntu-latest
    timeout-minutes: 120
    container:
      image: ${{ vars.SBOM_PIPELINE_IMAGE }}
    env:
      OUT_DIR: ${{ github.workspace }}/sbom-out
      TRIVY_CACHE_DIR: ${{ github.workspace }}/sbom-out/cache
      PARALLEL: '3'
    steps:
      - name: Preflight — 도구 확인
        run: |
          set -e
          for t in helm trivy python3 bash git; do
            command -v "$t" >/dev/null || { echo "::error::컨테이너에 $t 없음 (vars.SBOM_PIPELINE_IMAGE 확인)"; exit 1; }
          done
          helm version --short; trivy --version | head -1

      - uses: actions/checkout@v4

      - name: git safe.directory
        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"

      # 사설 레지스트리 인증: 시크릿으로 docker config.json 을 만들어 trivy 가 읽게 한다.
      - name: 레지스트리 인증 구성
        env:
          DOCKERHUB_USER: ${{ secrets.DOCKERHUB_USER }}
          DOCKERHUB_TOKEN: ${{ secrets.DOCKERHUB_TOKEN }}
          NGC_API_KEY: ${{ secrets.NGC_API_KEY }}
        run: |
          mkdir -p "$OUT_DIR/.docker"
          python3 - <<'PY'
          import os, json, base64
          auths={}
          def add(reg,user,secret):
              if user and secret:
                  auths[reg]={"auth":base64.b64encode(f"{user}:{secret}".encode()).decode()}
          add("https://index.docker.io/v1/", os.environ.get("DOCKERHUB_USER"), os.environ.get("DOCKERHUB_TOKEN"))
          # docker.getcollate.io(openmetadata)는 Docker Hub 프록시 → 익명 pull 시 Docker Hub rate
          # limit(TOOMANYREQUESTS)에 걸린다. Docker Hub 자격증명으로 인증해 해소.
          add("docker.getcollate.io", os.environ.get("DOCKERHUB_USER"), os.environ.get("DOCKERHUB_TOKEN"))
          add("nvcr.io", "$oauthtoken", os.environ.get("NGC_API_KEY"))
          out=os.path.join(os.environ["OUT_DIR"],".docker","config.json")
          json.dump({"auths":auths}, open(out,"w"))
          print("configured registries:", list(auths.keys()) or "(none)")
          PY
          echo "DOCKER_CONFIG=$OUT_DIR/.docker" >> "$GITHUB_ENV"

      - name: 이미지 인벤토리 추출
        run: bash doc/scripts/extract-helm-images.sh "$GITHUB_WORKSPACE/manifests/helm" "$OUT_DIR"

      - name: 스캔 대상 결정 (차트 필터 + 상한)
        env:
          CHART: ${{ github.event.inputs.chart || '' }}
          LIMIT: ${{ github.event.inputs.limit || '0' }}
        run: |
          if [ -n "$CHART" ]; then
            awk -F'\t' -v c="$CHART" '$1==c{print $3}' "$OUT_DIR/images_final.tsv" | sort -u > "$OUT_DIR/images_scan.txt"
            echo "차트 필터: $CHART"
          else
            cut -f3 "$OUT_DIR/images_final.tsv" | sort -u > "$OUT_DIR/images_scan.txt"
          fi
          if [ "$LIMIT" -gt 0 ] 2>/dev/null; then
            head -n "$LIMIT" "$OUT_DIR/images_scan.txt" > "$OUT_DIR/images_scan.txt.tmp"
            mv "$OUT_DIR/images_scan.txt.tmp" "$OUT_DIR/images_scan.txt"
          fi
          wc -l "$OUT_DIR/images_scan.txt"

      # SBOM 산출물은 필요 없으므로 trivy image 로 이미지를 직접 스캔한다(SBOM 생성 단계 생략).
      - name: 취약점 스캔 (trivy image 직접 실행)
        run: |
          set -uo pipefail
          REPORTS_DIR="$OUT_DIR/trivy-reports"
          mkdir -p "$REPORTS_DIR"
          [ -s "$OUT_DIR/images_scan.txt" ] || { echo "대상 이미지 없음 — 스캔 생략"; exit 0; }

          echo ">> trivy DB 워밍 중..."
          trivy image --download-db-only

          xargs -P "${PARALLEL:-3}" -I{} bash -c '
            img="$1"; reports="$2"
            safe=$(printf "%s" "$img" | tr "/:@" "___")
            echo ">> 스캔: $img"
            trivy image --quiet --cache-backend memory --skip-db-update \
              --format json --timeout 15m --output "$reports/$safe.json" "$img" \
              || echo "::warning::스캔 실패: $img"
          ' _ {} "$REPORTS_DIR" < "$OUT_DIR/images_scan.txt"

      # trivy-reports/*.json (이미지별 원본 Trivy 결과)을 python3 로 집계한 뒤,
      # images_final.tsv(chart⇥version⇥image) 기준으로 (catalog, version) 별 항목을 만든다.
      # 하나의 이미지가 여러 chart/version 에서 쓰이면 그 수만큼 결과가 중복 생성된다.
      - name: CVE JSON 생성
        run: |
          python3 - "$OUT_DIR/trivy-reports" "$OUT_DIR/images_final.tsv" "$OUT_DIR/cve-summary.json" <<'PY'
          import sys, os, json, glob, collections
          from datetime import datetime, timezone

          reports_dir, images_final_path, out_path = sys.argv[1], sys.argv[2], sys.argv[3]
          scanned_at = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")

          image_catalogs = collections.defaultdict(list)
          if os.path.exists(images_final_path):
              with open(images_final_path) as f:
                  for line in f:
                      parts = line.rstrip("\n").split("\t")
                      if len(parts) >= 3 and parts[2]:
                          entry = (parts[0], parts[1])
                          if entry not in image_catalogs[parts[2]]:
                              image_catalogs[parts[2]].append(entry)

          results = []
          for path in sorted(glob.glob(os.path.join(reports_dir, "*.json"))):
              with open(path) as f:
                  data = json.load(f)
              image = data.get("ArtifactName", os.path.basename(path))
              counts = {"LOW": 0, "HIGH": 0, "MEDIUM": 0, "CRITICAL": 0}
              critical_desc = {}
              for result in data.get("Results") or []:
                  for vuln in result.get("Vulnerabilities") or []:
                      sev = vuln.get("Severity")
                      if sev in counts:
                          counts[sev] += 1
                          if sev == "CRITICAL":
                              vid = vuln["VulnerabilityID"]
                              if vid not in critical_desc:
                                  desc = vuln.get("Title") or (vuln.get("Description") or "").split(". ")[0]
                                  critical_desc[vid] = desc.strip()

              summary = "; ".join(
                  f"{vid}: {desc}" if desc else vid
                  for vid, desc in sorted(critical_desc.items())
              )

              for catalog, version in image_catalogs.get(image, [("", "")]):
                  results.append({
                      "catalog": catalog,
                      "version": version,
                      "image": image,
                      "low": counts["LOW"],
                      "high": counts["HIGH"],
                      "medium": counts["MEDIUM"],
                      "critical": counts["CRITICAL"],
                      "scanned_at": scanned_at,
                      "summary": summary,
                  })

          with open(out_path, "w") as f:
              json.dump(results, f)
          print(json.dumps(results, indent=2))
          PY

          cat "$OUT_DIR/cve-summary.json" >> "$GITHUB_STEP_SUMMARY"

      - name: CVE 스캔 결과 전송
        if: always()
        env:
          CVE_API_KEY: ${{ secrets.CVE_API_KEY }}
        run: |
          if [ ! -f "$OUT_DIR/cve-summary.json" ]; then
            echo "::warning::$OUT_DIR/cve-summary.json 없음 — 전송 생략"
            exit 0
          fi
          curl --fail-with-body --silent --show-error --insecure \
            --request POST "https://edge.gke.paasup.io/api/v1/cve-scans" \
            --header "Content-Type: application/json" \
            --header "X-CVE-API-Key: $CVE_API_KEY" \
            --data @"$OUT_DIR/cve-summary.json"