Integre verificações de análise de composição de software em pipelines

  • 9 minutos

A integração da Análise de Composição de Software em pipelines de CI/CD permite a segurança de dependência automatizada e contínua e a verificação de conformidade durante todo o ciclo de vida de desenvolvimento de software. Em vez de realizar avaliações de segurança uma vez antes do lançamento, o SCA integrado ao pipeline valida continuamente as dependências a cada alteração de código, detetando vulnerabilidades precocemente quando elas são mais fáceis e baratas de corrigir.

Por que integrar a SCA em gasodutos?

As abordagens de segurança tradicionais criaram padrões perigosos em que as equipes de segurança descobriram vulnerabilidades no final do desenvolvimento, quando a pressão para liberar era maior. Esse padrão resultou no envio de software vulnerável ou em esforços caros de remediação de última hora, atrasando lançamentos.

Benefícios de segurança Shift-left

Deteção precoce de vulnerabilidades:

  • Feedback imediato: Os desenvolvedores recebem notificações de vulnerabilidade em poucos minutos após a introdução de dependências vulneráveis.
  • Custos de remediação mais baixos: Corrigir vulnerabilidades durante o desenvolvimento custa significativamente menos do que corrigi-las na produção.
  • Preservação do contexto: Os desenvolvedores têm contexto completo sobre as opções de dependência quando as vulnerabilidades são descobertas imediatamente.
  • Correções incrementais: Pequenas melhorias contínuas de segurança são mais fáceis de implementar do que grandes esforços de correção.

Conformidade contínua:

  • Aplicação da política: As verificações automatizadas de pipeline impõem políticas de licença e segurança em cada commit.
  • Pistas de auditoria: Os resultados da análise do pipeline fornecem evidências de conformidade e registos de auditoria.
  • Padrões consistentes: Todas as alterações de código passam pela mesma revisão de segurança, independentemente de quem as envia.
  • Prevenção dos riscos: O bloqueio de dependências vulneráveis antes da fusão evita a acumulação de dívidas de segurança.

Velocidade de desenvolvimento:

  • Revisões automatizadas: As ferramentas SCA executam a análise de dependência automaticamente sem exigir revisões manuais da equipe de segurança.
  • Processamento paralelo: As verificações de segurança são executadas em paralelo com outras etapas de compilação, minimizando o impacto nos tempos de compilação.
  • Lançamentos mais rápidos: A validação contínua de segurança durante todo o desenvolvimento permite lançamentos mais rápidos e confiáveis.
  • Retrabalho reduzido: Detetar problemas antecipadamente descarta o retrabalho dispendioso durante a preparação da versão.

Pontos de integração de pipeline

A implementação eficaz do SCA inclui vários pontos de integração em todo o pipeline de CI/CD.

Validação de pull request

Verificações de segurança pré-mesclagem: A validação de pull request identifica dependências vulneráveis antes que elas sejam fundidas em ramificações principais, evitando o acúmulo de dívidas de segurança.

Validação de solicitação pull do Azure Pipelines:

trigger: none

pr:
  branches:
    include:
      - main
      - develop

pool:
  vmImage: "ubuntu-latest"

steps:
  - task: UseNode@1
    inputs:
      version: "18.x"
    displayName: "Install Node.js"

  - script: npm ci
    displayName: "Install dependencies"

  - task: WhiteSource@21
    inputs:
      cwd: "$(System.DefaultWorkingDirectory)"
      projectName: "$(Build.Repository.Name)"
    displayName: "Run Mend SCA scan"

  - task: PublishTestResults@2
    inputs:
      testResultsFormat: "JUnit"
      testResultsFiles: "**/test-results.xml"
    displayName: "Publish scan results"

Validação de solicitação pull do GitHub Actions:

name: Security Scan

on:
  pull_request:
    branches: [main, develop]

jobs:
  sca-scan:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Set up Node.js
        uses: actions/setup-node@v3
        with:
          node-version: "18"

      - name: Install dependencies
        run: npm ci

      - name: Run Snyk security scan
        uses: snyk/actions/node@master
        env:
          SNYK_TOKEN: ${{ secrets.SNYK_TOKEN }}
        with:
          args: --severity-threshold=high

      - name: Upload scan results
        uses: github/codeql-action/upload-sarif@v2
        if: always()
        with:
          sarif_file: snyk.sarif

Verificações do pull request:

  • Alterações de dependência: Detete quais dependências foram alteradas na solicitação pull.
  • Novas vulnerabilidades: Identificar novas vulnerabilidades introduzidas por alterações de dependência.
  • Violações de licença: Sinalize violações da política de licença antes da mesclagem.
  • Portões de qualidade: Bloqueie solicitações pull que violem políticas de segurança ou conformidade.
  • Comentários da revisão: Publique as descobertas da varredura como comentários de solicitação pull para visibilidade do revisor.

Construções de integração contínua

Verificação SCA em tempo de construção: Cada compilação de CI deve incluir a verificação SCA para validar dependências no contexto completo do aplicativo.

Integração de CI do Azure Pipelines:

trigger:
  branches:
    include:
      - main
      - develop
      - feature/*

pool:
  vmImage: "ubuntu-latest"

variables:
  buildConfiguration: "Release"

steps:
  - task: UseDotNet@2
    inputs:
      packageType: "sdk"
      version: "7.x"
    displayName: "Install .NET SDK"

  - task: DotNetCoreCLI@2
    inputs:
      command: "restore"
      projects: "**/*.csproj"
    displayName: "Restore NuGet packages"

  - task: WhiteSource@21
    inputs:
      cwd: "$(System.DefaultWorkingDirectory)"
      projectName: "$(Build.Repository.Name)"
      scanComment: "CI Build $(Build.BuildNumber)"
      checkPolicies: true
      failBuildOnPolicyViolation: true
    displayName: "Mend SCA scan with policy enforcement"

  - task: DotNetCoreCLI@2
    inputs:
      command: "build"
      projects: "**/*.csproj"
      arguments: "--configuration $(buildConfiguration)"
    displayName: "Build application"

  - task: PublishBuildArtifacts@1
    inputs:
      pathToPublish: "$(Build.ArtifactStagingDirectory)"
      artifactName: "drop"
    displayName: "Publish build artifacts"

Integração do CI do GitHub Actions:

name: CI Build

on:
  push:
    branches: [main, develop]
  workflow_dispatch:

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v3

      - name: Set up Python
        uses: actions/setup-python@v4
        with:
          python-version: "3.11"

      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          pip install -r requirements.txt

      - name: Run OWASP Dependency-Check
        uses: dependency-check/Dependency-Check_Action@main
        with:
          project: "my-application"
          path: "."
          format: "SARIF"
          args: >
            --failOnCVSS 7
            --suppression suppression.xml

      - name: Upload scan results to GitHub Security
        uses: github/codeql-action/upload-sarif@v2
        with:
          sarif_file: dependency-check-report.sarif

      - name: Build application
        run: python setup.py build

      - name: Generate SBOM
        run: |
          pip install cyclonedx-bom
          cyclonedx-py -i requirements.txt -o sbom.json

      - name: Upload SBOM artifact
        uses: actions/upload-artifact@v3
        with:
          name: sbom
          path: sbom.json

Recursos de construção de CI:

  • Verificação de dependência completa: Analise todas as dependências, incluindo dependências transitivas.
  • Aplicação da política: Rejeitar compilações que violam políticas de segurança ou conformidade.
  • Geração de SBOM: Crie componentes de lista de materiais de software para utilização a jusante.
  • Comparação da linha de base: Compare os resultados da verificação atual com compilações anteriores para detetar regressões.
  • Coleção de métricas: Acompanhe as contagens de vulnerabilidades, as taxas de correção e as pontuações de conformidade ao longo do tempo.

Verificações profundas agendadas

Análise periódica abrangente: As verificações agendadas fornecem uma análise completa sem bloquear o fluxo de trabalho do desenvolvedor.

Verificação agendada em Azure Pipelines:

schedules:
  - cron: "0 2 * * *"
    displayName: "Nightly security scan"
    branches:
      include:
        - main
    always: true

trigger: none
pr: none

pool:
  vmImage: "ubuntu-latest"

steps:
  - task: NodeTool@0
    inputs:
      versionSpec: "18.x"
    displayName: "Install Node.js"

  - script: npm ci
    displayName: "Install dependencies"

  - task: Snyk@1
    inputs:
      serviceConnectionEndpoint: "SnykConnection"
      testType: "app"
      severityThreshold: "low"
      monitorOnBuild: true
      failOnIssues: false
      projectName: "$(Build.Repository.Name)"
    displayName: "Deep Snyk scan (all severities)"

  - task: BlackDuck@1
    inputs:
      BlackDuckService: "BlackDuckConnection"
      ScanMode: "intelligent"
      DetectArguments: "--detect.policy.check.fail.on.severities ALL"
    displayName: "Black Duck comprehensive scan"

  - task: PublishBuildArtifacts@1
    inputs:
      pathToPublish: "$(Build.ArtifactStagingDirectory)/SecurityReports"
      artifactName: "SecurityReports"
    displayName: "Publish detailed scan reports"

Vantagens da verificação programada:

  • Análise minuciosa: Varredura profunda com todos os níveis de gravidade, sem interromper o desenvolvimento.
  • Nova deteção de vulnerabilidade: Detete vulnerabilidades recém-divulgadas em dependências inalteradas.
  • Relatórios abrangentes: Gere relatórios detalhados para as equipes de segurança e gerenciamento.
  • Análise de tendências: Acompanhe as mudanças de postura de segurança ao longo do tempo através de uma varredura consistente.

Validação do pipeline de liberação

Portas de segurança pré-implantação: Os pipelines de lançamento devem validar os artefatos antes de serem implantados em ambientes de produção.

Portão de lançamento do Azure Pipelines:

stages:
  - stage: Build
    jobs:
      - job: BuildJob
        steps:
          - task: DotNetCoreCLI@2
            inputs:
              command: "build"

  - stage: SecurityValidation
    dependsOn: Build
    jobs:
      - job: SCAValidation
        steps:
          - task: DownloadBuildArtifacts@0
            inputs:
              artifactName: "drop"

          - task: WhiteSource@21
            inputs:
              cwd: "$(System.ArtifactsDirectory)/drop"
              projectName: "$(Build.Repository.Name)"
              checkPolicies: true
              failBuildOnPolicyViolation: true
            displayName: "Validate artifact dependencies"

  - stage: DeployProduction
    dependsOn: SecurityValidation
    condition: succeeded()
    jobs:
      - deployment: DeployToProduction
        environment: "production"
        strategy:
          runOnce:
            deploy:
              steps:
                - task: AzureWebApp@1
                  inputs:
                    azureSubscription: "AzureConnection"
                    appName: "my-web-app"
                    package: "$(Pipeline.Workspace)/drop"

Verificações de validação de versão:

  • Verificação de artefatos: Analise artefatos compilados e imagens de contêiner antes da implantação.
  • Políticas específicas de produção: Aplique políticas de segurança mais rígidas para implantações de produção.
  • Verificação da conformidade: Verifique a conformidade da licença antes da liberação de produção.
  • Portões de aprovação: Exigir aprovação manual para implantações com riscos conhecidos, mas aceitos.

Portas de qualidade e aplicação de políticas

Definição de políticas de segurança: As ferramentas SCA impõem políticas que definem padrões aceitáveis de segurança e conformidade.

Políticas baseadas na gravidade

Compilações de bloco com base na gravidade da vulnerabilidade:

Exemplo de política Mend:

{
  "name": "Production Security Policy",
  "enabled": true,
  "rules": [
    {
      "type": "VULNERABILITY_SEVERITY",
      "action": "FAIL_BUILD",
      "minSeverity": "HIGH"
    },
    {
      "type": "VULNERABILITY_AGE",
      "action": "FAIL_BUILD",
      "maxAge": 30,
      "minSeverity": "MEDIUM"
    }
  ]
}

Esta política falha em compilações que contêm vulnerabilidades altas ou críticas e vulnerabilidades médias com mais de 30 dias.

Exemplo de política Snyk:

# .snyk policy file
version: v1.0.0
patch: {}
ignore: {}
policies:
  - severity:
      low: ignore
      medium: warn
      high: fail
      critical: fail

Políticas baseadas em licença

Fazer cumprir a conformidade da licença:

Exemplo de política de licença:

{
  "name": "License Compliance Policy",
  "enabled": true,
  "rules": [
    {
      "type": "LICENSE_TYPE",
      "action": "FAIL_BUILD",
      "deniedLicenses": ["GPL-2.0", "GPL-3.0", "AGPL-3.0"]
    },
    {
      "type": "LICENSE_TYPE",
      "action": "REQUIRE_APPROVAL",
      "approvalRequired": ["LGPL-2.1", "LGPL-3.0", "MPL-2.0"]
    }
  ]
}

Categorias da política de licença:

  • Licenças negadas: Licenças proibidas em todas as circunstâncias (copyleft forte para software proprietário).
  • Licenças com aprovação necessária: Licenças que exigem revisão legal antes do uso (copyleft fraca, licenças personalizadas).
  • Licenças permitidas: Licenças permissivas aceitáveis sem revisão (MIT, Apache 2.0, BSD).

Regras de política personalizada

Condições avançadas da apólice:

{
  "name": "Advanced Security Policy",
  "enabled": true,
  "rules": [
    {
      "type": "VULNERABILITY_CVSS_SCORE",
      "action": "FAIL_BUILD",
      "minScore": 7.0,
      "condition": "exploitMaturity == 'FUNCTIONAL' OR exploitMaturity == 'HIGH'"
    },
    {
      "type": "DEPENDENCY_AGE",
      "action": "WARN",
      "maxAge": 365,
      "message": "Dependency has not been updated in over a year"
    },
    {
      "type": "MAINTAINER_STATUS",
      "action": "WARN",
      "condition": "abandonedProject == true"
    }
  ]
}

Geração de SBOM em gasodutos

Os documentos da Lista de Materiais de Software (SBOM) fornecem um inventário abrangente de todos os componentes de software.

Gerar artefatos SBOM

Geração de SBOM do CycloneDX:

steps:
  - task: UseNode@1
    inputs:
      version: "18.x"

  - script: |
      npm ci
      npm install -g @cyclonedx/cyclonedx-npm
      cyclonedx-npm --output-file sbom.json
    displayName: "Generate CycloneDX SBOM"

  - task: PublishBuildArtifacts@1
    inputs:
      pathToPublish: "sbom.json"
      artifactName: "SBOM"

Geração SPDX SBOM:

steps:
  - script: |
      pip install spdx-tools
      pip-licenses --format=json --output-file=licenses.json
      # Convert to SPDX format using custom script
      python scripts/generate_spdx.py licenses.json sbom.spdx
    displayName: "Generate SPDX SBOM"

Casos de uso de SBO:

  • Provas de conformidade: Fornecer aos clientes ou auditores uma demonstração de transparência nas dependências.
  • Rastreamento de vulnerabilidade: Use o SBOM para determinar rapidamente se as vulnerabilidades recém-divulgadas afetam o software implantado.
  • Segurança da cadeia de abastecimento: Rastreie a proveniência do software e detete ataques à cadeia de suprimentos.
  • Conformidade com a licença: Documente todas as obrigações de licença no software implantado.

Integrações específicas de ferramentas

Mend (anteriormente WhiteSource)

Tarefa de emenda do Azure Pipelines:

- task: WhiteSource@21
  inputs:
    cwd: "$(System.DefaultWorkingDirectory)"
    projectName: "$(Build.Repository.Name)"
    checkPolicies: true
    failBuildOnPolicyViolation: true
    scanComment: "Build $(Build.BuildNumber)"
  displayName: "Mend SCA scan"

Snyk

Tarefa Snyk do Azure Pipelines:

- task: SnykSecurityScan@1
  inputs:
    serviceConnectionEndpoint: "SnykConnection"
    testType: "app"
    severityThreshold: "high"
    monitorOnBuild: true
    failOnIssues: true
  displayName: "Snyk security scan"

Verificação de dependência do OWASP

Tarefa do OWASP no Azure Pipelines:

- script: |
    wget https://github.com/jeremylong/DependencyCheck/releases/download/v8.0.0/dependency-check-8.0.0-release.zip
    unzip dependency-check-8.0.0-release.zip
    ./dependency-check/bin/dependency-check.sh \
      --project "$(Build.Repository.Name)" \
      --scan . \
      --format ALL \
      --failOnCVSS 7
  displayName: "OWASP Dependency-Check scan"

Pato Preto

Tarefa do Azure Pipelines Black Duck:

- task: BlackDuck@1
  inputs:
    BlackDuckService: "BlackDuckConnection"
    ScanMode: "intelligent"
    DetectArguments: "--detect.policy.check.fail.on.severities CRITICAL,HIGH"
  displayName: "Black Duck scan"

Práticas recomendadas para integração de pipeline

Otimize o desempenho da digitalização:

  • Varredura incremental: Use varreduras incrementais para solicitações pull, verificações completas para compilações de ramificação principal.
  • Armazenamento em cache: Resolução de dependências de cache e resultados de análise para acelerar execuções subsequentes.
  • Execução paralela: Execute verificações SCA em paralelo com outras etapas de compilação quando possível.
  • Agendamento de verificações: Execute verificações abrangentes em horários programados em vez de bloquear cada commit.

Gerencie falsos positivos:

  • Arquivos de supressão: Gerencie arquivos de supressão para falsos positivos conhecidos.
  • Políticas sensíveis ao contexto: Configure políticas considerando se o código vulnerável é realmente usado.
  • Revisão periódica: Revise periodicamente os resultados suprimidos para garantir que permaneçam falsos positivos.

Forneça feedback prático:

  • Mensagens claras: Forneça explicações claras sobre violações de políticas e etapas de correção.
  • Orientação de remediação: Link para a documentação que explica como corrigir vulnerabilidades.
  • Priorização: Classifique as descobertas por gravidade e capacidade de exploração para ajudar os desenvolvedores a priorizar.

Monitorizar e melhorar:

  • Painéis de métricas: Acompanhe as tendências de vulnerabilidade, o tempo de correção e as taxas de conformidade.
  • Formação da equipa: Treine os desenvolvedores na seleção segura de dependências e na correção de vulnerabilidades.
  • Iteração do processo: Refine continuamente as políticas e a integração com base no feedback e nas métricas da equipe.

A integração da Análise de Composição de Software em pipelines de CI/CD transforma a segurança de uma barreira de estágio final em processo de validação contínua ao longo de todo o desenvolvimento. A análise automatizada e orientada por políticas deteta vulnerabilidades antecipadamente, reforça a conformidade continuamente e fornece a base para a entrega segura de software. A próxima unidade examina ferramentas SCA específicas e como avaliar suas capacidades para as necessidades da sua organização.