@serve.zone/dcrouter 2.12.4

package/dist_ts/mail/routing/classes.dnsmanager.js

@@ -0,0 +1,430 @@
+import * as plugins from '../../plugins.js';
+import * as paths from '../../paths.js';
+import { DKIMCreator } from '../security/classes.dkimcreator.js';
+/**
+ * Manager for DNS-related operations, including record lookups, verification, and generation
+ */
+export class DNSManager {
+    constructor(dkimCreatorArg, options) {
+        this.cache = new Map();
+        this.defaultOptions = {
+            cacheTtl: 300000, // 5 minutes
+            timeout: 5000 // 5 seconds
+        };
+        this.dkimCreator = dkimCreatorArg;
+        if (options) {
+            this.defaultOptions = {
+                ...this.defaultOptions,
+                ...options
+            };
+        }
+        // Ensure the DNS records directory exists
+        plugins.smartfile.fs.ensureDirSync(paths.dnsRecordsDir);
+    }
+    /**
+     * Lookup MX records for a domain
+     * @param domain Domain to look up
+     * @param options Lookup options
+     * @returns Array of MX records sorted by priority
+     */
+    async lookupMx(domain, options) {
+        const lookupOptions = { ...this.defaultOptions, ...options };
+        const cacheKey = `mx:${domain}`;
+        // Check cache first
+        const cached = this.getFromCache(cacheKey);
+        if (cached) {
+            return cached;
+        }
+        try {
+            const records = await this.dnsResolveMx(domain, lookupOptions.timeout);
+            // Sort by priority
+            records.sort((a, b) => a.priority - b.priority);
+            // Cache the result
+            this.setInCache(cacheKey, records, lookupOptions.cacheTtl);
+            return records;
+        }
+        catch (error) {
+            console.error(`Error looking up MX records for ${domain}:`, error);
+            throw new Error(`Failed to lookup MX records for ${domain}: ${error.message}`);
+        }
+    }
+    /**
+     * Lookup TXT records for a domain
+     * @param domain Domain to look up
+     * @param options Lookup options
+     * @returns Array of TXT records
+     */
+    async lookupTxt(domain, options) {
+        const lookupOptions = { ...this.defaultOptions, ...options };
+        const cacheKey = `txt:${domain}`;
+        // Check cache first
+        const cached = this.getFromCache(cacheKey);
+        if (cached) {
+            return cached;
+        }
+        try {
+            const records = await this.dnsResolveTxt(domain, lookupOptions.timeout);
+            // Cache the result
+            this.setInCache(cacheKey, records, lookupOptions.cacheTtl);
+            return records;
+        }
+        catch (error) {
+            console.error(`Error looking up TXT records for ${domain}:`, error);
+            throw new Error(`Failed to lookup TXT records for ${domain}: ${error.message}`);
+        }
+    }
+    /**
+     * Find specific TXT record by subdomain and prefix
+     * @param domain Base domain
+     * @param subdomain Subdomain prefix (e.g., "dkim._domainkey")
+     * @param prefix Record prefix to match (e.g., "v=DKIM1")
+     * @param options Lookup options
+     * @returns Matching TXT record or null if not found
+     */
+    async findTxtRecord(domain, subdomain = '', prefix = '', options) {
+        const fullDomain = subdomain ? `${subdomain}.${domain}` : domain;
+        try {
+            const records = await this.lookupTxt(fullDomain, options);
+            for (const recordArray of records) {
+                // TXT records can be split into chunks, join them
+                const record = recordArray.join('');
+                if (!prefix || record.startsWith(prefix)) {
+                    return record;
+                }
+            }
+            return null;
+        }
+        catch (error) {
+            // Domain might not exist or no TXT records
+            console.log(`No matching TXT record found for ${fullDomain} with prefix ${prefix}`);
+            return null;
+        }
+    }
+    /**
+     * Verify if a domain has a valid SPF record
+     * @param domain Domain to verify
+     * @returns Verification result
+     */
+    async verifySpfRecord(domain) {
+        const result = {
+            record: 'SPF',
+            found: false,
+            valid: false
+        };
+        try {
+            const spfRecord = await this.findTxtRecord(domain, '', 'v=spf1');
+            if (spfRecord) {
+                result.found = true;
+                result.value = spfRecord;
+                // Basic validation - check if it contains all, include, ip4, ip6, or mx mechanisms
+                const isValid = /v=spf1\s+([-~?+]?(all|include:|ip4:|ip6:|mx|a|exists:))/.test(spfRecord);
+                result.valid = isValid;
+                if (!isValid) {
+                    result.error = 'SPF record format is invalid';
+                }
+            }
+            else {
+                result.error = 'No SPF record found';
+            }
+        }
+        catch (error) {
+            result.error = `Error verifying SPF: ${error.message}`;
+        }
+        return result;
+    }
+    /**
+     * Verify if a domain has a valid DKIM record
+     * @param domain Domain to verify
+     * @param selector DKIM selector (usually "mta" in our case)
+     * @returns Verification result
+     */
+    async verifyDkimRecord(domain, selector = 'mta') {
+        const result = {
+            record: 'DKIM',
+            found: false,
+            valid: false
+        };
+        try {
+            const dkimSelector = `${selector}._domainkey`;
+            const dkimRecord = await this.findTxtRecord(domain, dkimSelector, 'v=DKIM1');
+            if (dkimRecord) {
+                result.found = true;
+                result.value = dkimRecord;
+                // Basic validation - check for required fields
+                const hasP = dkimRecord.includes('p=');
+                result.valid = dkimRecord.includes('v=DKIM1') && hasP;
+                if (!result.valid) {
+                    result.error = 'DKIM record is missing required fields';
+                }
+                else if (dkimRecord.includes('p=') && !dkimRecord.match(/p=[a-zA-Z0-9+/]+/)) {
+                    result.valid = false;
+                    result.error = 'DKIM record has invalid public key format';
+                }
+            }
+            else {
+                result.error = `No DKIM record found for selector ${selector}`;
+            }
+        }
+        catch (error) {
+            result.error = `Error verifying DKIM: ${error.message}`;
+        }
+        return result;
+    }
+    /**
+     * Verify if a domain has a valid DMARC record
+     * @param domain Domain to verify
+     * @returns Verification result
+     */
+    async verifyDmarcRecord(domain) {
+        const result = {
+            record: 'DMARC',
+            found: false,
+            valid: false
+        };
+        try {
+            const dmarcDomain = `_dmarc.${domain}`;
+            const dmarcRecord = await this.findTxtRecord(dmarcDomain, '', 'v=DMARC1');
+            if (dmarcRecord) {
+                result.found = true;
+                result.value = dmarcRecord;
+                // Basic validation - check for required fields
+                const hasPolicy = dmarcRecord.includes('p=');
+                result.valid = dmarcRecord.includes('v=DMARC1') && hasPolicy;
+                if (!result.valid) {
+                    result.error = 'DMARC record is missing required fields';
+                }
+            }
+            else {
+                result.error = 'No DMARC record found';
+            }
+        }
+        catch (error) {
+            result.error = `Error verifying DMARC: ${error.message}`;
+        }
+        return result;
+    }
+    /**
+     * Check all email authentication records (SPF, DKIM, DMARC) for a domain
+     * @param domain Domain to check
+     * @param dkimSelector DKIM selector
+     * @returns Object with verification results for each record type
+     */
+    async verifyEmailAuthRecords(domain, dkimSelector = 'mta') {
+        const [spf, dkim, dmarc] = await Promise.all([
+            this.verifySpfRecord(domain),
+            this.verifyDkimRecord(domain, dkimSelector),
+            this.verifyDmarcRecord(domain)
+        ]);
+        return { spf, dkim, dmarc };
+    }
+    /**
+     * Generate a recommended SPF record for a domain
+     * @param domain Domain name
+     * @param options Configuration options for the SPF record
+     * @returns Generated SPF record
+     */
+    generateSpfRecord(domain, options = {}) {
+        const { includeMx = true, includeA = true, includeIps = [], includeSpf = [], policy = 'softfail' } = options;
+        let value = 'v=spf1';
+        if (includeMx) {
+            value += ' mx';
+        }
+        if (includeA) {
+            value += ' a';
+        }
+        // Add IP addresses
+        for (const ip of includeIps) {
+            if (ip.includes(':')) {
+                value += ` ip6:${ip}`;
+            }
+            else {
+                value += ` ip4:${ip}`;
+            }
+        }
+        // Add includes
+        for (const include of includeSpf) {
+            value += ` include:${include}`;
+        }
+        // Add policy
+        const policyMap = {
+            'none': '?all',
+            'neutral': '~all',
+            'softfail': '~all',
+            'fail': '-all',
+            'reject': '-all'
+        };
+        value += ` ${policyMap[policy]}`;
+        return {
+            name: domain,
+            type: 'TXT',
+            value: value
+        };
+    }
+    /**
+     * Generate a recommended DMARC record for a domain
+     * @param domain Domain name
+     * @param options Configuration options for the DMARC record
+     * @returns Generated DMARC record
+     */
+    generateDmarcRecord(domain, options = {}) {
+        const { policy = 'none', subdomainPolicy, pct = 100, rua, ruf, daysInterval = 1 } = options;
+        let value = 'v=DMARC1; p=' + policy;
+        if (subdomainPolicy) {
+            value += `; sp=${subdomainPolicy}`;
+        }
+        if (pct !== 100) {
+            value += `; pct=${pct}`;
+        }
+        if (rua) {
+            value += `; rua=mailto:${rua}`;
+        }
+        if (ruf) {
+            value += `; ruf=mailto:${ruf}`;
+        }
+        if (daysInterval !== 1) {
+            value += `; ri=${daysInterval * 86400}`;
+        }
+        // Add reporting format and ADKIM/ASPF alignment
+        value += '; fo=1; adkim=r; aspf=r';
+        return {
+            name: `_dmarc.${domain}`,
+            type: 'TXT',
+            value: value
+        };
+    }
+    /**
+     * Save DNS record recommendations to a file
+     * @param domain Domain name
+     * @param records DNS records to save
+     */
+    async saveDnsRecommendations(domain, records) {
+        try {
+            const filePath = plugins.path.join(paths.dnsRecordsDir, `${domain}.recommendations.json`);
+            plugins.smartfile.memory.toFsSync(JSON.stringify(records, null, 2), filePath);
+            console.log(`DNS recommendations for ${domain} saved to ${filePath}`);
+        }
+        catch (error) {
+            console.error(`Error saving DNS recommendations for ${domain}:`, error);
+        }
+    }
+    /**
+     * Get cache key value
+     * @param key Cache key
+     * @returns Cached value or undefined if not found or expired
+     */
+    getFromCache(key) {
+        const cached = this.cache.get(key);
+        if (cached && cached.expires > Date.now()) {
+            return cached.data;
+        }
+        // Remove expired entry
+        if (cached) {
+            this.cache.delete(key);
+        }
+        return undefined;
+    }
+    /**
+     * Set cache key value
+     * @param key Cache key
+     * @param data Data to cache
+     * @param ttl TTL in milliseconds
+     */
+    setInCache(key, data, ttl = this.defaultOptions.cacheTtl) {
+        if (ttl <= 0)
+            return; // Don't cache if TTL is disabled
+        this.cache.set(key, {
+            data,
+            expires: Date.now() + ttl
+        });
+    }
+    /**
+     * Clear the DNS cache
+     * @param key Optional specific key to clear, or all cache if not provided
+     */
+    clearCache(key) {
+        if (key) {
+            this.cache.delete(key);
+        }
+        else {
+            this.cache.clear();
+        }
+    }
+    /**
+     * Promise-based wrapper for dns.resolveMx
+     * @param domain Domain to resolve
+     * @param timeout Timeout in milliseconds
+     * @returns Promise resolving to MX records
+     */
+    dnsResolveMx(domain, timeout = 5000) {
+        return new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(() => {
+                reject(new Error(`DNS MX lookup timeout for ${domain}`));
+            }, timeout);
+            plugins.dns.resolveMx(domain, (err, addresses) => {
+                clearTimeout(timeoutId);
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(addresses);
+                }
+            });
+        });
+    }
+    /**
+     * Promise-based wrapper for dns.resolveTxt
+     * @param domain Domain to resolve
+     * @param timeout Timeout in milliseconds
+     * @returns Promise resolving to TXT records
+     */
+    dnsResolveTxt(domain, timeout = 5000) {
+        return new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(() => {
+                reject(new Error(`DNS TXT lookup timeout for ${domain}`));
+            }, timeout);
+            plugins.dns.resolveTxt(domain, (err, records) => {
+                clearTimeout(timeoutId);
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(records);
+                }
+            });
+        });
+    }
+    /**
+     * Generate all recommended DNS records for proper email authentication
+     * @param domain Domain to generate records for
+     * @returns Array of recommended DNS records
+     */
+    async generateAllRecommendedRecords(domain) {
+        const records = [];
+        // Get DKIM record (already created by DKIMCreator)
+        try {
+            // Call the DKIM creator directly
+            const dkimRecord = await this.dkimCreator.getDNSRecordForDomain(domain);
+            records.push(dkimRecord);
+        }
+        catch (error) {
+            console.error(`Error getting DKIM record for ${domain}:`, error);
+        }
+        // Generate SPF record
+        const spfRecord = this.generateSpfRecord(domain, {
+            includeMx: true,
+            includeA: true,
+            policy: 'softfail'
+        });
+        records.push(spfRecord);
+        // Generate DMARC record
+        const dmarcRecord = this.generateDmarcRecord(domain, {
+            policy: 'none', // Start with monitoring mode
+            rua: `dmarc@${domain}` // Replace with appropriate report address
+        });
+        records.push(dmarcRecord);
+        // Save recommendations
+        await this.saveDnsRecommendations(domain, records);
+        return records;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.dnsmanager.js","sourceRoot":"","sources":["../../../ts/mail/routing/classes.dnsmanager.ts"],"names":[],"mappings":"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"}

package/dist_ts/mail/routing/classes.domain.registry.d.ts

@@ -0,0 +1,54 @@
+import type { IEmailDomainConfig } from './interfaces.js';
+/**
+ * Registry for email domain configurations
+ * Provides fast lookups and validation for domains
+ */
+export declare class DomainRegistry {
+    private domains;
+    private defaults;
+    constructor(domainConfigs: IEmailDomainConfig[], defaults?: {
+        dnsMode?: 'forward' | 'internal-dns' | 'external-dns';
+        dkim?: IEmailDomainConfig['dkim'];
+        rateLimits?: IEmailDomainConfig['rateLimits'];
+    });
+    /**
+     * Get default DKIM configuration
+     */
+    private getDefaultDkimConfig;
+    /**
+     * Apply defaults to a domain configuration
+     */
+    private applyDefaults;
+    /**
+     * Check if a domain is registered
+     */
+    isDomainRegistered(domain: string): boolean;
+    /**
+     * Check if an email address belongs to a registered domain
+     */
+    isEmailRegistered(email: string): boolean;
+    /**
+     * Get domain configuration
+     */
+    getDomainConfig(domain: string): IEmailDomainConfig | undefined;
+    /**
+     * Get domain configuration for an email address
+     */
+    getEmailDomainConfig(email: string): IEmailDomainConfig | undefined;
+    /**
+     * Extract domain from email address
+     */
+    private extractDomain;
+    /**
+     * Get all registered domains
+     */
+    getAllDomains(): string[];
+    /**
+     * Get all domain configurations
+     */
+    getAllConfigs(): IEmailDomainConfig[];
+    /**
+     * Get domains by DNS mode
+     */
+    getDomainsByMode(mode: 'forward' | 'internal-dns' | 'external-dns'): IEmailDomainConfig[];
+}

package/dist_ts/mail/routing/classes.domain.registry.js

@@ -0,0 +1,118 @@
+import { logger } from '../../logger.js';
+/**
+ * Registry for email domain configurations
+ * Provides fast lookups and validation for domains
+ */
+export class DomainRegistry {
+    constructor(domainConfigs, defaults) {
+        this.domains = new Map();
+        // Set defaults
+        this.defaults = {
+            dnsMode: defaults?.dnsMode || 'external-dns',
+            ...this.getDefaultDkimConfig(),
+            ...defaults?.dkim,
+            rateLimits: defaults?.rateLimits
+        };
+        // Process and store domain configurations
+        for (const config of domainConfigs) {
+            const processedConfig = this.applyDefaults(config);
+            this.domains.set(config.domain.toLowerCase(), processedConfig);
+            logger.log('info', `Registered domain: ${config.domain} with DNS mode: ${processedConfig.dnsMode}`);
+        }
+    }
+    /**
+     * Get default DKIM configuration
+     */
+    getDefaultDkimConfig() {
+        return {
+            selector: 'default',
+            keySize: 2048,
+            rotateKeys: false,
+            rotationInterval: 90
+        };
+    }
+    /**
+     * Apply defaults to a domain configuration
+     */
+    applyDefaults(config) {
+        return {
+            ...config,
+            dnsMode: config.dnsMode || this.defaults.dnsMode,
+            dkim: {
+                ...this.getDefaultDkimConfig(),
+                ...this.defaults,
+                ...config.dkim
+            },
+            rateLimits: {
+                ...this.defaults.rateLimits,
+                ...config.rateLimits,
+                outbound: {
+                    ...this.defaults.rateLimits?.outbound,
+                    ...config.rateLimits?.outbound
+                },
+                inbound: {
+                    ...this.defaults.rateLimits?.inbound,
+                    ...config.rateLimits?.inbound
+                }
+            }
+        };
+    }
+    /**
+     * Check if a domain is registered
+     */
+    isDomainRegistered(domain) {
+        return this.domains.has(domain.toLowerCase());
+    }
+    /**
+     * Check if an email address belongs to a registered domain
+     */
+    isEmailRegistered(email) {
+        const domain = this.extractDomain(email);
+        if (!domain)
+            return false;
+        return this.isDomainRegistered(domain);
+    }
+    /**
+     * Get domain configuration
+     */
+    getDomainConfig(domain) {
+        return this.domains.get(domain.toLowerCase());
+    }
+    /**
+     * Get domain configuration for an email address
+     */
+    getEmailDomainConfig(email) {
+        const domain = this.extractDomain(email);
+        if (!domain)
+            return undefined;
+        return this.getDomainConfig(domain);
+    }
+    /**
+     * Extract domain from email address
+     */
+    extractDomain(email) {
+        const parts = email.toLowerCase().split('@');
+        if (parts.length !== 2)
+            return null;
+        return parts[1];
+    }
+    /**
+     * Get all registered domains
+     */
+    getAllDomains() {
+        return Array.from(this.domains.keys());
+    }
+    /**
+     * Get all domain configurations
+     */
+    getAllConfigs() {
+        return Array.from(this.domains.values());
+    }
+    /**
+     * Get domains by DNS mode
+     */
+    getDomainsByMode(mode) {
+        return Array.from(this.domains.values()).filter(config => config.dnsMode === mode);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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