@maestro-ai/cli 1.0.0

package/content/prompts/seguranca/rate-limiting.md

@@ -0,0 +1,356 @@
+# Prompt: Rate Limiting e Throttling
+
+> **Prioridade**: 🔴 CRÍTICA  
+> **Aplicável a**: Todos os projetos com APIs expostas
+
+---
+
+## Por que é Crítico?
+
+Rate limiting protege seu sistema contra:
+- **DDoS e ataques de força bruta**
+- **Abuso de API** (scraping, spam)
+- **Esgotamento de recursos** (CPU, memória, banco)
+- **Custos inesperados** (APIs pagas, cloud billing)
+- **Degradação de serviço** para usuários legítimos
+
+---
+
+## Algoritmos de Rate Limiting
+
+| Algoritmo | Comportamento | Melhor Para |
+|-----------|---------------|-------------|
+| **Fixed Window** | Conta requests em janelas fixas (ex: por minuto) | APIs simples, fácil de implementar |
+| **Sliding Window Log** | Janela deslizante precisa | Precisão, mas alto uso de memória |
+| **Sliding Window Counter** | Híbrido: precisão + eficiência | Maioria dos casos |
+| **Token Bucket** | Tokens recarregam gradualmente, permite bursts | APIs que toleram picos curtos |
+| **Leaky Bucket** | Processa em taxa constante, descarta excesso | Suavizar tráfego, filas |
+
+---
+
+## Prompt Base
+
+```text
+Atue como engenheiro de segurança e performance.
+
+Preciso implementar rate limiting para:
+- API: [DESCREVA: ex. REST API pública de e-commerce]
+- Endpoints críticos: [LISTE: ex. /login, /checkout, /api/*]
+- Tráfego esperado: [ex. 1000 req/min normal, picos de 5000]
+- Tipos de cliente: [AUTENTICADO/ANÔNIMO/API_KEY/OAUTH]
+
+Stack: [ex. Node.js + Express + Redis / Python + FastAPI]
+
+Gere implementação completa com:
+
+1. **Algoritmo recomendado** e justificativa
+
+2. **Limites por tier**
+   - Anônimo: X req/min
+   - Autenticado free: Y req/min
+   - Autenticado premium: Z req/min
+   - API Key: W req/min
+
+3. **Limites específicos por endpoint**
+   - /login: mais restrito (proteção brute force)
+   - /search: menos restrito
+   - /checkout: moderado
+
+4. **Headers de resposta** (RFC 6585)
+   - X-RateLimit-Limit
+   - X-RateLimit-Remaining
+   - X-RateLimit-Reset
+   - Retry-After (quando 429)
+
+5. **Armazenamento** (Redis patterns)
+   - Schema de keys
+   - TTL
+
+6. **Bypasses seguros**
+   - Health checks
+   - Requests internos
+   - IPs whitelisted
+
+7. **Resposta 429** com:
+   - Mensagem clara
+   - Retry-After header
+   - Link para documentação de limites
+
+8. **Testes automatizados**
+```
+
+---
+
+## Padrões Obrigatórios
+
+### Headers de Resposta
+
+```http
+HTTP/1.1 200 OK
+X-RateLimit-Limit: 100
+X-RateLimit-Remaining: 95
+X-RateLimit-Reset: 1640000000
+```
+
+```http
+HTTP/1.1 429 Too Many Requests
+X-RateLimit-Limit: 100
+X-RateLimit-Remaining: 0
+X-RateLimit-Reset: 1640000000
+Retry-After: 60
+Content-Type: application/json
+
+{
+  "error": "rate_limit_exceeded",
+  "message": "Too many requests. Please retry after 60 seconds.",
+  "documentation_url": "https://api.example.com/docs/rate-limits",
+  "limit": 100,
+  "remaining": 0,
+  "reset_at": "2024-01-01T12:01:00Z"
+}
+```
+
+---
+
+## Limites Recomendados por Contexto
+
+### APIs Públicas
+
+| Tier | Limite | Janela |
+|------|--------|--------|
+| Anônimo | 60 req | 1 min |
+| Free | 100 req | 1 min |
+| Pro | 1000 req | 1 min |
+| Enterprise | 10000 req | 1 min |
+
+### Endpoints Sensíveis
+
+| Endpoint | Limite | Janela | Justificativa |
+|----------|--------|--------|---------------|
+| `/login` | 5 | 1 min | Brute force protection |
+| `/password-reset` | 3 | 15 min | Anti-abuse |
+| `/register` | 10 | 1 hora | Spam accounts |
+| `/search` | 30 | 1 min | Resource intensive |
+| `/export` | 5 | 1 hora | Heavy operation |
+
+---
+
+## Exemplo: Sliding Window Counter (Node.js + Redis)
+
+```typescript
+import { Redis } from 'ioredis';
+import { Request, Response, NextFunction } from 'express';
+
+const redis = new Redis();
+
+interface RateLimitConfig {
+  windowMs: number;      // Janela em ms
+  maxRequests: number;   // Máximo de requests na janela
+  keyPrefix?: string;    // Prefixo para a key
+}
+
+interface RateLimitInfo {
+  limit: number;
+  remaining: number;
+  reset: number;
+}
+
+function getClientIdentifier(req: Request): string {
+  // Prioridade: API Key > User ID > IP
+  const apiKey = req.headers['x-api-key'] as string;
+  if (apiKey) return `apikey:${apiKey}`;
+  
+  const userId = (req as any).user?.id;
+  if (userId) return `user:${userId}`;
+  
+  const ip = req.ip || req.headers['x-forwarded-for'] || 'unknown';
+  return `ip:${ip}`;
+}
+
+export function rateLimit(config: RateLimitConfig) {
+  const { windowMs, maxRequests, keyPrefix = 'ratelimit' } = config;
+  const windowSec = Math.ceil(windowMs / 1000);
+
+  return async (req: Request, res: Response, next: NextFunction) => {
+    const clientId = getClientIdentifier(req);
+    const now = Date.now();
+    const windowStart = Math.floor(now / windowMs) * windowMs;
+    const key = `${keyPrefix}:${clientId}:${windowStart}`;
+
+    try {
+      // Incrementar contador atomicamente
+      const current = await redis.incr(key);
+      
+      // Definir TTL apenas na primeira request da janela
+      if (current === 1) {
+        await redis.expire(key, windowSec + 1);
+      }
+
+      const remaining = Math.max(0, maxRequests - current);
+      const resetTime = Math.ceil((windowStart + windowMs) / 1000);
+
+      // Adicionar headers
+      res.setHeader('X-RateLimit-Limit', maxRequests);
+      res.setHeader('X-RateLimit-Remaining', remaining);
+      res.setHeader('X-RateLimit-Reset', resetTime);
+
+      if (current > maxRequests) {
+        const retryAfter = Math.ceil((windowStart + windowMs - now) / 1000);
+        res.setHeader('Retry-After', retryAfter);
+        
+        return res.status(429).json({
+          error: 'rate_limit_exceeded',
+          message: `Too many requests. Please retry after ${retryAfter} seconds.`,
+          limit: maxRequests,
+          remaining: 0,
+          reset_at: new Date(resetTime * 1000).toISOString()
+        });
+      }
+
+      next();
+    } catch (error) {
+      // Em caso de falha do Redis, permitir request (fail-open)
+      console.error('Rate limit error:', error);
+      next();
+    }
+  };
+}
+
+// Uso com diferentes limites
+const apiLimiter = rateLimit({ windowMs: 60000, maxRequests: 100 });
+const loginLimiter = rateLimit({ windowMs: 60000, maxRequests: 5, keyPrefix: 'login' });
+const searchLimiter = rateLimit({ windowMs: 60000, maxRequests: 30, keyPrefix: 'search' });
+
+app.use('/api/', apiLimiter);
+app.post('/login', loginLimiter, loginHandler);
+app.get('/search', searchLimiter, searchHandler);
+```
+
+---
+
+## Exemplo: Token Bucket para Bursts
+
+```typescript
+interface TokenBucketConfig {
+  bucketSize: number;        // Capacidade máxima
+  refillRate: number;        // Tokens adicionados por segundo
+  keyPrefix?: string;
+}
+
+export function tokenBucket(config: TokenBucketConfig) {
+  const { bucketSize, refillRate, keyPrefix = 'tokenbucket' } = config;
+
+  return async (req: Request, res: Response, next: NextFunction) => {
+    const clientId = getClientIdentifier(req);
+    const key = `${keyPrefix}:${clientId}`;
+    const now = Date.now();
+
+    // Lua script para operação atômica
+    const luaScript = `
+      local key = KEYS[1]
+      local now = tonumber(ARGV[1])
+      local bucketSize = tonumber(ARGV[2])
+      local refillRate = tonumber(ARGV[3])
+      
+      local bucket = redis.call('HMGET', key, 'tokens', 'last_refill')
+      local tokens = tonumber(bucket[1]) or bucketSize
+      local lastRefill = tonumber(bucket[2]) or now
+      
+      -- Calcular tokens recarregados
+      local elapsed = (now - lastRefill) / 1000
+      local refilled = math.min(bucketSize, tokens + (elapsed * refillRate))
+      
+      if refilled >= 1 then
+        -- Consumir 1 token
+        redis.call('HMSET', key, 'tokens', refilled - 1, 'last_refill', now)
+        redis.call('EXPIRE', key, 3600)
+        return {1, math.floor(refilled - 1), bucketSize}
+      else
+        return {0, 0, bucketSize}
+      end
+    `;
+
+    const result = await redis.eval(luaScript, 1, key, now, bucketSize, refillRate) as number[];
+    const [allowed, remaining, limit] = result;
+
+    res.setHeader('X-RateLimit-Limit', limit);
+    res.setHeader('X-RateLimit-Remaining', remaining);
+
+    if (!allowed) {
+      const retryAfter = Math.ceil((1 - remaining) / refillRate);
+      res.setHeader('Retry-After', retryAfter);
+      
+      return res.status(429).json({
+        error: 'rate_limit_exceeded',
+        message: `Too many requests. Retry after ${retryAfter} seconds.`
+      });
+    }
+
+    next();
+  };
+}
+
+// Permite burst de 10, recarrega 2 tokens/segundo
+app.use('/api/', tokenBucket({ bucketSize: 10, refillRate: 2 }));
+```
+
+---
+
+## Prompt: Revisar Rate Limiting Existente
+
+```text
+Tenho este código de rate limiting implementado:
+[COLE O CÓDIGO]
+
+Analise:
+1. O algoritmo está correto?
+2. Há condições de corrida (race conditions)?
+3. Os limites são apropriados para [CONTEXTO]?
+4. O que acontece se o Redis falhar?
+5. Sugira melhorias de segurança e performance.
+```
+
+---
+
+## Prompt: Rate Limiting para Microserviços
+
+```text
+Tenho uma arquitetura de microserviços com:
+- API Gateway (entrada única)
+- Serviços: [auth, orders, payments, notifications]
+- Comunicação interna via [gRPC/HTTP/mensageria]
+
+Stack: [DESCREVA]
+
+Projete uma estratégia de rate limiting que:
+1. Limite no gateway (proteção global)
+2. Limite por serviço (proteção granular)
+3. Propague limites entre serviços
+4. Trate rate limiting distribuído (múltiplas instâncias)
+5. Inclua circuit breaker para dependências lentas
+```
+
+---
+
+## Checklist de Implementação
+
+- [ ] Algoritmo escolhido e justificado
+- [ ] Limites definidos por tier de usuário
+- [ ] Limites específicos para endpoints sensíveis
+- [ ] Headers X-RateLimit-* em todas as respostas
+- [ ] Resposta 429 com Retry-After
+- [ ] Armazenamento distribuído (Redis)
+- [ ] Bypass para health checks e IPs internos
+- [ ] Fail-open em caso de falha do Redis
+- [ ] Logs de rate limiting para análise
+- [ ] Alertas quando limites são atingidos frequentemente
+- [ ] Documentação de limites para desenvolvedores
+- [ ] Testes automatizados
+
+---
+
+## Referências
+
+- [RFC 6585 - 429 Too Many Requests](https://tools.ietf.org/html/rfc6585)
+- [Stripe Rate Limiting](https://stripe.com/docs/rate-limits)
+- [Redis Rate Limiting Patterns](https://redis.io/commands/incr#pattern-rate-limiter)

package/content/prompts/seguranca/revisao-lgpd.md

@@ -0,0 +1,227 @@
+# Prompt: Revisão de Conformidade LGPD/GDPR
+
+> **Quando usar**: Projetos com dados pessoais de brasileiros ou europeus
+> **Especialista**: [Segurança da Informação](../../02-especialistas/Especialista%20em%20Segurança%20da%20Informação.md)
+> **Nível**: Médio
+
+---
+
+## Fluxo de Contexto
+
+Antes de usar este prompt, tenha em mãos:
+- `docs/CONTEXTO.md` - Entendimento do projeto
+- `docs/04-modelo/modelo-dominio.md` - Entidades com dados pessoais
+- Lista de tipos de dados coletados
+
+Após gerar, salve o resultado em:
+- `docs/09-seguranca/lgpd-compliance.md`
+
+---
+
+## Prompt Completo
+
+```text
+Atue como especialista em privacidade e proteção de dados (DPO).
+
+## Contexto do Projeto
+
+[COLE O CONTEÚDO DE docs/CONTEXTO.md]
+
+## Tipos de Dados Coletados
+
+Liste todos os dados pessoais:
+- [ ] Nome, CPF, RG
+- [ ] Email, telefone
+- [ ] Endereço
+- [ ] Dados de pagamento
+- [ ] Geolocalização
+- [ ] Cookies e tracking
+- [ ] Dados de saúde
+- [ ] Dados biométricos
+- [ ] Outros: [especificar]
+
+## Titulares dos Dados
+
+- Quem são: [clientes, funcionários, fornecedores]
+- Quantidade estimada: [volume de registros]
+- Localização: [Brasil, UE, outros]
+
+## Finalidades do Tratamento
+
+Para que os dados são usados:
+- [ ] Cadastro e login
+- [ ] Processamento de pedidos
+- [ ] Marketing direto
+- [ ] Analytics e melhoria do produto
+- [ ] Obrigações legais
+- [ ] Outros: [especificar]
+
+## Compartilhamento de Dados
+
+- Terceiros: [processadores de pagamento, analytics, email marketing]
+- Transferência internacional: [sim/não, para onde]
+
+---
+
+## Sua Missão
+
+Realize uma análise completa de conformidade LGPD:
+
+### 1. Inventário de Dados Pessoais
+
+| Dado | Categoria | Base Legal | Finalidade | Retenção | Armazenamento |
+|------|-----------|------------|------------|----------|---------------|
+| [Nome] | Identificação | Contrato | Cadastro | [período] | [local] |
+
+### 2. Análise de Bases Legais (Art. 7º LGPD)
+
+Para cada tratamento, justifique a base legal:
+
+| Tratamento | Base Legal | Justificativa |
+|------------|------------|---------------|
+| [ex: Cadastro] | Execução de contrato | Necessário para prestar o serviço |
+| [ex: Newsletter] | Consentimento | Opt-in explícito no cadastro |
+| [ex: Retenção fiscal] | Obrigação legal | Lei 9.613 (5 anos) |
+
+### 3. Direitos dos Titulares (Art. 18º)
+
+Como o sistema atende cada direito:
+
+| Direito | Implementado | Como Exercer |
+|---------|--------------|--------------|
+| Confirmação de tratamento | [Sim/Não/Parcial] | [descrição] |
+| Acesso aos dados | [Sim/Não/Parcial] | [descrição] |
+| Correção | [Sim/Não/Parcial] | [descrição] |
+| Anonimização/bloqueio | [Sim/Não/Parcial] | [descrição] |
+| Portabilidade | [Sim/Não/Parcial] | [descrição] |
+| Eliminação | [Sim/Não/Parcial] | [descrição] |
+| Revogação de consentimento | [Sim/Não/Parcial] | [descrição] |
+
+### 4. Avaliação de Risco de Privacidade
+
+| Risco | Probabilidade | Impacto | Nível | Mitigação |
+|-------|---------------|---------|-------|-----------|
+| Vazamento de dados | [1-5] | [1-5] | [P*I] | [ação] |
+| Uso indevido | [1-5] | [1-5] | [P*I] | [ação] |
+| Retenção excessiva | [1-5] | [1-5] | [P*I] | [ação] |
+
+### 5. Checklist de Conformidade Técnica
+
+#### Coleta de Dados
+- [ ] Política de privacidade clara e acessível
+- [ ] Consentimento com opt-in (não opt-out)
+- [ ] Coleta apenas de dados necessários (minimização)
+- [ ] Checkbox de aceite desvinculado de outros termos
+
+#### Armazenamento
+- [ ] Dados criptografados em repouso
+- [ ] Acesso restrito por necessidade
+- [ ] Logs de acesso a dados sensíveis
+- [ ] Backup criptografado
+
+#### Compartilhamento
+- [ ] Contratos com operadores (Art. 39)
+- [ ] Cláusulas de proteção de dados
+- [ ] Transferência internacional com salvaguardas
+
+#### Retenção e Eliminação
+- [ ] Política de retenção documentada
+- [ ] Processo de eliminação automática
+- [ ] Anonimização quando possível
+
+### 6. Relatório de Impacto (RIPD)
+
+Se aplicável (tratamento de alto risco):
+- Necessidade e proporcionalidade
+- Riscos aos titulares
+- Medidas de mitigação
+- Parecer do encarregado
+
+### 7. Plano de Ação
+
+| Ação | Prioridade | Responsável | Prazo |
+|------|------------|-------------|-------|
+| [ação] | [Alta/Média/Baixa] | [quem] | [quando] |
+
+### 8. Templates de Documentos
+
+Gere drafts de:
+- Política de Privacidade
+- Termo de Consentimento
+- Processo de atendimento a titulares
+```
+
+---
+
+## Exemplo de Uso
+
+```text
+Atue como especialista em privacidade e proteção de dados (DPO).
+
+## Contexto do Projeto
+
+App de delivery de comida. Clientes fazem pedidos, restaurantes recebem e entregadores fazem a entrega.
+
+## Tipos de Dados Coletados
+
+- [x] Nome, CPF
+- [x] Email, telefone
+- [x] Endereço
+- [x] Dados de pagamento (tokenizado via Stripe)
+- [x] Geolocalização (para entregas)
+- [x] Cookies e tracking
+
+## Titulares dos Dados
+
+- Clientes (consumidores finais)
+- Entregadores (parceiros)
+- Restaurantes (PJ, mas com dados de representantes)
+- Volume: ~10.000 clientes, ~500 entregadores
+
+## Finalidades
+
+- [x] Cadastro e login
+- [x] Processamento de pedidos
+- [x] Marketing direto (promoções)
+- [x] Analytics
+
+## Compartilhamento
+
+- Stripe (pagamentos)
+- Google Analytics
+- Firebase (push notifications)
+```
+
+---
+
+## Resposta Esperada (Resumo)
+
+### Gaps Críticos Identificados
+
+| # | Gap | Risco | Ação |
+|---|-----|-------|------|
+| 1 | Sem política de privacidade | Alto | Criar e publicar |
+| 2 | Geolocalização sem consentimento específico | Alto | Adicionar opt-in |
+| 3 | Sem processo para exclusão de conta | Médio | Implementar feature |
+| 4 | Analytics sem anonimização | Médio | Configurar IP anonymization |
+
+### Cronograma Sugerido
+
+- **Semana 1**: Política de privacidade + termos
+- **Semana 2**: Consentimento granular (geolocalização, marketing)
+- **Semana 3**: Feature de exclusão de conta
+- **Semana 4**: Revisão de terceiros e contratos
+
+---
+
+## Checklist Pós-Geração
+
+- [ ] Inventário de dados pessoais completo
+- [ ] Base legal identificada para cada tratamento
+- [ ] Direitos dos titulares mapeados
+- [ ] Gaps de conformidade identificados
+- [ ] Avaliação de risco realizada
+- [ ] Checklist técnico verificado
+- [ ] RIPD elaborado (se alto risco)
+- [ ] Plano de ação priorizado
+- [ ] Salvar em `docs/09-seguranca/lgpd-compliance.md`