Automatización del examen de imágenes de contenedor

  • 10 minutos

Las imágenes de contenedor empaquetan aplicaciones junto con todas sus dependencias, lo que las convierte en artefactos de implementación convenientes. Sin embargo, esta comodidad presenta importantes desafíos de seguridad: las vulnerabilidades en imágenes base, paquetes del sistema o dependencias de aplicaciones pueden poner en peligro los contenedores implementados. La automatización del examen de imágenes de contenedor durante todo el ciclo de vida de desarrollo e implementación garantiza que solo las imágenes seguras y compatibles lleguen a entornos de producción.

Descripción de los riesgos de seguridad de los contenedores

Las imágenes de contenedor presentan varias categorías de riesgo de seguridad:

Vulnerabilidades de la imagen base

Paquetes de sistema operativo:

  • Bibliotecas del sistema: Las imágenes base incluyen bibliotecas de sistema operativo (glibc, OpenSSL, zlib) que pueden contener vulnerabilidades.
  • Administradores de paquetes: Los administradores de paquetes del sistema (apt, yum, apk) y sus paquetes suelen tener problemas de seguridad.
  • Utilidades de shell: Las utilidades comunes (bash, curl, wget) en las imágenes base pueden tener vulnerabilidades.
  • Retraso de actualización: Las imágenes base oficiales pueden incluir paquetes obsoletos entre versiones.

Impacto en la selección de imágenes base:

  • Alpine frente a Debian: Las imágenes base de Alpine Linux son más pequeñas, pero usan bibliotecas diferentes (musl en lugar de glibc), lo que afecta a los perfiles de vulnerabilidad.
  • Imágenes sin distribución: Las imágenes sin distribución de Google solo contienen dependencias en tiempo de ejecución de la aplicación, lo que reduce drásticamente la superficie expuesta a ataques.
  • Variantes slim: Las variantes de imagen slim excluyen las utilidades comunes, lo que reduce el tamaño y la exposición a vulnerabilidades.
  • Moneda de versión: El uso latest de etiquetas puede introducir cambios inesperados; las etiquetas de versión específicas proporcionan estabilidad, pero requieren actualizaciones manuales.

Vulnerabilidades de dependencia de aplicaciones

Paquetes específicos del idioma:

  • Paquetes de npm: Node.js las aplicaciones traen cientos de dependencias de npm que pueden tener vulnerabilidades.
  • Paquetes de Python: Las aplicaciones de Python incluyen paquetes pyPI con posibles problemas de seguridad.
  • Dependencias de Java: Las dependencias de Maven y Gradle incluyen transitivamente muchos archivos JAR.
  • Paquetes .NET: Los paquetes NuGet en aplicaciones .NET pueden contener vulnerabilidades.

Dependencias transitivas:

  • Árboles de dependencia profundos: Las dependencias de la aplicación tienen sus propias dependencias, creando árboles de dependencia profundos.
  • Vulnerabilidades ocultas: Las vulnerabilidades en las dependencias transitivas son fáciles de pasar por alto sin el examen automatizado.
  • Complejidad de la actualización: La actualización de dependencias transitivas requiere comprender la compatibilidad en toda la cadena de dependencias.

Acumulación de capas de imagen

Sistema de archivos en capas:

  • Herencia de capas: Cada instrucción dockerfile crea una nueva capa y las vulnerabilidades de cualquier capa afectan a la imagen final.
  • Los archivos eliminados persisten: Los archivos eliminados en capas posteriores siguen existiendo en capas anteriores y contribuyen al tamaño de imagen y al perfil de seguridad.
  • Secretos en la historia: Los secretos accidentalmente incorporados en las primeras capas permanecen en el historial de imágenes, aunque se eliminen en capas posteriores.
  • Dependencias en tiempo de compilación: Las dependencias necesarias solo durante la compilación (compiladores, herramientas de compilación) no deben aparecer en imágenes de tiempo de ejecución finales.

Vulnerabilidades de configuración

Configuraciones incorrectas de Dockerfile:

  • En ejecución como raíz: Los contenedores que se ejecutan como usuario raíz tienen privilegios innecesarios.
  • Puertos expuestos: Los puertos expuestos innecesariamente expanden la superficie expuesta a ataques.
  • Archivos binarios de SUID: Los archivos binarios de SUID/SGID permiten ataques de escalación de privilegios.
  • Valores predeterminados no seguros: Es posible que las configuraciones predeterminadas no sigan los procedimientos recomendados de seguridad.

Enfoques de análisis de contenedores

La seguridad eficaz de los contenedores requiere el examen en varios puntos del ciclo de vida:

Escaneo del Registro

Supervisión continua del registro: Los registros de contenedor proporcionan ubicaciones centralizadas para el examen y la aplicación de directivas.

Examen de Azure Container Registry con Microsoft Defender:

  • Examen automático: Microsoft Defender para contenedores examina automáticamente las imágenes insertadas en Azure Container Registry.
  • Examen basado en desencadenadores: Examina el desencadenador en las operaciones de inserción, importación y extracción.
  • Reensayar continuamente: Las imágenes se vuelven a examinar periódicamente para detectar vulnerabilidades recién divulgadas.
  • Recomendaciones: Security Center proporciona recomendaciones de corrección para las vulnerabilidades detectadas.

Desencadenadores de examen del Registro:

  • Desencadenadores de inserción: las imágenes nuevas se examinar automáticamente cuando se envían al registro.
  • Desencadenadores de importación: Se examinan las imágenes importadas desde registros externos.
  • Desencadenadores de extracción: las imágenes se examinan en un plazo de 24 horas después de ser extraídas.
  • Volver a examinar periódicamente: Las imágenes escaneadas anteriormente se vuelven a examinar diariamente (los últimos 90 días para las imágenes insertadas, los últimos 30 días para las imágenes extraídas).

Escaneo durante la compilación

Integración de canalización de CI/CD: el examen durante las compilaciones de imágenes detecta vulnerabilidades antes de que las imágenes lleguen a los registros.

Examen de contenedores de 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)"

Examen de contenedores de Acciones de GitHub:

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

Examen de contenedores de Seguridad avanzada de GitHub: GitHub Advanced Security proporciona funcionalidades de seguridad de contenedores adicionales a través de CodeQL y análisis de dependencias.

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

Ventajas del escaneo en tiempo de construcción:

  • Fracasar rápido: impedir que las imágenes vulnerables se compilen e inserten en los registros.
  • Comentarios para desarrolladores: Proporcione comentarios inmediatos a los desarrolladores durante el proceso de compilación.
  • Cumplimiento de directivas: Aplicar directivas de seguridad antes de que las imágenes lleguen a registros o producción.
  • Validación del artefacto de compilación: asegúrese de que únicamente las imágenes compatibles progresen a través de la canalización de implementación.

Escaneo en tiempo de ejecución

Supervisión de contenedores implementada: El examen en tiempo de ejecución detecta vulnerabilidades en contenedores implementados realmente.

Controladores de admisión de Kubernetes: Los controladores de admisión aplican directivas antes de implementar contenedores en clústeres de Kubernetes.

Ejemplo de directiva de 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"
        }

Protección en tiempo de ejecución de Azure Kubernetes Service: Microsoft Defender para contenedores proporciona detección de amenazas en tiempo de ejecución:

  • Análisis de comportamiento: Supervisa el comportamiento del contenedor para detectar actividades anómalas.
  • Inteligencia sobre amenazas: Compara los comportamientos observados frente a patrones de ataque conocidos.
  • Asignación de MITRE ATT&CK: asigna las amenazas detectadas al marco de MITRE ATT&CK.
  • Generación de alertas: Genera alertas de seguridad para actividades de contenedor sospechosas.

Herramientas de examen de contenedores

Trivy (Aqua Security)

Trivy es un analizador completo de vulnerabilidades de contenedor de código abierto.

Características clave:

  • Examen completo: Examina los paquetes del sistema operativo, las dependencias de la aplicación, las configuraciones de IaC y los secretos.
  • Compatibilidad con varios formatos: Examina imágenes de contenedor, sistemas de archivos, repositorios de Git y clústeres de Kubernetes.
  • Análisis sin conexión: Puede funcionar en entornos aislados de redes con bases de datos de vulnerabilidades sin conexión.
  • Rendimiento rápido: Escáner ligero con tiempos de examen rápidos.
  • Generación SBOM: Genera la lista de materiales de software CycloneDX y SPDX.

Integración de Trivy de Azure Pipelines:

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

Contenedor de Snyk

Snyk Container proporciona el escaneo de imágenes de contenedores integrado con la plataforma enfocada en desarrolladores de Snyk.

Características clave:

  • Recomendaciones de imágenes base: Sugiere imágenes base alternativas con menos vulnerabilidades.
  • Priorización: Prioriza las vulnerabilidades en función de la vulnerabilidad y el impacto empresarial.
  • Guía de corrección: Proporciona pasos de corrección específicos para detectar vulnerabilidades.
  • Integración de Kubernetes: Examina las imágenes implementadas en clústeres de Kubernetes.

Aqua Security

Aqua Security ofrece seguridad de contenedor de nivel empresarial en todo el ciclo de vida.

Características clave:

  • Control de imágenes: Examen de imágenes completo con directivas personalizables.
  • Protección en tiempo de ejecución: Supervisa la ejecución de contenedores para detectar un comportamiento sospechoso.
  • Comprobación de cumplimiento: Valida imágenes en CIS Docker Benchmark y directivas personalizadas.
  • Seguridad de la cadena de suministro: Comprueba la procedencia de las imágenes y detecta ataques de cadena de suministro.

Anchore Engine

Anchore Engine es un analizador de imágenes de contenedor de código abierto con análisis basado en directivas.

Características clave:

  • Controlado por directivas: Motor de directivas flexible para definir reglas de seguridad y cumplimiento.
  • Inspección profunda: Analiza las capas de imagen, los paquetes y la configuración.
  • Directivas personalizadas: Defina directivas de cumplimiento y seguridad específicas de la organización.
  • Controlado por API: API REST para la integración con herramientas personalizadas.

GitHub Advanced Security

GitHub Advanced Security proporciona características de seguridad de nivel empresarial para repositorios, incluidas las funcionalidades de análisis de contenedores.

Características de seguridad del contenedor:

  • Examen de dependencias: Detecta automáticamente dependencias vulnerables en imágenes de contenedor.
  • Examen de secretos: Identifica secretos expuestos (claves de API, tokens, credenciales) en capas de contenedor y Dockerfiles.
  • Examen de código: Análisis de CodeQL de Dockerfiles y código de aplicación dentro de contenedores.
  • Avisos de seguridad: Integración con GitHub Advisory Database para la inteligencia sobre vulnerabilidades.
  • Seguridad de la cadena de suministro: Gráfico de dependencias y integración de Dependabot para las dependencias de contenedor.

Ejecución de CodeQL en contenedores: GitHub Advanced Security admite la ejecución del análisis de código codeQL en entornos de contenedor para un análisis completo:

Flujo de trabajo de análisis de contenedores de 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"

Examen de secretos para contenedores:

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

Ventajas de Seguridad avanzada de GitHub:

  • Integración nativa: Profundamente integrado con flujos de trabajo y características de seguridad de GitHub.
  • Panel unificado: Introducción a la seguridad centralizada en la pestaña Seguridad de GitHub.
  • Cumplimiento de directivas: las reglas de protección de rama pueden requerir pasar comprobaciones de seguridad.
  • Informes de cumplimiento: Informes de cumplimiento integrados para SOC 2, ISO 27001 y otros marcos.
  • Colaboración en equipo: Resultados de seguridad integrados en revisiones de solicitudes de incorporación de cambios y seguimiento de problemas.

Habilitación de GitHub Advanced Security:

Para organizaciones:

  1. Vaya a Configuración de la organización → Seguridad y análisis del código.
  2. Habilite Seguridad Avanzada de GitHub para todos los repositorios o para repositorios seleccionados.
  3. Configure las alertas de Dependabot, el escaneo de secretos y el escaneo de código.
  4. Configure directivas de seguridad y avisos de seguridad.

Para repositorios:

  1. Vaya a Configuración del repositorio → Seguridad y análisis del código.
  2. Habilite dependency graph (gratis para repositorios públicos).
  3. Habilite las alertas de Dependabot y las actualizaciones de seguridad de Dependabot.
  4. Habilite el examen de secretos (requiere la licencia de Seguridad avanzada de GitHub para repositorios privados).
  5. Habilite el análisis de código con CodeQL o herramientas de terceros.

Advanced Security para registros de contenedores:

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

Integración con las características de seguridad de GitHub:

  • Introducción a la seguridad: Panel de seguridad de toda la organización que muestra vulnerabilidades de contenedor.
  • Alertas de seguridad: Alertas automatizadas para dependencias de contenedor vulnerables.
  • Actualizaciones de Dependabot: solicitudes de incorporación de cambios automatizadas para actualizar las dependencias y las imágenes base vulnerables.
  • Integración de propietarios de código: enrutar los resultados de seguridad a los equipos adecuados a través del archivo CODEOWNERS.
  • Registros de auditoría: Complete la pista de auditoría de los eventos de seguridad y las acciones de corrección.

Procedimientos recomendados para el examen de contenedores

Implementar construcciones de varias etapas

Dependencias independientes de compilación y tiempo de ejecución:

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

Ventajas:

  • Imágenes más pequeñas: Las imágenes en tiempo de ejecución no incluyen herramientas de compilación ni artefactos intermedios.
  • Menos vulnerabilidades: Las dependencias de compilación (compiladores, SDK) no aparecen en imágenes finales.
  • Mejor rendimiento: Las imágenes más pequeñas se suben, se empujan y se ejecutan más rápido.

Uso de imágenes base mínimas

Elija las imágenes base adecuadas:

  • Alpino: Imagen base pequeña (~5 MB) con superficie de ataque mínima.
  • Sin distribución: Contiene solo dependencias de aplicación y tiempo de ejecución, sin shell ni administrador de paquetes.
  • Variantes slim: Las variantes oficiales *-slim excluyen utilidades innecesarias.
  • Versiones específicas: Use etiquetas de versión específicas en lugar de latest para la reproducibilidad.

Imagen de ejemplo 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"]

Escanea temprano y a menudo

Frecuencia de examen:

  • Estación de trabajo de desarrollador: Escanear imágenes localmente antes de confirmar su envío.
  • Validación de la solicitud de cambios: examine las canalizaciones de CI en cada solicitud de incorporación de cambios.
  • Compilaciones de rama principal: exámenes completos en las fusiones de la rama principal.
  • Admisión en los registros: Escanear imágenes antes de admitirlas en los registros.
  • Reescaneo programado: Reescanee periódicamente las imágenes almacenadas para detectar vulnerabilidades recientemente reveladas.
  • Implementación previa: Validación final antes de realizar la implementación en producción.

Implementación de puertas de seguridad

Puntos de cumplimiento de directivas:

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

Ejemplos de puerta:

  • Gravedad de vulnerabilidad: un error se crea con vulnerabilidades críticas o de gravedad alta.
  • Cumplimiento de licencias: Bloquear imágenes con licencias prohibidas.
  • Problemas de configuración: Impedir el despliegue de imágenes que se ejecutan como usuario root.
  • Detección de secretos: Error si se detectan secretos en capas de imagen.

Automatizar la remediación

Actualizaciones automatizadas:

  • Dependabot para Dockerfiles: Habilite Dependabot para actualizar las versiones de imagen base y las dependencias en Dockerfiles.
  • Recompilaciones automatizadas: configure canalizaciones para volver a compilar automáticamente imágenes cuando se actualicen las imágenes base.
  • Automatización de revisiones: Use herramientas para aplicar revisiones automáticas a imágenes base o dependencias.
  • Pruebas de canalizaciones: Asegúrese de que las actualizaciones automatizadas desencadenan pruebas completas.

Configuración de GitHub Dependabot para Docker:

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

Mantenimiento del historial de resultados del escaneo

Seguimiento y tendencias:

  • Informes centralizados: El análisis agregado da como resultado paneles centralizados.
  • Análisis de tendencias: Realice un seguimiento de los recuentos de vulnerabilidades a lo largo del tiempo para medir la posición de seguridad.
  • Auditorías de cumplimiento: Mantenga el historial de resultados del escaneo para proporcionar pruebas de cumplimiento.
  • Archivado de SBOM: archivar la lista de componentes de software para las imágenes implementadas.

Implementar la firma de imágenes

Comprobar la procedencia de la imagen:

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

Ventajas de la firma de imágenes:

  • Comprobación de la procedencia: Confirme que las imágenes se originaron en orígenes de confianza.
  • Detección de alteraciones: Detecte si las imágenes se han modificado después de la firma.
  • Cumplimiento de directivas: Implemente solo imágenes firmadas en entornos de producción.

La automatización del examen de imágenes de contenedor en todo el ciclo de vida de desarrollo e implementación garantiza la detección de vulnerabilidades completa y la aplicación de directivas. Al escanear temprano, escanear con frecuencia e implementar la remediación automatizada, las organizaciones pueden mantener despliegues seguros de contenedores sin sacrificar la velocidad de desarrollo. En la siguiente unidad se examina cómo interpretar y priorizar las alertas de las herramientas del analizador de seguridad.