@serve.zone/dcrouter 2.12.4

package/dist_ts/ts/mail/delivery/smtpserver/security-handler.d.ts

@@ -0,0 +1,86 @@
+/**
+ * SMTP Security Handler
+ * Responsible for security aspects including IP reputation checking,
+ * email validation, and authentication
+ */
+import * as plugins from '../../../plugins.js';
+import type { ISmtpAuth } from './interfaces.js';
+import type { ISecurityHandler, ISmtpServer } from './interfaces.js';
+/**
+ * Handles security aspects for SMTP server
+ */
+export declare class SecurityHandler implements ISecurityHandler {
+    /**
+     * Reference to the SMTP server instance
+     */
+    private smtpServer;
+    /**
+     * IP reputation checker service
+     */
+    private ipReputationService;
+    /**
+     * Simple in-memory IP denylist
+     */
+    private ipDenylist;
+    /**
+     * Cleanup interval timer
+     */
+    private cleanupInterval;
+    /**
+     * Creates a new security handler
+     * @param smtpServer - SMTP server instance
+     */
+    constructor(smtpServer: ISmtpServer);
+    /**
+     * Check IP reputation for a connection
+     * @param socket - Client socket
+     * @returns Promise that resolves to true if IP is allowed, false if blocked
+     */
+    checkIpReputation(socket: plugins.net.Socket | plugins.tls.TLSSocket): Promise<boolean>;
+    /**
+     * Validate an email address
+     * @param email - Email address to validate
+     * @returns Whether the email address is valid
+     */
+    isValidEmail(email: string): boolean;
+    /**
+     * Validate authentication credentials
+     * @param auth - Authentication credentials
+     * @returns Promise that resolves to true if authenticated
+     */
+    authenticate(auth: ISmtpAuth): Promise<boolean>;
+    /**
+     * Log a security event
+     * @param event - Event type
+     * @param level - Log level
+     * @param details - Event details
+     */
+    logSecurityEvent(event: string, level: string, message: string, details: Record<string, any>): void;
+    /**
+     * Add an IP to the denylist
+     * @param ip - IP address
+     * @param reason - Reason for denylisting
+     * @param duration - Duration in milliseconds (optional, indefinite if not specified)
+     */
+    private addToDenylist;
+    /**
+     * Check if an IP is denylisted
+     * @param ip - IP address
+     * @returns Whether the IP is denylisted
+     */
+    private isIpDenylisted;
+    /**
+     * Get the reason an IP was denylisted
+     * @param ip - IP address
+     * @returns Reason for denylisting or undefined if not denylisted
+     */
+    private getDenylistReason;
+    /**
+     * Clean expired denylist entries
+     */
+    private cleanExpiredDenylistEntries;
+    /**
+     * Clean up resources
+     */
+    destroy(): void;
+}

package/dist_ts/ts/mail/delivery/smtpserver/security-handler.js

@@ -0,0 +1,234 @@
+/**
+ * SMTP Security Handler
+ * Responsible for security aspects including IP reputation checking,
+ * email validation, and authentication
+ */
+import * as plugins from '../../../plugins.js';
+import { SmtpLogger } from './utils/logging.js';
+import { SecurityEventType, SecurityLogLevel } from './constants.js';
+import { isValidEmail } from './utils/validation.js';
+import { getSocketDetails, getTlsDetails } from './utils/helpers.js';
+import { IPReputationChecker } from '../../../security/classes.ipreputationchecker.js';
+/**
+ * Handles security aspects for SMTP server
+ */
+export class SecurityHandler {
+    /**
+     * Creates a new security handler
+     * @param smtpServer - SMTP server instance
+     */
+    constructor(smtpServer) {
+        /**
+         * Simple in-memory IP denylist
+         */
+        this.ipDenylist = [];
+        /**
+         * Cleanup interval timer
+         */
+        this.cleanupInterval = null;
+        this.smtpServer = smtpServer;
+        // Initialize IP reputation checker
+        this.ipReputationService = new IPReputationChecker();
+        // Clean expired denylist entries periodically
+        this.cleanupInterval = setInterval(() => this.cleanExpiredDenylistEntries(), 60000); // Every minute
+    }
+    /**
+     * Check IP reputation for a connection
+     * @param socket - Client socket
+     * @returns Promise that resolves to true if IP is allowed, false if blocked
+     */
+    async checkIpReputation(socket) {
+        const socketDetails = getSocketDetails(socket);
+        const ip = socketDetails.remoteAddress;
+        // Check local denylist first
+        if (this.isIpDenylisted(ip)) {
+            // Log the blocked connection
+            this.logSecurityEvent(SecurityEventType.IP_REPUTATION, SecurityLogLevel.WARN, `Connection blocked from denylisted IP: ${ip}`, { reason: this.getDenylistReason(ip) });
+            return false;
+        }
+        // Check with IP reputation service
+        if (!this.ipReputationService) {
+            return true;
+        }
+        try {
+            // Check with IP reputation service
+            const reputationResult = await this.ipReputationService.checkReputation(ip);
+            // Block if score is below HIGH_RISK threshold (20) or if it's spam/proxy/tor/vpn
+            const isBlocked = reputationResult.score < 20 ||
+                reputationResult.isSpam ||
+                reputationResult.isTor ||
+                reputationResult.isProxy;
+            if (isBlocked) {
+                // Add to local denylist temporarily
+                const reason = reputationResult.isSpam ? 'spam' :
+                    reputationResult.isTor ? 'tor' :
+                        reputationResult.isProxy ? 'proxy' :
+                            `low reputation score: ${reputationResult.score}`;
+                this.addToDenylist(ip, reason, 3600000); // 1 hour
+                // Log the blocked connection
+                this.logSecurityEvent(SecurityEventType.IP_REPUTATION, SecurityLogLevel.WARN, `Connection blocked by reputation service: ${ip}`, {
+                    reason,
+                    score: reputationResult.score,
+                    isSpam: reputationResult.isSpam,
+                    isTor: reputationResult.isTor,
+                    isProxy: reputationResult.isProxy,
+                    isVPN: reputationResult.isVPN
+                });
+                return false;
+            }
+            // Log the allowed connection
+            this.logSecurityEvent(SecurityEventType.IP_REPUTATION, SecurityLogLevel.INFO, `IP reputation check passed: ${ip}`, {
+                score: reputationResult.score,
+                country: reputationResult.country,
+                org: reputationResult.org
+            });
+            return true;
+        }
+        catch (error) {
+            // Log the error
+            SmtpLogger.error(`IP reputation check error: ${error instanceof Error ? error.message : String(error)}`, {
+                ip,
+                error: error instanceof Error ? error : new Error(String(error))
+            });
+            // Allow the connection on error (fail open)
+            return true;
+        }
+    }
+    /**
+     * Validate an email address
+     * @param email - Email address to validate
+     * @returns Whether the email address is valid
+     */
+    isValidEmail(email) {
+        return isValidEmail(email);
+    }
+    /**
+     * Validate authentication credentials
+     * @param auth - Authentication credentials
+     * @returns Promise that resolves to true if authenticated
+     */
+    async authenticate(auth) {
+        const { username, password } = auth;
+        // Get auth options from server
+        const options = this.smtpServer.getOptions();
+        const authOptions = options.auth;
+        // Check if authentication is enabled
+        if (!authOptions) {
+            this.logSecurityEvent(SecurityEventType.AUTHENTICATION, SecurityLogLevel.WARN, 'Authentication attempt when auth is disabled', { username });
+            return false;
+        }
+        // Note: Method validation and TLS requirement checks would need to be done
+        // at the caller level since the interface doesn't include session/method info
+        try {
+            let authenticated = false;
+            // Use custom validation function if provided
+            if (authOptions.validateUser) {
+                authenticated = await authOptions.validateUser(username, password);
+            }
+            else {
+                // Default behavior - no authentication
+                authenticated = false;
+            }
+            // Log the authentication result
+            this.logSecurityEvent(SecurityEventType.AUTHENTICATION, authenticated ? SecurityLogLevel.INFO : SecurityLogLevel.WARN, authenticated ? 'Authentication successful' : 'Authentication failed', { username });
+            return authenticated;
+        }
+        catch (error) {
+            // Log authentication error
+            this.logSecurityEvent(SecurityEventType.AUTHENTICATION, SecurityLogLevel.ERROR, `Authentication error: ${error instanceof Error ? error.message : String(error)}`, { username, error: error instanceof Error ? error.message : String(error) });
+            return false;
+        }
+    }
+    /**
+     * Log a security event
+     * @param event - Event type
+     * @param level - Log level
+     * @param details - Event details
+     */
+    logSecurityEvent(event, level, message, details) {
+        SmtpLogger.logSecurityEvent(level, event, message, details, details.ip, details.domain, details.success);
+    }
+    /**
+     * Add an IP to the denylist
+     * @param ip - IP address
+     * @param reason - Reason for denylisting
+     * @param duration - Duration in milliseconds (optional, indefinite if not specified)
+     */
+    addToDenylist(ip, reason, duration) {
+        // Remove existing entry if present
+        this.ipDenylist = this.ipDenylist.filter(entry => entry.ip !== ip);
+        // Create new entry
+        const entry = {
+            ip,
+            reason,
+            expiresAt: duration ? Date.now() + duration : undefined
+        };
+        // Add to denylist
+        this.ipDenylist.push(entry);
+        // Log the action
+        this.logSecurityEvent(SecurityEventType.ACCESS_CONTROL, SecurityLogLevel.INFO, `Added IP to denylist: ${ip}`, {
+            ip,
+            reason,
+            duration: duration ? `${duration / 1000} seconds` : 'indefinite'
+        });
+    }
+    /**
+     * Check if an IP is denylisted
+     * @param ip - IP address
+     * @returns Whether the IP is denylisted
+     */
+    isIpDenylisted(ip) {
+        const entry = this.ipDenylist.find(e => e.ip === ip);
+        if (!entry) {
+            return false;
+        }
+        // Check if entry has expired
+        if (entry.expiresAt && entry.expiresAt < Date.now()) {
+            // Remove expired entry
+            this.ipDenylist = this.ipDenylist.filter(e => e !== entry);
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Get the reason an IP was denylisted
+     * @param ip - IP address
+     * @returns Reason for denylisting or undefined if not denylisted
+     */
+    getDenylistReason(ip) {
+        const entry = this.ipDenylist.find(e => e.ip === ip);
+        return entry?.reason;
+    }
+    /**
+     * Clean expired denylist entries
+     */
+    cleanExpiredDenylistEntries() {
+        const now = Date.now();
+        const initialCount = this.ipDenylist.length;
+        this.ipDenylist = this.ipDenylist.filter(entry => {
+            return !entry.expiresAt || entry.expiresAt > now;
+        });
+        const removedCount = initialCount - this.ipDenylist.length;
+        if (removedCount > 0) {
+            this.logSecurityEvent(SecurityEventType.ACCESS_CONTROL, SecurityLogLevel.INFO, `Cleaned up ${removedCount} expired denylist entries`, { remainingCount: this.ipDenylist.length });
+        }
+    }
+    /**
+     * Clean up resources
+     */
+    destroy() {
+        // Clear the cleanup interval
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = null;
+        }
+        // Clear the denylist
+        this.ipDenylist = [];
+        // Clean up IP reputation service if it has a destroy method
+        if (this.ipReputationService && typeof this.ipReputationService.destroy === 'function') {
+            this.ipReputationService.destroy();
+        }
+        SmtpLogger.debug('SecurityHandler destroyed');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"security-handler.js","sourceRoot":"","sources":["../../../../../ts/mail/delivery/smtpserver/security-handler.ts"],"names":[],"mappings":"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"}

package/dist_ts/ts/mail/delivery/smtpserver/session-manager.d.ts

@@ -0,0 +1,140 @@
+/**
+ * SMTP Session Manager
+ * Responsible for creating, managing, and cleaning up SMTP sessions
+ */
+import * as plugins from '../../../plugins.js';
+import { SmtpState } from './interfaces.js';
+import type { ISmtpSession } from './interfaces.js';
+import type { ISessionManager, ISessionEvents } from './interfaces.js';
+/**
+ * Manager for SMTP sessions
+ * Handles session creation, tracking, timeout management, and cleanup
+ */
+export declare class SessionManager implements ISessionManager {
+    /**
+     * Map of socket ID to session
+     */
+    private sessions;
+    /**
+     * Map of socket to socket ID
+     */
+    private socketIds;
+    /**
+     * SMTP server options
+     */
+    private options;
+    /**
+     * Event listeners
+     */
+    private eventListeners;
+    /**
+     * Timer for cleanup interval
+     */
+    private cleanupTimer;
+    /**
+     * Creates a new session manager
+     * @param options - Session manager options
+     */
+    constructor(options?: {
+        socketTimeout?: number;
+        connectionTimeout?: number;
+        cleanupInterval?: number;
+    });
+    /**
+     * Creates a new session for a socket connection
+     * @param socket - Client socket
+     * @param secure - Whether the connection is secure (TLS)
+     * @returns New SMTP session
+     */
+    createSession(socket: plugins.net.Socket | plugins.tls.TLSSocket, secure: boolean): ISmtpSession;
+    /**
+     * Updates the session state
+     * @param session - SMTP session
+     * @param newState - New state
+     */
+    updateSessionState(session: ISmtpSession, newState: SmtpState): void;
+    /**
+     * Updates the session's last activity timestamp
+     * @param session - SMTP session
+     */
+    updateSessionActivity(session: ISmtpSession): void;
+    /**
+     * Removes a session
+     * @param socket - Client socket
+     */
+    removeSession(socket: plugins.net.Socket | plugins.tls.TLSSocket): void;
+    /**
+     * Gets a session for a socket
+     * @param socket - Client socket
+     * @returns SMTP session or undefined if not found
+     */
+    getSession(socket: plugins.net.Socket | plugins.tls.TLSSocket): ISmtpSession | undefined;
+    /**
+     * Cleans up idle sessions
+     */
+    cleanupIdleSessions(): void;
+    /**
+     * Gets the current number of active sessions
+     * @returns Number of active sessions
+     */
+    getSessionCount(): number;
+    /**
+     * Clears all sessions (used when shutting down)
+     */
+    clearAllSessions(): void;
+    /**
+     * Register an event listener
+     * @param event - Event name
+     * @param listener - Event listener function
+     */
+    on<K extends keyof ISessionEvents>(event: K, listener: ISessionEvents[K]): void;
+    /**
+     * Remove an event listener
+     * @param event - Event name
+     * @param listener - Event listener function
+     */
+    off<K extends keyof ISessionEvents>(event: K, listener: ISessionEvents[K]): void;
+    /**
+     * Emit an event to registered listeners
+     * @param event - Event name
+     * @param args - Event arguments
+     */
+    private emitEvent;
+    /**
+     * Start the cleanup timer
+     */
+    private startCleanupTimer;
+    /**
+     * Stop the cleanup timer
+     */
+    private stopCleanupTimer;
+    /**
+     * Replace socket mapping for STARTTLS upgrades
+     * @param oldSocket - Original plain socket
+     * @param newSocket - New TLS socket
+     * @returns Whether the replacement was successful
+     */
+    replaceSocket(oldSocket: plugins.net.Socket | plugins.tls.TLSSocket, newSocket: plugins.net.Socket | plugins.tls.TLSSocket): boolean;
+    /**
+     * Gets a unique key for a socket
+     * @param socket - Client socket
+     * @returns Socket key
+     */
+    private getSocketKey;
+    /**
+     * Get all active sessions
+     */
+    getAllSessions(): ISmtpSession[];
+    /**
+     * Update last activity for a session by socket
+     */
+    updateLastActivity(socket: plugins.net.Socket | plugins.tls.TLSSocket): void;
+    /**
+     * Check for timed out sessions
+     */
+    checkTimeouts(timeoutMs: number): ISmtpSession[];
+    /**
+     * Clean up resources
+     */
+    destroy(): void;
+}