@push.rocks/smartmta 5.1.3 → 5.2.0

package/dist_ts/security/classes.ipreputationchecker.js

@@ -0,0 +1,263 @@
+import * as plugins from '../plugins.js';
+import * as paths from '../paths.js';
+import { logger } from '../logger.js';
+import { SecurityLogger, SecurityLogLevel, SecurityEventType } from './classes.securitylogger.js';
+import { RustSecurityBridge } from './classes.rustsecuritybridge.js';
+import { LRUCache } from 'lru-cache';
+/**
+ * Reputation threshold scores
+ */
+export var ReputationThreshold;
+(function (ReputationThreshold) {
+    ReputationThreshold[ReputationThreshold["HIGH_RISK"] = 20] = "HIGH_RISK";
+    ReputationThreshold[ReputationThreshold["MEDIUM_RISK"] = 50] = "MEDIUM_RISK";
+    ReputationThreshold[ReputationThreshold["LOW_RISK"] = 80] = "LOW_RISK"; // Score below this is considered low risk (but not trusted)
+})(ReputationThreshold || (ReputationThreshold = {}));
+/**
+ * IP type classifications
+ */
+export var IPType;
+(function (IPType) {
+    IPType["RESIDENTIAL"] = "residential";
+    IPType["DATACENTER"] = "datacenter";
+    IPType["PROXY"] = "proxy";
+    IPType["TOR"] = "tor";
+    IPType["VPN"] = "vpn";
+    IPType["UNKNOWN"] = "unknown";
+})(IPType || (IPType = {}));
+/**
+ * IP reputation checker — delegates DNSBL lookups to the Rust security bridge.
+ * Retains LRU caching and disk persistence in TypeScript.
+ */
+export class IPReputationChecker {
+    static instance;
+    reputationCache;
+    options;
+    storageManager;
+    static DEFAULT_OPTIONS = {
+        maxCacheSize: 10000,
+        cacheTTL: 24 * 60 * 60 * 1000,
+        dnsblServers: [],
+        highRiskThreshold: ReputationThreshold.HIGH_RISK,
+        mediumRiskThreshold: ReputationThreshold.MEDIUM_RISK,
+        lowRiskThreshold: ReputationThreshold.LOW_RISK,
+        enableLocalCache: true,
+        enableDNSBL: true,
+        enableIPInfo: true
+    };
+    constructor(options = {}, storageManager) {
+        this.options = {
+            ...IPReputationChecker.DEFAULT_OPTIONS,
+            ...options
+        };
+        this.storageManager = storageManager;
+        this.reputationCache = new LRUCache({
+            max: this.options.maxCacheSize,
+            ttl: this.options.cacheTTL,
+        });
+        if (this.options.enableLocalCache) {
+            this.loadCache().catch(error => {
+                logger.log('error', `Failed to load IP reputation cache during initialization: ${error.message}`);
+            });
+        }
+    }
+    static getInstance(options = {}, storageManager) {
+        if (!IPReputationChecker.instance) {
+            IPReputationChecker.instance = new IPReputationChecker(options, storageManager);
+        }
+        return IPReputationChecker.instance;
+    }
+    /**
+     * Check an IP address's reputation via the Rust bridge
+     */
+    async checkReputation(ip) {
+        try {
+            if (!this.isValidIPAddress(ip)) {
+                logger.log('warn', `Invalid IP address format: ${ip}`);
+                return this.createErrorResult(ip, 'Invalid IP address format');
+            }
+            // Check cache first
+            const cachedResult = this.reputationCache.get(ip);
+            if (cachedResult) {
+                logger.log('info', `Using cached reputation data for IP ${ip}`, {
+                    score: cachedResult.score,
+                    isSpam: cachedResult.isSpam
+                });
+                return cachedResult;
+            }
+            // Delegate to Rust bridge
+            const bridge = RustSecurityBridge.getInstance();
+            const rustResult = await bridge.checkIpReputation(ip);
+            const result = {
+                score: rustResult.score,
+                isSpam: rustResult.listed_count > 0,
+                isProxy: rustResult.ip_type === 'proxy',
+                isTor: rustResult.ip_type === 'tor',
+                isVPN: rustResult.ip_type === 'vpn',
+                blacklists: rustResult.dnsbl_results
+                    .filter(d => d.listed)
+                    .map(d => d.server),
+                timestamp: Date.now(),
+            };
+            this.reputationCache.set(ip, result);
+            if (this.options.enableLocalCache) {
+                this.saveCache().catch(error => {
+                    logger.log('error', `Failed to save IP reputation cache: ${error.message}`);
+                });
+            }
+            this.logReputationCheck(ip, result);
+            return result;
+        }
+        catch (error) {
+            logger.log('error', `Error checking IP reputation for ${ip}: ${error.message}`, {
+                ip,
+                stack: error.stack
+            });
+            const errorResult = this.createErrorResult(ip, error.message);
+            // Cache error results to avoid repeated failing lookups
+            this.reputationCache.set(ip, errorResult);
+            return errorResult;
+        }
+    }
+    createErrorResult(ip, errorMessage) {
+        return {
+            score: 50,
+            isSpam: false,
+            isProxy: false,
+            isTor: false,
+            isVPN: false,
+            timestamp: Date.now(),
+            error: errorMessage
+        };
+    }
+    isValidIPAddress(ip) {
+        const ipv4Pattern = /^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
+        return ipv4Pattern.test(ip);
+    }
+    logReputationCheck(ip, result) {
+        let logLevel = SecurityLogLevel.INFO;
+        if (result.score < this.options.highRiskThreshold) {
+            logLevel = SecurityLogLevel.WARN;
+        }
+        SecurityLogger.getInstance().logEvent({
+            level: logLevel,
+            type: SecurityEventType.IP_REPUTATION,
+            message: `IP reputation check ${result.isSpam ? 'flagged spam' : 'completed'} for ${ip}`,
+            ipAddress: ip,
+            details: {
+                score: result.score,
+                isSpam: result.isSpam,
+                isProxy: result.isProxy,
+                isTor: result.isTor,
+                isVPN: result.isVPN,
+                country: result.country,
+                blacklists: result.blacklists
+            },
+            success: !result.isSpam
+        });
+    }
+    async saveCache() {
+        try {
+            const entries = Array.from(this.reputationCache.entries()).map(([ip, data]) => ({
+                ip,
+                data
+            }));
+            if (entries.length === 0) {
+                return;
+            }
+            const cacheData = JSON.stringify(entries);
+            if (this.storageManager) {
+                await this.storageManager.set('/security/ip-reputation-cache.json', cacheData);
+                logger.log('info', `Saved ${entries.length} IP reputation cache entries to StorageManager`);
+            }
+            else {
+                const cacheDir = plugins.path.join(paths.dataDir, 'security');
+                await plugins.smartfs.directory(cacheDir).recursive().create();
+                const cacheFile = plugins.path.join(cacheDir, 'ip_reputation_cache.json');
+                await plugins.smartfs.file(cacheFile).write(cacheData);
+                logger.log('info', `Saved ${entries.length} IP reputation cache entries to disk`);
+            }
+        }
+        catch (error) {
+            logger.log('error', `Failed to save IP reputation cache: ${error.message}`);
+        }
+    }
+    async loadCache() {
+        try {
+            let cacheData = null;
+            let fromFilesystem = false;
+            if (this.storageManager) {
+                try {
+                    cacheData = await this.storageManager.get('/security/ip-reputation-cache.json');
+                    if (!cacheData) {
+                        const cacheFile = plugins.path.join(paths.dataDir, 'security', 'ip_reputation_cache.json');
+                        if (plugins.fs.existsSync(cacheFile)) {
+                            logger.log('info', 'Migrating IP reputation cache from filesystem to StorageManager');
+                            cacheData = plugins.fs.readFileSync(cacheFile, 'utf8');
+                            fromFilesystem = true;
+                            await this.storageManager.set('/security/ip-reputation-cache.json', cacheData);
+                            logger.log('info', 'IP reputation cache migrated to StorageManager successfully');
+                            try {
+                                plugins.fs.unlinkSync(cacheFile);
+                                logger.log('info', 'Old cache file removed after migration');
+                            }
+                            catch (deleteError) {
+                                logger.log('warn', `Could not delete old cache file: ${deleteError.message}`);
+                            }
+                        }
+                    }
+                }
+                catch (error) {
+                    logger.log('error', `Error loading from StorageManager: ${error.message}`);
+                }
+            }
+            else {
+                const cacheFile = plugins.path.join(paths.dataDir, 'security', 'ip_reputation_cache.json');
+                if (plugins.fs.existsSync(cacheFile)) {
+                    cacheData = plugins.fs.readFileSync(cacheFile, 'utf8');
+                    fromFilesystem = true;
+                }
+            }
+            if (cacheData) {
+                const entries = JSON.parse(cacheData);
+                const now = Date.now();
+                const validEntries = entries.filter(entry => {
+                    const age = now - entry.data.timestamp;
+                    return age < this.options.cacheTTL;
+                });
+                for (const entry of validEntries) {
+                    this.reputationCache.set(entry.ip, entry.data);
+                }
+                const source = fromFilesystem ? 'disk' : 'StorageManager';
+                logger.log('info', `Loaded ${validEntries.length} IP reputation cache entries from ${source}`);
+            }
+        }
+        catch (error) {
+            logger.log('error', `Failed to load IP reputation cache: ${error.message}`);
+        }
+    }
+    static getRiskLevel(score) {
+        if (score < ReputationThreshold.HIGH_RISK) {
+            return 'high';
+        }
+        else if (score < ReputationThreshold.MEDIUM_RISK) {
+            return 'medium';
+        }
+        else if (score < ReputationThreshold.LOW_RISK) {
+            return 'low';
+        }
+        else {
+            return 'trusted';
+        }
+    }
+    updateStorageManager(storageManager) {
+        this.storageManager = storageManager;
+        logger.log('info', 'IPReputationChecker storage manager updated');
+        if (this.options.enableLocalCache && this.reputationCache.size > 0) {
+            this.saveCache().catch(error => {
+                logger.log('error', `Failed to save cache to new storage manager: ${error.message}`);
+            });
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.ipreputationchecker.js","sourceRoot":"","sources":["../../ts/security/classes.ipreputationchecker.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,398 @@
+import { EventEmitter } from 'events';
+interface IDkimVerificationResult {
+    is_valid: boolean;
+    domain: string | null;
+    selector: string | null;
+    status: string;
+    details: string | null;
+}
+interface ISpfResult {
+    result: string;
+    domain: string;
+    ip: string;
+    explanation: string | null;
+}
+interface IDmarcResult {
+    passed: boolean;
+    policy: string;
+    domain: string;
+    dkim_result: string;
+    spf_result: string;
+    action: string;
+    details: string | null;
+}
+interface IEmailSecurityResult {
+    dkim: IDkimVerificationResult[];
+    spf: ISpfResult | null;
+    dmarc: IDmarcResult | null;
+}
+interface IValidationResult {
+    valid: boolean;
+    formatValid: boolean;
+    score: number;
+    error: string | null;
+}
+interface IBounceDetection {
+    bounce_type: string;
+    category: string;
+}
+interface IReputationResult {
+    ip: string;
+    score: number;
+    risk_level: string;
+    ip_type: string;
+    dnsbl_results: Array<{
+        server: string;
+        listed: boolean;
+        response: string | null;
+    }>;
+    listed_count: number;
+    total_checked: number;
+}
+interface IContentScanResult {
+    threatScore: number;
+    threatType: string | null;
+    threatDetails: string | null;
+    scannedElements: string[];
+}
+interface IOutboundEmail {
+    from: string;
+    to: string[];
+    cc?: string[];
+    bcc?: string[];
+    subject?: string;
+    text?: string;
+    html?: string;
+    headers?: Record<string, string>;
+}
+interface ISmtpSendResult {
+    accepted: string[];
+    rejected: string[];
+    messageId?: string;
+    response: string;
+    envelope: {
+        from: string;
+        to: string[];
+    };
+}
+interface ISmtpSendOptions {
+    host: string;
+    port: number;
+    secure?: boolean;
+    domain?: string;
+    auth?: {
+        user: string;
+        pass: string;
+        method?: string;
+    };
+    email: IOutboundEmail;
+    dkim?: {
+        domain: string;
+        selector: string;
+        privateKey: string;
+        keyType?: string;
+    };
+    connectionTimeoutSecs?: number;
+    socketTimeoutSecs?: number;
+    poolKey?: string;
+    maxPoolConnections?: number;
+    tlsOpportunistic?: boolean;
+}
+interface ISmtpSendRawOptions {
+    host: string;
+    port: number;
+    secure?: boolean;
+    domain?: string;
+    auth?: {
+        user: string;
+        pass: string;
+        method?: string;
+    };
+    envelopeFrom: string;
+    envelopeTo: string[];
+    rawMessageBase64: string;
+    poolKey?: string;
+}
+interface ISmtpVerifyOptions {
+    host: string;
+    port: number;
+    secure?: boolean;
+    domain?: string;
+    auth?: {
+        user: string;
+        pass: string;
+        method?: string;
+    };
+}
+interface ISmtpVerifyResult {
+    reachable: boolean;
+    greeting?: string;
+    capabilities?: string[];
+}
+interface ISmtpPoolStatus {
+    pools: Record<string, {
+        total: number;
+        active: number;
+        idle: number;
+    }>;
+}
+interface IVersionInfo {
+    bin: string;
+    core: string;
+    security: string;
+    smtp: string;
+}
+interface ISmtpServerConfig {
+    hostname: string;
+    ports: number[];
+    securePort?: number;
+    tlsCertPem?: string;
+    tlsKeyPem?: string;
+    additionalTlsCerts?: Array<{
+        domains: string[];
+        certPem: string;
+        keyPem: string;
+    }>;
+    maxMessageSize?: number;
+    maxConnections?: number;
+    maxRecipients?: number;
+    connectionTimeoutSecs?: number;
+    dataTimeoutSecs?: number;
+    authEnabled?: boolean;
+    maxAuthFailures?: number;
+    socketTimeoutSecs?: number;
+    processingTimeoutSecs?: number;
+    rateLimits?: IRateLimitConfig;
+}
+interface IRateLimitConfig {
+    maxConnectionsPerIp?: number;
+    maxMessagesPerSender?: number;
+    maxAuthFailuresPerIp?: number;
+    windowSecs?: number;
+}
+interface IEmailData {
+    type: 'inline' | 'file';
+    base64?: string;
+    path?: string;
+}
+interface IEmailReceivedEvent {
+    correlationId: string;
+    sessionId: string;
+    mailFrom: string;
+    rcptTo: string[];
+    data: IEmailData;
+    remoteAddr: string;
+    clientHostname: string | null;
+    secure: boolean;
+    authenticatedUser: string | null;
+    securityResults: any | null;
+}
+interface IAuthRequestEvent {
+    correlationId: string;
+    sessionId: string;
+    username: string;
+    password: string;
+    remoteAddr: string;
+}
+interface IScramCredentialRequestEvent {
+    correlationId: string;
+    sessionId: string;
+    username: string;
+    remoteAddr: string;
+}
+export declare enum BridgeState {
+    Idle = "idle",
+    Starting = "starting",
+    Running = "running",
+    Restarting = "restarting",
+    Failed = "failed",
+    Stopped = "stopped"
+}
+export interface IBridgeResilienceConfig {
+    maxRestartAttempts: number;
+    healthCheckIntervalMs: number;
+    restartBackoffBaseMs: number;
+    restartBackoffMaxMs: number;
+    healthCheckTimeoutMs: number;
+}
+/**
+ * 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 declare class RustSecurityBridge extends EventEmitter {
+    private static instance;
+    private static _resilienceConfig;
+    private bridge;
+    private _running;
+    private _state;
+    private _restartAttempts;
+    private _restartTimer;
+    private _healthCheckTimer;
+    private _deliberateStop;
+    private _smtpServerConfig;
+    private constructor();
+    /** Get or create the singleton instance. */
+    static getInstance(): RustSecurityBridge;
+    /** Reset the singleton instance (for testing). */
+    static resetInstance(): void;
+    /** Configure resilience parameters. Can be called before or after getInstance(). */
+    static configure(config: Partial<IBridgeResilienceConfig>): void;
+    /** Current bridge state. */
+    get state(): BridgeState;
+    /** Whether the Rust process is currently running and accepting commands. */
+    get running(): boolean;
+    private setState;
+    /**
+     * Throws a descriptive error if the bridge is not in Running state.
+     * Called at the top of every command method.
+     */
+    private ensureRunning;
+    /**
+     * Spawn the Rust binary and wait for the ready signal.
+     * @returns `true` if the binary started successfully, `false` otherwise.
+     */
+    start(): Promise<boolean>;
+    /** Kill the Rust process deliberately. */
+    stop(): Promise<void>;
+    private attemptRestart;
+    /**
+     * Restore state after a successful restart:
+     * - Re-send startSmtpServer command if the SMTP server was running
+     */
+    private restoreAfterRestart;
+    private startHealthCheck;
+    private stopHealthCheck;
+    /** Ping the Rust process. */
+    ping(): Promise<boolean>;
+    /** Get version information for all Rust crates. */
+    getVersion(): Promise<IVersionInfo>;
+    /** Validate an email address. */
+    validateEmail(email: string): Promise<IValidationResult>;
+    /** Detect bounce type from SMTP response / diagnostic code. */
+    detectBounce(opts: {
+        smtpResponse?: string;
+        diagnosticCode?: string;
+        statusCode?: string;
+    }): Promise<IBounceDetection>;
+    /** Scan email content for threats (phishing, spam, malware, etc.). */
+    scanContent(opts: {
+        subject?: string;
+        textBody?: string;
+        htmlBody?: string;
+        attachmentNames?: string[];
+    }): Promise<IContentScanResult>;
+    /** Check IP reputation via DNSBL. */
+    checkIpReputation(ip: string): Promise<IReputationResult>;
+    /** Verify DKIM signatures on a raw email message. */
+    verifyDkim(rawMessage: string): Promise<IDkimVerificationResult[]>;
+    /** Sign an email with DKIM (RSA or Ed25519). */
+    signDkim(opts: {
+        rawMessage: string;
+        domain: string;
+        selector?: string;
+        privateKey: string;
+        keyType?: string;
+    }): Promise<{
+        header: string;
+        signedMessage: string;
+    }>;
+    /** Check SPF for a sender. */
+    checkSpf(opts: {
+        ip: string;
+        heloDomain: string;
+        hostname?: string;
+        mailFrom: string;
+    }): Promise<ISpfResult>;
+    /**
+     * 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.
+     */
+    verifyEmail(opts: {
+        rawMessage: string;
+        ip: string;
+        heloDomain: string;
+        hostname?: string;
+        mailFrom: string;
+    }): Promise<IEmailSecurityResult>;
+    /** Send a structured email via the Rust SMTP client. */
+    sendOutboundEmail(opts: ISmtpSendOptions): Promise<ISmtpSendResult>;
+    /** Send a pre-formatted raw email via the Rust SMTP client. */
+    sendRawEmail(opts: ISmtpSendRawOptions): Promise<ISmtpSendResult>;
+    /** Verify connectivity to an SMTP server. */
+    verifySmtpConnection(opts: ISmtpVerifyOptions): Promise<ISmtpVerifyResult>;
+    /** Close a specific connection pool (or all pools if no key is given). */
+    closeSmtpPool(poolKey?: string): Promise<void>;
+    /** Get status of all SMTP client connection pools. */
+    getSmtpPoolStatus(): Promise<ISmtpPoolStatus>;
+    /**
+     * 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.
+     */
+    startSmtpServer(config: ISmtpServerConfig): Promise<boolean>;
+    /** Stop the Rust SMTP server. */
+    stopSmtpServer(): Promise<void>;
+    /**
+     * 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.
+     */
+    sendEmailProcessingResult(opts: {
+        correlationId: string;
+        accepted: boolean;
+        smtpCode?: number;
+        smtpMessage?: string;
+    }): Promise<void>;
+    /**
+     * Send the result of authentication validation back to the Rust SMTP server.
+     */
+    sendAuthResult(opts: {
+        correlationId: string;
+        success: boolean;
+        message?: string;
+    }): Promise<void>;
+    /**
+     * Send SCRAM credentials back to the Rust SMTP server.
+     * Values (salt, storedKey, serverKey) must be base64-encoded.
+     */
+    sendScramCredentialResult(opts: {
+        correlationId: string;
+        found: boolean;
+        salt?: string;
+        iterations?: number;
+        storedKey?: string;
+        serverKey?: string;
+    }): Promise<void>;
+    /** Update rate limit configuration at runtime. */
+    configureRateLimits(config: IRateLimitConfig): Promise<void>;
+    /**
+     * 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: (data: IEmailReceivedEvent) => void): void;
+    /**
+     * Register a handler for authRequest events from the Rust SMTP server.
+     * The handler must call sendAuthResult() with the correlationId.
+     */
+    onAuthRequest(handler: (data: IAuthRequestEvent) => void): void;
+    /**
+     * Register a handler for scramCredentialRequest events from the Rust SMTP server.
+     * The handler must call sendScramCredentialResult() with the correlationId.
+     */
+    onScramCredentialRequest(handler: (data: IScramCredentialRequestEvent) => void): void;
+    /** Remove an emailReceived event handler. */
+    offEmailReceived(handler: (data: IEmailReceivedEvent) => void): void;
+    /** Remove an authRequest event handler. */
+    offAuthRequest(handler: (data: IAuthRequestEvent) => void): void;
+    /** Remove a scramCredentialRequest event handler. */
+    offScramCredentialRequest(handler: (data: IScramCredentialRequestEvent) => void): void;
+}
+export type { IDkimVerificationResult, ISpfResult, IDmarcResult, IEmailSecurityResult, IValidationResult, IBounceDetection, IContentScanResult, IReputationResult as IRustReputationResult, IVersionInfo, ISmtpServerConfig, IRateLimitConfig, IEmailData, IEmailReceivedEvent, IAuthRequestEvent, IScramCredentialRequestEvent, IOutboundEmail, ISmtpSendResult, ISmtpSendOptions, ISmtpSendRawOptions, ISmtpVerifyOptions, ISmtpVerifyResult, ISmtpPoolStatus, };