@push.rocks/smartmta 5.1.3 → 5.2.0

package/dist_ts/security/classes.rustsecuritybridge.js

@@ -0,0 +1,484 @@
+import * as plugins from '../plugins.js';
+import * as paths from '../paths.js';
+import { logger } from '../logger.js';
+import { EventEmitter } from 'events';
+// ---------------------------------------------------------------------------
+// Bridge state machine
+// ---------------------------------------------------------------------------
+export var BridgeState;
+(function (BridgeState) {
+    BridgeState["Idle"] = "idle";
+    BridgeState["Starting"] = "starting";
+    BridgeState["Running"] = "running";
+    BridgeState["Restarting"] = "restarting";
+    BridgeState["Failed"] = "failed";
+    BridgeState["Stopped"] = "stopped";
+})(BridgeState || (BridgeState = {}));
+const DEFAULT_RESILIENCE_CONFIG = {
+    maxRestartAttempts: 5,
+    healthCheckIntervalMs: 30_000,
+    restartBackoffBaseMs: 1_000,
+    restartBackoffMaxMs: 30_000,
+    healthCheckTimeoutMs: 5_000,
+};
+// ---------------------------------------------------------------------------
+// RustSecurityBridge — singleton wrapper around smartrust.RustBridge
+// ---------------------------------------------------------------------------
+/**
+ * Bridge between TypeScript and the Rust `mailer-bin` binary.
+ *
+ * Uses `@push.rocks/smartrust` for JSON-over-stdin/stdout IPC.
+ * Singleton — access via `RustSecurityBridge.getInstance()`.
+ *
+ * Features resilience via auto-restart with exponential backoff,
+ * periodic health checks, and a state machine that tracks the
+ * bridge lifecycle.
+ */
+export class RustSecurityBridge extends EventEmitter {
+    static instance = null;
+    static _resilienceConfig = { ...DEFAULT_RESILIENCE_CONFIG };
+    bridge;
+    _running = false;
+    _state = BridgeState.Idle;
+    _restartAttempts = 0;
+    _restartTimer = null;
+    _healthCheckTimer = null;
+    _deliberateStop = false;
+    _smtpServerConfig = null;
+    constructor() {
+        super();
+        this.bridge = new plugins.smartrust.RustBridge({
+            binaryName: 'mailer-bin',
+            cliArgs: ['--management'],
+            requestTimeoutMs: 30_000,
+            readyTimeoutMs: 10_000,
+            localPaths: [
+                plugins.path.join(paths.packageDir, 'dist_rust', 'mailer-bin'),
+                plugins.path.join(paths.packageDir, 'rust', 'target', 'release', 'mailer-bin'),
+                plugins.path.join(paths.packageDir, 'rust', 'target', 'debug', 'mailer-bin'),
+            ],
+            searchSystemPath: false,
+        });
+        // Forward lifecycle events
+        this.bridge.on('ready', () => {
+            this._running = true;
+            logger.log('info', 'Rust security bridge is ready');
+        });
+        this.bridge.on('exit', (code, signal) => {
+            this._running = false;
+            logger.log('warn', `Rust security bridge exited (code=${code}, signal=${signal})`);
+            if (this._deliberateStop) {
+                this.setState(BridgeState.Stopped);
+            }
+            else if (this._state === BridgeState.Running) {
+                // Unexpected exit — attempt restart
+                this.attemptRestart();
+            }
+        });
+        this.bridge.on('stderr', (line) => {
+            logger.log('debug', `[rust-bridge] ${line}`);
+        });
+    }
+    // -----------------------------------------------------------------------
+    // Static configuration & singleton
+    // -----------------------------------------------------------------------
+    /** Get or create the singleton instance. */
+    static getInstance() {
+        if (!RustSecurityBridge.instance) {
+            RustSecurityBridge.instance = new RustSecurityBridge();
+        }
+        return RustSecurityBridge.instance;
+    }
+    /** Reset the singleton instance (for testing). */
+    static resetInstance() {
+        if (RustSecurityBridge.instance) {
+            RustSecurityBridge.instance.stopHealthCheck();
+            if (RustSecurityBridge.instance._restartTimer) {
+                clearTimeout(RustSecurityBridge.instance._restartTimer);
+                RustSecurityBridge.instance._restartTimer = null;
+            }
+            RustSecurityBridge.instance.removeAllListeners();
+        }
+        RustSecurityBridge.instance = null;
+    }
+    /** Configure resilience parameters. Can be called before or after getInstance(). */
+    static configure(config) {
+        RustSecurityBridge._resilienceConfig = {
+            ...RustSecurityBridge._resilienceConfig,
+            ...config,
+        };
+    }
+    // -----------------------------------------------------------------------
+    // State management
+    // -----------------------------------------------------------------------
+    /** Current bridge state. */
+    get state() {
+        return this._state;
+    }
+    /** Whether the Rust process is currently running and accepting commands. */
+    get running() {
+        return this._running;
+    }
+    setState(newState) {
+        const oldState = this._state;
+        if (oldState === newState)
+            return;
+        this._state = newState;
+        logger.log('info', `Rust bridge state: ${oldState} -> ${newState}`);
+        this.emit('stateChange', { oldState, newState });
+    }
+    /**
+     * Throws a descriptive error if the bridge is not in Running state.
+     * Called at the top of every command method.
+     */
+    ensureRunning() {
+        if (this._state === BridgeState.Running && this._running) {
+            return;
+        }
+        switch (this._state) {
+            case BridgeState.Idle:
+                throw new Error('Rust bridge has not been started yet. Call start() first.');
+            case BridgeState.Starting:
+                throw new Error('Rust bridge is still starting. Wait for start() to resolve.');
+            case BridgeState.Restarting:
+                throw new Error('Rust bridge is restarting after a crash. Commands will resume once it recovers.');
+            case BridgeState.Failed:
+                throw new Error('Rust bridge has failed after exhausting all restart attempts.');
+            case BridgeState.Stopped:
+                throw new Error('Rust bridge has been stopped. Call start() to restart it.');
+            default:
+                throw new Error(`Rust bridge is not running (state=${this._state}).`);
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Lifecycle
+    // -----------------------------------------------------------------------
+    /**
+     * Spawn the Rust binary and wait for the ready signal.
+     * @returns `true` if the binary started successfully, `false` otherwise.
+     */
+    async start() {
+        if (this._running && this._state === BridgeState.Running) {
+            return true;
+        }
+        this._deliberateStop = false;
+        this._restartAttempts = 0;
+        this.setState(BridgeState.Starting);
+        try {
+            const ok = await this.bridge.spawn();
+            this._running = ok;
+            if (ok) {
+                this.setState(BridgeState.Running);
+                this.startHealthCheck();
+                logger.log('info', 'Rust security bridge started');
+            }
+            else {
+                this.setState(BridgeState.Failed);
+                logger.log('warn', 'Rust security bridge failed to start (binary not found or timeout)');
+            }
+            return ok;
+        }
+        catch (err) {
+            this.setState(BridgeState.Failed);
+            logger.log('error', `Failed to start Rust security bridge: ${err.message}`);
+            return false;
+        }
+    }
+    /** Kill the Rust process deliberately. */
+    async stop() {
+        this._deliberateStop = true;
+        // Cancel any pending restart
+        if (this._restartTimer) {
+            clearTimeout(this._restartTimer);
+            this._restartTimer = null;
+        }
+        this.stopHealthCheck();
+        this._smtpServerConfig = null;
+        if (!this._running) {
+            this.setState(BridgeState.Stopped);
+            return;
+        }
+        try {
+            this.bridge.kill();
+            this._running = false;
+            this.setState(BridgeState.Stopped);
+            logger.log('info', 'Rust security bridge stopped');
+        }
+        catch (err) {
+            logger.log('error', `Error stopping Rust security bridge: ${err.message}`);
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Auto-restart with exponential backoff
+    // -----------------------------------------------------------------------
+    attemptRestart() {
+        const config = RustSecurityBridge._resilienceConfig;
+        this._restartAttempts++;
+        if (this._restartAttempts > config.maxRestartAttempts) {
+            logger.log('error', `Rust bridge exceeded max restart attempts (${config.maxRestartAttempts}). Giving up.`);
+            this.setState(BridgeState.Failed);
+            return;
+        }
+        this.setState(BridgeState.Restarting);
+        this.stopHealthCheck();
+        const delay = Math.min(config.restartBackoffBaseMs * Math.pow(2, this._restartAttempts - 1), config.restartBackoffMaxMs);
+        logger.log('info', `Rust bridge restart attempt ${this._restartAttempts}/${config.maxRestartAttempts} in ${delay}ms`);
+        this._restartTimer = setTimeout(async () => {
+            this._restartTimer = null;
+            // Guard: if stop() was called while we were waiting, don't restart
+            if (this._deliberateStop) {
+                this.setState(BridgeState.Stopped);
+                return;
+            }
+            try {
+                const ok = await this.bridge.spawn();
+                this._running = ok;
+                if (ok) {
+                    logger.log('info', 'Rust bridge restarted successfully');
+                    this._restartAttempts = 0;
+                    this.setState(BridgeState.Running);
+                    this.startHealthCheck();
+                    await this.restoreAfterRestart();
+                }
+                else {
+                    logger.log('warn', 'Rust bridge restart failed (spawn returned false)');
+                    this.attemptRestart();
+                }
+            }
+            catch (err) {
+                logger.log('error', `Rust bridge restart failed: ${err.message}`);
+                this.attemptRestart();
+            }
+        }, delay);
+    }
+    /**
+     * Restore state after a successful restart:
+     * - Re-send startSmtpServer command if the SMTP server was running
+     */
+    async restoreAfterRestart() {
+        if (this._smtpServerConfig) {
+            try {
+                logger.log('info', 'Restoring SMTP server after bridge restart');
+                const result = await this.bridge.sendCommand('startSmtpServer', this._smtpServerConfig);
+                if (result?.started) {
+                    logger.log('info', 'SMTP server restored after bridge restart');
+                }
+                else {
+                    logger.log('warn', 'SMTP server failed to restore after bridge restart');
+                }
+            }
+            catch (err) {
+                logger.log('error', `Failed to restore SMTP server after restart: ${err.message}`);
+            }
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Health check
+    // -----------------------------------------------------------------------
+    startHealthCheck() {
+        this.stopHealthCheck();
+        const config = RustSecurityBridge._resilienceConfig;
+        this._healthCheckTimer = setInterval(async () => {
+            if (this._state !== BridgeState.Running || !this._running) {
+                return;
+            }
+            try {
+                const pongPromise = this.bridge.sendCommand('ping', {});
+                const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('Health check timeout')), config.healthCheckTimeoutMs));
+                const res = await Promise.race([pongPromise, timeoutPromise]);
+                if (!res?.pong) {
+                    throw new Error('Health check: unexpected ping response');
+                }
+            }
+            catch (err) {
+                logger.log('warn', `Rust bridge health check failed: ${err.message}. Killing process to trigger restart.`);
+                try {
+                    this.bridge.kill();
+                }
+                catch {
+                    // Already dead
+                }
+                // The exit handler will trigger attemptRestart()
+            }
+        }, config.healthCheckIntervalMs);
+    }
+    stopHealthCheck() {
+        if (this._healthCheckTimer) {
+            clearInterval(this._healthCheckTimer);
+            this._healthCheckTimer = null;
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Commands — thin typed wrappers over sendCommand
+    // -----------------------------------------------------------------------
+    /** Ping the Rust process. */
+    async ping() {
+        this.ensureRunning();
+        const res = await this.bridge.sendCommand('ping', {});
+        return res?.pong === true;
+    }
+    /** Get version information for all Rust crates. */
+    async getVersion() {
+        this.ensureRunning();
+        return this.bridge.sendCommand('version', {});
+    }
+    /** Validate an email address. */
+    async validateEmail(email) {
+        this.ensureRunning();
+        return this.bridge.sendCommand('validateEmail', { email });
+    }
+    /** Detect bounce type from SMTP response / diagnostic code. */
+    async detectBounce(opts) {
+        this.ensureRunning();
+        return this.bridge.sendCommand('detectBounce', opts);
+    }
+    /** Scan email content for threats (phishing, spam, malware, etc.). */
+    async scanContent(opts) {
+        this.ensureRunning();
+        return this.bridge.sendCommand('scanContent', opts);
+    }
+    /** Check IP reputation via DNSBL. */
+    async checkIpReputation(ip) {
+        this.ensureRunning();
+        return this.bridge.sendCommand('checkIpReputation', { ip });
+    }
+    /** Verify DKIM signatures on a raw email message. */
+    async verifyDkim(rawMessage) {
+        this.ensureRunning();
+        return this.bridge.sendCommand('verifyDkim', { rawMessage });
+    }
+    /** Sign an email with DKIM (RSA or Ed25519). */
+    async signDkim(opts) {
+        this.ensureRunning();
+        return this.bridge.sendCommand('signDkim', opts);
+    }
+    /** Check SPF for a sender. */
+    async checkSpf(opts) {
+        this.ensureRunning();
+        return this.bridge.sendCommand('checkSpf', opts);
+    }
+    /**
+     * Compound email security verification: DKIM + SPF + DMARC in one IPC call.
+     *
+     * This is the preferred method for inbound email verification — it avoids
+     * 3 sequential round-trips and correctly passes raw mail-auth types internally.
+     */
+    async verifyEmail(opts) {
+        this.ensureRunning();
+        return this.bridge.sendCommand('verifyEmail', opts);
+    }
+    // -----------------------------------------------------------------------
+    // SMTP Client — outbound email delivery via Rust
+    // -----------------------------------------------------------------------
+    /** Send a structured email via the Rust SMTP client. */
+    async sendOutboundEmail(opts) {
+        this.ensureRunning();
+        return this.bridge.sendCommand('sendEmail', opts);
+    }
+    /** Send a pre-formatted raw email via the Rust SMTP client. */
+    async sendRawEmail(opts) {
+        this.ensureRunning();
+        return this.bridge.sendCommand('sendRawEmail', opts);
+    }
+    /** Verify connectivity to an SMTP server. */
+    async verifySmtpConnection(opts) {
+        this.ensureRunning();
+        return this.bridge.sendCommand('verifySmtpConnection', opts);
+    }
+    /** Close a specific connection pool (or all pools if no key is given). */
+    async closeSmtpPool(poolKey) {
+        this.ensureRunning();
+        await this.bridge.sendCommand('closeSmtpPool', poolKey ? { poolKey } : {});
+    }
+    /** Get status of all SMTP client connection pools. */
+    async getSmtpPoolStatus() {
+        this.ensureRunning();
+        return this.bridge.sendCommand('getSmtpPoolStatus', {});
+    }
+    // -----------------------------------------------------------------------
+    // SMTP Server lifecycle
+    // -----------------------------------------------------------------------
+    /**
+     * Start the Rust SMTP server.
+     * The server will listen on the configured ports and emit events for
+     * emailReceived and authRequest that must be handled by the caller.
+     */
+    async startSmtpServer(config) {
+        this.ensureRunning();
+        this._smtpServerConfig = config;
+        const result = await this.bridge.sendCommand('startSmtpServer', config);
+        return result?.started === true;
+    }
+    /** Stop the Rust SMTP server. */
+    async stopSmtpServer() {
+        this.ensureRunning();
+        this._smtpServerConfig = null;
+        await this.bridge.sendCommand('stopSmtpServer', {});
+    }
+    /**
+     * Send the result of email processing back to the Rust SMTP server.
+     * This resolves a pending correlation-ID callback, allowing the Rust
+     * server to send the SMTP response to the client.
+     */
+    async sendEmailProcessingResult(opts) {
+        this.ensureRunning();
+        await this.bridge.sendCommand('emailProcessingResult', opts);
+    }
+    /**
+     * Send the result of authentication validation back to the Rust SMTP server.
+     */
+    async sendAuthResult(opts) {
+        this.ensureRunning();
+        await this.bridge.sendCommand('authResult', opts);
+    }
+    /**
+     * Send SCRAM credentials back to the Rust SMTP server.
+     * Values (salt, storedKey, serverKey) must be base64-encoded.
+     */
+    async sendScramCredentialResult(opts) {
+        this.ensureRunning();
+        await this.bridge.sendCommand('scramCredentialResult', opts);
+    }
+    /** Update rate limit configuration at runtime. */
+    async configureRateLimits(config) {
+        this.ensureRunning();
+        await this.bridge.sendCommand('configureRateLimits', config);
+    }
+    // -----------------------------------------------------------------------
+    // Event registration — delegates to the underlying bridge EventEmitter
+    // -----------------------------------------------------------------------
+    /**
+     * Register a handler for emailReceived events from the Rust SMTP server.
+     * These events fire when a complete email has been received and needs processing.
+     */
+    onEmailReceived(handler) {
+        this.bridge.on('management:emailReceived', handler);
+    }
+    /**
+     * Register a handler for authRequest events from the Rust SMTP server.
+     * The handler must call sendAuthResult() with the correlationId.
+     */
+    onAuthRequest(handler) {
+        this.bridge.on('management:authRequest', handler);
+    }
+    /**
+     * Register a handler for scramCredentialRequest events from the Rust SMTP server.
+     * The handler must call sendScramCredentialResult() with the correlationId.
+     */
+    onScramCredentialRequest(handler) {
+        this.bridge.on('management:scramCredentialRequest', handler);
+    }
+    /** Remove an emailReceived event handler. */
+    offEmailReceived(handler) {
+        this.bridge.off('management:emailReceived', handler);
+    }
+    /** Remove an authRequest event handler. */
+    offAuthRequest(handler) {
+        this.bridge.off('management:authRequest', handler);
+    }
+    /** Remove a scramCredentialRequest event handler. */
+    offScramCredentialRequest(handler) {
+        this.bridge.off('management:scramCredentialRequest', handler);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.rustsecuritybridge.js","sourceRoot":"","sources":["../../ts/security/classes.rustsecuritybridge.ts"],"names":[],"mappings":"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"}

package/dist_ts/security/classes.securitylogger.d.ts

@@ -0,0 +1,140 @@
+/**
+ * Log level for security events
+ */
+export declare enum SecurityLogLevel {
+    INFO = "info",
+    WARN = "warn",
+    ERROR = "error",
+    CRITICAL = "critical"
+}
+/**
+ * Security event types for categorization
+ */
+export declare enum SecurityEventType {
+    AUTHENTICATION = "authentication",
+    ACCESS_CONTROL = "access_control",
+    EMAIL_VALIDATION = "email_validation",
+    EMAIL_PROCESSING = "email_processing",
+    EMAIL_FORWARDING = "email_forwarding",
+    EMAIL_DELIVERY = "email_delivery",
+    DKIM = "dkim",
+    SPF = "spf",
+    DMARC = "dmarc",
+    RATE_LIMIT = "rate_limit",
+    RATE_LIMITING = "rate_limiting",
+    SPAM = "spam",
+    MALWARE = "malware",
+    CONNECTION = "connection",
+    DATA_EXPOSURE = "data_exposure",
+    CONFIGURATION = "configuration",
+    IP_REPUTATION = "ip_reputation",
+    REJECTED_CONNECTION = "rejected_connection"
+}
+/**
+ * Security event interface
+ */
+export interface ISecurityEvent {
+    timestamp: number;
+    level: SecurityLogLevel;
+    type: SecurityEventType;
+    message: string;
+    details?: any;
+    ipAddress?: string;
+    userId?: string;
+    sessionId?: string;
+    emailId?: string;
+    domain?: string;
+    action?: string;
+    result?: string;
+    success?: boolean;
+}
+/**
+ * Security logger for enhanced security monitoring
+ */
+export declare class SecurityLogger {
+    private static instance;
+    private securityEvents;
+    private maxEventHistory;
+    private enableNotifications;
+    private constructor();
+    /**
+     * Get singleton instance
+     */
+    static getInstance(options?: {
+        maxEventHistory?: number;
+        enableNotifications?: boolean;
+    }): SecurityLogger;
+    /**
+     * Log a security event
+     * @param event The security event to log
+     */
+    logEvent(event: Omit<ISecurityEvent, 'timestamp'>): void;
+    /**
+     * Get recent security events
+     * @param limit Maximum number of events to return
+     * @param filter Filter for specific event types
+     * @returns Recent security events
+     */
+    getRecentEvents(limit?: number, filter?: {
+        level?: SecurityLogLevel;
+        type?: SecurityEventType;
+        fromTimestamp?: number;
+        toTimestamp?: number;
+    }): ISecurityEvent[];
+    /**
+     * Get events by security level
+     * @param level The security level to filter by
+     * @param limit Maximum number of events to return
+     * @returns Security events matching the level
+     */
+    getEventsByLevel(level: SecurityLogLevel, limit?: number): ISecurityEvent[];
+    /**
+     * Get events by security type
+     * @param type The event type to filter by
+     * @param limit Maximum number of events to return
+     * @returns Security events matching the type
+     */
+    getEventsByType(type: SecurityEventType, limit?: number): ISecurityEvent[];
+    /**
+     * Get security events for a specific IP address
+     * @param ipAddress The IP address to filter by
+     * @param limit Maximum number of events to return
+     * @returns Security events for the IP address
+     */
+    getEventsByIP(ipAddress: string, limit?: number): ISecurityEvent[];
+    /**
+     * Get security events for a specific domain
+     * @param domain The domain to filter by
+     * @param limit Maximum number of events to return
+     * @returns Security events for the domain
+     */
+    getEventsByDomain(domain: string, limit?: number): ISecurityEvent[];
+    /**
+     * Send a notification for critical security events
+     * @param event The security event to notify about
+     * @private
+     */
+    private sendNotification;
+    /**
+     * Clear event history
+     */
+    clearEvents(): void;
+    /**
+     * Get statistical summary of security events
+     * @param timeWindow Optional time window in milliseconds
+     * @returns Summary of security events
+     */
+    getEventsSummary(timeWindow?: number): {
+        total: number;
+        byLevel: Record<SecurityLogLevel, number>;
+        byType: Record<SecurityEventType, number>;
+        topIPs: Array<{
+            ip: string;
+            count: number;
+        }>;
+        topDomains: Array<{
+            domain: string;
+            count: number;
+        }>;
+    };
+}