Automatiser scanning af objektbeholderafbildninger

  • 10 minutter

Containerafbildninger pakker applikationer sammen med alle deres afhængigheder, hvilket gør dem til praktiske implementeringsartefakter. Denne bekvemmelighed medfører dog betydelige sikkerhedsudfordringer – sårbarheder i basisafbildninger, systempakker eller programafhængigheder kan kompromittere udrullede objektbeholdere. Automatisering af scanning af objektbeholderafbildninger i hele udviklings- og udrulningslivscyklussen sikrer, at kun sikre, kompatible afbildninger når frem til produktionsmiljøer.

Forståelse af sikkerhedsrisici i objektbeholdere

Containerafbildninger introducerer flere sikkerhedsrisikokategorier:

Sårbarheder i basisafbildninger

Operativsystem pakker:

  • Systembiblioteker: Basisaftryk inkluderer operativsystembiblioteker (glibc, OpenSSL, zlib), der kan indeholde sårbarheder.
  • Pakkeansvarlige: Systempakkeadministratorer (apt, yum, apk) og deres pakker har ofte sikkerhedsproblemer.
  • Shell-værktøjer: Almindelige hjælpeprogrammer (bash, curl, wget) i basisbilleder kan have sårbarheder.
  • Opdateringsforsinkelse: Officielle basisaftryk kan indeholde forældede pakker mellem udgivelser.

Påvirkning af valg af basisbillede:

  • Alpine vs Debian: Alpine Linux-basisaftryk er mindre, men bruger forskellige biblioteker (musl i stedet for glibc), hvilket påvirker sårbarhedsprofiler.
  • Distroløse billeder: Googles distroløse billeder indeholder kun applikationskørselsafhængigheder, hvilket dramatisk reducerer angrebsfladen.
  • Slanke varianter: Slanke billedvarianter udelukker almindelige hjælpeprogrammer, hvilket reducerer størrelse og sårbarhedseksponering.
  • Versionens valuta: Brug af latest tags kan medføre uventede ændringer. Specifikke versionstags giver stabilitet, men kræver manuelle opdateringer.

Sårbarheder i forbindelse med programafhængighed

Sprogspecifikke pakker:

  • npm-pakker: Node.js applikationer bringer hundredvis af npm-afhængigheder, der kan have sårbarheder.
  • Python-pakker: Python-applikationer inkluderer PyPI-pakker med potentielle sikkerhedsproblemer.
  • Java-afhængigheder: Maven- og Gradle-afhængigheder indeholder transitivt mange JAR-filer.
  • .NET pakker: NuGet-pakker i .

Transitive afhængigheder:

  • Træer med dyb afhængighed: Programafhængigheder har deres egne afhængigheder, hvilket skaber dybe afhængighedstræer.
  • Skjulte sårbarheder: Sårbarheder i transitive afhængigheder er nemme at overse uden automatiseret scanning.
  • Opdater kompleksitet: Opdatering af transitive afhængigheder kræver forståelse af kompatibilitet på tværs af hele afhængighedskæden.

Ophobning af billedlag

Lagdelt filsystem:

  • Nedarvning af lag: Hver Dockerfile-instruktion opretter et nyt lag, og sårbarheder i ethvert lag påvirker det endelige billede.
  • Slettede filer bevares: Filer, der er slettet i senere lag, findes stadig i tidligere lag og bidrager til billedstørrelse og sikkerhedsprofil.
  • Hemmeligheder i historien: Hemmeligheder, der ved et uheld er begået i tidlige lag, forbliver i billedhistorikken, selvom de fjernes i senere lag.
  • Afhængigheder af byggetid: Afhængigheder, der kun er nødvendige under build (compilere, buildværktøjer), bør ikke vises i endelige runtime-billeder.

Sårbarheder i forbindelse med konfiguration

Dockerfile fejlkonfigurationer:

  • Kører som rod: Containere, der kører som root-bruger, har unødvendige rettigheder.
  • Udsatte porte: Unødigt udsatte porte udvider angrebsfladen.
  • SUID-binære filer: Binære SUID/SGID-filer muliggør rettighedseskaleringsangreb.
  • Usikre standarder: Standardkonfigurationer følger muligvis ikke bedste praksis for sikkerhed.

Metoder til scanning af objektbeholdere

Effektiv containersikkerhed kræver scanning på flere punkter i livscyklussen:

Scanning af registreringsdatabasen

Kontinuerlig overvågning af registreringsdatabasen: Containerregistre giver centraliserede placeringer til scanning og håndhævelse af politikker.

Scanning af Azure Container Registry med Microsoft Defender:

  • Automatisk scanning: Microsoft Defender for Containers scanner automatisk billeder, der sendes til Azure Container Registry.
  • Trigger-baseret scanning: Scanninger udløser ved push-, import- og pull-operationer.
  • Kontinuerlig genscanning: Afbildninger scannes med jævne mellemrum for nyligt afslørede sårbarheder.
  • Anbefalinger: Security Center indeholder anbefalinger til afhjælpning af opdagede sårbarheder.

Udløsere af scanning i registreringsdatabasen:

  • Tryk på udløsere: Nye afbildninger scannes automatisk, når de sendes til registreringsdatabasen.
  • Importer udløsere: Billeder, der importeres fra eksterne registre, scannes.
  • Træk i aftrækkere: Billeder scannes inden for 24 timer efter at være blevet trukket.
  • Periodisk genscanning: Tidligere scannede billeder scannes igen dagligt (seneste 90 dage for skubbede billeder, sidste 30 dage for hentede billeder).

Scanning i byggetid

Integration af CI/CD-pipeline: Scanning under billedopbygning fanger sårbarheder, før billederne når registrene.

Scanning af Azure Pipelines-objektbeholdere:

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

Scanning af GitHub Actions-objektbeholder:

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

GitHub Advanced Security-objektbeholderscanning: GitHub Advanced Security giver yderligere containersikkerhedsfunktioner gennem CodeQL og afhængighedsscanning.

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

Fordele ved scanning i byggetid:

  • Fejle hurtigt: Undgå, at sårbare billeder oprettes og skubbes til registre.
  • Feedback fra udviklere: Giv øjeblikkelig feedback til udviklere under byggeprocessen.
  • Håndhævelse af politikker: Gennemtving sikkerhedspolitikker, før billeder når registre eller produktion.
  • Validering af build-artefakter: Sørg for, at det kun er kompatible afbildninger, der går videre gennem udrulningspipelinen.

Runtime scanning

Overvågning af implementeret objektbeholder: Runtime-scanning registrerer sårbarheder i faktisk installerede objektbeholdere.

Kubernetes-adgangscontrollere: Adgangscontrollere gennemtvinger politikker, før objektbeholdere udrulles til Kubernetes-klynger.

Eksempel på OPA Gatekeeper-politik:

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

Beskyttelse af Azure Kubernetes Service-kørsel: Microsoft Defender for Containers indeholder registrering af kørselstrusler:

  • Adfærdsanalyse: Overvåger objektbeholderens funktionsmåde for at registrere unormale aktiviteter.
  • Trussel efterretninger: Sammenligner observeret adfærd med kendte angrebsmønstre.
  • MITRE ATT&CK-kortlægning: Kort registrerede trusler mod MITRE ATT&CK framework.
  • Generering af alarmer: Genererer sikkerhedsbeskeder for mistænkelige objektbeholderaktiviteter.

Værktøjer til scanning af objektbeholdere

Trivy (Aqua Security)

Trivy er en omfattende open source-containersårbarhedsscanner.

Vigtigste funktioner:

  • Omfattende scanning: Scanner OS-pakker, programafhængigheder, IaC-konfigurationer og hemmeligheder.
  • Understøttelse af flere formater: Scanner objektbeholderafbildninger, filsystemer, git-lagre og Kubernetes-klynger.
  • Offline scanning: Kan fungere i miljøer med luftgabte med offlinedatabaser med sårbarheder.
  • Hurtig ydeevne: Letvægtsscanner med hurtige scanningstider.
  • SBOM-generering: Genererer CycloneDX- og SPDX-softwarestyklister.

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

Snyk Container

Snyk Container leverer scanning af containerbilleder integreret med Snyks udviklerfokuserede platform.

Vigtigste funktioner:

  • Anbefalinger til basisbillede: Foreslår alternative basisafbildninger med færre sårbarheder.
  • Prioritering: Prioriterer sårbarheder baseret på udnyttelsesmuligheder og forretningspåvirkning.
  • Vejledning til rettelse: Indeholder specifikke afhjælpningstrin for opdagede sårbarheder.
  • Kubernetes-integration: Scanner afbildninger, der er udrullet til Kubernetes-klynger.

Aqua Sikkerhed

Aqua Security tilbyder containersikkerhed i virksomhedsklasse i hele livscyklussen.

Vigtigste funktioner:

  • Billedsikkerhed: Omfattende billedscanning med politikker, der kan tilpasses.
  • Beskyttelse af driftstid: Overvåger kørende containere for mistænkelig adfærd.
  • Kontrol af overholdelse: Validerer billeder i forhold til CIS Docker Benchmark og brugerdefinerede politikker.
  • Sikkerhed i forsyningskæden: Verificerer billedets herkomst og registrerer angreb i forsyningskæden.

Anchore motor

Anchore Engine er en open source-containerbilledscanner med politikbaseret analyse.

Vigtigste funktioner:

  • Politikdrevet: Fleksibelt politikprogram til definition af sikkerheds- og overholdelsesregler.
  • Dyb inspektion: Analyserer billedlag, pakker og konfiguration.
  • Tilpassede politikker: Definer organisationsspecifikke sikkerheds- og overholdelsespolitikker.
  • API-drevet: REST API til integration med brugerdefinerede værktøjer.

Avanceret sikkerhed i GitHub

GitHub Advanced Security indeholder sikkerhedsfunktioner i virksomhedsklassen til lagre, herunder funktioner til scanning af objektbeholdere.

Sikkerhedsfunktioner for containere:

  • Afhængighedsscanning: Registrerer automatisk sårbare afhængigheder i objektbeholderafbildninger.
  • Hemmelig scanning: Identificerer eksponerede hemmeligheder (API-nøgler, tokens, legitimationsoplysninger) i containerlag og Dockerfiles.
  • Scanning af kode: CodeQL-analyse af Dockerfiler og applikationskode i containere.
  • Sikkerhedsadvarsler: Integration med GitHub Advisory Database til intelligens om sårbarheder.
  • Sikkerhed i forsyningskæden: Afhængighedsgraf og Dependabot-integration til containerafhængigheder.

Kørsel af CodeQL i containere: GitHub Advanced Security understøtter kørsel af CodeQL-kodescanning i objektbeholdermiljøer til omfattende analyse:

Arbejdsgang for scanning af CodeQL-containere:

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"

Hemmelig scanning af containere:

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

Fordele ved GitHub Advanced Security:

  • Oprindelig integration: Dybt integreret med GitHub-arbejdsprocesser og sikkerhedsfunktioner.
  • Samlet dashboard: Centraliseret sikkerhedsoversigt under fanen GitHub-sikkerhed.
  • Håndhævelse af politikker: Regler for forgreningsbeskyttelse kan kræve, at sikkerhedskontrollen bestås.
  • Rapportering af overholdelse: Indbyggede compliance-rapporter for SOC 2, ISO 27001 og andre frameworks.
  • Teamsamarbejde: Sikkerhedsresultater integreret i gennemgang af pullanmodninger og problemsporing.

Aktivering af GitHub Advanced Security:

For organisationer:

  1. Gå til Organisationsindstillinger → Kodesikkerhed og -analyse.
  2. Aktivér GitHub Advanced Security for alle eller udvalgte lagre.
  3. Konfigurer Dependabot-advarsler, hemmelig scanning og kodescanning.
  4. Konfigurere sikkerhedspolitikker og sikkerhedsmeddelelser.

For arkiver:

  1. Gå til lagerindstillinger → kodesikkerhed og analyse.
  2. Aktivér afhængighedsgraf (gratis for offentlige lagre).
  3. Aktivér Dependabot-advarsler og Dependabot-sikkerhedsopdateringer.
  4. Aktivér hemmelig scanning (kræver GitHub Advanced Security-licens til private lagre).
  5. Aktiver kodescanning med CodeQL eller tredjepartsværktøjer.

Avanceret sikkerhed for containerregistre:

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

Integration med GitHub-sikkerhedsfunktioner:

  • Oversigt over sikkerhed: Sikkerhedsdashboard for hele organisationen, der viser sårbarheder i objektbeholdere.
  • Sikkerhedsadvarsler: Automatiserede beskeder om sårbare objektbeholderafhængigheder.
  • Dependabot-opdateringer: Automatiserede pullanmodninger til opdatering af sårbare basisbilleder og afhængigheder.
  • Integration af kodeejere: Send sikkerhedsresultater til relevante teams via CODEOWNERS-filen.
  • Overvågningslogfiler: Komplet revisionsspor for sikkerhedshændelser og afhjælpningshandlinger.

Bedste fremgangsmåder for scanning af objektbeholdere

Implementer builds i flere faser

Adskil build- og kørselsafhængigheder:

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

Fordele:

  • Mindre billeder: Runtime-billeder indeholder ikke buildværktøjer og mellemliggende artefakter.
  • Færre sårbarheder: Buildafhængigheder (compilere, SDK'er) vises ikke i endelige billeder.
  • Bedre ydeevne: Mindre billeder skubber, trækker og starter hurtigere.

Brug minimale basisbilleder

Vælg passende basisbilleder:

  • Alpine: Lille basisbillede (~5 MB) med minimal angrebsflade.
  • Distroless: Indeholder kun applikations- og runtime-afhængigheder, ingen shell eller pakkehåndtering.
  • Slanke varianter: Officielle *-slim varianter udelukker unødvendige hjælpeprogrammer.
  • Specifikke versioner: Brug specifikke versionskoder i stedet latest for for reproducerbarhed.

Eksempel på distroless billede:

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

Scan tidligt og ofte

Scanningsfrekvens:

  • Udvikler arbejdsstation: Scan billeder lokalt, før du forpligter dig.
  • Validering af pull-anmodning: Scan i CI-pipelines på hver pullanmodning.
  • Hovedafdelingen bygger: Omfattende scanninger af hovedgrensfletninger.
  • Optagelse i registreringsdatabasen: Scan billeder, før du accepterer dem i registre.
  • Planlagt genscanning: Scan regelmæssigt gemte billeder igen for nyligt afslørede sårbarheder.
  • Før implementering: Endelig validering før implementering til produktion.

Implementer sikkerhedsporte

Håndhævelsespunkter for politikker:

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

Eksempler på porte:

  • Sværhedsgrad af sårbarhed: Fejl builds med kritiske sårbarheder eller sårbarheder med høj alvorsgrad.
  • Overholdelse af licens: Bloker billeder med forbudte licenser.
  • Konfigurationsproblemer: Undgå installation af afbildninger, der kører som rod.
  • Hemmelig detektion: Mislykkes, hvis der registreres hemmeligheder i billedlag.

Automatiser afhjælpning

Automatiserede opdateringer:

  • Dependabot til Dockerfiles: Aktivér Dependabot for at opdatere basisafbildningsversioner og afhængigheder i Dockerfiles.
  • Automatiserede genopbygninger: Konfigurer pipelines til automatisk at genopbygge afbildninger, når basisafbildninger opdateres.
  • Automatisering af patch : Brug værktøjer til automatisk at rette basisbilleder eller afhængigheder.
  • Test af pipelines: Sørg for, at automatiserede opdateringer udløser omfattende test.

GitHub Dependabot-konfiguration til Docker:

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

Vedligehold historik over scanningsresultater

Sporing og trending:

  • Centraliseret rapportering: Samlet scanning resulterer i centraliserede dashboards.
  • Tendensanalyse: Spor sårbarhedstællinger over tid for at måle sikkerhedsniveau.
  • Compliance-revisioner: Vedligehold scanningsresultathistorik for overensstemmelsesbeviser.
  • SBOM-arkivering: Arkiver softwarestyklister til implementerede billeder.

Implementere billedsignering

Bekræft billedets herkomst:

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

Fordele ved billedsignering:

  • Verifikation af herkomst: Bekræft, at billeder stammer fra pålidelige kilder.
  • Registrering af manipulation: Registrer, om billeder er blevet ændret efter signering.
  • Håndhævelse af politikker: Udrul kun signerede afbildninger til produktionsmiljøer.

Automatisering af scanning af objektbeholderafbildninger på tværs af udviklings- og udrulningslivscyklussen sikrer omfattende registrering af sårbarheder og håndhævelse af politikker. Ved at scanne tidligt, scanne ofte og implementere automatiseret afhjælpning kan organisationer opretholde sikre containerimplementeringer uden at ofre udviklingshastigheden. Den næste enhed undersøger, hvordan man fortolker og prioriterer advarsler fra sikkerhedsscannerværktøjer.