What it does. 'Integrates Aqua Security''s Trivy scanner into CI/CD pipelines to detect Part of mukul975/Anthropic-Cybersecurity-Skills (817 security skills) (mukul975/Anthropic-Cybersecurity-Skills).

Upstream	mukul975/Anthropic-Cybersecurity-Skills
Skill file	skills/scanning-containers-with-trivy-in-cicd/SKILL.md
License	Apache-2.0 (skill folder LICENSE)
Author	mukul975
Fetched	2026-09-10

Install

• npx skills add mukul975/Anthropic-Cybersecurity-Skills --skill scanning-containers-with-trivy-in-cicd, or copy the skill folder into ~/.claude/skills/scanning-containers-with-trivy-in-cicd/.
• Raw file: curl -sL https://raw.githubusercontent.com/mukul975/Anthropic-Cybersecurity-Skills/HEAD/skills/scanning-containers-with-trivy-in-cicd/SKILL.md

SKILL.md (verbatim)

name: scanning-containers-with-trivy-in-cicd
description: 'Integrates Aqua Security''s Trivy scanner into CI/CD pipelines to detect
  OS package and application dependency CVEs, Dockerfile misconfigurations, and issues
  in filesystems or git repositories, and to enforce severity-based quality gates that
  block vulnerable images from being deployed. Use when building Docker images in
  CI/CD and needing automated vulnerability scanning and pass/fail gates before registry
  push or production deployment.

  '
domain: cybersecurity
subdomain: devsecops
tags:
- devsecops
- cicd
- trivy
- container-security
- vulnerability-scanning
- secure-sdlc
version: 1.0.0
author: mahipal
license: Apache-2.0
nist_csf:
- PR.PS-01
- GV.SC-07
- ID.IM-04
- PR.PS-04
mitre_attack:
- T1195
- T1554
- T1059.004
- T1610
- T1611

Scanning Containers with Trivy in CI/CD

When to Use

• When building Docker container images in CI/CD and needing automated vulnerability scanning before registry push
• When establishing quality gates that prevent images with critical or high CVEs from reaching production
• When compliance requirements mandate vulnerability scanning of all container images before deployment
• When scanning IaC files (Dockerfiles, Kubernetes manifests) alongside container image scanning
• When needing a single tool to scan OS packages, language-specific dependencies, and misconfigurations

Do not use for runtime container security monitoring (use Falco), for scanning running containers in production (use runtime agents), or when only scanning application source code without containerization (use SAST tools).

Prerequisites

• Trivy CLI installed (v0.50+) or access to aquasecurity/trivy-action GitHub Action
• Docker daemon available in CI/CD for building and scanning images
• Container registry credentials for pulling base images and pushing scanned images
• Trivy vulnerability database accessible (downloaded automatically or cached)

Workflow

Step 1: Configure Trivy Scanning in GitHub Actions

Set up a GitHub Actions workflow that builds a Docker image and scans it with Trivy before pushing to a container registry.

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

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]
    paths:
      - 'Dockerfile'
      - 'docker-compose*.yml'
      - 'src/**'
      - 'requirements*.txt'
      - 'package*.json'

jobs:
  build-and-scan:
    runs-on: ubuntu-latest
    permissions:
      security-events: write
      contents: read

    steps:
      - uses: actions/checkout@v4

      - name: Build Docker image
        run: docker build -t app:${{ github.sha }} .

      - name: Run Trivy vulnerability scanner
        uses: aquasecurity/trivy-action@0.28.0
        with:
          image-ref: 'app:${{ github.sha }}'
          format: 'sarif'
          output: 'trivy-results.sarif'
          severity: 'CRITICAL,HIGH'
          exit-code: '1'
          ignore-unfixed: true

      - name: Upload Trivy scan results
        uses: github/codeql-action/upload-sarif@v3
        if: always()
        with:
          sarif_file: 'trivy-results.sarif'
          category: 'trivy-container'

      - name: Run Trivy misconfiguration scanner
        uses: aquasecurity/trivy-action@0.28.0
        with:
          scan-type: 'config'
          scan-ref: '.'
          format: 'table'
          exit-code: '1'
          severity: 'CRITICAL,HIGH'

Step 2: Scan Dockerfiles for Misconfigurations

Trivy detects common Dockerfile security issues such as running as root, using latest tags, and exposing unnecessary ports.

# Scan Dockerfile for misconfigurations
trivy config --severity HIGH,CRITICAL ./Dockerfile

# Scan with custom policy directory
trivy config --policy ./security-policies --severity MEDIUM,HIGH,CRITICAL .

# Example secure Dockerfile practices Trivy checks for:
# - USER instruction present (not running as root)
# - HEALTHCHECK instruction defined
# - Base image uses specific tag, not :latest
# - No secrets in ENV or ARG instructions
# - COPY preferred over ADD

Step 3: Integrate with GitLab CI/CD

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

variables:
  TRIVY_CACHE_DIR: .trivycache/

build:
  stage: build
  script:
    - docker build -t $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA .
    - docker save $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA -o image.tar
  artifacts:
    paths:
      - image.tar

trivy-scan:
  stage: scan
  image:
    name: aquasec/trivy:latest
    entrypoint: [""]
  cache:
    paths:
      - .trivycache/
  script:
    - trivy image
        --input image.tar
        --exit-code 1
        --severity CRITICAL,HIGH
        --ignore-unfixed
        --format json
        --output trivy-report.json
    - trivy image
        --input image.tar
        --severity CRITICAL,HIGH,MEDIUM
        --format table
  artifacts:
    reports:
      container_scanning: trivy-report.json
    paths:
      - trivy-report.json
  allow_failure: false

push:
  stage: push
  needs: [trivy-scan]
  script:
    - docker load -i image.tar
    - docker push $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA

Step 4: Configure Trivy Ignore and Exception Handling

Manage false positives and accepted risks through Trivy's ignore file and VEX statements.

# .trivyignore.yaml
vulnerabilities:
  - id: CVE-2023-44487    # HTTP/2 rapid reset - mitigated at load balancer
    statement: "Mitigated by WAF rate limiting at ingress layer"
    expires: 2026-06-01

  - id: CVE-2024-21626    # runc container escape - patched in base image update
    statement: "Tracked in JIRA-SEC-1234, base image update scheduled"
    expires: 2026-03-15

misconfigurations:
  - id: DS002             # User not set - required for init containers
    paths:
      - "docker/init-container/Dockerfile"
    statement: "Init container requires root for volume permission setup"

Step 5: Implement Database Caching and Offline Scanning

Cache the Trivy vulnerability database in CI/CD to reduce scan times and enable air-gapped environments.

# GitHub Actions with database caching
- name: Cache Trivy DB
  uses: actions/cache@v4
  with:
    path: /tmp/trivy-db
    key: trivy-db-${{ hashFiles('.github/workflows/container-security.yml') }}
    restore-keys: trivy-db-

- name: Run Trivy with cached DB
  uses: aquasecurity/trivy-action@0.28.0
  with:
    image-ref: 'app:${{ github.sha }}'
    cache-dir: /tmp/trivy-db
    format: 'json'
    output: 'trivy-results.json'
    severity: 'CRITICAL,HIGH'
    exit-code: '1'

# Air-gapped: Download DB manually and mount
trivy image --download-db-only --cache-dir /path/to/cache
# Transfer cache to air-gapped system
trivy image --skip-db-update --cache-dir /path/to/cache myimage:tag

Step 6: Generate SBOM and Scan for License Compliance

Use Trivy to generate Software Bill of Materials alongside vulnerability scanning.

# Generate SBOM in CycloneDX format
trivy image --format cyclonedx --output sbom.cdx.json app:latest

# Generate SBOM in SPDX format
trivy image --format spdx-json --output sbom.spdx.json app:latest

# Scan SBOM for vulnerabilities (decouple generation from scanning)
trivy sbom sbom.cdx.json --severity CRITICAL,HIGH

# Scan with license detection
trivy image --scanners vuln,license --severity HIGH,CRITICAL app:latest

Key Concepts

Term	Definition
CVE	Common Vulnerabilities and Exposures — standardized identifiers for publicly known security vulnerabilities
Vulnerability DB	Trivy's regularly updated database aggregating CVE data from NVD, vendor advisories, and language-specific sources
Misconfiguration	Security-relevant configuration issue in Dockerfiles, Kubernetes manifests, or IaC templates
SBOM	Software Bill of Materials — complete inventory of all components and dependencies in a container image
Ignore Unfixed	Flag to skip CVEs without available patches, reducing noise from vulnerabilities with no actionable fix
VEX	Vulnerability Exploitability eXchange — machine-readable statements about whether a vulnerability is exploitable in context
Exit Code	Non-zero return code from Trivy when findings exceed the severity threshold, used to fail CI/CD pipelines

Tools & Systems

• Trivy: Open-source vulnerability scanner by Aqua Security supporting images, filesystems, repos, and IaC
• trivy-action: Official GitHub Action for running Trivy scans in GitHub Actions workflows
• Trivy Operator: Kubernetes operator that continuously scans cluster workloads with Trivy
• Grype: Alternative image scanner by Anchore for comparison and validation of scan results
• Harbor: Container registry with built-in Trivy integration for automatic image scanning on push

Common Scenarios

Scenario: Multi-Stage Build with Separate Scan and Push

Context: A team builds multi-stage Docker images and needs to scan the final production image before pushing to ECR, while also scanning the build stage for supply chain risks.

Approach:

1. Build the Docker image with --target production for the final stage
2. Run Trivy with --severity CRITICAL,HIGH --exit-code 1 --ignore-unfixed to block on exploitable issues
3. Generate an SBOM in CycloneDX format and store as a build artifact
4. Upload SARIF results to GitHub Security tab for visibility
5. Only push to ECR if the Trivy scan exits with code 0
6. Tag the pushed image with the scan timestamp and Trivy DB version for audit traceability

Pitfalls: Scanning only the final stage misses vulnerable packages that were present in build stages and may have influenced the build. Run trivy fs on the build context separately. Caching the Trivy DB too aggressively (weekly) means newly published CVEs take days to appear in scans.

Output Format

Trivy Container Scan Report
=============================
Image: app:a1b2c3d4
Base Image: python:3.12-slim-bookworm
Scan Date: 2026-02-23
DB Version: 2026-02-23T00:15:00Z

VULNERABILITY SUMMARY:
  Total: 47
  Critical: 2
  High: 5
  Medium: 18
  Low: 22
  Unfixed: 8 (excluded from gate)

CRITICAL FINDINGS:
  CVE-2025-12345  libssl3    3.0.11-1  3.0.13-1  OpenSSL buffer overflow
  CVE-2025-67890  curl       7.88.1-10 7.88.1-12 curl HSTS bypass

HIGH FINDINGS:
  CVE-2025-11111  zlib1g     1.2.13    1.2.13.1  zlib heap buffer overflow
  CVE-2025-22222  python3.12 3.12.1    3.12.3    CPython path traversal
  CVE-2025-33333  requests   2.31.0    2.32.0    requests SSRF in redirects

MISCONFIGURATION:
  DS002  [HIGH]   Dockerfile: USER instruction not set (running as root)
  DS026  [MEDIUM] Dockerfile: No HEALTHCHECK defined

QUALITY GATE: FAILED (2 Critical, 5 High findings)

Other files in this skill

• LICENSE
• assets/template.md
• references/api-reference.md
• references/standards.md
• references/workflows.md
• scripts/agent.py
• scripts/process.py

assets/template.md (verbatim)

Trivy Container Scanning Templates

GitHub Actions: Full Container Security Pipeline

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

on:
  push:
    branches: [main]
  pull_request:
    paths: ['Dockerfile', 'docker-compose*.yml', 'src/**']

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

jobs:
  build-scan-push:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      packages: write
      security-events: write

    steps:
      - uses: actions/checkout@v4

      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v3

      - name: Build image
        uses: docker/build-push-action@v6
        with:
          context: .
          load: true
          tags: ${{ env.IMAGE_NAME }}:scan
          cache-from: type=gha
          cache-to: type=gha,mode=max

      - name: Cache Trivy DB
        uses: actions/cache@v4
        with:
          path: /tmp/trivy
          key: trivy-db-${{ github.run_id }}
          restore-keys: trivy-db-

      - name: Trivy vulnerability scan
        uses: aquasecurity/trivy-action@0.28.0
        with:
          image-ref: ${{ env.IMAGE_NAME }}:scan
          format: sarif
          output: trivy-vuln.sarif
          severity: CRITICAL,HIGH
          exit-code: '1'
          ignore-unfixed: true
          cache-dir: /tmp/trivy

      - name: Upload vulnerability SARIF
        if: always()
        uses: github/codeql-action/upload-sarif@v3
        with:
          sarif_file: trivy-vuln.sarif
          category: trivy-vulnerabilities

      - name: Trivy misconfiguration scan
        uses: aquasecurity/trivy-action@0.28.0
        with:
          scan-type: config
          scan-ref: .
          format: sarif
          output: trivy-config.sarif
          severity: CRITICAL,HIGH
          exit-code: '1'

      - name: Upload config SARIF
        if: always()
        uses: github/codeql-action/upload-sarif@v3
        with:
          sarif_file: trivy-config.sarif
          category: trivy-misconfigurations

      - name: Generate SBOM
        uses: aquasecurity/trivy-action@0.28.0
        with:
          image-ref: ${{ env.IMAGE_NAME }}:scan
          format: cyclonedx
          output: sbom.cdx.json

      - name: Upload SBOM artifact
        uses: actions/upload-artifact@v4
        with:
          name: sbom
          path: sbom.cdx.json

      - name: Login to GHCR
        if: github.event_name == 'push'
        uses: docker/login-action@v3
        with:
          registry: ${{ env.REGISTRY }}
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}

      - name: Push image
        if: github.event_name == '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

Trivy Ignore File Template

# .trivyignore.yaml
vulnerabilities:
  # Accepted risk: mitigated at infrastructure level
  - id: CVE-YYYY-NNNNN
    statement: "Mitigated by WAF rules. Risk accepted by security team."
    expires: 2026-12-31

misconfigurations:
  # Init containers require root
  - id: DS002
    paths:
      - "docker/init/*.Dockerfile"
    statement: "Init containers need root for volume permissions"

Secure Dockerfile Template

# syntax=docker/dockerfile:1

# Build stage
FROM python:3.12-slim-bookworm AS builder
WORKDIR /build
COPY requirements.txt .
RUN pip install --no-cache-dir --prefix=/install -r requirements.txt

# Production stage
FROM python:3.12-slim-bookworm AS production

# Security: Create non-root user
RUN groupadd -r appuser && useradd -r -g appuser -s /bin/false appuser

# Security: Install only runtime dependencies, remove cache
RUN apt-get update && \
    apt-get install -y --no-install-recommends \
      libpq5 \
    && rm -rf /var/lib/apt/lists/*

# Copy installed packages from builder
COPY --from=builder /install /usr/local

# Copy application code
WORKDIR /app
COPY --chown=appuser:appuser src/ ./src/

# Security: Run as non-root
USER appuser

# Health check
HEALTHCHECK --interval=30s --timeout=3s --retries=3 \
  CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:8080/health')" || exit 1

EXPOSE 8080
ENTRYPOINT ["python", "-m", "src.main"]

Trivy Operator for Kubernetes

# Install Trivy Operator via Helm
# helm repo add aqua https://aquasecurity.github.io/helm-charts/
# helm install trivy-operator aqua/trivy-operator \
#   --namespace trivy-system --create-namespace \
#   --set trivy.severity=CRITICAL,HIGH

# Sample VulnerabilityReport CRD
apiVersion: aquasecurity.github.io/v1alpha1
kind: ClusterComplianceReport
metadata:
  name: cis-benchmark
spec:
  cron: "0 */6 * * *"
  compliance:
    id: cis
    title: CIS Kubernetes Benchmark
    platform: k8s

references/api-reference.md (verbatim)

API Reference: Scanning Containers with Trivy in CI/CD

Trivy CLI Commands

Command	Description
trivy image <ref>	Scan container image for vulnerabilities
trivy config <path>	Scan Dockerfiles/IaC for misconfigurations
trivy fs <path>	Scan filesystem for vulnerabilities
trivy sbom <file>	Scan existing SBOM for vulnerabilities
trivy image --format sarif	SARIF output for GitHub Security
trivy image --format cyclonedx	CycloneDX SBOM generation
trivy image --exit-code 1	Non-zero exit on findings

Scan Options

Flag	Description
--severity CRITICAL,HIGH	Filter by severity level
--ignore-unfixed	Skip CVEs without patches
--scanners vuln,misconfig,secret	Select scanner types
--format json/sarif/cyclonedx	Output format
--exit-code 1	Fail pipeline on findings
--skip-db-update	Use cached vulnerability DB
--cache-dir <path>	Set database cache directory

CI/CD Integration

Platform	Method
GitHub Actions	aquasecurity/trivy-action@v0.28.0
GitLab CI	aquasec/trivy:latest Docker image
Jenkins	Trivy CLI in pipeline script
Azure DevOps	Trivy CLI task

Quality Gate Severities

Level	CVSS Range	Default Gate Action
CRITICAL	9.0 - 10.0	Block deployment
HIGH	7.0 - 8.9	Block deployment
MEDIUM	4.0 - 6.9	Warn
LOW	0.1 - 3.9	Allow

Python Libraries

Library	Version	Purpose
subprocess	stdlib	Execute trivy CLI
json	stdlib	Parse scan results
pathlib	stdlib	Output file management

References

• Trivy Documentation: https://trivy.dev/docs/
• Trivy GitHub Action: https://github.com/aquasecurity/trivy-action
• Trivy GitHub: https://github.com/aquasecurity/trivy

references/standards.md (verbatim)

Standards Reference: Container Scanning with Trivy

NIST SP 800-190 - Application Container Security Guide

Image Vulnerabilities (Section 3.1)

• Scan all container images for known vulnerabilities before deployment
• Establish organizational policies for maximum acceptable vulnerability severity
• Monitor images in registries for newly discovered vulnerabilities
• Maintain an up-to-date vulnerability database for scanning tools

Image Configuration Defects (Section 3.2)

• Verify images follow CIS Docker Benchmark configuration guidelines
• Ensure images run as non-root users unless operationally required
• Remove unnecessary packages, shells, and utilities from production images

CIS Docker Benchmark v1.6.0

Image Level Controls

• 4.1: Ensure a user for the container has been created (maps to Trivy DS002)
• 4.2: Ensure containers use trusted base images
• 4.3: Ensure unnecessary packages are not installed in the container
• 4.6: Ensure HEALTHCHECK instructions have been added (maps to Trivy DS026)
• 4.7: Ensure update instructions are not used alone in the Dockerfile
• 4.9: Ensure COPY is used instead of ADD in Dockerfiles (maps to Trivy DS005)

OWASP Docker Security Cheat Sheet

Vulnerability Management

• Scan images in the CI/CD pipeline before pushing to registries
• Use --ignore-unfixed to focus on actionable vulnerabilities
• Implement SBOM generation for full component visibility
• Re-scan images on a schedule to catch newly published CVEs

Dockerfile Security

• Use minimal base images (distroless, Alpine, slim variants)
• Pin base image versions with digest for reproducibility
• Run containers as non-root with explicit USER instruction
• Use multi-stage builds to exclude build tools from production images

NIST SSDF (SP 800-218)

PW.4: Reuse Existing, Well-Secured Software

• PW.4.1: Use automated tools to check for known vulnerabilities in dependencies
• Map to Trivy's OS package and language dependency scanning capabilities

PS.1: Protect All Forms of Code

• PS.1.1: Store all forms of code in a code repository protected by access controls
• Container images in registries should be scanned and signed before use

SLSA Framework Alignment

Source Level

• Trivy filesystem scanning validates source dependencies before build
• Git repository scanning detects secrets and vulnerable dependencies in source

Build Level

• Trivy image scanning validates the build output for vulnerabilities
• SBOM generation creates a verifiable bill of materials for the built artifact

Deployment Level

• Admission controllers can verify Trivy scan results before pod scheduling
• Harbor registry integration enforces scan-before-pull policies

references/workflows.md (verbatim)

Workflow Reference: Container Scanning with Trivy in CI/CD

Container Security Scanning Pipeline

Source Code Push
       │
       ▼
┌──────────────────┐
│ Build Docker      │
│ Image             │
└──────┬───────────┘
       │
       ├──────────────────────┐
       ▼                      ▼
┌──────────────┐    ┌──────────────┐
│ Trivy Image  │    │ Trivy Config │
│ Vuln Scan    │    │ Misconfig    │
└──────┬───────┘    └──────┬───────┘
       │                    │
       ▼                    ▼
┌──────────────┐    ┌──────────────┐
│ SARIF/JSON   │    │ Table/JSON   │
│ Output       │    │ Output       │
└──────┬───────┘    └──────┬───────┘
       │                    │
       └──────────┬─────────┘
                  ▼
       ┌──────────────────┐
       │ Quality Gate     │
       │ Evaluation       │
       └──────┬───────────┘
              │
    ┌─────────┴──────────┐
    ▼                    ▼
 PASS: Push to         FAIL: Block
 Registry + Tag        + Alert Team
       │
       ▼
┌──────────────┐
│ Generate     │
│ SBOM + Sign  │
└──────────────┘

Trivy Scan Types Reference

Image Scanning

# Full scan (OS + language packages)
trivy image --severity CRITICAL,HIGH --exit-code 1 myimage:tag

# OS packages only
trivy image --vuln-type os myimage:tag

# Language-specific packages only
trivy image --vuln-type library myimage:tag

# From Docker archive
trivy image --input image.tar

Filesystem Scanning

# Scan project directory for vulnerable dependencies
trivy fs --severity HIGH,CRITICAL /path/to/project

# Scan specific lockfile
trivy fs --severity HIGH,CRITICAL requirements.txt

Repository Scanning

# Scan remote git repository
trivy repo https://github.com/org/repo

# Scan specific branch
trivy repo --branch develop https://github.com/org/repo

Configuration Scanning

# Scan Dockerfile and Kubernetes manifests
trivy config .

# Scan Terraform files
trivy config --tf-vars terraform.tfvars ./terraform/

# Scan Helm charts
trivy config ./charts/myapp/

Output Format Options

Format	Use Case	Flag
table	Human-readable terminal output	--format table
json	Programmatic processing and storage	--format json
sarif	GitHub Security tab upload	--format sarif
cyclonedx	SBOM generation (CycloneDX)	--format cyclonedx
spdx-json	SBOM generation (SPDX)	--format spdx-json
template	Custom report format	--format template --template @template.tpl
cosign-vuln	Cosign attestation format	--format cosign-vuln

Severity Threshold Matrix

Environment	Block On	Ignore Unfixed	Rationale
Development	CRITICAL	Yes	Fast feedback, focus on worst issues
Staging	CRITICAL, HIGH	Yes	Catch more issues before production
Production	CRITICAL, HIGH	No	Full visibility even for unfixed CVEs
Compliance	ALL	No	Complete audit trail required

Database Management

Database Update Strategy

# Download DB only (for caching)
trivy image --download-db-only --cache-dir /shared/trivy-cache

# Skip DB update (use cached)
trivy image --skip-db-update --cache-dir /shared/trivy-cache myimage:tag

# Java DB for JAR scanning
trivy image --download-java-db-only --cache-dir /shared/trivy-cache

Cache Locations

• Default: ~/.cache/trivy/
• CI override: TRIVY_CACHE_DIR=/tmp/trivy-cache
• GitHub Actions: Use actions/cache with key based on date

Back to mukul975/Anthropic-Cybersecurity-Skills (817 security skills) or Agent skills.