@push.rocks/smartmta 5.1.3 → 5.2.1

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

@@ -0,0 +1,62 @@
+/**
+ * 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.
+ * Delegates actual SPF evaluation to the Rust security bridge.
+ * Retains parseSpfRecord() for lightweight local parsing.
+ */
+export declare class SpfVerifier {
+    constructor(_dnsManager?: any);
+    /**
+     * Parse SPF record from TXT record (pure string parsing, no DNS)
+     */
+    parseSpfRecord(record: string): SpfRecord | null;
+}

package/dist_ts/mail/security/classes.spfverifier.js

@@ -0,0 +1,87 @@
+import { logger } from '../../logger.js';
+/**
+ * SPF result qualifiers
+ */
+export var SpfQualifier;
+(function (SpfQualifier) {
+    SpfQualifier["PASS"] = "+";
+    SpfQualifier["NEUTRAL"] = "?";
+    SpfQualifier["SOFTFAIL"] = "~";
+    SpfQualifier["FAIL"] = "-";
+})(SpfQualifier || (SpfQualifier = {}));
+/**
+ * SPF mechanism types
+ */
+export var SpfMechanismType;
+(function (SpfMechanismType) {
+    SpfMechanismType["ALL"] = "all";
+    SpfMechanismType["INCLUDE"] = "include";
+    SpfMechanismType["A"] = "a";
+    SpfMechanismType["MX"] = "mx";
+    SpfMechanismType["IP4"] = "ip4";
+    SpfMechanismType["IP6"] = "ip6";
+    SpfMechanismType["EXISTS"] = "exists";
+    SpfMechanismType["REDIRECT"] = "redirect";
+    SpfMechanismType["EXP"] = "exp";
+})(SpfMechanismType || (SpfMechanismType = {}));
+/**
+ * Class for verifying SPF records.
+ * Delegates actual SPF evaluation to the Rust security bridge.
+ * Retains parseSpfRecord() for lightweight local parsing.
+ */
+export class SpfVerifier {
+    constructor(_dnsManager) {
+        // dnsManager is no longer needed — Rust handles DNS lookups
+    }
+    /**
+     * Parse SPF record from TXT record (pure string parsing, no DNS)
+     */
+    parseSpfRecord(record) {
+        if (!record.startsWith('v=spf1')) {
+            return null;
+        }
+        try {
+            const spfRecord = {
+                version: 'spf1',
+                mechanisms: [],
+                modifiers: {}
+            };
+            const terms = record.split(' ').filter(term => term.length > 0);
+            for (let i = 1; i < terms.length; i++) {
+                const term = terms[i];
+                if (term.includes('=')) {
+                    const [name, value] = term.split('=');
+                    spfRecord.modifiers[name] = value;
+                    continue;
+                }
+                let qualifier = SpfQualifier.PASS;
+                let mechanismText = term;
+                if (term.startsWith('+') || term.startsWith('-') ||
+                    term.startsWith('~') || term.startsWith('?')) {
+                    qualifier = term[0];
+                    mechanismText = term.substring(1);
+                }
+                const colonIndex = mechanismText.indexOf(':');
+                let type;
+                let value;
+                if (colonIndex !== -1) {
+                    type = mechanismText.substring(0, colonIndex);
+                    value = mechanismText.substring(colonIndex + 1);
+                }
+                else {
+                    type = mechanismText;
+                }
+                spfRecord.mechanisms.push({ qualifier, type, value });
+            }
+            return spfRecord;
+        }
+        catch (error) {
+            logger.log('error', `Error parsing SPF record: ${error.message}`, {
+                record,
+                error: error.message
+            });
+            return null;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/mail/security/index.d.ts

@@ -0,0 +1,2 @@
+export * from './classes.dkimcreator.js';
+export * from './classes.spfverifier.js';

package/dist_ts/mail/security/index.js

@@ -0,0 +1,4 @@
+// Email security components
+export * from './classes.dkimcreator.js';
+export * from './classes.spfverifier.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9tYWlsL3NlY3VyaXR5L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDRCQUE0QjtBQUM1QixjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsMEJBQTBCLENBQUMifQ==

package/dist_ts/paths.d.ts

@@ -0,0 +1,14 @@
+export declare const baseDir: string;
+export declare const packageDir: string;
+export declare const distServe: string;
+export declare const dataDir: string;
+export declare const keysDir: string;
+export declare const dnsRecordsDir: string;
+export declare const sentEmailsDir: string;
+export declare const receivedEmailsDir: string;
+export declare const failedEmailsDir: string;
+export declare const logsDir: string;
+export declare const emailTemplatesDir: string;
+export declare const MtaAttachmentsDir: string;
+export declare const configPath: string;
+export declare function ensureDirectories(): Promise<void>;

package/dist_ts/paths.js

@@ -0,0 +1,39 @@
+import * as plugins from './plugins.js';
+// Base directories
+export const baseDir = process.cwd();
+export const packageDir = plugins.path.join(plugins.smartpath.get.dirnameFromImportMetaUrl(import.meta.url), '../');
+export const distServe = plugins.path.join(packageDir, './dist_serve');
+// Configure data directory with environment variable or default to .nogit/data
+const DEFAULT_DATA_PATH = '.nogit/data';
+export const dataDir = process.env.DATA_DIR
+    ? process.env.DATA_DIR
+    : plugins.path.join(baseDir, DEFAULT_DATA_PATH);
+// MTA directories 
+export const keysDir = plugins.path.join(dataDir, 'keys');
+export const dnsRecordsDir = plugins.path.join(dataDir, 'dns');
+export const sentEmailsDir = plugins.path.join(dataDir, 'emails', 'sent');
+export const receivedEmailsDir = plugins.path.join(dataDir, 'emails', 'received');
+export const failedEmailsDir = plugins.path.join(dataDir, 'emails', 'failed'); // For failed emails
+export const logsDir = plugins.path.join(dataDir, 'logs'); // For logs
+// Email template directories
+export const emailTemplatesDir = plugins.path.join(dataDir, 'templates', 'email');
+export const MtaAttachmentsDir = plugins.path.join(dataDir, 'attachments'); // For email attachments
+// Configuration path
+export const configPath = process.env.CONFIG_PATH
+    ? process.env.CONFIG_PATH
+    : plugins.path.join(baseDir, 'config.json');
+// Create directories if they don't exist
+export async function ensureDirectories() {
+    // Ensure data directories
+    await plugins.smartfs.directory(dataDir).recursive().create();
+    await plugins.smartfs.directory(keysDir).recursive().create();
+    await plugins.smartfs.directory(dnsRecordsDir).recursive().create();
+    await plugins.smartfs.directory(sentEmailsDir).recursive().create();
+    await plugins.smartfs.directory(receivedEmailsDir).recursive().create();
+    await plugins.smartfs.directory(failedEmailsDir).recursive().create();
+    await plugins.smartfs.directory(logsDir).recursive().create();
+    // Ensure email template directories
+    await plugins.smartfs.directory(emailTemplatesDir).recursive().create();
+    await plugins.smartfs.directory(MtaAttachmentsDir).recursive().create();
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/plugins.d.ts

@@ -0,0 +1,24 @@
+import * as dns from 'dns';
+import * as fs from 'fs';
+import * as crypto from 'crypto';
+import * as http from 'http';
+import * as net from 'net';
+import * as os from 'os';
+import * as path from 'path';
+import * as tls from 'tls';
+import * as util from 'util';
+export { dns, fs, crypto, http, net, os, path, tls, util, };
+import * as smartfile from '@push.rocks/smartfile';
+import { SmartFs } from '@push.rocks/smartfs';
+import * as smartlog from '@push.rocks/smartlog';
+import * as smartmail from '@push.rocks/smartmail';
+import * as smartpath from '@push.rocks/smartpath';
+import * as smartrust from '@push.rocks/smartrust';
+export declare const smartfs: SmartFs;
+export { smartfile, SmartFs, smartlog, smartmail, smartpath, smartrust };
+export type TLogLevel = 'error' | 'warn' | 'info' | 'success' | 'debug';
+import * as tsclass from '@tsclass/tsclass';
+export { tsclass, };
+import mailparser from 'mailparser';
+import * as uuid from 'uuid';
+export { mailparser, uuid, };

package/dist_ts/plugins.js

@@ -0,0 +1,28 @@
+// node native
+import * as dns from 'dns';
+import * as fs from 'fs';
+import * as crypto from 'crypto';
+import * as http from 'http';
+import * as net from 'net';
+import * as os from 'os';
+import * as path from 'path';
+import * as tls from 'tls';
+import * as util from 'util';
+export { dns, fs, crypto, http, net, os, path, tls, util, };
+// @push.rocks scope
+import * as smartfile from '@push.rocks/smartfile';
+import { SmartFs, SmartFsProviderNode } from '@push.rocks/smartfs';
+import * as smartlog from '@push.rocks/smartlog';
+import * as smartmail from '@push.rocks/smartmail';
+import * as smartpath from '@push.rocks/smartpath';
+import * as smartrust from '@push.rocks/smartrust';
+export const smartfs = new SmartFs(new SmartFsProviderNode());
+export { smartfile, SmartFs, smartlog, smartmail, smartpath, smartrust };
+// tsclass scope
+import * as tsclass from '@tsclass/tsclass';
+export { tsclass, };
+// third party
+import mailparser from 'mailparser';
+import * as uuid from 'uuid';
+export { mailparser, uuid, };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYztBQUNkLE9BQU8sS0FBSyxHQUFHLE1BQU0sS0FBSyxDQUFDO0FBQzNCLE9BQU8sS0FBSyxFQUFFLE1BQU0sSUFBSSxDQUFDO0FBQ3pCLE9BQU8sS0FBSyxNQUFNLE1BQU0sUUFBUSxDQUFDO0FBQ2pDLE9BQU8sS0FBSyxJQUFJLE1BQU0sTUFBTSxDQUFDO0FBQzdCLE9BQU8sS0FBSyxHQUFHLE1BQU0sS0FBSyxDQUFDO0FBQzNCLE9BQU8sS0FBSyxFQUFFLE1BQU0sSUFBSSxDQUFDO0FBQ3pCLE9BQU8sS0FBSyxJQUFJLE1BQU0sTUFBTSxDQUFDO0FBQzdCLE9BQU8sS0FBSyxHQUFHLE1BQU0sS0FBSyxDQUFDO0FBQzNCLE9BQU8sS0FBSyxJQUFJLE1BQU0sTUFBTSxDQUFDO0FBRTdCLE9BQU8sRUFDTCxHQUFHLEVBQ0gsRUFBRSxFQUNGLE1BQU0sRUFDTixJQUFJLEVBQ0osR0FBRyxFQUNILEVBQUUsRUFDRixJQUFJLEVBQ0osR0FBRyxFQUNILElBQUksR0FDTCxDQUFBO0FBRUQsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxTQUFTLE1BQU0sdUJBQXVCLENBQUM7QUFDbkQsT0FBTyxFQUFFLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQ25FLE9BQU8sS0FBSyxRQUFRLE1BQU0sc0JBQXNCLENBQUM7QUFDakQsT0FBTyxLQUFLLFNBQVMsTUFBTSx1QkFBdUIsQ0FBQztBQUNuRCxPQUFPLEtBQUssU0FBUyxNQUFNLHVCQUF1QixDQUFDO0FBQ25ELE9BQU8sS0FBSyxTQUFTLE1BQU0sdUJBQXVCLENBQUM7QUFFbkQsTUFBTSxDQUFDLE1BQU0sT0FBTyxHQUFHLElBQUksT0FBTyxDQUFDLElBQUksbUJBQW1CLEVBQUUsQ0FBQyxDQUFDO0FBRTlELE9BQU8sRUFBRSxTQUFTLEVBQUUsT0FBTyxFQUFFLFFBQVEsRUFBRSxTQUFTLEVBQUUsU0FBUyxFQUFFLFNBQVMsRUFBRSxDQUFDO0FBS3pFLGdCQUFnQjtBQUNoQixPQUFPLEtBQUssT0FBTyxNQUFNLGtCQUFrQixDQUFDO0FBRTVDLE9BQU8sRUFDTCxPQUFPLEdBQ1IsQ0FBQTtBQUVELGNBQWM7QUFDZCxPQUFPLFVBQVUsTUFBTSxZQUFZLENBQUM7QUFDcEMsT0FBTyxLQUFLLElBQUksTUFBTSxNQUFNLENBQUM7QUFFN0IsT0FBTyxFQUNMLFVBQVUsRUFDVixJQUFJLEdBQ0wsQ0FBQSJ9

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

@@ -0,0 +1,130 @@
+import { Email } from '../mail/core/classes.email.js';
+/**
+ * Scan result information
+ */
+export interface IScanResult {
+    isClean: boolean;
+    threatType?: string;
+    threatDetails?: string;
+    threatScore: number;
+    scannedElements: string[];
+    timestamp: number;
+}
+/**
+ * Options for content scanner configuration
+ */
+export interface IContentScannerOptions {
+    maxCacheSize?: number;
+    cacheTTL?: number;
+    scanSubject?: boolean;
+    scanBody?: boolean;
+    scanAttachments?: boolean;
+    maxAttachmentSizeToScan?: number;
+    scanAttachmentNames?: boolean;
+    blockExecutables?: boolean;
+    blockMacros?: boolean;
+    customRules?: Array<{
+        pattern: string | RegExp;
+        type: string;
+        score: number;
+        description: string;
+    }>;
+    minThreatScore?: number;
+    highThreatScore?: number;
+}
+/**
+ * Threat categories
+ */
+export declare enum ThreatCategory {
+    SPAM = "spam",
+    PHISHING = "phishing",
+    MALWARE = "malware",
+    EXECUTABLE = "executable",
+    SUSPICIOUS_LINK = "suspicious_link",
+    MALICIOUS_MACRO = "malicious_macro",
+    XSS = "xss",
+    SENSITIVE_DATA = "sensitive_data",
+    BLACKLISTED_CONTENT = "blacklisted_content",
+    CUSTOM_RULE = "custom_rule"
+}
+/**
+ * Content Scanner for detecting malicious email content
+ */
+export declare class ContentScanner {
+    private static instance;
+    private scanCache;
+    private options;
+    /**
+     * Default options for the content scanner
+     */
+    private static readonly DEFAULT_OPTIONS;
+    /**
+     * Constructor for the ContentScanner
+     * @param options Configuration options
+     */
+    constructor(options?: IContentScannerOptions);
+    /**
+     * Get the singleton instance of the scanner
+     * @param options Configuration options
+     * @returns Singleton scanner instance
+     */
+    static getInstance(options?: IContentScannerOptions): ContentScanner;
+    /**
+     * 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
+     */
+    scanEmail(email: Email): Promise<IScanResult>;
+    /**
+     * Generate a cache key from an email
+     * @param email The email to generate a key for
+     * @returns Cache key
+     */
+    private generateCacheKey;
+    /**
+     * 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
+     */
+    private scanAttachmentBinary;
+    /**
+     * 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
+     */
+    private applyCustomRules;
+    /**
+     * Extract text from a binary buffer for scanning
+     * @param buffer Binary content
+     * @returns Extracted text (may be partial)
+     */
+    private extractTextFromBuffer;
+    /**
+     * Check if an Office document likely contains macros
+     * @param attachment The attachment to check
+     * @returns Whether the file likely contains macros
+     */
+    private likelyContainsMacros;
+    /**
+     * Log a high threat finding to the security logger
+     * @param email The email containing the threat
+     * @param result The scan result
+     */
+    private logHighThreatFound;
+    /**
+     * Log a threat finding to the security logger
+     * @param email The email containing the threat
+     * @param result The scan result
+     */
+    private logThreatFound;
+    /**
+     * Get threat level description based on score
+     * @param score Threat score
+     * @returns Threat level description
+     */
+    static getThreatLevel(score: number): 'none' | 'low' | 'medium' | 'high';
+}