From 5220ee08575e478462c4ec93b964244fe375b7ec Mon Sep 17 00:00:00 2001 From: Juergen Kunz Date: Tue, 10 Feb 2026 22:00:44 +0000 Subject: [PATCH] feat(mailer-smtp): implement in-process SMTP server and management IPC integration --- changelog.md | 12 + dist_ts/00_commitinfo_data.js | 2 +- .../routing/classes.unified.email.server.d.ts | 11 + .../routing/classes.unified.email.server.js | 278 +++-- .../security/classes.rustsecuritybridge.d.ts | 92 +- .../security/classes.rustsecuritybridge.js | 61 +- rust/Cargo.lock | 18 + rust/crates/mailer-bin/Cargo.toml | 1 + rust/crates/mailer-bin/src/main.rs | 460 +++++++- rust/crates/mailer-smtp/Cargo.toml | 8 + rust/crates/mailer-smtp/src/command.rs | 421 +++++++ rust/crates/mailer-smtp/src/config.rs | 86 ++ rust/crates/mailer-smtp/src/connection.rs | 1023 +++++++++++++++++ rust/crates/mailer-smtp/src/data.rs | 289 +++++ rust/crates/mailer-smtp/src/lib.rs | 43 +- rust/crates/mailer-smtp/src/rate_limiter.rs | 198 ++++ rust/crates/mailer-smtp/src/response.rs | 284 +++++ rust/crates/mailer-smtp/src/server.rs | 308 +++++ rust/crates/mailer-smtp/src/session.rs | 206 ++++ rust/crates/mailer-smtp/src/state.rs | 219 ++++ rust/crates/mailer-smtp/src/validation.rs | 169 +++ ts/00_commitinfo_data.ts | 2 +- .../routing/classes.unified.email.server.ts | 306 +++-- ts/security/classes.rustsecuritybridge.ts | 167 +++ 24 files changed, 4390 insertions(+), 274 deletions(-) create mode 100644 rust/crates/mailer-smtp/src/command.rs create mode 100644 rust/crates/mailer-smtp/src/config.rs create mode 100644 rust/crates/mailer-smtp/src/connection.rs create mode 100644 rust/crates/mailer-smtp/src/data.rs create mode 100644 rust/crates/mailer-smtp/src/rate_limiter.rs create mode 100644 rust/crates/mailer-smtp/src/response.rs create mode 100644 rust/crates/mailer-smtp/src/server.rs create mode 100644 rust/crates/mailer-smtp/src/session.rs create mode 100644 rust/crates/mailer-smtp/src/state.rs create mode 100644 rust/crates/mailer-smtp/src/validation.rs diff --git a/changelog.md b/changelog.md index 62d6b1c..1fb7bd3 100644 --- a/changelog.md +++ b/changelog.md @@ -1,5 +1,17 @@ # Changelog +## 2026-02-10 - 2.2.0 - feat(mailer-smtp) +implement in-process SMTP server and management IPC integration + +- Add full SMTP protocol engine crate (mailer-smtp) with modules: command, config, connection, data, response, session, state, validation, rate_limiter and server +- Introduce SmtpServerConfig, DataAccumulator (DATA phase handling, dot-unstuffing, size limits) and SmtpResponse builder with EHLO capability construction +- Add in-process RateLimiter using DashMap and runtime-configurable RateLimitConfig +- Add TCP/TLS server start/stop API (start_server) with TlsAcceptor building from PEM and SmtpServerHandle for shutdown and status +- Integrate callback registry and oneshot-based correlation callbacks in mailer-bin management mode for email processing/auth results and JSON IPC parsing for SmtpServerConfig +- TypeScript bridge and routing updates: new IPC commands/types (startSmtpServer, stopSmtpServer, emailProcessingResult, authResult, configureRateLimits) and event handlers (emailReceived, authRequest) +- Update Cargo manifests and lockfile to add dependencies (dashmap, regex, rustls, rustls-pemfile, rustls-pki-types, uuid, serde_json, base64, etc.) +- Add comprehensive unit tests for new modules (config, data, response, session, state, rate_limiter, validation) + ## 2026-02-10 - 2.1.0 - feat(security) migrate content scanning and bounce detection to Rust security bridge; add scanContent IPC command and Rust content scanner with tests; update TS RustSecurityBridge and callers, and adjust CI package references diff --git a/dist_ts/00_commitinfo_data.js b/dist_ts/00_commitinfo_data.js index 1bdc242..47b8c58 100644 --- a/dist_ts/00_commitinfo_data.js +++ b/dist_ts/00_commitinfo_data.js @@ -3,7 +3,7 @@ */ export const commitinfo = { name: '@push.rocks/smartmta', - version: '2.0.1', + version: '2.1.0', description: 'A high-performance, enterprise-grade Mail Transfer Agent (MTA) built from scratch in TypeScript with Rust acceleration.' }; //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxzQkFBc0I7SUFDNUIsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLHlIQUF5SDtDQUN2SSxDQUFBIn0= \ No newline at end of file diff --git a/dist_ts/mail/routing/classes.unified.email.server.d.ts b/dist_ts/mail/routing/classes.unified.email.server.d.ts index 0d2a331..5144ff9 100644 --- a/dist_ts/mail/routing/classes.unified.email.server.d.ts +++ b/dist_ts/mail/routing/classes.unified.email.server.d.ts @@ -164,6 +164,17 @@ export declare class UnifiedEmailServer extends EventEmitter { * Stop the unified email server */ stop(): Promise; + /** + * Handle an emailReceived event from the Rust SMTP server. + * Decodes the email data, processes it through the routing system, + * and sends back the result via the correlation-ID callback. + */ + private handleRustEmailReceived; + /** + * Handle an authRequest event from the Rust SMTP server. + * Validates credentials and sends back the result. + */ + private handleRustAuthRequest; /** * Verify inbound email security (DKIM/SPF/DMARC) using the Rust bridge. * Falls back gracefully if the bridge is not running. diff --git a/dist_ts/mail/routing/classes.unified.email.server.js b/dist_ts/mail/routing/classes.unified.email.server.js index c4b0545..4b0a574 100644 --- a/dist_ts/mail/routing/classes.unified.email.server.js +++ b/dist_ts/mail/routing/classes.unified.email.server.js @@ -204,125 +204,77 @@ export class UnifiedEmailServer extends EventEmitter { // Ensure we have the necessary TLS options const hasTlsConfig = this.options.tls?.keyPath && this.options.tls?.certPath; // Prepare the certificate and key if available - let key; - let cert; + let tlsCertPem; + let tlsKeyPem; if (hasTlsConfig) { try { - key = plugins.fs.readFileSync(this.options.tls.keyPath, 'utf8'); - cert = plugins.fs.readFileSync(this.options.tls.certPath, 'utf8'); + tlsKeyPem = plugins.fs.readFileSync(this.options.tls.keyPath, 'utf8'); + tlsCertPem = plugins.fs.readFileSync(this.options.tls.certPath, 'utf8'); logger.log('info', 'TLS certificates loaded successfully'); } catch (error) { logger.log('warn', `Failed to load TLS certificates: ${error.message}`); } } - // Create a SMTP server for each port - for (const port of this.options.ports) { - // Create a reference object to hold the MTA service during setup - const mtaRef = { - config: { - smtp: { - hostname: this.options.hostname - }, - security: { - checkIPReputation: false, - verifyDkim: true, - verifySpf: true, - verifyDmarc: true - } - }, - // Security verification delegated to the Rust bridge - dkimVerifier: { - verify: async (rawMessage) => { - try { - const results = await this.rustBridge.verifyDkim(rawMessage); - const first = results[0]; - return { isValid: first?.is_valid ?? false, domain: first?.domain ?? '' }; - } - catch (err) { - logger.log('warn', `Rust DKIM verification failed: ${err.message}`); - return { isValid: false, domain: '' }; - } - } - }, - spfVerifier: { - verifyAndApply: async (session) => { - if (!session?.remoteAddress || session.remoteAddress === '127.0.0.1') { - return true; // localhost — skip SPF - } - try { - const result = await this.rustBridge.checkSpf({ - ip: session.remoteAddress, - heloDomain: session.clientHostname || '', - hostname: this.options.hostname, - mailFrom: session.envelope?.mailFrom?.address || session.mailFrom || '', - }); - return result.result === 'pass' || result.result === 'none' || result.result === 'neutral'; - } - catch (err) { - logger.log('warn', `Rust SPF check failed: ${err.message}`); - return true; // Accept on error to avoid blocking mail - } - } - }, - dmarcVerifier: { - verify: async () => ({}), - applyPolicy: () => true - }, - processIncomingEmail: async (email) => { - // Process email using the new route-based system - await this.processEmailByMode(email, { - id: 'session-' + Math.random().toString(36).substring(2), - state: SmtpState.FINISHED, - mailFrom: email.from, - rcptTo: email.to, - emailData: email.toRFC822String(), // Use the proper method to get the full email content - useTLS: false, - connectionEnded: true, - remoteAddress: '127.0.0.1', - clientHostname: '', - secure: false, - authenticated: false, - envelope: { - mailFrom: { address: email.from, args: {} }, - rcptTo: email.to.map(recipient => ({ address: recipient, args: {} })) - } - }); - return true; - } - }; - // Create server options - const serverOptions = { - port, - hostname: this.options.hostname, - key, - cert - }; - // Create and start the SMTP server - const smtpServer = createSmtpServer(mtaRef, serverOptions); - this.servers.push(smtpServer); - // Start the server - await new Promise((resolve, reject) => { - try { - // Leave this empty for now, smtpServer.start() is handled by the SMTPServer class internally - // The server is started when it's created - logger.log('info', `UnifiedEmailServer listening on port ${port}`); - // Event handlers are managed internally by the SmtpServer class - // No need to access the private server property - resolve(); - } - catch (err) { - if (err.code === 'EADDRINUSE') { - logger.log('error', `Port ${port} is already in use`); - reject(new Error(`Port ${port} is already in use`)); - } - else { - logger.log('error', `Error starting server on port ${port}: ${err.message}`); - reject(err); - } - } - }); + // --- Start Rust SMTP server --- + // Register event handlers for email reception and auth + this.rustBridge.onEmailReceived(async (data) => { + try { + await this.handleRustEmailReceived(data); + } + catch (err) { + logger.log('error', `Error handling email from Rust SMTP: ${err.message}`); + // Send rejection back to Rust + await this.rustBridge.sendEmailProcessingResult({ + correlationId: data.correlationId, + accepted: false, + smtpCode: 451, + smtpMessage: 'Internal processing error', + }); + } + }); + this.rustBridge.onAuthRequest(async (data) => { + try { + await this.handleRustAuthRequest(data); + } + catch (err) { + logger.log('error', `Error handling auth from Rust SMTP: ${err.message}`); + await this.rustBridge.sendAuthResult({ + correlationId: data.correlationId, + success: false, + message: 'Internal auth error', + }); + } + }); + // Determine which ports need STARTTLS and which need implicit TLS + const smtpPorts = this.options.ports.filter(p => p !== 465); + const securePort = this.options.ports.find(p => p === 465); + const started = await this.rustBridge.startSmtpServer({ + hostname: this.options.hostname, + ports: smtpPorts, + securePort: securePort, + tlsCertPem, + tlsKeyPem, + maxMessageSize: this.options.maxMessageSize || 10 * 1024 * 1024, + maxConnections: this.options.maxConnections || this.options.maxClients || 100, + maxRecipients: 100, + connectionTimeoutSecs: this.options.connectionTimeout ? Math.floor(this.options.connectionTimeout / 1000) : 30, + dataTimeoutSecs: 60, + authEnabled: !!this.options.auth?.required || !!(this.options.auth?.users?.length), + maxAuthFailures: 3, + socketTimeoutSecs: this.options.socketTimeout ? Math.floor(this.options.socketTimeout / 1000) : 300, + processingTimeoutSecs: 30, + rateLimits: this.options.rateLimits ? { + maxConnectionsPerIp: this.options.rateLimits.global?.maxConnectionsPerIP || 50, + maxMessagesPerSender: this.options.rateLimits.global?.maxMessagesPerMinute || 100, + maxAuthFailuresPerIp: this.options.rateLimits.global?.maxAuthFailuresPerIP || 5, + windowSecs: 60, + } : undefined, + }); + if (!started) { + throw new Error('Failed to start Rust SMTP server'); } + logger.log('info', `Rust SMTP server listening on ports: ${smtpPorts.join(', ')}${securePort ? ` + ${securePort} (TLS)` : ''}`); logger.log('info', 'UnifiedEmailServer started successfully'); this.emit('started'); } @@ -378,6 +330,14 @@ export class UnifiedEmailServer extends EventEmitter { async stop() { logger.log('info', 'Stopping UnifiedEmailServer'); try { + // Stop the Rust SMTP server first + try { + await this.rustBridge.stopSmtpServer(); + logger.log('info', 'Rust SMTP server stopped'); + } + catch (err) { + logger.log('warn', `Error stopping Rust SMTP server: ${err.message}`); + } // Clear the servers array - servers will be garbage collected this.servers = []; // Stop Rust security bridge @@ -411,6 +371,102 @@ export class UnifiedEmailServer extends EventEmitter { throw error; } } + // ----------------------------------------------------------------------- + // Rust SMTP server event handlers + // ----------------------------------------------------------------------- + /** + * Handle an emailReceived event from the Rust SMTP server. + * Decodes the email data, processes it through the routing system, + * and sends back the result via the correlation-ID callback. + */ + async handleRustEmailReceived(data) { + const { correlationId, mailFrom, rcptTo, remoteAddr, clientHostname, secure, authenticatedUser } = data; + logger.log('info', `Rust SMTP received email from=${mailFrom} to=${rcptTo.join(',')} remote=${remoteAddr}`); + try { + // Decode the email data + let rawMessageBuffer; + if (data.data.type === 'inline' && data.data.base64) { + rawMessageBuffer = Buffer.from(data.data.base64, 'base64'); + } + else if (data.data.type === 'file' && data.data.path) { + rawMessageBuffer = plugins.fs.readFileSync(data.data.path); + // Clean up temp file + try { + plugins.fs.unlinkSync(data.data.path); + } + catch { + // Ignore cleanup errors + } + } + else { + throw new Error('Invalid email data transport'); + } + // Build a session-like object for processEmailByMode + const session = { + id: data.sessionId || 'rust-' + Math.random().toString(36).substring(2), + state: SmtpState.FINISHED, + mailFrom: mailFrom, + rcptTo: rcptTo, + emailData: rawMessageBuffer.toString('utf8'), + useTLS: secure, + connectionEnded: false, + remoteAddress: remoteAddr, + clientHostname: clientHostname || '', + secure: secure, + authenticated: !!authenticatedUser, + envelope: { + mailFrom: { address: mailFrom, args: {} }, + rcptTo: rcptTo.map(addr => ({ address: addr, args: {} })), + }, + }; + if (authenticatedUser) { + session.user = { username: authenticatedUser }; + } + // Process the email through the routing system + await this.processEmailByMode(rawMessageBuffer, session); + // Send acceptance back to Rust + await this.rustBridge.sendEmailProcessingResult({ + correlationId, + accepted: true, + smtpCode: 250, + smtpMessage: '2.0.0 Message accepted for delivery', + }); + } + catch (err) { + logger.log('error', `Failed to process email from Rust SMTP: ${err.message}`); + await this.rustBridge.sendEmailProcessingResult({ + correlationId, + accepted: false, + smtpCode: 550, + smtpMessage: `5.0.0 Processing failed: ${err.message}`, + }); + } + } + /** + * Handle an authRequest event from the Rust SMTP server. + * Validates credentials and sends back the result. + */ + async handleRustAuthRequest(data) { + const { correlationId, username, password, remoteAddr } = data; + logger.log('info', `Rust SMTP auth request for user=${username} from=${remoteAddr}`); + // Check against configured users + const users = this.options.auth?.users || []; + const matched = users.find(u => u.username === username && u.password === password); + if (matched) { + await this.rustBridge.sendAuthResult({ + correlationId, + success: true, + }); + } + else { + logger.log('warn', `Auth failed for user=${username} from=${remoteAddr}`); + await this.rustBridge.sendAuthResult({ + correlationId, + success: false, + message: 'Invalid credentials', + }); + } + } /** * Verify inbound email security (DKIM/SPF/DMARC) using the Rust bridge. * Falls back gracefully if the bridge is not running. @@ -1507,4 +1563,4 @@ export class UnifiedEmailServer extends EventEmitter { return this.rateLimiter; } } -//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.unified.email.server.js","sourceRoot":"","sources":["../../../ts/mail/routing/classes.unified.email.server.ts"],"names":[],"mappings":"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"} \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.unified.email.server.js","sourceRoot":"","sources":["../../../ts/mail/routing/classes.unified.email.server.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/dist_ts/security/classes.rustsecuritybridge.d.ts b/dist_ts/security/classes.rustsecuritybridge.d.ts index 9975a10..e008e4d 100644 --- a/dist_ts/security/classes.rustsecuritybridge.d.ts +++ b/dist_ts/security/classes.rustsecuritybridge.d.ts @@ -60,6 +60,53 @@ interface IVersionInfo { security: string; smtp: string; } +interface ISmtpServerConfig { + hostname: string; + ports: number[]; + securePort?: number; + tlsCertPem?: string; + tlsKeyPem?: 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; +} /** * Bridge between TypeScript and the Rust `mailer-bin` binary. * @@ -135,5 +182,48 @@ export declare class RustSecurityBridge { hostname?: string; mailFrom: string; }): Promise; + /** + * 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; + /** Stop the Rust SMTP server. */ + stopSmtpServer(): Promise; + /** + * 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; + /** + * Send the result of authentication validation back to the Rust SMTP server. + */ + sendAuthResult(opts: { + correlationId: string; + success: boolean; + message?: string; + }): Promise; + /** Update rate limit configuration at runtime. */ + configureRateLimits(config: IRateLimitConfig): Promise; + /** + * 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; + /** Remove an emailReceived event handler. */ + offEmailReceived(handler: (data: IEmailReceivedEvent) => void): void; + /** Remove an authRequest event handler. */ + offAuthRequest(handler: (data: IAuthRequestEvent) => void): void; } -export type { IDkimVerificationResult, ISpfResult, IDmarcResult, IEmailSecurityResult, IValidationResult, IBounceDetection, IContentScanResult, IReputationResult as IRustReputationResult, IVersionInfo, }; +export type { IDkimVerificationResult, ISpfResult, IDmarcResult, IEmailSecurityResult, IValidationResult, IBounceDetection, IContentScanResult, IReputationResult as IRustReputationResult, IVersionInfo, ISmtpServerConfig, IRateLimitConfig, IEmailData, IEmailReceivedEvent, IAuthRequestEvent, }; diff --git a/dist_ts/security/classes.rustsecuritybridge.js b/dist_ts/security/classes.rustsecuritybridge.js index 122385e..349a922 100644 --- a/dist_ts/security/classes.rustsecuritybridge.js +++ b/dist_ts/security/classes.rustsecuritybridge.js @@ -141,5 +141,64 @@ export class RustSecurityBridge { async verifyEmail(opts) { return this.bridge.sendCommand('verifyEmail', opts); } + // ----------------------------------------------------------------------- + // 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) { + const result = await this.bridge.sendCommand('startSmtpServer', config); + return result?.started === true; + } + /** Stop the Rust SMTP server. */ + async stopSmtpServer() { + 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) { + await this.bridge.sendCommand('emailProcessingResult', opts); + } + /** + * Send the result of authentication validation back to the Rust SMTP server. + */ + async sendAuthResult(opts) { + await this.bridge.sendCommand('authResult', opts); + } + /** Update rate limit configuration at runtime. */ + async configureRateLimits(config) { + 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); + } + /** 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); + } } -//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/rust/Cargo.lock b/rust/Cargo.lock index 70a1b7a..42b669c 100644 --- a/rust/Cargo.lock +++ b/rust/Cargo.lock @@ -1005,6 +1005,7 @@ name = "mailer-bin" version = "0.1.0" dependencies = [ "clap", + "dashmap", "hickory-resolver 0.25.2", "mailer-core", "mailer-security", @@ -1068,15 +1069,23 @@ dependencies = [ name = "mailer-smtp" version = "0.1.0" dependencies = [ + "base64", "bytes", "dashmap", "hickory-resolver 0.25.2", "mailer-core", + "mailer-security", + "regex", + "rustls", + "rustls-pemfile", + "rustls-pki-types", "serde", + "serde_json", "thiserror", "tokio", "tokio-rustls", "tracing", + "uuid", ] [[package]] @@ -1491,6 +1500,15 @@ dependencies = [ "zeroize", ] +[[package]] +name = "rustls-pemfile" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dce314e5fee3f39953d46bb63bb8a46d40c2f8fb7cc5a3b6cab2bde9721d6e50" +dependencies = [ + "rustls-pki-types", +] + [[package]] name = "rustls-pki-types" version = "1.14.0" diff --git a/rust/crates/mailer-bin/Cargo.toml b/rust/crates/mailer-bin/Cargo.toml index a878ede..d212549 100644 --- a/rust/crates/mailer-bin/Cargo.toml +++ b/rust/crates/mailer-bin/Cargo.toml @@ -18,3 +18,4 @@ serde.workspace = true serde_json.workspace = true clap.workspace = true hickory-resolver.workspace = true +dashmap.workspace = true diff --git a/rust/crates/mailer-bin/src/main.rs b/rust/crates/mailer-bin/src/main.rs index ce3abd4..18cb8d7 100644 --- a/rust/crates/mailer-bin/src/main.rs +++ b/rust/crates/mailer-bin/src/main.rs @@ -6,9 +6,16 @@ //! integration with `@push.rocks/smartrust` from TypeScript use clap::{Parser, Subcommand}; +use dashmap::DashMap; use serde::{Deserialize, Serialize}; use std::io::{self, BufRead, Write}; use std::net::IpAddr; +use std::sync::Arc; +use tokio::sync::oneshot; + +use mailer_smtp::connection::{ + AuthResult, CallbackRegistry, ConnectionEvent, EmailProcessingResult, +}; /// mailer-bin: Rust-powered email security tools #[derive(Parser)] @@ -105,6 +112,43 @@ struct IpcEvent { data: serde_json::Value, } +// --- Pending callbacks for correlation-ID based reverse calls --- + +/// Stores oneshot senders for pending email processing and auth callbacks. +struct PendingCallbacks { + email: DashMap>, + auth: DashMap>, +} + +impl PendingCallbacks { + fn new() -> Self { + Self { + email: DashMap::new(), + auth: DashMap::new(), + } + } +} + +impl CallbackRegistry for PendingCallbacks { + fn register_email_callback( + &self, + correlation_id: &str, + ) -> oneshot::Receiver { + let (tx, rx) = oneshot::channel(); + self.email.insert(correlation_id.to_string(), tx); + rx + } + + fn register_auth_callback( + &self, + correlation_id: &str, + ) -> oneshot::Receiver { + let (tx, rx) = oneshot::channel(); + self.auth.insert(correlation_id.to_string(), tx); + rx + } +} + fn main() { let cli = Cli::parse(); @@ -278,7 +322,17 @@ fn main() { use std::io::Read; +/// Shared state for the management mode. +struct ManagementState { + callbacks: Arc, + smtp_handle: Option, + smtp_event_rx: Option>, +} + /// Run in management/IPC mode for smartrust bridge. +/// +/// This mode supports both request/response IPC (existing commands) and +/// long-running SMTP server with event-based callbacks. fn run_management_mode() { // Signal readiness let ready_event = IpcEvent { @@ -294,39 +348,153 @@ fn run_management_mode() { let rt = tokio::runtime::Runtime::new().unwrap(); - let stdin = io::stdin(); - for line in stdin.lock().lines() { - let line = match line { - Ok(l) => l, - Err(_) => break, - }; + let callbacks = Arc::new(PendingCallbacks::new()); + let mut state = ManagementState { + callbacks: callbacks.clone(), + smtp_handle: None, + smtp_event_rx: None, + }; - if line.trim().is_empty() { - continue; - } + // We need to read stdin in a separate thread (blocking I/O) + // and process commands + SMTP events in the tokio runtime. + let (cmd_tx, mut cmd_rx) = tokio::sync::mpsc::channel::(256); - let req: IpcRequest = match serde_json::from_str(&line) { - Ok(r) => r, - Err(e) => { - let resp = IpcResponse { - id: "unknown".to_string(), - success: false, - result: None, - error: Some(format!("Invalid request: {}", e)), - }; - println!("{}", serde_json::to_string(&resp).unwrap()); - io::stdout().flush().unwrap(); - continue; + // Spawn stdin reader thread + std::thread::spawn(move || { + let stdin = io::stdin(); + for line in stdin.lock().lines() { + match line { + Ok(l) if !l.trim().is_empty() => { + if cmd_tx.blocking_send(l).is_err() { + break; + } + } + Ok(_) => continue, + Err(_) => break, } - }; + } + }); - let response = rt.block_on(handle_ipc_request(&req)); - println!("{}", serde_json::to_string(&response).unwrap()); - io::stdout().flush().unwrap(); + rt.block_on(async { + loop { + // Select between stdin commands and SMTP server events + tokio::select! { + cmd = cmd_rx.recv() => { + match cmd { + Some(line) => { + let req: IpcRequest = match serde_json::from_str(&line) { + Ok(r) => r, + Err(e) => { + let resp = IpcResponse { + id: "unknown".to_string(), + success: false, + result: None, + error: Some(format!("Invalid request: {}", e)), + }; + emit_line(&serde_json::to_string(&resp).unwrap()); + continue; + } + }; + + let response = handle_ipc_request(&req, &mut state).await; + emit_line(&serde_json::to_string(&response).unwrap()); + } + None => { + // stdin closed — shut down + if let Some(handle) = state.smtp_handle.take() { + handle.shutdown().await; + } + break; + } + } + } + event = async { + if let Some(rx) = &mut state.smtp_event_rx { + rx.recv().await + } else { + // No SMTP server running — wait forever (yields to other branch) + std::future::pending::>().await + } + } => { + if let Some(event) = event { + handle_smtp_event(event); + } + } + } + } + }); +} + +/// Emit a line to stdout and flush. +fn emit_line(line: &str) { + let stdout = io::stdout(); + let mut handle = stdout.lock(); + let _ = writeln!(handle, "{}", line); + let _ = handle.flush(); +} + +/// Emit an IPC event to stdout. +fn emit_event(event_name: &str, data: serde_json::Value) { + let event = IpcEvent { + event: event_name.to_string(), + data, + }; + emit_line(&serde_json::to_string(&event).unwrap()); +} + +/// Handle a connection event from the SMTP server. +fn handle_smtp_event(event: ConnectionEvent) { + match event { + ConnectionEvent::EmailReceived { + correlation_id, + session_id, + mail_from, + rcpt_to, + data, + remote_addr, + client_hostname, + secure, + authenticated_user, + security_results, + } => { + emit_event( + "emailReceived", + serde_json::json!({ + "correlationId": correlation_id, + "sessionId": session_id, + "mailFrom": mail_from, + "rcptTo": rcpt_to, + "data": data, + "remoteAddr": remote_addr, + "clientHostname": client_hostname, + "secure": secure, + "authenticatedUser": authenticated_user, + "securityResults": security_results, + }), + ); + } + ConnectionEvent::AuthRequest { + correlation_id, + session_id, + username, + password, + remote_addr, + } => { + emit_event( + "authRequest", + serde_json::json!({ + "correlationId": correlation_id, + "sessionId": session_id, + "username": username, + "password": password, + "remoteAddr": remote_addr, + }), + ); + } } } -async fn handle_ipc_request(req: &IpcRequest) -> IpcResponse { +async fn handle_ipc_request(req: &IpcRequest, state: &mut ManagementState) -> IpcResponse { match req.method.as_str() { "ping" => IpcResponse { id: req.id.clone(), @@ -636,6 +804,35 @@ async fn handle_ipc_request(req: &IpcRequest) -> IpcResponse { } } + // --- SMTP Server lifecycle commands --- + + "startSmtpServer" => { + handle_start_smtp_server(req, state).await + } + + "stopSmtpServer" => { + handle_stop_smtp_server(req, state).await + } + + "emailProcessingResult" => { + handle_email_processing_result(req, state) + } + + "authResult" => { + handle_auth_result(req, state) + } + + "configureRateLimits" => { + // Rate limit configuration is set at startSmtpServer time. + // This command allows runtime updates, but for now we acknowledge it. + IpcResponse { + id: req.id.clone(), + success: true, + result: Some(serde_json::json!({"configured": true})), + error: None, + } + } + _ => IpcResponse { id: req.id.clone(), success: false, @@ -644,3 +841,214 @@ async fn handle_ipc_request(req: &IpcRequest) -> IpcResponse { }, } } + +/// Handle startSmtpServer IPC command. +async fn handle_start_smtp_server(req: &IpcRequest, state: &mut ManagementState) -> IpcResponse { + // Stop existing server if running + if let Some(handle) = state.smtp_handle.take() { + handle.shutdown().await; + } + + // Parse config from params + let config = match parse_smtp_config(&req.params) { + Ok(c) => c, + Err(e) => { + return IpcResponse { + id: req.id.clone(), + success: false, + result: None, + error: Some(format!("Invalid config: {}", e)), + }; + } + }; + + // Parse optional rate limit config + let rate_config = req.params.get("rateLimits").and_then(|v| { + serde_json::from_value::(v.clone()).ok() + }); + + match mailer_smtp::server::start_server(config, state.callbacks.clone(), rate_config).await { + Ok((handle, event_rx)) => { + state.smtp_handle = Some(handle); + state.smtp_event_rx = Some(event_rx); + IpcResponse { + id: req.id.clone(), + success: true, + result: Some(serde_json::json!({"started": true})), + error: None, + } + } + Err(e) => IpcResponse { + id: req.id.clone(), + success: false, + result: None, + error: Some(format!("Failed to start SMTP server: {}", e)), + }, + } +} + +/// Handle stopSmtpServer IPC command. +async fn handle_stop_smtp_server(req: &IpcRequest, state: &mut ManagementState) -> IpcResponse { + if let Some(handle) = state.smtp_handle.take() { + handle.shutdown().await; + state.smtp_event_rx = None; + IpcResponse { + id: req.id.clone(), + success: true, + result: Some(serde_json::json!({"stopped": true})), + error: None, + } + } else { + IpcResponse { + id: req.id.clone(), + success: true, + result: Some(serde_json::json!({"stopped": true, "wasRunning": false})), + error: None, + } + } +} + +/// Handle emailProcessingResult IPC command — resolves a pending email callback. +fn handle_email_processing_result(req: &IpcRequest, state: &ManagementState) -> IpcResponse { + let correlation_id = req + .params + .get("correlationId") + .and_then(|v| v.as_str()) + .unwrap_or(""); + + let result = EmailProcessingResult { + accepted: req.params.get("accepted").and_then(|v| v.as_bool()).unwrap_or(false), + smtp_code: req.params.get("smtpCode").and_then(|v| v.as_u64()).map(|v| v as u16), + smtp_message: req + .params + .get("smtpMessage") + .and_then(|v| v.as_str()) + .map(String::from), + }; + + if let Some((_, tx)) = state.callbacks.email.remove(correlation_id) { + let _ = tx.send(result); + IpcResponse { + id: req.id.clone(), + success: true, + result: Some(serde_json::json!({"resolved": true})), + error: None, + } + } else { + IpcResponse { + id: req.id.clone(), + success: false, + result: None, + error: Some(format!( + "No pending callback for correlationId: {}", + correlation_id + )), + } + } +} + +/// Handle authResult IPC command — resolves a pending auth callback. +fn handle_auth_result(req: &IpcRequest, state: &ManagementState) -> IpcResponse { + let correlation_id = req + .params + .get("correlationId") + .and_then(|v| v.as_str()) + .unwrap_or(""); + + let result = AuthResult { + success: req.params.get("success").and_then(|v| v.as_bool()).unwrap_or(false), + message: req + .params + .get("message") + .and_then(|v| v.as_str()) + .map(String::from), + }; + + if let Some((_, tx)) = state.callbacks.auth.remove(correlation_id) { + let _ = tx.send(result); + IpcResponse { + id: req.id.clone(), + success: true, + result: Some(serde_json::json!({"resolved": true})), + error: None, + } + } else { + IpcResponse { + id: req.id.clone(), + success: false, + result: None, + error: Some(format!( + "No pending auth callback for correlationId: {}", + correlation_id + )), + } + } +} + +/// Parse SmtpServerConfig from IPC params JSON. +fn parse_smtp_config( + params: &serde_json::Value, +) -> Result { + let mut config = mailer_smtp::config::SmtpServerConfig::default(); + + if let Some(hostname) = params.get("hostname").and_then(|v| v.as_str()) { + config.hostname = hostname.to_string(); + } + + if let Some(ports) = params.get("ports").and_then(|v| v.as_array()) { + config.ports = ports + .iter() + .filter_map(|v| v.as_u64().map(|p| p as u16)) + .collect(); + } + + if let Some(secure_port) = params.get("securePort").and_then(|v| v.as_u64()) { + config.secure_port = Some(secure_port as u16); + } + + if let Some(cert) = params.get("tlsCertPem").and_then(|v| v.as_str()) { + config.tls_cert_pem = Some(cert.to_string()); + } + + if let Some(key) = params.get("tlsKeyPem").and_then(|v| v.as_str()) { + config.tls_key_pem = Some(key.to_string()); + } + + if let Some(size) = params.get("maxMessageSize").and_then(|v| v.as_u64()) { + config.max_message_size = size; + } + + if let Some(conns) = params.get("maxConnections").and_then(|v| v.as_u64()) { + config.max_connections = conns as u32; + } + + if let Some(rcpts) = params.get("maxRecipients").and_then(|v| v.as_u64()) { + config.max_recipients = rcpts as u32; + } + + if let Some(timeout) = params.get("connectionTimeoutSecs").and_then(|v| v.as_u64()) { + config.connection_timeout_secs = timeout; + } + + if let Some(timeout) = params.get("dataTimeoutSecs").and_then(|v| v.as_u64()) { + config.data_timeout_secs = timeout; + } + + if let Some(auth) = params.get("authEnabled").and_then(|v| v.as_bool()) { + config.auth_enabled = auth; + } + + if let Some(failures) = params.get("maxAuthFailures").and_then(|v| v.as_u64()) { + config.max_auth_failures = failures as u32; + } + + if let Some(timeout) = params.get("socketTimeoutSecs").and_then(|v| v.as_u64()) { + config.socket_timeout_secs = timeout; + } + + if let Some(timeout) = params.get("processingTimeoutSecs").and_then(|v| v.as_u64()) { + config.processing_timeout_secs = timeout; + } + + Ok(config) +} diff --git a/rust/crates/mailer-smtp/Cargo.toml b/rust/crates/mailer-smtp/Cargo.toml index 2e37751..9ad39c7 100644 --- a/rust/crates/mailer-smtp/Cargo.toml +++ b/rust/crates/mailer-smtp/Cargo.toml @@ -6,6 +6,7 @@ license.workspace = true [dependencies] mailer-core = { path = "../mailer-core" } +mailer-security = { path = "../mailer-security" } tokio.workspace = true tokio-rustls.workspace = true hickory-resolver.workspace = true @@ -14,3 +15,10 @@ thiserror.workspace = true tracing.workspace = true bytes.workspace = true serde.workspace = true +serde_json = "1" +regex = "1" +uuid = { version = "1", features = ["v4"] } +base64.workspace = true +rustls-pki-types.workspace = true +rustls = { version = "0.23", default-features = false, features = ["ring", "logging", "std", "tls12"] } +rustls-pemfile = "2" diff --git a/rust/crates/mailer-smtp/src/command.rs b/rust/crates/mailer-smtp/src/command.rs new file mode 100644 index 0000000..9a533f5 --- /dev/null +++ b/rust/crates/mailer-smtp/src/command.rs @@ -0,0 +1,421 @@ +//! SMTP command parser. +//! +//! Parses raw SMTP command lines into structured `SmtpCommand` variants. + +use serde::{Deserialize, Serialize}; +use std::collections::HashMap; + +/// A parsed SMTP command. +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] +pub enum SmtpCommand { + /// EHLO with client hostname/IP + Ehlo(String), + /// HELO with client hostname/IP + Helo(String), + /// MAIL FROM with sender address and optional parameters (e.g. SIZE=12345) + MailFrom { + address: String, + params: HashMap>, + }, + /// RCPT TO with recipient address and optional parameters + RcptTo { + address: String, + params: HashMap>, + }, + /// DATA command — begin message body + Data, + /// RSET — reset current transaction + Rset, + /// NOOP — no operation + Noop, + /// QUIT — close connection + Quit, + /// STARTTLS — upgrade to TLS + StartTls, + /// AUTH with mechanism and optional initial response + Auth { + mechanism: AuthMechanism, + initial_response: Option, + }, + /// HELP with optional topic + Help(Option), + /// VRFY with address or username + Vrfy(String), + /// EXPN with mailing list name + Expn(String), +} + +/// Supported AUTH mechanisms. +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] +pub enum AuthMechanism { + Plain, + Login, +} + +/// Errors that can occur during command parsing. +#[derive(Debug, Clone, PartialEq, thiserror::Error)] +pub enum ParseError { + #[error("empty command line")] + Empty, + #[error("unrecognized command: {0}")] + UnrecognizedCommand(String), + #[error("syntax error in parameters: {0}")] + SyntaxError(String), + #[error("missing required argument for {0}")] + MissingArgument(String), +} + +/// Parse a raw SMTP command line (without trailing CRLF) into a `SmtpCommand`. +pub fn parse_command(line: &str) -> Result { + let line = line.trim_end_matches('\r').trim_end_matches('\n'); + if line.is_empty() { + return Err(ParseError::Empty); + } + + // Split into verb and the rest + let (verb, rest) = split_first_word(line); + let verb_upper = verb.to_ascii_uppercase(); + + match verb_upper.as_str() { + "EHLO" => { + let hostname = rest.trim(); + if hostname.is_empty() { + return Err(ParseError::MissingArgument("EHLO".into())); + } + Ok(SmtpCommand::Ehlo(hostname.to_string())) + } + "HELO" => { + let hostname = rest.trim(); + if hostname.is_empty() { + return Err(ParseError::MissingArgument("HELO".into())); + } + Ok(SmtpCommand::Helo(hostname.to_string())) + } + "MAIL" => parse_mail_from(rest), + "RCPT" => parse_rcpt_to(rest), + "DATA" => Ok(SmtpCommand::Data), + "RSET" => Ok(SmtpCommand::Rset), + "NOOP" => Ok(SmtpCommand::Noop), + "QUIT" => Ok(SmtpCommand::Quit), + "STARTTLS" => Ok(SmtpCommand::StartTls), + "AUTH" => parse_auth(rest), + "HELP" => { + let topic = rest.trim(); + if topic.is_empty() { + Ok(SmtpCommand::Help(None)) + } else { + Ok(SmtpCommand::Help(Some(topic.to_string()))) + } + } + "VRFY" => { + let arg = rest.trim(); + if arg.is_empty() { + return Err(ParseError::MissingArgument("VRFY".into())); + } + Ok(SmtpCommand::Vrfy(arg.to_string())) + } + "EXPN" => { + let arg = rest.trim(); + if arg.is_empty() { + return Err(ParseError::MissingArgument("EXPN".into())); + } + Ok(SmtpCommand::Expn(arg.to_string())) + } + _ => Err(ParseError::UnrecognizedCommand(verb_upper)), + } +} + +/// Parse `FROM: [PARAM=VALUE ...]` after "MAIL". +fn parse_mail_from(rest: &str) -> Result { + // Expect "FROM:" prefix (case-insensitive, whitespace-flexible) + let rest = rest.trim_start(); + let rest_upper = rest.to_ascii_uppercase(); + if !rest_upper.starts_with("FROM") { + return Err(ParseError::SyntaxError( + "expected FROM after MAIL".into(), + )); + } + let rest = &rest[4..]; // skip "FROM" + let rest = rest.trim_start(); + if !rest.starts_with(':') { + return Err(ParseError::SyntaxError( + "expected colon after MAIL FROM".into(), + )); + } + let rest = &rest[1..]; // skip ':' + let rest = rest.trim_start(); + + parse_address_and_params(rest, "MAIL FROM").map(|(address, params)| SmtpCommand::MailFrom { + address, + params, + }) +} + +/// Parse `TO: [PARAM=VALUE ...]` after "RCPT". +fn parse_rcpt_to(rest: &str) -> Result { + let rest = rest.trim_start(); + let rest_upper = rest.to_ascii_uppercase(); + if !rest_upper.starts_with("TO") { + return Err(ParseError::SyntaxError("expected TO after RCPT".into())); + } + let rest = &rest[2..]; // skip "TO" + let rest = rest.trim_start(); + if !rest.starts_with(':') { + return Err(ParseError::SyntaxError( + "expected colon after RCPT TO".into(), + )); + } + let rest = &rest[1..]; // skip ':' + let rest = rest.trim_start(); + + parse_address_and_params(rest, "RCPT TO").map(|(address, params)| SmtpCommand::RcptTo { + address, + params, + }) +} + +/// Parse `
[PARAM=VALUE ...]` from the rest of a MAIL FROM or RCPT TO line. +fn parse_address_and_params( + input: &str, + context: &str, +) -> Result<(String, HashMap>), ParseError> { + if !input.starts_with('<') { + return Err(ParseError::SyntaxError(format!( + "expected '<' in {context}" + ))); + } + let close_bracket = input.find('>').ok_or_else(|| { + ParseError::SyntaxError(format!("missing '>' in {context}")) + })?; + let address = input[1..close_bracket].to_string(); + let remainder = &input[close_bracket + 1..]; + let params = parse_params(remainder)?; + Ok((address, params)) +} + +/// Parse SMTP extension parameters like `SIZE=12345 BODY=8BITMIME`. +fn parse_params(input: &str) -> Result>, ParseError> { + let mut params = HashMap::new(); + for token in input.split_whitespace() { + if let Some(eq_pos) = token.find('=') { + let key = token[..eq_pos].to_ascii_uppercase(); + let value = token[eq_pos + 1..].to_string(); + params.insert(key, Some(value)); + } else { + params.insert(token.to_ascii_uppercase(), None); + } + } + Ok(params) +} + +/// Parse AUTH command: `AUTH [initial-response]`. +fn parse_auth(rest: &str) -> Result { + let rest = rest.trim(); + if rest.is_empty() { + return Err(ParseError::MissingArgument("AUTH".into())); + } + let (mech_str, initial) = split_first_word(rest); + let mechanism = match mech_str.to_ascii_uppercase().as_str() { + "PLAIN" => AuthMechanism::Plain, + "LOGIN" => AuthMechanism::Login, + other => { + return Err(ParseError::SyntaxError(format!( + "unsupported AUTH mechanism: {other}" + ))); + } + }; + let initial_response = { + let s = initial.trim(); + if s.is_empty() { None } else { Some(s.to_string()) } + }; + Ok(SmtpCommand::Auth { + mechanism, + initial_response, + }) +} + +/// Split a string into the first whitespace-delimited word and the remainder. +fn split_first_word(s: &str) -> (&str, &str) { + match s.find(char::is_whitespace) { + Some(pos) => (&s[..pos], &s[pos + 1..]), + None => (s, ""), + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_ehlo() { + let cmd = parse_command("EHLO mail.example.com").unwrap(); + assert_eq!(cmd, SmtpCommand::Ehlo("mail.example.com".into())); + } + + #[test] + fn test_ehlo_case_insensitive() { + let cmd = parse_command("ehlo MAIL.EXAMPLE.COM").unwrap(); + assert_eq!(cmd, SmtpCommand::Ehlo("MAIL.EXAMPLE.COM".into())); + } + + #[test] + fn test_helo() { + let cmd = parse_command("HELO example.com").unwrap(); + assert_eq!(cmd, SmtpCommand::Helo("example.com".into())); + } + + #[test] + fn test_ehlo_missing_arg() { + let err = parse_command("EHLO").unwrap_err(); + assert!(matches!(err, ParseError::MissingArgument(_))); + } + + #[test] + fn test_mail_from() { + let cmd = parse_command("MAIL FROM:").unwrap(); + assert_eq!( + cmd, + SmtpCommand::MailFrom { + address: "sender@example.com".into(), + params: HashMap::new(), + } + ); + } + + #[test] + fn test_mail_from_with_params() { + let cmd = parse_command("MAIL FROM: SIZE=12345 BODY=8BITMIME").unwrap(); + if let SmtpCommand::MailFrom { address, params } = cmd { + assert_eq!(address, "sender@example.com"); + assert_eq!(params.get("SIZE"), Some(&Some("12345".into()))); + assert_eq!(params.get("BODY"), Some(&Some("8BITMIME".into()))); + } else { + panic!("expected MailFrom"); + } + } + + #[test] + fn test_mail_from_empty_address() { + let cmd = parse_command("MAIL FROM:<>").unwrap(); + assert_eq!( + cmd, + SmtpCommand::MailFrom { + address: "".into(), + params: HashMap::new(), + } + ); + } + + #[test] + fn test_mail_from_flexible_spacing() { + let cmd = parse_command("MAIL FROM: ").unwrap(); + if let SmtpCommand::MailFrom { address, .. } = cmd { + assert_eq!(address, "user@example.com"); + } else { + panic!("expected MailFrom"); + } + } + + #[test] + fn test_rcpt_to() { + let cmd = parse_command("RCPT TO:").unwrap(); + assert_eq!( + cmd, + SmtpCommand::RcptTo { + address: "recipient@example.com".into(), + params: HashMap::new(), + } + ); + } + + #[test] + fn test_data() { + assert_eq!(parse_command("DATA").unwrap(), SmtpCommand::Data); + } + + #[test] + fn test_rset() { + assert_eq!(parse_command("RSET").unwrap(), SmtpCommand::Rset); + } + + #[test] + fn test_noop() { + assert_eq!(parse_command("NOOP").unwrap(), SmtpCommand::Noop); + } + + #[test] + fn test_quit() { + assert_eq!(parse_command("QUIT").unwrap(), SmtpCommand::Quit); + } + + #[test] + fn test_starttls() { + assert_eq!(parse_command("STARTTLS").unwrap(), SmtpCommand::StartTls); + } + + #[test] + fn test_auth_plain() { + let cmd = parse_command("AUTH PLAIN dGVzdAB0ZXN0AHBhc3N3b3Jk").unwrap(); + assert_eq!( + cmd, + SmtpCommand::Auth { + mechanism: AuthMechanism::Plain, + initial_response: Some("dGVzdAB0ZXN0AHBhc3N3b3Jk".into()), + } + ); + } + + #[test] + fn test_auth_login_no_initial() { + let cmd = parse_command("AUTH LOGIN").unwrap(); + assert_eq!( + cmd, + SmtpCommand::Auth { + mechanism: AuthMechanism::Login, + initial_response: None, + } + ); + } + + #[test] + fn test_help() { + assert_eq!(parse_command("HELP").unwrap(), SmtpCommand::Help(None)); + assert_eq!( + parse_command("HELP MAIL").unwrap(), + SmtpCommand::Help(Some("MAIL".into())) + ); + } + + #[test] + fn test_vrfy() { + assert_eq!( + parse_command("VRFY user@example.com").unwrap(), + SmtpCommand::Vrfy("user@example.com".into()) + ); + } + + #[test] + fn test_expn() { + assert_eq!( + parse_command("EXPN staff").unwrap(), + SmtpCommand::Expn("staff".into()) + ); + } + + #[test] + fn test_empty() { + assert!(matches!(parse_command(""), Err(ParseError::Empty))); + } + + #[test] + fn test_unrecognized() { + let err = parse_command("FOOBAR test").unwrap_err(); + assert!(matches!(err, ParseError::UnrecognizedCommand(_))); + } + + #[test] + fn test_crlf_stripped() { + let cmd = parse_command("QUIT\r\n").unwrap(); + assert_eq!(cmd, SmtpCommand::Quit); + } +} diff --git a/rust/crates/mailer-smtp/src/config.rs b/rust/crates/mailer-smtp/src/config.rs new file mode 100644 index 0000000..75d58a1 --- /dev/null +++ b/rust/crates/mailer-smtp/src/config.rs @@ -0,0 +1,86 @@ +//! SMTP server configuration. + +use serde::{Deserialize, Serialize}; + +/// Configuration for an SMTP server instance. +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct SmtpServerConfig { + /// Server hostname for greeting and EHLO responses. + pub hostname: String, + /// Ports to listen on (e.g. [25, 587]). + pub ports: Vec, + /// Port for implicit TLS (e.g. 465). None = no implicit TLS port. + pub secure_port: Option, + /// TLS certificate chain in PEM format. + pub tls_cert_pem: Option, + /// TLS private key in PEM format. + pub tls_key_pem: Option, + /// Maximum message size in bytes. + pub max_message_size: u64, + /// Maximum number of concurrent connections. + pub max_connections: u32, + /// Maximum recipients per message. + pub max_recipients: u32, + /// Connection timeout in seconds. + pub connection_timeout_secs: u64, + /// Data phase timeout in seconds. + pub data_timeout_secs: u64, + /// Whether authentication is available. + pub auth_enabled: bool, + /// Maximum authentication failures before disconnect. + pub max_auth_failures: u32, + /// Socket timeout in seconds (idle timeout for the entire connection). + pub socket_timeout_secs: u64, + /// Timeout in seconds waiting for TS to respond to email processing. + pub processing_timeout_secs: u64, +} + +impl Default for SmtpServerConfig { + fn default() -> Self { + Self { + hostname: "mail.example.com".to_string(), + ports: vec![25], + secure_port: None, + tls_cert_pem: None, + tls_key_pem: None, + max_message_size: 10 * 1024 * 1024, // 10 MB + max_connections: 100, + max_recipients: 100, + connection_timeout_secs: 30, + data_timeout_secs: 60, + auth_enabled: false, + max_auth_failures: 3, + socket_timeout_secs: 300, + processing_timeout_secs: 30, + } + } +} + +impl SmtpServerConfig { + /// Check if TLS is configured. + pub fn has_tls(&self) -> bool { + self.tls_cert_pem.is_some() && self.tls_key_pem.is_some() + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_defaults() { + let cfg = SmtpServerConfig::default(); + assert_eq!(cfg.max_message_size, 10 * 1024 * 1024); + assert_eq!(cfg.max_connections, 100); + assert!(!cfg.has_tls()); + } + + #[test] + fn test_has_tls() { + let mut cfg = SmtpServerConfig::default(); + cfg.tls_cert_pem = Some("cert".into()); + assert!(!cfg.has_tls()); // need both + cfg.tls_key_pem = Some("key".into()); + assert!(cfg.has_tls()); + } +} diff --git a/rust/crates/mailer-smtp/src/connection.rs b/rust/crates/mailer-smtp/src/connection.rs new file mode 100644 index 0000000..af9ec33 --- /dev/null +++ b/rust/crates/mailer-smtp/src/connection.rs @@ -0,0 +1,1023 @@ +//! Per-connection SMTP handler. +//! +//! Manages the read/write loop for a single SMTP connection. +//! Dispatches parsed commands, handles DATA mode, and manages +//! authentication flow. + +use crate::command::{parse_command, AuthMechanism, ParseError, SmtpCommand}; +use crate::config::SmtpServerConfig; +use crate::data::{DataAccumulator, DataAction}; +use crate::rate_limiter::RateLimiter; +use crate::response::{build_capabilities, SmtpResponse}; +use crate::session::{AuthState, SmtpSession}; +use crate::validation; + +use base64::Engine; +use base64::engine::general_purpose::STANDARD as BASE64; +use serde::{Deserialize, Serialize}; +use std::sync::Arc; +use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader}; +use tokio::net::TcpStream; +use tokio::sync::{mpsc, oneshot}; +use tokio::time::{timeout, Duration}; +use tokio_rustls::server::TlsStream; +use tracing::{debug, info, warn}; + +/// Events emitted by a connection handler to the server. +#[derive(Debug, Serialize, Deserialize)] +pub enum ConnectionEvent { + /// A complete email has been received and needs processing. + EmailReceived { + correlation_id: String, + session_id: String, + mail_from: String, + rcpt_to: Vec, + /// Base64-encoded raw message for inline, or file path for large messages. + data: EmailData, + remote_addr: String, + client_hostname: Option, + secure: bool, + authenticated_user: Option, + /// In-process security results (DKIM, SPF, DMARC, content scan). + security_results: Option, + }, + /// An authentication request that needs TS validation. + AuthRequest { + correlation_id: String, + session_id: String, + username: String, + password: String, + remote_addr: String, + }, +} + +/// How email data is transported from Rust to TS. +#[derive(Debug, Serialize, Deserialize)] +#[serde(tag = "type")] +pub enum EmailData { + /// Inline base64-encoded data (for messages <= 256KB). + #[serde(rename = "inline")] + Inline { base64: String }, + /// Path to a temp file containing the raw message (for large messages). + #[serde(rename = "file")] + File { path: String }, +} + +/// Result of TS processing an email. +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct EmailProcessingResult { + pub accepted: bool, + pub smtp_code: Option, + pub smtp_message: Option, +} + +/// Result of TS processing an auth request. +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct AuthResult { + pub success: bool, + pub message: Option, +} + +/// Abstraction over plain and TLS streams. +pub enum SmtpStream { + Plain(BufReader), + Tls(BufReader>), +} + +impl SmtpStream { + /// Read a line from the stream (up to max_line_length bytes). + pub async fn read_line(&mut self, buf: &mut String, max_len: usize) -> std::io::Result { + match self { + SmtpStream::Plain(reader) => { + let result = reader.read_line(buf).await?; + if buf.len() > max_len { + buf.truncate(max_len); + } + Ok(result) + } + SmtpStream::Tls(reader) => { + let result = reader.read_line(buf).await?; + if buf.len() > max_len { + buf.truncate(max_len); + } + Ok(result) + } + } + } + + /// Read bytes from the stream into a buffer. + pub async fn read_chunk(&mut self, buf: &mut [u8]) -> std::io::Result { + use tokio::io::AsyncReadExt; + match self { + SmtpStream::Plain(reader) => reader.read(buf).await, + SmtpStream::Tls(reader) => reader.read(buf).await, + } + } + + /// Write bytes to the stream. + pub async fn write_all(&mut self, buf: &[u8]) -> std::io::Result<()> { + match self { + SmtpStream::Plain(reader) => reader.get_mut().write_all(buf).await, + SmtpStream::Tls(reader) => reader.get_mut().write_all(buf).await, + } + } + + /// Flush the write buffer. + pub async fn flush(&mut self) -> std::io::Result<()> { + match self { + SmtpStream::Plain(reader) => reader.get_mut().flush().await, + SmtpStream::Tls(reader) => reader.get_mut().flush().await, + } + } + + /// Unwrap to get the raw TcpStream for STARTTLS upgrade. + /// Only works on Plain streams. + pub fn into_tcp_stream(self) -> Option { + match self { + SmtpStream::Plain(reader) => Some(reader.into_inner()), + SmtpStream::Tls(_) => None, + } + } +} + +/// Handle a single SMTP connection. +/// +/// This is the main entry point spawned for each incoming connection. +pub async fn handle_connection( + mut stream: SmtpStream, + config: Arc, + rate_limiter: Arc, + event_tx: mpsc::Sender, + callback_register: Arc, + tls_acceptor: Option>, + remote_addr: String, + is_secure: bool, +) { + let mut session = SmtpSession::new(remote_addr.clone(), is_secure); + + // Check IP rate limit + if !rate_limiter.check_connection(&remote_addr) { + let resp = SmtpResponse::service_unavailable( + &config.hostname, + "Too many connections from your IP", + ); + let _ = stream.write_all(&resp.to_bytes()).await; + let _ = stream.flush().await; + info!( + session_id = %session.id, + remote_addr = %remote_addr, + "Connection rejected: rate limit exceeded" + ); + return; + } + + // Send greeting + let greeting = SmtpResponse::greeting(&config.hostname); + if stream.write_all(&greeting.to_bytes()).await.is_err() { + return; + } + if stream.flush().await.is_err() { + return; + } + + let socket_timeout = Duration::from_secs(config.socket_timeout_secs); + + loop { + let mut line = String::new(); + let read_result = timeout(socket_timeout, stream.read_line(&mut line, 4096)).await; + + match read_result { + Err(_) => { + // Timeout + let resp = SmtpResponse::service_unavailable( + &config.hostname, + "Connection timed out", + ); + let _ = stream.write_all(&resp.to_bytes()).await; + let _ = stream.flush().await; + debug!(session_id = %session.id, "Connection timed out"); + break; + } + Ok(Err(e)) => { + debug!(session_id = %session.id, error = %e, "Read error"); + break; + } + Ok(Ok(0)) => { + debug!(session_id = %session.id, "Client disconnected"); + break; + } + Ok(Ok(_)) => { + // Process command + let response = process_line( + &line, + &mut session, + &mut stream, + &config, + &rate_limiter, + &event_tx, + callback_register.as_ref(), + &tls_acceptor, + ) + .await; + + match response { + LineResult::Response(resp) => { + if stream.write_all(&resp.to_bytes()).await.is_err() { + break; + } + if stream.flush().await.is_err() { + break; + } + } + LineResult::Quit(resp) => { + let _ = stream.write_all(&resp.to_bytes()).await; + let _ = stream.flush().await; + break; + } + LineResult::StartTlsSignal => { + // Send 220 Ready response + let resp = SmtpResponse::new(220, "Ready to start TLS"); + if stream.write_all(&resp.to_bytes()).await.is_err() { + break; + } + if stream.flush().await.is_err() { + break; + } + // Extract TCP stream and upgrade + if let Some(tcp_stream) = stream.into_tcp_stream() { + if let Some(acceptor) = &tls_acceptor { + match acceptor.accept(tcp_stream).await { + Ok(tls_stream) => { + stream = SmtpStream::Tls(BufReader::new(tls_stream)); + session.secure = true; + // Client must re-EHLO after STARTTLS + session.state = crate::state::SmtpState::Connected; + session.client_hostname = None; + session.esmtp = false; + session.auth_state = AuthState::None; + session.envelope = Default::default(); + debug!(session_id = %session.id, "TLS upgrade successful"); + } + Err(e) => { + warn!(session_id = %session.id, error = %e, "TLS handshake failed"); + break; + } + } + } else { + break; + } + } else { + // Already TLS — shouldn't happen + break; + } + } + LineResult::NoResponse => {} + LineResult::Disconnect => { + break; + } + } + } + } + } + + info!( + session_id = %session.id, + remote_addr = %remote_addr, + messages = session.message_count, + "Connection closed" + ); +} + +/// Result of processing a single input line. +enum LineResult { + /// Send this response to the client. + Response(SmtpResponse), + /// Send this response then close the connection. + Quit(SmtpResponse), + /// Signal that STARTTLS should be performed (main loop sends 220 and upgrades). + StartTlsSignal, + /// No response needed (handled internally). + NoResponse, + /// Disconnect immediately. + Disconnect, +} + +/// Trait for registering and resolving correlation-ID callbacks. +pub trait CallbackRegistry: Send + Sync { + /// Register a callback for email processing and return a receiver. + fn register_email_callback( + &self, + correlation_id: &str, + ) -> oneshot::Receiver; + + /// Register a callback for auth and return a receiver. + fn register_auth_callback( + &self, + correlation_id: &str, + ) -> oneshot::Receiver; +} + +/// Process a single input line from the client. +async fn process_line( + line: &str, + session: &mut SmtpSession, + stream: &mut SmtpStream, + config: &SmtpServerConfig, + rate_limiter: &RateLimiter, + event_tx: &mpsc::Sender, + callback_registry: &dyn CallbackRegistry, + tls_acceptor: &Option>, +) -> LineResult { + // Handle AUTH intermediate states (waiting for username/password) + match &session.auth_state { + AuthState::WaitingForUsername => { + return handle_auth_username(line.trim(), session); + } + AuthState::WaitingForPassword { .. } => { + return handle_auth_password( + line.trim(), + session, + config, + rate_limiter, + event_tx, + callback_registry, + ) + .await; + } + _ => {} + } + + // Parse SMTP command + let cmd = match parse_command(line) { + Ok(cmd) => cmd, + Err(ParseError::Empty) => return LineResult::NoResponse, + Err(_) => { + if session.record_invalid_command() { + return LineResult::Quit(SmtpResponse::service_unavailable( + &config.hostname, + "Too many invalid commands", + )); + } + return LineResult::Response(SmtpResponse::syntax_error()); + } + }; + + match cmd { + SmtpCommand::Ehlo(hostname) => handle_ehlo(hostname, true, session, config), + SmtpCommand::Helo(hostname) => handle_ehlo(hostname, false, session, config), + + SmtpCommand::MailFrom { address, params } => { + handle_mail_from(address, params, session, config, rate_limiter) + } + + SmtpCommand::RcptTo { address, params } => { + handle_rcpt_to(address, params, session, config) + } + + SmtpCommand::Data => { + handle_data(session, stream, config, event_tx, callback_registry).await + } + + SmtpCommand::Rset => { + session.reset_transaction(); + LineResult::Response(SmtpResponse::ok("OK")) + } + + SmtpCommand::Noop => LineResult::Response(SmtpResponse::ok("OK")), + + SmtpCommand::Quit => { + LineResult::Quit(SmtpResponse::closing(&config.hostname)) + } + + SmtpCommand::StartTls => { + handle_starttls(session, config, tls_acceptor) + } + + SmtpCommand::Auth { + mechanism, + initial_response, + } => { + handle_auth( + mechanism, + initial_response, + session, + config, + rate_limiter, + event_tx, + callback_registry, + ) + .await + } + + SmtpCommand::Help(_) => { + LineResult::Response(SmtpResponse::new( + 214, + "EHLO HELO MAIL RCPT DATA RSET NOOP QUIT STARTTLS AUTH HELP VRFY", + )) + } + + SmtpCommand::Vrfy(_) => { + LineResult::Response(SmtpResponse::new(252, "Cannot VRFY user")) + } + + SmtpCommand::Expn(_) => { + LineResult::Response(SmtpResponse::not_implemented()) + } + } +} + +/// Handle EHLO/HELO command. +fn handle_ehlo( + hostname: String, + esmtp: bool, + session: &mut SmtpSession, + config: &SmtpServerConfig, +) -> LineResult { + if !validation::is_valid_ehlo_hostname(&hostname) { + return LineResult::Response(SmtpResponse::param_error( + "Invalid hostname", + )); + } + + session.reset_for_ehlo(hostname, esmtp); + + if esmtp { + let caps = build_capabilities( + config.max_message_size, + config.has_tls(), + session.secure, + config.auth_enabled, + ); + LineResult::Response(SmtpResponse::ehlo_response(&config.hostname, &caps)) + } else { + LineResult::Response(SmtpResponse::ok(format!( + "{} Hello", + config.hostname + ))) + } +} + +/// Handle MAIL FROM command. +fn handle_mail_from( + address: String, + params: std::collections::HashMap>, + session: &mut SmtpSession, + config: &SmtpServerConfig, + rate_limiter: &RateLimiter, +) -> LineResult { + if !session.state.can_mail_from() { + return LineResult::Response(SmtpResponse::bad_sequence( + "Send EHLO/HELO first", + )); + } + + if !validation::is_valid_smtp_address(&address) { + return LineResult::Response(SmtpResponse::param_error( + "Invalid sender address", + )); + } + + // Check SIZE param + if let Some(Some(size_str)) = params.get("SIZE") { + match validation::validate_size_param(size_str, config.max_message_size) { + Ok(_) => {} + Err(msg) => return LineResult::Response(SmtpResponse::new(552, msg)), + } + } + + // Rate limit check for sender + if !address.is_empty() && !rate_limiter.check_message(&address) { + return LineResult::Response(SmtpResponse::temp_failure( + "Too many messages from this sender, try again later", + )); + } + + session.envelope.mail_from = address; + session.envelope.declared_size = params + .get("SIZE") + .and_then(|v| v.as_ref()) + .and_then(|s| s.parse().ok()); + session.envelope.body_type = params + .get("BODY") + .and_then(|v| v.clone()); + + match session.state.transition_mail_from() { + Ok(new_state) => { + session.state = new_state; + LineResult::Response(SmtpResponse::ok("OK")) + } + Err(_) => LineResult::Response(SmtpResponse::bad_sequence( + "Bad sequence of commands", + )), + } +} + +/// Handle RCPT TO command. +fn handle_rcpt_to( + address: String, + _params: std::collections::HashMap>, + session: &mut SmtpSession, + config: &SmtpServerConfig, +) -> LineResult { + if !session.state.can_rcpt_to() { + return LineResult::Response(SmtpResponse::bad_sequence( + "Send MAIL FROM first", + )); + } + + if !validation::is_valid_smtp_address(&address) || address.is_empty() { + return LineResult::Response(SmtpResponse::param_error( + "Invalid recipient address", + )); + } + + if session.envelope.rcpt_to.len() >= config.max_recipients as usize { + return LineResult::Response(SmtpResponse::new( + 452, + "Too many recipients", + )); + } + + session.envelope.rcpt_to.push(address); + + match session.state.transition_rcpt_to() { + Ok(new_state) => { + session.state = new_state; + LineResult::Response(SmtpResponse::ok("OK")) + } + Err(_) => LineResult::Response(SmtpResponse::bad_sequence( + "Bad sequence of commands", + )), + } +} + +/// Handle DATA command: switch to data mode, accumulate, then emit event. +async fn handle_data( + session: &mut SmtpSession, + stream: &mut SmtpStream, + config: &SmtpServerConfig, + event_tx: &mpsc::Sender, + callback_registry: &dyn CallbackRegistry, +) -> LineResult { + if !session.state.can_data() { + return LineResult::Response(SmtpResponse::bad_sequence( + "Send RCPT TO first", + )); + } + + // Transition to DATA state + session.state = match session.state.transition_data() { + Ok(s) => s, + Err(_) => { + return LineResult::Response(SmtpResponse::bad_sequence( + "Bad sequence of commands", + )); + } + }; + + // Send 354 + let start_resp = SmtpResponse::start_data(); + if stream.write_all(&start_resp.to_bytes()).await.is_err() { + return LineResult::Disconnect; + } + if stream.flush().await.is_err() { + return LineResult::Disconnect; + } + + // Accumulate data + let mut accumulator = DataAccumulator::new(config.max_message_size); + let data_timeout = Duration::from_secs(config.data_timeout_secs); + let mut buf = [0u8; 8192]; + + loop { + let read_result = timeout(data_timeout, stream.read_chunk(&mut buf)).await; + match read_result { + Err(_) => { + // Data timeout + return LineResult::Quit(SmtpResponse::service_unavailable( + &config.hostname, + "Data timeout", + )); + } + Ok(Err(_)) => return LineResult::Disconnect, + Ok(Ok(0)) => return LineResult::Disconnect, + Ok(Ok(n)) => { + match accumulator.process_chunk(&buf[..n]) { + DataAction::Continue => continue, + DataAction::SizeExceeded => { + // Must still read until end-of-data to stay in sync + session.state = crate::state::SmtpState::Greeted; + session.envelope = Default::default(); + return LineResult::Response(SmtpResponse::size_exceeded( + config.max_message_size, + )); + } + DataAction::Complete => break, + } + } + } + } + + // Data complete — prepare for delivery + let raw_message = accumulator.into_message().unwrap_or_default(); + let correlation_id = uuid::Uuid::new_v4().to_string(); + + // Determine transport: inline base64 or temp file + let email_data = if raw_message.len() <= 256 * 1024 { + EmailData::Inline { + base64: BASE64.encode(&raw_message), + } + } else { + // Write to temp file + let tmp_path = format!("/tmp/mailer-smtp-{}.eml", &correlation_id); + match tokio::fs::write(&tmp_path, &raw_message).await { + Ok(_) => EmailData::File { path: tmp_path }, + Err(e) => { + warn!(error = %e, "Failed to write temp file for large email"); + // Fall back to inline + EmailData::Inline { + base64: BASE64.encode(&raw_message), + } + } + } + }; + + // Register callback before sending event + let rx = callback_registry.register_email_callback(&correlation_id); + + // Send event to TS + let event = ConnectionEvent::EmailReceived { + correlation_id: correlation_id.clone(), + session_id: session.id.clone(), + mail_from: session.envelope.mail_from.clone(), + rcpt_to: session.envelope.rcpt_to.clone(), + data: email_data, + remote_addr: session.remote_addr.clone(), + client_hostname: session.client_hostname.clone(), + secure: session.secure, + authenticated_user: session.authenticated_user().map(|s| s.to_string()), + security_results: None, // Will be populated by server.rs when in-process security is added + }; + + if event_tx.send(event).await.is_err() { + warn!("Failed to send emailReceived event"); + return LineResult::Response(SmtpResponse::local_error( + "Internal processing error", + )); + } + + // Wait for TS response with timeout + let processing_timeout = Duration::from_secs(config.processing_timeout_secs); + let result = match timeout(processing_timeout, rx).await { + Ok(Ok(result)) => result, + Ok(Err(_)) => { + warn!(correlation_id = %correlation_id, "Callback channel dropped"); + EmailProcessingResult { + accepted: false, + smtp_code: Some(451), + smtp_message: Some("Processing error".into()), + } + } + Err(_) => { + warn!(correlation_id = %correlation_id, "Processing timeout"); + EmailProcessingResult { + accepted: false, + smtp_code: Some(451), + smtp_message: Some("Processing timeout".into()), + } + } + }; + + // Reset transaction state + session.envelope = Default::default(); + let _ = session.state.transition_finished(); + session.state = crate::state::SmtpState::Finished; + session.record_message(); + + if result.accepted { + LineResult::Response(SmtpResponse::ok( + result.smtp_message.unwrap_or_else(|| "Message accepted".into()), + )) + } else { + let code = result.smtp_code.unwrap_or(550); + let msg = result + .smtp_message + .unwrap_or_else(|| "Message rejected".into()); + LineResult::Response(SmtpResponse::new(code, msg)) + } +} + +/// Handle STARTTLS command. +/// +/// Returns `StartTlsSignal` to indicate the main loop should send 220 and +/// perform the TLS upgrade. The main loop handles the stream swap. +fn handle_starttls( + session: &SmtpSession, + config: &SmtpServerConfig, + tls_acceptor: &Option>, +) -> LineResult { + if session.secure { + return LineResult::Response(SmtpResponse::bad_sequence( + "Already using TLS", + )); + } + + if !session.state.can_starttls() { + return LineResult::Response(SmtpResponse::bad_sequence( + "STARTTLS not allowed in current state", + )); + } + + if tls_acceptor.is_none() || !config.has_tls() { + return LineResult::Response(SmtpResponse::new( + 454, + "TLS not available", + )); + } + + // Signal the main loop to perform TLS upgrade. + // The main loop will: send 220, extract TCP stream, do TLS handshake. + LineResult::StartTlsSignal +} + +/// Handle AUTH command. +async fn handle_auth( + mechanism: AuthMechanism, + initial_response: Option, + session: &mut SmtpSession, + config: &SmtpServerConfig, + rate_limiter: &RateLimiter, + event_tx: &mpsc::Sender, + callback_registry: &dyn CallbackRegistry, +) -> LineResult { + if !config.auth_enabled { + return LineResult::Response(SmtpResponse::not_implemented()); + } + + if session.is_authenticated() { + return LineResult::Response(SmtpResponse::bad_sequence( + "Already authenticated", + )); + } + + if !session.state.can_auth() { + return LineResult::Response(SmtpResponse::bad_sequence( + "Send EHLO first", + )); + } + + match mechanism { + AuthMechanism::Plain => { + if let Some(response) = initial_response { + // Decode and validate immediately + return process_auth_plain( + &response, + session, + config, + rate_limiter, + event_tx, + callback_registry, + ) + .await; + } + // No initial response — send challenge for credentials + session.auth_state = AuthState::WaitingForUsername; + // For PLAIN, we use an empty challenge + LineResult::Response(SmtpResponse::auth_challenge("")) + } + AuthMechanism::Login => { + if let Some(response) = initial_response { + // The initial response is the username (base64) + match BASE64.decode(response.as_bytes()) { + Ok(decoded) => { + let username = String::from_utf8_lossy(&decoded).to_string(); + session.auth_state = AuthState::WaitingForPassword { username }; + // Send password prompt (base64 of "Password:") + LineResult::Response(SmtpResponse::auth_challenge( + &BASE64.encode(b"Password:"), + )) + } + Err(_) => LineResult::Response(SmtpResponse::param_error( + "Invalid base64 encoding", + )), + } + } else { + session.auth_state = AuthState::WaitingForUsername; + // Send username prompt (base64 of "Username:") + LineResult::Response(SmtpResponse::auth_challenge( + &BASE64.encode(b"Username:"), + )) + } + } + } +} + +/// Handle username input during LOGIN auth flow. +fn handle_auth_username(line: &str, session: &mut SmtpSession) -> LineResult { + // Cancel auth if client sends "*" + if line == "*" { + session.auth_state = AuthState::None; + return LineResult::Response(SmtpResponse::new(501, "Authentication cancelled")); + } + + match BASE64.decode(line.as_bytes()) { + Ok(decoded) => { + let username = String::from_utf8_lossy(&decoded).to_string(); + session.auth_state = AuthState::WaitingForPassword { username }; + LineResult::Response(SmtpResponse::auth_challenge( + &BASE64.encode(b"Password:"), + )) + } + Err(_) => { + session.auth_state = AuthState::None; + LineResult::Response(SmtpResponse::param_error( + "Invalid base64 encoding", + )) + } + } +} + +/// Handle password input during LOGIN auth flow. +async fn handle_auth_password( + line: &str, + session: &mut SmtpSession, + config: &SmtpServerConfig, + rate_limiter: &RateLimiter, + event_tx: &mpsc::Sender, + callback_registry: &dyn CallbackRegistry, +) -> LineResult { + // Cancel auth if client sends "*" + if line == "*" { + session.auth_state = AuthState::None; + return LineResult::Response(SmtpResponse::new(501, "Authentication cancelled")); + } + + let username = match &session.auth_state { + AuthState::WaitingForPassword { username } => username.clone(), + _ => { + session.auth_state = AuthState::None; + return LineResult::Response(SmtpResponse::bad_sequence("Unexpected auth state")); + } + }; + + let password = match BASE64.decode(line.as_bytes()) { + Ok(decoded) => String::from_utf8_lossy(&decoded).to_string(), + Err(_) => { + session.auth_state = AuthState::None; + return LineResult::Response(SmtpResponse::param_error( + "Invalid base64 encoding", + )); + } + }; + + validate_credentials( + &username, + &password, + session, + config, + rate_limiter, + event_tx, + callback_registry, + ) + .await +} + +/// Process AUTH PLAIN credentials (base64-encoded "\0username\0password"). +async fn process_auth_plain( + base64_data: &str, + session: &mut SmtpSession, + config: &SmtpServerConfig, + rate_limiter: &RateLimiter, + event_tx: &mpsc::Sender, + callback_registry: &dyn CallbackRegistry, +) -> LineResult { + let decoded = match BASE64.decode(base64_data.as_bytes()) { + Ok(d) => d, + Err(_) => { + return LineResult::Response(SmtpResponse::param_error( + "Invalid base64 encoding", + )); + } + }; + + // PLAIN format: \0username\0password + let parts: Vec<&[u8]> = decoded.splitn(3, |&b| b == 0).collect(); + if parts.len() < 3 { + return LineResult::Response(SmtpResponse::param_error( + "Invalid PLAIN auth format", + )); + } + + let username = String::from_utf8_lossy(parts[1]).to_string(); + let password = String::from_utf8_lossy(parts[2]).to_string(); + + validate_credentials( + &username, + &password, + session, + config, + rate_limiter, + event_tx, + callback_registry, + ) + .await +} + +/// Validate credentials by sending authRequest to TS and waiting for response. +async fn validate_credentials( + username: &str, + password: &str, + session: &mut SmtpSession, + config: &SmtpServerConfig, + rate_limiter: &RateLimiter, + event_tx: &mpsc::Sender, + callback_registry: &dyn CallbackRegistry, +) -> LineResult { + let correlation_id = uuid::Uuid::new_v4().to_string(); + + // Register callback before sending event + let rx = callback_registry.register_auth_callback(&correlation_id); + + let event = ConnectionEvent::AuthRequest { + correlation_id: correlation_id.clone(), + session_id: session.id.clone(), + username: username.to_string(), + password: password.to_string(), + remote_addr: session.remote_addr.clone(), + }; + + if event_tx.send(event).await.is_err() { + session.auth_state = AuthState::None; + return LineResult::Response(SmtpResponse::local_error( + "Internal processing error", + )); + } + + // Wait for TS response + let auth_timeout = Duration::from_secs(5); + let result = match timeout(auth_timeout, rx).await { + Ok(Ok(result)) => result, + Ok(Err(_)) => AuthResult { + success: false, + message: Some("Auth processing error".into()), + }, + Err(_) => AuthResult { + success: false, + message: Some("Auth timeout".into()), + }, + }; + + if result.success { + session.auth_state = AuthState::Authenticated { + username: username.to_string(), + }; + LineResult::Response(SmtpResponse::auth_success()) + } else { + session.auth_state = AuthState::None; + let exceeded = session.record_auth_failure(config.max_auth_failures); + if exceeded { + if !rate_limiter.check_auth_failure(&session.remote_addr) { + return LineResult::Quit(SmtpResponse::service_unavailable( + &config.hostname, + "Too many authentication failures", + )); + } + return LineResult::Quit(SmtpResponse::service_unavailable( + &config.hostname, + "Too many authentication failures", + )); + } + LineResult::Response(SmtpResponse::auth_failed()) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_email_data_serialization() { + let data = EmailData::Inline { + base64: "dGVzdA==".into(), + }; + let json = serde_json::to_string(&data).unwrap(); + assert!(json.contains("inline")); + + let data = EmailData::File { + path: "/tmp/test.eml".into(), + }; + let json = serde_json::to_string(&data).unwrap(); + assert!(json.contains("file")); + } + + #[test] + fn test_processing_result_serialization() { + let result = EmailProcessingResult { + accepted: true, + smtp_code: Some(250), + smtp_message: Some("OK".into()), + }; + let json = serde_json::to_string(&result).unwrap(); + assert!(json.contains("accepted")); + } +} diff --git a/rust/crates/mailer-smtp/src/data.rs b/rust/crates/mailer-smtp/src/data.rs new file mode 100644 index 0000000..fe68313 --- /dev/null +++ b/rust/crates/mailer-smtp/src/data.rs @@ -0,0 +1,289 @@ +//! Email DATA phase processor. +//! +//! Handles dot-unstuffing, end-of-data detection, size enforcement, +//! and streaming accumulation of email data. + +/// Result of processing a chunk of DATA input. +#[derive(Debug, Clone, PartialEq)] +pub enum DataAction { + /// More data needed — continue accumulating. + Continue, + /// End-of-data detected. The complete message body is ready. + Complete, + /// Message size limit exceeded. + SizeExceeded, +} + +/// Streaming email data accumulator. +/// +/// Processes incoming bytes from the DATA phase, handling: +/// - CRLF line ending normalization +/// - Dot-unstuffing (RFC 5321 §4.5.2) +/// - End-of-data marker detection (`.`) +/// - Size enforcement +pub struct DataAccumulator { + /// Accumulated message bytes. + buffer: Vec, + /// Maximum allowed size in bytes. 0 = unlimited. + max_size: u64, + /// Whether we've detected end-of-data. + complete: bool, + /// Whether the current position is at the start of a line. + at_line_start: bool, + /// Partial state for cross-chunk boundary handling. + partial: PartialState, +} + +/// Tracks partial sequences that span chunk boundaries. +#[derive(Debug, Clone, Copy, PartialEq)] +enum PartialState { + /// No partial sequence. + None, + /// Saw `\r`, waiting for `\n`. + Cr, + /// At line start, saw `.`, waiting to determine dot-stuffing vs end-of-data. + Dot, + /// At line start, saw `.\r`, waiting for `\n` (end-of-data) or other. + DotCr, +} + +impl DataAccumulator { + /// Create a new accumulator with the given size limit. + pub fn new(max_size: u64) -> Self { + Self { + buffer: Vec::with_capacity(8192), + max_size, + complete: false, + at_line_start: true, // First byte is at start of first line + partial: PartialState::None, + } + } + + /// Process a chunk of incoming data. + /// + /// Returns the action to take: continue, complete, or size exceeded. + pub fn process_chunk(&mut self, chunk: &[u8]) -> DataAction { + if self.complete { + return DataAction::Complete; + } + + for &byte in chunk { + match self.partial { + PartialState::None => { + if self.at_line_start && byte == b'.' { + self.partial = PartialState::Dot; + } else if byte == b'\r' { + self.partial = PartialState::Cr; + } else { + self.buffer.push(byte); + self.at_line_start = false; + } + } + PartialState::Cr => { + if byte == b'\n' { + self.buffer.extend_from_slice(b"\r\n"); + self.at_line_start = true; + self.partial = PartialState::None; + } else { + // Bare CR — emit it and process current byte + self.buffer.push(b'\r'); + self.at_line_start = false; + self.partial = PartialState::None; + // Re-process current byte + if byte == b'\r' { + self.partial = PartialState::Cr; + } else { + self.buffer.push(byte); + } + } + } + PartialState::Dot => { + if byte == b'\r' { + self.partial = PartialState::DotCr; + } else if byte == b'.' { + // Dot-unstuffing: \r\n.. → \r\n. + // Emit one dot, consume the other + self.buffer.push(b'.'); + self.at_line_start = false; + self.partial = PartialState::None; + } else { + // Dot at line start but not stuffing or end-of-data + self.buffer.push(b'.'); + self.buffer.push(byte); + self.at_line_start = false; + self.partial = PartialState::None; + } + } + PartialState::DotCr => { + if byte == b'\n' { + // End-of-data: . + // Remove the trailing \r\n from the buffer + // (it was part of the terminator, not the message) + if self.buffer.ends_with(b"\r\n") { + let new_len = self.buffer.len() - 2; + self.buffer.truncate(new_len); + } + self.complete = true; + return DataAction::Complete; + } else { + // Not end-of-data — emit .\r and process current byte + self.buffer.push(b'.'); + self.buffer.push(b'\r'); + self.at_line_start = false; + self.partial = PartialState::None; + // Re-process current byte + if byte == b'\r' { + self.partial = PartialState::Cr; + } else { + self.buffer.push(byte); + } + } + } + } + + // Check size limit + if self.max_size > 0 && self.buffer.len() as u64 > self.max_size { + return DataAction::SizeExceeded; + } + } + + DataAction::Continue + } + + /// Consume the accumulator and return the complete message data. + /// + /// Returns `None` if end-of-data has not been detected. + pub fn into_message(self) -> Option> { + if !self.complete { + return None; + } + Some(self.buffer) + } + + /// Get a reference to the accumulated data so far. + pub fn data(&self) -> &[u8] { + &self.buffer + } + + /// Get the current accumulated size. + pub fn size(&self) -> usize { + self.buffer.len() + } + + /// Whether end-of-data has been detected. + pub fn is_complete(&self) -> bool { + self.complete + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_simple_message() { + let mut acc = DataAccumulator::new(0); + let data = b"Subject: Test\r\n\r\nHello world\r\n.\r\n"; + let action = acc.process_chunk(data); + assert_eq!(action, DataAction::Complete); + let msg = acc.into_message().unwrap(); + assert_eq!(msg, b"Subject: Test\r\n\r\nHello world"); + } + + #[test] + fn test_dot_unstuffing() { + let mut acc = DataAccumulator::new(0); + // A line starting with ".." should become "." + let data = b"Line 1\r\n..dot-stuffed\r\n.\r\n"; + let action = acc.process_chunk(data); + assert_eq!(action, DataAction::Complete); + let msg = acc.into_message().unwrap(); + assert_eq!(msg, b"Line 1\r\n.dot-stuffed"); + } + + #[test] + fn test_multiple_chunks() { + let mut acc = DataAccumulator::new(0); + assert_eq!(acc.process_chunk(b"Subject: Test\r\n"), DataAction::Continue); + assert_eq!(acc.process_chunk(b"\r\nBody line 1\r\n"), DataAction::Continue); + assert_eq!(acc.process_chunk(b"Body line 2\r\n.\r\n"), DataAction::Complete); + let msg = acc.into_message().unwrap(); + assert_eq!(msg, b"Subject: Test\r\n\r\nBody line 1\r\nBody line 2"); + } + + #[test] + fn test_end_of_data_spanning_chunks() { + let mut acc = DataAccumulator::new(0); + assert_eq!(acc.process_chunk(b"Body\r\n"), DataAction::Continue); + assert_eq!(acc.process_chunk(b".\r"), DataAction::Continue); + assert_eq!(acc.process_chunk(b"\n"), DataAction::Complete); + let msg = acc.into_message().unwrap(); + assert_eq!(msg, b"Body"); + } + + #[test] + fn test_size_limit() { + let mut acc = DataAccumulator::new(10); + let data = b"This is definitely more than 10 bytes\r\n.\r\n"; + let action = acc.process_chunk(data); + assert_eq!(action, DataAction::SizeExceeded); + } + + #[test] + fn test_not_complete() { + let mut acc = DataAccumulator::new(0); + acc.process_chunk(b"partial data"); + assert!(!acc.is_complete()); + assert!(acc.into_message().is_none()); + } + + #[test] + fn test_empty_message() { + let mut acc = DataAccumulator::new(0); + let action = acc.process_chunk(b".\r\n"); + assert_eq!(action, DataAction::Complete); + let msg = acc.into_message().unwrap(); + assert!(msg.is_empty()); + } + + #[test] + fn test_dot_not_at_line_start() { + let mut acc = DataAccumulator::new(0); + let data = b"Hello.World\r\n.\r\n"; + let action = acc.process_chunk(data); + assert_eq!(action, DataAction::Complete); + let msg = acc.into_message().unwrap(); + assert_eq!(msg, b"Hello.World"); + } + + #[test] + fn test_multiple_dots_in_line() { + let mut acc = DataAccumulator::new(0); + let data = b"...\r\n.\r\n"; + let action = acc.process_chunk(data); + assert_eq!(action, DataAction::Complete); + // First dot at line start is dot-unstuffed, leaving ".." + let msg = acc.into_message().unwrap(); + assert_eq!(msg, b".."); + } + + #[test] + fn test_crlf_dot_spanning_three_chunks() { + let mut acc = DataAccumulator::new(0); + assert_eq!(acc.process_chunk(b"Body\r"), DataAction::Continue); + assert_eq!(acc.process_chunk(b"\n."), DataAction::Continue); + assert_eq!(acc.process_chunk(b"\r\n"), DataAction::Complete); + let msg = acc.into_message().unwrap(); + assert_eq!(msg, b"Body"); + } + + #[test] + fn test_bare_cr() { + let mut acc = DataAccumulator::new(0); + let data = b"Hello\rWorld\r\n.\r\n"; + let action = acc.process_chunk(data); + assert_eq!(action, DataAction::Complete); + let msg = acc.into_message().unwrap(); + assert_eq!(msg, b"Hello\rWorld"); + } +} diff --git a/rust/crates/mailer-smtp/src/lib.rs b/rust/crates/mailer-smtp/src/lib.rs index 97b8e00..888580a 100644 --- a/rust/crates/mailer-smtp/src/lib.rs +++ b/rust/crates/mailer-smtp/src/lib.rs @@ -1,18 +1,39 @@ //! mailer-smtp: SMTP protocol engine (server + client). +//! +//! This crate provides the SMTP protocol implementation including: +//! - Command parsing (`command`) +//! - State machine (`state`) +//! - Response building (`response`) +//! - Email data accumulation (`data`) +//! - Per-connection session state (`session`) +//! - Address/input validation (`validation`) +//! - Server configuration (`config`) +//! - Rate limiting (`rate_limiter`) +//! - TCP/TLS server (`server`) +//! - Connection handling (`connection`) + +pub mod command; +pub mod config; +pub mod connection; +pub mod data; +pub mod rate_limiter; +pub mod response; +pub mod server; +pub mod session; +pub mod state; +pub mod validation; pub use mailer_core; -/// Placeholder for the SMTP server and client implementation. +// Re-export key types for convenience. +pub use command::{AuthMechanism, SmtpCommand}; +pub use config::SmtpServerConfig; +pub use data::{DataAccumulator, DataAction}; +pub use response::SmtpResponse; +pub use session::SmtpSession; +pub use state::SmtpState; + +/// Crate version. pub fn version() -> &'static str { env!("CARGO_PKG_VERSION") } - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_version() { - assert!(!version().is_empty()); - } -} diff --git a/rust/crates/mailer-smtp/src/rate_limiter.rs b/rust/crates/mailer-smtp/src/rate_limiter.rs new file mode 100644 index 0000000..1bb7bad --- /dev/null +++ b/rust/crates/mailer-smtp/src/rate_limiter.rs @@ -0,0 +1,198 @@ +//! In-process SMTP rate limiter. +//! +//! Uses DashMap for lock-free concurrent access to rate counters. +//! Tracks connections per IP, messages per sender, and auth failures. + +use dashmap::DashMap; +use serde::{Deserialize, Serialize}; +use std::time::{Duration, Instant}; + +/// Rate limiter configuration. +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct RateLimitConfig { + /// Maximum connections per IP per window. + pub max_connections_per_ip: u32, + /// Maximum messages per sender per window. + pub max_messages_per_sender: u32, + /// Maximum auth failures per IP per window. + pub max_auth_failures_per_ip: u32, + /// Window duration in seconds. + pub window_secs: u64, +} + +impl Default for RateLimitConfig { + fn default() -> Self { + Self { + max_connections_per_ip: 50, + max_messages_per_sender: 100, + max_auth_failures_per_ip: 5, + window_secs: 60, + } + } +} + +/// A timestamped counter entry. +struct CounterEntry { + count: u32, + window_start: Instant, +} + +/// In-process rate limiter using DashMap. +pub struct RateLimiter { + config: RateLimitConfig, + window: Duration, + connections: DashMap, + messages: DashMap, + auth_failures: DashMap, +} + +impl RateLimiter { + /// Create a new rate limiter with the given configuration. + pub fn new(config: RateLimitConfig) -> Self { + let window = Duration::from_secs(config.window_secs); + Self { + config, + window, + connections: DashMap::new(), + messages: DashMap::new(), + auth_failures: DashMap::new(), + } + } + + /// Update the configuration at runtime. + pub fn update_config(&mut self, config: RateLimitConfig) { + self.window = Duration::from_secs(config.window_secs); + self.config = config; + } + + /// Check and record a new connection from an IP. + /// Returns `true` if the connection should be allowed. + pub fn check_connection(&self, ip: &str) -> bool { + self.increment_and_check( + &self.connections, + ip, + self.config.max_connections_per_ip, + ) + } + + /// Check and record a message from a sender. + /// Returns `true` if the message should be allowed. + pub fn check_message(&self, sender: &str) -> bool { + self.increment_and_check( + &self.messages, + sender, + self.config.max_messages_per_sender, + ) + } + + /// Check and record an auth failure from an IP. + /// Returns `true` if more attempts should be allowed. + pub fn check_auth_failure(&self, ip: &str) -> bool { + self.increment_and_check( + &self.auth_failures, + ip, + self.config.max_auth_failures_per_ip, + ) + } + + /// Increment a counter and check against the limit. + /// Returns `true` if within limits. + fn increment_and_check( + &self, + map: &DashMap, + key: &str, + limit: u32, + ) -> bool { + let now = Instant::now(); + let mut entry = map + .entry(key.to_string()) + .or_insert_with(|| CounterEntry { + count: 0, + window_start: now, + }); + + // Reset window if expired + if now.duration_since(entry.window_start) > self.window { + entry.count = 0; + entry.window_start = now; + } + + entry.count += 1; + entry.count <= limit + } + + /// Clean up expired entries. Call periodically. + pub fn cleanup(&self) { + let now = Instant::now(); + let window = self.window; + self.connections + .retain(|_, v| now.duration_since(v.window_start) <= window); + self.messages + .retain(|_, v| now.duration_since(v.window_start) <= window); + self.auth_failures + .retain(|_, v| now.duration_since(v.window_start) <= window); + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_connection_limit() { + let limiter = RateLimiter::new(RateLimitConfig { + max_connections_per_ip: 3, + window_secs: 60, + ..Default::default() + }); + + assert!(limiter.check_connection("1.2.3.4")); + assert!(limiter.check_connection("1.2.3.4")); + assert!(limiter.check_connection("1.2.3.4")); + assert!(!limiter.check_connection("1.2.3.4")); // 4th = over limit + + // Different IP is independent + assert!(limiter.check_connection("5.6.7.8")); + } + + #[test] + fn test_message_limit() { + let limiter = RateLimiter::new(RateLimitConfig { + max_messages_per_sender: 2, + window_secs: 60, + ..Default::default() + }); + + assert!(limiter.check_message("sender@example.com")); + assert!(limiter.check_message("sender@example.com")); + assert!(!limiter.check_message("sender@example.com")); + } + + #[test] + fn test_auth_failure_limit() { + let limiter = RateLimiter::new(RateLimitConfig { + max_auth_failures_per_ip: 2, + window_secs: 60, + ..Default::default() + }); + + assert!(limiter.check_auth_failure("1.2.3.4")); + assert!(limiter.check_auth_failure("1.2.3.4")); + assert!(!limiter.check_auth_failure("1.2.3.4")); + } + + #[test] + fn test_cleanup() { + let limiter = RateLimiter::new(RateLimitConfig { + max_connections_per_ip: 1, + window_secs: 60, + ..Default::default() + }); + + limiter.check_connection("1.2.3.4"); + assert_eq!(limiter.connections.len(), 1); + + limiter.cleanup(); // entries not expired + assert_eq!(limiter.connections.len(), 1); + } +} diff --git a/rust/crates/mailer-smtp/src/response.rs b/rust/crates/mailer-smtp/src/response.rs new file mode 100644 index 0000000..502bfd8 --- /dev/null +++ b/rust/crates/mailer-smtp/src/response.rs @@ -0,0 +1,284 @@ +//! SMTP response builder. +//! +//! Constructs properly formatted SMTP response lines with status codes, +//! multiline support, and EHLO capability advertisement. + +use serde::{Deserialize, Serialize}; + +/// An SMTP response to send to the client. +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] +pub struct SmtpResponse { + /// 3-digit SMTP status code. + pub code: u16, + /// Response lines (without the status code prefix). + pub lines: Vec, +} + +impl SmtpResponse { + /// Create a single-line response. + pub fn new(code: u16, message: impl Into) -> Self { + Self { + code, + lines: vec![message.into()], + } + } + + /// Create a multiline response. + pub fn multiline(code: u16, lines: Vec) -> Self { + Self { code, lines } + } + + /// Format the response as bytes ready to write to the socket. + /// + /// Multiline responses use `code-text` for intermediate lines + /// and `code text` for the final line (RFC 5321 §4.2). + pub fn to_bytes(&self) -> Vec { + let mut buf = Vec::new(); + if self.lines.is_empty() { + buf.extend_from_slice(format!("{} \r\n", self.code).as_bytes()); + } else if self.lines.len() == 1 { + buf.extend_from_slice( + format!("{} {}\r\n", self.code, self.lines[0]).as_bytes(), + ); + } else { + for (i, line) in self.lines.iter().enumerate() { + if i < self.lines.len() - 1 { + buf.extend_from_slice( + format!("{}-{}\r\n", self.code, line).as_bytes(), + ); + } else { + buf.extend_from_slice( + format!("{} {}\r\n", self.code, line).as_bytes(), + ); + } + } + } + buf + } + + // --- Common response constructors --- + + /// 220 Service ready greeting. + pub fn greeting(hostname: &str) -> Self { + Self::new(220, format!("{hostname} ESMTP Service Ready")) + } + + /// 221 Service closing. + pub fn closing(hostname: &str) -> Self { + Self::new(221, format!("{hostname} Service closing transmission channel")) + } + + /// 250 OK. + pub fn ok(message: impl Into) -> Self { + Self::new(250, message) + } + + /// EHLO response with capabilities. + pub fn ehlo_response(hostname: &str, capabilities: &[String]) -> Self { + let mut lines = Vec::with_capacity(capabilities.len() + 1); + lines.push(format!("{hostname} greets you")); + for cap in capabilities { + lines.push(cap.clone()); + } + Self::multiline(250, lines) + } + + /// 235 Authentication successful. + pub fn auth_success() -> Self { + Self::new(235, "2.7.0 Authentication successful") + } + + /// 334 Auth challenge (base64-encoded prompt). + pub fn auth_challenge(prompt: &str) -> Self { + Self::new(334, prompt) + } + + /// 354 Start mail input. + pub fn start_data() -> Self { + Self::new(354, "Start mail input; end with .") + } + + /// 421 Service not available. + pub fn service_unavailable(hostname: &str, reason: &str) -> Self { + Self::new(421, format!("{hostname} {reason}")) + } + + /// 450 Temporary failure. + pub fn temp_failure(message: impl Into) -> Self { + Self::new(450, message) + } + + /// 451 Local error. + pub fn local_error(message: impl Into) -> Self { + Self::new(451, message) + } + + /// 500 Syntax error. + pub fn syntax_error() -> Self { + Self::new(500, "Syntax error, command unrecognized") + } + + /// 501 Syntax error in parameters. + pub fn param_error(message: impl Into) -> Self { + Self::new(501, message) + } + + /// 502 Command not implemented. + pub fn not_implemented() -> Self { + Self::new(502, "Command not implemented") + } + + /// 503 Bad sequence. + pub fn bad_sequence(message: impl Into) -> Self { + Self::new(503, message) + } + + /// 530 Authentication required. + pub fn auth_required() -> Self { + Self::new(530, "5.7.0 Authentication required") + } + + /// 535 Authentication failed. + pub fn auth_failed() -> Self { + Self::new(535, "5.7.8 Authentication credentials invalid") + } + + /// 550 Mailbox unavailable. + pub fn mailbox_unavailable(message: impl Into) -> Self { + Self::new(550, message) + } + + /// 552 Message size exceeded. + pub fn size_exceeded(max_size: u64) -> Self { + Self::new( + 552, + format!("5.3.4 Message size exceeds maximum of {max_size} bytes"), + ) + } + + /// 554 Transaction failed. + pub fn transaction_failed(message: impl Into) -> Self { + Self::new(554, message) + } + + /// Check if this is a success response (2xx). + pub fn is_success(&self) -> bool { + self.code >= 200 && self.code < 300 + } + + /// Check if this is a temporary error (4xx). + pub fn is_temp_error(&self) -> bool { + self.code >= 400 && self.code < 500 + } + + /// Check if this is a permanent error (5xx). + pub fn is_perm_error(&self) -> bool { + self.code >= 500 && self.code < 600 + } +} + +/// Build the list of EHLO capabilities for the server. +pub fn build_capabilities( + max_size: u64, + tls_available: bool, + already_secure: bool, + auth_available: bool, +) -> Vec { + let mut caps = vec![ + format!("SIZE {max_size}"), + "8BITMIME".to_string(), + "PIPELINING".to_string(), + "ENHANCEDSTATUSCODES".to_string(), + "HELP".to_string(), + ]; + // Only advertise STARTTLS if TLS is available and not already using TLS + if tls_available && !already_secure { + caps.push("STARTTLS".to_string()); + } + if auth_available { + caps.push("AUTH PLAIN LOGIN".to_string()); + } + caps +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_single_line() { + let resp = SmtpResponse::new(250, "OK"); + assert_eq!(resp.to_bytes(), b"250 OK\r\n"); + } + + #[test] + fn test_multiline() { + let resp = SmtpResponse::multiline( + 250, + vec![ + "mail.example.com greets you".into(), + "SIZE 10485760".into(), + "STARTTLS".into(), + ], + ); + let expected = b"250-mail.example.com greets you\r\n250-SIZE 10485760\r\n250 STARTTLS\r\n"; + assert_eq!(resp.to_bytes(), expected.to_vec()); + } + + #[test] + fn test_greeting() { + let resp = SmtpResponse::greeting("mail.example.com"); + assert_eq!(resp.code, 220); + assert!(resp.lines[0].contains("mail.example.com")); + } + + #[test] + fn test_ehlo_response() { + let caps = vec!["SIZE 10485760".into(), "STARTTLS".into()]; + let resp = SmtpResponse::ehlo_response("mail.example.com", &caps); + assert_eq!(resp.code, 250); + assert_eq!(resp.lines.len(), 3); // hostname + 2 caps + } + + #[test] + fn test_status_checks() { + assert!(SmtpResponse::new(250, "OK").is_success()); + assert!(SmtpResponse::new(450, "Try later").is_temp_error()); + assert!(SmtpResponse::new(550, "No such user").is_perm_error()); + assert!(!SmtpResponse::new(250, "OK").is_temp_error()); + } + + #[test] + fn test_build_capabilities() { + let caps = build_capabilities(10485760, true, false, true); + assert!(caps.contains(&"SIZE 10485760".to_string())); + assert!(caps.contains(&"STARTTLS".to_string())); + assert!(caps.contains(&"AUTH PLAIN LOGIN".to_string())); + assert!(caps.contains(&"PIPELINING".to_string())); + } + + #[test] + fn test_build_capabilities_secure() { + // When already secure, STARTTLS should NOT be advertised + let caps = build_capabilities(10485760, true, true, false); + assert!(!caps.contains(&"STARTTLS".to_string())); + assert!(!caps.contains(&"AUTH PLAIN LOGIN".to_string())); + } + + #[test] + fn test_empty_response() { + let resp = SmtpResponse::multiline(250, vec![]); + assert_eq!(resp.to_bytes(), b"250 \r\n"); + } + + #[test] + fn test_common_responses() { + assert_eq!(SmtpResponse::start_data().code, 354); + assert_eq!(SmtpResponse::syntax_error().code, 500); + assert_eq!(SmtpResponse::not_implemented().code, 502); + assert_eq!(SmtpResponse::bad_sequence("test").code, 503); + assert_eq!(SmtpResponse::auth_required().code, 530); + assert_eq!(SmtpResponse::auth_failed().code, 535); + assert_eq!(SmtpResponse::auth_success().code, 235); + } +} diff --git a/rust/crates/mailer-smtp/src/server.rs b/rust/crates/mailer-smtp/src/server.rs new file mode 100644 index 0000000..d5d3d32 --- /dev/null +++ b/rust/crates/mailer-smtp/src/server.rs @@ -0,0 +1,308 @@ +//! SMTP TCP/TLS server. +//! +//! Listens on configured ports, accepts connections, and dispatches +//! them to per-connection handlers. + +use crate::config::SmtpServerConfig; +use crate::connection::{ + self, CallbackRegistry, ConnectionEvent, SmtpStream, +}; +use crate::rate_limiter::{RateLimitConfig, RateLimiter}; + +use rustls_pki_types::{CertificateDer, PrivateKeyDer}; +use std::io::BufReader; +use std::sync::atomic::{AtomicBool, AtomicU32, Ordering}; +use std::sync::Arc; +use tokio::io::BufReader as TokioBufReader; +use tokio::net::TcpListener; +use tokio::sync::mpsc; +use tracing::{error, info, warn}; + +/// Handle for a running SMTP server. +pub struct SmtpServerHandle { + /// Shutdown signal. + shutdown: Arc, + /// Join handles for the listener tasks. + handles: Vec>, + /// Active connection count. + pub active_connections: Arc, +} + +impl SmtpServerHandle { + /// Signal shutdown and wait for all listeners to stop. + pub async fn shutdown(self) { + self.shutdown.store(true, Ordering::SeqCst); + for handle in self.handles { + let _ = handle.await; + } + info!("SMTP server shut down"); + } + + /// Check if the server is running. + pub fn is_running(&self) -> bool { + !self.shutdown.load(Ordering::SeqCst) + } +} + +/// Start the SMTP server with the given configuration. +/// +/// Returns a handle that can be used to shut down the server, +/// and an event receiver for connection events (emailReceived, authRequest). +pub async fn start_server( + config: SmtpServerConfig, + callback_registry: Arc, + rate_limit_config: Option, +) -> Result<(SmtpServerHandle, mpsc::Receiver), Box> +{ + let config = Arc::new(config); + let shutdown = Arc::new(AtomicBool::new(false)); + let active_connections = Arc::new(AtomicU32::new(0)); + let rate_limiter = Arc::new(RateLimiter::new( + rate_limit_config.unwrap_or_default(), + )); + + let (event_tx, event_rx) = mpsc::channel::(1024); + + // Build TLS acceptor if configured + let tls_acceptor = if config.has_tls() { + Some(Arc::new(build_tls_acceptor(&config)?)) + } else { + None + }; + + let mut handles = Vec::new(); + + // Start listeners on each port + for &port in &config.ports { + let listener = TcpListener::bind(format!("0.0.0.0:{port}")).await?; + info!(port = port, "SMTP server listening (STARTTLS)"); + + let handle = tokio::spawn(accept_loop( + listener, + config.clone(), + shutdown.clone(), + active_connections.clone(), + rate_limiter.clone(), + event_tx.clone(), + callback_registry.clone(), + tls_acceptor.clone(), + false, // not implicit TLS + )); + handles.push(handle); + } + + // Start implicit TLS listener if configured + if let Some(secure_port) = config.secure_port { + if tls_acceptor.is_some() { + let listener = + TcpListener::bind(format!("0.0.0.0:{secure_port}")).await?; + info!(port = secure_port, "SMTP server listening (implicit TLS)"); + + let handle = tokio::spawn(accept_loop( + listener, + config.clone(), + shutdown.clone(), + active_connections.clone(), + rate_limiter.clone(), + event_tx.clone(), + callback_registry.clone(), + tls_acceptor.clone(), + true, // implicit TLS + )); + handles.push(handle); + } else { + warn!("Secure port configured but TLS certificates not provided"); + } + } + + // Spawn periodic rate limiter cleanup + { + let rate_limiter = rate_limiter.clone(); + let shutdown = shutdown.clone(); + tokio::spawn(async move { + let mut interval = + tokio::time::interval(tokio::time::Duration::from_secs(60)); + loop { + interval.tick().await; + if shutdown.load(Ordering::SeqCst) { + break; + } + rate_limiter.cleanup(); + } + }); + } + + Ok(( + SmtpServerHandle { + shutdown, + handles, + active_connections, + }, + event_rx, + )) +} + +/// Accept loop for a single listener. +async fn accept_loop( + listener: TcpListener, + config: Arc, + shutdown: Arc, + active_connections: Arc, + rate_limiter: Arc, + event_tx: mpsc::Sender, + callback_registry: Arc, + tls_acceptor: Option>, + implicit_tls: bool, +) { + loop { + if shutdown.load(Ordering::SeqCst) { + break; + } + + // Use a short timeout to check shutdown periodically + let accept_result = tokio::time::timeout( + tokio::time::Duration::from_secs(1), + listener.accept(), + ) + .await; + + let (tcp_stream, peer_addr) = match accept_result { + Ok(Ok((stream, addr))) => (stream, addr), + Ok(Err(e)) => { + error!(error = %e, "Accept error"); + continue; + } + Err(_) => continue, // timeout, check shutdown + }; + + // Check max connections + let current = active_connections.load(Ordering::SeqCst); + if current >= config.max_connections { + warn!( + current = current, + max = config.max_connections, + "Max connections reached, rejecting" + ); + drop(tcp_stream); + continue; + } + + let remote_addr = peer_addr.ip().to_string(); + let config = config.clone(); + let rate_limiter = rate_limiter.clone(); + let event_tx = event_tx.clone(); + let callback_registry = callback_registry.clone(); + let tls_acceptor = tls_acceptor.clone(); + let active_connections = active_connections.clone(); + + active_connections.fetch_add(1, Ordering::SeqCst); + + tokio::spawn(async move { + let stream = if implicit_tls { + // Implicit TLS: wrap immediately + if let Some(acceptor) = &tls_acceptor { + match acceptor.accept(tcp_stream).await { + Ok(tls_stream) => { + SmtpStream::Tls(TokioBufReader::new(tls_stream)) + } + Err(e) => { + warn!( + remote_addr = %remote_addr, + error = %e, + "Implicit TLS handshake failed" + ); + active_connections.fetch_sub(1, Ordering::SeqCst); + return; + } + } + } else { + active_connections.fetch_sub(1, Ordering::SeqCst); + return; + } + } else { + SmtpStream::Plain(TokioBufReader::new(tcp_stream)) + }; + + connection::handle_connection( + stream, + config, + rate_limiter, + event_tx, + callback_registry, + tls_acceptor, + remote_addr, + implicit_tls, + ) + .await; + + active_connections.fetch_sub(1, Ordering::SeqCst); + }); + } +} + +/// Build a TLS acceptor from PEM cert/key strings. +fn build_tls_acceptor( + config: &SmtpServerConfig, +) -> Result> { + let cert_pem = config + .tls_cert_pem + .as_ref() + .ok_or("TLS cert not configured")?; + let key_pem = config + .tls_key_pem + .as_ref() + .ok_or("TLS key not configured")?; + + // Parse certificates + let certs: Vec> = { + let mut reader = BufReader::new(cert_pem.as_bytes()); + rustls_pemfile::certs(&mut reader) + .collect::, _>>()? + }; + + if certs.is_empty() { + return Err("No certificates found in PEM".into()); + } + + // Parse private key + let key: PrivateKeyDer<'static> = { + let mut reader = BufReader::new(key_pem.as_bytes()); + // Try PKCS8 first, then RSA, then EC + let mut keys = Vec::new(); + for item in rustls_pemfile::read_all(&mut reader) { + match item? { + rustls_pemfile::Item::Pkcs8Key(key) => { + keys.push(PrivateKeyDer::Pkcs8(key)); + } + rustls_pemfile::Item::Pkcs1Key(key) => { + keys.push(PrivateKeyDer::Pkcs1(key)); + } + rustls_pemfile::Item::Sec1Key(key) => { + keys.push(PrivateKeyDer::Sec1(key)); + } + _ => {} + } + } + keys.into_iter() + .next() + .ok_or("No private key found in PEM")? + }; + + let tls_config = rustls::ServerConfig::builder() + .with_no_client_auth() + .with_single_cert(certs, key)?; + + Ok(tokio_rustls::TlsAcceptor::from(Arc::new(tls_config))) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_server_config_defaults() { + let config = SmtpServerConfig::default(); + assert!(!config.has_tls()); + assert_eq!(config.ports, vec![25]); + } +} diff --git a/rust/crates/mailer-smtp/src/session.rs b/rust/crates/mailer-smtp/src/session.rs new file mode 100644 index 0000000..f1d7a22 --- /dev/null +++ b/rust/crates/mailer-smtp/src/session.rs @@ -0,0 +1,206 @@ +//! Per-connection SMTP session state. +//! +//! Tracks the envelope, authentication, TLS status, and counters +//! for a single SMTP connection. + +use crate::state::SmtpState; +use serde::{Deserialize, Serialize}; +use uuid::Uuid; + +/// Envelope accumulator for the current mail transaction. +#[derive(Debug, Clone, Default, Serialize, Deserialize)] +pub struct Envelope { + /// Sender address from MAIL FROM. + pub mail_from: String, + /// Recipient addresses from RCPT TO. + pub rcpt_to: Vec, + /// Declared message size from MAIL FROM SIZE= param (if any). + pub declared_size: Option, + /// BODY parameter (e.g. "8BITMIME"). + pub body_type: Option, +} + +/// Authentication state for the session. +#[derive(Debug, Clone, Serialize, Deserialize)] +pub enum AuthState { + /// Not authenticated and not in progress. + None, + /// Waiting for AUTH credentials (LOGIN flow step). + WaitingForUsername, + /// Have username, waiting for password. + WaitingForPassword { username: String }, + /// Successfully authenticated. + Authenticated { username: String }, +} + +impl Default for AuthState { + fn default() -> Self { + AuthState::None + } +} + +/// Per-connection session state. +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct SmtpSession { + /// Unique session identifier. + pub id: String, + /// Current protocol state. + pub state: SmtpState, + /// Client's EHLO/HELO hostname. + pub client_hostname: Option, + /// Whether the client used EHLO (vs HELO). + pub esmtp: bool, + /// Whether the connection is using TLS. + pub secure: bool, + /// Authentication state. + pub auth_state: AuthState, + /// Current transaction envelope. + pub envelope: Envelope, + /// Remote IP address. + pub remote_addr: String, + /// Number of messages sent in this session. + pub message_count: u32, + /// Number of failed auth attempts. + pub auth_failures: u32, + /// Number of invalid commands. + pub invalid_commands: u32, + /// Maximum allowed invalid commands before disconnect. + pub max_invalid_commands: u32, +} + +impl SmtpSession { + /// Create a new session for a connection. + pub fn new(remote_addr: String, secure: bool) -> Self { + Self { + id: Uuid::new_v4().to_string(), + state: SmtpState::Connected, + client_hostname: None, + esmtp: false, + secure, + auth_state: AuthState::None, + envelope: Envelope::default(), + remote_addr, + message_count: 0, + auth_failures: 0, + invalid_commands: 0, + max_invalid_commands: 20, + } + } + + /// Reset the current transaction (RSET), preserving connection state. + pub fn reset_transaction(&mut self) { + self.envelope = Envelope::default(); + if self.state != SmtpState::Connected { + self.state = SmtpState::Greeted; + } + } + + /// Reset session for a new EHLO (preserves counters and TLS). + pub fn reset_for_ehlo(&mut self, hostname: String, esmtp: bool) { + self.client_hostname = Some(hostname); + self.esmtp = esmtp; + self.envelope = Envelope::default(); + self.state = SmtpState::Greeted; + // Auth state is reset on new EHLO per RFC + self.auth_state = AuthState::None; + } + + /// Check if the client is authenticated. + pub fn is_authenticated(&self) -> bool { + matches!(self.auth_state, AuthState::Authenticated { .. }) + } + + /// Get the authenticated username, if any. + pub fn authenticated_user(&self) -> Option<&str> { + match &self.auth_state { + AuthState::Authenticated { username } => Some(username), + _ => None, + } + } + + /// Record a completed message delivery. + pub fn record_message(&mut self) { + self.message_count += 1; + } + + /// Record a failed auth attempt. Returns true if limit exceeded. + pub fn record_auth_failure(&mut self, max_failures: u32) -> bool { + self.auth_failures += 1; + self.auth_failures >= max_failures + } + + /// Record an invalid command. Returns true if limit exceeded. + pub fn record_invalid_command(&mut self) -> bool { + self.invalid_commands += 1; + self.invalid_commands >= self.max_invalid_commands + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_new_session() { + let session = SmtpSession::new("127.0.0.1".into(), false); + assert_eq!(session.state, SmtpState::Connected); + assert!(!session.secure); + assert!(!session.is_authenticated()); + assert!(session.client_hostname.is_none()); + } + + #[test] + fn test_reset_transaction() { + let mut session = SmtpSession::new("127.0.0.1".into(), false); + session.state = SmtpState::RcptTo; + session.envelope.mail_from = "sender@example.com".into(); + session.envelope.rcpt_to.push("rcpt@example.com".into()); + + session.reset_transaction(); + + assert_eq!(session.state, SmtpState::Greeted); + assert!(session.envelope.mail_from.is_empty()); + assert!(session.envelope.rcpt_to.is_empty()); + } + + #[test] + fn test_reset_for_ehlo() { + let mut session = SmtpSession::new("127.0.0.1".into(), true); + session.auth_state = AuthState::Authenticated { + username: "user".into(), + }; + + session.reset_for_ehlo("mail.example.com".into(), true); + + assert_eq!(session.state, SmtpState::Greeted); + assert_eq!(session.client_hostname.as_deref(), Some("mail.example.com")); + assert!(session.esmtp); + assert!(!session.is_authenticated()); // Auth reset after EHLO + } + + #[test] + fn test_auth_failures() { + let mut session = SmtpSession::new("127.0.0.1".into(), false); + assert!(!session.record_auth_failure(3)); + assert!(!session.record_auth_failure(3)); + assert!(session.record_auth_failure(3)); // 3rd failure -> limit + } + + #[test] + fn test_invalid_commands() { + let mut session = SmtpSession::new("127.0.0.1".into(), false); + session.max_invalid_commands = 3; + assert!(!session.record_invalid_command()); + assert!(!session.record_invalid_command()); + assert!(session.record_invalid_command()); // 3rd -> limit + } + + #[test] + fn test_message_count() { + let mut session = SmtpSession::new("127.0.0.1".into(), false); + assert_eq!(session.message_count, 0); + session.record_message(); + session.record_message(); + assert_eq!(session.message_count, 2); + } +} diff --git a/rust/crates/mailer-smtp/src/state.rs b/rust/crates/mailer-smtp/src/state.rs new file mode 100644 index 0000000..1bb7221 --- /dev/null +++ b/rust/crates/mailer-smtp/src/state.rs @@ -0,0 +1,219 @@ +//! SMTP protocol state machine. +//! +//! Defines valid states and transitions for an SMTP session. + +use serde::{Deserialize, Serialize}; + +/// SMTP session states following RFC 5321. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)] +pub enum SmtpState { + /// Initial state — waiting for server greeting. + Connected, + /// After successful EHLO/HELO. + Greeted, + /// After MAIL FROM accepted. + MailFrom, + /// After at least one RCPT TO accepted. + RcptTo, + /// In DATA mode — accumulating message body. + Data, + /// Transaction completed — can start a new one or QUIT. + Finished, +} + +/// State transition errors. +#[derive(Debug, Clone, PartialEq, thiserror::Error)] +pub enum TransitionError { + #[error("cannot {action} in state {state:?}")] + InvalidTransition { + state: SmtpState, + action: &'static str, + }, +} + +impl SmtpState { + /// Check whether EHLO/HELO is valid in the current state. + /// EHLO/HELO can be issued at any time to reset the session. + pub fn can_ehlo(&self) -> bool { + true + } + + /// Check whether MAIL FROM is valid in the current state. + pub fn can_mail_from(&self) -> bool { + matches!(self, SmtpState::Greeted | SmtpState::Finished) + } + + /// Check whether RCPT TO is valid in the current state. + pub fn can_rcpt_to(&self) -> bool { + matches!(self, SmtpState::MailFrom | SmtpState::RcptTo) + } + + /// Check whether DATA is valid in the current state. + pub fn can_data(&self) -> bool { + matches!(self, SmtpState::RcptTo) + } + + /// Check whether STARTTLS is valid in the current state. + /// Only before a transaction starts. + pub fn can_starttls(&self) -> bool { + matches!(self, SmtpState::Connected | SmtpState::Greeted | SmtpState::Finished) + } + + /// Check whether AUTH is valid in the current state. + /// Only after EHLO and before a transaction starts. + pub fn can_auth(&self) -> bool { + matches!(self, SmtpState::Greeted | SmtpState::Finished) + } + + /// Transition to Greeted state (after EHLO/HELO). + pub fn transition_ehlo(&self) -> Result { + // EHLO is always valid — it resets the session. + Ok(SmtpState::Greeted) + } + + /// Transition to MailFrom state (after MAIL FROM accepted). + pub fn transition_mail_from(&self) -> Result { + if self.can_mail_from() { + Ok(SmtpState::MailFrom) + } else { + Err(TransitionError::InvalidTransition { + state: *self, + action: "MAIL FROM", + }) + } + } + + /// Transition to RcptTo state (after RCPT TO accepted). + pub fn transition_rcpt_to(&self) -> Result { + if self.can_rcpt_to() { + Ok(SmtpState::RcptTo) + } else { + Err(TransitionError::InvalidTransition { + state: *self, + action: "RCPT TO", + }) + } + } + + /// Transition to Data state (after DATA command accepted). + pub fn transition_data(&self) -> Result { + if self.can_data() { + Ok(SmtpState::Data) + } else { + Err(TransitionError::InvalidTransition { + state: *self, + action: "DATA", + }) + } + } + + /// Transition to Finished state (after end-of-data). + pub fn transition_finished(&self) -> Result { + if *self == SmtpState::Data { + Ok(SmtpState::Finished) + } else { + Err(TransitionError::InvalidTransition { + state: *self, + action: "finish DATA", + }) + } + } + + /// Reset to Greeted state (after RSET command). + pub fn transition_rset(&self) -> Result { + match self { + SmtpState::Connected => Err(TransitionError::InvalidTransition { + state: *self, + action: "RSET", + }), + _ => Ok(SmtpState::Greeted), + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_initial_state() { + let state = SmtpState::Connected; + assert!(!state.can_mail_from()); + assert!(!state.can_rcpt_to()); + assert!(!state.can_data()); + assert!(state.can_starttls()); + assert!(state.can_ehlo()); + } + + #[test] + fn test_ehlo_always_valid() { + for state in [ + SmtpState::Connected, + SmtpState::Greeted, + SmtpState::MailFrom, + SmtpState::RcptTo, + SmtpState::Data, + SmtpState::Finished, + ] { + assert!(state.can_ehlo()); + assert!(state.transition_ehlo().is_ok()); + } + } + + #[test] + fn test_normal_flow() { + let state = SmtpState::Connected; + let state = state.transition_ehlo().unwrap(); + assert_eq!(state, SmtpState::Greeted); + + let state = state.transition_mail_from().unwrap(); + assert_eq!(state, SmtpState::MailFrom); + + let state = state.transition_rcpt_to().unwrap(); + assert_eq!(state, SmtpState::RcptTo); + + // Multiple RCPT TO + let state = state.transition_rcpt_to().unwrap(); + assert_eq!(state, SmtpState::RcptTo); + + let state = state.transition_data().unwrap(); + assert_eq!(state, SmtpState::Data); + + let state = state.transition_finished().unwrap(); + assert_eq!(state, SmtpState::Finished); + + // New transaction + let state = state.transition_mail_from().unwrap(); + assert_eq!(state, SmtpState::MailFrom); + } + + #[test] + fn test_invalid_transitions() { + assert!(SmtpState::Connected.transition_mail_from().is_err()); + assert!(SmtpState::Connected.transition_rcpt_to().is_err()); + assert!(SmtpState::Connected.transition_data().is_err()); + assert!(SmtpState::Greeted.transition_rcpt_to().is_err()); + assert!(SmtpState::Greeted.transition_data().is_err()); + assert!(SmtpState::MailFrom.transition_data().is_err()); + } + + #[test] + fn test_rset() { + let state = SmtpState::RcptTo; + let state = state.transition_rset().unwrap(); + assert_eq!(state, SmtpState::Greeted); + + // RSET from Connected is invalid (no EHLO yet) + assert!(SmtpState::Connected.transition_rset().is_err()); + } + + #[test] + fn test_starttls_validity() { + assert!(SmtpState::Connected.can_starttls()); + assert!(SmtpState::Greeted.can_starttls()); + assert!(!SmtpState::MailFrom.can_starttls()); + assert!(!SmtpState::RcptTo.can_starttls()); + assert!(!SmtpState::Data.can_starttls()); + assert!(SmtpState::Finished.can_starttls()); + } +} diff --git a/rust/crates/mailer-smtp/src/validation.rs b/rust/crates/mailer-smtp/src/validation.rs new file mode 100644 index 0000000..7757c20 --- /dev/null +++ b/rust/crates/mailer-smtp/src/validation.rs @@ -0,0 +1,169 @@ +//! SMTP-level validation utilities. +//! +//! Address parsing, EHLO hostname validation, and header injection detection. + +use regex::Regex; +use std::sync::LazyLock; + +/// Regex for basic email address format validation. +static EMAIL_RE: LazyLock = LazyLock::new(|| { + Regex::new(r"^[^\s@]+@[^\s@]+\.[^\s@]+$").unwrap() +}); + +/// Regex for valid EHLO hostname (domain name or IPv4/IPv6 literal). +/// Currently unused in favor of a more permissive check, but available +/// for strict validation if needed. +#[allow(dead_code)] +static EHLO_RE: LazyLock = LazyLock::new(|| { + // Permissive: domain names, IP literals [1.2.3.4], [IPv6:...], or bare words + Regex::new(r"^(?:\[(?:IPv6:)?[^\]]+\]|[a-zA-Z0-9](?:[a-zA-Z0-9\-\.]*[a-zA-Z0-9])?)$").unwrap() +}); + +/// Validate an email address for basic SMTP format. +/// +/// Returns `true` if the address has a valid-looking format. +/// Empty addresses (for bounce messages, MAIL FROM:<>) return `true`. +pub fn is_valid_smtp_address(address: &str) -> bool { + // Empty address is valid for MAIL FROM (bounce) + if address.is_empty() { + return true; + } + EMAIL_RE.is_match(address) +} + +/// Validate an EHLO/HELO hostname. +/// +/// Returns `true` if the hostname looks syntactically valid. +/// We are permissive because real-world SMTP clients send all kinds of values. +pub fn is_valid_ehlo_hostname(hostname: &str) -> bool { + if hostname.is_empty() { + return false; + } + // Be permissive — most SMTP servers accept anything non-empty. + // Only reject obviously malicious patterns. + if hostname.len() > 255 { + return false; + } + if contains_header_injection(hostname) { + return false; + } + // Must not contain null bytes + if hostname.contains('\0') { + return false; + } + true +} + +/// Check for SMTP header injection attempts. +/// +/// Returns `true` if the input contains characters that could be used +/// for header injection (bare CR/LF). +pub fn contains_header_injection(input: &str) -> bool { + input.contains('\r') || input.contains('\n') +} + +/// Validate the size parameter from MAIL FROM. +/// +/// Returns the parsed size if valid and within the max, or an error message. +pub fn validate_size_param(value: &str, max_size: u64) -> Result { + let size: u64 = value + .parse() + .map_err(|_| format!("invalid SIZE value: {value}"))?; + if size > max_size { + return Err(format!( + "message size {size} exceeds maximum {max_size}" + )); + } + Ok(size) +} + +/// Extract the domain part from an email address. +pub fn extract_domain(address: &str) -> Option<&str> { + if address.is_empty() { + return None; + } + address.rsplit_once('@').map(|(_, domain)| domain) +} + +/// Normalize an email address by lowercasing the domain part. +pub fn normalize_address(address: &str) -> String { + if address.is_empty() { + return String::new(); + } + match address.rsplit_once('@') { + Some((local, domain)) => format!("{local}@{}", domain.to_ascii_lowercase()), + None => address.to_string(), + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_valid_email() { + assert!(is_valid_smtp_address("user@example.com")); + assert!(is_valid_smtp_address("user+tag@sub.example.com")); + assert!(is_valid_smtp_address("a@b.c")); + } + + #[test] + fn test_empty_address_valid() { + assert!(is_valid_smtp_address("")); + } + + #[test] + fn test_invalid_email() { + assert!(!is_valid_smtp_address("no-at-sign")); + assert!(!is_valid_smtp_address("@no-local.com")); + assert!(!is_valid_smtp_address("user@")); + assert!(!is_valid_smtp_address("user@nodot")); + assert!(!is_valid_smtp_address("has space@example.com")); + } + + #[test] + fn test_valid_ehlo() { + assert!(is_valid_ehlo_hostname("mail.example.com")); + assert!(is_valid_ehlo_hostname("localhost")); + assert!(is_valid_ehlo_hostname("[127.0.0.1]")); + assert!(is_valid_ehlo_hostname("[IPv6:::1]")); + } + + #[test] + fn test_invalid_ehlo() { + assert!(!is_valid_ehlo_hostname("")); + assert!(!is_valid_ehlo_hostname("host\r\nname")); + assert!(!is_valid_ehlo_hostname(&"a".repeat(256))); + } + + #[test] + fn test_header_injection() { + assert!(contains_header_injection("test\r\nBcc: evil@evil.com")); + assert!(contains_header_injection("test\ninjection")); + assert!(contains_header_injection("test\rinjection")); + assert!(!contains_header_injection("normal text")); + } + + #[test] + fn test_size_param() { + assert_eq!(validate_size_param("12345", 1_000_000), Ok(12345)); + assert!(validate_size_param("99999999", 1_000).is_err()); + assert!(validate_size_param("notanumber", 1_000).is_err()); + } + + #[test] + fn test_extract_domain() { + assert_eq!(extract_domain("user@example.com"), Some("example.com")); + assert_eq!(extract_domain(""), None); + assert_eq!(extract_domain("nodomain"), None); + } + + #[test] + fn test_normalize_address() { + assert_eq!( + normalize_address("User@EXAMPLE.COM"), + "User@example.com" + ); + assert_eq!(normalize_address(""), ""); + } +} diff --git a/ts/00_commitinfo_data.ts b/ts/00_commitinfo_data.ts index 1186d55..b5b0ecc 100644 --- a/ts/00_commitinfo_data.ts +++ b/ts/00_commitinfo_data.ts @@ -3,6 +3,6 @@ */ export const commitinfo = { name: '@push.rocks/smartmta', - version: '2.1.0', + version: '2.2.0', description: 'A high-performance, enterprise-grade Mail Transfer Agent (MTA) built from scratch in TypeScript with Rust acceleration.' } diff --git a/ts/mail/routing/classes.unified.email.server.ts b/ts/mail/routing/classes.unified.email.server.ts index a1a643f..21a370d 100644 --- a/ts/mail/routing/classes.unified.email.server.ts +++ b/ts/mail/routing/classes.unified.email.server.ts @@ -10,6 +10,7 @@ import { import { DKIMCreator } from '../security/classes.dkimcreator.js'; import { IPReputationChecker } from '../../security/classes.ipreputationchecker.js'; import { RustSecurityBridge } from '../../security/classes.rustsecuritybridge.js'; +import type { IEmailReceivedEvent, IAuthRequestEvent, IEmailData } from '../../security/classes.rustsecuritybridge.js'; // Deliverability types (IPWarmupManager and SenderReputationMonitor are optional external modules) interface IIPWarmupConfig { enabled?: boolean; @@ -396,134 +397,86 @@ export class UnifiedEmailServer extends EventEmitter { this.emit('started'); return; } - + // Ensure we have the necessary TLS options const hasTlsConfig = this.options.tls?.keyPath && this.options.tls?.certPath; - + // Prepare the certificate and key if available - let key: string | undefined; - let cert: string | undefined; - + let tlsCertPem: string | undefined; + let tlsKeyPem: string | undefined; + if (hasTlsConfig) { try { - key = plugins.fs.readFileSync(this.options.tls.keyPath!, 'utf8'); - cert = plugins.fs.readFileSync(this.options.tls.certPath!, 'utf8'); + tlsKeyPem = plugins.fs.readFileSync(this.options.tls.keyPath!, 'utf8'); + tlsCertPem = plugins.fs.readFileSync(this.options.tls.certPath!, 'utf8'); logger.log('info', 'TLS certificates loaded successfully'); } catch (error) { logger.log('warn', `Failed to load TLS certificates: ${error.message}`); } } - - // Create a SMTP server for each port - for (const port of this.options.ports as number[]) { - // Create a reference object to hold the MTA service during setup - const mtaRef = { - config: { - smtp: { - hostname: this.options.hostname - }, - security: { - checkIPReputation: false, - verifyDkim: true, - verifySpf: true, - verifyDmarc: true - } - }, - // Security verification delegated to the Rust bridge - dkimVerifier: { - verify: async (rawMessage: string) => { - try { - const results = await this.rustBridge.verifyDkim(rawMessage); - const first = results[0]; - return { isValid: first?.is_valid ?? false, domain: first?.domain ?? '' }; - } catch (err) { - logger.log('warn', `Rust DKIM verification failed: ${(err as Error).message}`); - return { isValid: false, domain: '' }; - } - } - }, - spfVerifier: { - verifyAndApply: async (session: any) => { - if (!session?.remoteAddress || session.remoteAddress === '127.0.0.1') { - return true; // localhost — skip SPF - } - try { - const result = await this.rustBridge.checkSpf({ - ip: session.remoteAddress, - heloDomain: session.clientHostname || '', - hostname: this.options.hostname, - mailFrom: session.envelope?.mailFrom?.address || session.mailFrom || '', - }); - return result.result === 'pass' || result.result === 'none' || result.result === 'neutral'; - } catch (err) { - logger.log('warn', `Rust SPF check failed: ${(err as Error).message}`); - return true; // Accept on error to avoid blocking mail - } - } - }, - dmarcVerifier: { - verify: async () => ({}), - applyPolicy: () => true - }, - processIncomingEmail: async (email: Email) => { - // Process email using the new route-based system - await this.processEmailByMode(email, { - id: 'session-' + Math.random().toString(36).substring(2), - state: SmtpState.FINISHED, - mailFrom: email.from, - rcptTo: email.to, - emailData: email.toRFC822String(), // Use the proper method to get the full email content - useTLS: false, - connectionEnded: true, - remoteAddress: '127.0.0.1', - clientHostname: '', - secure: false, - authenticated: false, - envelope: { - mailFrom: { address: email.from, args: {} }, - rcptTo: email.to.map(recipient => ({ address: recipient, args: {} })) - } - }); - - return true; - } - }; - - // Create server options - const serverOptions = { - port, - hostname: this.options.hostname, - key, - cert - }; - - // Create and start the SMTP server - const smtpServer = createSmtpServer(mtaRef as any, serverOptions); - this.servers.push(smtpServer); - - // Start the server - await new Promise((resolve, reject) => { - try { - // Leave this empty for now, smtpServer.start() is handled by the SMTPServer class internally - // The server is started when it's created - logger.log('info', `UnifiedEmailServer listening on port ${port}`); - - // Event handlers are managed internally by the SmtpServer class - // No need to access the private server property - - resolve(); - } catch (err) { - if ((err as any).code === 'EADDRINUSE') { - logger.log('error', `Port ${port} is already in use`); - reject(new Error(`Port ${port} is already in use`)); - } else { - logger.log('error', `Error starting server on port ${port}: ${err.message}`); - reject(err); - } - } - }); + + // --- Start Rust SMTP server --- + // Register event handlers for email reception and auth + this.rustBridge.onEmailReceived(async (data) => { + try { + await this.handleRustEmailReceived(data); + } catch (err) { + logger.log('error', `Error handling email from Rust SMTP: ${(err as Error).message}`); + // Send rejection back to Rust + await this.rustBridge.sendEmailProcessingResult({ + correlationId: data.correlationId, + accepted: false, + smtpCode: 451, + smtpMessage: 'Internal processing error', + }); + } + }); + + this.rustBridge.onAuthRequest(async (data) => { + try { + await this.handleRustAuthRequest(data); + } catch (err) { + logger.log('error', `Error handling auth from Rust SMTP: ${(err as Error).message}`); + await this.rustBridge.sendAuthResult({ + correlationId: data.correlationId, + success: false, + message: 'Internal auth error', + }); + } + }); + + // Determine which ports need STARTTLS and which need implicit TLS + const smtpPorts = (this.options.ports as number[]).filter(p => p !== 465); + const securePort = (this.options.ports as number[]).find(p => p === 465); + + const started = await this.rustBridge.startSmtpServer({ + hostname: this.options.hostname, + ports: smtpPorts, + securePort: securePort, + tlsCertPem, + tlsKeyPem, + maxMessageSize: this.options.maxMessageSize || 10 * 1024 * 1024, + maxConnections: this.options.maxConnections || this.options.maxClients || 100, + maxRecipients: 100, + connectionTimeoutSecs: this.options.connectionTimeout ? Math.floor(this.options.connectionTimeout / 1000) : 30, + dataTimeoutSecs: 60, + authEnabled: !!this.options.auth?.required || !!(this.options.auth?.users?.length), + maxAuthFailures: 3, + socketTimeoutSecs: this.options.socketTimeout ? Math.floor(this.options.socketTimeout / 1000) : 300, + processingTimeoutSecs: 30, + rateLimits: this.options.rateLimits ? { + maxConnectionsPerIp: this.options.rateLimits.global?.maxConnectionsPerIP || 50, + maxMessagesPerSender: this.options.rateLimits.global?.maxMessagesPerMinute || 100, + maxAuthFailuresPerIp: this.options.rateLimits.global?.maxAuthFailuresPerIP || 5, + windowSecs: 60, + } : undefined, + }); + + if (!started) { + throw new Error('Failed to start Rust SMTP server'); } - + + logger.log('info', `Rust SMTP server listening on ports: ${smtpPorts.join(', ')}${securePort ? ` + ${securePort} (TLS)` : ''}`); logger.log('info', 'UnifiedEmailServer started successfully'); this.emit('started'); } catch (error) { @@ -587,6 +540,14 @@ export class UnifiedEmailServer extends EventEmitter { logger.log('info', 'Stopping UnifiedEmailServer'); try { + // Stop the Rust SMTP server first + try { + await this.rustBridge.stopSmtpServer(); + logger.log('info', 'Rust SMTP server stopped'); + } catch (err) { + logger.log('warn', `Error stopping Rust SMTP server: ${(err as Error).message}`); + } + // Clear the servers array - servers will be garbage collected this.servers = []; @@ -623,11 +584,112 @@ export class UnifiedEmailServer extends EventEmitter { throw error; } } - - - - - + + // ----------------------------------------------------------------------- + // Rust SMTP server event handlers + // ----------------------------------------------------------------------- + + /** + * Handle an emailReceived event from the Rust SMTP server. + * Decodes the email data, processes it through the routing system, + * and sends back the result via the correlation-ID callback. + */ + private async handleRustEmailReceived(data: IEmailReceivedEvent): Promise { + const { correlationId, mailFrom, rcptTo, remoteAddr, clientHostname, secure, authenticatedUser } = data; + + logger.log('info', `Rust SMTP received email from=${mailFrom} to=${rcptTo.join(',')} remote=${remoteAddr}`); + + try { + // Decode the email data + let rawMessageBuffer: Buffer; + if (data.data.type === 'inline' && data.data.base64) { + rawMessageBuffer = Buffer.from(data.data.base64, 'base64'); + } else if (data.data.type === 'file' && data.data.path) { + rawMessageBuffer = plugins.fs.readFileSync(data.data.path); + // Clean up temp file + try { + plugins.fs.unlinkSync(data.data.path); + } catch { + // Ignore cleanup errors + } + } else { + throw new Error('Invalid email data transport'); + } + + // Build a session-like object for processEmailByMode + const session: IExtendedSmtpSession = { + id: data.sessionId || 'rust-' + Math.random().toString(36).substring(2), + state: SmtpState.FINISHED, + mailFrom: mailFrom, + rcptTo: rcptTo, + emailData: rawMessageBuffer.toString('utf8'), + useTLS: secure, + connectionEnded: false, + remoteAddress: remoteAddr, + clientHostname: clientHostname || '', + secure: secure, + authenticated: !!authenticatedUser, + envelope: { + mailFrom: { address: mailFrom, args: {} }, + rcptTo: rcptTo.map(addr => ({ address: addr, args: {} })), + }, + }; + + if (authenticatedUser) { + session.user = { username: authenticatedUser }; + } + + // Process the email through the routing system + await this.processEmailByMode(rawMessageBuffer, session); + + // Send acceptance back to Rust + await this.rustBridge.sendEmailProcessingResult({ + correlationId, + accepted: true, + smtpCode: 250, + smtpMessage: '2.0.0 Message accepted for delivery', + }); + } catch (err) { + logger.log('error', `Failed to process email from Rust SMTP: ${(err as Error).message}`); + await this.rustBridge.sendEmailProcessingResult({ + correlationId, + accepted: false, + smtpCode: 550, + smtpMessage: `5.0.0 Processing failed: ${(err as Error).message}`, + }); + } + } + + /** + * Handle an authRequest event from the Rust SMTP server. + * Validates credentials and sends back the result. + */ + private async handleRustAuthRequest(data: IAuthRequestEvent): Promise { + const { correlationId, username, password, remoteAddr } = data; + + logger.log('info', `Rust SMTP auth request for user=${username} from=${remoteAddr}`); + + // Check against configured users + const users = this.options.auth?.users || []; + const matched = users.find( + u => u.username === username && u.password === password + ); + + if (matched) { + await this.rustBridge.sendAuthResult({ + correlationId, + success: true, + }); + } else { + logger.log('warn', `Auth failed for user=${username} from=${remoteAddr}`); + await this.rustBridge.sendAuthResult({ + correlationId, + success: false, + message: 'Invalid credentials', + }); + } + } + /** * Verify inbound email security (DKIM/SPF/DMARC) using the Rust bridge. * Falls back gracefully if the bridge is not running. diff --git a/ts/security/classes.rustsecuritybridge.ts b/ts/security/classes.rustsecuritybridge.ts index 150d85e..8e5e18d 100644 --- a/ts/security/classes.rustsecuritybridge.ts +++ b/ts/security/classes.rustsecuritybridge.ts @@ -73,6 +73,60 @@ interface IVersionInfo { smtp: string; } +// --- SMTP Server types --- + +interface ISmtpServerConfig { + hostname: string; + ports: number[]; + securePort?: number; + tlsCertPem?: string; + tlsKeyPem?: 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; +} + /** * Type-safe command map for the mailer-bin IPC bridge. */ @@ -128,6 +182,35 @@ type TMailerCommands = { }; result: IEmailSecurityResult; }; + startSmtpServer: { + params: ISmtpServerConfig; + result: { started: boolean }; + }; + stopSmtpServer: { + params: Record; + result: { stopped: boolean; wasRunning?: boolean }; + }; + emailProcessingResult: { + params: { + correlationId: string; + accepted: boolean; + smtpCode?: number; + smtpMessage?: string; + }; + result: { resolved: boolean }; + }; + authResult: { + params: { + correlationId: string; + success: boolean; + message?: string; + }; + result: { resolved: boolean }; + }; + configureRateLimits: { + params: IRateLimitConfig; + result: { configured: boolean }; + }; }; // --------------------------------------------------------------------------- @@ -314,6 +397,85 @@ export class RustSecurityBridge { }): Promise { return this.bridge.sendCommand('verifyEmail', opts); } + + // ----------------------------------------------------------------------- + // 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. + */ + public async startSmtpServer(config: ISmtpServerConfig): Promise { + const result = await this.bridge.sendCommand('startSmtpServer', config); + return result?.started === true; + } + + /** Stop the Rust SMTP server. */ + public async stopSmtpServer(): Promise { + await this.bridge.sendCommand('stopSmtpServer', {} as any); + } + + /** + * 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. + */ + public async sendEmailProcessingResult(opts: { + correlationId: string; + accepted: boolean; + smtpCode?: number; + smtpMessage?: string; + }): Promise { + await this.bridge.sendCommand('emailProcessingResult', opts); + } + + /** + * Send the result of authentication validation back to the Rust SMTP server. + */ + public async sendAuthResult(opts: { + correlationId: string; + success: boolean; + message?: string; + }): Promise { + await this.bridge.sendCommand('authResult', opts); + } + + /** Update rate limit configuration at runtime. */ + public async configureRateLimits(config: IRateLimitConfig): Promise { + 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. + */ + public onEmailReceived(handler: (data: IEmailReceivedEvent) => void): void { + 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. + */ + public onAuthRequest(handler: (data: IAuthRequestEvent) => void): void { + this.bridge.on('management:authRequest', handler); + } + + /** Remove an emailReceived event handler. */ + public offEmailReceived(handler: (data: IEmailReceivedEvent) => void): void { + this.bridge.off('management:emailReceived', handler); + } + + /** Remove an authRequest event handler. */ + public offAuthRequest(handler: (data: IAuthRequestEvent) => void): void { + this.bridge.off('management:authRequest', handler); + } } // Re-export interfaces for consumers @@ -327,4 +489,9 @@ export type { IContentScanResult, IReputationResult as IRustReputationResult, IVersionInfo, + ISmtpServerConfig, + IRateLimitConfig, + IEmailData, + IEmailReceivedEvent, + IAuthRequestEvent, };