Automatizando testes de segurança no pipeline: SAST, DAST, SCA e IaC

Os cinco tipos de teste de segurança automatizado

1. SAST (Static Application Security Testing)
Análise estática do código-fonte em busca de vulnerabilidades e falhas de segurança. Ferramentas como o Semgrep identificam padrões suspeitos no código, ajudando a corrigir problemas de forma proativa, antes do deploy.

2. DAST (Dynamic Application Security Testing)
Abordagem dinâmica que testa a aplicação em tempo de execução. Com o OWASP ZAP, dá para simular ataques reais e identificar vulnerabilidades de configuração de servidor, APIs expostas e pontos de entrada para invasão.

3. SCA (Software Composition Analysis)
Foca em identificar vulnerabilidades em bibliotecas e dependências de terceiros. O Dependency-Check detecta componentes com falhas conhecidas (CVEs) no seu projeto.

4. Secrets Scan
Detecta segredos expostos — chaves de API, credenciais, tokens — antes que cheguem ao histórico do repositório. O Gitleaks é a ferramenta de referência nessa categoria.

5. IaC Scan (Infrastructure as Code Scan)
Com a adoção de infraestrutura como código, garantir que as configurações estejam seguras é essencial. O Trivy verifica imagens de contêiner e arquivos de IaC em busca de vulnerabilidades.

Demonstração prática: o workflow no GitHub Actions

O projeto de referência automatiza os cinco testes num workflow com jobs independentes no GitHub Actions, gerando relatórios em JSON e SARIF como artefatos. Repositório: github.com/jmessiass/devsecops.

Foi usada uma API em Python e Flask para o estudo, mas a stack não interfere na execução dos testes nem no formato dos relatórios — o mesmo workflow pode ser adaptado para projetos em outras linguagens.

O arquivo .github/workflows/security.yml define cinco jobs: run_sast, run_sca, run_dast, run_secrets_scan e run_iac_scan:

name: Security Scan

on:
  push
jobs:
  run_sast:
    runs-on: ubuntu-latest
    container:
      image: returntocorp/semgrep

    steps:
      - name: clone application source code
        uses: actions/checkout@v3

      - name: run semgrep
        run: |
          semgrep \
            --sarif --output semgrep.sarif \
            --metrics=off \
            --config="p/default"

      - name: save report as pipeline artifact
        uses: actions/upload-artifact@v3
        with:
          name: semgrep.sarif
          path: semgrep.sarif

      - name: Download report
        uses: actions/download-artifact@v2
        with:
          name: semgrep.sarif

  run_sca:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v3
      - name: Build project with Maven
        run: mvn clean install
      - name: Depcheck
        uses: dependency-check/Dependency-Check_Action@main
        id: Depcheck
        with:
          project: 'case-devsecops'
          path: '.'
          format: 'JSON'
          out: 'depcheck'
          args: >
            --failOnCVSS 7
            --enableRetired
      - name: Upload Test results
        uses: actions/upload-artifact@master
        with:
            name: Depcheck report
            path: ${{github.workspace}}/depcheck

  run_dast:
    runs-on: ubuntu-latest

    steps:
      - name: Config docker
        uses: docker/setup-buildx-action@v1

      - name: Run api server
        run: docker run -d --publish 5000:5000 frolvlad/flask-restplus-server-example

      - name: Run owasp zap (dast)
        uses: zaproxy/action-full-scan@v0.8.0
        with:
          target: 'http://127.0.0.1:5000'

  run_secrets_scan:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
        with:
          fetch-depth: 0
      - uses: gitleaks/gitleaks-action@v2
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

  run_iac_scan:
    runs-on: ubuntu-20.04
    steps:
      - name: Checkout code
        uses: actions/checkout@v3

      - name: Run Trivy vulnerability scanner in IaC mode
        uses: aquasecurity/trivy-action@master
        with:
          scan-type: 'fs'
          ignore-unfixed: true
          format: 'sarif'
          output: 'trivy-results.sarif'
          severity: 'CRITICAL,HIGH'

      - name: Upload artifact
        uses: actions/upload-artifact@v2
        with:
          name: trivy-report
          path: 'trivy-results.sarif'

Para rodar o fluxo, basta abrir uma Pull Request para a branch main e aguardar os resultados:

Depois dos testes finalizados, os relatórios de cada ferramenta ficam disponíveis para download:

Benefícios da automação

• Agilidade: os testes rodam com frequência, sem o tempo e esforço de execução manual.
• Consistência: a execução automatizada garante que os testes rodem da mesma forma todas as vezes, aumentando a confiabilidade dos resultados.
• Precisão: a automação identifica vulnerabilidades que passariam despercebidas em revisões manuais.
• Qualidade de software: detectar e corrigir cedo contribui pra entregar software mais confiável e seguro.

Conclusão

Automatizar testes de segurança é um passo essencial para elevar a maturidade de segurança no ciclo de desenvolvimento. O projeto apresentado mostra como integrar SAST, DAST, SCA, secrets scan e IaC scan num único workflow de GitHub Actions — e o mesmo padrão vale para outras linguagens e stacks.

Vale reforçar: os relatórios gerados podem (e devem) ser importados para uma ferramenta de gestão de vulnerabilidades, como o DefectDojo, para dar visibilidade e priorizar o que precisa de tratativa por nível de criticidade.

Repositório no GitHub: github.com/jmessiass/devsecops

Referências

• OWASP DevSecOpsGuideline (GitHub)
• OWASP DevSecOps Guideline
• Semgrep
• OWASP Dependency-Check
• OWASP ZAP
• Gitleaks
• Trivy
• DefectDojo