Juergen Kunz
b82468ab1e
Phase 3 of the Rust migration: the Rust security bridge is now mandatory and all TypeScript security fallback implementations have been removed. - UnifiedEmailServer.start() throws if Rust bridge fails to start - SpfVerifier gutted to thin wrapper (parseSpfRecord stays in TS) - DKIMVerifier gutted to thin wrapper delegating to bridge.verifyDkim() - IPReputationChecker delegates to bridge.checkIpReputation(), keeps LRU cache - DmarcVerifier keeps alignment logic (works with pre-computed results) - DKIM signing via bridge.signDkim() in all 4 locations - Removed mailauth and ip packages from plugins.ts (~1,200 lines deleted)
846 lines
70 KiB
JavaScript
846 lines
70 KiB
JavaScript
import * as plugins from '../../plugins.js';
|
|
import { EventEmitter } from 'node:events';
|
|
import * as net from 'node:net';
|
|
import * as tls from 'node:tls';
|
|
import { logger } from '../../logger.js';
|
|
import { SecurityLogger, SecurityLogLevel, SecurityEventType } from '../../security/index.js';
|
|
import { UnifiedDeliveryQueue } from './classes.delivery.queue.js';
|
|
import { RustSecurityBridge } from '../../security/classes.rustsecuritybridge.js';
|
|
/**
|
|
* Delivery status enumeration
|
|
*/
|
|
export var DeliveryStatus;
|
|
(function (DeliveryStatus) {
|
|
DeliveryStatus["PENDING"] = "pending";
|
|
DeliveryStatus["DELIVERING"] = "delivering";
|
|
DeliveryStatus["DELIVERED"] = "delivered";
|
|
DeliveryStatus["DEFERRED"] = "deferred";
|
|
DeliveryStatus["FAILED"] = "failed";
|
|
})(DeliveryStatus || (DeliveryStatus = {}));
|
|
/**
|
|
* Handles delivery for all email processing modes
|
|
*/
|
|
export class MultiModeDeliverySystem extends EventEmitter {
|
|
queue;
|
|
options;
|
|
stats;
|
|
deliveryTimes = [];
|
|
activeDeliveries = new Set();
|
|
running = false;
|
|
throttled = false;
|
|
rateLimitLastCheck = Date.now();
|
|
rateLimitCounter = 0;
|
|
emailServer;
|
|
/**
|
|
* Create a new multi-mode delivery system
|
|
* @param queue Unified delivery queue
|
|
* @param options Delivery options
|
|
* @param emailServer Optional reference to unified email server for SmtpClient access
|
|
*/
|
|
constructor(queue, options, emailServer) {
|
|
super();
|
|
this.queue = queue;
|
|
this.emailServer = emailServer;
|
|
// Set default options
|
|
this.options = {
|
|
connectionPoolSize: options.connectionPoolSize || 10,
|
|
socketTimeout: options.socketTimeout || 30000, // 30 seconds
|
|
concurrentDeliveries: options.concurrentDeliveries || 10,
|
|
sendTimeout: options.sendTimeout || 60000, // 1 minute
|
|
verifyCertificates: options.verifyCertificates !== false, // Default to true
|
|
tlsMinVersion: options.tlsMinVersion || 'TLSv1.2',
|
|
forwardHandler: options.forwardHandler || {
|
|
deliver: this.handleForwardDelivery.bind(this)
|
|
},
|
|
deliveryHandler: options.deliveryHandler || {
|
|
deliver: this.handleMtaDelivery.bind(this)
|
|
},
|
|
processHandler: options.processHandler || {
|
|
deliver: this.handleProcessDelivery.bind(this)
|
|
},
|
|
globalRateLimit: options.globalRateLimit || 100, // 100 emails per minute
|
|
perPatternRateLimit: options.perPatternRateLimit || {},
|
|
processBounces: options.processBounces !== false, // Default to true
|
|
bounceHandler: options.bounceHandler || null,
|
|
onDeliveryStart: options.onDeliveryStart || (async () => { }),
|
|
onDeliverySuccess: options.onDeliverySuccess || (async () => { }),
|
|
onDeliveryFailed: options.onDeliveryFailed || (async () => { })
|
|
};
|
|
// Initialize statistics
|
|
this.stats = {
|
|
activeDeliveries: 0,
|
|
totalSuccessful: 0,
|
|
totalFailed: 0,
|
|
avgDeliveryTime: 0,
|
|
byMode: {
|
|
forward: {
|
|
successful: 0,
|
|
failed: 0
|
|
},
|
|
mta: {
|
|
successful: 0,
|
|
failed: 0
|
|
},
|
|
process: {
|
|
successful: 0,
|
|
failed: 0
|
|
}
|
|
},
|
|
rateLimiting: {
|
|
currentRate: 0,
|
|
globalLimit: this.options.globalRateLimit,
|
|
throttled: 0
|
|
}
|
|
};
|
|
// Set up event listeners
|
|
this.queue.on('itemsReady', this.processItems.bind(this));
|
|
}
|
|
/**
|
|
* Start the delivery system
|
|
*/
|
|
async start() {
|
|
logger.log('info', 'Starting MultiModeDeliverySystem');
|
|
if (this.running) {
|
|
logger.log('warn', 'MultiModeDeliverySystem is already running');
|
|
return;
|
|
}
|
|
this.running = true;
|
|
// Emit started event
|
|
this.emit('started');
|
|
logger.log('info', 'MultiModeDeliverySystem started successfully');
|
|
}
|
|
/**
|
|
* Stop the delivery system
|
|
*/
|
|
async stop() {
|
|
logger.log('info', 'Stopping MultiModeDeliverySystem');
|
|
if (!this.running) {
|
|
logger.log('warn', 'MultiModeDeliverySystem is already stopped');
|
|
return;
|
|
}
|
|
this.running = false;
|
|
// Wait for active deliveries to complete
|
|
if (this.activeDeliveries.size > 0) {
|
|
logger.log('info', `Waiting for ${this.activeDeliveries.size} active deliveries to complete`);
|
|
// Wait for a maximum of 30 seconds
|
|
await new Promise(resolve => {
|
|
const checkInterval = setInterval(() => {
|
|
if (this.activeDeliveries.size === 0) {
|
|
clearInterval(checkInterval);
|
|
clearTimeout(forceTimeout);
|
|
resolve();
|
|
}
|
|
}, 1000);
|
|
// Force resolve after 30 seconds
|
|
const forceTimeout = setTimeout(() => {
|
|
clearInterval(checkInterval);
|
|
resolve();
|
|
}, 30000);
|
|
});
|
|
}
|
|
// Emit stopped event
|
|
this.emit('stopped');
|
|
logger.log('info', 'MultiModeDeliverySystem stopped successfully');
|
|
}
|
|
/**
|
|
* Process ready items from the queue
|
|
* @param items Queue items ready for processing
|
|
*/
|
|
async processItems(items) {
|
|
if (!this.running) {
|
|
return;
|
|
}
|
|
// Check if we're already at max concurrent deliveries
|
|
if (this.activeDeliveries.size >= this.options.concurrentDeliveries) {
|
|
logger.log('debug', `Already at max concurrent deliveries (${this.activeDeliveries.size})`);
|
|
return;
|
|
}
|
|
// Check rate limiting
|
|
if (this.checkRateLimit()) {
|
|
logger.log('debug', 'Rate limit exceeded, throttling deliveries');
|
|
return;
|
|
}
|
|
// Calculate how many more deliveries we can start
|
|
const availableSlots = this.options.concurrentDeliveries - this.activeDeliveries.size;
|
|
const itemsToProcess = items.slice(0, availableSlots);
|
|
if (itemsToProcess.length === 0) {
|
|
return;
|
|
}
|
|
logger.log('info', `Processing ${itemsToProcess.length} items for delivery`);
|
|
// Process each item
|
|
for (const item of itemsToProcess) {
|
|
// Mark as processing
|
|
await this.queue.markProcessing(item.id);
|
|
// Add to active deliveries
|
|
this.activeDeliveries.add(item.id);
|
|
this.stats.activeDeliveries = this.activeDeliveries.size;
|
|
// Deliver asynchronously
|
|
this.deliverItem(item).catch(err => {
|
|
logger.log('error', `Unhandled error in delivery: ${err.message}`);
|
|
});
|
|
}
|
|
// Update statistics
|
|
this.emit('statsUpdated', this.stats);
|
|
}
|
|
/**
|
|
* Deliver an item from the queue
|
|
* @param item Queue item to deliver
|
|
*/
|
|
async deliverItem(item) {
|
|
const startTime = Date.now();
|
|
try {
|
|
// Call delivery start hook
|
|
await this.options.onDeliveryStart(item);
|
|
// Emit delivery start event
|
|
this.emit('deliveryStart', item);
|
|
logger.log('info', `Starting delivery of item ${item.id}, mode: ${item.processingMode}`);
|
|
// Choose the appropriate handler based on mode
|
|
let result;
|
|
switch (item.processingMode) {
|
|
case 'forward':
|
|
result = await this.options.forwardHandler.deliver(item);
|
|
break;
|
|
case 'mta':
|
|
result = await this.options.deliveryHandler.deliver(item);
|
|
break;
|
|
case 'process':
|
|
result = await this.options.processHandler.deliver(item);
|
|
break;
|
|
default:
|
|
throw new Error(`Unknown processing mode: ${item.processingMode}`);
|
|
}
|
|
// Mark as delivered
|
|
await this.queue.markDelivered(item.id);
|
|
// Update statistics
|
|
this.stats.totalSuccessful++;
|
|
this.stats.byMode[item.processingMode].successful++;
|
|
// Calculate delivery time
|
|
const deliveryTime = Date.now() - startTime;
|
|
this.deliveryTimes.push(deliveryTime);
|
|
this.updateDeliveryTimeStats();
|
|
// Call delivery success hook
|
|
await this.options.onDeliverySuccess(item, result);
|
|
// Emit delivery success event
|
|
this.emit('deliverySuccess', item, result);
|
|
logger.log('info', `Item ${item.id} delivered successfully in ${deliveryTime}ms`);
|
|
SecurityLogger.getInstance().logEvent({
|
|
level: SecurityLogLevel.INFO,
|
|
type: SecurityEventType.EMAIL_DELIVERY,
|
|
message: 'Email delivery successful',
|
|
details: {
|
|
itemId: item.id,
|
|
mode: item.processingMode,
|
|
routeName: item.route?.name || 'unknown',
|
|
deliveryTime
|
|
},
|
|
success: true
|
|
});
|
|
}
|
|
catch (error) {
|
|
// Calculate delivery attempt time even for failures
|
|
const deliveryTime = Date.now() - startTime;
|
|
// Mark as failed
|
|
await this.queue.markFailed(item.id, error.message);
|
|
// Update statistics
|
|
this.stats.totalFailed++;
|
|
this.stats.byMode[item.processingMode].failed++;
|
|
// Call delivery failed hook
|
|
await this.options.onDeliveryFailed(item, error.message);
|
|
// Process as bounce if enabled and we have a bounce handler
|
|
if (this.options.processBounces && this.options.bounceHandler) {
|
|
try {
|
|
const email = item.processingResult;
|
|
// Extract recipient and error message
|
|
// For multiple recipients, we'd need more sophisticated parsing
|
|
const recipient = email.to.length > 0 ? email.to[0] : '';
|
|
if (recipient) {
|
|
logger.log('info', `Processing delivery failure as bounce for recipient ${recipient}`);
|
|
// Process SMTP failure through bounce handler
|
|
await this.options.bounceHandler.processSmtpFailure(recipient, error.message, {
|
|
sender: email.from,
|
|
originalEmailId: item.id,
|
|
headers: email.headers
|
|
});
|
|
logger.log('info', `Bounce record created for failed delivery to ${recipient}`);
|
|
}
|
|
}
|
|
catch (bounceError) {
|
|
logger.log('error', `Failed to process bounce: ${bounceError.message}`);
|
|
}
|
|
}
|
|
// Emit delivery failed event
|
|
this.emit('deliveryFailed', item, error);
|
|
logger.log('error', `Item ${item.id} delivery failed: ${error.message}`);
|
|
SecurityLogger.getInstance().logEvent({
|
|
level: SecurityLogLevel.ERROR,
|
|
type: SecurityEventType.EMAIL_DELIVERY,
|
|
message: 'Email delivery failed',
|
|
details: {
|
|
itemId: item.id,
|
|
mode: item.processingMode,
|
|
routeName: item.route?.name || 'unknown',
|
|
error: error.message,
|
|
deliveryTime
|
|
},
|
|
success: false
|
|
});
|
|
}
|
|
finally {
|
|
// Remove from active deliveries
|
|
this.activeDeliveries.delete(item.id);
|
|
this.stats.activeDeliveries = this.activeDeliveries.size;
|
|
// Update statistics
|
|
this.emit('statsUpdated', this.stats);
|
|
}
|
|
}
|
|
/**
|
|
* Default handler for forward mode delivery
|
|
* @param item Queue item
|
|
*/
|
|
async handleForwardDelivery(item) {
|
|
logger.log('info', `Forward delivery for item ${item.id}`);
|
|
const email = item.processingResult;
|
|
const route = item.route;
|
|
// Get target server information
|
|
const targetServer = route?.action.forward?.host;
|
|
const targetPort = route?.action.forward?.port || 25;
|
|
const useTls = false; // TLS configuration can be enhanced later
|
|
if (!targetServer) {
|
|
throw new Error('No target server configured for forward mode');
|
|
}
|
|
logger.log('info', `Forwarding email to ${targetServer}:${targetPort}, TLS: ${useTls}`);
|
|
try {
|
|
// Get SMTP client from email server if available
|
|
if (!this.emailServer) {
|
|
// Fall back to raw socket implementation if no email server
|
|
logger.log('warn', 'No email server available, falling back to raw socket implementation');
|
|
return this.handleForwardDeliveryLegacy(item);
|
|
}
|
|
// Get SMTP client from UnifiedEmailServer
|
|
const smtpClient = this.emailServer.getSmtpClient(targetServer, targetPort);
|
|
// Apply DKIM signing if configured in the route
|
|
if (item.route?.action.options?.mtaOptions?.dkimSign) {
|
|
await this.applyDkimSigning(email, item.route.action.options.mtaOptions);
|
|
}
|
|
// Send the email using SmtpClient
|
|
const result = await smtpClient.sendMail(email);
|
|
if (result.success) {
|
|
logger.log('info', `Email forwarded successfully to ${targetServer}:${targetPort}`);
|
|
return {
|
|
targetServer: targetServer,
|
|
targetPort: targetPort,
|
|
recipients: result.acceptedRecipients.length,
|
|
messageId: result.messageId,
|
|
rejectedRecipients: result.rejectedRecipients
|
|
};
|
|
}
|
|
else {
|
|
throw new Error(result.error?.message || 'Failed to forward email');
|
|
}
|
|
}
|
|
catch (error) {
|
|
logger.log('error', `Failed to forward email: ${error.message}`);
|
|
throw error;
|
|
}
|
|
}
|
|
/**
|
|
* Legacy forward delivery using raw sockets (fallback)
|
|
* @param item Queue item
|
|
*/
|
|
async handleForwardDeliveryLegacy(item) {
|
|
const email = item.processingResult;
|
|
const route = item.route;
|
|
// Get target server information
|
|
const targetServer = route?.action.forward?.host;
|
|
const targetPort = route?.action.forward?.port || 25;
|
|
const useTls = false; // TLS configuration can be enhanced later
|
|
if (!targetServer) {
|
|
throw new Error('No target server configured for forward mode');
|
|
}
|
|
// Create a socket connection to the target server
|
|
const socket = new net.Socket();
|
|
// Set timeout
|
|
socket.setTimeout(this.options.socketTimeout);
|
|
try {
|
|
// Connect to the target server
|
|
await new Promise((resolve, reject) => {
|
|
// Handle connection events
|
|
socket.on('connect', () => {
|
|
logger.log('debug', `Connected to ${targetServer}:${targetPort}`);
|
|
resolve();
|
|
});
|
|
socket.on('timeout', () => {
|
|
reject(new Error(`Connection timeout to ${targetServer}:${targetPort}`));
|
|
});
|
|
socket.on('error', (err) => {
|
|
reject(new Error(`Connection error to ${targetServer}:${targetPort}: ${err.message}`));
|
|
});
|
|
// Connect to the server
|
|
socket.connect({
|
|
host: targetServer,
|
|
port: targetPort
|
|
});
|
|
});
|
|
// Send EHLO
|
|
await this.smtpCommand(socket, `EHLO ${route?.action.options?.mtaOptions?.domain || 'localhost'}`);
|
|
// Start TLS if required
|
|
if (useTls) {
|
|
await this.smtpCommand(socket, 'STARTTLS');
|
|
// Upgrade to TLS
|
|
const tlsSocket = await this.upgradeTls(socket, targetServer);
|
|
// Send EHLO again after STARTTLS
|
|
await this.smtpCommand(tlsSocket, `EHLO ${route?.action.options?.mtaOptions?.domain || 'localhost'}`);
|
|
// Use tlsSocket for remaining commands
|
|
return this.completeSMTPExchange(tlsSocket, email, route);
|
|
}
|
|
// Complete the SMTP exchange
|
|
return this.completeSMTPExchange(socket, email, route);
|
|
}
|
|
catch (error) {
|
|
logger.log('error', `Failed to forward email: ${error.message}`);
|
|
// Close the connection
|
|
socket.destroy();
|
|
throw error;
|
|
}
|
|
}
|
|
/**
|
|
* Complete the SMTP exchange after connection and initial setup
|
|
* @param socket Network socket
|
|
* @param email Email to send
|
|
* @param rule Domain rule
|
|
*/
|
|
async completeSMTPExchange(socket, email, route) {
|
|
try {
|
|
// Authenticate if credentials provided
|
|
if (route?.action?.forward?.auth?.user && route?.action?.forward?.auth?.pass) {
|
|
// Send AUTH LOGIN
|
|
await this.smtpCommand(socket, 'AUTH LOGIN');
|
|
// Send username (base64)
|
|
const username = Buffer.from(route.action.forward.auth.user).toString('base64');
|
|
await this.smtpCommand(socket, username);
|
|
// Send password (base64)
|
|
const password = Buffer.from(route.action.forward.auth.pass).toString('base64');
|
|
await this.smtpCommand(socket, password);
|
|
}
|
|
// Send MAIL FROM
|
|
await this.smtpCommand(socket, `MAIL FROM:<${email.from}>`);
|
|
// Send RCPT TO for each recipient
|
|
for (const recipient of email.getAllRecipients()) {
|
|
await this.smtpCommand(socket, `RCPT TO:<${recipient}>`);
|
|
}
|
|
// Send DATA
|
|
await this.smtpCommand(socket, 'DATA');
|
|
// Send email content (simplified)
|
|
const emailContent = await this.getFormattedEmail(email);
|
|
await this.smtpData(socket, emailContent);
|
|
// Send QUIT
|
|
await this.smtpCommand(socket, 'QUIT');
|
|
// Close the connection
|
|
socket.end();
|
|
logger.log('info', `Email forwarded successfully to ${route?.action?.forward?.host}:${route?.action?.forward?.port || 25}`);
|
|
return {
|
|
targetServer: route?.action?.forward?.host,
|
|
targetPort: route?.action?.forward?.port || 25,
|
|
recipients: email.getAllRecipients().length
|
|
};
|
|
}
|
|
catch (error) {
|
|
logger.log('error', `Failed to forward email: ${error.message}`);
|
|
// Close the connection
|
|
socket.destroy();
|
|
throw error;
|
|
}
|
|
}
|
|
/**
|
|
* Default handler for MTA mode delivery
|
|
* @param item Queue item
|
|
*/
|
|
async handleMtaDelivery(item) {
|
|
logger.log('info', `MTA delivery for item ${item.id}`);
|
|
const email = item.processingResult;
|
|
const route = item.route;
|
|
try {
|
|
// Apply DKIM signing if configured in the route
|
|
if (item.route?.action.options?.mtaOptions?.dkimSign) {
|
|
await this.applyDkimSigning(email, item.route.action.options.mtaOptions);
|
|
}
|
|
// In a full implementation, this would use the MTA service
|
|
// For now, we'll simulate a successful delivery
|
|
logger.log('info', `Email processed by MTA: ${email.subject} to ${email.getAllRecipients().join(', ')}`);
|
|
// Note: The MTA implementation would handle actual local delivery
|
|
// Simulate successful delivery
|
|
return {
|
|
recipients: email.getAllRecipients().length,
|
|
subject: email.subject,
|
|
dkimSigned: !!item.route?.action.options?.mtaOptions?.dkimSign
|
|
};
|
|
}
|
|
catch (error) {
|
|
logger.log('error', `Failed to process email in MTA mode: ${error.message}`);
|
|
throw error;
|
|
}
|
|
}
|
|
/**
|
|
* Default handler for process mode delivery
|
|
* @param item Queue item
|
|
*/
|
|
async handleProcessDelivery(item) {
|
|
logger.log('info', `Process delivery for item ${item.id}`);
|
|
const email = item.processingResult;
|
|
const route = item.route;
|
|
try {
|
|
// 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;
|
|
}
|
|
}
|
|
}
|
|
// Apply DKIM signing if configured (after all transformations)
|
|
if (item.route?.action.options?.mtaOptions?.dkimSign || item.route?.action.process?.dkim) {
|
|
await this.applyDkimSigning(email, item.route.action.options?.mtaOptions || {});
|
|
}
|
|
logger.log('info', `Email successfully processed in store-and-forward mode`);
|
|
// Simulate successful delivery
|
|
return {
|
|
recipients: email.getAllRecipients().length,
|
|
subject: email.subject,
|
|
scanned: !!route?.action.options?.contentScanning,
|
|
transformed: !!(route?.action.options?.transformations && route?.action.options?.transformations.length > 0),
|
|
dkimSigned: !!(item.route?.action.options?.mtaOptions?.dkimSign || item.route?.action.process?.dkim)
|
|
};
|
|
}
|
|
catch (error) {
|
|
logger.log('error', `Failed to process email: ${error.message}`);
|
|
throw error;
|
|
}
|
|
}
|
|
/**
|
|
* Get file extension from filename
|
|
*/
|
|
getFileExtension(filename) {
|
|
return filename.substring(filename.lastIndexOf('.')).toLowerCase();
|
|
}
|
|
/**
|
|
* Apply DKIM signing to an email
|
|
*/
|
|
async applyDkimSigning(email, mtaOptions) {
|
|
if (!this.emailServer) {
|
|
logger.log('warn', 'Cannot apply DKIM signing without email server reference');
|
|
return;
|
|
}
|
|
const domainName = mtaOptions.dkimOptions?.domainName || email.from.split('@')[1];
|
|
const keySelector = mtaOptions.dkimOptions?.keySelector || 'default';
|
|
try {
|
|
// Ensure DKIM keys exist for the domain
|
|
await this.emailServer.dkimCreator.handleDKIMKeysForDomain(domainName);
|
|
// Get the private key
|
|
const dkimPrivateKey = (await this.emailServer.dkimCreator.readDKIMKeys(domainName)).privateKey;
|
|
// Convert Email to raw format for signing
|
|
const rawEmail = email.toRFC822String();
|
|
// Sign via Rust bridge
|
|
const bridge = RustSecurityBridge.getInstance();
|
|
const signResult = await bridge.signDkim({
|
|
rawMessage: rawEmail,
|
|
domain: domainName,
|
|
selector: keySelector,
|
|
privateKey: dkimPrivateKey,
|
|
});
|
|
if (signResult.header) {
|
|
email.addHeader('DKIM-Signature', signResult.header);
|
|
logger.log('info', `Successfully added DKIM signature for ${domainName}`);
|
|
}
|
|
}
|
|
catch (error) {
|
|
logger.log('error', `Failed to apply DKIM signature: ${error.message}`);
|
|
// Don't throw - allow email to be sent without DKIM if signing fails
|
|
}
|
|
}
|
|
/**
|
|
* Format email for SMTP transmission
|
|
* @param email Email to format
|
|
*/
|
|
async getFormattedEmail(email) {
|
|
// This is a simplified implementation
|
|
// In a full implementation, this would use proper MIME formatting
|
|
let content = '';
|
|
// Add headers
|
|
content += `From: ${email.from}\r\n`;
|
|
content += `To: ${email.to.join(', ')}\r\n`;
|
|
content += `Subject: ${email.subject}\r\n`;
|
|
// Add additional headers
|
|
for (const [name, value] of Object.entries(email.headers || {})) {
|
|
content += `${name}: ${value}\r\n`;
|
|
}
|
|
// Add content type for multipart
|
|
if (email.attachments && email.attachments.length > 0) {
|
|
const boundary = `----_=_NextPart_${Math.random().toString(36).substr(2)}`;
|
|
content += `MIME-Version: 1.0\r\n`;
|
|
content += `Content-Type: multipart/mixed; boundary="${boundary}"\r\n`;
|
|
content += `\r\n`;
|
|
// Add text part
|
|
content += `--${boundary}\r\n`;
|
|
content += `Content-Type: text/plain; charset="UTF-8"\r\n`;
|
|
content += `\r\n`;
|
|
content += `${email.text}\r\n`;
|
|
// Add HTML part if present
|
|
if (email.html) {
|
|
content += `--${boundary}\r\n`;
|
|
content += `Content-Type: text/html; charset="UTF-8"\r\n`;
|
|
content += `\r\n`;
|
|
content += `${email.html}\r\n`;
|
|
}
|
|
// Add attachments
|
|
for (const attachment of email.attachments) {
|
|
content += `--${boundary}\r\n`;
|
|
content += `Content-Type: ${attachment.contentType || 'application/octet-stream'}; name="${attachment.filename}"\r\n`;
|
|
content += `Content-Disposition: attachment; filename="${attachment.filename}"\r\n`;
|
|
content += `Content-Transfer-Encoding: base64\r\n`;
|
|
content += `\r\n`;
|
|
// Add base64 encoded content
|
|
const base64Content = attachment.content.toString('base64');
|
|
// Split into lines of 76 characters
|
|
for (let i = 0; i < base64Content.length; i += 76) {
|
|
content += base64Content.substring(i, i + 76) + '\r\n';
|
|
}
|
|
}
|
|
// End boundary
|
|
content += `--${boundary}--\r\n`;
|
|
}
|
|
else {
|
|
// Simple email with just text
|
|
content += `Content-Type: text/plain; charset="UTF-8"\r\n`;
|
|
content += `\r\n`;
|
|
content += `${email.text}\r\n`;
|
|
}
|
|
return content;
|
|
}
|
|
/**
|
|
* Send SMTP command and wait for response
|
|
* @param socket Socket connection
|
|
* @param command SMTP command to send
|
|
*/
|
|
async smtpCommand(socket, command) {
|
|
return new Promise((resolve, reject) => {
|
|
const onData = (data) => {
|
|
const response = data.toString().trim();
|
|
// Clean up listeners
|
|
socket.removeListener('data', onData);
|
|
socket.removeListener('error', onError);
|
|
socket.removeListener('timeout', onTimeout);
|
|
// Check response code
|
|
if (response.charAt(0) === '2' || response.charAt(0) === '3') {
|
|
resolve(response);
|
|
}
|
|
else {
|
|
reject(new Error(`SMTP error: ${response}`));
|
|
}
|
|
};
|
|
const onError = (err) => {
|
|
// Clean up listeners
|
|
socket.removeListener('data', onData);
|
|
socket.removeListener('error', onError);
|
|
socket.removeListener('timeout', onTimeout);
|
|
reject(err);
|
|
};
|
|
const onTimeout = () => {
|
|
// Clean up listeners
|
|
socket.removeListener('data', onData);
|
|
socket.removeListener('error', onError);
|
|
socket.removeListener('timeout', onTimeout);
|
|
reject(new Error('SMTP command timeout'));
|
|
};
|
|
// Set up listeners
|
|
socket.once('data', onData);
|
|
socket.once('error', onError);
|
|
socket.once('timeout', onTimeout);
|
|
// Send command
|
|
socket.write(command + '\r\n');
|
|
});
|
|
}
|
|
/**
|
|
* Send SMTP DATA command with content
|
|
* @param socket Socket connection
|
|
* @param data Email content to send
|
|
*/
|
|
async smtpData(socket, data) {
|
|
return new Promise((resolve, reject) => {
|
|
const onData = (responseData) => {
|
|
const response = responseData.toString().trim();
|
|
// Clean up listeners
|
|
socket.removeListener('data', onData);
|
|
socket.removeListener('error', onError);
|
|
socket.removeListener('timeout', onTimeout);
|
|
// Check response code
|
|
if (response.charAt(0) === '2') {
|
|
resolve(response);
|
|
}
|
|
else {
|
|
reject(new Error(`SMTP error: ${response}`));
|
|
}
|
|
};
|
|
const onError = (err) => {
|
|
// Clean up listeners
|
|
socket.removeListener('data', onData);
|
|
socket.removeListener('error', onError);
|
|
socket.removeListener('timeout', onTimeout);
|
|
reject(err);
|
|
};
|
|
const onTimeout = () => {
|
|
// Clean up listeners
|
|
socket.removeListener('data', onData);
|
|
socket.removeListener('error', onError);
|
|
socket.removeListener('timeout', onTimeout);
|
|
reject(new Error('SMTP data timeout'));
|
|
};
|
|
// Set up listeners
|
|
socket.once('data', onData);
|
|
socket.once('error', onError);
|
|
socket.once('timeout', onTimeout);
|
|
// Send data and end with CRLF.CRLF
|
|
socket.write(data + '\r\n.\r\n');
|
|
});
|
|
}
|
|
/**
|
|
* Upgrade socket to TLS
|
|
* @param socket Socket connection
|
|
* @param hostname Target hostname for TLS
|
|
*/
|
|
async upgradeTls(socket, hostname) {
|
|
return new Promise((resolve, reject) => {
|
|
const tlsOptions = {
|
|
socket,
|
|
servername: hostname,
|
|
rejectUnauthorized: this.options.verifyCertificates,
|
|
minVersion: this.options.tlsMinVersion
|
|
};
|
|
const tlsSocket = tls.connect(tlsOptions);
|
|
tlsSocket.once('secureConnect', () => {
|
|
resolve(tlsSocket);
|
|
});
|
|
tlsSocket.once('error', (err) => {
|
|
reject(new Error(`TLS error: ${err.message}`));
|
|
});
|
|
tlsSocket.setTimeout(this.options.socketTimeout);
|
|
tlsSocket.once('timeout', () => {
|
|
reject(new Error('TLS connection timeout'));
|
|
});
|
|
});
|
|
}
|
|
/**
|
|
* Update delivery time statistics
|
|
*/
|
|
updateDeliveryTimeStats() {
|
|
if (this.deliveryTimes.length === 0)
|
|
return;
|
|
// Keep only the last 1000 delivery times
|
|
if (this.deliveryTimes.length > 1000) {
|
|
this.deliveryTimes = this.deliveryTimes.slice(-1000);
|
|
}
|
|
// Calculate average
|
|
const sum = this.deliveryTimes.reduce((acc, time) => acc + time, 0);
|
|
this.stats.avgDeliveryTime = sum / this.deliveryTimes.length;
|
|
}
|
|
/**
|
|
* Check if rate limit is exceeded
|
|
* @returns True if rate limited, false otherwise
|
|
*/
|
|
checkRateLimit() {
|
|
const now = Date.now();
|
|
const elapsed = now - this.rateLimitLastCheck;
|
|
// Reset counter if more than a minute has passed
|
|
if (elapsed >= 60000) {
|
|
this.rateLimitLastCheck = now;
|
|
this.rateLimitCounter = 0;
|
|
this.throttled = false;
|
|
this.stats.rateLimiting.currentRate = 0;
|
|
return false;
|
|
}
|
|
// Check if we're already throttled
|
|
if (this.throttled) {
|
|
return true;
|
|
}
|
|
// Increment counter
|
|
this.rateLimitCounter++;
|
|
// Calculate current rate (emails per minute)
|
|
const rate = (this.rateLimitCounter / elapsed) * 60000;
|
|
this.stats.rateLimiting.currentRate = rate;
|
|
// Check if rate limit is exceeded
|
|
if (rate > this.options.globalRateLimit) {
|
|
this.throttled = true;
|
|
this.stats.rateLimiting.throttled++;
|
|
// Schedule throttle reset
|
|
const resetDelay = 60000 - elapsed;
|
|
setTimeout(() => {
|
|
this.throttled = false;
|
|
this.rateLimitLastCheck = Date.now();
|
|
this.rateLimitCounter = 0;
|
|
this.stats.rateLimiting.currentRate = 0;
|
|
}, resetDelay);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
/**
|
|
* Update delivery options
|
|
* @param options New options
|
|
*/
|
|
updateOptions(options) {
|
|
this.options = {
|
|
...this.options,
|
|
...options
|
|
};
|
|
// Update rate limit statistics
|
|
if (options.globalRateLimit) {
|
|
this.stats.rateLimiting.globalLimit = options.globalRateLimit;
|
|
}
|
|
logger.log('info', 'MultiModeDeliverySystem options updated');
|
|
}
|
|
/**
|
|
* Get delivery statistics
|
|
*/
|
|
getStats() {
|
|
return { ...this.stats };
|
|
}
|
|
}
|
|
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.delivery.system.js","sourceRoot":"","sources":["../../../ts/mail/delivery/classes.delivery.system.ts"],"names":[],"mappings":"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"}
|