@push.rocks/smartmta 6.5.1 → 7.0.0

package/ts/security/classes.ipreputationchecker.ts

@@ -1,7 +1,5 @@
-import * as plugins from '../plugins.js';
-import * as paths from '../paths.js';
 import { logger } from '../logger.js';
-import { hasStorageManagerMethods, type IStorageManagerLike } from '../mail/interfaces.storage.js';
+import type { IStorageManager } from '../mail/interfaces.storage.js';
 import { SecurityLogger, SecurityLogLevel, SecurityEventType } from './classes.securitylogger.js';
 import { RustSecurityBridge } from './classes.rustsecuritybridge.js';
 import { LRUCache } from 'lru-cache';
@@ -54,20 +52,20 @@ export interface IIPReputationOptions {
   highRiskThreshold?: number; // Score below this is high risk
   mediumRiskThreshold?: number; // Score below this is medium risk
   lowRiskThreshold?: number; // Score below this is low risk
-  enableLocalCache?: boolean; // Whether to persist cache to disk (default: true)
+  persistCache?: boolean; // Whether to persist cache through IStorageManager (default: true)
   enableDNSBL?: boolean; // Whether to use DNSBL checks (default: true)
   enableIPInfo?: boolean; // Whether to use IP info service (default: true)
 }
 
 /**
  * IP reputation checker — delegates DNSBL lookups to the Rust security bridge.
- * Retains LRU caching and disk persistence in TypeScript.
+ * Retains an in-memory LRU cache and optionally persists it through managed storage.
  */
 export class IPReputationChecker {
   private static instance: IPReputationChecker;
   private reputationCache: LRUCache<string, IReputationResult>;
   private options: Required<IIPReputationOptions>;
-  private storageManager?: IStorageManagerLike;
+  private storageManager?: IStorageManager;
 
   private static readonly DEFAULT_OPTIONS: Required<IIPReputationOptions> = {
     maxCacheSize: 10000,
@@ -76,12 +74,12 @@ export class IPReputationChecker {
     highRiskThreshold: ReputationThreshold.HIGH_RISK,
     mediumRiskThreshold: ReputationThreshold.MEDIUM_RISK,
     lowRiskThreshold: ReputationThreshold.LOW_RISK,
-    enableLocalCache: true,
+    persistCache: true,
     enableDNSBL: true,
     enableIPInfo: true
   };
 
-  constructor(options: IIPReputationOptions = {}, storageManager?: IStorageManagerLike) {
+  constructor(options: IIPReputationOptions = {}, storageManager?: IStorageManager) {
     this.options = {
       ...IPReputationChecker.DEFAULT_OPTIONS,
       ...options
@@ -94,14 +92,14 @@ export class IPReputationChecker {
       ttl: this.options.cacheTTL,
     });
 
-    if (this.options.enableLocalCache) {
+    if (this.options.persistCache) {
       this.loadCache().catch(error => {
         logger.log('error', `Failed to load IP reputation cache during initialization: ${error.message}`);
       });
     }
   }
 
-  public static getInstance(options: IIPReputationOptions = {}, storageManager?: IStorageManagerLike): IPReputationChecker {
+  public static getInstance(options: IIPReputationOptions = {}, storageManager?: IStorageManager): IPReputationChecker {
     if (!IPReputationChecker.instance) {
       IPReputationChecker.instance = new IPReputationChecker(options, storageManager);
     }
@@ -146,7 +144,7 @@ export class IPReputationChecker {
 
       this.reputationCache.set(ip, result);
 
-      if (this.options.enableLocalCache) {
+      if (this.options.persistCache) {
         this.saveCache().catch(error => {
           logger.log('error', `Failed to save IP reputation cache: ${error.message}`);
         });
@@ -208,87 +206,25 @@ export class IPReputationChecker {
   }
 
   private async saveCache(): Promise<void> {
-    try {
-      const entries = Array.from(this.reputationCache.entries()).map(([ip, data]) => ({
-        ip,
-        data
-      }));
-
-      if (entries.length === 0) {
-        return;
-      }
-
-      const cacheData = JSON.stringify(entries);
-
-      if (hasStorageManagerMethods(this.storageManager, ['set'])) {
-        await this.storageManager.set('/security/ip-reputation-cache.json', cacheData);
-        logger.log('info', `Saved ${entries.length} IP reputation cache entries to StorageManager`);
-      } else {
-        const cacheDir = plugins.path.join(paths.dataDir, 'security');
-        await plugins.smartfs.directory(cacheDir).recursive().create();
-        const cacheFile = plugins.path.join(cacheDir, 'ip_reputation_cache.json');
-        await plugins.smartfs.file(cacheFile).write(cacheData);
-        logger.log('info', `Saved ${entries.length} IP reputation cache entries to disk`);
-      }
-    } catch (error) {
-      logger.log('error', `Failed to save IP reputation cache: ${error.message}`);
-    }
+    if (!this.storageManager) return;
+    const entries = Array.from(this.reputationCache.entries()).map(([ip, data]) => ({ ip, data }));
+    if (entries.length === 0) return;
+    await this.storageManager.set('/security/ip-reputation-cache.json', JSON.stringify(entries));
+    logger.log('info', `Saved ${entries.length} IP reputation cache entries`);
   }
 
   private async loadCache(): Promise<void> {
-    try {
-      let cacheData: string | null = null;
-      let fromFilesystem = false;
-
-      if (hasStorageManagerMethods(this.storageManager, ['get', 'set'])) {
-        try {
-          cacheData = await this.storageManager.get('/security/ip-reputation-cache.json');
-
-          if (!cacheData) {
-            const cacheFile = plugins.path.join(paths.dataDir, 'security', 'ip_reputation_cache.json');
-            if (plugins.fs.existsSync(cacheFile)) {
-              logger.log('info', 'Migrating IP reputation cache from filesystem to StorageManager');
-              cacheData = plugins.fs.readFileSync(cacheFile, 'utf8');
-              fromFilesystem = true;
-              await this.storageManager.set('/security/ip-reputation-cache.json', cacheData);
-              logger.log('info', 'IP reputation cache migrated to StorageManager successfully');
-              try {
-                plugins.fs.unlinkSync(cacheFile);
-                logger.log('info', 'Old cache file removed after migration');
-              } catch (deleteError) {
-                logger.log('warn', `Could not delete old cache file: ${deleteError.message}`);
-              }
-            }
-          }
-        } catch (error) {
-          logger.log('error', `Error loading from StorageManager: ${error.message}`);
-        }
-      } else {
-        const cacheFile = plugins.path.join(paths.dataDir, 'security', 'ip_reputation_cache.json');
-        if (plugins.fs.existsSync(cacheFile)) {
-          cacheData = plugins.fs.readFileSync(cacheFile, 'utf8');
-          fromFilesystem = true;
-        }
-      }
-
-      if (cacheData) {
-        const entries = JSON.parse(cacheData);
-        const now = Date.now();
-        const validEntries = entries.filter(entry => {
-          const age = now - entry.data.timestamp;
-          return age < this.options.cacheTTL;
-        });
-
-        for (const entry of validEntries) {
-          this.reputationCache.set(entry.ip, entry.data);
-        }
-
-        const source = fromFilesystem ? 'disk' : 'StorageManager';
-        logger.log('info', `Loaded ${validEntries.length} IP reputation cache entries from ${source}`);
-      }
-    } catch (error) {
-      logger.log('error', `Failed to load IP reputation cache: ${error.message}`);
+    if (!this.storageManager) return;
+    const cacheData = await this.storageManager.get('/security/ip-reputation-cache.json');
+    if (!cacheData) return;
+
+    const entries = JSON.parse(cacheData);
+    const now = Date.now();
+    const validEntries = entries.filter((entry) => now - entry.data.timestamp < this.options.cacheTTL);
+    for (const entry of validEntries) {
+      this.reputationCache.set(entry.ip, entry.data);
     }
+    logger.log('info', `Loaded ${validEntries.length} IP reputation cache entries`);
   }
 
   public static getRiskLevel(score: number): 'high' | 'medium' | 'low' | 'trusted' {
@@ -303,11 +239,11 @@ export class IPReputationChecker {
     }
   }
 
-  public updateStorageManager(storageManager: IStorageManagerLike): void {
+  public updateStorageManager(storageManager: IStorageManager): void {
     this.storageManager = storageManager;
     logger.log('info', 'IPReputationChecker storage manager updated');
 
-    if (this.options.enableLocalCache && this.reputationCache.size > 0) {
+    if (this.options.persistCache && this.reputationCache.size > 0) {
       this.saveCache().catch(error => {
         logger.log('error', `Failed to save cache to new storage manager: ${error.message}`);
       });

package/ts/security/classes.rustsecuritybridge.ts

@@ -159,6 +159,7 @@ interface ISmtpServerConfig {
   additionalTlsCerts?: Array<{ domains: string[]; certPem: string; keyPem: string }>;
   maxMessageSize?: number;
   maxConnections?: number;
+  maxConcurrentMessages?: number;
   maxRecipients?: number;
   connectionTimeoutSecs?: number;
   dataTimeoutSecs?: number;
@@ -183,9 +184,8 @@ interface IRateLimitConfig {
 }
 
 interface IEmailData {
-  type: 'inline' | 'file';
-  base64?: string;
-  path?: string;
+  type: 'inline';
+  base64: string;
 }
 
 interface IEmailReceivedEvent {