Integrar verificações de análise de composição de software a pipelines

9 minutos

A integração da Análise de Composição de Software em pipelines de CI/CD permite verificação automatizada e contínua de segurança de dependência e conformidade em todo o ciclo de vida de desenvolvimento de software. Em vez de executar 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, capturando vulnerabilidades mais cedo quando elas são mais fáceis e menos caras de corrigir.

Por que integrar a SCA em pipelines?

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 liberação era maior. Esse padrão resultou no envio de software vulnerável ou esforços caros de correção de última hora atrasando as versões.

Benefícios de segurança Shift-left

Detecção de vulnerabilidade precoce:

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

Conformidade contínua:

Imposição de políticas: as verificações automatizadas do pipeline impõem licenças e políticas de segurança em todos os commits.
Trilhas de auditoria: os resultados da verificação do pipeline fornecem evidências de conformidade e trilhas 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 de risco: Bloquear dependências vulneráveis antes da mesclagem impede o acúmulo de dívidas de segurança.

Velocidade de desenvolvimento:

Revisões automatizadas: As ferramentas de 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 build, minimizando o impacto nos tempos de build.
Versões mais rápidas: A validação contínua de segurança em todo o desenvolvimento permite versões mais rápidas e confiantes.
Retrabalho reduzido: Detectar problemas antecipadamente elimina retrabalhos caros durante a preparação do lançamento.

Pontos de integração do pipeline

A implementação efetiva 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 detecta dependências vulneráveis antes de serem mescladas em ramificações principais, evitando a acumulação de dívidas de segurança.

Validação da solicitação de 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 da solicitação de 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 de solicitação de pull:

Alterações de dependência: Detecte quais dependências foram alteradas na solicitação de pull.
Novas vulnerabilidades: Identificar novas vulnerabilidades introduzidas por alterações de dependência.
Violações de licença: Sinalizar violações de política de licença antes da mesclagem.
Portões de qualidade: Bloquear solicitações de pull que violam políticas de segurança ou conformidade.
Comentários de revisão: publique os resultados da verificação como comentários de pull request para visibilidade do revisor.

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

verificação SCA no tempo de compilação: todas as compilações de IC devem incluir 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 de 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 build de CI:

Verificação de dependência completa: Examine todas as dependências, incluindo dependências transitivas.
Aplicação de políticas: falhar compilações que violam políticas de segurança ou conformidade.
Geração de SBOM: criar artefatos de lista de materiais de software para consumo downstream.
Comparação de linha de base: Compare os resultados atuais da verificação com os builds anteriores para detectar 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 do 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 agendada:

Análise completa: verificação profunda com todos os níveis de gravidade sem bloquear o desenvolvimento.
Nova detecção de vulnerabilidade: Detecte vulnerabilidades recentemente divulgadas em dependências inalteradas.
Relatórios abrangentes: Gere relatórios detalhados para equipes de segurança e gerenciamento.
Análise de tendência: Monitore as mudanças na postura de segurança ao longo do tempo por meio de escaneamentos consistentes.

Validação do pipeline de lançamento

Portas de segurança pré-implantação: os pipelines de lançamento devem validar artefatos antes de implantar 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 da versão:

Verificação de artefatos: Examine 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 rigorosas para implantações de produção.
Verificação de conformidade: Verifique a conformidade da licença antes da versão de produção.
Portões de aprovação: Exigir aprovação manual para implantações com riscos conhecidos, mas aceitos.

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

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

Políticas baseadas em severidade

Bloquear builds 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"
    }
  ]
}

Essa política falha nos builds que contêm vulnerabilidades altas ou críticas e vulnerabilidades médias com mais de 30 dias.

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

Garantir 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 de política de licença:

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

Regras de política personalizadas

Condições de política avançadas:

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

Os documentos de SBOM (Software Bill of Materials) 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 de SBOM SPDX:

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 do SBOM:

Evidência de conformidade: Forneça aos clientes ou auditores uma demonstração de transparência de dependência.
Acompanhamento de vulnerabilidades: Use o SBOM para determinar rapidamente se as vulnerabilidades recentemente divulgadas afetam o software implantado.
Segurança da cadeia de suprimentos: Acompanhe a procedência do software e detecte ataques da cadeia de suprimentos.
Conformidade de licença: Documente todas as obrigações de licença no software implantado.

Integrações específicas à ferramenta

Mend (anteriormente WhiteSource)

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

OWASP Dependency-Check

Tarefa OWASP do 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 pipelines

Otimizar o desempenho da verificação:

Verificação incremental: usa verificações incrementais para pull requests e verificações completas para compilações da ramificação principal.
Armazenamento em cache: armazena em cache a resolução de dependências e os resultados da verificação para acelerar as execuções subsequentes.
Execução paralela: Execute verificações de SCA em paralelo com outras etapas de build, quando possível.
Agendamento de varredura: Execute varreduras abrangentes de acordo com um cronograma em vez de bloquear cada commit.

Gerenciar falsos positivos:

Arquivos de supressão: Gerencie arquivos de supressão para falsos positivos conhecidos.
Políticas com reconhecimento de contexto: Configure políticas considerando se o código vulnerável é realmente usado.
Revisão regular: Revise periodicamente os achados suprimidos para garantir que eles permaneçam falsos positivos.

Forneça comentários acionáveis:

Mensagens claras: Forneça explicações claras sobre violações das políticas e etapas de remediação.
Diretrizes de correção: Link para a documentação explicando como corrigir vulnerabilidades.
Priorização: Classificar as descobertas por severidade e explorabilidade para ajudar os desenvolvedores a priorizar.

Monitorar e melhorar:

Painéis de métricas: Acompanhe as tendências de vulnerabilidade, o tempo de correção e as taxas de conformidade.
Educação em equipe: Treine os desenvolvedores sobre a seleção de dependência segura e a correção de vulnerabilidades.
Iteração do processo: Refinar continuamente as políticas e a integração com base nos comentários e 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 um gate de estágio final em um processo de validação contínua durante todo o desenvolvimento. A verificação automatizada, controlada por políticas, captura vulnerabilidades antecipadamente, impõe 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 funcionalidades para as necessidades da sua organização.

Comentários

Esta página foi útil?