RFC-009: Security Standards e Compliance

Campo	Valor
Status	Draft
Author	Time de Tecnologia
Created	2026-02-05
Updated	2026-02-05
Reunião	A ser agendada
Deciders	Todo o time técnico

Status

🟡 Draft - RFC em elaboração, aguardando apresentação

Contexto e Problema

Secure coding documentado em docs/security/secure-coding.md, mas falta:

• OWASP Top 10 compliance formal e verificação
• Security scanning obrigatório no CI/CD
• Vulnerability management process
• Penetration testing cadence
• Security training obrigatório para devs

Por que resolver isso agora?

• Ataques cibernéticos aumentando
• Compliance pode ser requerido por clientes
• Vulnerabilidades não são rastreadas sistematicamente
• Falta processo formal de security review
• Dependencies com vulnerabilidades conhecidas

Impacto de não resolver

• Data breach (vazamento de dados)
• Vulnerabilidades conhecidas em produção
• Multas por não-compliance
• Reputação danificada
• Custos de remediation exponenciais

Documentação relacionada: - docs/security/secure-coding.md - Práticas atuais - docs/security/secrets-management.md - Gestão de secrets - docs/security/incident-response.md - Resposta a incidentes - docs/infrastructure/iam-policies.md - Políticas IAM - docs/architecture/aws-services.md - Security groups, WAF

Proposta de Solução

Security-first approach com OWASP Top 10 compliance, scanning automático, e security training.

OWASP Top 10 Compliance

A01: Broken Access Control - ✅ RBAC (Role-Based Access Control) obrigatório - ✅ Least privilege por padrão - ✅ Verificação de permissões em cada endpoint

from fastapi import Depends, HTTPException

def require_role(required_role: str):
    async def check_role(current_user: User = Depends(get_current_user)):
        if required_role not in current_user.roles:
            raise HTTPException(status_code=403, detail="Insufficient permissions")
        return current_user
    return check_role

@router.delete("/users/{user_id}", dependencies=[Depends(require_role("admin"))])
async def delete_user(user_id: int):
    ...

A02: Cryptographic Failures - ✅ HTTPS obrigatório (TLS 1.2+) - ✅ Bcrypt para passwords (cost factor 12) - ✅ Secrets encriptados at rest (AWS Secrets Manager) - ✅ Dados sensíveis nunca em logs

A03: Injection - ✅ Prepared statements / ORM (Django ORM, SQLAlchemy) - ✅ Input validation com Pydantic - ✅ Output escaping - ✅ Parametrized queries apenas

A04: Insecure Design - ✅ Threat modeling para features críticas - ✅ Security review para mudanças arquiteturais - ✅ Princípio de least privilege

A05: Security Misconfiguration - ✅ Security headers obrigatórios - ✅ Disable debug mode em produção - ✅ Remove informações de versão em responses - ✅ CORS configurado restritivamente

from fastapi.middleware.cors import CORSMiddleware
from fastapi.middleware.trustedhost import TrustedHostMiddleware

# Security headers
@app.middleware("http")
async def add_security_headers(request: Request, call_next):
    response = await call_next(request)
    response.headers["X-Content-Type-Options"] = "nosniff"
    response.headers["X-Frame-Options"] = "DENY"
    response.headers["X-XSS-Protection"] = "1; mode=block"
    response.headers["Strict-Transport-Security"] = "max-age=31536000; includeSubDomains"
    response.headers["Content-Security-Policy"] = "default-src 'self'"
    return response

# CORS
app.add_middleware(
    CORSMiddleware,
    allow_origins=["https://seuapp.com"],  # Specific origins only
    allow_credentials=True,
    allow_methods=["GET", "POST", "PUT", "DELETE"],
    allow_headers=["*"],
)

A06: Vulnerable and Outdated Components - ✅ Dependabot ou Snyk habilitado - ✅ Dependencies atualizadas mensalmente - ✅ Security scan no CI/CD (blocker)

A07: Identification and Authentication Failures - ✅ JWT tokens com expiration curta (15 min) - ✅ Refresh tokens (7 dias) - ✅ MFA para admin accounts - ✅ Rate limiting em login (5 tentativas/min) - ✅ Account lockout após 5 falhas

A08: Software and Data Integrity Failures - ✅ Code signing - ✅ CI/CD com verificação de integridade - ✅ Verificação de checksums em downloads

A09: Security Logging and Monitoring Failures - ✅ Logging de eventos de segurança - ✅ Alertas para tentativas de ataque - ✅ Retention de logs (90 dias mínimo)

A10: Server-Side Request Forgery (SSRF) - ✅ Validação de URLs externas - ✅ Allowlist de domínios - ✅ Não seguir redirects automáticos

Security Scanning (CI/CD)

Dependabot (GitHub):

# .github/dependabot.yml
version: 2
updates:
  - package-ecosystem: "pip"
    directory: "/"
    schedule:
      interval: "weekly"
    open-pull-requests-limit: 10

  - package-ecosystem: "npm"
    directory: "/"
    schedule:
      interval: "weekly"
    open-pull-requests-limit: 10

Snyk (Vulnerability Scanning):

# .github/workflows/security.yml
name: Security Scan

on: [push, pull_request]

jobs:
  snyk:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Run Snyk to check for vulnerabilities
        uses: snyk/actions/python@master
        env:
          SNYK_TOKEN: ${{ secrets.SNYK_TOKEN }}
        with:
          command: test
          args: --severity-threshold=high --fail-on=all

      - name: Snyk monitor
        if: github.ref == 'refs/heads/main'
        run: snyk monitor

Bandit (Python Security Linter):

- name: Run Bandit
  run: |
    pip install bandit
    bandit -r app/ -f json -o bandit-report.json
    # Fail if HIGH severity issues
    bandit -r app/ -ll

npm audit (JavaScript):

- name: npm audit
  run: |
    npm audit --audit-level=high

Security Review Checklist

Para PRs críticos:

• Input validation completa
• Output escaping adequado
• Autenticação/autorização verificada
• Secrets não hardcoded
• Logs não contêm dados sensíveis
• Rate limiting adequado
• SQL injection prevented
• XSS prevented
• CSRF tokens onde necessário

Vulnerability Management

Processo:

1. Detection: Dependabot/Snyk detecta vulnerability
2. Triage (24h): Avaliar severidade e impacto
3. Fix (SLA por severidade):
4. Critical: 24h
5. High: 7 dias
6. Medium: 30 dias
7. Low: 90 dias
8. Verify: Testar fix em staging
9. Deploy: Deploy para produção
10. Document: Documentar em security log

Penetration Testing

Cadência: - Quarterly: Automated pen testing (via ferramenta) - Annually: External pen testing (firma contratada) - Ad-hoc: Após mudanças arquiteturais significativas

Scope: - Autenticação e autorização - APIs públicas - Input validation - Session management - Sensitive data handling

Security Training

Obrigatório para todos os devs: - OWASP Top 10 training (anual) - Secure coding best practices - Incident response procedures - Social engineering awareness

Rate Limiting

from slowapi import Limiter, _rate_limit_exceeded_handler
from slowapi.util import get_remote_address

limiter = Limiter(key_func=get_remote_address)
app.state.limiter = limiter
app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)

@router.post("/login")
@limiter.limit("5/minute")  # 5 requests per minute per IP
async def login(request: Request, credentials: LoginRequest):
    ...

@router.post("/api/v1/orders")
@limiter.limit("100/hour")  # 100 requests per hour per IP
async def create_order(request: Request, order: CreateOrderRequest):
    ...

WAF (Web Application Firewall)

# AWS WAF via SAM
WebACL:
  Type: AWS::WAFv2::WebACL
  Properties:
    DefaultAction:
      Allow: {}
    Rules:
      - Name: RateLimitRule
        Priority: 1
        Statement:
          RateBasedStatement:
            Limit: 2000  # requests per 5 minutes per IP
            AggregateKeyType: IP
        Action:
          Block: {}

      - Name: AWSManagedRulesCommonRuleSet
        Priority: 2
        Statement:
          ManagedRuleGroupStatement:
            VendorName: AWS
            Name: AWSManagedRulesCommonRuleSet
        OverrideAction:
          None: {}

      - Name: AWSManagedRulesKnownBadInputsRuleSet
        Priority: 3
        Statement:
          ManagedRuleGroupStatement:
            VendorName: AWS
            Name: AWSManagedRulesKnownBadInputsRuleSet
        OverrideAction:
          None: {}

Alternativas Consideradas

Opção 1: Manual security reviews apenas

Prós: - Zero custo de ferramentas - Flexível

Contras: - Não escala - Humanos erram - Inconsistente

Por que não escolhemos: Automação é essencial para detectar vulnerabilidades sistematicamente.

Opção 2: Ferramentas pagas (Veracode, Checkmarx)

Prós: - Mais completas - Melhor suporte

Contras: - Muito caras ($10k+/ano) - Snyk + Dependabot cobrem 90% dos casos

Por que não escolhemos: Custo não justificado para nosso estágio.

Análise de Impacto

Impacto Técnico

• Security scans obrigatórios no CI/CD
• PRs podem ser bloqueados por vulnerabilidades
• Rate limiting pode afetar alguns clients
• WAF pode bloquear requests legítimos (raros)

Impacto em Negócio

• ✅ Risco de breach reduzido em 80%
• ✅ Compliance com padrões de segurança
• ✅ Confiança de clientes aumentada
• ⚠️ Custo Snyk: ~$500/ano
• ⚠️ Custo pen testing: ~$5k/ano

Riscos

Risco: Falsos positivos de security scans bloqueiam desenvolvimento

Mitigação: Configuração bem ajustada, possibilidade de ignores justificados.

Plano de Implementação

Fase 1: Scanning (Semana 1)

• Configurar Dependabot
• Configurar Snyk
• Adicionar Bandit no CI/CD

Fase 2: Compliance (Semana 2-3)

• Audit OWASP Top 10 compliance
• Implementar gaps críticos
• Documentar

Fase 3: WAF (Semana 4)

• Configurar AWS WAF
• Testar em staging
• Deploy em produção

Fase 4: Training (Mês 2)

• OWASP Top 10 training session
• Security best practices workshop
• Incident response drill

Métricas de Sucesso

Após 1 mês: - ✅ Security scans rodando em todos PRs - ✅ Zero vulnerabilidades HIGH+ - ✅ WAF configurado

Após 3 meses: - ✅ OWASP Top 10 100% compliant - ✅ Time treinado em security - ✅ Vulnerability SLAs cumpridos

Referências

• OWASP Top 10
• Snyk
• AWS WAF
• Secure Coding Guidelines