@serve.zone/dcrouter 5.0.2 → 5.0.3

package/dist_ts/radius/classes.vlan.manager.js

@@ -0,0 +1,272 @@
+import * as plugins from '../plugins.js';
+import { logger } from '../logger.js';
+/**
+ * Manages MAC address to VLAN mappings with support for:
+ * - Exact MAC address matching
+ * - OUI (vendor prefix) pattern matching
+ * - Wildcard patterns
+ * - Default VLAN for unknown devices
+ */
+export class VlanManager {
+    mappings = new Map();
+    config;
+    storageManager;
+    // Cache for normalized MAC lookups
+    normalizedMacCache = new Map();
+    constructor(config, storageManager) {
+        this.config = {
+            defaultVlan: config?.defaultVlan ?? 1,
+            allowUnknownMacs: config?.allowUnknownMacs ?? true,
+            storagePrefix: config?.storagePrefix ?? '/radius/vlan-mappings',
+        };
+        this.storageManager = storageManager;
+    }
+    /**
+     * Initialize the VLAN manager and load persisted mappings
+     */
+    async initialize() {
+        if (this.storageManager) {
+            await this.loadMappings();
+        }
+        logger.log('info', `VlanManager initialized with ${this.mappings.size} mappings, default VLAN: ${this.config.defaultVlan}`);
+    }
+    /**
+     * Normalize a MAC address to lowercase with colons
+     * Accepts formats: 00:11:22:33:44:55, 00-11-22-33-44-55, 001122334455
+     */
+    normalizeMac(mac) {
+        // Check cache first
+        const cached = this.normalizedMacCache.get(mac);
+        if (cached) {
+            return cached;
+        }
+        // Remove all separators and convert to lowercase
+        const cleaned = mac.toLowerCase().replace(/[-:]/g, '');
+        // Format with colons
+        const normalized = cleaned.match(/.{1,2}/g)?.join(':') || mac.toLowerCase();
+        // Cache the result
+        this.normalizedMacCache.set(mac, normalized);
+        return normalized;
+    }
+    /**
+     * Check if a MAC address matches a pattern
+     * Supports:
+     * - Exact match: "00:11:22:33:44:55"
+     * - OUI match: "00:11:22" (matches any device with this vendor prefix)
+     * - Wildcard: "*" (matches all)
+     */
+    macMatchesPattern(mac, pattern) {
+        const normalizedMac = this.normalizeMac(mac);
+        const normalizedPattern = this.normalizeMac(pattern);
+        // Wildcard matches all
+        if (pattern === '*') {
+            return true;
+        }
+        // Exact match
+        if (normalizedMac === normalizedPattern) {
+            return true;
+        }
+        // OUI/prefix match (pattern is shorter than full MAC)
+        if (normalizedPattern.length < 17 && normalizedMac.startsWith(normalizedPattern)) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Add or update a MAC to VLAN mapping
+     */
+    async addMapping(mapping) {
+        const normalizedMac = this.normalizeMac(mapping.mac);
+        const now = Date.now();
+        const existingMapping = this.mappings.get(normalizedMac);
+        const fullMapping = {
+            ...mapping,
+            mac: normalizedMac,
+            createdAt: existingMapping?.createdAt || now,
+            updatedAt: now,
+        };
+        this.mappings.set(normalizedMac, fullMapping);
+        // Persist to storage
+        if (this.storageManager) {
+            await this.saveMappings();
+        }
+        logger.log('info', `VLAN mapping ${existingMapping ? 'updated' : 'added'}: ${normalizedMac} -> VLAN ${mapping.vlan}`);
+        return fullMapping;
+    }
+    /**
+     * Remove a MAC to VLAN mapping
+     */
+    async removeMapping(mac) {
+        const normalizedMac = this.normalizeMac(mac);
+        const removed = this.mappings.delete(normalizedMac);
+        if (removed && this.storageManager) {
+            await this.saveMappings();
+            logger.log('info', `VLAN mapping removed: ${normalizedMac}`);
+        }
+        return removed;
+    }
+    /**
+     * Get a specific mapping by MAC
+     */
+    getMapping(mac) {
+        return this.mappings.get(this.normalizeMac(mac));
+    }
+    /**
+     * Get all mappings
+     */
+    getAllMappings() {
+        return Array.from(this.mappings.values());
+    }
+    /**
+     * Determine VLAN assignment for a MAC address
+     * Returns the most specific matching rule (exact > OUI > wildcard > default)
+     */
+    assignVlan(mac) {
+        const normalizedMac = this.normalizeMac(mac);
+        // First, try exact match
+        const exactMatch = this.mappings.get(normalizedMac);
+        if (exactMatch && exactMatch.enabled) {
+            return {
+                assigned: true,
+                vlan: exactMatch.vlan,
+                matchedRule: exactMatch,
+                isDefault: false,
+            };
+        }
+        // Try OUI/prefix matches (sorted by specificity - longer patterns first)
+        const patternMatches = [];
+        for (const mapping of this.mappings.values()) {
+            if (mapping.enabled && mapping.mac !== normalizedMac && this.macMatchesPattern(normalizedMac, mapping.mac)) {
+                patternMatches.push(mapping);
+            }
+        }
+        // Sort by pattern length (most specific first)
+        patternMatches.sort((a, b) => b.mac.length - a.mac.length);
+        if (patternMatches.length > 0) {
+            const bestMatch = patternMatches[0];
+            return {
+                assigned: true,
+                vlan: bestMatch.vlan,
+                matchedRule: bestMatch,
+                isDefault: false,
+            };
+        }
+        // No match - use default VLAN if allowed
+        if (this.config.allowUnknownMacs) {
+            return {
+                assigned: true,
+                vlan: this.config.defaultVlan,
+                isDefault: true,
+            };
+        }
+        // Unknown MAC and not allowed
+        return {
+            assigned: false,
+            vlan: 0,
+            isDefault: false,
+        };
+    }
+    /**
+     * Bulk import mappings
+     */
+    async importMappings(mappings) {
+        let imported = 0;
+        for (const mapping of mappings) {
+            await this.addMapping(mapping);
+            imported++;
+        }
+        logger.log('info', `Imported ${imported} VLAN mappings`);
+        return imported;
+    }
+    /**
+     * Export all mappings
+     */
+    exportMappings() {
+        return this.getAllMappings();
+    }
+    /**
+     * Update configuration
+     */
+    updateConfig(config) {
+        if (config.defaultVlan !== undefined) {
+            this.config.defaultVlan = config.defaultVlan;
+        }
+        if (config.allowUnknownMacs !== undefined) {
+            this.config.allowUnknownMacs = config.allowUnknownMacs;
+        }
+        logger.log('info', `VlanManager config updated: defaultVlan=${this.config.defaultVlan}, allowUnknown=${this.config.allowUnknownMacs}`);
+    }
+    /**
+     * Get current configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Get statistics
+     */
+    getStats() {
+        let exactMatches = 0;
+        let ouiPatterns = 0;
+        let wildcardPatterns = 0;
+        let enabledMappings = 0;
+        for (const mapping of this.mappings.values()) {
+            if (mapping.enabled) {
+                enabledMappings++;
+            }
+            if (mapping.mac === '*') {
+                wildcardPatterns++;
+            }
+            else if (mapping.mac.length < 17) {
+                // OUI patterns are shorter than full MAC (17 chars with colons)
+                ouiPatterns++;
+            }
+            else {
+                exactMatches++;
+            }
+        }
+        return {
+            totalMappings: this.mappings.size,
+            enabledMappings,
+            exactMatches,
+            ouiPatterns,
+            wildcardPatterns,
+        };
+    }
+    /**
+     * Load mappings from storage
+     */
+    async loadMappings() {
+        if (!this.storageManager) {
+            return;
+        }
+        try {
+            const data = await this.storageManager.getJSON(this.config.storagePrefix);
+            if (data && Array.isArray(data)) {
+                for (const mapping of data) {
+                    this.mappings.set(this.normalizeMac(mapping.mac), mapping);
+                }
+                logger.log('info', `Loaded ${data.length} VLAN mappings from storage`);
+            }
+        }
+        catch (error) {
+            logger.log('warn', `Failed to load VLAN mappings from storage: ${error.message}`);
+        }
+    }
+    /**
+     * Save mappings to storage
+     */
+    async saveMappings() {
+        if (!this.storageManager) {
+            return;
+        }
+        try {
+            const mappings = Array.from(this.mappings.values());
+            await this.storageManager.setJSON(this.config.storagePrefix, mappings);
+        }
+        catch (error) {
+            logger.log('error', `Failed to save VLAN mappings to storage: ${error.message}`);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.vlan.manager.js","sourceRoot":"","sources":["../../../ts/radius/classes.vlan.manager.ts"],"names":[],"mappings":"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"}

package/dist_ts/radius/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * RADIUS module for DcRouter
+ *
+ * Provides:
+ * - MAC Authentication Bypass (MAB) for network device authentication
+ * - VLAN assignment based on MAC addresses
+ * - OUI (vendor prefix) pattern matching for device categorization
+ * - RADIUS accounting for session tracking and billing
+ * - Integration with StorageManager for persistence
+ */
+export * from './classes.radius.server.js';
+export * from './classes.vlan.manager.js';
+export * from './classes.accounting.manager.js';

package/dist_ts/radius/index.js

@@ -0,0 +1,14 @@
+/**
+ * RADIUS module for DcRouter
+ *
+ * Provides:
+ * - MAC Authentication Bypass (MAB) for network device authentication
+ * - VLAN assignment based on MAC addresses
+ * - OUI (vendor prefix) pattern matching for device categorization
+ * - RADIUS accounting for session tracking and billing
+ * - Integration with StorageManager for persistence
+ */
+export * from './classes.radius.server.js';
+export * from './classes.vlan.manager.js';
+export * from './classes.accounting.manager.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9yYWRpdXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7OztHQVNHO0FBRUgsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsaUNBQWlDLENBQUMifQ==

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

@@ -0,0 +1,160 @@
+import { Email } from '@push.rocks/smartmta';
+/**
+ * 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;
+    private static readonly MALICIOUS_PATTERNS;
+    private static readonly EXECUTABLE_EXTENSIONS;
+    private static readonly MACRO_DOCUMENT_EXTENSIONS;
+    /**
+     * 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
+     * @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 email subject for threats
+     * @param subject The subject to scan
+     * @param result The scan result to update
+     */
+    private scanSubject;
+    /**
+     * Scan plain text content for threats
+     * @param text The text content to scan
+     * @param result The scan result to update
+     */
+    private scanTextContent;
+    /**
+     * Scan HTML content for threats
+     * @param html The HTML content to scan
+     * @param result The scan result to update
+     */
+    private scanHtmlContent;
+    /**
+     * Scan an attachment for threats
+     * @param attachment The attachment to scan
+     * @param result The scan result to update
+     */
+    private scanAttachment;
+    /**
+     * Extract links from HTML content
+     * @param html HTML content
+     * @returns Array of extracted links
+     */
+    private extractLinksFromHtml;
+    /**
+     * Extract plain text from HTML
+     * @param html HTML content
+     * @returns Extracted text
+     */
+    private extractTextFromHtml;
+    /**
+     * 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
+     * This is a simplified check - real implementation would use specialized libraries
+     * @param attachment The attachment to check
+     * @returns Whether the file likely contains macros
+     */
+    private likelyContainsMacros;
+    /**
+     * Map a pattern category to a threat type
+     * @param category The pattern category
+     * @returns The corresponding threat type
+     */
+    private mapCategoryToThreatType;
+    /**
+     * 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';
+}