@serve.zone/dcrouter 2.12.4

package/dist_ts/mail/delivery/classes.unified.rate.limiter.js

@@ -0,0 +1,817 @@
+import * as plugins from '../../plugins.js';
+import { EventEmitter } from 'node:events';
+import { logger } from '../../logger.js';
+import { SecurityLogger, SecurityLogLevel, SecurityEventType } from '../../security/index.js';
+/**
+ * Unified rate limiter for all email processing modes
+ */
+export class UnifiedRateLimiter extends EventEmitter {
+    /**
+     * Create a new unified rate limiter
+     * @param config Rate limit configuration
+     */
+    constructor(config) {
+        super();
+        this.counters = new Map();
+        this.patternCounters = new Map();
+        this.ipCounters = new Map();
+        this.domainCounters = new Map();
+        // Set default configuration
+        this.config = {
+            global: {
+                maxMessagesPerMinute: config.global.maxMessagesPerMinute || 100,
+                maxRecipientsPerMessage: config.global.maxRecipientsPerMessage || 100,
+                maxConnectionsPerIP: config.global.maxConnectionsPerIP || 20,
+                maxErrorsPerIP: config.global.maxErrorsPerIP || 10,
+                maxAuthFailuresPerIP: config.global.maxAuthFailuresPerIP || 5,
+                blockDuration: config.global.blockDuration || 3600000 // 1 hour
+            },
+            patterns: config.patterns || {},
+            ips: config.ips || {},
+            blocks: config.blocks || {}
+        };
+        // Initialize statistics
+        this.stats = {
+            activeCounters: 0,
+            totalBlocked: 0,
+            currentlyBlocked: 0,
+            byPattern: {},
+            byIp: {}
+        };
+        // Start cleanup interval
+        this.startCleanupInterval();
+    }
+    /**
+     * Start the cleanup interval
+     */
+    startCleanupInterval() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+        }
+        // Run cleanup every minute
+        this.cleanupInterval = setInterval(() => this.cleanup(), 60000);
+    }
+    /**
+     * Stop the cleanup interval
+     */
+    stop() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = undefined;
+        }
+    }
+    /**
+     * Destroy the rate limiter and clean up all resources
+     */
+    destroy() {
+        // Stop the cleanup interval
+        this.stop();
+        // Clear all maps to free memory
+        this.counters.clear();
+        this.ipCounters.clear();
+        this.patternCounters.clear();
+        // Clear blocks
+        if (this.config.blocks) {
+            this.config.blocks = {};
+        }
+        // Clear statistics
+        this.stats = {
+            activeCounters: 0,
+            totalBlocked: 0,
+            currentlyBlocked: 0,
+            byPattern: {},
+            byIp: {}
+        };
+        logger.log('info', 'UnifiedRateLimiter destroyed');
+    }
+    /**
+     * Clean up expired counters and blocks
+     */
+    cleanup() {
+        const now = Date.now();
+        // Clean up expired blocks
+        if (this.config.blocks) {
+            for (const [ip, expiry] of Object.entries(this.config.blocks)) {
+                if (expiry <= now) {
+                    delete this.config.blocks[ip];
+                    logger.log('info', `Rate limit block expired for IP ${ip}`);
+                    // Update statistics
+                    if (this.stats.byIp[ip]) {
+                        this.stats.byIp[ip].blocked = false;
+                    }
+                    this.stats.currentlyBlocked--;
+                }
+            }
+        }
+        // Clean up old counters (older than 10 minutes)
+        const cutoff = now - 600000;
+        // Clean global counters
+        for (const [key, counter] of this.counters.entries()) {
+            if (counter.lastReset < cutoff) {
+                this.counters.delete(key);
+            }
+        }
+        // Clean pattern counters
+        for (const [key, counter] of this.patternCounters.entries()) {
+            if (counter.lastReset < cutoff) {
+                this.patternCounters.delete(key);
+            }
+        }
+        // Clean IP counters
+        for (const [key, counter] of this.ipCounters.entries()) {
+            if (counter.lastReset < cutoff) {
+                this.ipCounters.delete(key);
+            }
+        }
+        // Clean domain counters
+        for (const [key, counter] of this.domainCounters.entries()) {
+            if (counter.lastReset < cutoff) {
+                this.domainCounters.delete(key);
+            }
+        }
+        // Update statistics
+        this.updateStats();
+    }
+    /**
+     * Check if a message is allowed by rate limits
+     * @param email Email address
+     * @param ip IP address
+     * @param recipients Number of recipients
+     * @param pattern Matched pattern
+     * @param domain Domain name for domain-specific limits
+     * @returns Result of rate limit check
+     */
+    checkMessageLimit(email, ip, recipients, pattern, domain) {
+        // Check if IP is blocked
+        if (this.isIpBlocked(ip)) {
+            return {
+                allowed: false,
+                reason: 'IP is blocked',
+                resetIn: this.getBlockReleaseTime(ip)
+            };
+        }
+        // Check global message rate limit
+        const globalResult = this.checkGlobalMessageLimit(email);
+        if (!globalResult.allowed) {
+            return globalResult;
+        }
+        // Check pattern-specific limit if pattern is provided
+        if (pattern) {
+            const patternResult = this.checkPatternMessageLimit(pattern);
+            if (!patternResult.allowed) {
+                return patternResult;
+            }
+        }
+        // Check domain-specific limit if domain is provided
+        if (domain) {
+            const domainResult = this.checkDomainMessageLimit(domain);
+            if (!domainResult.allowed) {
+                return domainResult;
+            }
+        }
+        // Check IP-specific limit
+        const ipResult = this.checkIpMessageLimit(ip);
+        if (!ipResult.allowed) {
+            return ipResult;
+        }
+        // Check recipient limit
+        const recipientResult = this.checkRecipientLimit(email, recipients, pattern, domain);
+        if (!recipientResult.allowed) {
+            return recipientResult;
+        }
+        // All checks passed
+        return { allowed: true };
+    }
+    /**
+     * Check global message rate limit
+     * @param email Email address
+     */
+    checkGlobalMessageLimit(email) {
+        const now = Date.now();
+        const limit = this.config.global.maxMessagesPerMinute;
+        if (!limit) {
+            return { allowed: true };
+        }
+        // Get or create counter
+        const key = 'global';
+        let counter = this.counters.get(key);
+        if (!counter) {
+            counter = {
+                count: 0,
+                lastReset: now,
+                recipients: 0,
+                errors: 0,
+                authFailures: 0,
+                connections: 0
+            };
+            this.counters.set(key, counter);
+        }
+        // Check if counter needs to be reset
+        if (now - counter.lastReset >= 60000) {
+            counter.count = 0;
+            counter.lastReset = now;
+        }
+        // Check if limit is exceeded
+        if (counter.count >= limit) {
+            // Calculate reset time
+            const resetIn = 60000 - (now - counter.lastReset);
+            return {
+                allowed: false,
+                reason: 'Global message rate limit exceeded',
+                limit,
+                current: counter.count,
+                resetIn
+            };
+        }
+        // Increment counter
+        counter.count++;
+        // Update statistics
+        this.updateStats();
+        return { allowed: true };
+    }
+    /**
+     * Check pattern-specific message rate limit
+     * @param pattern Pattern to check
+     */
+    checkPatternMessageLimit(pattern) {
+        const now = Date.now();
+        // Get pattern-specific limit or use global
+        const patternConfig = this.config.patterns?.[pattern];
+        const limit = patternConfig?.maxMessagesPerMinute || this.config.global.maxMessagesPerMinute;
+        if (!limit) {
+            return { allowed: true };
+        }
+        // Get or create counter
+        let counter = this.patternCounters.get(pattern);
+        if (!counter) {
+            counter = {
+                count: 0,
+                lastReset: now,
+                recipients: 0,
+                errors: 0,
+                authFailures: 0,
+                connections: 0
+            };
+            this.patternCounters.set(pattern, counter);
+            // Initialize pattern stats if needed
+            if (!this.stats.byPattern[pattern]) {
+                this.stats.byPattern[pattern] = {
+                    messagesPerMinute: 0,
+                    totalMessages: 0,
+                    totalBlocked: 0
+                };
+            }
+        }
+        // Check if counter needs to be reset
+        if (now - counter.lastReset >= 60000) {
+            counter.count = 0;
+            counter.lastReset = now;
+        }
+        // Check if limit is exceeded
+        if (counter.count >= limit) {
+            // Calculate reset time
+            const resetIn = 60000 - (now - counter.lastReset);
+            // Update statistics
+            this.stats.byPattern[pattern].totalBlocked++;
+            this.stats.totalBlocked++;
+            return {
+                allowed: false,
+                reason: `Pattern "${pattern}" message rate limit exceeded`,
+                limit,
+                current: counter.count,
+                resetIn
+            };
+        }
+        // Increment counter
+        counter.count++;
+        // Update statistics
+        this.stats.byPattern[pattern].messagesPerMinute = counter.count;
+        this.stats.byPattern[pattern].totalMessages++;
+        return { allowed: true };
+    }
+    /**
+     * Check domain-specific message rate limit
+     * @param domain Domain to check
+     */
+    checkDomainMessageLimit(domain) {
+        const now = Date.now();
+        // Get domain-specific limit or use global
+        const domainConfig = this.config.domains?.[domain];
+        const limit = domainConfig?.maxMessagesPerMinute || this.config.global.maxMessagesPerMinute;
+        if (!limit) {
+            return { allowed: true };
+        }
+        // Get or create counter
+        let counter = this.domainCounters.get(domain);
+        if (!counter) {
+            counter = {
+                count: 0,
+                lastReset: now,
+                recipients: 0,
+                errors: 0,
+                authFailures: 0,
+                connections: 0
+            };
+            this.domainCounters.set(domain, counter);
+        }
+        // Check if counter needs to be reset
+        if (now - counter.lastReset >= 60000) {
+            counter.count = 0;
+            counter.lastReset = now;
+        }
+        // Check if limit is exceeded
+        if (counter.count >= limit) {
+            // Calculate reset time
+            const resetIn = 60000 - (now - counter.lastReset);
+            logger.log('warn', `Domain ${domain} rate limit exceeded: ${counter.count}/${limit} messages per minute`);
+            return {
+                allowed: false,
+                reason: `Domain "${domain}" message rate limit exceeded`,
+                limit,
+                current: counter.count,
+                resetIn
+            };
+        }
+        // Increment counter
+        counter.count++;
+        return { allowed: true };
+    }
+    /**
+     * Check IP-specific message rate limit
+     * @param ip IP address
+     */
+    checkIpMessageLimit(ip) {
+        const now = Date.now();
+        // Get IP-specific limit or use global
+        const ipConfig = this.config.ips?.[ip];
+        const limit = ipConfig?.maxMessagesPerMinute || this.config.global.maxMessagesPerMinute;
+        if (!limit) {
+            return { allowed: true };
+        }
+        // Get or create counter
+        let counter = this.ipCounters.get(ip);
+        if (!counter) {
+            counter = {
+                count: 0,
+                lastReset: now,
+                recipients: 0,
+                errors: 0,
+                authFailures: 0,
+                connections: 0
+            };
+            this.ipCounters.set(ip, counter);
+            // Initialize IP stats if needed
+            if (!this.stats.byIp[ip]) {
+                this.stats.byIp[ip] = {
+                    messagesPerMinute: 0,
+                    totalMessages: 0,
+                    totalBlocked: 0,
+                    connections: 0,
+                    errors: 0,
+                    authFailures: 0,
+                    blocked: false
+                };
+            }
+        }
+        // Check if counter needs to be reset
+        if (now - counter.lastReset >= 60000) {
+            counter.count = 0;
+            counter.lastReset = now;
+        }
+        // Check if limit is exceeded
+        if (counter.count >= limit) {
+            // Calculate reset time
+            const resetIn = 60000 - (now - counter.lastReset);
+            // Update statistics
+            this.stats.byIp[ip].totalBlocked++;
+            this.stats.totalBlocked++;
+            return {
+                allowed: false,
+                reason: `IP ${ip} message rate limit exceeded`,
+                limit,
+                current: counter.count,
+                resetIn
+            };
+        }
+        // Increment counter
+        counter.count++;
+        // Update statistics
+        this.stats.byIp[ip].messagesPerMinute = counter.count;
+        this.stats.byIp[ip].totalMessages++;
+        return { allowed: true };
+    }
+    /**
+     * Check recipient limit
+     * @param email Email address
+     * @param recipients Number of recipients
+     * @param pattern Matched pattern
+     * @param domain Domain name
+     */
+    checkRecipientLimit(email, recipients, pattern, domain) {
+        // Get the most specific limit available
+        let limit = this.config.global.maxRecipientsPerMessage;
+        // Check pattern-specific limit
+        if (pattern && this.config.patterns?.[pattern]?.maxRecipientsPerMessage) {
+            limit = this.config.patterns[pattern].maxRecipientsPerMessage;
+        }
+        // Check domain-specific limit (overrides pattern if present)
+        if (domain && this.config.domains?.[domain]?.maxRecipientsPerMessage) {
+            limit = this.config.domains[domain].maxRecipientsPerMessage;
+        }
+        if (!limit) {
+            return { allowed: true };
+        }
+        // Check if limit is exceeded
+        if (recipients > limit) {
+            return {
+                allowed: false,
+                reason: 'Recipient limit exceeded',
+                limit,
+                current: recipients
+            };
+        }
+        return { allowed: true };
+    }
+    /**
+     * Record a connection from an IP
+     * @param ip IP address
+     * @returns Result of rate limit check
+     */
+    recordConnection(ip) {
+        const now = Date.now();
+        // Check if IP is blocked
+        if (this.isIpBlocked(ip)) {
+            return {
+                allowed: false,
+                reason: 'IP is blocked',
+                resetIn: this.getBlockReleaseTime(ip)
+            };
+        }
+        // Get IP-specific limit or use global
+        const ipConfig = this.config.ips?.[ip];
+        const limit = ipConfig?.maxConnectionsPerIP || this.config.global.maxConnectionsPerIP;
+        if (!limit) {
+            return { allowed: true };
+        }
+        // Get or create counter
+        let counter = this.ipCounters.get(ip);
+        if (!counter) {
+            counter = {
+                count: 0,
+                lastReset: now,
+                recipients: 0,
+                errors: 0,
+                authFailures: 0,
+                connections: 0
+            };
+            this.ipCounters.set(ip, counter);
+            // Initialize IP stats if needed
+            if (!this.stats.byIp[ip]) {
+                this.stats.byIp[ip] = {
+                    messagesPerMinute: 0,
+                    totalMessages: 0,
+                    totalBlocked: 0,
+                    connections: 0,
+                    errors: 0,
+                    authFailures: 0,
+                    blocked: false
+                };
+            }
+        }
+        // Check if counter needs to be reset
+        if (now - counter.lastReset >= 60000) {
+            counter.connections = 0;
+            counter.lastReset = now;
+        }
+        // Check if limit is exceeded
+        if (counter.connections >= limit) {
+            // Calculate reset time
+            const resetIn = 60000 - (now - counter.lastReset);
+            // Update statistics
+            this.stats.byIp[ip].totalBlocked++;
+            this.stats.totalBlocked++;
+            return {
+                allowed: false,
+                reason: `IP ${ip} connection rate limit exceeded`,
+                limit,
+                current: counter.connections,
+                resetIn
+            };
+        }
+        // Increment counter
+        counter.connections++;
+        // Update statistics
+        this.stats.byIp[ip].connections = counter.connections;
+        return { allowed: true };
+    }
+    /**
+     * Record an error from an IP
+     * @param ip IP address
+     * @returns True if IP should be blocked
+     */
+    recordError(ip) {
+        const now = Date.now();
+        // Get IP-specific limit or use global
+        const ipConfig = this.config.ips?.[ip];
+        const limit = ipConfig?.maxErrorsPerIP || this.config.global.maxErrorsPerIP;
+        if (!limit) {
+            return false;
+        }
+        // Get or create counter
+        let counter = this.ipCounters.get(ip);
+        if (!counter) {
+            counter = {
+                count: 0,
+                lastReset: now,
+                recipients: 0,
+                errors: 0,
+                authFailures: 0,
+                connections: 0
+            };
+            this.ipCounters.set(ip, counter);
+            // Initialize IP stats if needed
+            if (!this.stats.byIp[ip]) {
+                this.stats.byIp[ip] = {
+                    messagesPerMinute: 0,
+                    totalMessages: 0,
+                    totalBlocked: 0,
+                    connections: 0,
+                    errors: 0,
+                    authFailures: 0,
+                    blocked: false
+                };
+            }
+        }
+        // Check if counter needs to be reset
+        if (now - counter.lastReset >= 60000) {
+            counter.errors = 0;
+            counter.lastReset = now;
+        }
+        // Increment counter
+        counter.errors++;
+        // Update statistics
+        this.stats.byIp[ip].errors = counter.errors;
+        // Check if limit is exceeded
+        if (counter.errors >= limit) {
+            // Block the IP
+            this.blockIp(ip);
+            logger.log('warn', `IP ${ip} blocked due to excessive errors (${counter.errors}/${limit})`);
+            SecurityLogger.getInstance().logEvent({
+                level: SecurityLogLevel.WARN,
+                type: SecurityEventType.RATE_LIMITING,
+                message: 'IP blocked due to excessive errors',
+                ipAddress: ip,
+                details: {
+                    errors: counter.errors,
+                    limit
+                },
+                success: false
+            });
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Record an authentication failure from an IP
+     * @param ip IP address
+     * @returns True if IP should be blocked
+     */
+    recordAuthFailure(ip) {
+        const now = Date.now();
+        // Get IP-specific limit or use global
+        const ipConfig = this.config.ips?.[ip];
+        const limit = ipConfig?.maxAuthFailuresPerIP || this.config.global.maxAuthFailuresPerIP;
+        if (!limit) {
+            return false;
+        }
+        // Get or create counter
+        let counter = this.ipCounters.get(ip);
+        if (!counter) {
+            counter = {
+                count: 0,
+                lastReset: now,
+                recipients: 0,
+                errors: 0,
+                authFailures: 0,
+                connections: 0
+            };
+            this.ipCounters.set(ip, counter);
+            // Initialize IP stats if needed
+            if (!this.stats.byIp[ip]) {
+                this.stats.byIp[ip] = {
+                    messagesPerMinute: 0,
+                    totalMessages: 0,
+                    totalBlocked: 0,
+                    connections: 0,
+                    errors: 0,
+                    authFailures: 0,
+                    blocked: false
+                };
+            }
+        }
+        // Check if counter needs to be reset
+        if (now - counter.lastReset >= 60000) {
+            counter.authFailures = 0;
+            counter.lastReset = now;
+        }
+        // Increment counter
+        counter.authFailures++;
+        // Update statistics
+        this.stats.byIp[ip].authFailures = counter.authFailures;
+        // Check if limit is exceeded
+        if (counter.authFailures >= limit) {
+            // Block the IP
+            this.blockIp(ip);
+            logger.log('warn', `IP ${ip} blocked due to excessive authentication failures (${counter.authFailures}/${limit})`);
+            SecurityLogger.getInstance().logEvent({
+                level: SecurityLogLevel.WARN,
+                type: SecurityEventType.AUTHENTICATION,
+                message: 'IP blocked due to excessive authentication failures',
+                ipAddress: ip,
+                details: {
+                    authFailures: counter.authFailures,
+                    limit
+                },
+                success: false
+            });
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Block an IP address
+     * @param ip IP address to block
+     * @param duration Override the default block duration (milliseconds)
+     */
+    blockIp(ip, duration) {
+        if (!this.config.blocks) {
+            this.config.blocks = {};
+        }
+        // Set block expiry time
+        const expiry = Date.now() + (duration || this.config.global.blockDuration || 3600000);
+        this.config.blocks[ip] = expiry;
+        // Update statistics
+        if (!this.stats.byIp[ip]) {
+            this.stats.byIp[ip] = {
+                messagesPerMinute: 0,
+                totalMessages: 0,
+                totalBlocked: 0,
+                connections: 0,
+                errors: 0,
+                authFailures: 0,
+                blocked: false
+            };
+        }
+        this.stats.byIp[ip].blocked = true;
+        this.stats.currentlyBlocked++;
+        // Emit event
+        this.emit('ipBlocked', {
+            ip,
+            expiry,
+            duration: duration || this.config.global.blockDuration
+        });
+        logger.log('warn', `IP ${ip} blocked until ${new Date(expiry).toISOString()}`);
+    }
+    /**
+     * Unblock an IP address
+     * @param ip IP address to unblock
+     */
+    unblockIp(ip) {
+        if (!this.config.blocks) {
+            return;
+        }
+        // Remove block
+        delete this.config.blocks[ip];
+        // Update statistics
+        if (this.stats.byIp[ip]) {
+            this.stats.byIp[ip].blocked = false;
+            this.stats.currentlyBlocked--;
+        }
+        // Emit event
+        this.emit('ipUnblocked', { ip });
+        logger.log('info', `IP ${ip} unblocked`);
+    }
+    /**
+     * Check if an IP is blocked
+     * @param ip IP address to check
+     */
+    isIpBlocked(ip) {
+        if (!this.config.blocks) {
+            return false;
+        }
+        // Check if IP is in blocks
+        if (!(ip in this.config.blocks)) {
+            return false;
+        }
+        // Check if block has expired
+        const expiry = this.config.blocks[ip];
+        if (expiry <= Date.now()) {
+            // Remove expired block
+            delete this.config.blocks[ip];
+            // Update statistics
+            if (this.stats.byIp[ip]) {
+                this.stats.byIp[ip].blocked = false;
+                this.stats.currentlyBlocked--;
+            }
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Get the time until a block is released
+     * @param ip IP address
+     * @returns Milliseconds until release or 0 if not blocked
+     */
+    getBlockReleaseTime(ip) {
+        if (!this.config.blocks || !(ip in this.config.blocks)) {
+            return 0;
+        }
+        const expiry = this.config.blocks[ip];
+        const now = Date.now();
+        return expiry > now ? expiry - now : 0;
+    }
+    /**
+     * Update rate limiter statistics
+     */
+    updateStats() {
+        // Update active counters count
+        this.stats.activeCounters = this.counters.size + this.patternCounters.size + this.ipCounters.size;
+        // Emit statistics update
+        this.emit('statsUpdated', this.stats);
+    }
+    /**
+     * Get rate limiter statistics
+     */
+    getStats() {
+        return { ...this.stats };
+    }
+    /**
+     * Update rate limiter configuration
+     * @param config New configuration
+     */
+    updateConfig(config) {
+        if (config.global) {
+            this.config.global = {
+                ...this.config.global,
+                ...config.global
+            };
+        }
+        if (config.patterns) {
+            this.config.patterns = {
+                ...this.config.patterns,
+                ...config.patterns
+            };
+        }
+        if (config.ips) {
+            this.config.ips = {
+                ...this.config.ips,
+                ...config.ips
+            };
+        }
+        logger.log('info', 'Rate limiter configuration updated');
+    }
+    /**
+     * Get configuration for debugging
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Apply domain-specific rate limits
+     * Merges domain limits with existing configuration
+     * @param domain Domain name
+     * @param limits Rate limit configuration for the domain
+     */
+    applyDomainLimits(domain, limits) {
+        if (!this.config.domains) {
+            this.config.domains = {};
+        }
+        // Merge the limits with any existing domain config
+        this.config.domains[domain] = {
+            ...this.config.domains[domain],
+            ...limits
+        };
+        logger.log('info', `Applied rate limits for domain ${domain}:`, limits);
+    }
+    /**
+     * Remove domain-specific rate limits
+     * @param domain Domain name
+     */
+    removeDomainLimits(domain) {
+        if (this.config.domains && this.config.domains[domain]) {
+            delete this.config.domains[domain];
+            // Also remove the counter
+            this.domainCounters.delete(domain);
+            logger.log('info', `Removed rate limits for domain ${domain}`);
+        }
+    }
+    /**
+     * Get domain-specific rate limits
+     * @param domain Domain name
+     * @returns Domain rate limit config or undefined
+     */
+    getDomainLimits(domain) {
+        return this.config.domains?.[domain];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.unified.rate.limiter.js","sourceRoot":"","sources":["../../../ts/mail/delivery/classes.unified.rate.limiter.ts"],"names":[],"mappings":"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"}