Automatize a verificação de imagens de contêiner

  • 10 minutos

As imagens de contêiner empacotam aplicativos juntamente com todas as suas dependências, tornando-os artefatos de implantação convenientes. No entanto, essa conveniência introduz desafios de segurança significativos — vulnerabilidades em imagens base, pacotes do sistema ou dependências de aplicativos podem comprometer contêineres implantados. A automatização da digitalização de imagens de contêiner durante todo o ciclo de vida de desenvolvimento e implantação garante que apenas imagens seguras e compatíveis cheguem aos ambientes de produção.

Noções básicas sobre os riscos de segurança do contêiner

As imagens de contêiner apresentam várias categorias de risco de segurança:

Vulnerabilidades de imagem de base

Pacotes do sistema operacional:

  • Bibliotecas do sistema: As imagens base incluem bibliotecas do sistema operacional (glibc, OpenSSL, zlib) que podem conter vulnerabilidades.
  • Gerenciadores de pacotes: Os gerenciadores de pacotes do sistema (apt, yum, apk) e seus pacotes frequentemente têm problemas de segurança.
  • Utilitários Shell: Utilitários comuns (bash, curl, wget) em imagens de base podem ter vulnerabilidades.
  • Atraso na atualização: As imagens de base oficiais podem incluir pacotes desatualizados entre lançamentos.

Impacto na seleção da imagem de base:

  • Alpine vs Debian: As imagens de base do Alpine Linux são menores, mas usam bibliotecas diferentes (musl em vez de glibc), afetando os perfis de vulnerabilidade.
  • Imagens distroless: As imagens distroless do Google contêm apenas as dependências de tempo de execução do aplicativo, reduzindo drasticamente a superfície de ataque.
  • Variantes compactas: As variantes de imagem compactas excluem utilitários comuns, reduzindo o tamanho e a exposição a vulnerabilidades.
  • Moeda da versão: O uso de latest tags pode introduzir alterações inesperadas, tags de versões específicas fornecem estabilidade, mas exigem atualizações manuais.

Vulnerabilidades de dependência de aplicativos

Pacotes específicos para cada idioma:

  • Pacotes NPM: Node.js aplicativos trazem centenas de dependências do NPM que podem ter vulnerabilidades.
  • Pacotes Python: Os aplicativos Python incluem pacotes PyPI com possíveis problemas de segurança.
  • Dependências Java: As dependências Maven e Gradle incluem transitivamente muitos arquivos JAR.
  • Pacotes .NET: Os pacotes NuGet em aplicativos .NET podem conter vulnerabilidades.

Dependências transitivas:

  • Árvores de dependência profunda: As dependências de aplicativos têm suas próprias dependências, criando árvores de dependência profundas.
  • Vulnerabilidades ocultas: As vulnerabilidades nas dependências transitivas são fáceis de ignorar sem verificação automatizada.
  • Complexidade da atualização: A atualização de dependências transitivas requer a compreensão da compatibilidade em toda a cadeia de dependências.

Acumulação da camada de imagem

Sistema de arquivos em camadas:

  • Herança de camadas: Cada instrução do Dockerfile cria uma nova camada, e vulnerabilidades em qualquer camada afetam a imagem final.
  • Os arquivos excluídos persistem: Os arquivos excluídos em camadas posteriores ainda existem em camadas anteriores e contribuem para o tamanho da imagem e o perfil de segurança.
  • Segredos na história: Segredos comprometidos acidentalmente com as camadas iniciais permanecem na história da imagem, mesmo que sejam removidos em camadas posteriores.
  • Dependências em tempo de construção: As dependências necessárias apenas durante a compilação (compiladores, ferramentas de compilação) não devem aparecer nas imagens finais de tempo de execução.

Vulnerabilidades de configuração

Configurações incorretas do Dockerfile:

  • Executando como root: Os contêineres executados como usuário raiz têm privilégios desnecessários.
  • Portas expostas: As portas desnecessariamente expostas expandem a superfície de ataque.
  • Binários SUID: Os binários SUID/SGID permitem ataques de escalonamento de privilégios.
  • Padrões inseguros: As configurações padrão podem não seguir as práticas recomendadas de segurança.

Abordagens de varredura de contêineres

A segurança eficaz do contêiner requer a verificação em vários pontos do ciclo de vida:

Análise do registo

Monitorização contínua do registo: Os registros de contêiner fornecem locais centralizados para verificação e aplicação de políticas.

Análise do Registo de Contentores do Azure com o Microsoft Defender:

  • Verificação automática: O Microsoft Defender for Containers verifica automaticamente as imagens enviadas por push para o Registro de Contêiner do Azure.
  • Verificação baseada em gatilho: As varreduras são acionadas em operações push, import e pull.
  • Revarredura contínua: As imagens são periodicamente verificadas em busca de vulnerabilidades recém-divulgadas.
  • Recomendações: A Central de Segurança fornece recomendações de correção para vulnerabilidades descobertas.

Gatilhos de verificação do registro:

  • Gatilhos de pressão: Novas imagens são verificadas automaticamente quando enviadas para o registro.
  • Gatilhos de importação: As imagens importadas de registos externos são digitalizadas.
  • Acionar gatilhos: As imagens são digitalizadas no prazo de 24 horas após serem extraídas.
  • Reescan periódico: As imagens previamente verificadas são re-verificadas diariamente (últimos 90 dias para imagens enviadas, últimos 30 dias para imagens extraídas).

Verificação durante a construção

Integração de pipeline CI/CD: A varredura durante a criação das imagens identifica vulnerabilidades antes que as imagens cheguem aos registos.

Verificação de contêiner do 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)"

Verificação de contentores do 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 }}

Verificação de contêiner do GitHub Advanced Security: O GitHub Advanced Security fornece recursos adicionais de segurança de contêiner por meio do CodeQL e da verificação de dependência.

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

Benefícios da verificação em tempo de construção:

  • Falha rápida: Impeça que imagens vulneráveis sejam criadas e publicadas em repositórios.
  • Comentários dos desenvolvedores: Forneça feedback imediato aos desenvolvedores durante o processo de compilação.
  • Aplicação da política: Aplique políticas de segurança antes que as imagens cheguem aos registros ou à produção.
  • Validação de artefato de construção: Garanta que apenas imagens compatíveis progridam através do pipeline de implantação.

Verificação em tempo de execução

Monitoramento de contêiner implantado: A verificação em tempo de execução deteta vulnerabilidades em contêineres realmente implantados.

Controladores de admissão do Kubernetes: Os controladores de admissão aplicam políticas antes que os contêineres sejam implantados em clusters do Kubernetes.

Exemplo de política do 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"
        }

Proteção de tempo de execução do Serviço Kubernetes do Azure: O Microsoft Defender for Containers fornece deteção de ameaças em tempo de execução:

  • Análise comportamental: Monitora o comportamento do contêiner para detetar atividades anômalas.
  • Informações sobre ameaças: Compara comportamentos observados com padrões de ataque conhecidos.
  • Mapeamento MITRE ATT&CK: Mapeia ameaças detetadas para a estrutura MITRE ATT&CK.
  • Geração de alertas: Gera alertas de segurança para atividades suspeitas de contêineres.

Ferramentas de varredura de contêineres

Trivy (Aqua Security)

Trivy é um scanner de vulnerabilidade de contêiner de código aberto abrangente.

Principais funcionalidades:

  • Varredura abrangente: Analisa pacotes de sistema operativo, dependências de aplicações, configurações de IaC e informações sigilosas.
  • Suporte multi-formato: Analisa imagens de contentores, sistemas de ficheiros, repositórios git e clusters Kubernetes.
  • Análise offline: Pode operar em ambientes isolados com bancos de dados de vulnerabilidade offline.
  • Desempenho rápido: Scanner leve com tempos de verificação rápidos.
  • Geração de SBOM: Gera lista de materiais de software nos formatos CycloneDX e SPDX.

Integração do 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 fornece digitalização de imagens de container integrado na plataforma da Snyk focada em desenvolvedores.

Principais funcionalidades:

  • Recomendações de imagem base: Sugere imagens de base alternativas com menos vulnerabilidades.
  • Priorização: Prioriza vulnerabilidades com base na capacidade de exploração e no impacto nos negócios.
  • Orientação de correção: Fornece etapas específicas de correção para vulnerabilidades descobertas.
  • Integração com Kubernetes: Verifica imagens implantadas em clusters do Kubernetes.

Aqua Segurança

O Aqua Security oferece segurança de contentores de nível empresarial durante todo o ciclo de vida.

Principais funcionalidades:

  • Garantia de imagem: Digitalização de imagens abrangente com políticas personalizáveis.
  • Proteção de tempo de execução: Monitora a execução de contêineres em busca de comportamento suspeito.
  • Verificação da conformidade: Valida imagens em relação ao CIS Docker Benchmark e políticas personalizadas.
  • Segurança da cadeia de abastecimento: Verifica a proveniência da imagem e deteta ataques à cadeia de abastecimento.

Motor de ancoragem

O Anchore Engine é um scanner de imagem de contêiner de código aberto com análise baseada em políticas.

Principais funcionalidades:

  • Orientado por políticas: Motor de políticas flexível para definir regras de segurança e conformidade.
  • Inspeção profunda: Analisa camadas de imagem, pacotes e configuração.
  • Políticas personalizadas: Defina políticas de segurança e conformidade específicas da organização.
  • Orientado por API: API REST para integração com ferramentas personalizadas.

GitHub Advanced Security

O GitHub Advanced Security fornece recursos de segurança de nível empresarial para repositórios, incluindo recursos de verificação de contêineres.

Recursos de segurança do contêiner:

  • Varredura de dependências: Deteta automaticamente dependências vulneráveis em imagens de contentores.
  • Verificação de segredos: Identifica segredos expostos (chaves de API, tokens, credenciais) em camadas de contentor e ficheiros Docker.
  • Verificação de código: Análise CodeQL de Dockerfiles e código de aplicação dentro de contêineres.
  • Avisos de segurança: Integração com o GitHub Advisory Database para inteligência de vulnerabilidade.
  • Segurança da cadeia de abastecimento: Gráfico de dependência e integração Dependabot para dependências de contêiner.

Executando CodeQL em contêineres: O GitHub Advanced Security suporta a execução da verificação de código CodeQL em ambientes de contêiner para uma análise abrangente:

Fluxo de trabalho de verificação de contêiner 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"

Varredura secreta para contêineres:

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

Benefícios do GitHub Advanced Security:

  • Integração nativa: Profundamente integrado com fluxos de trabalho e recursos de segurança do GitHub.
  • Painel unificado: Visão geral da segurança centralizada na guia Segurança do GitHub.
  • Aplicação da política: As regras de proteção de sucursais podem exigir a aprovação em verificações de segurança.
  • Relatórios de conformidade: Relatórios de conformidade integrados para SOC 2, ISO 27001 e outras estruturas.
  • Colaboração em equipa: Descobertas de segurança integradas em revisões de solicitação pull e rastreamento de problemas.

Ativando a Segurança Avançada do GitHub:

Para as organizações:

  1. Navegue até Configurações da organização → Segurança e análise de código.
  2. Habilite a Segurança Avançada do GitHub para todos os repositórios ou para alguns repositórios.
  3. Configure alertas Dependabot, varredura secreta e verificação de código.
  4. Configure políticas de segurança e avisos de segurança.

Para repositórios:

  1. Vá para Configurações do repositório → Segurança e análise de código.
  2. Habilite o gráfico de dependência (gratuito para repositórios públicos).
  3. Habilite alertas eatualizações de segurança do Dependabot.
  4. Habilite a verificação secreta (requer licença de segurança avançada do GitHub para repositórios privados).
  5. Habilite a verificação de código com o CodeQL ou ferramentas de terceiros.

Segurança avançada para registos de contentores:

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

Integração com recursos de segurança do GitHub:

  • Visão geral de segurança: Painel de segurança em toda a organização mostrando vulnerabilidades de contêiner.
  • Alertas de segurança: Alertas automatizados para dependências de contêineres vulneráveis.
  • Atualizações do Dependabot: Solicitações pull automatizadas para atualizar imagens de base vulneráveis e dependências.
  • Integração de proprietários de código: Encaminhe as descobertas de segurança para as equipes apropriadas por meio do arquivo CODEOWNERS.
  • Logs de auditoria: Registo de auditoria completo de eventos de segurança e ações de remediação.

Práticas recomendadas para varredura de contentores

Implementar construções de vários estágios

Separe as dependências de compilação e tempo de execução:

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

Benefícios:

  • Imagens menores: As imagens de tempo de execução não incluem ferramentas de construção e artefatos intermédios.
  • Menos vulnerabilidades: As dependências de compilação (compiladores, SDKs) não aparecem nas imagens finais.
  • Melhor desempenho: Imagens menores empurram, puxam e começam mais rápido.

Use imagens de base mínimas

Escolha as imagens de base apropriadas:

  • Alpine: Imagem base leve (~5 MB) com superfície de ataque mínima.
  • Distroles: Contém apenas dependências de aplicativo e tempo de execução, sem shell ou gerenciador de pacotes.
  • Variantes finas: As variantes oficiais *-slim excluem utilitários desnecessários.
  • Versões específicas: Use tags de versão específicas em vez de latest para reprodutibilidade.

Exemplo de imagem 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"]

Escaneie cedo e com frequência

Frequência de varredura:

  • Estação de trabalho do desenvolvedor: Analise imagens localmente antes de confirmar.
  • Validação de pull request: Verificar nos pipelines de CI em cada pedido de pull.
  • A filial principal constrói: Varreduras abrangentes em fusões de filiais principais.
  • Admissão de registo: Digitalizar imagens antes de as aceitar em registos.
  • Nova verificação agendada: Analise periodicamente as imagens armazenadas em busca de vulnerabilidades recém-divulgadas.
  • Pré-implantação: Validação final antes da implantação na produção.

Implementar portas de segurança

Pontos de aplicação da política:

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

Exemplos de portões:

  • Gravidade da vulnerabilidade: Falhas em compilações com vulnerabilidades críticas ou de alta gravidade.
  • Conformidade com a licença: Bloqueie imagens com licenças proibidas.
  • Problemas de configuração: Impeça a implantação de imagens em execução como root.
  • Deteção de segredos: Ocorre uma falha se segredos forem detetados nas camadas da imagem.

Automatizar a remediação

Atualizações automatizadas:

  • Dependabot para Dockerfiles: Habilite o Dependabot para atualizar as versões e dependências da imagem base no Dockerfiles.
  • Reconstruções automatizadas: Configure pipelines para reconstruir imagens automaticamente quando as imagens base forem atualizadas.
  • Automação de patches: Use ferramentas para corrigir automaticamente imagens de base ou dependências.
  • Pipelines de teste: Garanta que as atualizações automatizadas acionem testes abrangentes.

Configuração do GitHub Dependabot para Docker:

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

Manter o histórico de resultados da verificação

Acompanhamento e tendências:

  • Relatórios centralizados: A verificação agregada resulta em painéis centralizados.
  • Análise de tendências: Rastreie as contagens de vulnerabilidade ao longo do tempo para medir a postura de segurança.
  • Auditorias de conformidade: Mantenha o histórico de resultados da verificação para obter evidências de conformidade.
  • Arquivo SBOM: Lista de materiais do software de arquivamento para imagens implantadas.

Implementar assinatura de imagem

Verifique a proveniência da imagem:

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

Benefícios da assinatura de imagem:

  • Verificação da proveniência: Confirme imagens originadas de fontes confiáveis.
  • Deteção de adulteração: Detete se as imagens foram modificadas após a assinatura.
  • Aplicação da política: Implante apenas imagens assinadas em ambientes de produção.

A automatização da verificação de imagens de contêiner em todo o ciclo de vida de desenvolvimento e implantação garante a deteção abrangente de vulnerabilidades e a aplicação de políticas. Com a varredura antecipada, a varredura frequente e a implementação de remediação automatizada, as organizações podem manter implantações de contêineres seguras sem sacrificar a velocidade de desenvolvimento. A próxima unidade examina como interpretar e priorizar alertas de ferramentas de verificação de segurança.