@serve.zone/dcrouter 32.6.3 → 32.7.0

package/dist_ts/email/classes.email-tls-manager.js

@@ -0,0 +1,321 @@
+import * as plugins from '../plugins.js';
+import { logger } from '../logger.js';
+import { ProxyCertDoc } from '../db/index.js';
+/** Whether `emailConfig.tls` carries operator-managed certificate material. */
+export const hasConfiguredEmailTlsMaterial = (tlsArg) => Boolean(tlsArg?.certPem || tlsArg?.keyPem || tlsArg?.certPath || tlsArg?.keyPath);
+/**
+ * Source for settings persisted without one: the material they served before
+ * the source existed — configured material when present, otherwise the
+ * managed certificate.
+ */
+export const deriveEmailTlsSource = (tlsArg) => hasConfiguredEmailTlsMaterial(tlsArg) ? 'configuredMaterial' : 'managedCertificate';
+/** The `tls` block without certificate material; undefined when nothing else remains. */
+export const withoutConfiguredEmailTlsMaterial = (tlsArg) => {
+    if (!tlsArg)
+        return undefined;
+    const { certPem, keyPem, certPath, keyPath, ...remaining } = tlsArg;
+    return Object.keys(remaining).length > 0 ? remaining : undefined;
+};
+/** The `tls` block handed to SmartMTA: configured options plus the resolved PEM material. */
+export const composeEmailServerTls = (tlsArg, materialArg) => {
+    const options = withoutConfiguredEmailTlsMaterial(tlsArg);
+    if (!materialArg)
+        return options;
+    return { ...options, certPem: materialArg.certPem, keyPem: materialArg.keyPem };
+};
+const describeError = (errorArg) => errorArg instanceof Error ? errorArg.message : String(errorArg);
+const normalizeHostname = (hostnameArg) => hostnameArg.trim().toLowerCase().replace(/\.$/, '');
+/** DNS subject alternative names of a certificate, lowercased. */
+export const getCertificateDnsNames = (certificateArg) => (certificateArg.subjectAltName || '')
+    .split(',')
+    .map((entry) => entry.trim())
+    .filter((entry) => entry.startsWith('DNS:'))
+    .map((entry) => normalizeHostname(entry.slice('DNS:'.length).replace(/^"|"$/g, '')));
+/**
+ * RFC 6125 name matching: exact, or a `*.` wildcard standing for exactly one
+ * left-most label. Implemented here because X509Certificate.checkHost does not
+ * match wildcards on every runtime dcrouter ships on.
+ */
+export const certificateNameCovers = (nameArg, hostnameArg) => {
+    const hostname = normalizeHostname(hostnameArg);
+    if (nameArg === hostname)
+        return true;
+    if (!nameArg.startsWith('*.'))
+        return false;
+    const firstDot = hostname.indexOf('.');
+    return firstDot > 0 && hostname.slice(firstDot + 1) === nameArg.slice(2);
+};
+const findUncoveredHostnames = (namesArg, hostnamesArg) => hostnamesArg.filter((hostname) => !namesArg.some((name) => certificateNameCovers(name, hostname)));
+const parseCertificate = (certPemArg) => new plugins.crypto.X509Certificate(certPemArg);
+const isCurrentlyValid = (certificateArg, nowArg) => certificateArg.validFromDate.getTime() <= nowArg && nowArg < certificateArg.validToDate.getTime();
+/**
+ * Owns the SMTP listener's certificate: resolves it from the selected source
+ * on every listener start and relevant renewal, and reports what is served.
+ *
+ * Resolved material is held here and never written back into the email
+ * configuration, so every resolution reads the source of truth again.
+ */
+export class EmailTlsManager {
+    served;
+    /** Resolve the listener material from the selected source and record it as served. */
+    async resolve(requestArg) {
+        const material = requestArg.source === 'configuredMaterial'
+            ? await this.resolveConfiguredMaterial(requestArg.tls)
+            : await this.resolveManagedCertificate(requestArg.requiredHostnames);
+        const status = this.getStatus(requestArg.requiredHostnames);
+        if (status && status.problems.length > 0) {
+            logger.log('error', `SMTP TLS certificate problem (source=${status.source}, origin=${status.origin ?? 'none'}): ${status.problems.join('; ')}`);
+        }
+        else if (status) {
+            logger.log('info', `SMTP TLS certificate: source=${status.source}, origin=${status.origin}, notAfter=${status.notAfter === null ? 'unknown' : new Date(status.notAfter).toISOString()}, names=[${status.names.join(', ')}]`);
+        }
+        return material;
+    }
+    /**
+     * Push an issued or renewed certificate to the running listener when it can
+     * change what the listener should serve. Returns the applied material.
+     */
+    async applyIssuance(domainArg, listenerArg, requestArg) {
+        if (!(await this.isRelevantIssuance(domainArg, requestArg.requiredHostnames)))
+            return undefined;
+        const material = await this.resolve(requestArg);
+        if (!material)
+            return undefined;
+        listenerArg.updateOptions({ tls: composeEmailServerTls(requestArg.tls, material) });
+        return material;
+    }
+    /** Forget the served certificate (the listener is stopped). */
+    clear() {
+        this.served = undefined;
+    }
+    /**
+     * Whether an issued or renewed certificate can change what the listener
+     * should serve. Only the managed source follows issuance; the stored
+     * certificate is keyed by the requested route domain, so a wildcard or
+     * sibling issuance is matched by the names it covers, not by its key.
+     */
+    async isRelevantIssuance(domainArg, requiredHostnamesArg) {
+        const served = this.served;
+        if (!served || served.source !== 'managedCertificate')
+            return false;
+        const domain = normalizeHostname(domainArg);
+        if (served.storedDomain !== null && normalizeHostname(served.storedDomain) === domain)
+            return true;
+        if (requiredHostnamesArg.some((hostname) => normalizeHostname(hostname) === domain))
+            return true;
+        const stored = await ProxyCertDoc.findByDomain(domainArg);
+        if (!stored?.publicKey)
+            return false;
+        try {
+            const names = getCertificateDnsNames(parseCertificate(stored.publicKey));
+            return findUncoveredHostnames(names, requiredHostnamesArg).length < requiredHostnamesArg.length;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * The best stored certificate for the required hostnames: currently valid
+     * and covering every name first, then valid, then the most names covered,
+     * then the latest expiry. Undefined when none covers any required hostname.
+     */
+    async selectStoredCertificate(requiredHostnamesArg, nowArg = Date.now()) {
+        const candidates = [];
+        for (const doc of await ProxyCertDoc.findAll()) {
+            if (!doc.publicKey || !doc.privateKey)
+                continue;
+            let certificate;
+            try {
+                certificate = parseCertificate(doc.publicKey);
+            }
+            catch {
+                continue;
+            }
+            const names = getCertificateDnsNames(certificate);
+            const uncoveredHostnames = findUncoveredHostnames(names, requiredHostnamesArg);
+            if (uncoveredHostnames.length === requiredHostnamesArg.length)
+                continue;
+            candidates.push({
+                domain: doc.domain,
+                certPem: doc.publicKey,
+                keyPem: doc.privateKey,
+                certificate,
+                names,
+                uncoveredHostnames,
+                currentlyValid: isCurrentlyValid(certificate, nowArg),
+            });
+        }
+        const rank = (candidateArg) => [
+            candidateArg.currentlyValid && candidateArg.uncoveredHostnames.length === 0 ? 1 : 0,
+            candidateArg.currentlyValid ? 1 : 0,
+            -candidateArg.uncoveredHostnames.length,
+            candidateArg.certificate.validToDate.getTime(),
+        ];
+        candidates.sort((left, right) => {
+            const leftRank = rank(left);
+            const rightRank = rank(right);
+            for (let index = 0; index < leftRank.length; index++) {
+                if (leftRank[index] !== rightRank[index])
+                    return rightRank[index] - leftRank[index];
+            }
+            return left.domain.localeCompare(right.domain);
+        });
+        return candidates[0];
+    }
+    /**
+     * Gate for switching to the managed source: refuses unless a currently
+     * valid stored certificate covers every required hostname.
+     */
+    async assertManagedCertificateAvailable(requiredHostnamesArg) {
+        const stored = await this.selectStoredCertificate(requiredHostnamesArg);
+        if (stored?.currentlyValid && stored.uncoveredHostnames.length === 0)
+            return stored;
+        const closest = !stored
+            ? ''
+            : stored.currentlyValid
+                ? ` The closest stored certificate '${stored.domain}' does not cover ${stored.uncoveredHostnames.join(', ')}.`
+                : ` The closest stored certificate '${stored.domain}' is outside its validity period (notAfter ${stored.certificate.validToDate.toISOString()}).`;
+        throw new Error(`Refusing the managedCertificate email TLS source: no currently valid stored certificate covers ${requiredHostnamesArg.join(', ')}.${closest}`);
+    }
+    /**
+     * The served certificate checked against the required hostnames now, so
+     * expiry while running shows up without a new resolution.
+     */
+    getStatus(requiredHostnamesArg, nowArg = Date.now()) {
+        const served = this.served;
+        if (!served)
+            return undefined;
+        const problems = [...served.materialProblems];
+        const certificate = served.certificate;
+        if (certificate) {
+            const notBefore = certificate.validFromDate.getTime();
+            const notAfter = certificate.validToDate.getTime();
+            if (nowArg >= notAfter) {
+                problems.push(`certificate expired at ${new Date(notAfter).toISOString()}`);
+            }
+            else if (nowArg < notBefore) {
+                problems.push(`certificate is not valid before ${new Date(notBefore).toISOString()}`);
+            }
+            const uncovered = findUncoveredHostnames(served.names, requiredHostnamesArg);
+            if (uncovered.length > 0) {
+                problems.push(`certificate does not cover ${uncovered.join(', ')}`);
+            }
+        }
+        return {
+            source: served.source,
+            origin: served.origin,
+            names: [...served.names],
+            notBefore: certificate ? certificate.validFromDate.getTime() : null,
+            notAfter: certificate ? certificate.validToDate.getTime() : null,
+            requiredHostnames: [...requiredHostnamesArg],
+            problems,
+            checkedAt: nowArg,
+        };
+    }
+    /**
+     * Operator-managed material. Paths that cannot be read FAIL listener
+     * startup: continuing without TLS is what once produced a cleartext
+     * submission port, so a broken explicit configuration must be impossible
+     * to miss.
+     */
+    async resolveConfiguredMaterial(tlsArg) {
+        let material;
+        if (tlsArg?.certPem && tlsArg.keyPem) {
+            material = { certPem: tlsArg.certPem, keyPem: tlsArg.keyPem, origin: 'inline PEM' };
+        }
+        else if (tlsArg?.certPath || tlsArg?.keyPath) {
+            if (!tlsArg.certPath || !tlsArg.keyPath) {
+                throw new Error('emailConfig.tls requires both certPath and keyPath when either is configured');
+            }
+            let certPem;
+            let keyPem;
+            try {
+                certPem = await plugins.fs.promises.readFile(tlsArg.certPath, 'utf8');
+                keyPem = await plugins.fs.promises.readFile(tlsArg.keyPath, 'utf8');
+            }
+            catch (error) {
+                throw new Error(`Unable to read the configured SMTP TLS material (certPath=${tlsArg.certPath}, keyPath=${tlsArg.keyPath}): ${describeError(error)}`);
+            }
+            if (!certPem.trim() || !keyPem.trim()) {
+                throw new Error(`The configured SMTP TLS material is empty (certPath=${tlsArg.certPath}, keyPath=${tlsArg.keyPath})`);
+            }
+            material = { certPem, keyPem, origin: `configured paths (${tlsArg.certPath})` };
+        }
+        else if (tlsArg?.certPem || tlsArg?.keyPem) {
+            throw new Error('emailConfig.tls requires both certPem and keyPem when either is configured');
+        }
+        if (!material) {
+            this.served = {
+                source: 'configuredMaterial',
+                origin: null,
+                storedDomain: null,
+                certificate: null,
+                names: [],
+                materialProblems: ['the configuredMaterial source is selected but emailConfig.tls carries no certificate material'],
+            };
+            return undefined;
+        }
+        const materialProblems = [];
+        let certificate = null;
+        try {
+            certificate = parseCertificate(material.certPem);
+        }
+        catch (error) {
+            materialProblems.push(`certificate cannot be parsed: ${describeError(error)}`);
+        }
+        if (certificate) {
+            materialProblems.push(...this.checkKeyPair(certificate, material.keyPem));
+        }
+        this.served = {
+            source: 'configuredMaterial',
+            origin: material.origin,
+            storedDomain: null,
+            certificate,
+            names: certificate ? getCertificateDnsNames(certificate) : [],
+            materialProblems,
+        };
+        return material;
+    }
+    async resolveManagedCertificate(requiredHostnamesArg) {
+        let stored;
+        let lookupProblem;
+        try {
+            stored = await this.selectStoredCertificate(requiredHostnamesArg);
+        }
+        catch (error) {
+            lookupProblem = `stored certificates cannot be read: ${describeError(error)}`;
+        }
+        if (!stored) {
+            this.served = {
+                source: 'managedCertificate',
+                origin: null,
+                storedDomain: null,
+                certificate: null,
+                names: [],
+                materialProblems: [lookupProblem ?? `no stored certificate covers ${requiredHostnamesArg.join(', ')}`],
+            };
+            return undefined;
+        }
+        const origin = `stored certificate '${stored.domain}'`;
+        this.served = {
+            source: 'managedCertificate',
+            origin,
+            storedDomain: stored.domain,
+            certificate: stored.certificate,
+            names: stored.names,
+            materialProblems: this.checkKeyPair(stored.certificate, stored.keyPem),
+        };
+        return { certPem: stored.certPem, keyPem: stored.keyPem, origin };
+    }
+    checkKeyPair(certificateArg, keyPemArg) {
+        try {
+            return certificateArg.checkPrivateKey(plugins.crypto.createPrivateKey(keyPemArg))
+                ? []
+                : ['private key does not match the certificate'];
+        }
+        catch (error) {
+            return [`private key cannot be parsed: ${describeError(error)}`];
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.email-tls-manager.js","sourceRoot":"","sources":["../../../ts/email/classes.email-tls-manager.ts"],"names":[],"mappings":"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"}

package/dist_ts/email/index.d.ts

@@ -8,6 +8,7 @@ export * from './reconcile-mail-dns-singleton.js';
 export * from './classes.mail-egress-coordinator.js';
 export * from './classes.mail-edge-eligibility.js';
 export * from './classes.email-settings.manager.js';
+export * from './classes.email-tls-manager.js';
 export * from './classes.gateway-mail-domain.store.js';
 export * from './classes.coremail-gateway.manager.js';
 export * from './classes.coremail-gateway.store.js';

package/dist_ts/email/index.js

@@ -8,6 +8,7 @@ export * from './reconcile-mail-dns-singleton.js';
 export * from './classes.mail-egress-coordinator.js';
 export * from './classes.mail-edge-eligibility.js';
 export * from './classes.email-settings.manager.js';
+export * from './classes.email-tls-manager.js';
 export * from './classes.gateway-mail-domain.store.js';
 export * from './classes.coremail-gateway.manager.js';
 export * from './classes.coremail-gateway.store.js';
@@ -24,4 +25,4 @@ export * from './gateway-mail-domain-authority.js';
 export * from './email-dns-records.js';
 export * from './helpers.email-log-traffic.js';
 export * from './helpers.inbound-security.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9lbWFpbC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLG1DQUFtQyxDQUFDO0FBQ2xELGNBQWMsbUNBQW1DLENBQUM7QUFDbEQsY0FBYyxrQ0FBa0MsQ0FBQztBQUNqRCxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLG1DQUFtQyxDQUFDO0FBQ2xELGNBQWMsc0NBQXNDLENBQUM7QUFDckQsY0FBYyxvQ0FBb0MsQ0FBQztBQUNuRCxjQUFjLHFDQUFxQyxDQUFDO0FBQ3BELGNBQWMsd0NBQXdDLENBQUM7QUFDdkQsY0FBYyx1Q0FBdUMsQ0FBQztBQUN0RCxjQUFjLHFDQUFxQyxDQUFDO0FBQ3BELGNBQWMsdUNBQXVDLENBQUM7QUFDdEQsY0FBYyxpQ0FBaUMsQ0FBQztBQUNoRCxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMsNENBQTRDLENBQUM7QUFDM0QsY0FBYyx1Q0FBdUMsQ0FBQztBQUN0RCxjQUFjLDhCQUE4QixDQUFDO0FBQzdDLGNBQWMsbUNBQW1DLENBQUM7QUFDbEQsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLG1DQUFtQyxDQUFDO0FBQ2xELGNBQWMsb0NBQW9DLENBQUM7QUFDbkQsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLGdDQUFnQyxDQUFDO0FBQy9DLGNBQWMsK0JBQStCLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9lbWFpbC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLG1DQUFtQyxDQUFDO0FBQ2xELGNBQWMsbUNBQW1DLENBQUM7QUFDbEQsY0FBYyxrQ0FBa0MsQ0FBQztBQUNqRCxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLG1DQUFtQyxDQUFDO0FBQ2xELGNBQWMsc0NBQXNDLENBQUM7QUFDckQsY0FBYyxvQ0FBb0MsQ0FBQztBQUNuRCxjQUFjLHFDQUFxQyxDQUFDO0FBQ3BELGNBQWMsZ0NBQWdDLENBQUM7QUFDL0MsY0FBYyx3Q0FBd0MsQ0FBQztBQUN2RCxjQUFjLHVDQUF1QyxDQUFDO0FBQ3RELGNBQWMscUNBQXFDLENBQUM7QUFDcEQsY0FBYyx1Q0FBdUMsQ0FBQztBQUN0RCxjQUFjLGlDQUFpQyxDQUFDO0FBQ2hELGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYyw0Q0FBNEMsQ0FBQztBQUMzRCxjQUFjLHVDQUF1QyxDQUFDO0FBQ3RELGNBQWMsOEJBQThCLENBQUM7QUFDN0MsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsbUNBQW1DLENBQUM7QUFDbEQsY0FBYyxvQ0FBb0MsQ0FBQztBQUNuRCxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsZ0NBQWdDLENBQUM7QUFDL0MsY0FBYywrQkFBK0IsQ0FBQyJ9

package/dist_ts/opsserver/handlers/email-settings.handler.js

@@ -40,10 +40,12 @@ export class EmailSettingsHandler {
         const smtpListenerActive = dcRouter.emailServer
             ? dcRouter.emailServer.isSmtpListenerActive()
             : undefined;
+        const tlsCertificate = dcRouter.getEmailTlsCertificateStatus();
         const manager = dcRouter.emailSettingsManager;
         if (manager) {
             return {
                 ...manager.getPublicSettings(),
+                ...(tlsCertificate ? { tlsCertificate } : {}),
                 outboundEgress,
                 mailerBridgeState,
                 smtpAccountCount,
@@ -64,6 +66,8 @@ export class EmailSettingsHandler {
             portMapping: emailPortConfig?.portMapping ? { ...emailPortConfig.portMapping } : null,
             receivedEmailsPath: emailPortConfig?.receivedEmailsPath || null,
             maxMessageSize: emailConfig?.maxMessageSize ?? null,
+            tlsSource: dcRouter.getEmailTlsSource(),
+            ...(tlsCertificate ? { tlsCertificate } : {}),
             domainCount: emailConfig?.domains?.length || 0,
             routeCount: emailConfig?.routes?.length || 0,
             authUserCount: emailConfig?.auth?.users?.length || 0,
@@ -74,4 +78,4 @@ export class EmailSettingsHandler {
         };
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW1haWwtc2V0dGluZ3MuaGFuZGxlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3RzL29wc3NlcnZlci9oYW5kbGVycy9lbWFpbC1zZXR0aW5ncy5oYW5kbGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sa0JBQWtCLENBQUM7QUFFNUMsT0FBTyxLQUFLLFVBQVUsTUFBTSxpQ0FBaUMsQ0FBQztBQUM5RCxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFFcEQsTUFBTSxPQUFPLG9CQUFvQjtJQUdYO0lBRmIsV0FBVyxHQUFHLElBQUksT0FBTyxDQUFDLFlBQVksQ0FBQyxXQUFXLEVBQUUsQ0FBQztJQUU1RCxZQUFvQixZQUF1QjtRQUF2QixpQkFBWSxHQUFaLFlBQVksQ0FBVztRQUN6QyxJQUFJLENBQUMsWUFBWSxDQUFDLFdBQVcsQ0FBQyxjQUFjLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxDQUFDO1FBQy9ELElBQUksQ0FBQyxnQkFBZ0IsRUFBRSxDQUFDO0lBQzFCLENBQUM7SUFFTyxnQkFBZ0I7UUFDdEIsSUFBSSxDQUFDLFdBQVcsQ0FBQyxlQUFlLENBQzlCLElBQUksT0FBTyxDQUFDLFlBQVksQ0FBQyxZQUFZLENBQ25DLHdCQUF3QixFQUN4QixLQUFLLEVBQUUsT0FBTyxFQUFFLEVBQUU7WUFDaEIsTUFBTSxjQUFjLENBQUMsSUFBSSxDQUFDLFlBQVksRUFBRSxPQUFPLEVBQUUsRUFBRSxLQUFLLEVBQUUsb0JBQTJCLEVBQUUsQ0FBQyxDQUFDO1lBQ3pGLE9BQU8sRUFBRSxRQUFRLEVBQUUsSUFBSSxDQUFDLFdBQVcsRUFBRSxFQUFFLENBQUM7UUFDMUMsQ0FBQyxDQUNGLENBQ0YsQ0FBQztRQUVGLElBQUksQ0FBQyxXQUFXLENBQUMsZUFBZSxDQUM5QixJQUFJLE9BQU8sQ0FBQyxZQUFZLENBQUMsWUFBWSxDQUNuQywyQkFBMkIsRUFDM0IsS0FBSyxFQUFFLE9BQU8sRUFBRSxFQUFFO1lBQ2hCLE1BQU0sSUFBSSxHQUFHLE1BQU0sY0FBYyxDQUFDLElBQUksQ0FBQyxZQUFZLEVBQUUsT0FBTyxFQUFFO2dCQUM1RCxLQUFLLEVBQUUscUJBQTRCO2dCQUNuQyxvQkFBb0IsRUFBRSxJQUFJO2FBQzNCLENBQUMsQ0FBQztZQUNILE1BQU0sT0FBTyxHQUFHLElBQUksQ0FBQyxZQUFZLENBQUMsV0FBVyxDQUFDLG9CQUFvQixDQUFDO1lBQ25FLElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQztnQkFDYixPQUFPLEVBQUUsT0FBTyxFQUFFLEtBQUssRUFBRSxPQUFPLEVBQUUsc0NBQXNDLEVBQUUsQ0FBQztZQUM3RSxDQUFDO1lBQ0QsSUFBSSxDQUFDO2dCQUNILE1BQU0sUUFBUSxHQUFHLE1BQU0sSUFBSSxDQUFDLFlBQVksQ0FBQyxXQUFXLENBQUMseUJBQXlCLENBQzVFLE9BQU8sQ0FBQyxRQUFRLEVBQ2hCLElBQUksQ0FBQyxNQUFNLENBQ1osQ0FBQztnQkFDRixPQUFPLEVBQUUsT0FBTyxFQUFFLElBQUksRUFBRSxRQUFRLEVBQUUsQ0FBQztZQUNyQyxDQUFDO1lBQUMsT0FBTyxHQUFZLEVBQUUsQ0FBQztnQkFDdEIsT0FBTyxFQUFFLE9BQU8sRUFBRSxLQUFLLEVBQUUsT0FBTyxFQUFHLEdBQWEsQ0FBQyxPQUFPLEVBQUUsQ0FBQztZQUM3RCxDQUFDO1FBQ0gsQ0FBQyxDQUNGLENBQ0YsQ0FBQztJQUNKLENBQUM7SUFFTyxXQUFXO1FBQ2pCLE1BQU0sUUFBUSxHQUFHLElBQUksQ0FBQyxZQUFZLENBQUMsV0FBVyxDQUFDO1FBQy9DLE1BQU0sY0FBYyxHQUFHLFFBQVEsQ0FBQyx1QkFBdUIsRUFBRSxDQUFDO1FBQzFELE1BQU0saUJBQWlCLEdBQUcsUUFBUSxDQUFDLFdBQVcsRUFBRSxjQUFjLEVBRWpELENBQUM7UUFDZCxNQUFNLGdCQUFnQixHQUFHLFFBQVEsQ0FBQyxrQkFBa0IsRUFBRSxlQUFlLEVBQUUsSUFBSSxDQUFDLENBQUM7UUFDN0UsTUFBTSxrQkFBa0IsR0FBRyxRQUFRLENBQUMsV0FBVztZQUM3QyxDQUFDLENBQUMsUUFBUSxDQUFDLFdBQVcsQ0FBQyxvQkFBb0IsRUFBRTtZQUM3QyxDQUFDLENBQUMsU0FBUyxDQUFDO1FBQ2QsTUFBTSxPQUFPLEdBQUcsUUFBUSxDQUFDLG9CQUFvQixDQUFDO1FBQzlDLElBQUksT0FBTyxFQUFFLENBQUM7WUFDWixPQUFPO2dCQUNMLEdBQUcsT0FBTyxDQUFDLGlCQUFpQixFQUFFO2dCQUM5QixjQUFjO2dCQUNkLGlCQUFpQjtnQkFDakIsZ0JBQWdCO2dCQUNoQixHQUFHLENBQUMsa0JBQWtCLEtBQUssU0FBUyxDQUFDLENBQUMsQ0FBQyxFQUFFLGtCQUFrQixFQUFFLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQzthQUNwRSxDQUFDO1FBQ0osQ0FBQztRQUNELE1BQU0sV0FBVyxHQUFHLFFBQVEsQ0FBQyxPQUFPLENBQUMsV0FBVyxDQUFDO1FBQ2pELE1BQU0sZUFBZSxHQUFHLFFBQVEsQ0FBQyxPQUFPLENBQUMsZUFBZSxDQUFDO1FBQ3pELE9BQU87WUFDTCxPQUFPLEVBQUUsT0FBTyxDQUFDLFdBQVcsQ0FBQztZQUM3QixRQUFRLEVBQUUsV0FBVyxFQUFFLFFBQVEsSUFBSSxJQUFJO1lBQ3ZDLG9FQUFvRTtZQUNwRSxtRUFBbUU7WUFDbkUsWUFBWSxFQUFFLFFBQVEsQ0FBQyxPQUFPLENBQUMsaUJBQWlCLElBQUksZUFBZTtZQUNuRSxjQUFjO1lBQ2QsaUJBQWlCO1lBQ2pCLEtBQUssRUFBRSxDQUFDLEdBQUcsQ0FBQyxXQUFXLEVBQUUsS0FBSyxJQUFJLEVBQUUsQ0FBQyxDQUFDO1lBQ3RDLFdBQVcsRUFBRSxlQUFlLEVBQUUsV0FBVyxDQUFDLENBQUMsQ0FBQyxFQUFFLEdBQUcsZUFBZSxDQUFDLFdBQVcsRUFBRSxDQUFDLENBQUMsQ0FBQyxJQUFJO1lBQ3JGLGtCQUFrQixFQUFFLGVBQWUsRUFBRSxrQkFBa0IsSUFBSSxJQUFJO1lBQy9ELGNBQWMsRUFBRSxXQUFXLEVBQUUsY0FBYyxJQUFJLElBQUk7WUFDbkQsV0FBVyxFQUFFLFdBQVcsRUFBRSxPQUFPLEVBQUUsTUFBTSxJQUFJLENBQUM7WUFDOUMsVUFBVSxFQUFFLFdBQVcsRUFBRSxNQUFNLEVBQUUsTUFBTSxJQUFJLENBQUM7WUFDNUMsYUFBYSxFQUFFLFdBQVcsRUFBRSxJQUFJLEVBQUUsS0FBSyxFQUFFLE1BQU0sSUFBSSxDQUFDO1lBQ3BELGdCQUFnQjtZQUNoQixHQUFHLENBQUMsa0JBQWtCLEtBQUssU0FBUyxDQUFDLENBQUMsQ0FBQyxFQUFFLGtCQUFrQixFQUFFLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQztZQUNuRSxTQUFTLEVBQUUsQ0FBQztZQUNaLFNBQVMsRUFBRSxpQkFBaUI7U0FDN0IsQ0FBQztJQUNKLENBQUM7Q0FDRiJ9
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_interfaces/data/email-settings.d.ts

@@ -11,6 +11,38 @@ export interface IEmailOutboundEgressStatus {
 }
 /** Lifecycle state of the smartmta Rust mailer bridge. 'failed' and 'restarting' mean mail processing is degraded. */
 export type TEmailBridgeState = 'idle' | 'starting' | 'running' | 'restarting' | 'failed' | 'stopped';
+/**
+ * Where the SMTP listener's certificate (STARTTLS on 25/587, implicit TLS on
+ * the smartmta-terminated secure port) comes from.
+ * - 'managedCertificate': the stored ACME certificate that covers the mail
+ *   hostname and every enabled mail-edge hostname. Configured `emailConfig.tls`
+ *   material is ignored, and is removed when an operator switches to this
+ *   source. Renewals reach the running listener without a restart.
+ * - 'configuredMaterial': the operator-managed `emailConfig.tls` material
+ *   (inline `certPem`/`keyPem`, or `certPath`/`keyPath` read when the listener
+ *   starts). ACME renewals never replace it.
+ * Settings persisted without a source keep their previous behaviour:
+ * 'configuredMaterial' while `emailConfig.tls` carries material, otherwise
+ * 'managedCertificate'.
+ */
+export type TEmailTlsSource = 'managedCertificate' | 'configuredMaterial';
+/** The certificate the running SMTP listener serves, checked at read time. */
+export interface IEmailTlsCertificateStatus {
+    source: TEmailTlsSource;
+    /** Where the served material was read from; null when no material was found. */
+    origin: string | null;
+    /** DNS subject alternative names of the served certificate. */
+    names: string[];
+    /** Epoch milliseconds; null when no parseable certificate is served. */
+    notBefore: number | null;
+    /** Epoch milliseconds; null when no parseable certificate is served. */
+    notAfter: number | null;
+    /** Mail hostname plus every enabled mail-edge hostname the certificate must cover. */
+    requiredHostnames: string[];
+    /** Empty when the served certificate is valid, matches its key and covers every required hostname. */
+    problems: string[];
+    checkedAt: number;
+}
 export interface IEmailPortConfig {
     /** External to internal SMTP port mapping. */
     portMapping?: Record<number, number>;
@@ -31,6 +63,10 @@ export interface IEmailServerSettings {
     portMapping: Record<number, number> | null;
     receivedEmailsPath: string | null;
     maxMessageSize: number | null;
+    /** Effective SMTP certificate source (see TEmailTlsSource for the default of settings persisted without one). */
+    tlsSource: TEmailTlsSource;
+    /** Present when the email server is running: the certificate the SMTP listener serves. */
+    tlsCertificate?: IEmailTlsCertificateStatus;
     domainCount: number;
     routeCount: number;
     authUserCount: number;
@@ -59,6 +95,13 @@ export type TEmailServerSettingsUpdate = {
     portMapping?: Record<number, number> | null;
     receivedEmailsPath?: string | null;
     maxMessageSize?: number | null;
+    /**
+     * Switch the SMTP certificate source. 'managedCertificate' is refused while
+     * no valid stored certificate covers the mail hostname and every enabled
+     * mail-edge hostname; accepting it removes the configured `emailConfig.tls`
+     * material. 'configuredMaterial' is refused while none is persisted.
+     */
+    tlsSource?: TEmailTlsSource;
     /**
      * Exact names of persisted legacy routes to remove (the internal-relay
      * retirement lever). Fails loudly on unknown names and refuses generated

package/dist_ts_web/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@serve.zone/dcrouter',
-    version: '32.6.3',
+    version: '32.7.0',
     description: 'A multifaceted routing service handling mail and SMS delivery functions.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHNfd2ViLzAwX2NvbW1pdGluZm9fZGF0YS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLFVBQVUsR0FBRztJQUN4QixJQUFJLEVBQUUsc0JBQXNCO0lBQzVCLE9BQU8sRUFBRSxRQUFRO0lBQ2pCLFdBQVcsRUFBRSwwRUFBMEU7Q0FDeEYsQ0FBQSJ9

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@serve.zone/dcrouter",
   "private": false,
-  "version": "32.6.3",
+  "version": "32.7.0",
   "description": "A multifaceted routing service handling mail and SMS delivery functions.",
   "type": "module",
   "bin": {
@@ -15,16 +15,16 @@
   "author": "Task Venture Capital GmbH",
   "license": "MIT",
   "devDependencies": {
-    "@git.zone/tsbuild": "^5.0.0",
-    "@git.zone/tsbundle": "^3.0.0",
-    "@git.zone/tsdeno": "^1.12.0",
-    "@git.zone/tsdocker": "^3.9.0",
+    "@git.zone/tsbuild": "^5.1.2",
+    "@git.zone/tsbundle": "^3.1.3",
+    "@git.zone/tsdeno": "^1.15.0",
+    "@git.zone/tsdocker": "^3.11.0",
     "@git.zone/tsrun": "^3.0.2",
-    "@git.zone/tstest": "^6.3.2",
-    "@git.zone/tswatch": "^4.0.2",
+    "@git.zone/tstest": "^7.1.0",
+    "@git.zone/tswatch": "^6.0.1",
     "@push.rocks/smartdb-v2": "npm:@push.rocks/smartdb@2.14.6",
     "@push.rocks/smartdb-v5.2": "npm:@push.rocks/smartdb@5.2.2",
-    "@types/node": "26.6.2",
+    "@types/node": "26.6.3",
     "@types/web-push": "3.6.4"
   },
   "dependencies": {

package/readme.md

@@ -818,11 +818,14 @@ On upgrade, a migration converts legacy plaintext `emailConfig.auth.users` entri
 
 SMTP AUTH is only ever offered on an encrypted transport. A submission port that has no TLS material and no upstream TLS terminator advertises neither `STARTTLS` nor `AUTH`, and refuses an `AUTH` command with `538 5.7.11` — credentials never cross a cleartext channel.
 
-`emailConfig.tls` therefore has to actually reach the SMTP listener. SmartMTA consumes PEM content, so dcrouter resolves it in this order:
+The SMTP listener's certificate therefore has to actually reach it. SmartMTA consumes PEM content and takes one certificate for every name the listener answers, so dcrouter resolves it from one of two sources, chosen by the email server setting `tlsSource`:
 
-1. `emailConfig.tls.certPem` / `keyPem` — inline PEM.
-2. `emailConfig.tls.certPath` / `keyPath` — file paths, read eagerly at startup. Both are required together. A path that cannot be read, or that holds an empty file, **fails startup** rather than silently leaving the listener without TLS.
-3. The stored ACME certificate for `emailConfig.hostname` in the proxy certificate store. Renewals are pushed to the running listener automatically (unless explicit paths are configured, which are never superseded by an ACME renewal for the same name).
+- `managedCertificate` — the stored ACME certificate that covers `emailConfig.hostname` and the `mailHostname` of every enabled mail edge (dcrouter issues it with the domain wildcard included, so one certificate covers them all). Every issuance or renewal of a stored certificate that covers one of those names is pushed to the running listener, including one stored under a wildcard or sibling route domain; SmartMTA restarts only the Rust listener when the PEM material changes.
+- `configuredMaterial` — operator-managed material in `emailConfig.tls`: inline `certPem` / `keyPem`, or `certPath` / `keyPath` read when the listener starts. Both paths are required together; a path that cannot be read, or that holds an empty file, **fails startup** rather than silently leaving the listener without TLS. ACME renewals never replace this material.
+
+Settings stored without a `tlsSource` keep their previous behaviour: `configuredMaterial` while `emailConfig.tls` carries material, otherwise `managedCertificate`. Operators switch with `updateEmailServerSettings { settings: { tlsSource } }`, which restarts the email components in-process. Switching to `managedCertificate` is refused, and the settings stay unchanged, while no currently valid stored certificate covers the mail hostname and every enabled mail-edge hostname; once accepted it removes the configured material from the persisted settings. Switching to `configuredMaterial` is refused while no material is persisted.
+
+`getEmailServerSettings` reports the effective `tlsSource` and, while the listener runs, `tlsCertificate`: where the served material came from, its DNS names, `notBefore` / `notAfter`, the hostnames it must cover, and `problems`. The material is checked on every read, so a certificate that expires while the listener runs, does not cover a required hostname, or does not match its key is listed in `problems`; resolving such material also logs an error.
 
 CoreTraffic terminates public TLS for port 465 and forwards the decrypted stream to the internal SMTP leg, so that leg is plaintext even though the client's channel was encrypted. dcrouter derives those ports from the generated email routes and declares them to SmartMTA as `smtp.tlsTerminatedPorts`, gated on the PROXY-protocol trust dcrouter already requires from `127.0.0.1`/`::1` — so implicit-TLS submission keeps authenticating while the plain ports require `STARTTLS` first.
 

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@serve.zone/dcrouter',
-  version: '32.6.3',
+  version: '32.7.0',
   description: 'A multifaceted routing service handling mail and SMS delivery functions.'
 }