@serve.zone/dcrouter 2.12.4

package/dist_ts/ts/mail/delivery/smtpclient/tls-handler.js

@@ -0,0 +1,202 @@
+/**
+ * SMTP Client TLS Handler
+ * TLS and STARTTLS client functionality
+ */
+import * as tls from 'node:tls';
+import * as net from 'node:net';
+import { DEFAULTS } from './constants.js';
+import { CONNECTION_STATES } from './constants.js';
+import { logTLS, logDebug } from './utils/logging.js';
+import { isSuccessCode } from './utils/helpers.js';
+export class TlsHandler {
+    constructor(options, commandHandler) {
+        this.options = options;
+        this.commandHandler = commandHandler;
+    }
+    /**
+     * Upgrade connection to TLS using STARTTLS
+     */
+    async upgradeToTLS(connection) {
+        if (connection.secure) {
+            logDebug('Connection already secure', this.options);
+            return;
+        }
+        // Check if STARTTLS is supported
+        if (!connection.capabilities?.starttls) {
+            throw new Error('Server does not support STARTTLS');
+        }
+        logTLS('starttls_start', this.options);
+        try {
+            // Send STARTTLS command
+            const response = await this.commandHandler.sendStartTls(connection);
+            if (!isSuccessCode(response.code)) {
+                throw new Error(`STARTTLS command failed: ${response.message}`);
+            }
+            // Upgrade the socket to TLS
+            await this.performTLSUpgrade(connection);
+            // Clear capabilities as they may have changed after TLS
+            connection.capabilities = undefined;
+            connection.secure = true;
+            logTLS('starttls_success', this.options);
+        }
+        catch (error) {
+            logTLS('starttls_failure', this.options, { error });
+            throw error;
+        }
+    }
+    /**
+     * Create a direct TLS connection
+     */
+    async createTLSConnection(host, port) {
+        return new Promise((resolve, reject) => {
+            const timeout = this.options.connectionTimeout || DEFAULTS.CONNECTION_TIMEOUT;
+            const tlsOptions = {
+                host,
+                port,
+                ...this.options.tls,
+                // Default TLS options for email
+                secureProtocol: 'TLS_method',
+                ciphers: 'HIGH:!aNULL:!eNULL:!EXPORT:!DES:!RC4:!MD5:!PSK:!SRP:!CAMELLIA',
+                rejectUnauthorized: this.options.tls?.rejectUnauthorized !== false
+            };
+            logTLS('tls_connected', this.options, { host, port });
+            const socket = tls.connect(tlsOptions);
+            const timeoutHandler = setTimeout(() => {
+                socket.destroy();
+                reject(new Error(`TLS connection timeout after ${timeout}ms`));
+            }, timeout);
+            socket.once('secureConnect', () => {
+                clearTimeout(timeoutHandler);
+                if (!socket.authorized && this.options.tls?.rejectUnauthorized !== false) {
+                    socket.destroy();
+                    reject(new Error(`TLS certificate verification failed: ${socket.authorizationError}`));
+                    return;
+                }
+                logDebug('TLS connection established', this.options, {
+                    authorized: socket.authorized,
+                    protocol: socket.getProtocol(),
+                    cipher: socket.getCipher()
+                });
+                resolve(socket);
+            });
+            socket.once('error', (error) => {
+                clearTimeout(timeoutHandler);
+                reject(error);
+            });
+        });
+    }
+    /**
+     * Validate TLS certificate
+     */
+    validateCertificate(socket) {
+        if (!socket.authorized) {
+            logDebug('TLS certificate not authorized', this.options, {
+                error: socket.authorizationError
+            });
+            // Allow self-signed certificates if explicitly configured
+            if (this.options.tls?.rejectUnauthorized === false) {
+                logDebug('Accepting unauthorized certificate (rejectUnauthorized: false)', this.options);
+                return true;
+            }
+            return false;
+        }
+        const cert = socket.getPeerCertificate();
+        if (!cert) {
+            logDebug('No peer certificate available', this.options);
+            return false;
+        }
+        // Additional certificate validation
+        const now = new Date();
+        if (cert.valid_from && new Date(cert.valid_from) > now) {
+            logDebug('Certificate not yet valid', this.options, { validFrom: cert.valid_from });
+            return false;
+        }
+        if (cert.valid_to && new Date(cert.valid_to) < now) {
+            logDebug('Certificate expired', this.options, { validTo: cert.valid_to });
+            return false;
+        }
+        logDebug('TLS certificate validated', this.options, {
+            subject: cert.subject,
+            issuer: cert.issuer,
+            validFrom: cert.valid_from,
+            validTo: cert.valid_to
+        });
+        return true;
+    }
+    /**
+     * Get TLS connection information
+     */
+    getTLSInfo(socket) {
+        if (!(socket instanceof tls.TLSSocket)) {
+            return null;
+        }
+        return {
+            authorized: socket.authorized,
+            authorizationError: socket.authorizationError,
+            protocol: socket.getProtocol(),
+            cipher: socket.getCipher(),
+            peerCertificate: socket.getPeerCertificate(),
+            alpnProtocol: socket.alpnProtocol
+        };
+    }
+    /**
+     * Check if TLS upgrade is required or recommended
+     */
+    shouldUseTLS(connection) {
+        // Already secure
+        if (connection.secure) {
+            return false;
+        }
+        // Direct TLS connection configured
+        if (this.options.secure) {
+            return false; // Already handled in connection establishment
+        }
+        // STARTTLS available and not explicitly disabled
+        if (connection.capabilities?.starttls) {
+            return this.options.tls !== null && this.options.tls !== undefined; // Use TLS if configured
+        }
+        return false;
+    }
+    async performTLSUpgrade(connection) {
+        return new Promise((resolve, reject) => {
+            const plainSocket = connection.socket;
+            const timeout = this.options.connectionTimeout || DEFAULTS.CONNECTION_TIMEOUT;
+            const tlsOptions = {
+                socket: plainSocket,
+                host: this.options.host,
+                ...this.options.tls,
+                // Default TLS options for STARTTLS
+                secureProtocol: 'TLS_method',
+                ciphers: 'HIGH:!aNULL:!eNULL:!EXPORT:!DES:!RC4:!MD5:!PSK:!SRP:!CAMELLIA',
+                rejectUnauthorized: this.options.tls?.rejectUnauthorized !== false
+            };
+            const timeoutHandler = setTimeout(() => {
+                reject(new Error(`TLS upgrade timeout after ${timeout}ms`));
+            }, timeout);
+            // Create TLS socket from existing connection
+            const tlsSocket = tls.connect(tlsOptions);
+            tlsSocket.once('secureConnect', () => {
+                clearTimeout(timeoutHandler);
+                // Validate certificate if required
+                if (!this.validateCertificate(tlsSocket)) {
+                    tlsSocket.destroy();
+                    reject(new Error('TLS certificate validation failed'));
+                    return;
+                }
+                // Replace the socket in the connection
+                connection.socket = tlsSocket;
+                connection.secure = true;
+                logDebug('STARTTLS upgrade completed', this.options, {
+                    protocol: tlsSocket.getProtocol(),
+                    cipher: tlsSocket.getCipher()
+                });
+                resolve();
+            });
+            tlsSocket.once('error', (error) => {
+                clearTimeout(timeoutHandler);
+                reject(error);
+            });
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tls-handler.js","sourceRoot":"","sources":["../../../../../ts/mail/delivery/smtpclient/tls-handler.ts"],"names":[],"mappings":"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"}

package/dist_ts/ts/mail/delivery/smtpclient/utils/helpers.d.ts

@@ -0,0 +1,77 @@
+/**
+ * SMTP Client Helper Functions
+ * Protocol helper functions and utilities
+ */
+import type { ISmtpResponse, ISmtpCapabilities } from '../interfaces.js';
+/**
+ * Parse SMTP server response
+ */
+export declare function parseSmtpResponse(data: string): ISmtpResponse;
+/**
+ * Parse EHLO response and extract capabilities
+ */
+export declare function parseEhloResponse(response: string): ISmtpCapabilities;
+/**
+ * Format SMTP command with proper line ending
+ */
+export declare function formatCommand(command: string, ...args: string[]): string;
+/**
+ * Encode authentication string for AUTH PLAIN
+ */
+export declare function encodeAuthPlain(username: string, password: string): string;
+/**
+ * Encode authentication string for AUTH LOGIN
+ */
+export declare function encodeAuthLogin(value: string): string;
+/**
+ * Generate OAuth2 authentication string
+ */
+export declare function generateOAuth2String(username: string, accessToken: string): string;
+/**
+ * Check if response code indicates success
+ */
+export declare function isSuccessCode(code: number): boolean;
+/**
+ * Check if response code indicates temporary failure
+ */
+export declare function isTemporaryFailure(code: number): boolean;
+/**
+ * Check if response code indicates permanent failure
+ */
+export declare function isPermanentFailure(code: number): boolean;
+/**
+ * Escape email address for SMTP commands
+ */
+export declare function escapeEmailAddress(email: string): string;
+/**
+ * Extract email address from angle brackets
+ */
+export declare function extractEmailAddress(email: string): string;
+/**
+ * Generate unique connection ID
+ */
+export declare function generateConnectionId(): string;
+/**
+ * Format timeout duration for human readability
+ */
+export declare function formatTimeout(milliseconds: number): string;
+/**
+ * Validate and normalize email data size
+ */
+export declare function validateEmailSize(emailData: string, maxSize?: number): boolean;
+/**
+ * Clean sensitive data from logs
+ */
+export declare function sanitizeForLogging(data: any): any;
+/**
+ * Calculate exponential backoff delay
+ */
+export declare function calculateBackoffDelay(attempt: number, baseDelay?: number): number;
+/**
+ * Parse enhanced status code
+ */
+export declare function parseEnhancedStatusCode(code: string): {
+    class: number;
+    subject: number;
+    detail: number;
+} | null;

package/dist_ts/ts/mail/delivery/smtpclient/utils/helpers.js

@@ -0,0 +1,196 @@
+/**
+ * SMTP Client Helper Functions
+ * Protocol helper functions and utilities
+ */
+import { SMTP_CODES, REGEX_PATTERNS, LINE_ENDINGS } from '../constants.js';
+/**
+ * Parse SMTP server response
+ */
+export function parseSmtpResponse(data) {
+    const lines = data.trim().split(/\r?\n/);
+    const firstLine = lines[0];
+    const match = firstLine.match(REGEX_PATTERNS.RESPONSE_CODE);
+    if (!match) {
+        return {
+            code: 500,
+            message: 'Invalid server response',
+            raw: data
+        };
+    }
+    const code = parseInt(match[1], 10);
+    const separator = match[2];
+    const message = lines.map(line => line.substring(4)).join(' ');
+    // Check for enhanced status code
+    const enhancedMatch = message.match(REGEX_PATTERNS.ENHANCED_STATUS);
+    const enhancedCode = enhancedMatch ? enhancedMatch[1] : undefined;
+    return {
+        code,
+        message: enhancedCode ? message.substring(enhancedCode.length + 1) : message,
+        enhancedCode,
+        raw: data
+    };
+}
+/**
+ * Parse EHLO response and extract capabilities
+ */
+export function parseEhloResponse(response) {
+    const lines = response.trim().split(/\r?\n/);
+    const capabilities = {
+        extensions: new Set(),
+        authMethods: new Set(),
+        pipelining: false,
+        starttls: false,
+        eightBitMime: false
+    };
+    for (const line of lines.slice(1)) { // Skip first line (greeting)
+        const extensionLine = line.substring(4); // Remove "250-" or "250 "
+        const parts = extensionLine.split(/\s+/);
+        const extension = parts[0].toUpperCase();
+        capabilities.extensions.add(extension);
+        switch (extension) {
+            case 'PIPELINING':
+                capabilities.pipelining = true;
+                break;
+            case 'STARTTLS':
+                capabilities.starttls = true;
+                break;
+            case '8BITMIME':
+                capabilities.eightBitMime = true;
+                break;
+            case 'SIZE':
+                if (parts[1]) {
+                    capabilities.maxSize = parseInt(parts[1], 10);
+                }
+                break;
+            case 'AUTH':
+                // Parse authentication methods
+                for (let i = 1; i < parts.length; i++) {
+                    capabilities.authMethods.add(parts[i].toUpperCase());
+                }
+                break;
+        }
+    }
+    return capabilities;
+}
+/**
+ * Format SMTP command with proper line ending
+ */
+export function formatCommand(command, ...args) {
+    const fullCommand = args.length > 0 ? `${command} ${args.join(' ')}` : command;
+    return fullCommand + LINE_ENDINGS.CRLF;
+}
+/**
+ * Encode authentication string for AUTH PLAIN
+ */
+export function encodeAuthPlain(username, password) {
+    const authString = `\0${username}\0${password}`;
+    return Buffer.from(authString, 'utf8').toString('base64');
+}
+/**
+ * Encode authentication string for AUTH LOGIN
+ */
+export function encodeAuthLogin(value) {
+    return Buffer.from(value, 'utf8').toString('base64');
+}
+/**
+ * Generate OAuth2 authentication string
+ */
+export function generateOAuth2String(username, accessToken) {
+    const authString = `user=${username}\x01auth=Bearer ${accessToken}\x01\x01`;
+    return Buffer.from(authString, 'utf8').toString('base64');
+}
+/**
+ * Check if response code indicates success
+ */
+export function isSuccessCode(code) {
+    return code >= 200 && code < 300;
+}
+/**
+ * Check if response code indicates temporary failure
+ */
+export function isTemporaryFailure(code) {
+    return code >= 400 && code < 500;
+}
+/**
+ * Check if response code indicates permanent failure
+ */
+export function isPermanentFailure(code) {
+    return code >= 500;
+}
+/**
+ * Escape email address for SMTP commands
+ */
+export function escapeEmailAddress(email) {
+    return `<${email.trim()}>`;
+}
+/**
+ * Extract email address from angle brackets
+ */
+export function extractEmailAddress(email) {
+    const match = email.match(/^<(.+)>$/);
+    return match ? match[1] : email.trim();
+}
+/**
+ * Generate unique connection ID
+ */
+export function generateConnectionId() {
+    return `smtp-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+}
+/**
+ * Format timeout duration for human readability
+ */
+export function formatTimeout(milliseconds) {
+    if (milliseconds < 1000) {
+        return `${milliseconds}ms`;
+    }
+    else if (milliseconds < 60000) {
+        return `${Math.round(milliseconds / 1000)}s`;
+    }
+    else {
+        return `${Math.round(milliseconds / 60000)}m`;
+    }
+}
+/**
+ * Validate and normalize email data size
+ */
+export function validateEmailSize(emailData, maxSize) {
+    const size = Buffer.byteLength(emailData, 'utf8');
+    return !maxSize || size <= maxSize;
+}
+/**
+ * Clean sensitive data from logs
+ */
+export function sanitizeForLogging(data) {
+    if (typeof data !== 'object' || data === null) {
+        return data;
+    }
+    const sanitized = { ...data };
+    const sensitiveFields = ['password', 'pass', 'accessToken', 'refreshToken', 'clientSecret'];
+    for (const field of sensitiveFields) {
+        if (field in sanitized) {
+            sanitized[field] = '[REDACTED]';
+        }
+    }
+    return sanitized;
+}
+/**
+ * Calculate exponential backoff delay
+ */
+export function calculateBackoffDelay(attempt, baseDelay = 1000) {
+    return Math.min(baseDelay * Math.pow(2, attempt - 1), 30000); // Max 30 seconds
+}
+/**
+ * Parse enhanced status code
+ */
+export function parseEnhancedStatusCode(code) {
+    const match = code.match(/^(\d)\.(\d)\.(\d)$/);
+    if (!match) {
+        return null;
+    }
+    return {
+        class: parseInt(match[1], 10),
+        subject: parseInt(match[2], 10),
+        detail: parseInt(match[3], 10)
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/ts/mail/delivery/smtpclient/utils/logging.d.ts

@@ -0,0 +1,46 @@
+/**
+ * SMTP Client Logging Utilities
+ * Client-side logging utilities for SMTP operations
+ */
+import type { ISmtpResponse, ISmtpClientOptions } from '../interfaces.js';
+export interface ISmtpClientLogData {
+    component: string;
+    host?: string;
+    port?: number;
+    secure?: boolean;
+    command?: string;
+    response?: ISmtpResponse;
+    error?: Error;
+    connectionId?: string;
+    messageId?: string;
+    duration?: number;
+    [key: string]: any;
+}
+/**
+ * Log SMTP client connection events
+ */
+export declare function logConnection(event: 'connecting' | 'connected' | 'disconnected' | 'error', options: ISmtpClientOptions, data?: Partial<ISmtpClientLogData>): void;
+/**
+ * Log SMTP command execution
+ */
+export declare function logCommand(command: string, response?: ISmtpResponse, options?: ISmtpClientOptions, data?: Partial<ISmtpClientLogData>): void;
+/**
+ * Log authentication events
+ */
+export declare function logAuthentication(event: 'start' | 'success' | 'failure', method: string, options: ISmtpClientOptions, data?: Partial<ISmtpClientLogData>): void;
+/**
+ * Log TLS/STARTTLS events
+ */
+export declare function logTLS(event: 'starttls_start' | 'starttls_success' | 'starttls_failure' | 'tls_connected', options: ISmtpClientOptions, data?: Partial<ISmtpClientLogData>): void;
+/**
+ * Log email sending events
+ */
+export declare function logEmailSend(event: 'start' | 'success' | 'failure', recipients: string[], options: ISmtpClientOptions, data?: Partial<ISmtpClientLogData>): void;
+/**
+ * Log performance metrics
+ */
+export declare function logPerformance(operation: string, duration: number, options: ISmtpClientOptions, data?: Partial<ISmtpClientLogData>): void;
+/**
+ * Log debug information (only when debug is enabled)
+ */
+export declare function logDebug(message: string, options: ISmtpClientOptions, data?: Partial<ISmtpClientLogData>): void;