Como usar o OWASP ZAP para varreduras automáticas de segurança

1. Introdução ao OWASP ZAP e seu papel na segurança de aplicações

O OWASP ZAP (Zed Attack Proxy) é uma ferramenta de teste de segurança de aplicações web mantida pela Open Web Application Security Project. Sua relevância no ecossistema de segurança para desenvolvedores reside em sua capacidade de identificar vulnerabilidades comuns como SQL Injection, Cross-Site Scripting (XSS) e configurações incorretas de segurança, tudo de forma automatizada e integrada a pipelines de desenvolvimento.

A diferença fundamental entre varredura manual e automática está na profundidade versus eficiência. A varredura manual permite que um especialista explore vulnerabilidades complexas de lógica de negócio, enquanto a automática, como a oferecida pelo ZAP, é ideal para detectar vulnerabilidades conhecidas de forma rápida e repetível. O ZAP oferece três modos principais de operação: Spider (rastreamento de URLs), Active Scan (envio de payloads ofensivos) e Passive Scan (análise de tráfego sem modificação). Além disso, o modo headless permite execução sem interface gráfica, essencial para automação.

2. Instalação e configuração inicial do ZAP

A instalação via Docker é a abordagem mais recomendada para automação, pois elimina dependências do sistema operacional e garante consistência entre ambientes. Execute:

docker pull owasp/zap2docker-stable
docker run -d -p 8080:8080 -p 8090:8090 --name zap owasp/zap2docker-stable zap.sh -daemon -port 8080 -host 0.0.0.0 -config api.disablekey=true

Para configuração de proxy e integração com navegadores headless, utilize:

# Configurando Chrome headless para usar o ZAP como proxy
chrome_options = webdriver.ChromeOptions()
chrome_options.add_argument('--proxy-server=http://127.0.0.1:8080')
chrome_options.add_argument('--headless')
chrome_options.add_argument('--no-sandbox')

O ajuste de contexto de aplicação é crítico para varreduras precisas. Defina o escopo com URLs permitidas e credenciais de autenticação:

# Configuração de contexto via API REST
curl -X POST "http://localhost:8080/JSON/context/action/newContext" \
  -d "contextName=MinhaApp"

curl -X POST "http://localhost:8080/JSON/context/action/includeInContext" \
  -d "contextName=MinhaApp&regex=https://minhaapp.com.br/.*"

3. Varreduras passivas vs. ativas: entendendo os riscos

A varredura passiva analisa requisições e respostas sem modificar nenhum dado, identificando headers inseguros, cookies sem flags Secure/HttpOnly e informações expostas em comentários HTML. Exemplo de alerta comum:

Alerta: Cookie sem flag HttpOnly
URL: https://minhaapp.com.br/login
Evidência: Set-Cookie: sessionId=abc123; Path=/
Solução: Adicionar ; HttpOnly; Secure ao cookie

A varredura ativa envia payloads maliciosos para detectar SQL Injection, XSS e CSRF. Exemplo de execução via API:

curl "http://localhost:8080/JSON/ascan/action/scan" \
  -d "url=https://minhaapp.com.br/&recurse=true&inScopeOnly=true&scanPolicyName=Default%20Policy"

Estratégias para balancear profundidade com tempo de execução incluem:
- Usar varredura passiva primeiro para identificar endpoints críticos
- Executar varredura ativa apenas em URLs no escopo definido
- Configurar thread count para evitar sobrecarga do servidor alvo

4. Automatizando varreduras com a API REST do ZAP

Habilite a API REST protegida por chave no modo daemon:

docker run -d -p 8080:8080 owasp/zap2docker-stable \
  zap.sh -daemon -port 8080 -config api.key=minhachave123

Exemplos de requisições cURL para iniciar Spider, Active Scan e exportar relatórios:

# Iniciar Spider
curl "http://localhost:8080/JSON/spider/action/scan" \
  -d "url=https://minhaapp.com.br/&maxChildren=10&recurse=true&contextName=MinhaApp"

# Verificar progresso do Spider
curl "http://localhost:8080/JSON/spider/view/status?scanId=0"

# Iniciar Active Scan após Spider
curl "http://localhost:8080/JSON/ascan/action/scan" \
  -d "url=https://minhaapp.com.br/&recurse=true"

# Exportar relatório HTML
curl "http://localhost:8080/OTHER/core/other/htmlreport/" \
  -o relatorio_zap.html

Script de automação básico em Python para pipeline CI/CD:

import requests
import time

ZAP_API_KEY = "minhachave123"
ZAP_BASE_URL = "http://localhost:8080"

def iniciar_varredura(url_alvo):
    # Iniciar Spider
    spider_response = requests.get(
        f"{ZAP_BASE_URL}/JSON/spider/action/scan/",
        params={"url": url_alvo, "apikey": ZAP_API_KEY}
    )
    spider_id = spider_response.json()["scan"]

    # Aguardar conclusão do Spider
    while True:
        status = requests.get(
            f"{ZAP_BASE_URL}/JSON/spider/view/status/",
            params={"scanId": spider_id, "apikey": ZAP_API_KEY}
        ).json()["status"]
        if status == "100":
            break
        time.sleep(5)

    # Iniciar Active Scan
    ascan_response = requests.get(
        f"{ZAP_BASE_URL}/JSON/ascan/action/scan/",
        params={"url": url_alvo, "recurse": True, "apikey": ZAP_API_KEY}
    )
    return ascan_response.json()

resultado = iniciar_varredura("https://minhaapp.com.br/")
print(f"Varredura iniciada: {resultado}")

5. Integração com pipelines CI/CD (GitHub Actions, GitLab CI, Jenkins)

Exemplo de job no GitHub Actions com execução do ZAP em container Docker:

name: Varredura de Segurança com OWASP ZAP

on:
  push:
    branches: [main, develop]

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

      - name: Iniciar ZAP em modo daemon
        run: |
          docker run -d --name zap -p 8080:8080 \
            owasp/zap2docker-stable \
            zap.sh -daemon -port 8080 -host 0.0.0.0 \
            -config api.disablekey=true
          sleep 10

      - name: Executar varredura automática
        run: |
          curl "http://localhost:8080/JSON/spider/action/scan" \
            -d "url=https://staging.minhaapp.com.br/&recurse=true"
          sleep 30
          curl "http://localhost:8080/JSON/ascan/action/scan" \
            -d "url=https://staging.minhaapp.com.br/&recurse=true"
          sleep 60
          curl "http://localhost:8080/OTHER/core/other/htmlreport/" \
            -o relatorio_zap.html

      - name: Falhar pipeline se alertas críticos encontrados
        run: |
          python3 -c "
          import json, requests
          alerts = requests.get(
              'http://localhost:8080/JSON/core/view/alerts/',
              params={'baseurl': 'https://staging.minhaapp.com.br/'}
          ).json()['alerts']
          criticos = [a for a in alerts if a['risk'] in ['High', 'Critical']]
          if criticos:
              print(f'ERRO: {len(criticos)} alertas críticos encontrados')
              exit(1)
          "

Para integração com GitHub Code Scanning, utilize o formato SARIF:

# Exportar relatório SARIF
curl "http://localhost:8080/OTHER/core/other/sarifreport/" \
  -o results.sarif

# Upload para GitHub
- name: Upload SARIF
  uses: github/codeql-action/upload-sarif@v2
  with:
    sarif_file: results.sarif

6. Interpretação de relatórios e priorização de correções

O relatório HTML do ZAP organiza alertas por severidade (Critical, High, Medium, Low, Informational). Cada alerta contém:

Alerta: SQL Injection
Risk: High
URL: https://minhaapp.com.br/produto?id=1
Evidência: 1' OR '1'='1
Solução: Use prepared statements com parâmetros vinculados
CWE: 89
WASC: 19

Para filtrar falsos positivos, crie regras de exclusão no contexto:

# Excluir URLs de logout da varredura ativa
curl "http://localhost:8080/JSON/context/action/excludeFromContext" \
  -d "contextName=MinhaApp&regex=.*logout.*"

# Desabilitar regra específica (ex: verificação de charset)
curl "http://localhost:8080/JSON/ascan/action/disableScanners" \
  -d "ids=10027"

A priorização baseada em OWASP Risk Rating considera:
- Impacto: Dano potencial (financeiro, reputacional, legal)
- Probabilidade: Facilidade de exploração e exposição do vetor

Exemplo de matriz de priorização:

Severidade | Impacto | Probabilidade | Prioridade
Critical   | Alto    | Alta          | Corrigir imediatamente
High       | Alto    | Média         | Corrigir em 24h
Medium     | Médio   | Alta          | Corrigir no próximo sprint
Low        | Baixo   | Baixa         | Documentar e monitorar

7. Boas práticas e limitações em ambientes de produção

Cuidados essenciais ao executar varreduras ativas:

# Configurar rate limiting para evitar bloqueio pelo WAF
curl "http://localhost:8080/JSON/ascan/action/setOptionMaxResultsToList" \
  -d "maxResults=100"

curl "http://localhost:8080/JSON/ascan/action/setOptionDelayInMs" \
  -d "delay=200"

# Usar autenticação para acessar áreas protegidas
curl "http://localhost:8080/JSON/authentication/action/setAuthenticationMethod" \
  -d "contextName=MinhaApp&authMethodName=formBasedAuth&authMethodConfigParams=loginUrl=https://minhaapp.com.br/login&loginRequestData=username={%username%}&password={%password%}"

Estratégias para ambientes sensíveis:

# Executar varredura em staging, não em produção
# Usar dados de teste, não reais
# Configurar timeout para evitar loops infinitos
curl "http://localhost:8080/JSON/ascan/action/setOptionMaxScanDurationInMins" \
  -d "maxDuration=30"

Limitações importantes do ZAP:
- Varreduras cegas: Não detecta vulnerabilidades que exigem múltiplas etapas ou contexto de sessão complexo
- Vulnerabilidades de lógica de negócio: Não identifica falhas como "comprar item por preço errado" ou "acessar dados de outro usuário"
- Testes manuais complementares: Sempre necessários para cenários que exigem criatividade humana e compreensão do domínio

Referências