431 lines
28 KiB
JavaScript
431 lines
28 KiB
JavaScript
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 {
|
|
dkimCreator;
|
|
cache = new Map();
|
|
defaultOptions = {
|
|
cacheTtl: 300000, // 5 minutes
|
|
timeout: 5000 // 5 seconds
|
|
};
|
|
constructor(dkimCreatorArg, options) {
|
|
this.dkimCreator = dkimCreatorArg;
|
|
if (options) {
|
|
this.defaultOptions = {
|
|
...this.defaultOptions,
|
|
...options
|
|
};
|
|
}
|
|
// Ensure the DNS records directory exists
|
|
plugins.fs.mkdirSync(paths.dnsRecordsDir, { recursive: true });
|
|
}
|
|
/**
|
|
* 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`);
|
|
await plugins.smartfs.file(filePath).write(JSON.stringify(records, null, 2));
|
|
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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"}
|