Automatizzare l'analisi delle immagini del contenitore

  • 10 minuti

Le immagini dei container impacchettano le applicazioni insieme a tutte le loro dipendenze, rendendole comodi artefatti di distribuzione. Tuttavia, questa praticità introduce notevoli problemi di sicurezza: le vulnerabilità nelle immagini di base, nei pacchetti di sistema o nelle dipendenze dell'applicazione possono compromettere i contenitori distribuiti. L'automazione dell'analisi delle immagini dei contenitori in tutto il ciclo di vita di sviluppo e distribuzione garantisce che solo immagini sicure e conformi raggiungano gli ambienti di produzione.

Informazioni sui rischi per la sicurezza dei contenitori

Le immagini del contenitore introducono più categorie di rischio per la sicurezza:

Vulnerabilità dell'immagine di base

Pacchetti del sistema operativo:

  • Librerie di sistema: Le immagini di base includono librerie del sistema operativo (glibc, OpenSSL, zlib) che possono contenere vulnerabilità.
  • Gestione pacchetti: Gli strumenti di gestione pacchetti di sistema (apt, yum, apk) e i relativi pacchetti presentano spesso problemi di sicurezza.
  • Utilità della shell: Le utilità comuni (bash, curl, wget) nelle immagini di base possono avere vulnerabilità.
  • Ritardo aggiornamento: Le immagini di base ufficiali possono includere pacchetti obsoleti tra le versioni.

Impatto della selezione dell'immagine di base:

  • Alpine vs Debian: Le immagini di base Alpine Linux sono più piccole ma usano librerie diverse (musl anziché glibc), che influiscono sui profili di vulnerabilità.
  • Immagini distroless: le immagini senza distribuzione di Google contengono solo dipendenze di runtime applicazione, riducendo drasticamente la superficie di attacco.
  • Varianti sottili: Le varianti di immagini sottili escludono utilità comuni, riducendo le dimensioni e l'esposizione alla vulnerabilità.
  • Valuta della versione: L'uso dei tag può introdurre modifiche impreviste. I latest tag di versione specifici forniscono stabilità, ma richiedono aggiornamenti manuali.

Vulnerabilità delle dipendenze dell'applicazione

Pacchetti specifici della lingua:

  • pacchetti npm: Node.js applicazioni portano centinaia di dipendenze npm che potrebbero avere vulnerabilità.
  • Pacchetti Python: Le applicazioni Python includono pacchetti PyPI con potenziali problemi di sicurezza.
  • Dipendenze Java: Le dipendenze Maven e Gradle includono in modo transitivo molti file JAR.
  • Pacchetti .NET: I pacchetti NuGet nelle applicazioni .NET possono contenere vulnerabilità.

Dipendenze transitive:

  • Alberi delle dipendenze profonde: Le dipendenze dell'applicazione hanno dipendenze proprie, creando alberi delle dipendenze profondi.
  • Vulnerabilità nascoste: Le vulnerabilità nelle dipendenze transitive sono facili da ignorare senza l'analisi automatica.
  • Complessità degli aggiornamenti: L'aggiornamento delle dipendenze transitive richiede la comprensione della compatibilità nell'intera catena di dipendenze.

Accumulo di strati immagine

File system a più livelli:

  • Ereditarietà dei livelli: Ogni istruzione Dockerfile crea un nuovo livello e le vulnerabilità in qualsiasi livello influiscono sull'immagine finale.
  • I file eliminati vengono salvati in modo permanente: I file eliminati nei livelli successivi esistono ancora nei livelli precedenti e contribuiscono alle dimensioni dell'immagine e al profilo di sicurezza.
  • Segreti nella cronologia delle immagini: I segreti accidentalmente registrati nei livelli iniziali rimangono nella cronologia delle immagini anche se rimossi nei livelli successivi.
  • Dipendenze in fase di compilazione: Le dipendenze necessarie solo durante la compilazione (compilatori, strumenti di compilazione) non devono essere visualizzate nelle immagini di runtime finali.

Vulnerabilità di configurazione

Errori di configurazione del Dockerfile:

  • Esecuzione come root: I contenitori in esecuzione come utente root hanno privilegi non necessari.
  • Porte esposte: Le porte esposte inutilmente espandono la superficie di attacco.
  • File binari SUID: I file binari SUID/SGID abilitano gli attacchi di escalation dei privilegi.
  • Impostazioni predefinite non sicure: Le configurazioni predefinite potrebbero non seguire le procedure consigliate per la sicurezza.

Approcci di analisi dei contenitori

La sicurezza efficace dei contenitori richiede l'analisi in più punti del ciclo di vita:

Analisi del Registro di sistema

Monitoraggio continuo del registro dei container: I registri dei container forniscono posizioni centralizzate per la scansione e l'applicazione delle policy.

Analisi di Registro Azure Container con Microsoft Defender:

  • Analisi automatica: Microsoft Defender per contenitori analizza automaticamente le immagini di cui è stato eseguito il push in Azure Container Registry.
  • Analisi basata su trigger: analizza il trigger sulle operazioni push, importazione e pull.
  • Risciansione continua: Le immagini vengono riesaminate periodicamente per individuare le vulnerabilità appena divulgate.
  • Consigli: Il Centro sicurezza fornisce raccomandazioni di correzione per le vulnerabilità individuate.

Trigger di analisi del Registro di sistema:

  • Trigger push: le nuove immagini vengono analizzate automaticamente quando viene eseguito il push nel Registro di sistema.
  • Trigger di importazione: Le immagini importate da registri esterni vengono analizzate.
  • Attivazioni pull: le immagini vengono analizzate entro 24 ore dall'esecuzione del pull.
  • Riesame periodico: Le immagini analizzate in precedenza vengono riesaminate quotidianamente (negli ultimi 90 giorni per le immagini sottoposte a push, negli ultimi 30 giorni per le immagini scaricate).

Analisi in fase di compilazione

Integrazione della pipeline CI/CD: L'analisi durante le compilazioni di immagini rileva le vulnerabilità prima che le immagini raggiungano i registri.

Analisi dei contenitori di Azure Pipelines:

trigger:
  branches:
    include:
      - main

pool:
  vmImage: "ubuntu-latest"

variables:
  imageName: "myapp"
  dockerfilePath: "$(Build.SourcesDirectory)/Dockerfile"

steps:
  - task: Docker@2
    displayName: "Build container image"
    inputs:
      command: "build"
      repository: "$(imageName)"
      dockerfile: "$(dockerfilePath)"
      tags: "$(Build.BuildNumber)"

  - task: AquaScannerCLI@4
    displayName: "Scan image with Aqua Security"
    inputs:
      image: "$(imageName):$(Build.BuildNumber)"
      scanType: "local"
      register: false
      hideBase: false
      showNegligible: false

  - script: |
      docker run --rm \
        -v /var/run/docker.sock:/var/run/docker.sock \
        -v $(Build.SourcesDirectory):/src \
        aquasec/trivy image \
        --severity HIGH,CRITICAL \
        --exit-code 1 \
        $(imageName):$(Build.BuildNumber)
    displayName: "Scan with Trivy (fail on high/critical)"

  - task: Docker@2
    displayName: "Push image to registry"
    condition: succeeded()
    inputs:
      command: "push"
      repository: "$(imageName)"
      tags: "$(Build.BuildNumber)"

Analisi dei contenitori di GitHub Actions:

name: Container Build and Scan

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

env:
  IMAGE_NAME: myapp
  REGISTRY: ghcr.io

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

    steps:
      - name: Checkout code
        uses: actions/checkout@v3

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

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

      - name: Scan image with Trivy
        uses: aquasecurity/trivy-action@master
        with:
          image-ref: "${{ env.IMAGE_NAME }}:${{ github.sha }}"
          format: "sarif"
          output: "trivy-results.sarif"
          severity: "CRITICAL,HIGH"

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

      - name: Scan with Snyk
        uses: snyk/actions/docker@master
        env:
          SNYK_TOKEN: ${{ secrets.SNYK_TOKEN }}
        with:
          image: ${{ env.IMAGE_NAME }}:${{ github.sha }}
          args: --severity-threshold=high --file=Dockerfile

      - name: Log in to GitHub Container Registry
        if: github.event_name == 'push'
        uses: docker/login-action@v2
        with:
          registry: ${{ env.REGISTRY }}
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}

      - name: Push image to registry
        if: github.event_name == 'push'
        run: |
          docker tag ${{ env.IMAGE_NAME }}:${{ github.sha }} \
            ${{ env.REGISTRY }}/${{ github.repository }}:${{ github.sha }}
          docker push ${{ env.REGISTRY }}/${{ github.repository }}:${{ github.sha }}

Analisi dei contenitori gitHub Advanced Security: GitHub Advanced Security offre funzionalità aggiuntive di sicurezza dei contenitori tramite CodeQL e l'analisi delle dipendenze.

name: Container Security with GitHub Advanced Security

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]
  schedule:
    - cron: "0 0 * * 0" # Weekly scheduled scan

env:
  IMAGE_NAME: myapp
  REGISTRY: ghcr.io

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

    steps:
      - name: Checkout code
        uses: actions/checkout@v3

      - name: Initialize CodeQL
        uses: github/codeql-action/init@v2
        with:
          languages: "javascript" # Adjust based on your language

      - name: Build container image
        run: |
          docker build -t ${{ env.IMAGE_NAME }}:${{ github.sha }} .

      - name: Perform CodeQL Analysis
        uses: github/codeql-action/analyze@v2
        with:
          category: "/language:javascript"

      - name: Run CodeQL container scanning
        uses: github/codeql-action/analyze@v2
        with:
          category: "/language:dockerfile"

      - name: Scan container dependencies
        uses: anchore/scan-action@v3
        with:
          image: ${{ env.IMAGE_NAME }}:${{ github.sha }}
          fail-build: true
          severity-cutoff: high

      - name: Upload Anchore scan SARIF report
        uses: github/codeql-action/upload-sarif@v2
        if: always()
        with:
          sarif_file: results.sarif

      - name: Push image to registry
        if: github.event_name == 'push'
        run: |
          echo ${{ secrets.GITHUB_TOKEN }} | docker login ${{ env.REGISTRY }} -u ${{ github.actor }} --password-stdin
          docker tag ${{ env.IMAGE_NAME }}:${{ github.sha }} ${{ env.REGISTRY }}/${{ github.repository }}:${{ github.sha }}
          docker push ${{ env.REGISTRY }}/${{ github.repository }}:${{ github.sha }}

Vantaggi dell'analisi in fase di compilazione:

  • Fallire e rispondere immediatamente agli errori: impedire la creazione e il push nei registri di immagini vulnerabili.
  • Commenti e suggerimenti per gli sviluppatori: Fornire feedback immediato agli sviluppatori durante il processo di compilazione.
  • Applicazione dei criteri: Applicare i criteri di sicurezza prima che le immagini raggiungano registri o produzione.
  • Convalida dell'artefatto della compilazione: assicurarsi che solo le immagini conformi passino attraverso la pipeline di distribuzione.

Analisi di runtime

Monitoraggio dei contenitori distribuito: L'analisi di runtime rileva le vulnerabilità nei contenitori effettivamente distribuiti.

Controller di ammissione Kubernetes: I controller di ammissione applicano i criteri prima che i contenitori vengano distribuiti nei cluster Kubernetes.

Esempio di criterio OPA Gatekeeper:

apiVersion: templates.gatekeeper.sh/v1
kind: ConstraintTemplate
metadata:
  name: k8srequiredscanstatus
spec:
  crd:
    spec:
      names:
        kind: K8sRequiredScanStatus
      validation:
        openAPIV3Schema:
          type: object
          properties:
            maxSeverity:
              type: string
  targets:
    - target: admission.k8s.gatekeeper.sh
      rego: |
        package k8srequiredscanstatus

        violation[{"msg": msg}] {
          container := input.review.object.spec.containers[_]
          not scan_clean(container.image)
          msg := sprintf("Image %v has not been scanned or has vulnerabilities", [container.image])
        }

        scan_clean(image) {
          # Query registry for scan status
          # This is simplified; actual implementation queries scan results
          scan_result := data.scans[image]
          scan_result.status == "passed"
        }

Protezione del runtime del servizio Azure Kubernetes: Microsoft Defender per contenitori fornisce il rilevamento delle minacce in fase di esecuzione:

  • Analisi comportamentale: Monitora il comportamento del contenitore per rilevare le attività anomale.
  • Intelligence sulle minacce: Confronta i comportamenti osservati rispetto ai modelli di attacco noti.
  • Mapping MITRE ATT&CK: Mappa le minacce rilevate nel framework MITRE ATT&CK.
  • Generazione di avvisi: Genera avvisi di sicurezza per attività di contenitore sospette.

Strumenti di analisi dei contenitori

Trivy (Aqua Security)

Trivy è uno scanner completo di vulnerabilità dei contenitori open source.

Funzionalità principali:

  • Analisi completa: Analizza pacchetti del sistema operativo, dipendenze dell'applicazione, configurazioni IaC e segreti.
  • Supporto multi-formato: Analizza immagini di container, file systems, repository Git e cluster Kubernetes.
  • Analisi offline: Può operare in ambienti air-gapped utilizzando database di vulnerabilità offline.
  • Prestazioni veloci: Scanner leggero con tempi di analisi rapidi.
  • Generazione SBOM: genera la distinta base del software CicloneDX e SPDX.

Integrazione di Azure Pipelines Trivy:

- script: |
    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 /etc/apt/sources.list.d/trivy.list
    sudo apt-get update
    sudo apt-get install trivy

    trivy image \
      --severity HIGH,CRITICAL \
      --exit-code 1 \
      --no-progress \
      --format json \
      --output trivy-results.json \
      $(imageName):$(Build.BuildNumber)
  displayName: "Scan image with Trivy"

Contenitore Snyk

Il contenitore Snyk offre l'analisi delle immagini dei contenitori integrata con la piattaforma orientata allo sviluppatore di Snyk.

Funzionalità principali:

  • Consigli per l'immagine di base: Suggerisce immagini di base alternative con un minor numero di vulnerabilità.
  • Definizione delle priorità: Assegna priorità alle vulnerabilità in base all'exploitbilità e all'impatto aziendale.
  • Linee guida per la correzione: Fornisce procedure di correzione specifiche per le vulnerabilità individuate.
  • Integrazione di Kubernetes: Analizza le immagini distribuite nei cluster Kubernetes.

Aqua Security

Aqua Security offre sicurezza dei contenitori di livello aziendale per tutto il ciclo di vita.

Funzionalità principali:

  • Controllo delle immagini: Analisi completa delle immagini con criteri personalizzabili.
  • Protezione di runtime: Monitora l'esecuzione di contenitori per un comportamento sospetto.
  • Verifica della conformità: Convalida le immagini in base al benchmark Docker CIS e ai criteri personalizzati.
  • Sicurezza della catena di approvvigionamento: Verifica la provenienza dell'immagine e rileva gli attacchi alla supply chain.

Motore di ancoraggio

Anchore Engine è uno scanner di immagini container open source con analisi basata su policy.

Funzionalità principali:

  • Guidata dai criteri: Motore di criteri flessibile per la definizione delle regole di sicurezza e conformità.
  • Ispezione approfondita: Analizza i livelli, i pacchetti e la configurazione delle immagini.
  • Criteri personalizzati: Definire criteri di sicurezza e conformità specifici dell'organizzazione.
  • Guidata dall'API: API REST per l'integrazione con strumenti personalizzati.

Sicurezza avanzata di GitHub

GitHub Advanced Security offre funzionalità di sicurezza di livello aziendale per i repository, incluse le funzionalità di analisi dei contenitori.

Funzionalità di sicurezza dei contenitori:

  • Analisi delle dipendenze: Rileva automaticamente le dipendenze vulnerabili nelle immagini del contenitore.
  • Analisi dei segreti: Identifica i segreti esposti (chiavi API, token, credenziali) nei livelli del contenitore e nei Dockerfile.
  • Analisi del codice: Analisi di CodeQL per i Dockerfile e il codice dell'applicazione all'interno dei contenitori.
  • Avvisi di sicurezza: Integrazione con GitHub Advisory Database per l'intelligence sulle vulnerabilità.
  • Sicurezza della catena di approvvigionamento: Grafico delle dipendenze e Integrazione Dependabot per le dipendenze dei contenitori.

Esecuzione di CodeQL nei contenitori: GitHub Advanced Security supporta l'esecuzione di analisi del codice CodeQL all'interno di ambienti contenitore per un'analisi completa:

Flusso di lavoro di analisi dei contenitori CodeQL:

name: CodeQL Container Analysis

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

jobs:
  analyze-container:
    runs-on: ubuntu-latest
    permissions:
      actions: read
      contents: read
      security-events: write

    strategy:
      fail-fast: false
      matrix:
        language: ["javascript", "python"]

    steps:
      - name: Checkout repository
        uses: actions/checkout@v3

      - name: Initialize CodeQL
        uses: github/codeql-action/init@v2
        with:
          languages: ${{ matrix.language }}
          queries: security-extended,security-and-quality

      - name: Build application in container
        run: |
          docker build -t app:latest .
          docker create --name temp-container app:latest
          docker cp temp-container:/app/built-artifacts ./artifacts
          docker rm temp-container

      - name: Perform CodeQL Analysis
        uses: github/codeql-action/analyze@v2
        with:
          category: "/language:${{ matrix.language }}"

      - name: Scan Dockerfile
        uses: github/codeql-action/analyze@v2
        with:
          category: "/language:dockerfile"

Analisi dei segreti per i contenitori:

name: Container Secret Scanning

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

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

    steps:
      - name: Checkout code
        uses: actions/checkout@v3

      - name: Build container image
        run: docker build -t myapp:${{ github.sha }} .

      - name: Scan image for secrets
        uses: trufflesecurity/trufflehog@main
        with:
          path: ./
          base: ${{ github.event.repository.default_branch }}
          head: HEAD

      - name: Scan container layers for secrets
        run: |
          docker save myapp:${{ github.sha }} -o image.tar
          docker run --rm -v $(pwd):/scan \
            trufflesecurity/trufflehog:latest \
            filesystem /scan/image.tar \
            --json > secrets-report.json

      - name: Upload secret scan results
        uses: github/codeql-action/upload-sarif@v2
        if: always()
        with:
          sarif_file: secrets-report.sarif

Vantaggi della sicurezza avanzata di GitHub:

  • Integrazione nativa: Integrazione approfondita con i flussi di lavoro e le funzionalità di sicurezza di GitHub.
  • Dashboard unificato: Panoramica della sicurezza centralizzata nella scheda Sicurezza di GitHub.
  • Applicazione dei criteri: Le regole di protezione dei rami possono richiedere il superamento dei controlli di sicurezza.
  • Report di conformità: Report di conformità predefiniti per SOC 2, ISO 27001 e altri framework.
  • Collaborazione tra team: Risultati della sicurezza integrati nelle revisioni delle richieste pull e monitoraggio dei problemi.

Abilitazione della sicurezza avanzata di GitHub:

Per le organizzazioni:

  1. Passare a Impostazioni organizzazione → Sicurezza e analisi del codice.
  2. Abilitare GitHub Advanced Security per tutti o i repository selezionati.
  3. Configurare gli avvisi Dependabot, l'analisi dei segreti e l'analisi del codice.
  4. Configurare i criteri di sicurezza e gli avvisi di sicurezza.

Per i repository:

  1. Passare a Impostazioni repository → Sicurezza e analisi del codice.
  2. Abilitare Il grafico delle dipendenze (gratuito per i repository pubblici).
  3. Abilitare gli avvisi Dependabot e gli aggiornamenti della sicurezza Dependabot.
  4. Abilitare l'analisi dei segreti (richiede la licenza gitHub Advanced Security per i repository privati).
  5. Abilitare l'analisi del codice con codeQL o strumenti di terze parti.

Sicurezza avanzata per i registri contenitori:

name: Registry Security Monitoring

on:
  schedule:
    - cron: "0 */6 * * *" # Every 6 hours
  workflow_dispatch:

jobs:
  scan-registry:
    runs-on: ubuntu-latest
    permissions:
      packages: read
      security-events: write

    steps:
      - name: Login to GitHub Container Registry
        uses: docker/login-action@v2
        with:
          registry: ghcr.io
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}

      - name: Pull images from registry
        run: |
          docker pull ghcr.io/${{ github.repository }}/app:latest
          docker pull ghcr.io/${{ github.repository }}/app:staging

      - name: Scan registry images
        uses: aquasecurity/trivy-action@master
        with:
          image-ref: "ghcr.io/${{ github.repository }}/app:latest"
          format: "sarif"
          output: "trivy-registry.sarif"

      - name: Upload scan results
        uses: github/codeql-action/upload-sarif@v2
        with:
          sarif_file: trivy-registry.sarif
          category: "registry-scan"

      - name: Check for critical vulnerabilities
        run: |
          CRITICAL_COUNT=$(docker run --rm \
            -v /var/run/docker.sock:/var/run/docker.sock \
            aquasec/trivy image \
            --severity CRITICAL \
            --format json \
            ghcr.io/${{ github.repository }}/app:latest | \
            jq '.Results[].Vulnerabilities | length')

          if [ "$CRITICAL_COUNT" -gt 0 ]; then
            echo "::error::Found $CRITICAL_COUNT critical vulnerabilities"
            exit 1
          fi

Integrazione con le funzionalità di sicurezza di GitHub:

  • Panoramica della sicurezza: Dashboard di sicurezza a livello di organizzazione che mostra le vulnerabilità dei contenitori.
  • Avvisi di sicurezza: Avvisi automatizzati per le dipendenze dei contenitori vulnerabili.
  • Aggiornamenti di Dependabot: Richieste pull automatizzate per aggiornare le immagini e le dipendenze di base vulnerabili.
  • Integrazione dei proprietari di codice: Indirizzare i risultati della sicurezza ai team appropriati tramite il file CODEOWNERS.
  • Log di controllo: Completare il audit trail degli eventi di sicurezza e delle azioni correttive.

Procedure consigliate per l'analisi dei contenitori

Implementare compilazioni a più fasi

Dipendenze di compilazione e runtime separate:

# Build stage
FROM node:18 AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

# Runtime stage
FROM node:18-slim
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
COPY package*.json ./
USER node
EXPOSE 3000
CMD ["node", "dist/server.js"]

Vantaggi:

  • Immagini più piccole: Le immagini di runtime non includono strumenti di compilazione e artefatti intermedi.
  • Minor numero di vulnerabilità: Le dipendenze di compilazione (compilatori, SDK) non vengono visualizzate nelle immagini finali.
  • Prestazioni migliori: Le immagini di dimensioni ridotte inviano, scaricano e avviano più velocemente.

Usare immagini di base minime

Scegliere le immagini di base appropriate:

  • Alpino: Immagine di base piccola (~5 MB) con superficie di attacco minima.
  • Distroless: Contiene solo dipendenze dell'applicazione e del runtime, senza shell né gestore dei pacchetti.
  • Varianti sottili: Le varianti ufficiali *-slim escludono utilità non necessarie.
  • Versioni specifiche: Utilizzare tag di versioni specifiche invece di latest, per garantire la riproducibilità.

Immagine distroless di esempio:

FROM golang:1.21 AS builder
WORKDIR /app
COPY . .
RUN CGO_ENABLED=0 go build -o myapp .

FROM gcr.io/distroless/static-debian11
COPY --from=builder /app/myapp /
USER nonroot:nonroot
CMD ["/myapp"]

Analizza in anticipo e spesso

Frequenza di scansione:

  • Workstation per sviluppatori: Analizzare le immagini in locale prima di eseguire il commit.
  • Convalida della richiesta pull: eseguire l'analisi nelle pipeline CI in ogni richiesta pull.
  • Compilazioni del ramo principale: analisi complete sui merge dei rami principali.
  • Ammissione al Registro di sistema: Analizza le immagini prima di accettarle nei registri.
  • Riesecuzione pianificata: Ripetere periodicamente l'analisi delle immagini archiviate per individuare le vulnerabilità appena divulgate.
  • Pre-distribuzione: Convalida finale prima della distribuzione nell'ambiente di produzione.

Implementare le barriere di sicurezza

Punti di imposizione dei criteri:

- task: Trivy@1
  inputs:
    image: "$(imageName):$(Build.BuildNumber)"
    severityThreshold: "HIGH"
    exitCode: 1
  displayName: "Security gate: block high/critical vulnerabilities"

Esempi di gate:

  • Gravità della vulnerabilità: Le build falliscono con vulnerabilità critiche o ad alta gravità.
  • Conformità delle licenze: Bloccare le immagini con licenze non consentite.
  • Problemi di configurazione: Impedire la distribuzione di immagini in esecuzione come root.
  • Rilevamento dei segreti: Fallimento se vengono rilevati segreti nei livelli dell'immagine.

Automatizzare la correzione

Aggiornamenti automatici:

  • Dependabot per Dockerfiles: Abilitare Dependabot per aggiornare le versioni e le dipendenze delle immagini di base nei Dockerfile.
  • Ricompilazione automatizzata: Configurare le pipeline per ricompilare automaticamente le immagini quando vengono aggiornate le immagini di base.
  • Automazione delle patch: Usare gli strumenti per applicare automaticamente patch alle immagini o alle dipendenze di base.
  • Pipeline di test: Assicurarsi che gli aggiornamenti automatizzati attivino test completi.

Configurazione di GitHub Dependabot per Docker:

version: 2
updates:
  - package-ecosystem: "docker"
    directory: "/"
    schedule:
      interval: "weekly"
    open-pull-requests-limit: 5

Gestire la cronologia dei risultati dell'analisi

Rilevamento e tendenza:

  • Creazione centralizzata di report: Aggregare i risultati dell'analisi nei dashboard centralizzati.
  • Analisi delle tendenze: Tenere traccia dei conteggi delle vulnerabilità nel tempo per misurare il comportamento di sicurezza.
  • Controlli di conformità: Mantenere la cronologia dei risultati dell'analisi per l'evidenza di conformità.
  • Archiviazione SBOM: archiviare la distinta base per le immagini distribuite.

Implementare la firma delle immagini

Verificare la provenienza dell'immagine:

- task: Docker@2
  inputs:
    command: "sign"
    arguments: "--key $(signingKey) $(imageName):$(Build.BuildNumber)"
  displayName: "Sign container image"

- script: |
    docker trust inspect --pretty $(imageName):$(Build.BuildNumber)
  displayName: "Verify image signature"

Vantaggi della firma delle immagini:

  • Verifica della provenienza: Verificare che le immagini provenissino da origini attendibili.
  • Rilevamento delle manomissioni: Rilevare se le immagini sono state modificate dopo la firma.
  • Applicazione dei criteri: Distribuire solo immagini firmate in ambienti di produzione.

L'automazione dell'analisi delle immagini dei contenitori nel ciclo di vita dello sviluppo e della distribuzione garantisce un rilevamento completo delle vulnerabilità e l'applicazione dei criteri. Eseguendo l'analisi anticipata, l'analisi spesso e l'implementazione di correzioni automatizzate, le organizzazioni possono mantenere distribuzioni di contenitori sicure senza sacrificare la velocità di sviluppo. L'unità successiva esamina come interpretare e classificare in ordine di priorità gli avvisi dagli strumenti dello scanner di sicurezza.