Automatiseren van het scannen van containerafbeeldingen

  • 10 minuten

Containerafbeeldingen verpakken applicaties samen met hun afhankelijkheden, waardoor ze handige implementatieartefacts zijn. Dit gemak introduceert echter aanzienlijke beveiligingsuitdagingen: beveiligingsproblemen in basisinstallatiekopieën, systeempakketten of toepassingsafhankelijkheden kunnen in gevaar komen voor geïmplementeerde containers. Het automatiseren van het scannen van containerinstallatiekopieën gedurende de ontwikkelings- en implementatielevenscyclus zorgt ervoor dat alleen veilige, compatibele installatiekopieën productieomgevingen bereiken.

Inzicht in beveiligingsrisico's voor containers

Containerafbeeldingen introduceren meerdere categorieën van beveiligingsrisico's.

Beveiligingsproblemen met basisafbeeldingen

Besturingssysteempakketten:

  • Systeembibliotheken: Basisinstallatiekopieën bevatten besturingssysteembibliotheken (glibc, OpenSSL, zlib) die mogelijk beveiligingsproblemen bevatten.
  • Pakketbeheerders: Systeempakketbeheerders (apt, yum, apk) en hun pakketten hebben vaak beveiligingsproblemen.
  • Shell-hulpprogramma's: Algemene hulpprogramma's (bash, curl, wget) in basisinstallatiekopieën kunnen beveiligingsproblemen hebben.
  • Updatevertraging: Officiële basisimages kunnen verouderde pakketten bevatten tussen releases in.

Impact van de selectie van basisafbeeldingen:

  • Alpine versus Debian: Alpine Linux-basisinstallatiekopieën zijn kleiner, maar gebruiken verschillende bibliotheken (musl in plaats van glibc), die van invloed zijn op beveiligingsprofielen.
  • Distributieloze afbeeldingen: De distributieloze installatiekopieën van Google bevatten alleen afhankelijkheden van toepassingsruntime, waardoor de kwetsbaarheid voor aanvallen aanzienlijk wordt verminderd.
  • Slanke varianten: Slanke afbeeldingsvarianten sluiten veelgebruikte hulpprogramma's uit, waardoor de blootstelling aan beveiligingsproblemen wordt verminderd.
  • Versievaluta: Het gebruik van latest tags kan onverwachte wijzigingen veroorzaken; specifieke versietags bieden stabiliteit, maar vereisen handmatige updates.

Beveiligingsproblemen in toepassingsafhankelijkheid

Taalspecifieke pakketten:

  • npm-pakketten: Node.js toepassingen honderden npm-afhankelijkheden bevatten die mogelijk beveiligingsproblemen hebben.
  • Python-pakketten: Python-toepassingen bevatten PyPI-pakketten met mogelijke beveiligingsproblemen.
  • Java-afhankelijkheden: Maven- en Gradle-afhankelijkheden bevatten transitief veel JAR-bestanden.
  • .NET-pakketten: NuGet-pakketten in .NET-toepassingen kunnen beveiligingsproblemen bevatten.

Transitieve afhankelijkheden:

  • Diepe afhankelijkheidsstructuren: Toepassingsafhankelijkheden hebben hun eigen afhankelijkheden, waardoor diepe afhankelijkheidsstructuren worden gemaakt.
  • Verborgen beveiligingsproblemen: Beveiligingsproblemen in transitieve afhankelijkheden zijn eenvoudig te overzien zonder geautomatiseerd scannen.
  • Complexiteit bijwerken: Het bijwerken van transitieve afhankelijkheden vereist inzicht in de compatibiliteit in de hele afhankelijkheidsketen.

Accumulatie van afbeeldingslaag

Gelaagd bestandssysteem:

  • Overname van lagen: Elke Dockerfile-instructie maakt een nieuwe laag en beveiligingsproblemen in elke laag zijn van invloed op de uiteindelijke installatiekopie.
  • Verwijderde bestanden blijven behouden: Bestanden die in latere lagen zijn verwijderd, bestaan nog steeds in eerdere lagen en dragen bij aan de afbeeldingsgrootte en het beveiligingsprofiel.
  • Geheimen in de geschiedenis: Geheimen die per ongeluk zijn toegewezen aan vroege lagen, blijven in de afbeeldingsgeschiedenis, zelfs als ze in latere lagen worden verwijderd.
  • Build-time-afhankelijkheden: Afhankelijkheden die alleen nodig zijn tijdens de build (compilers, buildhulpprogramma's) mogen niet worden weergegeven in de uiteindelijke runtime-installatiekopieën.

Beveiligingsproblemen in de configuratie

Onjuiste configuraties van Dockerfile:

  • Uitvoeren als rootgebruiker: Containers die als rootgebruiker worden uitgevoerd, hebben onnodige privileges.
  • Blootgestelde poorten: Onnodig blootgestelde poorten breiden het aanvalsoppervlak uit.
  • BINAIRE SUID-bestanden: BINAIRE SUID-/SGID-bestanden maken escalatieaanvallen met bevoegdheden mogelijk.
  • Onveilige standaardinstellingen: Standaardconfiguraties volgen mogelijk niet de aanbevolen beveiligingsprocedures.

Benaderingen voor het scannen van containers

Voor effectieve containerbeveiliging moet op meerdere punten in de levenscyclus worden gescand:

Scannen van registers

Continue registerbewaking: Containerregisters bieden gecentraliseerde locaties voor het scannen en afdwingen van beleid.

Azure Container Registry scannen met Microsoft Defender:

  • Automatisch scannen: Microsoft Defender for Containers scant automatisch afbeeldingen die naar Azure Container Registry worden gepusht.
  • Scannen op basis van triggers: Scant trigger bij push-, import- en pull-bewerkingen.
  • Doorlopend opnieuw scannen: Afbeeldingen worden periodiek opnieuw gescand op nieuw openbaar gemaakte kwetsbaarheden.
  • Aanbevelingen: Security Center biedt herstelaanbeveling voor gedetecteerde beveiligingsproblemen.

Registerscan-activeringen:

  • Push-triggers: Nieuwe beelden worden automatisch gescand wanneer ze naar het register worden geüpload.
  • Importtriggers: Afbeeldingen geïmporteerd uit externe registers worden gescand.
  • Pull-triggers: Afbeeldingen worden binnen 24 uur gescand nadat ze zijn opgehaald.
  • Periodiek opnieuw scannen: Eerder gescande afbeeldingen worden dagelijks opnieuw gescand (afgelopen 90 dagen voor gepushte afbeeldingen, afgelopen 30 dagen voor opgehaalde afbeeldingen).

Build-time scannen

Integratie van CI/CD-pijplijn: Scannen tijdens het bouwen van beelden herkent beveiligingsproblemen voordat beelden registries bereiken.

Scannen van Azure Pipelines-containers:

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

Scannen van GitHub Actions-containers:

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

Scannen van GitHub Advanced Security-containers: GitHub Advanced Security biedt extra mogelijkheden voor containerbeveiliging via CodeQL en afhankelijkheidsscans.

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

Voordelen van scannen tijdens de bouwtijd:

  • Snel falen: Voorkom dat kwetsbare afbeeldingen worden gebouwd en naar registries worden geüpload.
  • Feedback voor ontwikkelaars: Geef onmiddellijk feedback aan ontwikkelaars tijdens het bouwproces.
  • Beleidshandhaving: Beveiligingsbeleid afdwingen voordat afbeeldingen registers of productie bereiken.
  • Validatie van buildartefact: Zorg ervoor dat alleen de voortgang van compatibele installatiekopieën verloopt via de implementatiepijplijn.

Runtimescans

Geïmplementeerde containerbewaking: Runtimescans detecteren beveiligingsproblemen in daadwerkelijk geïmplementeerde containers.

Kubernetes-toegangscontrollers: Toegangscontrollers dwingen beleidsregels af voordat containers worden geïmplementeerd in Kubernetes-clusters.

Voorbeeld van OPA Gatekeeper-beleid:

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

Azure Kubernetes Service Runtime-beveiliging: Microsoft Defender for Containers biedt runtime-bedreigingsdetectie:

  • Gedragsanalyse: Bewaakt het gedrag van containers om afwijkende activiteiten te detecteren.
  • Bedreigingsinformatie: Vergelijkt waargenomen gedrag tegen bekende aanvalspatronen.
  • MITRE ATT&CK-mapping: In kaart brengen van gedetecteerde bedreigingen aan het MITRE ATT&CK-framework.
  • Genereren van waarschuwingen: Hiermee worden beveiligingswaarschuwingen gegenereerd voor verdachte containeractiviteiten.

Hulpprogramma's voor het scannen van containers

Trivy (Aqua Security)

Trivy is een uitgebreide opensource-scanner voor beveiligingsproblemen in containers.

Belangrijke functies:

  • Uitgebreid scannen: Scant besturingssysteempakketten, toepassingsafhankelijkheden, IaC-configuraties en geheimen.
  • Ondersteuning voor meerdere indelingen: Scant containerinstallatiekopieën, bestandssystemen, Git repositories en Kubernetes-clusters.
  • Offline scannen: Kan worden uitgevoerd in luchtgescheiden omgevingen met offline databases voor kwetsbaarheden.
  • Snelle prestaties: Lichtgewicht scanner met snelle scantijden.
  • SBOM-generatie: Genereert CycloneDX- en SPDX-softwarestuklijsten.

Azure Pipelines Trivy-integratie:

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

Snyk Container

Snyk Container biedt scannen van containerafbeeldingen dat is geïntegreerd met Snyk's ontwikkelaarsplatform.

Belangrijke functies:

  • Aanbevelingen voor basisinstallatiekopieën: Suggesties voor alternatieve basisinstallatiekopieën met minder beveiligingsproblemen.
  • Prioriteitstelling: Geeft prioriteit aan beveiligingsproblemen op basis van exploiteerbaarheid en bedrijfsimpact.
  • Hulp bij het oplossen van problemen: Biedt specifieke herstelstappen voor gedetecteerde beveiligingsproblemen.
  • Kubernetes-integratie: Scant afbeeldingen die in Kubernetes-clusters zijn ingezet.

Aqua Security

Aqua Security biedt hoogwaardige containerbeveiliging gedurende de volledige levenscyclus.

Belangrijke functies:

  • Afbeeldingsgarantie: Uitgebreid scannen van afbeeldingen met aanpasbare beleidsregels.
  • Runtimebeveiliging: Bewaakt actieve containers op verdacht gedrag.
  • Nalevingscontrole: Valideert container afbeeldingen op basis van de CIS Docker Benchmark en aangepaste beleidsregels.
  • Beveiliging van toeleveringsketen: Controleert de herkomst van afbeeldingen en detecteert supply chain-aanvallen.

Anchore Engine

Anchore Engine is een opensource-scanner voor containerafbeeldingen met beleidsgestuurde analyse.

Belangrijke functies:

  • Beleidgestuurd: Flexibele beleidsengine voor het definiëren van beveiligings- en nalevingsregels.
  • Grondige inspectie: Analyseert beeldlagen, pakketten en configuratie.
  • Aangepast beleid: Organisatiespecifiek beveiligings- en nalevingsbeleid definiëren.
  • API-gestuurd: REST API voor integratie met aangepaste hulpprogramma's.

Geavanceerde beveiliging van GitHub

GitHub Advanced Security biedt hoogwaardige beveiligingsfuncties voor opslagplaatsen, waaronder mogelijkheden voor het scannen van containers.

Beveiligingsfuncties voor containers:

  • Scannen op afhankelijkheden: Detecteert automatisch kwetsbare afhankelijkheden in containerinstallatiekopieën.
  • Geheim scannen: Identificeert blootgestelde geheimen (API-sleutels, tokens, referenties) in containerlagen en Dockerfiles.
  • Code scannen: CodeQL-analyse van Dockerfiles en toepassingscode binnen containers.
  • Beveiligingsadviezen: Integratie met GitHub Advisory Database voor informatie over beveiligingsproblemen.
  • Beveiliging van toeleveringsketen: Afhankelijkheidsgrafiek en Dependabot-integratie voor containerafhankelijkheden.

CodeQL uitvoeren in containers: GitHub Advanced Security biedt ondersteuning voor het uitvoeren van CodeQL-codescans in containeromgevingen voor uitgebreide analyse:

CodeQL-containerscanwerkstroom:

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"

Geheim scannen op containers:

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

Voordelen van GitHub Advanced Security:

  • Systeemeigen integratie: Diep geïntegreerd met GitHub-werkstromen en beveiligingsfuncties.
  • Geïntegreerd dashboard: Gecentraliseerd beveiligingsoverzicht op het tabblad GitHub Security.
  • Beleidshandhaving: Vertaktbeschermingsregels kunnen vereisen dat beveiligingscontroles worden gepasseerd.
  • Nalevingsrapportage: Ingebouwde nalevingsrapporten voor SOC 2, ISO 27001 en andere frameworks.
  • Teamsamenwerking: Beveiligingsresultaten die zijn geïntegreerd in beoordelingen van pull-aanvragen en het bijhouden van problemen.

GitHub Advanced Security inschakelen:

Voor organisaties:

  1. Navigeer naar organisatie-instellingen → Codebeveiliging en -analyse.
  2. Schakel GitHub Advanced Security in voor alle of geselecteerde opslagplaatsen.
  3. Configureer Dependabot-waarschuwingen, geheimscans en codescans.
  4. Beveiligingsbeleid en beveiligingsadviezen instellen.

Voor opslagplaatsen:

  1. Ga naar opslagplaatsinstellingen → Codebeveiliging en -analyse.
  2. Afhankelijkheidsgrafiek inschakelen (gratis voor openbare opslagplaatsen).
  3. Schakel Dependabot-waarschuwingen en Dependabot-beveiligingsupdates in.
  4. Geheim scannen inschakelen (hiervoor is een GitHub Advanced Security-licentie vereist voor privé-opslagplaatsen).
  5. Codescans inschakelen met CodeQL- of hulpprogramma's van derden.

Geavanceerde beveiliging voor containerregisters:

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

Integratie met GitHub-beveiligingsfuncties:

  • Overzicht van beveiliging: Beveiligingsdashboard voor de hele organisatie met beveiligingsproblemen in containers.
  • Beveiligingswaarschuwingen: Geautomatiseerde waarschuwingen voor kwetsbare containerafhankelijkheden.
  • Dependabot-updates: Geautomatiseerde pull-aanvragen om kwetsbare basisinstallatiekopieën en afhankelijkheden bij te werken.
  • Integratie van code-eigenaren: Routeer beveiligingsresultaten naar de juiste teams via het CODEOWNERS-bestand.
  • Auditlogboeken: Voltooi het audittrail van beveiligingsgebeurtenissen en herstelacties.

Aanbevolen procedures voor het scannen van containers

Builds met meerdere fasen implementeren

Afzonderlijke build- en runtime-afhankelijkheden:

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

Voordelen:

  • Kleinere afbeeldingen: Runtime-afbeeldingen bevatten geen buildhulpprogramma's en intermediaire artefacten.
  • Minder beveiligingsproblemen: Build-afhankelijkheden (compilers, SDK's) worden niet weergegeven in definitieve installatiekopieën.
  • Betere prestaties: Met kleinere afbeeldingen kunnen push-, pull- en startacties sneller worden uitgevoerd.

Gebruik minimale basisbeelden

Kies de juiste basisafbeeldingen:

  • Alpine: Kleine basisimage (~5 MB) met een minimaal aanvalsoppervlak.
  • Distributieloos: Bevat alleen toepassings- en runtime-afhankelijkheden, geen shell- of pakketbeheer.
  • Slanke varianten: Officiële *-slim varianten sluiten onnodige hulpprogramma's uit.
  • Specifieke versies: Gebruik specifieke versietags in plaats van latest voor reproduceerbaarheid.

Voorbeeld van distroless image:

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

Scannen vroeg en vaak

Scanfrequentie:

  • Werkstation voor ontwikkelaars: Scan afbeeldingen lokaal voordat u ze doorvoert.
  • Validatie van pull request: Scan in CI-pijplijnen bij elke pull request.
  • Hoofdbranch-builds: Uitgebreide scans tijdens het samenvoegen van de hoofdbranch.
  • Registervermelding: Scan afbeeldingen voordat u ze accepteert in registers.
  • Geplande herscanning: Scan regelmatig opgeslagen installatiekopieën opnieuw op nieuwe beveiligingsproblemen.
  • Pre-implementatie: Definitieve validatie voordat deze in productie wordt geïmplementeerd.

Beveiligingspoorten implementeren

Afdwingingspunten voor beleid:

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

Gate-voorbeelden:

  • Ernst van beveiligingsproblemen: Mislukte builds met kritieke of hoge ernstproblemen.
  • Licentiecompatibiliteit: Afbeeldingen met verboden licenties blokkeren.
  • Configuratieproblemen: Voorkom de implementatie van images die als root worden uitgevoerd.
  • Detectie van geheimen: Falen indien geheimen ontdekt worden in afbeeldingslagen.

Geautomatiseerde herstel

Geautomatiseerde updates:

  • Dependabot voor Dockerfiles: Schakel Dependabot in om versies en afhankelijkheden van basisinstallatiekopieën in Dockerfiles bij te werken.
  • Geautomatiseerde herbouwen: Configureer pipelines om images automatisch te herbouwen bij updates van basisimages.
  • Patchautomatisering: Gebruik hulpprogramma's om automatisch basisinstallatiekopieën of afhankelijkheden te patchen.
  • Pijplijnen testen: Zorg ervoor dat geautomatiseerde updates uitgebreide tests activeren.

GitHub Dependabot-configuratie voor Docker:

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

Scanresultatengeschiedenis onderhouden

Bijhouden en trends:

  • Gecentraliseerde rapportage: Scanresultaten samenvoegen in centrale dashboards.
  • Trendanalyse: Houd het aantal beveiligingsproblemen in de loop van de tijd bij om het beveiligingspostuur te meten.
  • Nalevingscontroles: Houd de scanresultatengeschiedenis bij voor nalevingsinformatie.
  • SBOM-archivering: De softwarefactuur van materialen voor geïmplementeerde installatiekopieën archiveren.

Afbeeldingsondertekening implementeren

Controleer de herkomst van de afbeelding:

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

Voordelen van afbeeldingsondertekening:

  • Verificatie van herkomst: Bevestig dat afbeeldingen afkomstig zijn van vertrouwde bronnen.
  • Manipulatiedetectie: Detecteren of afbeeldingen zijn gewijzigd na ondertekening.
  • Beleidshandhaving: Alleen ondertekende images implementeren in productieomgevingen.

Het automatiseren van het scannen van containerafbeeldingen in de ontwikkelings- en implementatielevenscyclus zorgt voor uitgebreide detectie van kwetsbaarheden en het afdwingen van beleid. Door vroeg te scannen, vaak te scannen en geautomatiseerd herstel te implementeren, kunnen organisaties veilige containerimplementaties onderhouden zonder de ontwikkelingssnelheid op te offeren. In de volgende les wordt beschreven hoe u waarschuwingen van hulpprogramma's voor beveiligingsscanners interpreteert en prioriteert.