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