Fix IP in ProvaService.ts and Add PUBLIC_URL

Signed-off-by: Rodrigo Martins <rodrigo.sousa.577@gmail.com>

src/server/services/ProvaService.ts

@@ -6,8 +6,10 @@ import * as fs from 'fs/promises';
 import * as path from 'path';
 import { execSync } from 'child_process';
 import { BlockchainService } from './BlockchainService';
+import { ipDetectionMiddleware } from '../middleware/ipDetection';
 import { FileValidator } from './FileValidator';
 import { ReportGenerator } from './ReportGenerator'; // Adicionar import
+import { Request, Response } from 'express'; // Importar Request e Response
 
 // Tentativa de importar o MetadataCollector com fallback
 let MetadataCollectorClass;
@@ -66,9 +68,12 @@ export class ProvaService {
       // 2. Coletar metadados avançados (com tratamento de erro)
       let enhancedMetadata;
       try {
+        // Garantir que estamos usando o IP real do cliente
+        const clientIP = this.extractRealClientIP(metadata.ipAddress, metadata);
+        
         enhancedMetadata = await this.metadataCollector.collectMetadata({
           userAgent: metadata.userAgent,
-          ipAddress: metadata.ipAddress || '0.0.0.0',
+          ipAddress: clientIP,
           timestamp: new Date(metadata.timestamp),
           fileName: file.originalname,
           fileModified: metadata.modification_times ? new Date(parseInt(metadata.modification_times)) : undefined,
@@ -99,14 +104,21 @@ export class ProvaService {
       const processedFile = await this.processFileByType(file);
 
       // 6. Gerar URL de verificação
-      const verificationUrl = `${process.env.BACKEND_URL || 'http://localhost:5000'}/verificar/${checksums.sha256}`;
+      const verificationUrl = `${process.env.PUBLIC_URL || 'http://localhost:5000'}/verificar/${checksums.sha256}`;
 
       // 7. Gerar relatório
       const reportResult = await this.reportGenerator.generateReport({
         file,
         checksums,
         timestamp,
-        metadata: enhancedMetadata,
+        metadata: {
+          ...enhancedMetadata,
+          // Garantir que as informações de IP estejam disponíveis
+          ipAddress: enhancedMetadata.ipAddress,
+          headers: metadata.headers,
+          connectionInfo: metadata.connectionInfo,
+          clientPort: metadata.clientPort
+        },
         processedFile,
         verificationUrl
       });
@@ -147,6 +159,75 @@ export class ProvaService {
     }
   }
 
+  /**
+   * Extrai o endereço IP real do cliente, ignorando IPs locais quando possível
+   * @param ipAddress O endereço IP fornecido na requisição
+   * @param metadata Metadados adicionais para análise
+   * @returns O endereço IP real do cliente
+   */
+  private extractRealClientIP(ipAddress: string, metadata?: any): string {
+    // Verificar se temos dados válidos para trabalhar
+    if (!metadata) {
+      return ipAddress || '0.0.0.0';
+    }
+
+    console.log('Tentando extrair IP real. IP original:', ipAddress);
+    
+    // Lista de IPs locais/internos que devem ser evitados
+    const localIPs = ['::1', '127.0.0.1', 'localhost', '::ffff:127.0.0.1', '::ffff:10.15.0.1'];
+    
+    // Verificar PRIMEIRO os headers HTTP que são a fonte mais confiável em produção
+    if (metadata.headers) {
+      // Headers comuns que podem conter o IP real
+      if (metadata.headers['x-forwarded-for']) {
+        const forwardedIps = metadata.headers['x-forwarded-for'].split(',').map(ip => ip.trim());
+        if (forwardedIps.length > 0 && !localIPs.includes(forwardedIps[0])) {
+          console.log('Usando IP do x-forwarded-for:', forwardedIps[0]);
+          return forwardedIps[0];
+        }
+      }
+      
+      // Outros headers comuns
+      const otherHeaders = ['x-real-ip', 'cf-connecting-ip', 'true-client-ip'];
+      for (const header of otherHeaders) {
+        if (metadata.headers[header] && !localIPs.includes(metadata.headers[header])) {
+          console.log(`Usando IP do header ${header}:`, metadata.headers[header]);
+          return metadata.headers[header];
+        }
+      }
+    }
+    
+    // Verificar nas informações de conexão
+    if (metadata.connectionInfo && metadata.connectionInfo.forwardedIp) {
+      if (!localIPs.includes(metadata.connectionInfo.forwardedIp)) {
+        console.log('Usando IP encaminhado da conexão:', metadata.connectionInfo.forwardedIp);
+        return metadata.connectionInfo.forwardedIp;
+      }
+    }
+    
+    // Se o IP não é local, usá-lo
+    if (ipAddress && !localIPs.includes(ipAddress)) {
+      console.log('Usando IP original:', ipAddress);
+      return ipAddress;
+    }
+    
+    // Se chegamos aqui, temos apenas IPs locais. Usar o IP com a porta como identificador
+    const port = metadata.clientPort || 
+                metadata.connectionInfo?.socketPort || 
+                metadata.porta;
+                
+    if (port) {
+      const ipWithPort = `${ipAddress || '127.0.0.1'}:${port}`;
+      console.log('Usando identificador IP:porta:', ipWithPort);
+      return ipWithPort;
+    }
+    
+    // NUNCA retornar 0.0.0.0 - se nada funcionar, usar 127.0.0.1 com timestamp
+    const fallbackIp = `127.0.0.1:${Date.now() % 10000}`;
+    console.log('Usando fallback:', fallbackIp);
+    return fallbackIp;
+  }
+
   private generateChecksums(buffer: Buffer) {
     return {
       sha256: createHash('sha256').update(buffer).digest('hex'),
@@ -166,8 +247,15 @@ export class ProvaService {
       // 2. Obter tempo NTP do servidor oficial para maior confiabilidade
       let ntpTime = '';
       try {
-        // Usar servidores NTP confiáveis para obter tempo preciso
-        ntpTime = execSync('w32tm /stripchart /computer:time.nist.gov /samples:1 /dataonly').toString();
+        // Detectar plataforma e usar o comando apropriado
+        if (process.platform === 'win32') {
+          // Windows
+          ntpTime = execSync('w32tm /stripchart /computer:time.nist.gov /samples:1 /dataonly').toString();
+        } else {
+          // Linux/Unix/MacOS - usar implementação alternativa
+          // Tentar usar o comando 'date' para obter a hora do sistema
+          ntpTime = execSync('date -u +"%Y-%m-%dT%H:%M:%S.%3NZ"').toString().trim();
+        }
       } catch (e) {
         console.warn('Não foi possível obter tempo NTP, usando tempo local:', e);
       }
@@ -190,7 +278,16 @@ export class ProvaService {
       };
     } catch (error) {
       console.error('Erro ao criar timestamp local:', error);
-      throw new Error(`Falha ao criar timestamp: ${error.message}`);
+      // Em caso de erro, retornar um timestamp básico sem interromper o processo
+      const basicTimestamp = {
+        hash,
+        timestamp: new Date().toISOString(),
+        ntpReference: 'Indisponível (erro)',
+        unixTimestamp: Math.floor(Date.now() / 1000),
+        error: error.message
+      };
+      
+      return basicTimestamp;
     }
   }
 
@@ -211,7 +308,7 @@ export class ProvaService {
     return file.buffer;
   }
 
-  async verifyFile(hash: string) {
+  async verifyFile(hash: string, ipInfo?: any) {
     try {
       // 1. Buscar prova no banco de dados
       const prova = await prisma.prova.findFirst({
@@ -249,6 +346,16 @@ export class ProvaService {
       // 4. Ler o timestamp
       const timestampData = JSON.parse(await fs.readFile(timestampPath, 'utf-8'));
 
+      // 5. Se fornecido, incluir informações de IP no registro
+      if (ipInfo) {
+        // Registrar essa verificação
+        try {
+          await this.logVerification(hash, ipInfo);
+        } catch (logError) {
+          console.error('Erro ao registrar verificação:', logError);
+        }
+      }
+
       return {
         verified: true,
         message: 'Arquivo verificado com sucesso',
@@ -261,6 +368,43 @@ export class ProvaService {
     }
   }
 
+  // Método para registrar verificações
+  private async logVerification(hash: string, ipInfo: any) {
+    try {
+      const verificationLog = {
+        timestamp: new Date().toISOString(),
+        hash,
+        ip: ipInfo.ip || '127.0.0.1',
+        porta: ipInfo.porta || '0',
+        userAgent: ipInfo.userAgent || 'Desconhecido'
+      };
+      
+      const logPath = path.join(this.storageDir, `${hash}_verifications.json`);
+      
+      // Verificar se o arquivo já existe
+      let existingLogs = [];
+      try {
+        const existingData = await fs.readFile(logPath, 'utf-8');
+        existingLogs = JSON.parse(existingData);
+        if (!Array.isArray(existingLogs)) {
+          existingLogs = [];
+        }
+      } catch (e) {
+        // Arquivo não existe, criar novo
+      }
+      
+      // Adicionar nova verificação
+      existingLogs.push(verificationLog);
+      
+      // Salvar arquivo
+      await fs.writeFile(logPath, JSON.stringify(existingLogs, null, 2));
+      
+      console.log(`Verificação registrada para ${hash} de IP ${ipInfo.ip}`);
+    } catch (error) {
+      console.error('Erro ao registrar verificação:', error);
+    }
+  }
+
   // Novo método para registrar informações forenses
   private async logForensicInfo(file: Express.Multer.File, metadata: any, checksums: any) {
     try {
@@ -295,3 +439,43 @@ export class ProvaService {
     }
   }
 }
+
+// No handler de upload de arquivo:
+export const uploadProva = async (req: Request, res: Response) => {
+  try {
+    const file = req.file;
+    if (!file) {
+      return res.status(400).json({ error: 'Nenhum arquivo enviado' });
+    }
+
+    // Coletar todas as informações possíveis sobre o cliente
+    const metadata = {
+      ipAddress: req.ip, // Express geralmente fornece isso
+      remoteAddress: req.socket?.remoteAddress, // Endereço IP direto do socket
+      porta: req.socket?.remotePort?.toString(), // Porta de conexão do cliente
+      userAgent: req.headers['user-agent'],
+      headers: req.headers, // Todos os headers HTTP
+      timestamp: new Date().toISOString(),
+      // Outros metadados do formulário
+      ...req.body
+    };
+
+    console.log('Metadados de conexão:', {
+      ip: req.ip,
+      remoteAddress: req.socket?.remoteAddress,
+      remotePort: req.socket?.remotePort,
+      headers: {
+        'x-forwarded-for': req.headers['x-forwarded-for'],
+        'x-real-ip': req.headers['x-real-ip']
+      }
+    });
+
+    const provaService = new ProvaService();
+    const result = await provaService.processFile(file, metadata);
+
+    return res.status(200).json(result);
+  } catch (error) {
+    console.error('Erro ao processar upload de prova:', error);
+    return res.status(500).json({ error: error.message });
+  }
+};