Skip to content
TheChatArchiveThe Chat Archive
Metallama-4-maverick-17b-128e-instruct· MetaHugging 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. Meta Assistant

    Diseño e Implementación del Sistema de Protección Anti-Spam

    1. Arquitectura General

    El sistema de protección anti-spam se integrará en el flujo existente de n8n que procesa webhooks de WhatsApp usando WHAPI. La arquitectura se basa en:

    • Detector de Patrones: Nodo de código que analiza los mensajes entrantes y clasifica el comportamiento del usuario.
    • Router de Acciones: Nodo de conmutación que dirige el flujo según la clasificación obtenida.
    • Rate Limiting con Redis: Sistema de limitación de tasa que utiliza Redis para almacenar y verificar los contadores de mensajes.

    2. Detector de Patrones

    2.1. Entrada y Salida

    • Entrada: {chatId, message, timestamp}
    • Salida: {comportamiento, accion, severidad, delaySegundos, maxMensajesHora, rateLimitKey}

    2.2. Procesamiento

    1. Mantener estado en global.chatStats por chatId.
    2. Analizar ventanas temporales: 30s, 1min, 5min.
    3. Calcular métricas:
      • Intervalos entre mensajes.
      • Repetición de contenido.
      • Longitud de los mensajes.
    4. Clasificar comportamiento según criterios definidos.

    2.3. Implementación

    // detector-patrones.js
    const criteriosBot = {
      critico: {
        mensajes30s: "> 15",
        intervalPromedio: "< 800",
        repeticionContenido: "> 0.7"
      },
      moderado: {
        mensajes1min: "> 20",
        intervalMinimo: "< 500",
        patronesRoboticos: "> 5"
      }
    };
    
    const criteriosSpamHumano = {
      agresivo: {
        mensajes1min: "> 25",
        mensajesCortos: "> 15"
      },
      repetitivo: {
        repeticionRatio: "> 0.6",
        volumenMinimo: "> 10"
      }
    };
    
    let global = { chatStats: {} };
    
    module.exports = async function({ chatId, message, timestamp }) {
      if (!global.chatStats[chatId]) {
        global.chatStats[chatId] = {
          mensajes: [],
          ultimaActualizacion: timestamp
        };
      }
    
      const chatStats = global.chatStats[chatId];
      chatStats.mensajes.push({ message, timestamp });
    
      // Limpiar mensajes antiguos
      chatStats.mensajes = chatStats.mensajes.filter(m => m.timestamp > timestamp - 300000);
    
      // Calcular métricas
      const mensajes30s = chatStats.mensajes.filter(m => m.timestamp > timestamp - 30000).length;
      const intervaloPromedio = calcularIntervaloPromedio(chatStats.mensajes);
      const repeticionContenido = calcularRepeticion(chatStats.mensajes);
    
      // Clasificar comportamiento
      let comportamiento, accion, severidad, delaySegundos, maxMensajesHora;
    
      if (mensajes30s > 15 && intervaloPromedio < 800 && repeticionContenido > 0.7) {
        comportamiento = 'ataque_bot_critico';
        accion = 'bloquear_permanente';
        severidad = 10;
      } else if (/* otros criterios */) {
        // Otras clasificaciones
      } else {
        comportamiento = 'normal';
        accion = 'procesar';
        severidad = 0;
      }
    
      // Asignar delay y límite según clasificación
      switch (comportamiento) {
        case 'normal':
          delaySegundos = 0;
          maxMensajesHora = 120;
          break;
        case 'usuario_muy_activo':
          delaySegundos = 5;
          maxMensajesHora = 50;
          break;
        // Otros casos
      }
    
      return {
        comportamiento,
        accion,
        severidad,
        delaySegundos,
        maxMensajesHora,
        rateLimitKey: `ratelimit:${chatId}:${Math.floor(timestamp / 3600000)}`
      };
    };
    

    3. Router de Acciones

    3.1. Rutas

    • bloquear_permanente
    • bloquear_temporal
    • delay_[nivel]
    • procesar

    3.2. Implementación

    // router-acciones.js
    module.exports = async function({ accion, delaySegundos, chatId, message }) {
      switch (accion) {
        case 'bloquear_permanente':
          // Enviar advertencia y terminar flujo
          return { fin: true };
        case 'bloquear_temporal':
          // Enviar notificación y terminar flujo
          return { fin: true };
        case 'delay_normal':
        case 'delay_usuario_activo':
        case 'delay_usuario_muy_activo':
          // Esperar según delaySegundos
          await new Promise(resolve => setTimeout(resolve, delaySegundos * 1000));
          return { continuar: true };
        case 'procesar':
          return { continuar: true };
        default:
          throw new Error(`Acción no reconocida: ${accion}`);
      }
    };
    

    4. Rate Limiting con Redis

    4.1. Operaciones

    1. GET ratelimit:{chatId}:{hora}: Obtener contador actual.
    2. INCR ratelimit:{chatId}:{hora}: Incrementar contador.
    3. EXPIRE ratelimit:{chatId}:{hora} 3600: Establecer TTL.

    4.2. Implementación

    // rate-limiting.js
    const redis = require('redis');
    const client = redis.createClient({ url: process.env.REDIS_URL });
    
    module.exports = async function({ rateLimitKey, maxMensajesHora }) {
      const contador = await client.get(rateLimitKey);
      if (contador && parseInt(contador) >= maxMensajesHora) {
        // Rechazar mensaje
        return { excedido: true };
      } else {
        await client.incr(rateLimitKey);
        await client.expire(rateLimitKey, 3600);
        return { excedido: false };
      }
    };
    

    5. Flujo de Ejecución

    1. Mensaje entrante.
    2. Detector de Patrones: Clasificar comportamiento.
    3. Router de Acciones: Dirigir flujo según clasificación.
    4. Rate Limiting: Verificar límite de tasa.
    5. Si no excedido, procesar mensaje.

    6. Casos de Prueba

    6.1. Usuario Normal

    • Input: 3 mensajes en 2 minutos, contenido variado.
    • Expected: Clasificación "normal", 0 delay, límite 120/hora.

    6.2. Usuario Muy Activo

    • Input: 35 mensajes en 5 minutos, contenido diverso.
    • Expected: Clasificación "usuario_muy_activo", delay 5s, límite 50/hora.

    6.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.

    6.4. Bot Crítico

    • Input: 20 mensajes en 25 segundos, intervalos de 800ms, 80% idénticos.
    • Expected: Clasificación "ataque_bot_critico", bloqueo permanente.

    7. Métricas de Monitoreo

    {
      "mensajes30s": 5,
      "mensajes1min": 10,
      "mensajes5min": 20,
      "intervaloPromedio": 1000,
      "intervaloMinimo": 500,
      "repeticionRatio": 0.2,
      "textosUnicos": 8,
      "mensajesCortos": 3,
      "intervalosRoboticos": 2,
      "comportamiento": "normal",
      "severidad": 0,
      "timestampAnalisis": "2023-04-01T12:00:00.000Z"
    }
    

    8. Configuración de Despliegue

    # Workers configuration
    n8n worker --concurrency=5
    
    # Redis configuration
    REDIS_URL=redis://localhost:6379
    

    9. 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.

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