jerkjs 2.5.8 → 2.6.1

package/lib/admin/modules/WAFModule.js

@@ -0,0 +1,737 @@
+/**
+ * Módulo de Web Application Firewall (WAF) para la Extensión de Administración de JERK Framework
+ * Módulo personalizado para mostrar estadísticas del firewall
+ */
+
+class WAFModule {
+  /**
+   * Constructor del módulo WAF
+   * @param {Object} adminExtension - Instancia de la extensión de administración
+   */
+  constructor(adminExtension) {
+    this.adminExtension = adminExtension;
+    this.name = 'WAF Module';
+    this.description = 'Módulo para mostrar estadísticas del Web Application Firewall';
+    this.commands = ['waf-status', 'waf-stats', 'waf-blocked', 'waf-security', 'waf-block-ip', 'waf-unblock-ip', 'waf-whitelist', 'waf-blacklist', 'waf-x-headers', 'create-x-rule', 'remove-x-rule', 'save-rules', 'load-rules'];
+    
+    // Mapa para almacenar el estado de procesos interactivos
+    this.currentProcess = new Map();
+
+    // Cargar el objeto global de estadísticas del firewall
+    this.globalWAFStats = require('../../utils/globalWAFStats').globalWAFStats;
+  }
+
+  /**
+   * Manejador para los comandos del módulo WAF
+   * @param {string} command - Comando a ejecutar
+   * @param {Object} socket - Socket de la conexión
+   */
+  handleCommand(command, socket) {
+    switch (command) {
+      case 'waf-status':
+      case 'waf-stats':
+        this.showWAFStats(socket);
+        break;
+      case 'waf-blocked':
+      case 'waf-security':
+        this.showWAFBlockedStats(socket);
+        break;
+      case 'waf-block-ip':
+        this.startInteractiveProcess(socket, 'block_ip');
+        this.promptForIPBlock(socket);
+        break;
+      case 'waf-unblock-ip':
+        this.startInteractiveProcess(socket, 'unblock_ip');
+        this.promptForIPUnblock(socket);
+        break;
+      case 'waf-whitelist':
+        this.startInteractiveProcess(socket, 'whitelist_ip');
+        this.promptForWhitelist(socket);
+        break;
+      case 'waf-blacklist':
+        this.startInteractiveProcess(socket, 'blacklist_ip');
+        this.promptForBlacklist(socket);
+        break;
+      case 'waf-x-headers':
+        this.showXHeaderRules(socket);
+        break;
+      case 'create-x-rule':
+        this.startInteractiveProcess(socket, 'x_header_name');
+        this.promptForXHeaderRule(socket);
+        break;
+      case 'remove-x-rule':
+        this.listXHeaderRulesToRemove(socket);
+        break;
+      case 'save-rules':
+        this.saveRulesToFile(socket);
+        break;
+      case 'load-rules':
+        this.loadRulesFromFile(socket);
+        break;
+      default:
+        socket.write(`Comando desconocido para el módulo WAF: ${command}\n`);
+        socket.write(`Comandos disponibles: waf-status, waf-stats, waf-blocked, waf-security, waf-block-ip, waf-unblock-ip, waf-whitelist, waf-blacklist, waf-x-headers, create-x-rule, remove-x-rule, save-rules, load-rules\n\n`);
+        socket.write(`> `);
+    }
+  }
+
+  /**
+   * Muestra estadísticas generales del WAF
+   * @param {Object} socket - Socket de la conexión
+   */
+  showWAFStats(socket) {
+    const formattedRequestBytes = this.formatBytes(this.globalWAFStats.requestBytes);
+    const formattedResponseBytes = this.formatBytes(this.globalWAFStats.responseBytes);
+
+    socket.write('\n=== Estadísticas del WAF ===\n');
+    socket.write(`Solicitudes procesadas: ${this.globalWAFStats.requestsProcessed}\n`);
+    socket.write(`Solicitudes procesadas (KB): ${formattedRequestBytes}\n`);
+    socket.write(`Respuestas enviadas: ${this.globalWAFStats.responsesSent}\n`);
+    socket.write(`Respuestas enviadas (KB): ${formattedResponseBytes}\n`);
+    socket.write(`IPs en lista blanca: ${this.globalWAFStats.whitelist.size}\n`);
+    socket.write(`IPs en lista negra: ${this.globalWAFStats.blacklist.size}\n`);
+    socket.write(`Reglas de seguridad activas: ${this.globalWAFStats.securityRules.size}\n\n`);
+    socket.write(`> `);
+  }
+
+  /**
+   * Muestra estadísticas de bloqueos del WAF
+   * @param {Object} socket - Socket de la conexión
+   */
+  showWAFBlockedStats(socket) {
+    socket.write('\n=== Estadísticas de Seguridad del WAF ===\n');
+    socket.write(`IPs bloqueadas temporalmente: ${this.globalWAFStats.blockedIPs.size}\n`);
+    socket.write(`Intentos de ataque detectados: ${this.globalWAFStats.attackAttempts}\n`);
+    socket.write(`Tipos de ataques detectados: ${this.globalWAFStats.attackTypes.size}\n`);
+    socket.write(`Registros de seguridad: ${this.globalWAFStats.securityLogs.length}\n`);
+
+    // Mostrar accesos a rutas
+    if (this.globalWAFStats.routeAccesses.size > 0) {
+      socket.write('\nAccesos a rutas (Input/Output):\n');
+      for (const [route, count] of this.globalWAFStats.routeAccesses) {
+        socket.write(`  ${route}: ${count} accesos\n`);
+      }
+    } else {
+      socket.write('\nNo hay accesos a rutas registrados.\n');
+    }
+
+    // Mostrar endpoints más accedidos
+    if (this.globalWAFStats.endpointHits.size > 0) {
+      socket.write('\nEndpoints más accedidos:\n');
+
+      // Convertir el mapa a array y ordenar por número de hits
+      const sortedEndpoints = Array.from(this.globalWAFStats.endpointHits.entries())
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 10); // Mostrar top 10
+
+      for (const [endpoint, hits] of sortedEndpoints) {
+        socket.write(`  ${endpoint}: ${hits} hits\n`);
+      }
+    } else {
+      socket.write('\nNo hay datos de endpoints accedidos.\n');
+    }
+
+    socket.write('\n> ');
+  }
+
+  /**
+   * Inicia un proceso interactivo
+   * @param {Object} socket - Socket de la conexión
+   * @param {string} step - Paso del proceso
+   */
+  startInteractiveProcess(socket, step) {
+    const sessionId = this.getSessionId(socket);
+    this.currentProcess.set(sessionId, { step });
+  }
+
+  /**
+   * Solicita la IP para bloquear
+   * @param {Object} socket - Socket de la conexión
+   */
+  promptForIPBlock(socket) {
+    socket.write('\nIntroduce la IP a bloquear temporalmente (ej: 192.168.1.100):\n> ');
+  }
+
+  /**
+   * Solicita la IP para desbloquear
+   * @param {Object} socket - Socket de la conexión
+   */
+  promptForIPUnblock(socket) {
+    socket.write('\nIntroduce la IP a desbloquear (ej: 192.168.1.100):\n> ');
+  }
+
+  /**
+   * Solicita la IP para agregar a la lista blanca
+   * @param {Object} socket - Socket de la conexión
+   */
+  promptForWhitelist(socket) {
+    socket.write('\nIntroduce la IP a agregar a la lista blanca (ej: 192.168.1.100):\n> ');
+  }
+
+  /**
+   * Solicita la IP para agregar a la lista negra
+   * @param {Object} socket - Socket de la conexión
+   */
+  promptForBlacklist(socket) {
+    socket.write('\nIntroduce la IP a agregar a la lista negra (ej: 192.168.1.100):\n> ');
+  }
+
+  /**
+   * Muestra las reglas de headers X-
+   * @param {Object} socket - Socket de la conexión
+   */
+  showXHeaderRules(socket) {
+    socket.write('\n=== Reglas de Headers X- ===\n');
+    
+    if (this.globalWAFStats.xHeaderRules.size === 0) {
+      socket.write('No hay reglas de headers X- configuradas.\n\n');
+      socket.write('¿Deseas crear una nueva regla? (sí/no):\n> ');
+      // Aquí se podría implementar la lógica para crear reglas interactivamente
+      return;
+    }
+
+    socket.write(`Total de reglas: ${this.globalWAFStats.xHeaderRules.size}\n\n`);
+
+    for (const [ruleId, rule] of this.globalWAFStats.xHeaderRules) {
+      socket.write(`ID: ${ruleId}\n`);
+      socket.write(`  Header: ${rule.headerName}\n`);
+      socket.write(`  Patrón: ${rule.pattern}\n`);
+      socket.write(`  Acción: ${rule.action}\n`);
+      socket.write(`  Razón: ${rule.reason}\n\n`);
+    }
+
+    socket.write(`> `);
+  }
+
+  /**
+   * Solicita la creación de una regla de header X-
+   * @param {Object} socket - Socket de la conexión
+   */
+  promptForXHeaderRule(socket) {
+    const sessionId = this.getSessionId(socket);
+    
+    // Iniciar proceso interactivo para crear regla
+    this.currentProcess.set(sessionId, {
+      step: 'x_header_name',
+      action: 'create_rule'
+    });
+    
+    socket.write('\n=== Crear Regla de Header X- ===\n');
+    socket.write('Introduce el nombre del header X- (ej: X-Forwarded-For, X-Real-IP):\n> ');
+  }
+
+  /**
+   * Maneja la entrada del nombre del header X-
+   * @param {Object} socket - Socket de la conexión
+   * @param {string} headerName - Nombre del header
+   */
+  handleXHeaderName(socket, headerName) {
+    if (!headerName.toLowerCase().startsWith('x-')) {
+      socket.write('El nombre del header debe comenzar con "X-". Introduce un nombre válido:\n> ');
+      return;
+    }
+
+    const sessionId = this.getSessionId(socket);
+    const processState = this.currentProcess.get(sessionId);
+    processState.headerName = headerName.toLowerCase();
+    processState.step = 'x_header_pattern';
+
+    socket.write(`\nHeader seleccionado: ${headerName}\n`);
+    socket.write('Introduce el patrón para coincidir (cadena o expresión regular):\n> ');
+  }
+
+  /**
+   * Maneja la entrada del patrón para la regla X-
+   * @param {Object} socket - Socket de la conexión
+   * @param {string} pattern - Patrón para coincidir
+   */
+  handleXHeaderPattern(socket, pattern) {
+    if (!pattern) {
+      socket.write('El patrón no puede estar vacío. Introduce un patrón válido:\n> ');
+      return;
+    }
+
+    const sessionId = this.getSessionId(socket);
+    const processState = this.currentProcess.get(sessionId);
+    processState.pattern = pattern;
+    processState.step = 'x_header_action';
+
+    socket.write(`\nPatrón: ${pattern}\n`);
+    socket.write('Selecciona la acción a tomar:\n');
+    socket.write('1. block - Bloquear solicitudes que coincidan\n');
+    socket.write('2. log - Registrar solicitudes que coincidan\n');
+    socket.write('3. monitor - Monitorear solicitudes que coincidan\n');
+    socket.write('Escribe el número o el nombre de la acción:\n> ');
+  }
+
+  /**
+   * Maneja la selección de acción para la regla X-
+   * @param {Object} socket - Socket de la conexión
+   * @param {string} action - Acción seleccionada
+   */
+  handleXHeaderAction(socket, action) {
+    const actionMap = {
+      '1': 'block',
+      '2': 'log',
+      '3': 'monitor',
+      'block': 'block',
+      'log': 'log',
+      'monitor': 'monitor'
+    };
+
+    const selectedAction = actionMap[action.toLowerCase()];
+    if (!selectedAction) {
+      socket.write('Acción inválida. Por favor selecciona 1 (block), 2 (log) o 3 (monitor):\n> ');
+      return;
+    }
+
+    const sessionId = this.getSessionId(socket);
+    const processState = this.currentProcess.get(sessionId);
+    processState.action = selectedAction;
+    processState.step = 'x_header_reason';
+
+    socket.write(`\nAcción seleccionada: ${selectedAction}\n`);
+    socket.write('Introduce la razón para la regla (opcional):\n> ');
+  }
+
+  /**
+   * Maneja la entrada de la razón para la regla X-
+   * @param {Object} socket - Socket de la conexión
+   * @param {string} reason - Razón para la regla
+   */
+  handleXHeaderReason(socket, reason) {
+    const sessionId = this.getSessionId(socket);
+    const processState = this.currentProcess.get(sessionId);
+    
+    const ruleReason = reason || `Regla de header X-${processState.headerName} creada por administrador`;
+    processState.reason = ruleReason;
+
+    // Crear la regla
+    const ruleId = `xheader_${processState.headerName.replace(/[^a-z0-9]/g, '_')}_${Date.now()}`;
+    this.globalWAFStats.xHeaderRules.set(ruleId, {
+      headerName: processState.headerName,
+      pattern: processState.pattern,
+      action: processState.action,
+      reason: processState.reason,
+      createdAt: new Date().toISOString()
+    });
+
+    socket.write(`\n✅ Regla de header X- creada exitosamente:\n`);
+    socket.write(`  ID: ${ruleId}\n`);
+    socket.write(`  Header: ${processState.headerName}\n`);
+    socket.write(`  Patrón: ${processState.pattern}\n`);
+    socket.write(`  Acción: ${processState.action}\n`);
+    socket.write(`  Razón: ${processState.reason}\n\n`);
+
+    socket.write(`> `);
+    
+    // Limpiar el proceso
+    this.currentProcess.delete(sessionId);
+  }
+
+  /**
+   * Obtiene el ID de sesión para el socket
+   * @param {Object} socket - Socket de la conexión
+   * @returns {string} - ID de sesión
+   */
+  getSessionId(socket) {
+    return `${socket.remoteAddress}:${socket.remotePort}`;
+  }
+
+  /**
+   * Procesa la entrada del usuario durante el proceso interactivo
+   * @param {Object} socket - Socket de la conexión
+   * @param {string} input - Entrada del usuario
+   */
+  processInput(socket, input) {
+    const sessionId = this.getSessionId(socket);
+    const processState = this.currentProcess.get(sessionId);
+    
+    if (!processState) {
+      socket.write('No hay proceso interactivo activo.\n> ');
+      return;
+    }
+    
+    const userInput = input.trim();
+    
+    if (userInput.toLowerCase() === 'cancel' || userInput.toLowerCase() === 'back') {
+      socket.write('\nOperación cancelada.\n> ');
+      this.currentProcess.delete(sessionId);
+      return;
+    }
+    
+    // Validar formato de IP solo para operaciones de IP
+    if (['block_ip', 'unblock_ip', 'whitelist_ip', 'blacklist_ip'].includes(processState.step)) {
+      const ipPattern = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
+      if (!ipPattern.test(userInput)) {
+        socket.write('\nFormato de IP inválido.\n> ');
+        return;
+      }
+    }
+    
+    switch (processState.step) {
+      case 'block_ip':
+        this.handleIPBlock(socket, sessionId, userInput);
+        break;
+      case 'unblock_ip':
+        this.handleIPUnblock(socket, sessionId, userInput);
+        break;
+      case 'whitelist_ip':
+        this.handleWhitelistIP(socket, sessionId, userInput);
+        break;
+      case 'blacklist_ip':
+        this.handleBlacklistIP(socket, sessionId, userInput);
+        break;
+      case 'x_header_name':
+        this.handleXHeaderName(socket, userInput);
+        break;
+      case 'x_header_pattern':
+        this.handleXHeaderPattern(socket, userInput);
+        break;
+      case 'x_header_action':
+        this.handleXHeaderAction(socket, userInput);
+        break;
+      case 'x_header_reason':
+        this.handleXHeaderReason(socket, userInput);
+        break;
+      default:
+        socket.write(`\nEstado desconocido: ${processState.step}\n> `);
+        this.currentProcess.delete(sessionId);
+    }
+  }
+
+  /**
+   * Maneja el bloqueo de una IP
+   * @param {Object} socket - Socket de la conexión
+   * @param {string} sessionId - ID de la sesión
+   * @param {string} ip - IP a bloquear
+   */
+  handleIPBlock(socket, sessionId, ip) {
+    // Agregar IP a la lista negra temporal
+    this.globalWAFStats.blockedIPs.set(ip, {
+      blockedUntil: Date.now() + 900000, // 15 minutos
+      reason: 'Bloqueada manualmente por administrador',
+      attempts: 1,
+      timestamp: new Date().toISOString()
+    });
+    
+    socket.write(`\nIP ${ip} bloqueada temporalmente.\n\n> `);
+    this.currentProcess.delete(sessionId);
+  }
+
+  /**
+   * Maneja el desbloqueo de una IP
+   * @param {Object} socket - Socket de la conexión
+   * @param {string} sessionId - ID de la sesión
+   * @param {string} ip - IP a desbloquear
+   */
+  handleIPUnblock(socket, sessionId, ip) {
+    if (this.globalWAFStats.blockedIPs.has(ip)) {
+      this.globalWAFStats.blockedIPs.delete(ip);
+      socket.write(`\nIP ${ip} desbloqueada.\n\n> `);
+    } else {
+      socket.write(`\nLa IP ${ip} no está bloqueada.\n\n> `);
+    }
+    this.currentProcess.delete(sessionId);
+  }
+
+  /**
+   * Maneja la adición de una IP a la lista blanca
+   * @param {Object} socket - Socket de la conexión
+   * @param {string} sessionId - ID de la sesión
+   * @param {string} ip - IP a agregar a la lista blanca
+   */
+  handleWhitelistIP(socket, sessionId, ip) {
+    this.globalWAFStats.whitelist.add(ip);
+    socket.write(`\nIP ${ip} agregada a la lista blanca.\n\n> `);
+    this.currentProcess.delete(sessionId);
+  }
+
+  /**
+   * Maneja la adición de una IP a la lista negra
+   * @param {Object} socket - Socket de la conexión
+   * @param {string} sessionId - ID de la sesión
+   * @param {string} ip - IP a agregar a la lista negra
+   */
+  handleBlacklistIP(socket, sessionId, ip) {
+    this.globalWAFStats.blacklist.add(ip);
+    // También eliminar de la lista blanca si estaba
+    this.globalWAFStats.whitelist.delete(ip);
+    // Y eliminar de la lista de bloqueadas temporalmente si estaba
+    this.globalWAFStats.blockedIPs.delete(ip);
+    
+    socket.write(`\nIP ${ip} agregada a la lista negra.\n\n> `);
+    this.currentProcess.delete(sessionId);
+  }
+
+  /**
+   * Lista las reglas X-Header disponibles para remover
+   * @param {Object} socket - Socket de la conexión
+   */
+  listXHeaderRulesToRemove(socket) {
+    if (this.globalWAFStats.xHeaderRules.size === 0) {
+      socket.write('\nNo hay reglas X-Header para remover.\n\n> ');
+      return;
+    }
+
+    socket.write('\n=== Reglas X-Header Disponibles para Remover ===\n');
+    const rulesArray = Array.from(this.globalWAFStats.xHeaderRules.entries());
+    
+    for (let i = 0; i < rulesArray.length; i++) {
+      const [ruleId, rule] = rulesArray[i];
+      socket.write(`${i + 1}. ${ruleId}\n`);
+      socket.write(`   Header: ${rule.headerName}\n`);
+      socket.write(`   Patrón: ${rule.pattern}\n`);
+      socket.write(`   Acción: ${rule.action}\n`);
+      socket.write(`   Razón: ${rule.reason}\n\n`);
+    }
+    
+    socket.write('Introduce el número de la regla a remover (o "cancel" para cancelar):\n> ');
+    
+    // Iniciar proceso interactivo para remover regla
+    const sessionId = this.getSessionId(socket);
+    this.currentProcess.set(sessionId, { step: 'remove_x_rule_selection' });
+  }
+
+  /**
+   * Guarda las reglas a un archivo
+   * @param {Object} socket - Socket de la conexión
+   */
+  saveRulesToFile(socket) {
+    const fs = require('fs');
+    const path = require('path');
+    
+    try {
+      // Convertir las reglas a un formato serializable
+      const rulesData = {
+        xHeaderRules: Array.from(this.globalWAFStats.xHeaderRules.entries()),
+        timestamp: new Date().toISOString(),
+        version: '2.5.8'
+      };
+      
+      const rulesDir = path.join(process.cwd(), 'waf-rules');
+      if (!fs.existsSync(rulesDir)) {
+        fs.mkdirSync(rulesDir, { recursive: true });
+      }
+      
+      const filePath = path.join(rulesDir, `waf-rules-${Date.now()}.json`);
+      fs.writeFileSync(filePath, JSON.stringify(rulesData, null, 2));
+      
+      socket.write(`\n✅ Reglas guardadas exitosamente en: ${filePath}\n`);
+      socket.write(`Total de reglas guardadas: ${this.globalWAFStats.xHeaderRules.size}\n\n> `);
+    } catch (error) {
+      socket.write(`\n❌ Error al guardar reglas: ${error.message}\n\n> `);
+    }
+  }
+
+  /**
+   * Carga reglas desde un archivo
+   * @param {Object} socket - Socket de la conexión
+   */
+  loadRulesFromFile(socket) {
+    const fs = require('fs');
+    const path = require('path');
+    
+    try {
+      const rulesDir = path.join(process.cwd(), 'waf-rules');
+      if (!fs.existsSync(rulesDir)) {
+        socket.write('\nNo hay directorio de reglas para cargar.\n\n> ');
+        return;
+      }
+      
+      const files = fs.readdirSync(rulesDir);
+      const jsonFiles = files.filter(file => file.endsWith('.json'));
+      
+      if (jsonFiles.length === 0) {
+        socket.write('\nNo hay archivos de reglas para cargar.\n\n> ');
+        return;
+      }
+      
+      socket.write('\n=== Archivos de Reglas Disponibles ===\n');
+      for (let i = 0; i < jsonFiles.length; i++) {
+        socket.write(`${i + 1}. ${jsonFiles[i]}\n`);
+      }
+      
+      socket.write('\nIntroduce el número del archivo a cargar (o "cancel" para cancelar):\n> ');
+      
+      // Iniciar proceso interactivo para cargar regla
+      const sessionId = this.getSessionId(socket);
+      this.currentProcess.set(sessionId, { step: 'load_rules_selection', files: jsonFiles });
+    } catch (error) {
+      socket.write(`\n❌ Error al cargar reglas: ${error.message}\n\n> `);
+    }
+  }
+
+  /**
+   * Formatea bytes a una unidad legible
+   * @param {number} bytes - Cantidad en bytes
+   * @returns {string} - Cantidad formateada con unidad
+   */
+  formatBytes(bytes) {
+    // Manejar valores nulos o indefinidos
+    if (bytes == null || isNaN(bytes) || bytes === 0) return '0 Bytes';
+    const k = 1024;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+  }
+
+  /**
+   * Procesa la entrada del usuario durante el proceso interactivo
+   * @param {Object} socket - Socket de la conexión
+   * @param {string} input - Entrada del usuario
+   */
+  processInput(socket, input) {
+    const sessionId = this.getSessionId(socket);
+    const processState = this.currentProcess.get(sessionId);
+    
+    if (!processState) {
+      socket.write('No hay proceso interactivo activo.\n> ');
+      return;
+    }
+    
+    const userInput = input.trim();
+    
+    if (userInput.toLowerCase() === 'cancel') {
+      socket.write('\nOperación cancelada.\n> ');
+      this.currentProcess.delete(sessionId);
+      return;
+    }
+    
+    switch (processState.step) {
+      case 'x_header_name':
+        this.handleXHeaderName(socket, userInput);
+        break;
+      case 'x_header_pattern':
+        this.handleXHeaderPattern(socket, userInput);
+        break;
+      case 'x_header_action':
+        this.handleXHeaderAction(socket, userInput);
+        break;
+      case 'x_header_reason':
+        this.handleXHeaderReason(socket, userInput);
+        break;
+      case 'remove_x_rule_selection':
+        this.handleRemoveXRuleSelection(socket, sessionId, userInput);
+        break;
+      case 'load_rules_selection':
+        this.handleLoadRulesSelection(socket, sessionId, userInput, processState.files);
+        break;
+      case 'confirm_load_rules':
+        // Actualizar el estado para usar el método correcto
+        this.currentProcess.set(sessionId, { 
+          step: 'waiting_confirmation',
+          rulesData: processState.rulesData,
+          filePath: processState.filePath
+        });
+        if (userInput.toLowerCase() === 'sí' || userInput.toLowerCase() === 'si' || userInput.toLowerCase() === 'yes') {
+          // Reemplazar las reglas actuales con las del archivo
+          this.globalWAFStats.xHeaderRules.clear();
+          for (const [ruleId, rule] of processState.rulesData) {
+            this.globalWAFStats.xHeaderRules.set(ruleId, rule);
+          }
+          
+          socket.write(`\n✅ Reglas cargadas exitosamente desde: ${processState.filePath}\n`);
+          socket.write(`Total de reglas cargadas: ${processState.rulesData.length}\n\n> `);
+        } else {
+          socket.write('\nCarga de reglas cancelada.\n\n> ');
+        }
+        this.currentProcess.delete(sessionId);
+        break;
+      default:
+        socket.write(`\nEstado desconocido: ${processState.step}\n> `);
+        this.currentProcess.delete(sessionId);
+    }
+  }
+
+  /**
+   * Maneja la selección de regla X-Header a remover
+   * @param {Object} socket - Socket de la conexión
+   * @param {string} sessionId - ID de la sesión
+   * @param {string} selection - Selección del usuario
+   */
+  handleRemoveXRuleSelection(socket, sessionId, selection) {
+    const rulesArray = Array.from(this.globalWAFStats.xHeaderRules.entries());
+    const ruleIndex = parseInt(selection) - 1;
+    
+    if (isNaN(ruleIndex) || ruleIndex < 0 || ruleIndex >= rulesArray.length) {
+      socket.write('\nNúmero de regla inválido.\n> ');
+      return;
+    }
+    
+    const [ruleId] = rulesArray[ruleIndex];
+    
+    // Remover la regla
+    this.globalWAFStats.xHeaderRules.delete(ruleId);
+    
+    socket.write(`\n✅ Regla "${ruleId}" removida exitosamente.\n\n> `);
+    this.currentProcess.delete(sessionId);
+  }
+
+  /**
+   * Maneja la selección de archivo de reglas a cargar
+   * @param {Object} socket - Socket de la conexión
+   * @param {string} sessionId - ID de la sesión
+   * @param {string} selection - Selección del usuario
+   * @param {Array} files - Lista de archivos disponibles
+   */
+  handleLoadRulesSelection(socket, sessionId, selection, files) {
+    const fileIndex = parseInt(selection) - 1;
+    
+    if (isNaN(fileIndex) || fileIndex < 0 || fileIndex >= files.length) {
+      socket.write('\nNúmero de archivo inválido.\n> ');
+      return;
+    }
+    
+    const fs = require('fs');
+    const path = require('path');
+    const filePath = path.join(process.cwd(), 'waf-rules', files[fileIndex]);
+    
+    try {
+      const rulesData = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+      
+      // Cargar las reglas
+      if (rulesData.xHeaderRules && Array.isArray(rulesData.xHeaderRules)) {
+        // Limpiar reglas existentes si se desea
+        socket.write('\n¿Deseas reemplazar las reglas actuales? (sí/no):\n> ');
+        
+        // Actualizar el estado para esperar confirmación
+        this.currentProcess.set(sessionId, { 
+          step: 'confirm_load_rules',
+          rulesData: rulesData.xHeaderRules,
+          filePath: filePath
+        });
+      }
+    } catch (error) {
+      socket.write(`\n❌ Error al cargar archivo: ${error.message}\n\n> `);
+      this.currentProcess.delete(sessionId);
+    }
+  }
+
+  /**
+   * Maneja la confirmación de carga de reglas
+   * @param {Object} socket - Socket de la conexión
+   * @param {string} sessionId - ID de la sesión
+   * @param {string} confirmation - Confirmación del usuario
+   * @param {Array} rulesData - Datos de reglas a cargar
+   * @param {string} filePath - Ruta del archivo
+   */
+  handleLoadRulesConfirmation(socket, sessionId, confirmation, rulesData, filePath) {
+    if (confirmation.toLowerCase() === 'sí' || confirmation.toLowerCase() === 'si' || confirmation.toLowerCase() === 'yes') {
+      // Reemplazar las reglas actuales con las del archivo
+      this.globalWAFStats.xHeaderRules.clear();
+      for (const [ruleId, rule] of rulesData) {
+        this.globalWAFStats.xHeaderRules.set(ruleId, rule);
+      }
+      
+      socket.write(`\n✅ Reglas cargadas exitosamente desde: ${filePath}\n`);
+      socket.write(`Total de reglas cargadas: ${rulesData.length}\n\n> `);
+    } else {
+      socket.write('\nCarga de reglas cancelada.\n\n> ');
+    }
+    
+    this.currentProcess.delete(sessionId);
+  }
+}
+
+module.exports = WAFModule;