Skip to content
TheChatArchiveThe Chat Archive
Mistralmagistral-medium-2506Hugging Face Arena Expert 5K

ONTEXTO DEL PROBLEMA Sistema actual: Flujo de n8n que procesa webhooks de WhatsApp…

  1. User

    ONTEXTO DEL PROBLEMA Sistema actual: Flujo de n8n que procesa webhooks de WhatsApp usando WHAPI Arquitectura: Queue mode con múltiples workers + Redis para batching Problema crítico: Vulnerabilidad a ataques masivos de mensajes que saturan Redis y colapsan el sistema OBJETIVO TÉCNICO Diseñar e implementar un sistema de protección anti-spam que:

    PROTEJA ANTES DE CONTAMINAR: Filtrar mensajes maliciosos ANTES de que lleguen a Redis DIFERENCIE PATRONES: Distinguir entre usuarios legítimos activos vs ataques automatizados DEGRADE GRACIOSAMENTE: Aplicar throttling progresivo en lugar de bloqueos absolutos SEA COMPATIBLE CON WORKERS: Funcionar correctamente en queue mode distribuido MANTENGA ESTADO CONSISTENTE: Usar Redis como fuente de verdad compartida entre workers

    ESPECIFICACIONES TÉCNICAS REQUERIDAS ANÁLISIS DE PATRONES EN TIEMPO REAL javascript// Criterios de detección robustos const criteriosBot = { critico: { mensajes30s: "> 15", intervalPromedio: "< 800ms", repeticionContenido: "> 70%" }, moderado: { mensajes1min: "> 20", intervalMinimo: "< 500ms", patronesRoboticos: "> 5 intervalos idénticos" } };

    const criteriosSpamHumano = { agresivo: { mensajes1min: "> 25", mensajesCortos: "> 15 con <10 caracteres" }, repetitivo: { repeticionRatio: "> 60%", volumenMinimo: "> 10 mensajes/min" } }; SISTEMA DE RATE LIMITING DINÁMICO LÍMITES POR CLASIFICACIÓN:

    • Usuario normal: 120 mensajes/hora
    • Usuario activo: 80 mensajes/hora
    • Usuario muy activo: 50 mensajes/hora
    • Spam detectado: 5-20 mensajes/hora
    • Bot moderado: 1 mensaje/hora
    • Bot crítico: 0 mensajes/hora (bloqueo total) ARQUITECTURA DE DELAYS PROGRESIVOS ESCALACIÓN DE DELAYS:
    • Comportamiento normal: 0 segundos
    • Usuario activo: 2 segundos
    • Usuario muy activo: 5 segundos
    • Spam repetitivo: 15 segundos
    • Spam agresivo: 30 segundos
    • Bot moderado: Bloqueo temporal (mensaje informativo)
    • Bot crítico: Bloqueo permanente (mensaje de advertencia) REQUERIMIENTOS DE IMPLEMENTACIÓN
    1. DETECTOR DE PATRONES (Nodo Code) javascriptENTRADA: {chatId, message, timestamp} PROCESAMIENTO:
    • Mantener estado en global.chatStats por chatId
    • Analizar ventanas temporales: 30s, 1min, 5min
    • Calcular métricas: intervalos, repetición, longitud
    • Clasificar comportamiento según criterios SALIDA: {comportamiento, accion, severidad, delaySegundos, maxMensajesHora, rateLimitKey}
    1. ROUTER DE ACCIONES (Nodo Switch) RUTAS:
    • bloquear_permanente → Envío de advertencia + FIN
    • bloquear_temporal → Envío de notificación + FIN
    • delay_[nivel] → Wait dinámico → Continuar
    • procesar → Rate limiting directo
    1. RATE LIMITING CON REDIS OPERACIONES:
    2. GET ratelimit:{chatId}:{hora} → Obtener contador actual
    3. IF contador >= límite → Rechazar + Notificar
    4. ELSE INCR ratelimit:{chatId}:{hora} TTL 3600 → Continuar
    5. GESTIÓN DE ESTADO DISTRIBUIDO REDIS KEYS:
    • ratelimit:{chatId}:{timestamp_hora} → Contador con TTL 3600s
    • Estado compartido entre todos los workers
    • Operaciones atómicas (INCR) para thread-safety FLUJO DE EJECUCIÓN ESPERADO Mensaje → Detector Patrones → Clasificación → Router ↓ ┌─ Bot Crítico → Bloqueo Permanente → FIN ├─ Bot Moderado → Warning Temporal → FIN ├─ Spam → Delay Dinámico → Rate Limit Check └─ Normal → Rate Limit Check ↓ Rate Limit Check → ¿Excedido? ↓ ↓ Rechazar Incrementar → PushMessage → Continuar flujo original CASOS DE PRUEBA REQUERIDOS USUARIO NORMAL

    Input: 3 mensajes en 2 minutos, contenido variado Expected: Clasificación "normal", 0 delay, límite 120/hora Flow: Detector → Router → Rate Check → Incrementar → PushMessage

    USUARIO MUY ACTIVO

    Input: 35 mensajes en 5 minutos, contenido diverso Expected: Clasificación "usuario_muy_activo", delay 5s, límite 50/hora Flow: Detector → Router → Wait 5s → Rate Check → Incrementar → PushMessage

    SPAM HUMANO AGRESIVO

    Input: 30 mensajes en 1 minuto, 20 de ellos <10 caracteres Expected: Clasificación "spam_humano_agresivo", delay 30s, límite 5/hora Flow: Detector → Router → Wait 30s → Rate Check → Incrementar → PushMessage

    BOT CRÍTICO

    Input: 20 mensajes en 25 segundos, intervalos de 800ms, 80% idénticos Expected: Clasificación "ataque_bot_critico", bloqueo permanente Flow: Detector → Router → Bloqueo Permanente → FIN (no procesado)

    MÉTRICAS DE MONITOREO REQUERIDAS javascriptSALIDA DE MÉTRICAS: { mensajes30s: number, mensajes1min: number, mensajes5min: number, intervaloPromedio: number, intervaloMinimo: number, repeticionRatio: percentage, textosUnicos: number, mensajesCortos: number, intervalosRoboticos: number, comportamiento: string, severidad: 0-10, timestampAnalisis: ISO_string } CRITERIOS DE ÉXITO

    PROTECCIÓN EFECTIVA: Bloquear ataques bot sin falsos positivos en usuarios legítimos DEGRADACIÓN GRADUAL: Aplicar delays progresivos, no bloqueos binarios TRANSPARENCIA: Usuario siempre informado de acciones tomadas y razones RECUPERACIÓN AUTOMÁTICA: Límites se resetean cada hora sin intervención manual COMPATIBILIDAD TOTAL: Funcionar en queue mode con múltiples workers PERFORMANCE: No agregar latencia significativa a mensajes normales MEMORIA CONTROLADA: Auto-limpieza de estado para evitar memory leaks

    CONFIGURACIÓN DE DESPLIEGUE bash# Workers configuration n8n worker --concurrency=5 # Multiple instances

    Redis configuration

    • TTL automático en keys de rate limiting
    • Operaciones atómicas para thread-safety
    • Estado compartido entre workers

    Environment variables

    REDIS_URL=existing_redis_instance WHAPI_TOKEN=existing_token RESULTADO ESPERADO Un sistema robusto que proteja la infraestructura de ataques masivos manteniendo una experiencia de usuario aceptable para uso legítimo, compatible con la arquitectura existente de queue mode y workers distribuidos.

  2. Mistral Assistant

    Solución Propuesta

    Para abordar el problema de vulnerabilidad a ataques masivos de mensajes en el sistema actual, se propone un sistema de protección anti-spam que cumple con los objetivos técnicos y especificaciones proporcionadas. A continuación, se detalla la solución:

    Detector de Patrones

    El detector de patrones analiza los mensajes en tiempo real y clasifica el comportamiento del usuario. Se implementa como un nodo de código en n8n que realiza las siguientes acciones:

    1. Mantenimiento de Estado: Mantiene un estado global (global.chatStats) por chatId para rastrear los mensajes recientes.
    2. Análisis de Ventanas Temporales: Analiza ventanas de tiempo de 30 segundos, 1 minuto y 5 minutos para calcular métricas como la cantidad de mensajes, intervalos entre mensajes, repetición de contenido y longitud de los mensajes.
    3. Clasificación de Comportamiento: Basado en las métricas calculadas, clasifica el comportamiento del usuario en categorías como "normal", "usuario_activo", "usuario_muy_activo", "spam_humano_agresivo", "spam_humano_repetitivo", "bot_moderado" o "ataque_bot_critico".
    function detectPattern(chatId, message, timestamp) {
      // Inicializar estado si no existe
      if (!global.chatStats) global.chatStats = {};
      if (!global.chatStats[chatId]) {
        global.chatStats[chatId] = {
          messages: [],
          lastAnalysis: null
        };
      }
    
      const chatStats = global.chatStats[chatId];
      chatStats.messages.push({ message, timestamp });
    
      // Limpiar mensajes antiguos (más de 5 minutos)
      const now = new Date(timestamp);
      chatStats.messages = chatStats.messages.filter(msg => {
        const msgTime = new Date(msg.timestamp);
        return (now - msgTime) <= 300000; // 5 minutos en milisegundos
      });
    
      // Calcular métricas
      const messages30s = chatStats.messages.filter(msg => {
        const msgTime = new Date(msg.timestamp);
        return (now - msgTime) <= 30000; // 30 segundos
      }).length;
    
      const messages1min = chatStats.messages.filter(msg => {
        const msgTime = new Date(msg.timestamp);
        return (now - msgTime) <= 60000; // 1 minuto
      }).length;
    
      const messages5min = chatStats.messages.length;
    
      // Calcular intervalos entre mensajes
      const intervals = [];
      for (let i = 1; i < chatStats.messages.length; i++) {
        const prevTime = new Date(chatStats.messages[i-1].timestamp);
        const currTime = new Date(chatStats.messages[i].timestamp);
        intervals.push(currTime - prevTime);
      }
    
      const intervalPromedio = intervals.length > 0 ?
        intervals.reduce((a, b) => a + b, 0) / intervals.length : 0;
      const intervalMinimo = intervals.length > 0 ?
        Math.min(...intervals) : Infinity;
    
      // Calcular repetición de contenido
      const messageTexts = chatStats.messages.map(msg => msg.message);
      const uniqueTexts = [...new Set(messageTexts)];
      const repeticionRatio = uniqueTexts.length > 0 ?
        (messageTexts.length - uniqueTexts.length) / messageTexts.length : 0;
    
      // Calcular mensajes cortos
      const mensajesCortos = chatStats.messages.filter(msg =>
        msg.message.length < 10
      ).length;
    
      // Calcular intervalos robóticos (intervalos idénticos)
      const intervalCounts = {};
      intervals.forEach(interval => {
        const roundedInterval = Math.round(interval / 100) * 100; // Redondear a 100ms
        intervalCounts[roundedInterval] = (intervalCounts[roundedInterval] || 0) + 1;
      });
      const patronesRoboticos = Object.values(intervalCounts).filter(count => count > 1).length;
    
      // Clasificar comportamiento
      let comportamiento = "normal";
      let severidad = 0;
      let delaySegundos = 0;
      let maxMensajesHora = 120;
    
      // Criterios para bots críticos
      if (messages30s > 15 && intervalPromedio < 800 && repeticionRatio > 0.7) {
        comportamiento = "ataque_bot_critico";
        severidad = 10;
        delaySegundos = 0; // Bloqueo permanente
        maxMensajesHora = 0;
      }
      // Criterios para bots moderados
      else if (messages1min > 20 && intervalMinimo < 500 && patronesRoboticos > 5) {
        comportamiento = "bot_moderado";
        severidad = 8;
        delaySegundos = 0; // Bloqueo temporal
        maxMensajesHora = 1;
      }
      // Criterios para spam humano agresivo
      else if (messages1min > 25 && mensajesCortos > 15) {
        comportamiento = "spam_humano_agresivo";
        severidad = 7;
        delaySegundos = 30;
        maxMensajesHora = 5;
      }
      // Criterios para spam humano repetitivo
      else if (repeticionRatio > 0.6 && messages1min > 10) {
        comportamiento = "spam_humano_repetitivo";
        severidad = 6;
        delaySegundos = 15;
        maxMensajesHora = 20;
      }
      // Usuario muy activo
      else if (messages5min > 35) {
        comportamiento = "usuario_muy_activo";
        severidad = 4;
        delaySegundos = 5;
        maxMensajesHora = 50;
      }
      // Usuario activo
      else if (messages5min > 20) {
        comportamiento = "usuario_activo";
        severidad = 2;
        delaySegundos = 2;
        maxMensajesHora = 80;
      }
      // Usuario normal
      else {
        comportamiento = "normal";
        severidad = 0;
        delaySegundos = 0;
        maxMensajesHora = 120;
      }
    
      // Generar clave para rate limiting (por hora)
      const nowDate = new Date(timestamp);
      const hourStart = new Date(nowDate.getFullYear(), nowDate.getMonth(), nowDate.getDate(), nowDate.getHours(), 0, 0, 0);
      const rateLimitKey = `ratelimit:${chatId}:${hourStart.getTime()}`;
    
      return {
        comportamiento,
        accion: getAccion(comportamiento),
        severidad,
        delaySegundos,
        maxMensajesHora,
        rateLimitKey,
        metrics: {
          mensajes30s,
          mensajes1min,
          mensajes5min,
          intervaloPromedio,
          intervaloMinimo,
          repeticionRatio,
          textosUnicos: uniqueTexts.length,
          mensajesCortos,
          intervalosRoboticos: patronesRoboticos,
          timestampAnalisis: now.toISOString()
        }
      };
    }
    
    function getAccion(comportamiento) {
      switch (comportamiento) {
        case "ataque_bot_critico":
          return "bloquear_permanente";
        case "bot_moderado":
          return "bloquear_temporal";
        case "spam_humano_agresivo":
          return "delay_30";
        case "spam_humano_repetitivo":
          return "delay_15";
        case "usuario_muy_activo":
          return "delay_5";
        case "usuario_activo":
          return "delay_2";
        default:
          return "procesar";
      }
    }
    

    Router de Acciones

    El router de acciones es un nodo switch en n8n que dirige el flujo según la acción devuelta por el detector de patrones. Las rutas posibles son:

    1. Bloqueo Permanente: Envía un mensaje de advertencia y termina el flujo.
    2. Bloqueo Temporal: Envía una notificación y termina el flujo.
    3. Delay: Espera el tiempo especificado y continúa con el rate limiting.
    4. Procesar: Continúa directamente con el rate limiting.

    Rate Limiting con Redis

    El rate limiting se implementa usando Redis para mantener el estado compartido entre workers. Se utiliza una clave por chatId y hora para contar los mensajes y aplicar los límites de tasa.

    const redis = require('redis');
    const client = redis.createClient(process.env.REDIS_URL);
    
    async function checkRateLimit(chatId, rateLimitKey, maxMensajesHora) {
      return new Promise((resolve, reject) => {
        client.get(rateLimitKey, (err, reply) => {
          if (err) {
            reject(err);
            return;
          }
    
          const currentCount = reply ? parseInt(reply, 10) : 0;
          if (currentCount >= maxMensajesHora) {
            resolve({ allowed: false, currentCount });
          } else {
            // Incrementar el contador con TTL de 1 hora
            client.multi()
              .incr(rateLimitKey)
              .expire(rateLimitKey, 3600)
              .exec((err, replies) => {
                if (err) {
                  reject(err);
                  return;
                }
                resolve({ allowed: true, currentCount: currentCount + 1 });
              });
          }
        });
      });
    }
    

    Flujo Completo en n8n

    1. Webhook Trigger: Recibe los mensajes de WhatsApp.
    2. Function Node (Detector de Patrones): Analiza el mensaje y clasifica el comportamiento.
    3. Switch Node (Router de Acciones): Dirige el flujo según la acción.
      • Bloqueo permanente: Envía un mensaje de advertencia y termina.
      • Bloqueo temporal: Envía una notificación y termina.
      • Delay: Espera el tiempo especificado y continúa.
      • Procesar: Continúa al siguiente paso.
    4. Function Node (Rate Limiting): Verifica el límite de tasa en Redis.
      • Si se excede, rechaza el mensaje.
      • Si no, incrementa el contador y continúa.
    5. Procesamiento Normal: Continúa con el flujo original de procesamiento de mensajes.

    Casos de Prueba

    Se implementan los siguientes casos de prueba para verificar el funcionamiento del sistema:

    1. Usuario normal:

      • Input: 3 mensajes en 2 minutos, contenido variado.
      • Expected: Clasificación "normal", 0 delay, límite 120/hora.
      • Flujo: Detector → Router → Rate Check → Incrementar → PushMessage.
    2. Usuario muy activo:

      • Input: 35 mensajes en 5 minutos, contenido diverso.
      • Expected: Clasificación "usuario_muy_activo", delay 5s, límite 50/hora.
      • Flujo: Detector → Router → Wait 5s → Rate Check → Incrementar → PushMessage.
    3. Spam humano agresivo:

      • Input: 30 mensajes en 1 minuto, 20 de ellos <10 caracteres.
      • Expected: Clasificación "spam_humano_agresivo", delay 30s, límite 5/hora.
      • Flujo: Detector → Router → Wait 30s → Rate Check → Incrementar → PushMessage.
    4. Bot crítico:

      • Input: 20 mensajes en 25 segundos, intervalos de 800ms, 80% idénticos.
      • Expected: Clasificación "ataque_bot_critico", bloqueo permanente.
      • Flujo: Detector → Router → Bloqueo Permanente → FIN (no procesado).

    Conclusión

    La solución propuesta incluye un detector de patrones que analiza los mensajes en tiempo real, un router de acciones que dirige el flujo según la clasificación, y un sistema de rate limiting basado en Redis para mantener el estado y aplicar límites de tasa. Esta solución protege el sistema contra ataques masivos de mensajes mientras mantiene una buena experiencia para usuarios legítimos, y es compatible con la arquitectura existente de queue mode y workers distribuidos.

    // Ejemplo de implementación en n8n
    const resultado = detectPattern("chat123", "Hola", "2023-10-01T12:00:00Z");
    console.log(resultado);
    

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.