Seguranca de Producao

Alem das camadas de seguranca ja implementadas (documentadas em Seguranca), a plataforma ProCases possui uma arquitetura de seguranca avancada planejada para o ambiente de producao.

Roadmap de Seguranca

┌─────────────────────────────────────────────────────────────────┐
│                    CAMADA EDGE (CDN)                              │
│  • Cloudflare WAF    • DDoS Protection    • Turnstile CAPTCHA   │
└─────────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────────┐
│                  CAMADA APLICACAO (Avancada)                      │
│  • IP Blacklist    • Rate Limiting Customizado    • Circuit Break│
└─────────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────────┐
│                  DETECCAO E PREVENCAO                             │
│  • Security Scan Detector    • Brute Force Protection           │
│  • Device Fingerprinting     • Fraud Detection                  │
└─────────────────────────────────────────────────────────────────┘

Cloudflare WAF

Web Application Firewall gerenciado pelo Cloudflare, posicionado na borda da rede antes de qualquer requisicao chegar aos servidores.

Funcionalidades:

Bloqueio automatico de ataques OWASP Top 10
Regras customizadas para bloquear padroes suspeitos
Geo-blocking por pais (se necessario)
Challenge pages para trafego suspeito

Configuracao planejada:

Cloudflare → Nginx (reverse proxy) → API (NestJS)

Modo: Full (Strict) SSL
Security Level: High
Bot Fight Mode: On
Managed Rules: OWASP Core Ruleset

DDoS Protection

Protecao contra ataques distribuidos de negacao de servico.

Camadas de protecao:

Camada	Protecao	Onde
L3/L4	Protecao de rede (TCP/UDP flood)	Cloudflare
L7	Protecao de aplicacao (HTTP flood)	Cloudflare + Rate Limiting
Aplicacao	Rate limiting por IP/usuario/acao	NestJS Throttler

Mitigacao:

Rate limiting progressivo (short → medium → long)
Challenge CAPTCHA automatico sob carga
Bloqueio de ranges de IP maliciosos
Under Attack Mode (Cloudflare) para situacoes criticas

Cloudflare Turnstile (CAPTCHA)

CAPTCHA invisible/managed para proteger acoes criticas sem degradar a experiencia do usuario.

Onde sera aplicado:

Acao	Tipo de Challenge
Login Steam	Managed (invisivel na maioria)
Deposito	Managed
Saque	Interactive (obrigatorio)
Abertura de caixa rapida (>5/min)	Managed
Criar batalha	Managed

Implementacao planejada:

typescript

// src/infrastructure/security/turnstile.service.ts
@Injectable()
export class TurnstileService {
  async verify(token: string, ip: string): Promise<boolean> {
    const response = await fetch(
      'https://challenges.cloudflare.com/turnstile/v0/siteverify',
      {
        method: 'POST',
        body: JSON.stringify({
          secret: this.config.turnstileSecretKey,
          response: token,
          remoteip: ip,
        }),
      },
    );
    const data = await response.json();
    return data.success === true;
  }
}

Variavel de ambiente:

bash

TURNSTILE_SECRET_KEY=your-turnstile-secret-key
TURNSTILE_SITE_KEY=your-turnstile-site-key

IP Blacklist

Sistema de bloqueio de IPs maliciosos usando Redis Set para lookup O(1).

Funcionalidades planejadas:

Blacklist manual (admin) e automatica (deteccao)
Whitelist para IPs confiados
TTL configuravel por entrada
Bloqueio por IP individual ou range CIDR
Logs de bloqueios para auditoria

Implementacao planejada:

typescript

// src/infrastructure/security/ip-blacklist.service.ts
@Injectable()
export class IpBlacklistService {
  private readonly BLACKLIST_KEY = 'security:ip:blacklist';
  private readonly WHITELIST_KEY = 'security:ip:whitelist';

  async isBlacklisted(ip: string): Promise<boolean> {
    if (await this.redis.sismember(this.WHITELIST_KEY, ip)) {
      return false;
    }
    return this.redis.sismember(this.BLACKLIST_KEY, ip);
  }

  async addToBlacklist(ip: string, reason: string, ttlSeconds?: number): Promise<void> {
    await this.redis.sadd(this.BLACKLIST_KEY, ip);
    if (ttlSeconds) {
      await this.redis.expire(`${this.BLACKLIST_KEY}:${ip}`, ttlSeconds);
    }
    await this.auditService.log('IP_BLACKLISTED', { ip, reason });
  }
}

Middleware planejado:

typescript

// Aplicado globalmente via NestMiddleware
@Injectable()
export class IpBlacklistMiddleware implements NestMiddleware {
  async use(req: Request, res: Response, next: NextFunction) {
    const ip = getClientIp(req);
    if (await this.blacklistService.isBlacklisted(ip)) {
      throw new ForbiddenException('Access denied');
    }
    next();
  }
}

Rate Limiting Avancado

Alem do ThrottlerModule basico ja implementado, o rate limiting avancado adiciona granularidade por acao e deteccao de abuso.

Limites planejados por acao:

Acao	Limite	Janela	Acao ao Exceder
Login	5 tentativas	15 minutos	Block + CAPTCHA
Abertura de caixa	10/minuto	Por usuario	Rate limit
Criar batalha	5/minuto	Por usuario	Rate limit
Deposito	3/hora	Por usuario	Block
Saque	2/hora	Por usuario	Block + alerta
API geral	100/minuto	Por IP	Rate limit

Implementacao planejada:

typescript

// src/infrastructure/security/rate-limiter.service.ts
@Injectable()
export class RateLimiterService {
  async checkLimit(key: string, limit: number, windowMs: number): Promise<{
    allowed: boolean;
    remaining: number;
    resetAt: Date;
  }> {
    const current = await this.redis.incr(`ratelimit:${key}`);
    if (current === 1) {
      await this.redis.pexpire(`ratelimit:${key}`, windowMs);
    }
    return {
      allowed: current <= limit,
      remaining: Math.max(0, limit - current),
      resetAt: new Date(Date.now() + windowMs),
    };
  }
}

Circuit Breaker

Padrao de resiliencia para chamadas a servicos externos (Steam API, Waxpeer, payment providers).

Comportamento:

CLOSED → (falhas > threshold) → OPEN → (timeout) → HALF-OPEN → (sucesso) → CLOSED
                                                     │
                                                     └→ (falha) → OPEN

Estados:

Estado	Comportamento
CLOSED	Requisicoes passam normalmente
OPEN	Requisicoes rejeitadas imediatamente (fail fast)
HALF-OPEN	Permite 1 requisicao de teste

Implementacao planejada:

typescript

// src/infrastructure/resilience/circuit-breaker.ts
class CircuitBreaker {
  private state: 'CLOSED' | 'OPEN' | 'HALF_OPEN' = 'CLOSED';
  private failureCount = 0;
  private lastFailureTime: number = 0;

  async execute<T>(fn: () => Promise<T>): Promise<T> {
    if (this.state === 'OPEN') {
      if (Date.now() - this.lastFailureTime > this.resetTimeout) {
        this.state = 'HALF_OPEN';
      } else {
        throw new ServiceUnavailableException('Circuit breaker is open');
      }
    }

    try {
      const result = await fn();
      this.onSuccess();
      return result;
    } catch (error) {
      this.onFailure();
      throw error;
    }
  }
}

Onde sera aplicado:

Servico	Threshold	Timeout
Steam API	5 falhas	30s
Waxpeer API	3 falhas	60s
Payment Provider	3 falhas	120s

Security Scan Detector

Middleware para detectar e bloquear scanners automaticos de vulnerabilidade (Nmap, Nikto, etc).

Padroes detectados:

User-Agent de scanners conhecidos
Paths de exploracao comuns (/wp-admin, /phpmyadmin, /.env, etc)
Velocidade de requisicao anomala
Headers malformados

Implementacao planejada:

typescript

// src/infrastructure/security/security-scan-detector.middleware.ts
@Injectable()
export class SecurityScanDetectorMiddleware implements NestMiddleware {
  private readonly SUSPICIOUS_PATHS = [
    '/wp-admin', '/wp-login', '/phpmyadmin',
    '/.env', '/.git', '/config.php',
    '/admin/config', '/debug', '/trace',
  ];

  private readonly SUSPICIOUS_UA = [
    'nikto', 'nmap', 'sqlmap', 'dirbuster',
    'gobuster', 'masscan', 'zap',
  ];

  async use(req: Request, res: Response, next: NextFunction) {
    const ua = (req.headers['user-agent'] || '').toLowerCase();
    const path = req.path.toLowerCase();

    const isSuspicious =
      this.SUSPICIOUS_UA.some(s => ua.includes(s)) ||
      this.SUSPICIOUS_PATHS.some(p => path.startsWith(p));

    if (isSuspicious) {
      await this.blacklistService.addToBlacklist(
        getClientIp(req), 'security_scan', 3600
      );
      throw new ForbiddenException();
    }

    next();
  }
}

Brute Force Protection

Protecao contra tentativas de forca bruta em endpoints de autenticacao.

Mecanismo planejado:

Contagem de tentativas falhadas por IP + por conta
Bloqueio progressivo (1min → 5min → 15min → 1h → 24h)
Alerta automatico para admin apos 10 tentativas
Reset do contador apos login bem-sucedido

Implementacao planejada:

typescript

// src/infrastructure/security/brute-force.service.ts
@Injectable()
export class BruteForceService {
  private readonly MAX_ATTEMPTS = 5;
  private readonly BLOCK_DURATIONS = [60, 300, 900, 3600, 86400]; // segundos

  async recordFailedAttempt(identifier: string): Promise<void> {
    const key = `bruteforce:${identifier}`;
    const attempts = await this.redis.incr(key);
    
    if (attempts >= this.MAX_ATTEMPTS) {
      const blockIndex = Math.min(
        Math.floor(attempts / this.MAX_ATTEMPTS) - 1,
        this.BLOCK_DURATIONS.length - 1
      );
      const blockDuration = this.BLOCK_DURATIONS[blockIndex];
      await this.redis.setex(`blocked:${identifier}`, blockDuration, '1');
    }
  }

  async isBlocked(identifier: string): Promise<boolean> {
    return (await this.redis.exists(`blocked:${identifier}`)) === 1;
  }
}

Device Fingerprinting

Identificacao de dispositivos para detectar atividade suspeita e prevenir multi-accounting.

Dados coletados:

Canvas fingerprint
WebGL renderer
Timezone + linguagem
Screen resolution
Installed plugins/fonts

Uso planejado:

Detectar multiplas contas do mesmo dispositivo
Alertar sobre login de novo dispositivo
Risk scoring para transacoes

Fraud Detection

Sistema de pontuacao de risco para detectar comportamento fraudulento.

Fatores de risco:

Fator	Pontos	Descricao
Novo IP	+10	IP nunca visto para este usuario
VPN/Proxy	+20	IP identificado como proxy
Deposito + saque rapido	+30	Saque <24h apos deposito
Multiplas contas mesmo IP	+25	Potencial multi-accounting
Padrao de apostas anomalo	+15	Desvio do comportamento historico
Device novo	+10	Fingerprint nunca visto

Acoes automaticas:

Score	Acao
0-30	Normal
31-60	CAPTCHA obrigatorio
61-80	Revisao manual de saques
81+	Conta suspensa para revisao

Checklist de Producao

A Implementar

[ ] Cloudflare WAF (regras customizadas)
[ ] DDoS protection (config Cloudflare)
[ ] Cloudflare Turnstile (CAPTCHA)
[ ] IP Blacklist service (Redis Set)
[ ] Rate limiting por acao (granular)
[ ] Circuit breaker (servicos externos)
[ ] Security scan detector (middleware)
[ ] Brute force protection (bloqueio progressivo)
[ ] Device fingerprinting
[ ] Fraud detection (risk scoring)
[ ] IP reputation checking
[ ] PCI DSS compliance (se cartao)
[ ] Penetration testing regular

Prioridade

Prioridade	Feature	Impacto
P0 (critico)	Cloudflare WAF + DDoS	Protecao base da infra
P0 (critico)	Turnstile CAPTCHA	Anti-bot em acoes criticas
P1 (alto)	IP Blacklist	Bloqueio de IPs maliciosos
P1 (alto)	Brute Force Protection	Protecao de autenticacao
P2 (medio)	Circuit Breaker	Resiliencia de servicos
P2 (medio)	Rate Limiting Granular	Protecao por acao
P3 (baixo)	Device Fingerprinting	Anti multi-accounting
P3 (baixo)	Fraud Detection ML	Deteccao avancada

Pastas Reservadas

As seguintes pastas ja estao criadas na estrutura do projeto para receber as implementacoes:

src/infrastructure/
├── security/                    # IP Blacklist, Rate Limiter, Turnstile, Scan Detector
├── resilience/                  # Circuit Breaker
└── ...

Seguranca de Producao ​

Roadmap de Seguranca ​

Cloudflare WAF ​

DDoS Protection ​

Cloudflare Turnstile (CAPTCHA) ​

IP Blacklist ​

Rate Limiting Avancado ​

Circuit Breaker ​

Security Scan Detector ​

Brute Force Protection ​

Device Fingerprinting ​

Fraud Detection ​

Checklist de Producao ​

A Implementar ​

Prioridade ​

Pastas Reservadas ​

Seguranca de Producao

Roadmap de Seguranca

Cloudflare WAF

DDoS Protection

Cloudflare Turnstile (CAPTCHA)

IP Blacklist

Rate Limiting Avancado

Circuit Breaker

Security Scan Detector

Brute Force Protection

Device Fingerprinting

Fraud Detection

Checklist de Producao

A Implementar

Prioridade

Pastas Reservadas