Logging, Monitoring e AppSec Pipeline

A09:2021 — Security Logging and Monitoring Failures

OWASP AppSensor

AppSensor define pontos de detecção e resposta para ataques em tempo real:

Categorias de detecção:
  - RE: Request Exception (parâmetros inválidos, payload anormal)
  - AE: Authentication Exception (tentativas de login, brute force)
  - ACE: Access Control Exception (tentativas de acesso não autorizado)
  - IE: Injection Exception (SQLi, XSS detectados)
  - ME: Malicious Execution (RCE detectado)

Resposta automática:
  - Log: Registrar o evento
  - Alert: Notificar time de segurança
  - Block: Bloquear IP/usuário temporariamente
  - Disable: Desabilitar conta do usuário
  - Throttle: Reduzir taxa de requisições

Audit Logs

# Exemplo de audit logging estruturado
import json
import datetime

def audit_log(event_type, user_id, resource, action, result, ip_address):
    log_entry = {
        "timestamp": datetime.datetime.utcnow().isoformat(),
        "event_type": event_type,
        "user_id": user_id,
        "resource": resource,
        "action": action,
        "result": result,        # success / failure
        "ip_address": ip_address,
        "user_agent": get_user_agent(),
        "correlation_id": get_correlation_id()
    }
    # Enviar para sistema de logging centralizado
    send_to_siem(json.dumps(log_entry))

# Uso
audit_log("AUTH_LOGIN", user.id, "/api/login", "LOGIN", "FAILURE", request.remote_addr)

SIEM (Security Information and Event Management)

Soluções populares:
  - Wazuh (open source)
  - Elastic Security (ELK Stack)
  - Splunk
  - QRadar (IBM)
  - Sentinel (Microsoft)

Correlação de eventos:
  - Múltiplas falhas de login (brute force)
  - Acesso a recurso sensível fora do horário
  - Execução de comando suspeito
  - Anomalia de tráfego (exfiltração de dados)

ELK Stack (Elasticsearch, Logstash, Kibana)

# Filebeat — coleta logs da aplicação
filebeat.inputs:
  - type: log
    paths:
      - /var/log/app/*.log
    fields:
      app: "minha-aplicacao"

output.elasticsearch:
  hosts: ["localhost:9200"]
  index: "app-logs-%{+yyyy.MM.dd}"

Detection Rules

Exemplos de regras de detecção Wazuh/Sigma:

Título: Múltiplas Falhas de Login
Regra: 5+ falhas de login no mesmo usuário em 1 minuto
Ação: Bloquear IP por 15 minutos, alertar time SOC

Título: SQL Injection Detectado
Regra: WAF marca requisição como SQLi
Ação: Log detalhado, bloquear IP, notificar desenvolvedor

OWASP Cheat Sheets

Cheat Sheet	Conteúdo
REST Security	Autenticação, rate limiting, versionamento, HATEOAS
Docker Security	Imagens mínimas, non-root, read-only FS, secrets
Kubernetes Security	RBAC, PodSecurityPolicy, network policies
GraphQL Security	Depth limiting, query cost analysis, introspection off
JSON Web Token	Algoritmos seguros, expiração, audience validation
File Upload	Extensão, tamanho, content-type, scanning
Input Validation	Allowlist, encoding, canonicalization

REST Security

GET /api/v1/users HTTP/1.1
Host: api.exemplo.com
Authorization: Bearer eyJhbGciOiJIUzI1NiIs...
X-API-Key: abc123

# Rate limiting
X-RateLimit-Limit: 100
X-RateLimit-Remaining: 45
X-RateLimit-Reset: 1700000000

GraphQL Security

# Query maliciosa (deep nesting → DoS)
query {
  user(id: 1) {
    posts {
      comments {
        user {
          posts {
            comments {
              user { name }
            }
          }
        }
      }
    }
  }
}

# Mitigação: query depth limit (máx 6 níveis)
# Mitigação: query cost analysis (peso por campo)
# Mitigação: rate limiting por IP/API key
# Mitigação: introspection desabilitada em produção

AppSec Pipeline

SAST (Static Application Security Testing)

# Semgrep — regras customizáveis de SAST
semgrep --config=auto .
semgrep --config=p/python .
semgrep --config= r/javascript.react.security .
semgrep -c rules/sql-injection.yaml src/

# SonarQube — análise contínua de qualidade + segurança
sonar-scanner \
  -Dsonar.projectKey=meu_projeto \
  -Dsonar.sources=. \
  -Dsonar.host.url=http://localhost:9000 \
  -Dsonar.login=TOKEN

DAST (Dynamic Application Security Testing)

# OWASP ZAP — DAST automático
zap.sh -daemon -port 8081
zap-cli quick-scan -s all http://meuapp.test

# Burp Suite Professional — Scan automatizado
burpsuite --scan --url=http://meuapp.test --output=report.xml

SCA (Software Composition Analysis)

# OWASP Dependency-Check
dependency-check --project "App" --scan . --format HTML

# Snyk
snyk test --severity-threshold=high

# Trivy
trivy fs --scanners vuln .

Pipeline Integrado

# .github/workflows/appsec.yml
name: AppSec Pipeline
on: [push, pull_request]
jobs:
  appsec:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: SAST — Semgrep
        run: semgrep --config=auto --error .

      - name: SCA — Dependency Check
        run: dependency-check --project App --scan .

      - name: DAST — ZAP Scan (staging)
        run: |
          zap.sh -daemon -port 8081
          zap-cli quick-scan http://staging.app.test

Bug Bounty

Plataformas:
  - HackerOne
  - Bugcrowd
  - Intigriti
  - YesWeHack

Programas VDP (Vulnerability Disclosure Program):
  - Google VRP
  - Microsoft Bounty
  - Meta Bug Bounty

Report Template:
  Título: [Tipo] — Componente — Impacto
  Severidade: Critical / High / Medium / Low
  Descrição: O que ocorre e onde
  Passos para reproduzir: 1, 2, 3
  Impacto: O que um atacante pode fazer
  Prova de conceito: curl, screenshot, vídeo
  Recomendação: Como corrigir

Lab: Configurando AppSec Pipeline

# 1. SAST com Semgrep no projeto
semgrep --config=auto --error .

# 2. SCA com Trivy
trivy fs --scanners vuln .

# 3. Verificar logs da aplicação (estrutura)
cat /var/log/app/application.log | ConvertFrom-Json

# 4. Simular detecção de brute force
# Monitorar log de autenticação para múltiplas falhas
Get-Content /var/log/auth.log | Select-String "Failed password" | Group-Object {$_ -split ' ' | Select -Last 1} | Where-Object Count -gt 5

# 5. Verificar OWASP Cheat Sheets
# https://cheatsheetseries.owasp.org/

Logging sem monitoramento é inútil. AppSec pipeline (SAST + DAST + SCA) deve ser parte do CI/CD, não um processo separado. Bug bounty é a camada final — testadores reais encontram o que scanners automatizados não detectam.