Update modules/SecurityLogger.js

modules/SecurityLogger.js

@@ -1,66 +1,41 @@
-/**
- * ═══════════════════════════════════════════════════════════════════════════
- * SECURITY LOGGER - LOG DETALHADO DE OPERAÇÕES DE CYBERSECURITY
- * ═══════════════════════════════════════════════════════════════════════════
- * ✅ Registra todas as operações com timestamps
- * ✅ Armazena em database segura
- * ✅ Fornece relatórios de auditoria
- * ✅ Detecta atividade suspeita
- * ✅ Integração com alertas
- * ═══════════════════════════════════════════════════════════════════════════
- */
-
 const fs = require('fs');
 const path = require('path');
 
 class SecurityLogger {
-  constructor(config) {
+  constructor(config = {}) {
     this.config = config;
-    
-    // ═══════════════════════════════════════════════════════════════════
-    // HF SPACES: Usar /tmp para garantir permissões de escrita
-    // O HF Spaces tem sistema de arquivos somente-leitura em /
-    // ═══════════════════════════════════════════════════════════════════
-    
-    // Forçar uso de /tmp no HF Spaces (sistema read-only)
-    this.logsPath = '/tmp/akira_data/security_logs';
+
+    /**
+     * Detecta ambiente
+     * HF Spaces → filesystem root read-only
+     * Railway / Docker → usar volume persistente
+     */
+    const isHF = !!process.env.SPACE_ID;
+    const basePath = isHF
+      ? '/tmp/akira_data'
+      : process.env.DATA_PATH || path.resolve('data');
+
+    this.logsPath = path.join(basePath, 'security_logs');
     this.alertsPath = path.join(this.logsPath, 'alerts.json');
     this.opsPath = path.join(this.logsPath, 'operations.json');
-    
-    // Cria diretórios com tratamento de erro
+
     try {
-      if (!fs.existsSync(this.logsPath)) {
-        fs.mkdirSync(this.logsPath, { recursive: true });
-        console.log(`✅ SecurityLogger: Diretório criado: ${this.logsPath}`);
-      }
-    } catch (error) {
-      console.warn(`⚠️  SecurityLogger: Não foi possível criar diretório em ${this.logsPath}:`, error.message);
-      
-      // Fallback para /tmp direto
-      const tmpPath = '/tmp/security_logs';
-      try {
-        fs.mkdirSync(tmpPath, { recursive: true });
-        this.logsPath = tmpPath;
-        this.alertsPath = path.join(this.logsPath, 'alerts.json');
-        this.opsPath = path.join(this.logsPath, 'operations.json');
-        console.log(`✅ SecurityLogger: Usando fallback: ${this.logsPath}`);
-      } catch (fallbackError) {
-        console.error('❌ SecurityLogger: Erro crítico ao criar diretório:', fallbackError.message);
-        this.logsPath = null;
-      }
+      fs.mkdirSync(this.logsPath, { recursive: true });
+      console.log(`✅ SecurityLogger: Diretório ativo: ${this.logsPath}`);
+    } catch (err) {
+      console.error('❌ SecurityLogger: Falha ao criar diretório:', err.message);
+      this.logsPath = null;
     }
 
-    // Carrega logs
     this.operations = this.logsPath ? this._loadJSON(this.opsPath, []) : [];
     this.alerts = this.logsPath ? this._loadJSON(this.alertsPath, []) : [];
 
     console.log('✅ SecurityLogger inicializado');
   }
 
-  /**
-   * Registra operação de cybersecurity
-   */
   logOperation(operacao) {
+    if (!this.logsPath) return;
+
     try {
       const entry = {
         id: `${Date.now()}_${Math.random().toString(36).slice(2, 9)}`,
@@ -75,199 +50,75 @@ class SecurityLogger {
         duracao: operacao.duracao || 0
       };
 
-      // Adiciona ao log
       this.operations.push(entry);
       this._saveJSON(this.opsPath, this.operations);
 
-      // Verifica se é atividade suspeita
       if (this._isSuspicious(entry)) {
         this._createAlert(entry);
       }
 
-      console.log(`📋 [SECURITY LOG] ${entry.tipoOperacao} em ${entry.alvo}`);
+      console.log(`📋 [SECURITY] ${entry.tipoOperacao} → ${entry.alvo}`);
       return entry;
     } catch (e) {
       console.error('Erro ao logar operação:', e);
     }
   }
 
-  /**
-   * Cria alerta de atividade suspeita
-   */
   _createAlert(operacao) {
-    try {
-      const alert = {
-        id: `alert_${Date.now()}`,
-        timestamp: new Date().toISOString(),
-        severidade: 'ALTO',
-        operacaoId: operacao.id,
-        usuario: operacao.usuario,
-        descricao: `Operação suspeita: ${operacao.tipoOperacao} em ${operacao.alvo}`,
-        motivo: this._getSuspiciousReason(operacao),
-        status: 'NOVO'
-      };
-
-      this.alerts.push(alert);
-      this._saveJSON(this.alertsPath, this.alerts);
-
-      console.log(`🚨 [ALERT] ${alert.descricao}`);
-      return alert;
-    } catch (e) {
-      console.error('Erro ao criar alerta:', e);
-    }
+    const alert = {
+      id: `alert_${Date.now()}`,
+      timestamp: new Date().toISOString(),
+      severidade: 'ALTO',
+      operacaoId: operacao.id,
+      usuario: operacao.usuario,
+      descricao: `Operação suspeita: ${operacao.tipoOperacao}`,
+      motivo: this._getSuspiciousReason(operacao),
+      status: 'NOVO'
+    };
+
+    this.alerts.push(alert);
+    this._saveJSON(this.alertsPath, this.alerts);
+
+    console.log(`🚨 [SECURITY ALERT] ${alert.descricao}`);
+    return alert;
   }
 
-  /**
-   * Obtém relatório de operações
-   */
-  getOperationReport(filtros = {}) {
-    try {
-      let ops = [...this.operations];
-
-      // Filtra por usuário
-      if (filtros.usuario) {
-        ops = ops.filter(o => o.usuario === filtros.usuario);
-      }
-
-      // Filtra por tipo
-      if (filtros.tipo) {
-        ops = ops.filter(o => o.tipoOperacao === filtros.tipo);
-      }
-
-      // Filtra por período
-      if (filtros.dataInicio && filtros.dataFim) {
-        const inicio = new Date(filtros.dataInicio);
-        const fim = new Date(filtros.dataFim);
-        ops = ops.filter(o => {
-          const data = new Date(o.timestamp);
-          return data >= inicio && data <= fim;
-        });
-      }
-
-      // Agrupa por tipo
-      const porTipo = {};
-      const porRisco = {};
-
-      ops.forEach(op => {
-        porTipo[op.tipoOperacao] = (porTipo[op.tipoOperacao] || 0) + 1;
-        porRisco[op.risco] = (porRisco[op.risco] || 0) + 1;
-      });
-
-      return {
-        totalOperacoes: ops.length,
-        operacoes: ops.slice(-50), // Últimas 50
-        resumoPorTipo: porTipo,
-        resumoPorRisco: porRisco,
-        operaçõesSuspeitas: ops.filter(o => o.risco === 'ALTO' || o.risco === 'CRÍTICO').length
-      };
-    } catch (e) {
-      console.error('Erro ao gerar relatório:', e);
-      return { erro: e.message };
-    }
-  }
-
-  /**
-   * Obtém relatório de alertas
-   */
-  getAlertReport() {
-    try {
-      const alertasNovos = this.alerts.filter(a => a.status === 'NOVO');
-      const alertasResolvidos = this.alerts.filter(a => a.status === 'RESOLVIDO');
-
-      return {
-        totalAlertas: this.alerts.length,
-        alertasNovos: alertasNovos.length,
-        alertasResolvidos: alertasResolvidos.length,
-        ultimos: this.alerts.slice(-20)
-      };
-    } catch (e) {
-      return { erro: e.message };
-    }
-  }
-
-  /**
-   * Marca alerta como resolvido
-   */
-  resolveAlert(alertId) {
-    try {
-      const alert = this.alerts.find(a => a.id === alertId);
-      if (alert) {
-        alert.status = 'RESOLVIDO';
-        alert.resolvidoEm = new Date().toISOString();
-        this._saveJSON(this.alertsPath, this.alerts);
-        return true;
-      }
-      return false;
-    } catch (e) {
-      return false;
-    }
-  }
-
-  /**
-   * Detecção de atividade suspeita
-   */
   _isSuspicious(operacao) {
-    // Operações em múltiplos domínios em curto espaço
-    const recentOps = this.operations.filter(o => {
-      const timeDiff = new Date(operacao.timestamp) - new Date(o.timestamp);
-      return timeDiff < 60000; // últimos 60s
-    });
+    const recentOps = this.operations.filter(o =>
+      new Date(operacao.timestamp) - new Date(o.timestamp) < 60000
+    );
 
     if (recentOps.length > 5) return true;
-
-    // Scan agressivo
     if (operacao.tipoOperacao === 'NMAP_SCAN' && operacao.risco === 'ALTO') return true;
-
-    // Múltiplas tentativas de SQL injection
     if (operacao.tipoOperacao === 'SQLMAP_TEST' && operacao.resultado === 'VULNERÁVEL') return true;
 
-    // Breach search repetido
-    if (operacao.tipoOperacao === 'BREACH_SEARCH') {
-      const recent = recentOps.filter(o => o.tipoOperacao === 'BREACH_SEARCH');
-      if (recent.length > 3) return true;
-    }
-
     return false;
   }
 
   _getSuspiciousReason(operacao) {
-    const razoes = [];
+    const reasons = [];
 
-    if (operacao.tipoOperacao === 'NMAP_SCAN') {
-      razoes.push('Port scan detectado');
-    }
+    if (operacao.tipoOperacao === 'NMAP_SCAN') reasons.push('Port scan');
+    if (operacao.tipoOperacao === 'SQLMAP_TEST') reasons.push('SQL Injection');
+    if (operacao.risco === 'CRÍTICO') reasons.push('Risco crítico');
 
-    if (operacao.tipoOperacao === 'SQLMAP_TEST') {
-      razoes.push('Teste de SQL Injection');
-    }
-
-    if (operacao.risco === 'CRÍTICO') {
-      razoes.push('Risco crítico detectado');
-    }
-
-    return razoes.length > 0 ? razoes.join(', ') : 'Atividade incomum';
+    return reasons.join(', ') || 'Atividade incomum';
   }
 
-  /**
-   * FUNÇÕES AUXILIARES
-   */
-
-  _loadJSON(filepath, defaultValue = {}) {
+  _loadJSON(file, fallback) {
     try {
-      if (fs.existsSync(filepath)) {
-        return JSON.parse(fs.readFileSync(filepath, 'utf8'));
+      if (fs.existsSync(file)) {
+        return JSON.parse(fs.readFileSync(file, 'utf8'));
       }
-    } catch (e) {
-      console.warn(`Erro ao carregar ${filepath}:`, e);
-    }
-    return defaultValue;
+    } catch {}
+    return fallback;
   }
 
-  _saveJSON(filepath, data) {
+  _saveJSON(file, data) {
     try {
-      fs.writeFileSync(filepath, JSON.stringify(data, null, 2));
+      fs.writeFileSync(file, JSON.stringify(data, null, 2));
     } catch (e) {
-      console.error(`Erro ao salvar ${filepath}:`, e);
+      console.error(`Erro ao salvar ${file}:`, e.message);
     }
   }
 }