820 lines
54 KiB
JavaScript
820 lines
54 KiB
JavaScript
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,{"version":3,"file":"classes.unified.rate.limiter.js","sourceRoot":"","sources":["../../../ts/mail/delivery/classes.unified.rate.limiter.ts"],"names":[],"mappings":"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"}
|