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

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 {
    config;
    counters = new Map();
    patternCounters = new Map();
    ipCounters = new Map();
    domainCounters = new Map();
    cleanupInterval;
    stats;
    /**
     * Create a new unified rate limiter
     * @param config Rate limit configuration
     */
    constructor(config) {
        super();
        // 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,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