ONTEXTO DEL PROBLEMA Sistema actual: Flujo de n8n que procesa webhooks de WhatsApp…
- 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
- 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}
- 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
- RATE LIMITING CON REDIS OPERACIONES:
- GET ratelimit:{chatId}:{hora} → Obtener contador actual
- IF contador >= límite → Rechazar + Notificar
- ELSE INCR ratelimit:{chatId}:{hora} TTL 3600 → Continuar
- 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.
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:
- Mantenimiento de Estado: Mantiene un estado global (
global.chatStats) porchatIdpara rastrear los mensajes recientes. - 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.
- 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:
- Bloqueo Permanente: Envía un mensaje de advertencia y termina el flujo.
- Bloqueo Temporal: Envía una notificación y termina el flujo.
- Delay: Espera el tiempo especificado y continúa con el rate limiting.
- 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
chatIdy 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
- Webhook Trigger: Recibe los mensajes de WhatsApp.
- Function Node (Detector de Patrones): Analiza el mensaje y clasifica el comportamiento.
- 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.
- 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.
- 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:
-
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.
-
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.
-
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.
-
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);- Mantenimiento de Estado: Mantiene un estado global (
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.