Juergen Kunz
6b082cee8f
Use addHeader() instead of non-existent setHeader() for security result headers, and align IBounceDetection with actual Rust struct fields (bounce_type + category only).
1568 lines
127 KiB
JavaScript
1568 lines
127 KiB
JavaScript
import * as plugins from '../../plugins.js';
|
|
import * as paths from '../../paths.js';
|
|
import { EventEmitter } from 'events';
|
|
import { logger } from '../../logger.js';
|
|
import { SecurityLogger, SecurityLogLevel, SecurityEventType } from '../../security/index.js';
|
|
import { DKIMCreator } from '../security/classes.dkimcreator.js';
|
|
import { IPReputationChecker } from '../../security/classes.ipreputationchecker.js';
|
|
import { RustSecurityBridge } from '../../security/classes.rustsecuritybridge.js';
|
|
import { EmailRouter } from './classes.email.router.js';
|
|
import { Email } from '../core/classes.email.js';
|
|
import { DomainRegistry } from './classes.domain.registry.js';
|
|
import { DnsManager } from './classes.dns.manager.js';
|
|
import { BounceManager, BounceType, BounceCategory } from '../core/classes.bouncemanager.js';
|
|
import { createSmtpServer } from '../delivery/smtpserver/index.js';
|
|
import { createPooledSmtpClient } from '../delivery/smtpclient/create-client.js';
|
|
import { MultiModeDeliverySystem } from '../delivery/classes.delivery.system.js';
|
|
import { UnifiedDeliveryQueue } from '../delivery/classes.delivery.queue.js';
|
|
import { UnifiedRateLimiter } from '../delivery/classes.unified.rate.limiter.js';
|
|
import { SmtpState } from '../delivery/interfaces.js';
|
|
/**
|
|
* Unified email server that handles all email traffic with pattern-based routing
|
|
*/
|
|
export class UnifiedEmailServer extends EventEmitter {
|
|
dcRouter;
|
|
options;
|
|
emailRouter;
|
|
domainRegistry;
|
|
servers = [];
|
|
stats;
|
|
// Add components needed for sending and securing emails
|
|
dkimCreator;
|
|
rustBridge;
|
|
ipReputationChecker;
|
|
bounceManager;
|
|
ipWarmupManager;
|
|
senderReputationMonitor;
|
|
deliveryQueue;
|
|
deliverySystem;
|
|
rateLimiter; // TODO: Implement rate limiting in SMTP server handlers
|
|
dkimKeys = new Map(); // domain -> private key
|
|
smtpClients = new Map(); // host:port -> client
|
|
constructor(dcRouter, options) {
|
|
super();
|
|
this.dcRouter = dcRouter;
|
|
// Set default options
|
|
this.options = {
|
|
...options,
|
|
banner: options.banner || `${options.hostname} ESMTP UnifiedEmailServer`,
|
|
maxMessageSize: options.maxMessageSize || 10 * 1024 * 1024, // 10MB
|
|
maxClients: options.maxClients || 100,
|
|
maxConnections: options.maxConnections || 1000,
|
|
connectionTimeout: options.connectionTimeout || 60000, // 1 minute
|
|
socketTimeout: options.socketTimeout || 60000 // 1 minute
|
|
};
|
|
// Initialize Rust security bridge (singleton)
|
|
this.rustBridge = RustSecurityBridge.getInstance();
|
|
// Initialize DKIM creator with storage manager
|
|
this.dkimCreator = new DKIMCreator(paths.keysDir, dcRouter.storageManager);
|
|
// Initialize IP reputation checker with storage manager
|
|
this.ipReputationChecker = IPReputationChecker.getInstance({
|
|
enableLocalCache: true,
|
|
enableDNSBL: true,
|
|
enableIPInfo: true
|
|
}, dcRouter.storageManager);
|
|
// Initialize bounce manager with storage manager
|
|
this.bounceManager = new BounceManager({
|
|
maxCacheSize: 10000,
|
|
cacheTTL: 30 * 24 * 60 * 60 * 1000, // 30 days
|
|
storageManager: dcRouter.storageManager
|
|
});
|
|
// IP warmup manager and sender reputation monitor are optional
|
|
// They will be initialized when the deliverability module is available
|
|
this.ipWarmupManager = null;
|
|
this.senderReputationMonitor = null;
|
|
// Initialize domain registry
|
|
this.domainRegistry = new DomainRegistry(options.domains, options.defaults);
|
|
// Initialize email router with routes and storage manager
|
|
this.emailRouter = new EmailRouter(options.routes || [], {
|
|
storageManager: dcRouter.storageManager,
|
|
persistChanges: true
|
|
});
|
|
// Initialize rate limiter
|
|
this.rateLimiter = new UnifiedRateLimiter(options.rateLimits || {
|
|
global: {
|
|
maxConnectionsPerIP: 10,
|
|
maxMessagesPerMinute: 100,
|
|
maxRecipientsPerMessage: 50,
|
|
maxErrorsPerIP: 10,
|
|
maxAuthFailuresPerIP: 5,
|
|
blockDuration: 300000 // 5 minutes
|
|
}
|
|
});
|
|
// Initialize delivery components
|
|
const queueOptions = {
|
|
storageType: 'memory', // Default to memory storage
|
|
maxRetries: 3,
|
|
baseRetryDelay: 300000, // 5 minutes
|
|
maxRetryDelay: 3600000 // 1 hour
|
|
};
|
|
this.deliveryQueue = new UnifiedDeliveryQueue(queueOptions);
|
|
const deliveryOptions = {
|
|
globalRateLimit: 100, // Default to 100 emails per minute
|
|
concurrentDeliveries: 10,
|
|
processBounces: true,
|
|
bounceHandler: {
|
|
processSmtpFailure: this.processSmtpFailure.bind(this)
|
|
},
|
|
onDeliverySuccess: async (item, _result) => {
|
|
// Record delivery success event for reputation monitoring
|
|
const email = item.processingResult;
|
|
const senderDomain = email.from.split('@')[1];
|
|
if (senderDomain) {
|
|
this.recordReputationEvent(senderDomain, {
|
|
type: 'delivered',
|
|
count: email.to.length
|
|
});
|
|
}
|
|
}
|
|
};
|
|
this.deliverySystem = new MultiModeDeliverySystem(this.deliveryQueue, deliveryOptions, this);
|
|
// Initialize statistics
|
|
this.stats = {
|
|
startTime: new Date(),
|
|
connections: {
|
|
current: 0,
|
|
total: 0
|
|
},
|
|
messages: {
|
|
processed: 0,
|
|
delivered: 0,
|
|
failed: 0
|
|
},
|
|
processingTime: {
|
|
avg: 0,
|
|
max: 0,
|
|
min: 0
|
|
}
|
|
};
|
|
// We'll create the SMTP servers during the start() method
|
|
}
|
|
/**
|
|
* Get or create an SMTP client for the given host and port
|
|
* Uses connection pooling for efficiency
|
|
*/
|
|
getSmtpClient(host, port = 25) {
|
|
const clientKey = `${host}:${port}`;
|
|
// Check if we already have a client for this destination
|
|
let client = this.smtpClients.get(clientKey);
|
|
if (!client) {
|
|
// Create a new pooled SMTP client
|
|
client = createPooledSmtpClient({
|
|
host,
|
|
port,
|
|
secure: port === 465,
|
|
connectionTimeout: this.options.outbound?.connectionTimeout || 30000,
|
|
socketTimeout: this.options.outbound?.socketTimeout || 120000,
|
|
maxConnections: this.options.outbound?.maxConnections || 10,
|
|
maxMessages: 1000, // Messages per connection before reconnect
|
|
pool: true,
|
|
debug: false
|
|
});
|
|
this.smtpClients.set(clientKey, client);
|
|
logger.log('info', `Created new SMTP client pool for ${clientKey}`);
|
|
}
|
|
return client;
|
|
}
|
|
/**
|
|
* Start the unified email server
|
|
*/
|
|
async start() {
|
|
logger.log('info', `Starting UnifiedEmailServer on ports: ${this.options.ports.join(', ')}`);
|
|
try {
|
|
// Initialize the delivery queue
|
|
await this.deliveryQueue.initialize();
|
|
logger.log('info', 'Email delivery queue initialized');
|
|
// Start the delivery system
|
|
await this.deliverySystem.start();
|
|
logger.log('info', 'Email delivery system started');
|
|
// Start Rust security bridge (non-blocking — server works without it)
|
|
const bridgeOk = await this.rustBridge.start();
|
|
if (bridgeOk) {
|
|
logger.log('info', 'Rust security bridge started — using Rust for DKIM/SPF/DMARC verification');
|
|
}
|
|
else {
|
|
logger.log('warn', 'Rust security bridge unavailable — falling back to TypeScript security verification');
|
|
}
|
|
// Set up DKIM for all domains
|
|
await this.setupDkimForDomains();
|
|
logger.log('info', 'DKIM configuration completed for all domains');
|
|
// Create DNS manager and ensure all DNS records are created
|
|
const dnsManager = new DnsManager(this.dcRouter);
|
|
await dnsManager.ensureDnsRecords(this.domainRegistry.getAllConfigs(), this.dkimCreator);
|
|
logger.log('info', 'DNS records ensured for all configured domains');
|
|
// Apply per-domain rate limits
|
|
this.applyDomainRateLimits();
|
|
logger.log('info', 'Per-domain rate limits configured');
|
|
// Check and rotate DKIM keys if needed
|
|
await this.checkAndRotateDkimKeys();
|
|
logger.log('info', 'DKIM key rotation check completed');
|
|
// Skip server creation in socket-handler mode
|
|
if (this.options.useSocketHandler) {
|
|
logger.log('info', 'UnifiedEmailServer started in socket-handler mode (no port listening)');
|
|
this.emit('started');
|
|
return;
|
|
}
|
|
// Ensure we have the necessary TLS options
|
|
const hasTlsConfig = this.options.tls?.keyPath && this.options.tls?.certPath;
|
|
// Prepare the certificate and key if available
|
|
let key;
|
|
let cert;
|
|
if (hasTlsConfig) {
|
|
try {
|
|
key = plugins.fs.readFileSync(this.options.tls.keyPath, 'utf8');
|
|
cert = plugins.fs.readFileSync(this.options.tls.certPath, 'utf8');
|
|
logger.log('info', 'TLS certificates loaded successfully');
|
|
}
|
|
catch (error) {
|
|
logger.log('warn', `Failed to load TLS certificates: ${error.message}`);
|
|
}
|
|
}
|
|
// Create a SMTP server for each port
|
|
for (const port of this.options.ports) {
|
|
// Create a reference object to hold the MTA service during setup
|
|
const mtaRef = {
|
|
config: {
|
|
smtp: {
|
|
hostname: this.options.hostname
|
|
},
|
|
security: {
|
|
checkIPReputation: false,
|
|
verifyDkim: true,
|
|
verifySpf: true,
|
|
verifyDmarc: true
|
|
}
|
|
},
|
|
// Security verification delegated to the Rust bridge when available
|
|
dkimVerifier: {
|
|
verify: async (rawMessage) => {
|
|
if (this.rustBridge.running) {
|
|
try {
|
|
const results = await this.rustBridge.verifyDkim(rawMessage);
|
|
const first = results[0];
|
|
return { isValid: first?.is_valid ?? false, domain: first?.domain ?? '' };
|
|
}
|
|
catch (err) {
|
|
logger.log('warn', `Rust DKIM verification failed, accepting: ${err.message}`);
|
|
return { isValid: true, domain: '' };
|
|
}
|
|
}
|
|
return { isValid: true, domain: '' }; // No bridge — accept
|
|
}
|
|
},
|
|
spfVerifier: {
|
|
verifyAndApply: async (session) => {
|
|
if (this.rustBridge.running && session?.remoteAddress && session.remoteAddress !== '127.0.0.1') {
|
|
try {
|
|
const result = await this.rustBridge.checkSpf({
|
|
ip: session.remoteAddress,
|
|
heloDomain: session.clientHostname || '',
|
|
hostname: this.options.hostname,
|
|
mailFrom: session.envelope?.mailFrom?.address || session.mailFrom || '',
|
|
});
|
|
return result.result === 'pass' || result.result === 'none' || result.result === 'neutral';
|
|
}
|
|
catch (err) {
|
|
logger.log('warn', `Rust SPF check failed, accepting: ${err.message}`);
|
|
return true;
|
|
}
|
|
}
|
|
return true; // No bridge or localhost — accept
|
|
}
|
|
},
|
|
dmarcVerifier: {
|
|
verify: async () => ({}),
|
|
applyPolicy: () => true
|
|
},
|
|
processIncomingEmail: async (email) => {
|
|
// Process email using the new route-based system
|
|
await this.processEmailByMode(email, {
|
|
id: 'session-' + Math.random().toString(36).substring(2),
|
|
state: SmtpState.FINISHED,
|
|
mailFrom: email.from,
|
|
rcptTo: email.to,
|
|
emailData: email.toRFC822String(), // Use the proper method to get the full email content
|
|
useTLS: false,
|
|
connectionEnded: true,
|
|
remoteAddress: '127.0.0.1',
|
|
clientHostname: '',
|
|
secure: false,
|
|
authenticated: false,
|
|
envelope: {
|
|
mailFrom: { address: email.from, args: {} },
|
|
rcptTo: email.to.map(recipient => ({ address: recipient, args: {} }))
|
|
}
|
|
});
|
|
return true;
|
|
}
|
|
};
|
|
// Create server options
|
|
const serverOptions = {
|
|
port,
|
|
hostname: this.options.hostname,
|
|
key,
|
|
cert
|
|
};
|
|
// Create and start the SMTP server
|
|
const smtpServer = createSmtpServer(mtaRef, serverOptions);
|
|
this.servers.push(smtpServer);
|
|
// Start the server
|
|
await new Promise((resolve, reject) => {
|
|
try {
|
|
// Leave this empty for now, smtpServer.start() is handled by the SMTPServer class internally
|
|
// The server is started when it's created
|
|
logger.log('info', `UnifiedEmailServer listening on port ${port}`);
|
|
// Event handlers are managed internally by the SmtpServer class
|
|
// No need to access the private server property
|
|
resolve();
|
|
}
|
|
catch (err) {
|
|
if (err.code === 'EADDRINUSE') {
|
|
logger.log('error', `Port ${port} is already in use`);
|
|
reject(new Error(`Port ${port} is already in use`));
|
|
}
|
|
else {
|
|
logger.log('error', `Error starting server on port ${port}: ${err.message}`);
|
|
reject(err);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
logger.log('info', 'UnifiedEmailServer started successfully');
|
|
this.emit('started');
|
|
}
|
|
catch (error) {
|
|
logger.log('error', `Failed to start UnifiedEmailServer: ${error.message}`);
|
|
throw error;
|
|
}
|
|
}
|
|
/**
|
|
* Handle a socket from smartproxy in socket-handler mode
|
|
* @param socket The socket to handle
|
|
* @param port The port this connection is for (25, 587, 465)
|
|
*/
|
|
async handleSocket(socket, port) {
|
|
if (!this.options.useSocketHandler) {
|
|
logger.log('error', 'handleSocket called but useSocketHandler is not enabled');
|
|
socket.destroy();
|
|
return;
|
|
}
|
|
logger.log('info', `Handling socket for port ${port}`);
|
|
// Create a temporary SMTP server instance for this connection
|
|
// We need a full server instance because the SMTP protocol handler needs all components
|
|
const smtpServerOptions = {
|
|
port,
|
|
hostname: this.options.hostname,
|
|
key: this.options.tls?.keyPath ? plugins.fs.readFileSync(this.options.tls.keyPath, 'utf8') : undefined,
|
|
cert: this.options.tls?.certPath ? plugins.fs.readFileSync(this.options.tls.certPath, 'utf8') : undefined
|
|
};
|
|
// Create the SMTP server instance
|
|
const smtpServer = createSmtpServer(this, smtpServerOptions);
|
|
// Get the connection manager from the server
|
|
const connectionManager = smtpServer.connectionManager;
|
|
if (!connectionManager) {
|
|
logger.log('error', 'Could not get connection manager from SMTP server');
|
|
socket.destroy();
|
|
return;
|
|
}
|
|
// Determine if this is a secure connection
|
|
// Port 465 uses implicit TLS, so the socket is already secure
|
|
const isSecure = port === 465 || socket instanceof plugins.tls.TLSSocket;
|
|
// Pass the socket to the connection manager
|
|
try {
|
|
await connectionManager.handleConnection(socket, isSecure);
|
|
}
|
|
catch (error) {
|
|
logger.log('error', `Error handling socket connection: ${error.message}`);
|
|
socket.destroy();
|
|
}
|
|
}
|
|
/**
|
|
* Stop the unified email server
|
|
*/
|
|
async stop() {
|
|
logger.log('info', 'Stopping UnifiedEmailServer');
|
|
try {
|
|
// Clear the servers array - servers will be garbage collected
|
|
this.servers = [];
|
|
// Stop Rust security bridge
|
|
await this.rustBridge.stop();
|
|
// Stop the delivery system
|
|
if (this.deliverySystem) {
|
|
await this.deliverySystem.stop();
|
|
logger.log('info', 'Email delivery system stopped');
|
|
}
|
|
// Shut down the delivery queue
|
|
if (this.deliveryQueue) {
|
|
await this.deliveryQueue.shutdown();
|
|
logger.log('info', 'Email delivery queue shut down');
|
|
}
|
|
// Close all SMTP client connections
|
|
for (const [clientKey, client] of this.smtpClients) {
|
|
try {
|
|
await client.close();
|
|
logger.log('info', `Closed SMTP client pool for ${clientKey}`);
|
|
}
|
|
catch (error) {
|
|
logger.log('warn', `Error closing SMTP client for ${clientKey}: ${error.message}`);
|
|
}
|
|
}
|
|
this.smtpClients.clear();
|
|
logger.log('info', 'UnifiedEmailServer stopped successfully');
|
|
this.emit('stopped');
|
|
}
|
|
catch (error) {
|
|
logger.log('error', `Error stopping UnifiedEmailServer: ${error.message}`);
|
|
throw error;
|
|
}
|
|
}
|
|
/**
|
|
* Verify inbound email security (DKIM/SPF/DMARC) using the Rust bridge.
|
|
* Falls back gracefully if the bridge is not running.
|
|
*/
|
|
async verifyInboundSecurity(email, session) {
|
|
if (!this.rustBridge.running) {
|
|
return; // Bridge not available — skip verification
|
|
}
|
|
try {
|
|
const rawMessage = session.emailData || email.toRFC822String();
|
|
const result = await this.rustBridge.verifyEmail({
|
|
rawMessage,
|
|
ip: session.remoteAddress,
|
|
heloDomain: session.clientHostname || '',
|
|
hostname: this.options.hostname,
|
|
mailFrom: session.envelope?.mailFrom?.address || session.mailFrom || '',
|
|
});
|
|
// Apply DKIM result headers
|
|
if (result.dkim && result.dkim.length > 0) {
|
|
const dkimSummary = result.dkim
|
|
.map(d => `${d.status}${d.domain ? ` (${d.domain})` : ''}`)
|
|
.join(', ');
|
|
email.addHeader('X-DKIM-Result', dkimSummary);
|
|
}
|
|
// Apply SPF result header
|
|
if (result.spf) {
|
|
email.addHeader('Received-SPF', `${result.spf.result} (domain: ${result.spf.domain}, ip: ${result.spf.ip})`);
|
|
// Mark as spam on SPF hard fail
|
|
if (result.spf.result === 'fail') {
|
|
email.mightBeSpam = true;
|
|
logger.log('warn', `SPF fail for ${session.remoteAddress} — marking as potential spam`);
|
|
}
|
|
}
|
|
// Apply DMARC result header and policy
|
|
if (result.dmarc) {
|
|
email.addHeader('X-DMARC-Result', `${result.dmarc.action} (policy=${result.dmarc.policy}, dkim=${result.dmarc.dkim_result}, spf=${result.dmarc.spf_result})`);
|
|
if (result.dmarc.action === 'reject') {
|
|
email.mightBeSpam = true;
|
|
logger.log('warn', `DMARC reject for domain ${result.dmarc.domain} — marking as spam`);
|
|
}
|
|
else if (result.dmarc.action === 'quarantine') {
|
|
email.mightBeSpam = true;
|
|
logger.log('info', `DMARC quarantine for domain ${result.dmarc.domain} — marking as potential spam`);
|
|
}
|
|
}
|
|
logger.log('info', `Inbound security verified for email from ${session.remoteAddress}: DKIM=${result.dkim?.[0]?.status ?? 'none'}, SPF=${result.spf?.result ?? 'none'}, DMARC=${result.dmarc?.action ?? 'none'}`);
|
|
}
|
|
catch (err) {
|
|
logger.log('warn', `Inbound security verification failed: ${err.message} — accepting email`);
|
|
}
|
|
}
|
|
/**
|
|
* Process email based on routing rules
|
|
*/
|
|
async processEmailByMode(emailData, session) {
|
|
// Convert Buffer to Email if needed
|
|
let email;
|
|
if (Buffer.isBuffer(emailData)) {
|
|
// Parse the email data buffer into an Email object
|
|
try {
|
|
const parsed = await plugins.mailparser.simpleParser(emailData);
|
|
email = new Email({
|
|
from: parsed.from?.value[0]?.address || session.envelope.mailFrom.address,
|
|
to: session.envelope.rcptTo[0]?.address || '',
|
|
subject: parsed.subject || '',
|
|
text: parsed.text || '',
|
|
html: parsed.html || undefined,
|
|
attachments: parsed.attachments?.map(att => ({
|
|
filename: att.filename || '',
|
|
content: att.content,
|
|
contentType: att.contentType
|
|
})) || []
|
|
});
|
|
}
|
|
catch (error) {
|
|
logger.log('error', `Error parsing email data: ${error.message}`);
|
|
throw new Error(`Error parsing email data: ${error.message}`);
|
|
}
|
|
}
|
|
else {
|
|
email = emailData;
|
|
}
|
|
// Run inbound security verification (DKIM/SPF/DMARC) via Rust bridge
|
|
if (session.remoteAddress && session.remoteAddress !== '127.0.0.1') {
|
|
await this.verifyInboundSecurity(email, session);
|
|
}
|
|
// First check if this is a bounce notification email
|
|
// Look for common bounce notification subject patterns
|
|
const subject = email.subject || '';
|
|
const isBounceLike = /mail delivery|delivery (failed|status|notification)|failure notice|returned mail|undeliverable|delivery problem/i.test(subject);
|
|
if (isBounceLike) {
|
|
logger.log('info', `Email subject matches bounce notification pattern: "${subject}"`);
|
|
// Try to process as a bounce
|
|
const isBounce = await this.processBounceNotification(email);
|
|
if (isBounce) {
|
|
logger.log('info', 'Successfully processed as bounce notification, skipping regular processing');
|
|
return email;
|
|
}
|
|
logger.log('info', 'Not a valid bounce notification, continuing with regular processing');
|
|
}
|
|
// Find matching route
|
|
const context = { email, session };
|
|
const route = await this.emailRouter.evaluateRoutes(context);
|
|
if (!route) {
|
|
// No matching route - reject
|
|
throw new Error('No matching route for email');
|
|
}
|
|
// Store matched route in session
|
|
session.matchedRoute = route;
|
|
// Execute action based on route
|
|
await this.executeAction(route.action, email, context);
|
|
// Return the processed email
|
|
return email;
|
|
}
|
|
/**
|
|
* Execute action based on route configuration
|
|
*/
|
|
async executeAction(action, email, context) {
|
|
switch (action.type) {
|
|
case 'forward':
|
|
await this.handleForwardAction(action, email, context);
|
|
break;
|
|
case 'process':
|
|
await this.handleProcessAction(action, email, context);
|
|
break;
|
|
case 'deliver':
|
|
await this.handleDeliverAction(action, email, context);
|
|
break;
|
|
case 'reject':
|
|
await this.handleRejectAction(action, email, context);
|
|
break;
|
|
default:
|
|
throw new Error(`Unknown action type: ${action.type}`);
|
|
}
|
|
}
|
|
/**
|
|
* Handle forward action
|
|
*/
|
|
async handleForwardAction(_action, email, context) {
|
|
if (!_action.forward) {
|
|
throw new Error('Forward action requires forward configuration');
|
|
}
|
|
const { host, port = 25, auth, addHeaders } = _action.forward;
|
|
logger.log('info', `Forwarding email to ${host}:${port}`);
|
|
// Add forwarding headers
|
|
if (addHeaders) {
|
|
for (const [key, value] of Object.entries(addHeaders)) {
|
|
email.headers[key] = value;
|
|
}
|
|
}
|
|
// Add standard forwarding headers
|
|
email.headers['X-Forwarded-For'] = context.session.remoteAddress || 'unknown';
|
|
email.headers['X-Forwarded-To'] = email.to.join(', ');
|
|
email.headers['X-Forwarded-Date'] = new Date().toISOString();
|
|
// Get SMTP client
|
|
const client = this.getSmtpClient(host, port);
|
|
try {
|
|
// Send email
|
|
await client.sendMail(email);
|
|
logger.log('info', `Successfully forwarded email to ${host}:${port}`);
|
|
SecurityLogger.getInstance().logEvent({
|
|
level: SecurityLogLevel.INFO,
|
|
type: SecurityEventType.EMAIL_FORWARDING,
|
|
message: 'Email forwarded successfully',
|
|
ipAddress: context.session.remoteAddress,
|
|
details: {
|
|
sessionId: context.session.id,
|
|
routeName: context.session.matchedRoute?.name,
|
|
targetHost: host,
|
|
targetPort: port,
|
|
recipients: email.to
|
|
},
|
|
success: true
|
|
});
|
|
}
|
|
catch (error) {
|
|
logger.log('error', `Failed to forward email: ${error.message}`);
|
|
SecurityLogger.getInstance().logEvent({
|
|
level: SecurityLogLevel.ERROR,
|
|
type: SecurityEventType.EMAIL_FORWARDING,
|
|
message: 'Email forwarding failed',
|
|
ipAddress: context.session.remoteAddress,
|
|
details: {
|
|
sessionId: context.session.id,
|
|
routeName: context.session.matchedRoute?.name,
|
|
targetHost: host,
|
|
targetPort: port,
|
|
error: error.message
|
|
},
|
|
success: false
|
|
});
|
|
// Handle as bounce
|
|
for (const recipient of email.getAllRecipients()) {
|
|
await this.bounceManager.processSmtpFailure(recipient, error.message, {
|
|
sender: email.from,
|
|
originalEmailId: email.headers['Message-ID']
|
|
});
|
|
}
|
|
throw error;
|
|
}
|
|
}
|
|
/**
|
|
* Handle process action
|
|
*/
|
|
async handleProcessAction(action, email, context) {
|
|
logger.log('info', `Processing email with action options`);
|
|
// Apply scanning if requested
|
|
if (action.process?.scan) {
|
|
// Use existing content scanner
|
|
// Note: ContentScanner integration would go here
|
|
logger.log('info', 'Content scanning requested');
|
|
}
|
|
// Note: DKIM signing will be applied at delivery time to ensure signature validity
|
|
// Queue for delivery
|
|
const queue = action.process?.queue || 'normal';
|
|
await this.deliveryQueue.enqueue(email, 'process', context.session.matchedRoute);
|
|
logger.log('info', `Email queued for delivery in ${queue} queue`);
|
|
}
|
|
/**
|
|
* Handle deliver action
|
|
*/
|
|
async handleDeliverAction(_action, email, context) {
|
|
logger.log('info', `Delivering email locally`);
|
|
// Queue for local delivery
|
|
await this.deliveryQueue.enqueue(email, 'mta', context.session.matchedRoute);
|
|
logger.log('info', 'Email queued for local delivery');
|
|
}
|
|
/**
|
|
* Handle reject action
|
|
*/
|
|
async handleRejectAction(action, email, context) {
|
|
const code = action.reject?.code || 550;
|
|
const message = action.reject?.message || 'Message rejected';
|
|
logger.log('info', `Rejecting email with code ${code}: ${message}`);
|
|
SecurityLogger.getInstance().logEvent({
|
|
level: SecurityLogLevel.WARN,
|
|
type: SecurityEventType.EMAIL_PROCESSING,
|
|
message: 'Email rejected by routing rule',
|
|
ipAddress: context.session.remoteAddress,
|
|
details: {
|
|
sessionId: context.session.id,
|
|
routeName: context.session.matchedRoute?.name,
|
|
rejectCode: code,
|
|
rejectMessage: message,
|
|
from: email.from,
|
|
to: email.to
|
|
},
|
|
success: false
|
|
});
|
|
// Throw error with SMTP code and message
|
|
const error = new Error(message);
|
|
error.responseCode = code;
|
|
throw error;
|
|
}
|
|
/**
|
|
* Handle email in MTA mode (programmatic processing)
|
|
*/
|
|
async _handleMtaMode(email, session) {
|
|
logger.log('info', `Handling email in MTA mode for session ${session.id}`);
|
|
try {
|
|
// Apply MTA rule options if provided
|
|
if (session.matchedRoute?.action.options?.mtaOptions) {
|
|
const options = session.matchedRoute.action.options.mtaOptions;
|
|
// Apply DKIM signing if enabled
|
|
if (options.dkimSign && options.dkimOptions) {
|
|
// Sign the email with DKIM
|
|
logger.log('info', `Signing email with DKIM for domain ${options.dkimOptions.domainName}`);
|
|
try {
|
|
// Ensure DKIM keys exist for the domain
|
|
await this.dkimCreator.handleDKIMKeysForDomain(options.dkimOptions.domainName);
|
|
// Convert Email to raw format for signing
|
|
const rawEmail = email.toRFC822String();
|
|
// Create headers object
|
|
const headers = {};
|
|
for (const [key, value] of Object.entries(email.headers)) {
|
|
headers[key] = value;
|
|
}
|
|
// Sign the email
|
|
const dkimDomain = options.dkimOptions.domainName;
|
|
const dkimSelector = options.dkimOptions.keySelector || 'mta';
|
|
const dkimPrivateKey = (await this.dkimCreator.readDKIMKeys(dkimDomain)).privateKey;
|
|
const signResult = await plugins.dkimSign(rawEmail, {
|
|
signingDomain: dkimDomain,
|
|
selector: dkimSelector,
|
|
privateKey: dkimPrivateKey,
|
|
canonicalization: 'relaxed/relaxed',
|
|
algorithm: 'rsa-sha256',
|
|
signTime: new Date(),
|
|
signatureData: [
|
|
{
|
|
signingDomain: dkimDomain,
|
|
selector: dkimSelector,
|
|
privateKey: dkimPrivateKey,
|
|
algorithm: 'rsa-sha256',
|
|
canonicalization: 'relaxed/relaxed'
|
|
}
|
|
]
|
|
});
|
|
// Add the DKIM-Signature header to the email
|
|
if (signResult.signatures) {
|
|
email.addHeader('DKIM-Signature', signResult.signatures);
|
|
logger.log('info', `Successfully added DKIM signature for ${options.dkimOptions.domainName}`);
|
|
}
|
|
}
|
|
catch (error) {
|
|
logger.log('error', `Failed to sign email with DKIM: ${error.message}`);
|
|
}
|
|
}
|
|
}
|
|
// Get email content for logging/processing
|
|
const subject = email.subject;
|
|
const recipients = email.getAllRecipients().join(', ');
|
|
logger.log('info', `Email processed by MTA: ${subject} to ${recipients}`);
|
|
SecurityLogger.getInstance().logEvent({
|
|
level: SecurityLogLevel.INFO,
|
|
type: SecurityEventType.EMAIL_PROCESSING,
|
|
message: 'Email processed by MTA',
|
|
ipAddress: session.remoteAddress,
|
|
details: {
|
|
sessionId: session.id,
|
|
ruleName: session.matchedRoute?.name || 'default',
|
|
subject,
|
|
recipients
|
|
},
|
|
success: true
|
|
});
|
|
}
|
|
catch (error) {
|
|
logger.log('error', `Failed to process email in MTA mode: ${error.message}`);
|
|
SecurityLogger.getInstance().logEvent({
|
|
level: SecurityLogLevel.ERROR,
|
|
type: SecurityEventType.EMAIL_PROCESSING,
|
|
message: 'MTA processing failed',
|
|
ipAddress: session.remoteAddress,
|
|
details: {
|
|
sessionId: session.id,
|
|
ruleName: session.matchedRoute?.name || 'default',
|
|
error: error.message
|
|
},
|
|
success: false
|
|
});
|
|
throw error;
|
|
}
|
|
}
|
|
/**
|
|
* Handle email in process mode (store-and-forward with scanning)
|
|
*/
|
|
async _handleProcessMode(email, session) {
|
|
logger.log('info', `Handling email in process mode for session ${session.id}`);
|
|
try {
|
|
const route = session.matchedRoute;
|
|
// Apply content scanning if enabled
|
|
if (route?.action.options?.contentScanning && route.action.options.scanners && route.action.options.scanners.length > 0) {
|
|
logger.log('info', 'Performing content scanning');
|
|
// Apply each scanner
|
|
for (const scanner of route.action.options.scanners) {
|
|
switch (scanner.type) {
|
|
case 'spam':
|
|
logger.log('info', 'Scanning for spam content');
|
|
// Implement spam scanning
|
|
break;
|
|
case 'virus':
|
|
logger.log('info', 'Scanning for virus content');
|
|
// Implement virus scanning
|
|
break;
|
|
case 'attachment':
|
|
logger.log('info', 'Scanning attachments');
|
|
// Check for blocked extensions
|
|
if (scanner.blockedExtensions && scanner.blockedExtensions.length > 0) {
|
|
for (const attachment of email.attachments) {
|
|
const ext = this.getFileExtension(attachment.filename);
|
|
if (scanner.blockedExtensions.includes(ext)) {
|
|
if (scanner.action === 'reject') {
|
|
throw new Error(`Blocked attachment type: ${ext}`);
|
|
}
|
|
else { // tag
|
|
email.addHeader('X-Attachment-Warning', `Potentially unsafe attachment: ${attachment.filename}`);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
// Apply transformations if defined
|
|
if (route?.action.options?.transformations && route.action.options.transformations.length > 0) {
|
|
logger.log('info', 'Applying email transformations');
|
|
for (const transform of route.action.options.transformations) {
|
|
switch (transform.type) {
|
|
case 'addHeader':
|
|
if (transform.header && transform.value) {
|
|
email.addHeader(transform.header, transform.value);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
logger.log('info', `Email successfully processed in store-and-forward mode`);
|
|
SecurityLogger.getInstance().logEvent({
|
|
level: SecurityLogLevel.INFO,
|
|
type: SecurityEventType.EMAIL_PROCESSING,
|
|
message: 'Email processed and queued',
|
|
ipAddress: session.remoteAddress,
|
|
details: {
|
|
sessionId: session.id,
|
|
ruleName: route?.name || 'default',
|
|
contentScanning: route?.action.options?.contentScanning || false,
|
|
subject: email.subject
|
|
},
|
|
success: true
|
|
});
|
|
}
|
|
catch (error) {
|
|
logger.log('error', `Failed to process email: ${error.message}`);
|
|
SecurityLogger.getInstance().logEvent({
|
|
level: SecurityLogLevel.ERROR,
|
|
type: SecurityEventType.EMAIL_PROCESSING,
|
|
message: 'Email processing failed',
|
|
ipAddress: session.remoteAddress,
|
|
details: {
|
|
sessionId: session.id,
|
|
ruleName: session.matchedRoute?.name || 'default',
|
|
error: error.message
|
|
},
|
|
success: false
|
|
});
|
|
throw error;
|
|
}
|
|
}
|
|
/**
|
|
* Get file extension from filename
|
|
*/
|
|
getFileExtension(filename) {
|
|
return filename.substring(filename.lastIndexOf('.')).toLowerCase();
|
|
}
|
|
/**
|
|
* Set up DKIM configuration for all domains
|
|
*/
|
|
async setupDkimForDomains() {
|
|
const domainConfigs = this.domainRegistry.getAllConfigs();
|
|
if (domainConfigs.length === 0) {
|
|
logger.log('warn', 'No domains configured for DKIM');
|
|
return;
|
|
}
|
|
for (const domainConfig of domainConfigs) {
|
|
const domain = domainConfig.domain;
|
|
const selector = domainConfig.dkim?.selector || 'default';
|
|
try {
|
|
// Check if DKIM keys already exist for this domain
|
|
let keyPair;
|
|
try {
|
|
// Try to read existing keys
|
|
keyPair = await this.dkimCreator.readDKIMKeys(domain);
|
|
logger.log('info', `Using existing DKIM keys for domain: ${domain}`);
|
|
}
|
|
catch (error) {
|
|
// Generate new keys if they don't exist
|
|
keyPair = await this.dkimCreator.createDKIMKeys();
|
|
// Store them for future use
|
|
await this.dkimCreator.createAndStoreDKIMKeys(domain);
|
|
logger.log('info', `Generated new DKIM keys for domain: ${domain}`);
|
|
}
|
|
// Store the private key for signing
|
|
this.dkimKeys.set(domain, keyPair.privateKey);
|
|
// DNS record creation is now handled by DnsManager
|
|
logger.log('info', `DKIM keys loaded for domain: ${domain} with selector: ${selector}`);
|
|
}
|
|
catch (error) {
|
|
logger.log('error', `Failed to set up DKIM for domain ${domain}: ${error.message}`);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Apply per-domain rate limits from domain configurations
|
|
*/
|
|
applyDomainRateLimits() {
|
|
const domainConfigs = this.domainRegistry.getAllConfigs();
|
|
for (const domainConfig of domainConfigs) {
|
|
if (domainConfig.rateLimits) {
|
|
const domain = domainConfig.domain;
|
|
const rateLimitConfig = {};
|
|
// Convert domain-specific rate limits to the format expected by UnifiedRateLimiter
|
|
if (domainConfig.rateLimits.outbound) {
|
|
if (domainConfig.rateLimits.outbound.messagesPerMinute) {
|
|
rateLimitConfig.maxMessagesPerMinute = domainConfig.rateLimits.outbound.messagesPerMinute;
|
|
}
|
|
// Note: messagesPerHour and messagesPerDay would need additional implementation in rate limiter
|
|
}
|
|
if (domainConfig.rateLimits.inbound) {
|
|
if (domainConfig.rateLimits.inbound.messagesPerMinute) {
|
|
rateLimitConfig.maxMessagesPerMinute = domainConfig.rateLimits.inbound.messagesPerMinute;
|
|
}
|
|
if (domainConfig.rateLimits.inbound.connectionsPerIp) {
|
|
rateLimitConfig.maxConnectionsPerIP = domainConfig.rateLimits.inbound.connectionsPerIp;
|
|
}
|
|
if (domainConfig.rateLimits.inbound.recipientsPerMessage) {
|
|
rateLimitConfig.maxRecipientsPerMessage = domainConfig.rateLimits.inbound.recipientsPerMessage;
|
|
}
|
|
}
|
|
// Apply the rate limits if we have any
|
|
if (Object.keys(rateLimitConfig).length > 0) {
|
|
this.rateLimiter.applyDomainLimits(domain, rateLimitConfig);
|
|
logger.log('info', `Applied rate limits for domain ${domain}:`, rateLimitConfig);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Check and rotate DKIM keys if needed
|
|
*/
|
|
async checkAndRotateDkimKeys() {
|
|
const domainConfigs = this.domainRegistry.getAllConfigs();
|
|
for (const domainConfig of domainConfigs) {
|
|
const domain = domainConfig.domain;
|
|
const selector = domainConfig.dkim?.selector || 'default';
|
|
const rotateKeys = domainConfig.dkim?.rotateKeys || false;
|
|
const rotationInterval = domainConfig.dkim?.rotationInterval || 90;
|
|
const keySize = domainConfig.dkim?.keySize || 2048;
|
|
if (!rotateKeys) {
|
|
logger.log('debug', `DKIM key rotation disabled for ${domain}`);
|
|
continue;
|
|
}
|
|
try {
|
|
// Check if keys need rotation
|
|
const needsRotation = await this.dkimCreator.needsRotation(domain, selector, rotationInterval);
|
|
if (needsRotation) {
|
|
logger.log('info', `DKIM keys need rotation for ${domain} (selector: ${selector})`);
|
|
// Rotate the keys
|
|
const newSelector = await this.dkimCreator.rotateDkimKeys(domain, selector, keySize);
|
|
// Update the domain config with new selector
|
|
domainConfig.dkim = {
|
|
...domainConfig.dkim,
|
|
selector: newSelector
|
|
};
|
|
// Re-register DNS handler for new selector if internal-dns mode
|
|
if (domainConfig.dnsMode === 'internal-dns' && this.dcRouter.dnsServer) {
|
|
// Get new public key
|
|
const keyPair = await this.dkimCreator.readDKIMKeysForSelector(domain, newSelector);
|
|
const publicKeyBase64 = keyPair.publicKey
|
|
.replace(/-----BEGIN PUBLIC KEY-----/g, '')
|
|
.replace(/-----END PUBLIC KEY-----/g, '')
|
|
.replace(/\s/g, '');
|
|
const ttl = domainConfig.dns?.internal?.ttl || 3600;
|
|
// Register new selector
|
|
this.dcRouter.dnsServer.registerHandler(`${newSelector}._domainkey.${domain}`, ['TXT'], () => ({
|
|
name: `${newSelector}._domainkey.${domain}`,
|
|
type: 'TXT',
|
|
class: 'IN',
|
|
ttl: ttl,
|
|
data: `v=DKIM1; k=rsa; p=${publicKeyBase64}`
|
|
}));
|
|
logger.log('info', `DKIM DNS handler registered for new selector: ${newSelector}._domainkey.${domain}`);
|
|
// Store the updated public key in storage
|
|
await this.dcRouter.storageManager.set(`/email/dkim/${domain}/public.key`, keyPair.publicKey);
|
|
}
|
|
// Clean up old keys after grace period (async, don't wait)
|
|
this.dkimCreator.cleanupOldKeys(domain, 30).catch(error => {
|
|
logger.log('warn', `Failed to cleanup old DKIM keys for ${domain}: ${error.message}`);
|
|
});
|
|
}
|
|
else {
|
|
logger.log('debug', `DKIM keys for ${domain} are up to date`);
|
|
}
|
|
}
|
|
catch (error) {
|
|
logger.log('error', `Failed to check/rotate DKIM keys for ${domain}: ${error.message}`);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Generate SmartProxy routes for email ports
|
|
*/
|
|
generateProxyRoutes(portMapping) {
|
|
const routes = [];
|
|
const defaultPortMapping = {
|
|
25: 10025,
|
|
587: 10587,
|
|
465: 10465
|
|
};
|
|
const actualPortMapping = portMapping || defaultPortMapping;
|
|
// Generate routes for each configured port
|
|
for (const externalPort of this.options.ports) {
|
|
const internalPort = actualPortMapping[externalPort] || externalPort + 10000;
|
|
let routeName = 'email-route';
|
|
let tlsMode = 'passthrough';
|
|
// Configure based on port
|
|
switch (externalPort) {
|
|
case 25:
|
|
routeName = 'smtp-route';
|
|
tlsMode = 'passthrough'; // STARTTLS
|
|
break;
|
|
case 587:
|
|
routeName = 'submission-route';
|
|
tlsMode = 'passthrough'; // STARTTLS
|
|
break;
|
|
case 465:
|
|
routeName = 'smtps-route';
|
|
tlsMode = 'terminate'; // Implicit TLS
|
|
break;
|
|
default:
|
|
routeName = `email-port-${externalPort}-route`;
|
|
}
|
|
routes.push({
|
|
name: routeName,
|
|
match: {
|
|
ports: [externalPort]
|
|
},
|
|
action: {
|
|
type: 'forward',
|
|
target: {
|
|
host: 'localhost',
|
|
port: internalPort
|
|
},
|
|
tls: {
|
|
mode: tlsMode
|
|
}
|
|
}
|
|
});
|
|
}
|
|
return routes;
|
|
}
|
|
/**
|
|
* Update server configuration
|
|
*/
|
|
updateOptions(options) {
|
|
// Stop the server if changing ports
|
|
const portsChanged = options.ports &&
|
|
(!this.options.ports ||
|
|
JSON.stringify(options.ports) !== JSON.stringify(this.options.ports));
|
|
if (portsChanged) {
|
|
this.stop().then(() => {
|
|
this.options = { ...this.options, ...options };
|
|
this.start();
|
|
});
|
|
}
|
|
else {
|
|
// Update options without restart
|
|
this.options = { ...this.options, ...options };
|
|
// Update domain registry if domains changed
|
|
if (options.domains) {
|
|
this.domainRegistry = new DomainRegistry(options.domains, options.defaults || this.options.defaults);
|
|
}
|
|
// Update email router if routes changed
|
|
if (options.routes) {
|
|
this.emailRouter.updateRoutes(options.routes);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Update email routes
|
|
*/
|
|
updateEmailRoutes(routes) {
|
|
this.options.routes = routes;
|
|
this.emailRouter.updateRoutes(routes);
|
|
}
|
|
/**
|
|
* Get server statistics
|
|
*/
|
|
getStats() {
|
|
return { ...this.stats };
|
|
}
|
|
/**
|
|
* Get domain registry
|
|
*/
|
|
getDomainRegistry() {
|
|
return this.domainRegistry;
|
|
}
|
|
/**
|
|
* Update email routes dynamically
|
|
*/
|
|
updateRoutes(routes) {
|
|
this.emailRouter.setRoutes(routes);
|
|
logger.log('info', `Updated email routes with ${routes.length} routes`);
|
|
}
|
|
/**
|
|
* Send an email through the delivery system
|
|
* @param email The email to send
|
|
* @param mode The processing mode to use
|
|
* @param rule Optional rule to apply
|
|
* @param options Optional sending options
|
|
* @returns The ID of the queued email
|
|
*/
|
|
async sendEmail(email, mode = 'mta', route, options) {
|
|
logger.log('info', `Sending email: ${email.subject} to ${email.to.join(', ')}`);
|
|
try {
|
|
// Validate the email
|
|
if (!email.from) {
|
|
throw new Error('Email must have a sender address');
|
|
}
|
|
if (!email.to || email.to.length === 0) {
|
|
throw new Error('Email must have at least one recipient');
|
|
}
|
|
// Check if any recipients are on the suppression list (unless explicitly skipped)
|
|
if (!options?.skipSuppressionCheck) {
|
|
const suppressedRecipients = email.to.filter(recipient => this.isEmailSuppressed(recipient));
|
|
if (suppressedRecipients.length > 0) {
|
|
// Filter out suppressed recipients
|
|
const originalCount = email.to.length;
|
|
const suppressed = suppressedRecipients.map(recipient => {
|
|
const info = this.getSuppressionInfo(recipient);
|
|
return {
|
|
email: recipient,
|
|
reason: info?.reason || 'Unknown',
|
|
until: info?.expiresAt ? new Date(info.expiresAt).toISOString() : 'permanent'
|
|
};
|
|
});
|
|
logger.log('warn', `Filtering out ${suppressedRecipients.length} suppressed recipient(s)`, { suppressed });
|
|
// If all recipients are suppressed, throw an error
|
|
if (suppressedRecipients.length === originalCount) {
|
|
throw new Error('All recipients are on the suppression list');
|
|
}
|
|
// Filter the recipients list to only include non-suppressed addresses
|
|
email.to = email.to.filter(recipient => !this.isEmailSuppressed(recipient));
|
|
}
|
|
}
|
|
// IP warmup handling
|
|
let ipAddress = options?.ipAddress;
|
|
// If no specific IP was provided, use IP warmup manager to find the best IP
|
|
if (!ipAddress) {
|
|
const domain = email.from.split('@')[1];
|
|
ipAddress = this.getBestIPForSending({
|
|
from: email.from,
|
|
to: email.to,
|
|
domain,
|
|
isTransactional: options?.isTransactional
|
|
});
|
|
if (ipAddress) {
|
|
logger.log('info', `Selected IP ${ipAddress} for sending based on warmup status`);
|
|
}
|
|
}
|
|
// If an IP is provided or selected by warmup manager, check its capacity
|
|
if (ipAddress) {
|
|
// Check if the IP can send more today
|
|
if (!this.canIPSendMoreToday(ipAddress)) {
|
|
logger.log('warn', `IP ${ipAddress} has reached its daily sending limit, email will be queued for later delivery`);
|
|
}
|
|
// Check if the IP can send more this hour
|
|
if (!this.canIPSendMoreThisHour(ipAddress)) {
|
|
logger.log('warn', `IP ${ipAddress} has reached its hourly sending limit, email will be queued for later delivery`);
|
|
}
|
|
// Record the send for IP warmup tracking
|
|
this.recordIPSend(ipAddress);
|
|
// Add IP header to the email
|
|
email.addHeader('X-Sending-IP', ipAddress);
|
|
}
|
|
// Check if the sender domain has DKIM keys and sign the email if needed
|
|
if (mode === 'mta' && route?.action.options?.mtaOptions?.dkimSign) {
|
|
const domain = email.from.split('@')[1];
|
|
await this.handleDkimSigning(email, domain, route.action.options.mtaOptions.dkimOptions?.keySelector || 'mta');
|
|
}
|
|
// Generate a unique ID for this email
|
|
const id = plugins.uuid.v4();
|
|
// Queue the email for delivery
|
|
await this.deliveryQueue.enqueue(email, mode, route);
|
|
// Record 'sent' event for domain reputation monitoring
|
|
const senderDomain = email.from.split('@')[1];
|
|
if (senderDomain) {
|
|
this.recordReputationEvent(senderDomain, {
|
|
type: 'sent',
|
|
count: email.to.length
|
|
});
|
|
}
|
|
logger.log('info', `Email queued with ID: ${id}`);
|
|
return id;
|
|
}
|
|
catch (error) {
|
|
logger.log('error', `Failed to send email: ${error.message}`);
|
|
throw error;
|
|
}
|
|
}
|
|
/**
|
|
* Handle DKIM signing for an email
|
|
* @param email The email to sign
|
|
* @param domain The domain to sign with
|
|
* @param selector The DKIM selector
|
|
*/
|
|
async handleDkimSigning(email, domain, selector) {
|
|
try {
|
|
// Ensure we have DKIM keys for this domain
|
|
await this.dkimCreator.handleDKIMKeysForDomain(domain);
|
|
// Get the private key
|
|
const { privateKey } = await this.dkimCreator.readDKIMKeys(domain);
|
|
// Convert Email to raw format for signing
|
|
const rawEmail = email.toRFC822String();
|
|
// Sign the email
|
|
const signResult = await plugins.dkimSign(rawEmail, {
|
|
signingDomain: domain,
|
|
selector: selector,
|
|
privateKey: privateKey,
|
|
canonicalization: 'relaxed/relaxed',
|
|
algorithm: 'rsa-sha256',
|
|
signTime: new Date(),
|
|
signatureData: [
|
|
{
|
|
signingDomain: domain,
|
|
selector: selector,
|
|
privateKey: privateKey,
|
|
algorithm: 'rsa-sha256',
|
|
canonicalization: 'relaxed/relaxed'
|
|
}
|
|
]
|
|
});
|
|
// Add the DKIM-Signature header to the email
|
|
if (signResult.signatures) {
|
|
email.addHeader('DKIM-Signature', signResult.signatures);
|
|
logger.log('info', `Successfully added DKIM signature for ${domain}`);
|
|
}
|
|
}
|
|
catch (error) {
|
|
logger.log('error', `Failed to sign email with DKIM: ${error.message}`);
|
|
// Continue without DKIM rather than failing the send
|
|
}
|
|
}
|
|
/**
|
|
* Process a bounce notification email
|
|
* @param bounceEmail The email containing bounce notification information
|
|
* @returns Processed bounce record or null if not a bounce
|
|
*/
|
|
async processBounceNotification(bounceEmail) {
|
|
logger.log('info', 'Processing potential bounce notification email');
|
|
try {
|
|
// Process as a bounce notification (no conversion needed anymore)
|
|
const bounceRecord = await this.bounceManager.processBounceEmail(bounceEmail);
|
|
if (bounceRecord) {
|
|
logger.log('info', `Successfully processed bounce notification for ${bounceRecord.recipient}`, {
|
|
bounceType: bounceRecord.bounceType,
|
|
bounceCategory: bounceRecord.bounceCategory
|
|
});
|
|
// Notify any registered listeners about the bounce
|
|
this.emit('bounceProcessed', bounceRecord);
|
|
// Record bounce event for domain reputation tracking
|
|
if (bounceRecord.domain) {
|
|
this.recordReputationEvent(bounceRecord.domain, {
|
|
type: 'bounce',
|
|
hardBounce: bounceRecord.bounceCategory === BounceCategory.HARD,
|
|
receivingDomain: bounceRecord.recipient.split('@')[1]
|
|
});
|
|
}
|
|
// Log security event
|
|
SecurityLogger.getInstance().logEvent({
|
|
level: SecurityLogLevel.INFO,
|
|
type: SecurityEventType.EMAIL_VALIDATION,
|
|
message: `Bounce notification processed for recipient`,
|
|
domain: bounceRecord.domain,
|
|
details: {
|
|
recipient: bounceRecord.recipient,
|
|
bounceType: bounceRecord.bounceType,
|
|
bounceCategory: bounceRecord.bounceCategory
|
|
},
|
|
success: true
|
|
});
|
|
return true;
|
|
}
|
|
else {
|
|
logger.log('info', 'Email not recognized as a bounce notification');
|
|
return false;
|
|
}
|
|
}
|
|
catch (error) {
|
|
logger.log('error', `Error processing bounce notification: ${error.message}`);
|
|
SecurityLogger.getInstance().logEvent({
|
|
level: SecurityLogLevel.ERROR,
|
|
type: SecurityEventType.EMAIL_VALIDATION,
|
|
message: 'Failed to process bounce notification',
|
|
details: {
|
|
error: error.message,
|
|
subject: bounceEmail.subject
|
|
},
|
|
success: false
|
|
});
|
|
return false;
|
|
}
|
|
}
|
|
/**
|
|
* Process an SMTP failure as a bounce
|
|
* @param recipient Recipient email that failed
|
|
* @param smtpResponse SMTP error response
|
|
* @param options Additional options for bounce processing
|
|
* @returns Processed bounce record
|
|
*/
|
|
async processSmtpFailure(recipient, smtpResponse, options = {}) {
|
|
logger.log('info', `Processing SMTP failure for ${recipient}: ${smtpResponse}`);
|
|
try {
|
|
// Process the SMTP failure through the bounce manager
|
|
const bounceRecord = await this.bounceManager.processSmtpFailure(recipient, smtpResponse, options);
|
|
logger.log('info', `Successfully processed SMTP failure for ${recipient} as ${bounceRecord.bounceCategory} bounce`, {
|
|
bounceType: bounceRecord.bounceType
|
|
});
|
|
// Notify any registered listeners about the bounce
|
|
this.emit('bounceProcessed', bounceRecord);
|
|
// Record bounce event for domain reputation tracking
|
|
if (bounceRecord.domain) {
|
|
this.recordReputationEvent(bounceRecord.domain, {
|
|
type: 'bounce',
|
|
hardBounce: bounceRecord.bounceCategory === BounceCategory.HARD,
|
|
receivingDomain: bounceRecord.recipient.split('@')[1]
|
|
});
|
|
}
|
|
// Log security event
|
|
SecurityLogger.getInstance().logEvent({
|
|
level: SecurityLogLevel.INFO,
|
|
type: SecurityEventType.EMAIL_VALIDATION,
|
|
message: `SMTP failure processed for recipient`,
|
|
domain: bounceRecord.domain,
|
|
details: {
|
|
recipient: bounceRecord.recipient,
|
|
bounceType: bounceRecord.bounceType,
|
|
bounceCategory: bounceRecord.bounceCategory,
|
|
smtpResponse
|
|
},
|
|
success: true
|
|
});
|
|
return true;
|
|
}
|
|
catch (error) {
|
|
logger.log('error', `Error processing SMTP failure: ${error.message}`);
|
|
SecurityLogger.getInstance().logEvent({
|
|
level: SecurityLogLevel.ERROR,
|
|
type: SecurityEventType.EMAIL_VALIDATION,
|
|
message: 'Failed to process SMTP failure',
|
|
details: {
|
|
recipient,
|
|
smtpResponse,
|
|
error: error.message
|
|
},
|
|
success: false
|
|
});
|
|
return false;
|
|
}
|
|
}
|
|
/**
|
|
* Check if an email address is suppressed (has bounced previously)
|
|
* @param email Email address to check
|
|
* @returns Whether the email is suppressed
|
|
*/
|
|
isEmailSuppressed(email) {
|
|
return this.bounceManager.isEmailSuppressed(email);
|
|
}
|
|
/**
|
|
* Get suppression information for an email
|
|
* @param email Email address to check
|
|
* @returns Suppression information or null if not suppressed
|
|
*/
|
|
getSuppressionInfo(email) {
|
|
return this.bounceManager.getSuppressionInfo(email);
|
|
}
|
|
/**
|
|
* Get bounce history information for an email
|
|
* @param email Email address to check
|
|
* @returns Bounce history or null if no bounces
|
|
*/
|
|
getBounceHistory(email) {
|
|
return this.bounceManager.getBounceInfo(email);
|
|
}
|
|
/**
|
|
* Get all suppressed email addresses
|
|
* @returns Array of suppressed email addresses
|
|
*/
|
|
getSuppressionList() {
|
|
return this.bounceManager.getSuppressionList();
|
|
}
|
|
/**
|
|
* Get all hard bounced email addresses
|
|
* @returns Array of hard bounced email addresses
|
|
*/
|
|
getHardBouncedAddresses() {
|
|
return this.bounceManager.getHardBouncedAddresses();
|
|
}
|
|
/**
|
|
* Add an email to the suppression list
|
|
* @param email Email address to suppress
|
|
* @param reason Reason for suppression
|
|
* @param expiresAt Optional expiration time (undefined for permanent)
|
|
*/
|
|
addToSuppressionList(email, reason, expiresAt) {
|
|
this.bounceManager.addToSuppressionList(email, reason, expiresAt);
|
|
logger.log('info', `Added ${email} to suppression list: ${reason}`);
|
|
}
|
|
/**
|
|
* Remove an email from the suppression list
|
|
* @param email Email address to remove from suppression
|
|
*/
|
|
removeFromSuppressionList(email) {
|
|
this.bounceManager.removeFromSuppressionList(email);
|
|
logger.log('info', `Removed ${email} from suppression list`);
|
|
}
|
|
/**
|
|
* Get the status of IP warmup process
|
|
* @param ipAddress Optional specific IP to check
|
|
* @returns Status of IP warmup
|
|
*/
|
|
getIPWarmupStatus(ipAddress) {
|
|
return this.ipWarmupManager.getWarmupStatus(ipAddress);
|
|
}
|
|
/**
|
|
* Add a new IP address to the warmup process
|
|
* @param ipAddress IP address to add
|
|
*/
|
|
addIPToWarmup(ipAddress) {
|
|
this.ipWarmupManager.addIPToWarmup(ipAddress);
|
|
}
|
|
/**
|
|
* Remove an IP address from the warmup process
|
|
* @param ipAddress IP address to remove
|
|
*/
|
|
removeIPFromWarmup(ipAddress) {
|
|
this.ipWarmupManager.removeIPFromWarmup(ipAddress);
|
|
}
|
|
/**
|
|
* Update metrics for an IP in the warmup process
|
|
* @param ipAddress IP address
|
|
* @param metrics Metrics to update
|
|
*/
|
|
updateIPWarmupMetrics(ipAddress, metrics) {
|
|
this.ipWarmupManager.updateMetrics(ipAddress, metrics);
|
|
}
|
|
/**
|
|
* Check if an IP can send more emails today
|
|
* @param ipAddress IP address to check
|
|
* @returns Whether the IP can send more today
|
|
*/
|
|
canIPSendMoreToday(ipAddress) {
|
|
return this.ipWarmupManager.canSendMoreToday(ipAddress);
|
|
}
|
|
/**
|
|
* Check if an IP can send more emails in the current hour
|
|
* @param ipAddress IP address to check
|
|
* @returns Whether the IP can send more this hour
|
|
*/
|
|
canIPSendMoreThisHour(ipAddress) {
|
|
return this.ipWarmupManager.canSendMoreThisHour(ipAddress);
|
|
}
|
|
/**
|
|
* Get the best IP to use for sending an email based on warmup status
|
|
* @param emailInfo Information about the email being sent
|
|
* @returns Best IP to use or null
|
|
*/
|
|
getBestIPForSending(emailInfo) {
|
|
return this.ipWarmupManager.getBestIPForSending(emailInfo);
|
|
}
|
|
/**
|
|
* Set the active IP allocation policy for warmup
|
|
* @param policyName Name of the policy to set
|
|
*/
|
|
setIPAllocationPolicy(policyName) {
|
|
this.ipWarmupManager.setActiveAllocationPolicy(policyName);
|
|
}
|
|
/**
|
|
* Record that an email was sent using a specific IP
|
|
* @param ipAddress IP address used for sending
|
|
*/
|
|
recordIPSend(ipAddress) {
|
|
this.ipWarmupManager.recordSend(ipAddress);
|
|
}
|
|
/**
|
|
* Get reputation data for a domain
|
|
* @param domain Domain to get reputation for
|
|
* @returns Domain reputation metrics
|
|
*/
|
|
getDomainReputationData(domain) {
|
|
return this.senderReputationMonitor.getReputationData(domain);
|
|
}
|
|
/**
|
|
* Get summary reputation data for all monitored domains
|
|
* @returns Summary data for all domains
|
|
*/
|
|
getReputationSummary() {
|
|
return this.senderReputationMonitor.getReputationSummary();
|
|
}
|
|
/**
|
|
* Add a domain to the reputation monitoring system
|
|
* @param domain Domain to add
|
|
*/
|
|
addDomainToMonitoring(domain) {
|
|
this.senderReputationMonitor.addDomain(domain);
|
|
}
|
|
/**
|
|
* Remove a domain from the reputation monitoring system
|
|
* @param domain Domain to remove
|
|
*/
|
|
removeDomainFromMonitoring(domain) {
|
|
this.senderReputationMonitor.removeDomain(domain);
|
|
}
|
|
/**
|
|
* Record an email event for domain reputation tracking
|
|
* @param domain Domain sending the email
|
|
* @param event Event details
|
|
*/
|
|
recordReputationEvent(domain, event) {
|
|
this.senderReputationMonitor.recordSendEvent(domain, event);
|
|
}
|
|
/**
|
|
* Check if DKIM key exists for a domain
|
|
* @param domain Domain to check
|
|
*/
|
|
hasDkimKey(domain) {
|
|
return this.dkimKeys.has(domain);
|
|
}
|
|
/**
|
|
* Record successful email delivery
|
|
* @param domain Sending domain
|
|
*/
|
|
recordDelivery(domain) {
|
|
this.recordReputationEvent(domain, {
|
|
type: 'delivered',
|
|
count: 1
|
|
});
|
|
}
|
|
/**
|
|
* Record email bounce
|
|
* @param domain Sending domain
|
|
* @param receivingDomain Receiving domain that bounced
|
|
* @param bounceType Type of bounce (hard/soft)
|
|
* @param reason Bounce reason
|
|
*/
|
|
recordBounce(domain, receivingDomain, bounceType, reason) {
|
|
// Record bounce in bounce manager
|
|
const bounceRecord = {
|
|
id: `bounce_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`,
|
|
recipient: `user@${receivingDomain}`,
|
|
sender: `user@${domain}`,
|
|
domain: domain,
|
|
bounceType: bounceType === 'hard' ? BounceType.INVALID_RECIPIENT : BounceType.TEMPORARY_FAILURE,
|
|
bounceCategory: bounceType === 'hard' ? BounceCategory.HARD : BounceCategory.SOFT,
|
|
timestamp: Date.now(),
|
|
smtpResponse: reason,
|
|
diagnosticCode: reason,
|
|
statusCode: bounceType === 'hard' ? '550' : '450',
|
|
processed: false
|
|
};
|
|
// Process the bounce
|
|
this.bounceManager.processBounce(bounceRecord);
|
|
// Record reputation event
|
|
this.recordReputationEvent(domain, {
|
|
type: 'bounce',
|
|
count: 1,
|
|
hardBounce: bounceType === 'hard',
|
|
receivingDomain
|
|
});
|
|
}
|
|
/**
|
|
* Get the rate limiter instance
|
|
* @returns The unified rate limiter
|
|
*/
|
|
getRateLimiter() {
|
|
return this.rateLimiter;
|
|
}
|
|
}
|
|
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.unified.email.server.js","sourceRoot":"","sources":["../../../ts/mail/routing/classes.unified.email.server.ts"],"names":[],"mappings":"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"}
|