Automatisera genomsökning av containeravbildningar

  • 10 minuter

Containerbilder paketerar applikationer tillsammans med alla deras beroenden, vilket gör dem till praktiska distributionskomponenter. Den här bekvämligheten medför dock betydande säkerhetsutmaningar – sårbarheter i basavbildningar, systempaket eller programberoenden kan äventyra distribuerade containrar. Automatisering av skanning av containeravbildningar genom hela utvecklings- och distributionslivscykeln säkerställer att endast säkra och regelkompatibla avbildningar når produktionsmiljöer.

Förstå säkerhetsrisker för containrar

Containeravbildningar introducerar flera säkerhetsriskkategorier:

Sårbarheter i basavbildningar

Operativsystempaket:

  • Systembibliotek: Basavbildningar omfattar operativsystembibliotek (glibc, OpenSSL, zlib) som kan innehålla säkerhetsrisker.
  • Pakethanterare: Systempakethanterare (apt, yum, apk) och deras paket har ofta säkerhetsproblem.
  • Gränssnittsverktyg: Vanliga verktyg (bash, curl, wget) i basavbildningar kan ha sårbarheter.
  • Uppdateringsfördröjning: Officiella basavbildningar kan innehålla föråldrade paket mellan olika utgåvor.

Påverkan på basavbildningsval:

  • Alpine vs Debian: Alpine Linux-basavbildningar är mindre men använder olika bibliotek (musl i stället för glibc), vilket påverkar sårbarhetsprofiler.
  • Distrolösa bilder: Googles distrolösa bilder innehåller endast programkörningsberoenden, vilket dramatiskt minskar attackytan.
  • Smala varianter: Smala bildvarianter exkluderar vanliga verktyg, vilket minskar storleken och sårbarhetsexponeringen.
  • Versionsvaluta: Med hjälp av latest taggar kan oväntade ändringar införas. Specifika versionstaggar ger stabilitet men kräver manuella uppdateringar.

Sårbarheter för programberoende

Språkspecifika paket:

  • npm-paket: Node.js program ger hundratals npm-beroenden som kan ha säkerhetsrisker.
  • Python-paket: Python-program innehåller PyPI-paket med potentiella säkerhetsproblem.
  • Java-beroenden: Maven- och Gradle-beroenden omfattar transitivt många JAR-filer.
  • .NET-paket: NuGet-paket i .NET-program kan innehålla sårbarheter.

Transitiva beroenden:

  • Djupa beroendeträd: Programberoenden har sina egna beroenden och skapar djupa beroendeträd.
  • Dolda sårbarheter: Säkerhetsrisker i transitiva beroenden är lätta att förbise utan automatisk genomsökning.
  • Uppdateringskomplexitet: Uppdatering av transitiva beroenden kräver att du förstår kompatibiliteten i hela beroendekedjan.

Ackumulering av bildskikt

Lagerbaserat filsystem:

  • Lagerarv: Varje Dockerfile-instruktion skapar ett nytt lager, och sårbarheter i alla lager påverkar den slutliga avbildningen.
  • Borttagna filer bevaras: Filer som tas bort i senare lager finns fortfarande i tidigare lager och bidrar till bildstorlek och säkerhetsprofil.
  • Hemligheter i historien: Hemligheter som oavsiktligt har checkats in i tidiga lager finns kvar i bildhistoriken även om de tas bort i senare lager.
  • Byggtidsberoenden: Beroenden som endast behövs under bygget (kompilatorer, byggverktyg) bör inte visas i de sista körningsavbildningarna.

Konfigurationssårbarheter

Felkonfigurationer för Dockerfile:

  • Körs som root: Containrar som körs som root-användare har överflödiga rättigheter.
  • Exponerade portar: I onödan exponerade portar expanderar attackytan.
  • SUID-binärfiler: SUID/SGID-binärfiler möjliggör privilegiereskaleringsattacker.
  • Osäkra standardvärden: Standardkonfigurationer kanske inte följer rekommenderade säkerhetsmetoder.

Metoder för containergenomsökning

Effektiv containersäkerhet kräver genomsökning på flera punkter i livscykeln:

Registergenomsökning

Kontinuerlig registerövervakning: Containerregister tillhandahåller centraliserade platser för genomsökning och principtillämpning.

Genomsökning av Azure Container Registry med Microsoft Defender:

  • Automatisk genomsökning: Microsoft Defender för containrar genomsöker automatiskt avbildningar som skickas till Azure Container Registry.
  • Utlösarbaserad genomsökning: Söker igenom utlösaren vid push-, import- och pull-åtgärder.
  • Kontinuerlig genomsökning: Bilder genomsöks regelbundet för nyligen avslöjade sårbarheter.
  • Rekommendationer: Security Center tillhandahåller reparationsrekommendationer för identifierade säkerhetsrisker.

Utlösare för registergenomsökning:

  • Push-utlösare: Nya bilder genomsöks automatiskt när de skickas till registret.
  • Importutlösare: Bilder som importeras från externa register genomsöks.
  • Pull-utlösare: Bilder genomsöks inom 24 timmar efter att de har hämtats.
  • Periodisk omskanning: Tidigare skannade bilder genomsöks dagligen (de senaste 90 dagarna för push-överförda bilder, de senaste 30 dagarna för hämtade bilder).

Kompileringsgenomsökning

CI/CD-pipelineintegrering: Genomsökning under bildbyggnader identifierar sårbarheter innan bilder når register.

Genomsökning av Azure Pipelines-containrar:

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

GitHub Actions-containergenomsökning:

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

Genomsökning av GitHub Advanced Security-container: GitHub Advanced Security tillhandahåller ytterligare säkerhetsfunktioner för containrar via CodeQL och beroendegenomsökning.

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

Fördelar med genomsökning under byggtid

  • Misslyckas snabbt: Förhindra att sårbara avbildningar skapas och skickas till register.
  • Feedback från utvecklare: Ge omedelbar feedback till utvecklare under byggprocessen.
  • Policytillämpning: Framtvinga säkerhetspolicyer innan bilder når register eller produktion.
  • Bygg artefaktvalidering: Se till att endast kompatibla avbildningar får gå vidare genom distributionspipelinens gång.

Runtime-genomsökning

Distribuerad containerövervakning: Körningsgenomsökning identifierar sårbarheter i faktiskt distribuerade containrar.

Kubernetes-antagningskontrollanter: Antagningskontrollanter tillämpar principer innan containrar distribueras till Kubernetes-kluster.

OPA Gatekeeper-policyexempel:

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-körningsskydd: Microsoft Defender för containrar erbjuder detektering av körningstidshot.

  • Beteendeanalys: Övervakar containerbeteendet för att identifiera avvikande aktiviteter.
  • Hotinformation: Jämför observerade beteenden mot kända attackmönster.
  • MITRE ATT&CK-mappning: Mappar identifierade hot mot MITRE ATT&CK-ramverket.
  • Aviseringsgenerering: Genererar säkerhetsaviseringar för misstänkta containeraktiviteter.

Verktyg för containergenomsökning

Trivy (Aqua Security)

Trivy är en omfattande sårbarhetsskanner med öppen källkod.

Huvudfunktioner:

  • Omfattande genomsökning: Söker igenom OS-paket, programberoenden, IaC-konfigurationer och hemligheter.
  • Stöd för flera format: Söker igenom containeravbildningar, filsystem, git-lagringsplatser och Kubernetes-kluster.
  • Offline-skanning: Kan användas i luftgapmiljöer med offline sårbarhetsdatabaser.
  • Snabba prestanda: Enkel skanner med snabba genomsökningstider.
  • SBOM-generering: Genererar CycloneDX- och SPDX-programvaruförteckningar.

Azure Pipelines Trivy-integrering:

- 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 tillhandahåller genomsökning av containeravbildningar integrerat med Snyks utvecklarfokuserade plattform.

Huvudfunktioner:

  • Rekommendationer för basavbildning: Föreslår alternativa basavbildningar med färre säkerhetsrisker.
  • Prioritering: Prioriterar sårbarheter baserat på sårbarhet och affärspåverkan.
  • Fixguidning: Innehåller specifika reparationssteg för identifierade sårbarheter.
  • Kubernetes-integrering: Söker igenom avbildningar som distribuerats till Kubernetes-kluster.

Aqua Security

Aqua Security erbjuder containersäkerhet i företagsklass under hela livscykeln.

Huvudfunktioner:

  • Bildsäkerhet: Omfattande avbildningsgenomsökning med anpassningsbara principer.
  • Körningsskydd: Övervakar körande containrar av misstänkt beteende.
  • Efterlevnadskontroll: Verifierar avbildningar mot CIS Docker Benchmark och anpassade principer.
  • Säkerhet i leveranskedjan: Verifierar bild proveniens och identifierar leveranskedjeattacker.

Fästpunktsmotor

Anchore Engine är en containeravbildningsskanner med öppen källkod med principbaserad analys.

Huvudfunktioner:

  • Policydriven: Flexibel policymotor för att definiera säkerhets- och efterlevnadsregler.
  • Djupinspektion: Analyserar bildskikt, paket och konfiguration.
  • Anpassade principer: Definiera organisationsspecifika säkerhets- och efterlevnadsprinciper.
  • API-driven: REST API för integrering med anpassade verktyg.

GitHub Advanced Security

GitHub Advanced Security tillhandahåller säkerhetsfunktioner i företagsklass för lagringsplatser, inklusive funktioner för genomsökning av containrar.

Säkerhetsfunktioner för containrar:

  • Beroendegenomsökning: Identifierar automatiskt sårbara beroenden i containeravbildningar.
  • Hemlig genomsökning: Identifierar exponerade hemligheter (API-nycklar, token, autentiseringsuppgifter) i containerlager och Dockerfiles.
  • Kodgenomsökning: CodeQL-analys av Dockerfiles och programkod i containrar.
  • Säkerhetsrekommendationer: Integrering med GitHub Advisory Database för sårbarhetsinformation.
  • Säkerhet i leveranskedjan: Beroendediagram och Dependabot-integrering för containerberoenden.

Köra CodeQL i containrar: GitHub Advanced Security stöder körning av CodeQL-kodgenomsökning i containermiljöer för omfattande analys:

CodeQL-containergenomsökningsarbetsflöde:

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"

Hemlig genomsökning av containrar:

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

GitHub Advanced Security-fördelar:

  • Intern integrering: Djupt integrerad med GitHub-arbetsflöden och säkerhetsfunktioner.
  • Enhetlig instrumentpanel: Översikt över centraliserad säkerhet på fliken GitHub-säkerhet.
  • Efterlevnad av policy: Regler för grenskydd kan kräva att säkerhetskontroller passeras.
  • Efterlevnadsrapportering: Inbyggda efterlevnadsrapporter för SOC 2, ISO 27001 och andra ramverk.
  • Teamsamarbete: Säkerhetsresultat integrerade i granskningar av pull-begäranden och problemspårning.

Aktivera GitHub Advanced Security:

För organisationer:

  1. Gå till organisationsinställningar → Kodsäkerhet och analys.
  2. Aktivera GitHub Advanced Security för alla eller valda lagringsplatser.
  3. Konfigurera Dependabot-aviseringar, hemlig genomsökning och kodgenomsökning.
  4. Konfigurera säkerhetsprinciper och säkerhetsrekommendationer.

För lagringsplatser:

  1. Gå till Lagringsplatsinställningar → Kodsäkerhet och analys.
  2. Aktivera beroendediagram (kostnadsfritt för offentliga lagringsplatser).
  3. Aktivera Dependabot-aviseringar och Dependabot-säkerhetsuppdateringar.
  4. Aktivera hemlig genomsökning (kräver GitHub Advanced Security-licens för privata lagringsplatser).
  5. Aktivera kodgenomsökning med CodeQL eller verktyg från tredje part.

Avancerad säkerhet för containerregister:

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

Integrering med GitHub-säkerhetsfunktioner:

  • Säkerhetsöversikt: Säkerhetsinstrumentpanel för hela organisationen som visar sårbarheter i containrar.
  • Säkerhetsaviseringar: Automatiserade aviseringar för sårbara containerberoenden.
  • Dependabot-uppdateringar: Automatiserade pull-begäranden för att uppdatera sårbara basavbildningar och beroenden.
  • Integrering av kodägare: Dirigera säkerhetsresultat till lämpliga team via CODEOWNERS-filen.
  • Granskningsloggar: Slutför spårningsloggen för säkerhetshändelser och reparationsåtgärder.

Metodtips för containergenomsökning

Implementera flerstegsversioner

Separata beroenden för byggtid och körningstid:

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

Fördelar:

  • Mindre bilder: Körningsavbildningar innehåller inte byggverktyg och mellanliggande artefakter.
  • Färre sårbarheter: Byggberoenden (kompilatorer, SDK:er) visas inte i de sista bilderna.
  • Bättre prestanda: Mindre bilder överförs, dras och startar snabbare.

Använd minimala basavbildningar

Välj lämpliga basavbildningar:

  • Alpin: Liten basavbildning (~5 MB) med minimal attackyta.
  • Distroless: Innehåller endast program- och körningsberoenden, inget gränssnitt eller pakethanterare.
  • Smala varianter: Officiella *-slim varianter utesluter onödiga verktyg.
  • Specifika versioner: Använd specifika versionstaggar i stället latest för för reproducerbarhet.

Exempel på distrolös bild:

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

Genomsök tidigt och ofta

Genomsökningsfrekvens:

  • Arbetsstation för utvecklare: Skanna avbildningar lokalt innan du skickar upp.
  • Validering av pull-begäran: Genomsök i CI-pipelines på varje pull-begäran.
  • Byggnationer av huvudgrenen: Omfattande skanningar när huvudgrenar slås samman.
  • Registerantagning: Skanna avbildningar innan du godkänner dem i register.
  • Schemalagd omskanning: Genomsök regelbundet lagrade bilder på nytt för nyligen avslöjade säkerhetsrisker.
  • Före distribution: Slutlig validering innan du distribuerar till produktion.

Implementera säkerhetsgrindar

Policykontrollpunkter:

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

Gateexempel:

  • Allvarlighetsgrad för sårbarhet: Felversioner med kritiska eller allvarliga säkerhetsrisker.
  • Licensefterlevnad: Blockera avbildningar med förbjudna licenser.
  • Konfigurationsproblem: Förhindra distribution av bilder som körs under root.
  • Identifiering av hemlighet: Misslyckas om hemligheter identifieras i bildlager.

Automatisera reparation

Automatiserade uppdateringar:

  • Dependabot för Dockerfiles: Aktivera Dependabot för att uppdatera basavbildningsversioner och beroenden i Dockerfiles.
  • Automatiserade återskapanden: Konfigurera pipelines för att automatiskt återskapa avbildningar när basavbildningar uppdateras.
  • Korrigeringsautomatisering: Använd verktyg för att automatiskt korrigera basavbildningar eller beroenden.
  • Testa pipelines: Säkerställ att automatiserade uppdateringar utlöser fullständig testning.

GitHub Dependabot-konfiguration för Docker:

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

Behåll resultathistorik för genomsökning

Spårning och trendning:

  • Centraliserad rapportering: Aggregerade genomsökningsresultat i centraliserade instrumentpaneler.
  • Trendanalys: Spåra antalet säkerhetsrisker över tid för att mäta säkerhetsstatusen.
  • Efterlevnadsgranskningar: Underhåll historiken för genomsökningsresultat för efterlevnadsbevis.
  • SBOM-arkivering: Arkivera programvarufaktura för distribuerade avbildningar.

Implementera bildsignering

Verifiera bildens proveniens:

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

Fördelar med bildsignering:

  • Proveniensverifiering: Bekräfta att avbildningar kommer från betrodda källor.
  • Identifiering av manipulering: Identifiera om avbildningar har ändrats efter signeringen.
  • Principtillämpning: Implementera endast signerade avbildningar till produktionsmiljöer.

Automatiserad skanning av containeravbildningar under utvecklings- och distributionsfasen säkerställer omfattande sårbarhetsidentifiering och policyefterlevnad. Genom att skanna tidigt, genomsöka ofta och implementera automatiserad reparation kan organisationer upprätthålla säkra containerdistributioner utan att offra utvecklingshastigheten. Nästa lektion undersöker hur du tolkar och prioriterar aviseringar från säkerhetsskannerverktyg.