@push.rocks/smartmta 5.1.2 → 5.2.0

package/dist_ts/security/classes.contentscanner.js

@@ -0,0 +1,338 @@
+import * as plugins from '../plugins.js';
+import * as paths from '../paths.js';
+import { logger } from '../logger.js';
+import { Email } from '../mail/core/classes.email.js';
+import { SecurityLogger, SecurityLogLevel, SecurityEventType } from './classes.securitylogger.js';
+import { RustSecurityBridge } from './classes.rustsecuritybridge.js';
+import { LRUCache } from 'lru-cache';
+/**
+ * Threat categories
+ */
+export var ThreatCategory;
+(function (ThreatCategory) {
+    ThreatCategory["SPAM"] = "spam";
+    ThreatCategory["PHISHING"] = "phishing";
+    ThreatCategory["MALWARE"] = "malware";
+    ThreatCategory["EXECUTABLE"] = "executable";
+    ThreatCategory["SUSPICIOUS_LINK"] = "suspicious_link";
+    ThreatCategory["MALICIOUS_MACRO"] = "malicious_macro";
+    ThreatCategory["XSS"] = "xss";
+    ThreatCategory["SENSITIVE_DATA"] = "sensitive_data";
+    ThreatCategory["BLACKLISTED_CONTENT"] = "blacklisted_content";
+    ThreatCategory["CUSTOM_RULE"] = "custom_rule";
+})(ThreatCategory || (ThreatCategory = {}));
+/**
+ * Content Scanner for detecting malicious email content
+ */
+export class ContentScanner {
+    static instance;
+    scanCache;
+    options;
+    /**
+     * Default options for the content scanner
+     */
+    static DEFAULT_OPTIONS = {
+        maxCacheSize: 10000,
+        cacheTTL: 24 * 60 * 60 * 1000, // 24 hours
+        scanSubject: true,
+        scanBody: true,
+        scanAttachments: true,
+        maxAttachmentSizeToScan: 10 * 1024 * 1024, // 10MB
+        scanAttachmentNames: true,
+        blockExecutables: true,
+        blockMacros: true,
+        customRules: [],
+        minThreatScore: 30, // Minimum score to consider content as a threat
+        highThreatScore: 70 // Score above which content is considered high threat
+    };
+    /**
+     * Constructor for the ContentScanner
+     * @param options Configuration options
+     */
+    constructor(options = {}) {
+        // Merge with default options
+        this.options = {
+            ...ContentScanner.DEFAULT_OPTIONS,
+            ...options
+        };
+        // Initialize cache
+        this.scanCache = new LRUCache({
+            max: this.options.maxCacheSize,
+            ttl: this.options.cacheTTL,
+        });
+        logger.log('info', 'ContentScanner initialized');
+    }
+    /**
+     * Get the singleton instance of the scanner
+     * @param options Configuration options
+     * @returns Singleton scanner instance
+     */
+    static getInstance(options = {}) {
+        if (!ContentScanner.instance) {
+            ContentScanner.instance = new ContentScanner(options);
+        }
+        return ContentScanner.instance;
+    }
+    /**
+     * Scan an email for malicious content.
+     * Delegates text/subject/html/filename pattern scanning to Rust.
+     * Binary attachment scanning (PE headers, VBA macros) stays in TS.
+     * @param email The email to scan
+     * @returns Scan result
+     */
+    async scanEmail(email) {
+        try {
+            // Generate a cache key from the email
+            const cacheKey = this.generateCacheKey(email);
+            // Check cache first
+            const cachedResult = this.scanCache.get(cacheKey);
+            if (cachedResult) {
+                logger.log('info', `Using cached scan result for email ${email.getMessageId()}`);
+                return cachedResult;
+            }
+            // Delegate text/subject/html/filename scanning to Rust
+            const bridge = RustSecurityBridge.getInstance();
+            const rustResult = await bridge.scanContent({
+                subject: this.options.scanSubject ? email.subject : undefined,
+                textBody: this.options.scanBody ? email.text : undefined,
+                htmlBody: this.options.scanBody ? email.html : undefined,
+                attachmentNames: this.options.scanAttachmentNames
+                    ? email.attachments?.map(a => a.filename) ?? []
+                    : [],
+            });
+            const result = {
+                isClean: true,
+                threatScore: rustResult.threatScore,
+                threatType: rustResult.threatType ?? undefined,
+                threatDetails: rustResult.threatDetails ?? undefined,
+                scannedElements: rustResult.scannedElements,
+                timestamp: Date.now(),
+            };
+            // Attachment binary scanning stays in TS (PE headers, macro detection)
+            if (this.options.scanAttachments && email.attachments?.length > 0) {
+                for (const attachment of email.attachments) {
+                    this.scanAttachmentBinary(attachment, result);
+                }
+            }
+            // Apply custom rules (TS-only, runtime-configured)
+            this.applyCustomRules(email, result);
+            // Determine if the email is clean based on threat score
+            result.isClean = result.threatScore < this.options.minThreatScore;
+            // Save to cache
+            this.scanCache.set(cacheKey, result);
+            // Log high threat findings
+            if (result.threatScore >= this.options.highThreatScore) {
+                this.logHighThreatFound(email, result);
+            }
+            else if (!result.isClean) {
+                this.logThreatFound(email, result);
+            }
+            return result;
+        }
+        catch (error) {
+            logger.log('error', `Error scanning email: ${error.message}`, {
+                messageId: email.getMessageId(),
+                error: error.stack
+            });
+            // Return a safe default with error indication
+            return {
+                isClean: true,
+                threatScore: 0,
+                scannedElements: ['error'],
+                timestamp: Date.now(),
+                threatType: 'scan_error',
+                threatDetails: `Scan error: ${error.message}`
+            };
+        }
+    }
+    /**
+     * Generate a cache key from an email
+     * @param email The email to generate a key for
+     * @returns Cache key
+     */
+    generateCacheKey(email) {
+        // Use message ID if available
+        if (email.getMessageId()) {
+            return `email:${email.getMessageId()}`;
+        }
+        // Fallback to a hash of key content
+        const contentToHash = [
+            email.from,
+            email.subject || '',
+            email.text?.substring(0, 1000) || '',
+            email.html?.substring(0, 1000) || '',
+            email.attachments?.length || 0
+        ].join(':');
+        return `email:${plugins.crypto.createHash('sha256').update(contentToHash).digest('hex')}`;
+    }
+    /**
+     * Scan attachment binary content for PE headers and VBA macros.
+     * This stays in TS because it accesses raw Buffer data (too large for IPC).
+     * @param attachment The attachment to scan
+     * @param result The scan result to update
+     */
+    scanAttachmentBinary(attachment, result) {
+        if (!attachment.content) {
+            return;
+        }
+        // Skip large attachments
+        if (attachment.content.length > this.options.maxAttachmentSizeToScan) {
+            return;
+        }
+        const filename = attachment.filename.toLowerCase();
+        // Check for PE headers (Windows executables disguised with non-.exe extensions)
+        if (attachment.content.length > 64 &&
+            attachment.content[0] === 0x4D &&
+            attachment.content[1] === 0x5A) { // 'MZ' header
+            result.threatScore += 80;
+            result.threatType = ThreatCategory.EXECUTABLE;
+            result.threatDetails = `Attachment contains executable code: ${filename}`;
+            return;
+        }
+        // Check for VBA macro indicators in Office documents
+        if (this.options.blockMacros && this.likelyContainsMacros(attachment)) {
+            result.threatScore += 60;
+            result.threatType = ThreatCategory.MALICIOUS_MACRO;
+            result.threatDetails = `Attachment appears to contain macros: ${filename}`;
+        }
+    }
+    /**
+     * Apply custom rules (runtime-configured patterns) to the email.
+     * These stay in TS because they are configured at runtime.
+     * @param email The email to check
+     * @param result The scan result to update
+     */
+    applyCustomRules(email, result) {
+        if (!this.options.customRules.length) {
+            return;
+        }
+        const textsToCheck = [];
+        if (email.subject)
+            textsToCheck.push(email.subject);
+        if (email.text)
+            textsToCheck.push(email.text);
+        if (email.html)
+            textsToCheck.push(email.html);
+        for (const rule of this.options.customRules) {
+            const pattern = rule.pattern instanceof RegExp ? rule.pattern : new RegExp(rule.pattern, 'i');
+            for (const text of textsToCheck) {
+                if (pattern.test(text)) {
+                    result.threatScore += rule.score;
+                    result.threatType = rule.type;
+                    result.threatDetails = rule.description;
+                    return;
+                }
+            }
+        }
+    }
+    /**
+     * Extract text from a binary buffer for scanning
+     * @param buffer Binary content
+     * @returns Extracted text (may be partial)
+     */
+    extractTextFromBuffer(buffer) {
+        try {
+            // Limit the amount we convert to avoid memory issues
+            const sampleSize = Math.min(buffer.length, 100 * 1024); // 100KB max sample
+            const sample = buffer.slice(0, sampleSize);
+            // Try to convert to string, filtering out non-printable chars
+            return sample.toString('utf8')
+                .replace(/[\x00-\x09\x0B-\x1F\x7F-\x9F]/g, '') // Remove control chars
+                .replace(/\uFFFD/g, ''); // Remove replacement char
+        }
+        catch (error) {
+            logger.log('warn', `Error extracting text from buffer: ${error.message}`);
+            return '';
+        }
+    }
+    /**
+     * Check if an Office document likely contains macros
+     * @param attachment The attachment to check
+     * @returns Whether the file likely contains macros
+     */
+    likelyContainsMacros(attachment) {
+        const content = this.extractTextFromBuffer(attachment.content);
+        const macroIndicators = [
+            /vbaProject\.bin/i,
+            /Microsoft VBA/i,
+            /\bVBA\b/,
+            /Auto_Open/i,
+            /AutoExec/i,
+            /DocumentOpen/i,
+            /AutoOpen/i,
+            /\bExecute\(/i,
+            /\bShell\(/i,
+            /\bCreateObject\(/i
+        ];
+        for (const indicator of macroIndicators) {
+            if (indicator.test(content)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Log a high threat finding to the security logger
+     * @param email The email containing the threat
+     * @param result The scan result
+     */
+    logHighThreatFound(email, result) {
+        SecurityLogger.getInstance().logEvent({
+            level: SecurityLogLevel.ERROR,
+            type: SecurityEventType.MALWARE,
+            message: `High threat content detected in email from ${email.from} to ${email.to.join(', ')}`,
+            details: {
+                messageId: email.getMessageId(),
+                threatType: result.threatType,
+                threatDetails: result.threatDetails,
+                threatScore: result.threatScore,
+                scannedElements: result.scannedElements,
+                subject: email.subject
+            },
+            success: false,
+            domain: email.getFromDomain()
+        });
+    }
+    /**
+     * Log a threat finding to the security logger
+     * @param email The email containing the threat
+     * @param result The scan result
+     */
+    logThreatFound(email, result) {
+        SecurityLogger.getInstance().logEvent({
+            level: SecurityLogLevel.WARN,
+            type: SecurityEventType.SPAM,
+            message: `Suspicious content detected in email from ${email.from} to ${email.to.join(', ')}`,
+            details: {
+                messageId: email.getMessageId(),
+                threatType: result.threatType,
+                threatDetails: result.threatDetails,
+                threatScore: result.threatScore,
+                scannedElements: result.scannedElements,
+                subject: email.subject
+            },
+            success: false,
+            domain: email.getFromDomain()
+        });
+    }
+    /**
+     * Get threat level description based on score
+     * @param score Threat score
+     * @returns Threat level description
+     */
+    static getThreatLevel(score) {
+        if (score < 20) {
+            return 'none';
+        }
+        else if (score < 40) {
+            return 'low';
+        }
+        else if (score < 70) {
+            return 'medium';
+        }
+        else {
+            return 'high';
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.contentscanner.js","sourceRoot":"","sources":["../../ts/security/classes.contentscanner.ts"],"names":[],"mappings":"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"}

package/dist_ts/security/classes.ipreputationchecker.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Reputation check result information
+ */
+export interface IReputationResult {
+    score: number;
+    isSpam: boolean;
+    isProxy: boolean;
+    isTor: boolean;
+    isVPN: boolean;
+    country?: string;
+    asn?: string;
+    org?: string;
+    blacklists?: string[];
+    timestamp: number;
+    error?: string;
+}
+/**
+ * Reputation threshold scores
+ */
+export declare enum ReputationThreshold {
+    HIGH_RISK = 20,// Score below this is considered high risk
+    MEDIUM_RISK = 50,// Score below this is considered medium risk
+    LOW_RISK = 80
+}
+/**
+ * IP type classifications
+ */
+export declare enum IPType {
+    RESIDENTIAL = "residential",
+    DATACENTER = "datacenter",
+    PROXY = "proxy",
+    TOR = "tor",
+    VPN = "vpn",
+    UNKNOWN = "unknown"
+}
+/**
+ * Options for the IP Reputation Checker
+ */
+export interface IIPReputationOptions {
+    maxCacheSize?: number;
+    cacheTTL?: number;
+    dnsblServers?: string[];
+    highRiskThreshold?: number;
+    mediumRiskThreshold?: number;
+    lowRiskThreshold?: number;
+    enableLocalCache?: boolean;
+    enableDNSBL?: boolean;
+    enableIPInfo?: boolean;
+}
+/**
+ * IP reputation checker — delegates DNSBL lookups to the Rust security bridge.
+ * Retains LRU caching and disk persistence in TypeScript.
+ */
+export declare class IPReputationChecker {
+    private static instance;
+    private reputationCache;
+    private options;
+    private storageManager?;
+    private static readonly DEFAULT_OPTIONS;
+    constructor(options?: IIPReputationOptions, storageManager?: any);
+    static getInstance(options?: IIPReputationOptions, storageManager?: any): IPReputationChecker;
+    /**
+     * Check an IP address's reputation via the Rust bridge
+     */
+    checkReputation(ip: string): Promise<IReputationResult>;
+    private createErrorResult;
+    private isValidIPAddress;
+    private logReputationCheck;
+    private saveCache;
+    private loadCache;
+    static getRiskLevel(score: number): 'high' | 'medium' | 'low' | 'trusted';
+    updateStorageManager(storageManager: any): void;
+}