Juergen Kunz
b82468ab1e
Phase 3 of the Rust migration: the Rust security bridge is now mandatory and all TypeScript security fallback implementations have been removed. - UnifiedEmailServer.start() throws if Rust bridge fails to start - SpfVerifier gutted to thin wrapper (parseSpfRecord stays in TS) - DKIMVerifier gutted to thin wrapper delegating to bridge.verifyDkim() - IPReputationChecker delegates to bridge.checkIpReputation(), keeps LRU cache - DmarcVerifier keeps alignment logic (works with pre-computed results) - DKIM signing via bridge.signDkim() in all 4 locations - Removed mailauth and ip packages from plugins.ts (~1,200 lines deleted)
366 lines
28 KiB
JavaScript
366 lines
28 KiB
JavaScript
import { logger } from '../../logger.js';
|
|
import { SecurityLogger, SecurityLogLevel, SecurityEventType } from '../../security/index.js';
|
|
/**
|
|
* DMARC policy types
|
|
*/
|
|
export var DmarcPolicy;
|
|
(function (DmarcPolicy) {
|
|
DmarcPolicy["NONE"] = "none";
|
|
DmarcPolicy["QUARANTINE"] = "quarantine";
|
|
DmarcPolicy["REJECT"] = "reject";
|
|
})(DmarcPolicy || (DmarcPolicy = {}));
|
|
/**
|
|
* DMARC alignment modes
|
|
*/
|
|
export var DmarcAlignment;
|
|
(function (DmarcAlignment) {
|
|
DmarcAlignment["RELAXED"] = "r";
|
|
DmarcAlignment["STRICT"] = "s";
|
|
})(DmarcAlignment || (DmarcAlignment = {}));
|
|
/**
|
|
* Class for verifying and enforcing DMARC policies
|
|
*/
|
|
export class DmarcVerifier {
|
|
// DNS Manager reference for verifying records
|
|
dnsManager;
|
|
constructor(dnsManager) {
|
|
this.dnsManager = dnsManager;
|
|
}
|
|
/**
|
|
* Parse a DMARC record from a TXT record string
|
|
* @param record DMARC TXT record string
|
|
* @returns Parsed DMARC record or null if invalid
|
|
*/
|
|
parseDmarcRecord(record) {
|
|
if (!record.startsWith('v=DMARC1')) {
|
|
return null;
|
|
}
|
|
try {
|
|
// Initialize record with default values
|
|
const dmarcRecord = {
|
|
version: 'DMARC1',
|
|
policy: DmarcPolicy.NONE,
|
|
pct: 100,
|
|
adkim: DmarcAlignment.RELAXED,
|
|
aspf: DmarcAlignment.RELAXED
|
|
};
|
|
// Split the record into tag/value pairs
|
|
const parts = record.split(';').map(part => part.trim());
|
|
for (const part of parts) {
|
|
if (!part || !part.includes('='))
|
|
continue;
|
|
const [tag, value] = part.split('=').map(p => p.trim());
|
|
// Process based on tag
|
|
switch (tag.toLowerCase()) {
|
|
case 'v':
|
|
dmarcRecord.version = value;
|
|
break;
|
|
case 'p':
|
|
dmarcRecord.policy = value;
|
|
break;
|
|
case 'sp':
|
|
dmarcRecord.subdomainPolicy = value;
|
|
break;
|
|
case 'pct':
|
|
const pctValue = parseInt(value, 10);
|
|
if (!isNaN(pctValue) && pctValue >= 0 && pctValue <= 100) {
|
|
dmarcRecord.pct = pctValue;
|
|
}
|
|
break;
|
|
case 'adkim':
|
|
dmarcRecord.adkim = value;
|
|
break;
|
|
case 'aspf':
|
|
dmarcRecord.aspf = value;
|
|
break;
|
|
case 'ri':
|
|
const interval = parseInt(value, 10);
|
|
if (!isNaN(interval) && interval > 0) {
|
|
dmarcRecord.reportInterval = interval;
|
|
}
|
|
break;
|
|
case 'fo':
|
|
dmarcRecord.failureOptions = value;
|
|
break;
|
|
case 'rua':
|
|
dmarcRecord.reportUriAggregate = value.split(',').map(uri => {
|
|
if (uri.startsWith('mailto:')) {
|
|
return uri.substring(7).trim();
|
|
}
|
|
return uri.trim();
|
|
});
|
|
break;
|
|
case 'ruf':
|
|
dmarcRecord.reportUriForensic = value.split(',').map(uri => {
|
|
if (uri.startsWith('mailto:')) {
|
|
return uri.substring(7).trim();
|
|
}
|
|
return uri.trim();
|
|
});
|
|
break;
|
|
}
|
|
}
|
|
// Ensure subdomain policy is set if not explicitly provided
|
|
if (!dmarcRecord.subdomainPolicy) {
|
|
dmarcRecord.subdomainPolicy = dmarcRecord.policy;
|
|
}
|
|
return dmarcRecord;
|
|
}
|
|
catch (error) {
|
|
logger.log('error', `Error parsing DMARC record: ${error.message}`, {
|
|
record,
|
|
error: error.message
|
|
});
|
|
return null;
|
|
}
|
|
}
|
|
/**
|
|
* Check if domains are aligned according to DMARC policy
|
|
* @param headerDomain Domain from header (From)
|
|
* @param authDomain Domain from authentication (SPF, DKIM)
|
|
* @param alignment Alignment mode
|
|
* @returns Whether the domains are aligned
|
|
*/
|
|
isDomainAligned(headerDomain, authDomain, alignment) {
|
|
if (!headerDomain || !authDomain) {
|
|
return false;
|
|
}
|
|
// For strict alignment, domains must match exactly
|
|
if (alignment === DmarcAlignment.STRICT) {
|
|
return headerDomain.toLowerCase() === authDomain.toLowerCase();
|
|
}
|
|
// For relaxed alignment, the authenticated domain must be a subdomain of the header domain
|
|
// or the same as the header domain
|
|
const headerParts = headerDomain.toLowerCase().split('.');
|
|
const authParts = authDomain.toLowerCase().split('.');
|
|
// Ensures we have at least two parts (domain and TLD)
|
|
if (headerParts.length < 2 || authParts.length < 2) {
|
|
return false;
|
|
}
|
|
// Get organizational domain (last two parts)
|
|
const headerOrgDomain = headerParts.slice(-2).join('.');
|
|
const authOrgDomain = authParts.slice(-2).join('.');
|
|
return headerOrgDomain === authOrgDomain;
|
|
}
|
|
/**
|
|
* Extract domain from an email address
|
|
* @param email Email address
|
|
* @returns Domain part of the email
|
|
*/
|
|
getDomainFromEmail(email) {
|
|
if (!email)
|
|
return '';
|
|
// Handle name + email format: "John Doe <john@example.com>"
|
|
const matches = email.match(/<([^>]+)>/);
|
|
const address = matches ? matches[1] : email;
|
|
const parts = address.split('@');
|
|
return parts.length > 1 ? parts[1] : '';
|
|
}
|
|
/**
|
|
* Check if DMARC verification should be applied based on percentage
|
|
* @param record DMARC record
|
|
* @returns Whether DMARC verification should be applied
|
|
*/
|
|
shouldApplyDmarc(record) {
|
|
if (record.pct === undefined || record.pct === 100) {
|
|
return true;
|
|
}
|
|
// Apply DMARC randomly based on percentage
|
|
const random = Math.floor(Math.random() * 100) + 1;
|
|
return random <= record.pct;
|
|
}
|
|
/**
|
|
* Determine the action to take based on DMARC policy
|
|
* @param policy DMARC policy
|
|
* @returns Action to take
|
|
*/
|
|
determineAction(policy) {
|
|
switch (policy) {
|
|
case DmarcPolicy.REJECT:
|
|
return 'reject';
|
|
case DmarcPolicy.QUARANTINE:
|
|
return 'quarantine';
|
|
case DmarcPolicy.NONE:
|
|
default:
|
|
return 'pass';
|
|
}
|
|
}
|
|
/**
|
|
* Verify DMARC for an incoming email
|
|
* @param email Email to verify
|
|
* @param spfResult SPF verification result
|
|
* @param dkimResult DKIM verification result
|
|
* @returns DMARC verification result
|
|
*/
|
|
async verify(email, spfResult, dkimResult) {
|
|
const securityLogger = SecurityLogger.getInstance();
|
|
// Initialize result
|
|
const result = {
|
|
hasDmarc: false,
|
|
spfDomainAligned: false,
|
|
dkimDomainAligned: false,
|
|
spfPassed: spfResult.result,
|
|
dkimPassed: dkimResult.result,
|
|
policyEvaluated: DmarcPolicy.NONE,
|
|
actualPolicy: DmarcPolicy.NONE,
|
|
appliedPercentage: 100,
|
|
action: 'pass',
|
|
details: 'DMARC not configured'
|
|
};
|
|
try {
|
|
// Extract From domain
|
|
const fromHeader = email.getFromEmail();
|
|
const fromDomain = this.getDomainFromEmail(fromHeader);
|
|
if (!fromDomain) {
|
|
result.error = 'Invalid From domain';
|
|
return result;
|
|
}
|
|
// Check alignment
|
|
result.spfDomainAligned = this.isDomainAligned(fromDomain, spfResult.domain, DmarcAlignment.RELAXED);
|
|
result.dkimDomainAligned = this.isDomainAligned(fromDomain, dkimResult.domain, DmarcAlignment.RELAXED);
|
|
// Lookup DMARC record
|
|
const dmarcVerificationResult = this.dnsManager ?
|
|
await this.dnsManager.verifyDmarcRecord(fromDomain) :
|
|
{ found: false, valid: false, error: 'DNS Manager not available' };
|
|
// If DMARC record exists and is valid
|
|
if (dmarcVerificationResult.found && dmarcVerificationResult.valid) {
|
|
result.hasDmarc = true;
|
|
// Parse DMARC record
|
|
const parsedRecord = this.parseDmarcRecord(dmarcVerificationResult.value);
|
|
if (parsedRecord) {
|
|
result.record = parsedRecord;
|
|
result.actualPolicy = parsedRecord.policy;
|
|
result.appliedPercentage = parsedRecord.pct || 100;
|
|
// Override alignment modes if specified in record
|
|
if (parsedRecord.adkim) {
|
|
result.dkimDomainAligned = this.isDomainAligned(fromDomain, dkimResult.domain, parsedRecord.adkim);
|
|
}
|
|
if (parsedRecord.aspf) {
|
|
result.spfDomainAligned = this.isDomainAligned(fromDomain, spfResult.domain, parsedRecord.aspf);
|
|
}
|
|
// Determine DMARC compliance
|
|
const spfAligned = result.spfPassed && result.spfDomainAligned;
|
|
const dkimAligned = result.dkimPassed && result.dkimDomainAligned;
|
|
// Email passes DMARC if either SPF or DKIM passes with alignment
|
|
const dmarcPass = spfAligned || dkimAligned;
|
|
// Use record percentage to determine if policy should be applied
|
|
const applyPolicy = this.shouldApplyDmarc(parsedRecord);
|
|
if (!dmarcPass) {
|
|
// DMARC failed, apply policy
|
|
result.policyEvaluated = applyPolicy ? parsedRecord.policy : DmarcPolicy.NONE;
|
|
result.action = this.determineAction(result.policyEvaluated);
|
|
result.details = `DMARC failed: SPF aligned=${spfAligned}, DKIM aligned=${dkimAligned}, policy=${result.policyEvaluated}`;
|
|
}
|
|
else {
|
|
result.policyEvaluated = DmarcPolicy.NONE;
|
|
result.action = 'pass';
|
|
result.details = `DMARC passed: SPF aligned=${spfAligned}, DKIM aligned=${dkimAligned}`;
|
|
}
|
|
}
|
|
else {
|
|
result.error = 'Invalid DMARC record format';
|
|
result.details = 'DMARC record invalid';
|
|
}
|
|
}
|
|
else {
|
|
// No DMARC record found or invalid
|
|
result.details = dmarcVerificationResult.error || 'No DMARC record found';
|
|
}
|
|
// Log the DMARC verification
|
|
securityLogger.logEvent({
|
|
level: result.action === 'pass' ? SecurityLogLevel.INFO : SecurityLogLevel.WARN,
|
|
type: SecurityEventType.DMARC,
|
|
message: result.details,
|
|
domain: fromDomain,
|
|
details: {
|
|
fromDomain,
|
|
spfDomain: spfResult.domain,
|
|
dkimDomain: dkimResult.domain,
|
|
spfPassed: result.spfPassed,
|
|
dkimPassed: result.dkimPassed,
|
|
spfAligned: result.spfDomainAligned,
|
|
dkimAligned: result.dkimDomainAligned,
|
|
dmarcPolicy: result.policyEvaluated,
|
|
action: result.action
|
|
},
|
|
success: result.action === 'pass'
|
|
});
|
|
return result;
|
|
}
|
|
catch (error) {
|
|
logger.log('error', `Error verifying DMARC: ${error.message}`, {
|
|
error: error.message,
|
|
emailId: email.getMessageId()
|
|
});
|
|
result.error = `DMARC verification error: ${error.message}`;
|
|
// Log error
|
|
securityLogger.logEvent({
|
|
level: SecurityLogLevel.ERROR,
|
|
type: SecurityEventType.DMARC,
|
|
message: `DMARC verification failed with error`,
|
|
details: {
|
|
error: error.message,
|
|
emailId: email.getMessageId()
|
|
},
|
|
success: false
|
|
});
|
|
return result;
|
|
}
|
|
}
|
|
/**
|
|
* Apply DMARC policy to an email
|
|
* @param email Email to apply policy to
|
|
* @param dmarcResult DMARC verification result
|
|
* @returns Whether the email should be accepted
|
|
*/
|
|
applyPolicy(email, dmarcResult) {
|
|
// Apply action based on DMARC verification result
|
|
switch (dmarcResult.action) {
|
|
case 'reject':
|
|
// Reject the email
|
|
email.mightBeSpam = true;
|
|
logger.log('warn', `Email rejected due to DMARC policy: ${dmarcResult.details}`, {
|
|
emailId: email.getMessageId(),
|
|
from: email.getFromEmail(),
|
|
subject: email.subject
|
|
});
|
|
return false;
|
|
case 'quarantine':
|
|
// Quarantine the email (mark as spam)
|
|
email.mightBeSpam = true;
|
|
// Add spam header
|
|
if (!email.headers['X-Spam-Flag']) {
|
|
email.headers['X-Spam-Flag'] = 'YES';
|
|
}
|
|
// Add DMARC reason header
|
|
email.headers['X-DMARC-Result'] = dmarcResult.details;
|
|
logger.log('warn', `Email quarantined due to DMARC policy: ${dmarcResult.details}`, {
|
|
emailId: email.getMessageId(),
|
|
from: email.getFromEmail(),
|
|
subject: email.subject
|
|
});
|
|
return true;
|
|
case 'pass':
|
|
default:
|
|
// Accept the email
|
|
// Add DMARC result header for information
|
|
email.headers['X-DMARC-Result'] = dmarcResult.details;
|
|
return true;
|
|
}
|
|
}
|
|
/**
|
|
* End-to-end DMARC verification and policy application
|
|
* This method should be called after SPF and DKIM verification
|
|
* @param email Email to verify
|
|
* @param spfResult SPF verification result
|
|
* @param dkimResult DKIM verification result
|
|
* @returns Whether the email should be accepted
|
|
*/
|
|
async verifyAndApply(email, spfResult, dkimResult) {
|
|
// Verify DMARC
|
|
const dmarcResult = await this.verify(email, spfResult, dkimResult);
|
|
// Apply DMARC policy
|
|
return this.applyPolicy(email, dmarcResult);
|
|
}
|
|
}
|
|
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.dmarcverifier.js","sourceRoot":"","sources":["../../../ts/mail/security/classes.dmarcverifier.ts"],"names":[],"mappings":"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"}
|