Automatiser l’analyse des images de conteneur

  • 10 minutes

Les images conteneur encapsulent les applications ainsi que toutes leurs dépendances, ce qui en fait des éléments de déploiement pratiques. Toutefois, cette commodité présente des défis de sécurité importants : les vulnérabilités dans les images de base, les packages système ou les dépendances d’application peuvent compromettre les conteneurs déployés. L’automatisation de l’analyse des images conteneur tout au long du cycle de vie du développement et du déploiement garantit que seules les images sécurisées et conformes atteignent des environnements de production.

Présentation des risques de sécurité des conteneurs

Les images conteneur présentent plusieurs catégories de risques de sécurité :

Vulnérabilités d’image de base

Packages de système d’exploitation :

  • Bibliothèques système : Les images de base incluent des bibliothèques de système d’exploitation (glibc, OpenSSL, zlib) qui peuvent contenir des vulnérabilités.
  • Gestionnaires de packages : Les gestionnaires de packages système (apt, yum, apk) et leurs packages présentent fréquemment des problèmes de sécurité.
  • Utilitaires Shell : Les utilitaires courants (bash, curl, wget) dans les images de base peuvent avoir des vulnérabilités.
  • Décalage de mise à jour : Les images de base officielles peuvent inclure des packages obsolètes entre les versions.

Impact sur la sélection d’images de base :

  • Alpine vs Debian : Les images de base Alpine Linux sont plus petites, mais utilisent des bibliothèques différentes (musl au lieu de glibc), affectant les profils de vulnérabilité.
  • Images distroless : Les images distroless de Google contiennent uniquement les dépendances nécessaires à l'exécution des applications, réduisant considérablement la surface d’attaque.
  • Versions allégées : Les versions d'images allégées excluent les outils communs, permettant de réduire la taille et l'exposition aux vulnérabilités.
  • Devise de version : L’utilisation de latest balises peut introduire des modifications inattendues ; des balises de version spécifiques fournissent une stabilité, mais nécessitent des mises à jour manuelles.

Vulnérabilités des dépendances d’application

Packages spécifiques à la langue :

  • packages npm : Node.js applications apportent des centaines de dépendances npm susceptibles d’avoir des vulnérabilités.
  • Packages Python : Les applications Python incluent des packages PyPI avec des problèmes de sécurité potentiels.
  • Dépendances Java : Les dépendances Maven et Gradle incluent de manière transitive de nombreux fichiers JAR.
  • Packages .NET : Les packages NuGet dans les applications .NET peuvent contenir des vulnérabilités.

Dépendances transitives :

  • Arborescences de dépendances profondes : Les dépendances d’application ont leurs propres dépendances, créant des arborescences de dépendances approfondies.
  • Vulnérabilités masquées : Les vulnérabilités dans les dépendances transitives sont faciles à ignorer sans analyse automatisée.
  • Complexité des mises à jour : La mise à jour des dépendances transitives nécessite une compréhension de la compatibilité entre l’ensemble de la chaîne de dépendances.

Accumulation de couche d’image

Système de fichiers en couches :

  • Héritage de couche : Chaque instruction Dockerfile crée une nouvelle couche et les vulnérabilités dans n’importe quelle couche affectent l’image finale.
  • Les fichiers supprimés persistent : Les fichiers supprimés dans les couches ultérieures existent toujours dans les couches antérieures et contribuent à la taille de l’image et au profil de sécurité.
  • Secrets dans l’historique : Les secrets enregistrés accidentellement dans les premières couches restent dans l’historique d'image même s’ils sont supprimés dans les couches ultérieures.
  • Dépendances au moment de la génération : Les dépendances nécessaires uniquement pendant la génération (compilateurs, outils de génération) ne doivent pas apparaître dans les images runtime finales.

Vulnérabilités de configuration

Configurations incorrectes du fichier Dockerfile :

  • Exécution en tant que superutilisateur : Les conteneurs exécutés en tant que superutilisateur ont des privilèges inutiles.
  • Ports exposés : Les ports exposés inutilement étendent la surface d’attaque.
  • Fichiers binaires SUID : Les fichiers binaires SUID/SGID permettent d’attaquer l’escalade de privilèges.
  • Valeurs par défaut non sécurisées : Les configurations par défaut peuvent ne pas suivre les meilleures pratiques de sécurité.

Approches d’analyse de conteneur

La sécurité efficace des conteneurs nécessite l’analyse à plusieurs points du cycle de vie :

Analyse du Registre

Surveillance continue du Registre : Les registres de conteneurs fournissent des emplacements centralisés pour l’analyse et l’application des stratégies.

Analyse d’Azure Container Registry avec Microsoft Defender :

  • Analyse automatique : Microsoft Defender pour conteneurs analyse automatiquement les images envoyées à Azure Container Registry.
  • Analyse basée sur un déclencheur : Les analyses se déclenchent lors des opérations de push, d’importation et de récupération.
  • Réexécriture continue : Les images sont régulièrement réanalysées pour les vulnérabilités nouvellement divulguées.
  • Recommandations: Security Center fournit des recommandations de correction pour les vulnérabilités découvertes.

Déclencheurs d’analyse du Registre :

  • Déclencheurs Push : Les nouvelles images sont automatiquement analysées lorsqu'elles sont envoyées au registre.
  • Déclencheurs d’importation : Les images importées à partir de registres externes sont analysées.
  • Déclencheurs d’extraction : Les images sont analysées dans les 24 heures suivant l’extraction.
  • Nouvelle analyse périodique : Les images précédemment analysées sont réanalysées quotidiennement (90 derniers jours pour les images envoyées, les 30 derniers jours pour les images tirées).

Analyse au moment de la génération

Intégration du pipeline CI/CD : L’analyse pendant les builds d’images intercepte les vulnérabilités avant que les images atteignent des registres.

Analyse du conteneur 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)"

Analyse du conteneur 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 }}

Analyse des conteneurs GitHub Advanced Security : GitHub Advanced Security fournit des fonctionnalités de sécurité de conteneur supplémentaires via CodeQL et l’analyse des dépendances.

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 }}

Avantages de l’analyse au moment de la génération :

  • Fail-fast : Empêcher la création et la publication d’images vulnérables dans les registres.
  • Commentaires des développeurs : Fournissez des commentaires immédiats aux développeurs pendant le processus de génération.
  • Application des politiques : Appliquez les politiques de sécurité avant que les images atteignent les registres ou la production.
  • Validation de l’artefact de build : Veillez à ce que seules les images conformes progressent via le pipeline de déploiement.

Analyse du runtime

Supervision des conteneurs déployée : L’analyse du runtime détecte les vulnérabilités dans les conteneurs réellement déployés.

Contrôleurs d’admission Kubernetes : Les contrôleurs d’admission appliquent des stratégies avant que les conteneurs ne soient déployés sur des clusters Kubernetes.

Exemple de stratégie 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"
        }

Protection du runtime Azure Kubernetes Service : Microsoft Defender pour conteneurs fournit la détection des menaces au moment de l’exécution :

  • Analyse comportementale : Surveille le comportement du conteneur pour détecter les activités anormales.
  • Renseignement sur les menaces : Compare les comportements observés par rapport aux modèles d’attaque connus.
  • Mappage MITRE ATT&CK : Mappe les menaces détectées à l’infrastructure MITRE ATT&CK.
  • Génération d’alerte : Génère des alertes de sécurité pour les activités suspectes de conteneur.

Outils d’analyse de conteneurs

Trivy (Aqua Security)

Trivy est un scanneur complet des vulnérabilités de conteneur open source.

Fonctionnalités clés :

  • Analyse complète : Analyse les packages de système d’exploitation, les dépendances d’application, les configurations IaC et les secrets.
  • Prise en charge multi-format : Analyse les images conteneur, les systèmes de fichiers, les référentiels Git et les clusters Kubernetes.
  • Analyse hors connexion : Peut fonctionner dans des environnements isolés avec des bases de données de vulnérabilités hors ligne.
  • Performances rapides : Scanneur léger avec des temps d’analyse rapides.
  • Génération de SBOM : Génère la nomenclature des logiciels CycloneDX et SPDX.

Intégration d’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"

Conteneur Snyk

Snyk Container fournit une analyse d’image conteneur intégrée à la plateforme axée sur les développeurs de Snyk.

Fonctionnalités clés :

  • Recommandations d’image de base : Suggère des images de base alternatives avec moins de vulnérabilités.
  • Hiérarchisation : Hiérarchise les vulnérabilités en fonction de l’exploitabilité et de l’impact de l’entreprise.
  • Instructions de correction : Fournit des étapes de correction spécifiques pour les vulnérabilités découvertes.
  • Intégration de Kubernetes : Analyse les images déployées sur des clusters Kubernetes.

Aqua Security

Aqua Security offre une sécurité des conteneurs de niveau entreprise à chaque étape du cycle de vie.

Fonctionnalités clés :

  • Assurance de l’image : Analyse complète des images avec des stratégies personnalisables.
  • Protection du runtime : Surveille les conteneurs en cours d'exécution pour détecter un comportement suspect.
  • Vérification de la conformité : Valide les images par rapport au benchmark Docker CIS et aux stratégies personnalisées.
  • Sécurité de la chaîne logistique : Vérifie la provenance de l’image et détecte les attaques de chaîne d’approvisionnement.

Moteur Anchore

Anchore Engine est un scanneur d’images conteneur open source avec une analyse basée sur des stratégies.

Fonctionnalités clés :

  • Piloté par la stratégie : Moteur de stratégie flexible pour définir des règles de sécurité et de conformité.
  • Inspection approfondie : Analyse les couches d’image, les packages et la configuration.
  • Stratégies personnalisées : Définissez des stratégies de sécurité et de conformité spécifiques à l’organisation.
  • Piloté par l’API : API REST pour l’intégration à des outils personnalisés.

Sécurité avancée GitHub

GitHub Advanced Security fournit des fonctionnalités de sécurité de niveau entreprise pour les référentiels, notamment les fonctionnalités d’analyse de conteneur.

Fonctionnalités de sécurité des conteneurs :

  • Analyse des dépendances : Détecte automatiquement les dépendances vulnérables dans les images conteneur.
  • Analyse des secrets : Identifie les secrets exposés (clés API, jetons, informations d’identification) dans les couches de conteneur et les fichiers Dockerfiles.
  • Analyse du code : Analyse CodeQL des fichiers Dockerfiles et du code d’application au sein des conteneurs.
  • Avis de sécurité : Intégration à GitHub Advisory Database pour l’intelligence des vulnérabilités.
  • Sécurité de la chaîne logistique : Graphe de dépendances et intégration de Dependabot pour les dépendances de conteneurs.

Exécution de CodeQL dans des conteneurs : GitHub Advanced Security prend en charge l’exécution de l’analyse du code CodeQL dans les environnements de conteneur pour une analyse complète :

Flux de travail d’analyse de conteneur 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"

Analyse des secrets pour les conteneurs :

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

Avantages de GitHub Advanced Security :

  • Intégration native : Profondément intégré aux flux de travail GitHub et aux fonctionnalités de sécurité.
  • Tableau de bord unifié : Vue d’ensemble de la sécurité centralisée sous l’onglet Sécurité GitHub.
  • Application de la stratégie : Les règles de protection des branches peuvent nécessiter de passer les contrôles de sécurité.
  • Rapports de conformité : Rapports de conformité intégrés pour SOC 2, ISO 27001 et d’autres frameworks.
  • Collaboration en équipe : Résultats de sécurité intégrés aux révisions de demandes de tirage (pull request) et au suivi des problèmes.

Activation de GitHub Advanced Security :

Pour les organisations :

  1. Accédez aux paramètres de l’organisation → sécurité et analyse du code.
  2. Activez GitHub Advanced Security pour tous les dépôts ou dépôts sélectionnés.
  3. Configurez les alertes Dependabot, l’analyse des secrets et l’analyse du code.
  4. Configurez les stratégies de sécurité et les avis de sécurité.

Pour les référentiels :

  1. Accédez aux paramètres du référentiel → sécurité et analyse du code.
  2. Activer le graphique de dépendances (gratuit pour les référentiels publics).
  3. Activez les alertes Dependabot et les mises à jour de sécurité De Dependabot.
  4. Activez l’analyse des secrets (nécessite une licence GitHub Advanced Security pour les dépôts privés).
  5. Activez l’analyse du code avec CodeQL ou des outils tiers.

Advanced Security pour les registres de conteneurs :

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

Intégration avec les fonctionnalités de sécurité GitHub :

  • Vue d’ensemble de la sécurité : Tableau de bord de sécurité à l’échelle de l’organisation montrant les vulnérabilités des conteneurs.
  • Alertes de sécurité : Alertes automatisées pour les dépendances de conteneur vulnérables.
  • Mises à jour de Dependabot : Demandes de tirage automatisées pour mettre à jour les images de base vulnérables et les dépendances vulnérables.
  • Intégration des propriétaires de code : Acheminer les résultats de sécurité vers les équipes appropriées via le fichier CODEOWNERS.
  • Journaux d’audit : Trace complète des événements de sécurité et des actions de remédiation.

Meilleures pratiques pour l’analyse de conteneur

Implémenter des builds multi-phases

Séparez les dépendances de build et d’exécution :

# 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"]

Avantages :

  • Images plus petites : Les images runtime n’incluent pas d’outils de génération et d’artefacts intermédiaires.
  • Moins de vulnérabilités : Les dépendances de build (compilateurs, sdk) n’apparaissent pas dans les images finales.
  • Meilleures performances : Les images plus petites se transfèrent, s'extraient et démarrent plus rapidement.

Utiliser des images de base minimales

Choisissez les images de base appropriées :

  • Alpin: Petite image de base (~5 Mo) avec une surface d’attaque minimale.
  • Distroless : Contient uniquement les dépendances d’application et d’exécution, aucun interpréteur de commandes ou gestionnaire de package.
  • Variantes minces : Les variantes officielles *-slim excluent les utilitaires inutiles.
  • Versions spécifiques : Utilisez des balises de version spécifiques pour assurer la reproductibilité au lieu de latest.

Exemple d’image distroless :

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"]

Scanner tôt et fréquemment

Fréquence d’analyse :

  • Station de travail développeur : Analysez les images localement avant de valider.
  • Validation des pull requests : Analyse dans les pipelines CI pour chaque pull request.
  • Compilations de branche principale : Analyses complètes sur les fusionnements de branche principale.
  • Admission au Registre : Analysez les images avant de les accepter dans des registres.
  • Rescanning planifié : Réanalysez régulièrement les images stockées pour les vulnérabilités nouvellement divulguées.
  • Prédéploiement : Validation finale avant le déploiement en production.

Implémenter des portes de sécurité

Points d’application de stratégie :

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

Exemples de porte :

  • Gravité des vulnérabilités : Échec des builds avec des vulnérabilités critiques ou de gravité élevée.
  • Conformité des licences : Bloquer les images avec des licences interdites.
  • Problèmes de configuration : Empêcher le déploiement d’images s’exécutant avec les privilèges root.
  • Détection des secrets : Échec si les secrets sont détectés dans les couches d’images.

Automatiser la remédiation

Mises à jour automatisées :

  • Dependabot pour dockerfiles : Activez Dependabot pour mettre à jour les versions d’image de base et les dépendances dans les fichiers Dockerfiles.
  • Reconstructions automatisées : Configurez des pipelines pour reconstruire automatiquement des images lorsque des images de base sont mises à jour.
  • Automatisation des correctifs : Utilisez des outils pour corriger automatiquement les images de base ou les dépendances.
  • Test des pipelines : Assurez-vous que les mises à jour automatisées déclenchent des tests complets.

Configuration de GitHub Dependabot pour Docker :

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

Gérer l’historique des résultats de l’analyse

Suivi et tendance :

  • Rapports centralisés : L’analyse agrégée génère des tableaux de bord centralisés.
  • Analyse des tendances : Suivez le nombre de vulnérabilités au fil du temps pour mesurer la posture de sécurité.
  • Audits de conformité : Conservez l’historique des résultats de l’analyse pour obtenir des preuves de conformité.
  • Archivage SBOM : Archiver la nomenclature logicielle pour les images déployées.

Implémenter la signature d’image

Vérifiez la provenance de l’image :

- 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"

Avantages de la signature d’images :

  • Vérification de la provenance : Vérifiez que les images proviennent de sources approuvées.
  • Détection de falsification : Détecter si des images ont été modifiées après la signature.
  • Application de la politique : Ne déployez que des images signées dans les environnements de production.

L’automatisation de l’analyse des images conteneur dans le cycle de vie du développement et du déploiement garantit une détection complète des vulnérabilités et l’application des stratégies. En analysant rapidement, analysez souvent et implémentez des corrections automatisées, les organisations peuvent maintenir des déploiements de conteneurs sécurisés sans sacrifier la vitesse de développement. L’unité suivante examine comment interpréter et hiérarchiser les alertes des outils de scanneur de sécurité.