@serve.zone/dcrouter 2.12.4

package/dist_ts/ts/mail/security/classes.dmarcverifier.js

@@ -0,0 +1,365 @@
+import * as plugins from '../../plugins.js';
+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 {
+    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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"}

package/dist_ts/ts/mail/security/classes.spfverifier.d.ts

@@ -0,0 +1,103 @@
+import type { Email } from '../core/classes.email.js';
+/**
+ * SPF result qualifiers
+ */
+export declare enum SpfQualifier {
+    PASS = "+",
+    NEUTRAL = "?",
+    SOFTFAIL = "~",
+    FAIL = "-"
+}
+/**
+ * SPF mechanism types
+ */
+export declare enum SpfMechanismType {
+    ALL = "all",
+    INCLUDE = "include",
+    A = "a",
+    MX = "mx",
+    IP4 = "ip4",
+    IP6 = "ip6",
+    EXISTS = "exists",
+    REDIRECT = "redirect",
+    EXP = "exp"
+}
+/**
+ * SPF mechanism definition
+ */
+export interface SpfMechanism {
+    qualifier: SpfQualifier;
+    type: SpfMechanismType;
+    value?: string;
+}
+/**
+ * SPF record parsed data
+ */
+export interface SpfRecord {
+    version: string;
+    mechanisms: SpfMechanism[];
+    modifiers: Record<string, string>;
+}
+/**
+ * SPF verification result
+ */
+export interface SpfResult {
+    result: 'pass' | 'neutral' | 'softfail' | 'fail' | 'temperror' | 'permerror' | 'none';
+    explanation?: string;
+    domain: string;
+    ip: string;
+    record?: string;
+    error?: string;
+}
+/**
+ * Class for verifying SPF records
+ */
+export declare class SpfVerifier {
+    private dnsManager?;
+    private lookupCount;
+    constructor(dnsManager?: any);
+    /**
+     * Parse SPF record from TXT record
+     * @param record SPF TXT record
+     * @returns Parsed SPF record or null if invalid
+     */
+    parseSpfRecord(record: string): SpfRecord | null;
+    /**
+     * Check if IP is in CIDR range
+     * @param ip IP address to check
+     * @param cidr CIDR range
+     * @returns Whether the IP is in the CIDR range
+     */
+    private isIpInCidr;
+    /**
+     * Check if a domain has the specified IP in its A or AAAA records
+     * @param domain Domain to check
+     * @param ip IP address to check
+     * @returns Whether the domain resolves to the IP
+     */
+    private isDomainResolvingToIp;
+    /**
+     * Verify SPF for a given email with IP and helo domain
+     * @param email Email to verify
+     * @param ip Sender IP address
+     * @param heloDomain HELO/EHLO domain used by sender
+     * @returns SPF verification result
+     */
+    verify(email: Email, ip: string, heloDomain: string): Promise<SpfResult>;
+    /**
+     * Check SPF record against IP address
+     * @param spfRecord Parsed SPF record
+     * @param domain Domain being checked
+     * @param ip IP address to check
+     * @returns SPF result
+     */
+    private checkSpfRecord;
+    /**
+     * Check if email passes SPF verification
+     * @param email Email to verify
+     * @param ip Sender IP address
+     * @param heloDomain HELO/EHLO domain used by sender
+     * @returns Whether email passes SPF
+     */
+    verifyAndApply(email: Email, ip: string, heloDomain: string): Promise<boolean>;
+}