@serve.zone/dcrouter 11.14.0 → 11.16.0

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

@@ -0,0 +1,279 @@
+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);
+        // Prevent unbounded cache growth
+        if (this.normalizedMacCache.size > 10000) {
+            const iterator = this.normalizedMacCache.keys();
+            for (let i = 0; i < 1000; i++) {
+                this.normalizedMacCache.delete(iterator.next().value);
+            }
+        }
+        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/remoteingress/classes.remoteingress-manager.d.ts

@@ -0,0 +1,94 @@
+import type { StorageManager } from '../storage/classes.storagemanager.js';
+import type { IRemoteIngress, IDcRouterRouteConfig } from '../../dist_ts_interfaces/data/remoteingress.js';
+/**
+ * Manages CRUD for remote ingress edge registrations.
+ * Persists edge configs via StorageManager and provides
+ * the allowed edges list for the Rust hub.
+ */
+export declare class RemoteIngressManager {
+    private storageManager;
+    private edges;
+    private routes;
+    constructor(storageManager: StorageManager);
+    /**
+     * Load all edge registrations from storage into memory.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Store the current route configs for port derivation.
+     */
+    setRoutes(routes: IDcRouterRouteConfig[]): void;
+    /**
+     * Derive listen ports for an edge from routes tagged with remoteIngress.enabled.
+     * When a route specifies edgeFilter, only edges whose id or tags match get that route's ports.
+     * When edgeFilter is absent, the route applies to all edges.
+     */
+    derivePortsForEdge(edgeId: string, edgeTags?: string[]): number[];
+    /**
+     * Derive UDP listen ports for an edge from routes with transport 'udp' or 'all'.
+     * These ports need UDP listeners on the edge (e.g. for QUIC/HTTP3).
+     */
+    deriveUdpPortsForEdge(edgeId: string, edgeTags?: string[]): number[];
+    /**
+     * Get the effective listen ports for an edge.
+     * Manual ports are always included. Auto-derived ports are added (union) when autoDerivePorts is true.
+     */
+    getEffectiveListenPorts(edge: IRemoteIngress): number[];
+    /**
+     * Get the effective UDP listen ports for an edge.
+     * Manual UDP ports are always included. Auto-derived UDP ports are added when autoDerivePorts is true.
+     */
+    getEffectiveListenPortsUdp(edge: IRemoteIngress): number[];
+    /**
+     * Get manual and derived port breakdown for an edge (used in API responses).
+     * Derived ports exclude any ports already present in the manual list.
+     */
+    getPortBreakdown(edge: IRemoteIngress): {
+        manual: number[];
+        derived: number[];
+    };
+    /**
+     * Create a new edge registration.
+     */
+    createEdge(name: string, listenPorts?: number[], tags?: string[], autoDerivePorts?: boolean): Promise<IRemoteIngress>;
+    /**
+     * Get an edge by ID.
+     */
+    getEdge(id: string): IRemoteIngress | undefined;
+    /**
+     * Get all edge registrations.
+     */
+    getAllEdges(): IRemoteIngress[];
+    /**
+     * Update an edge registration.
+     */
+    updateEdge(id: string, updates: {
+        name?: string;
+        listenPorts?: number[];
+        autoDerivePorts?: boolean;
+        enabled?: boolean;
+        tags?: string[];
+    }): Promise<IRemoteIngress | null>;
+    /**
+     * Delete an edge registration.
+     */
+    deleteEdge(id: string): Promise<boolean>;
+    /**
+     * Regenerate the secret for an edge.
+     */
+    regenerateSecret(id: string): Promise<string | null>;
+    /**
+     * Verify an edge's secret using constant-time comparison.
+     */
+    verifySecret(id: string, secret: string): boolean;
+    /**
+     * Get the list of allowed edges (enabled only) for the Rust hub.
+     * Includes listenPortsUdp when routes with transport 'udp' or 'all' are present.
+     */
+    getAllowedEdges(): Array<{
+        id: string;
+        secret: string;
+        listenPorts: number[];
+        listenPortsUdp?: number[];
+    }>;
+}