@serve.zone/dcrouter 2.12.4 → 5.0.3

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

@@ -0,0 +1,417 @@
+import * as plugins from '../plugins.js';
+import { logger } from '../logger.js';
+/**
+ * Manages RADIUS accounting data including:
+ * - Session tracking (start/stop/interim)
+ * - Data usage tracking (bytes in/out)
+ * - Session history and retention
+ * - Billing reports and summaries
+ */
+export class AccountingManager {
+    activeSessions = new Map();
+    config;
+    storageManager;
+    // Counters for statistics
+    stats = {
+        totalSessionsStarted: 0,
+        totalSessionsStopped: 0,
+        totalInputBytes: 0,
+        totalOutputBytes: 0,
+        interimUpdatesReceived: 0,
+    };
+    constructor(config, storageManager) {
+        this.config = {
+            storagePrefix: config?.storagePrefix ?? '/radius/accounting',
+            retentionDays: config?.retentionDays ?? 30,
+            detailedLogging: config?.detailedLogging ?? false,
+            maxActiveSessions: config?.maxActiveSessions ?? 10000,
+        };
+        this.storageManager = storageManager;
+    }
+    /**
+     * Initialize the accounting manager
+     */
+    async initialize() {
+        if (this.storageManager) {
+            await this.loadActiveSessions();
+        }
+        logger.log('info', `AccountingManager initialized with ${this.activeSessions.size} active sessions`);
+    }
+    /**
+     * Handle accounting start request
+     */
+    async handleAccountingStart(data) {
+        const now = Date.now();
+        const session = {
+            sessionId: data.sessionId,
+            username: data.username,
+            macAddress: data.macAddress,
+            nasIpAddress: data.nasIpAddress,
+            nasPort: data.nasPort,
+            nasPortType: data.nasPortType,
+            nasIdentifier: data.nasIdentifier,
+            vlanId: data.vlanId,
+            framedIpAddress: data.framedIpAddress,
+            calledStationId: data.calledStationId,
+            callingStationId: data.callingStationId,
+            serviceType: data.serviceType,
+            startTime: now,
+            endTime: 0,
+            lastUpdateTime: now,
+            status: 'active',
+            inputOctets: 0,
+            outputOctets: 0,
+            inputPackets: 0,
+            outputPackets: 0,
+            sessionTime: 0,
+        };
+        // Check if we're at capacity
+        if (this.activeSessions.size >= this.config.maxActiveSessions) {
+            // Remove oldest session
+            const oldest = this.findOldestSession();
+            if (oldest) {
+                await this.evictSession(oldest);
+            }
+        }
+        this.activeSessions.set(data.sessionId, session);
+        this.stats.totalSessionsStarted++;
+        if (this.config.detailedLogging) {
+            logger.log('info', `Accounting Start: session=${data.sessionId}, user=${data.username}, NAS=${data.nasIpAddress}`);
+        }
+        // Persist session
+        if (this.storageManager) {
+            await this.persistSession(session);
+        }
+    }
+    /**
+     * Handle accounting interim update request
+     */
+    async handleAccountingUpdate(data) {
+        const session = this.activeSessions.get(data.sessionId);
+        if (!session) {
+            logger.log('warn', `Interim update for unknown session: ${data.sessionId}`);
+            return;
+        }
+        // Update session metrics
+        if (data.inputOctets !== undefined) {
+            session.inputOctets = data.inputOctets;
+        }
+        if (data.outputOctets !== undefined) {
+            session.outputOctets = data.outputOctets;
+        }
+        if (data.inputPackets !== undefined) {
+            session.inputPackets = data.inputPackets;
+        }
+        if (data.outputPackets !== undefined) {
+            session.outputPackets = data.outputPackets;
+        }
+        if (data.sessionTime !== undefined) {
+            session.sessionTime = data.sessionTime;
+        }
+        session.lastUpdateTime = Date.now();
+        this.stats.interimUpdatesReceived++;
+        if (this.config.detailedLogging) {
+            logger.log('debug', `Accounting Interim: session=${data.sessionId}, in=${data.inputOctets}, out=${data.outputOctets}`);
+        }
+        // Update persisted session
+        if (this.storageManager) {
+            await this.persistSession(session);
+        }
+    }
+    /**
+     * Handle accounting stop request
+     */
+    async handleAccountingStop(data) {
+        const session = this.activeSessions.get(data.sessionId);
+        if (!session) {
+            logger.log('warn', `Stop for unknown session: ${data.sessionId}`);
+            return;
+        }
+        // Update final metrics
+        if (data.inputOctets !== undefined) {
+            session.inputOctets = data.inputOctets;
+        }
+        if (data.outputOctets !== undefined) {
+            session.outputOctets = data.outputOctets;
+        }
+        if (data.inputPackets !== undefined) {
+            session.inputPackets = data.inputPackets;
+        }
+        if (data.outputPackets !== undefined) {
+            session.outputPackets = data.outputPackets;
+        }
+        if (data.sessionTime !== undefined) {
+            session.sessionTime = data.sessionTime;
+        }
+        session.endTime = Date.now();
+        session.lastUpdateTime = session.endTime;
+        session.status = 'stopped';
+        session.terminateCause = data.terminateCause;
+        // Update global stats
+        this.stats.totalSessionsStopped++;
+        this.stats.totalInputBytes += session.inputOctets;
+        this.stats.totalOutputBytes += session.outputOctets;
+        if (this.config.detailedLogging) {
+            logger.log('info', `Accounting Stop: session=${data.sessionId}, duration=${session.sessionTime}s, in=${session.inputOctets}, out=${session.outputOctets}`);
+        }
+        // Archive the session
+        if (this.storageManager) {
+            await this.archiveSession(session);
+        }
+        // Remove from active sessions
+        this.activeSessions.delete(data.sessionId);
+    }
+    /**
+     * Get an active session by ID
+     */
+    getSession(sessionId) {
+        return this.activeSessions.get(sessionId);
+    }
+    /**
+     * Get all active sessions
+     */
+    getActiveSessions() {
+        return Array.from(this.activeSessions.values());
+    }
+    /**
+     * Get active sessions by username
+     */
+    getSessionsByUsername(username) {
+        return Array.from(this.activeSessions.values()).filter(s => s.username === username);
+    }
+    /**
+     * Get active sessions by NAS IP
+     */
+    getSessionsByNas(nasIpAddress) {
+        return Array.from(this.activeSessions.values()).filter(s => s.nasIpAddress === nasIpAddress);
+    }
+    /**
+     * Get active sessions by VLAN
+     */
+    getSessionsByVlan(vlanId) {
+        return Array.from(this.activeSessions.values()).filter(s => s.vlanId === vlanId);
+    }
+    /**
+     * Get accounting summary for a time period
+     */
+    async getSummary(startTime, endTime) {
+        // Get archived sessions for the time period
+        const archivedSessions = await this.getArchivedSessions(startTime, endTime);
+        // Combine with active sessions that started within the period
+        const activeSessions = Array.from(this.activeSessions.values()).filter(s => s.startTime >= startTime && s.startTime <= endTime);
+        const allSessions = [...archivedSessions, ...activeSessions];
+        // Calculate summary
+        let totalInputBytes = 0;
+        let totalOutputBytes = 0;
+        let totalSessionTime = 0;
+        const uniqueUsers = new Set();
+        const sessionsByVlan = {};
+        const userTraffic = {};
+        for (const session of allSessions) {
+            totalInputBytes += session.inputOctets;
+            totalOutputBytes += session.outputOctets;
+            totalSessionTime += session.sessionTime;
+            uniqueUsers.add(session.username);
+            if (session.vlanId !== undefined) {
+                sessionsByVlan[session.vlanId] = (sessionsByVlan[session.vlanId] || 0) + 1;
+            }
+            const userBytes = session.inputOctets + session.outputOctets;
+            userTraffic[session.username] = (userTraffic[session.username] || 0) + userBytes;
+        }
+        // Top users by traffic
+        const topUsersByTraffic = Object.entries(userTraffic)
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 10)
+            .map(([username, totalBytes]) => ({ username, totalBytes }));
+        return {
+            periodStart: startTime,
+            periodEnd: endTime,
+            totalSessions: allSessions.length,
+            activeSessions: activeSessions.length,
+            totalInputBytes,
+            totalOutputBytes,
+            totalSessionTime,
+            averageSessionDuration: allSessions.length > 0 ? totalSessionTime / allSessions.length : 0,
+            uniqueUsers: uniqueUsers.size,
+            sessionsByVlan,
+            topUsersByTraffic,
+        };
+    }
+    /**
+     * Get statistics
+     */
+    getStats() {
+        return {
+            activeSessions: this.activeSessions.size,
+            ...this.stats,
+        };
+    }
+    /**
+     * Disconnect a session (admin action)
+     */
+    async disconnectSession(sessionId, reason = 'AdminReset') {
+        const session = this.activeSessions.get(sessionId);
+        if (!session) {
+            return false;
+        }
+        await this.handleAccountingStop({
+            sessionId,
+            terminateCause: reason,
+            sessionTime: Math.floor((Date.now() - session.startTime) / 1000),
+        });
+        return true;
+    }
+    /**
+     * Clean up old archived sessions based on retention policy
+     */
+    async cleanupOldSessions() {
+        if (!this.storageManager) {
+            return 0;
+        }
+        const cutoffTime = Date.now() - this.config.retentionDays * 24 * 60 * 60 * 1000;
+        let deletedCount = 0;
+        try {
+            const keys = await this.storageManager.list(`${this.config.storagePrefix}/archive/`);
+            for (const key of keys) {
+                try {
+                    const session = await this.storageManager.getJSON(key);
+                    if (session && session.endTime > 0 && session.endTime < cutoffTime) {
+                        await this.storageManager.delete(key);
+                        deletedCount++;
+                    }
+                }
+                catch (error) {
+                    // Ignore individual errors
+                }
+            }
+            if (deletedCount > 0) {
+                logger.log('info', `Cleaned up ${deletedCount} old accounting sessions`);
+            }
+        }
+        catch (error) {
+            logger.log('error', `Failed to cleanup old sessions: ${error.message}`);
+        }
+        return deletedCount;
+    }
+    /**
+     * Find the oldest active session
+     */
+    findOldestSession() {
+        let oldestTime = Infinity;
+        let oldestSessionId = null;
+        for (const [sessionId, session] of this.activeSessions) {
+            if (session.lastUpdateTime < oldestTime) {
+                oldestTime = session.lastUpdateTime;
+                oldestSessionId = sessionId;
+            }
+        }
+        return oldestSessionId;
+    }
+    /**
+     * Evict a session from memory
+     */
+    async evictSession(sessionId) {
+        const session = this.activeSessions.get(sessionId);
+        if (session) {
+            session.status = 'terminated';
+            session.terminateCause = 'SessionEvicted';
+            session.endTime = Date.now();
+            if (this.storageManager) {
+                await this.archiveSession(session);
+            }
+            this.activeSessions.delete(sessionId);
+            logger.log('warn', `Evicted session ${sessionId} due to capacity limit`);
+        }
+    }
+    /**
+     * Load active sessions from storage
+     */
+    async loadActiveSessions() {
+        if (!this.storageManager) {
+            return;
+        }
+        try {
+            const keys = await this.storageManager.list(`${this.config.storagePrefix}/active/`);
+            for (const key of keys) {
+                try {
+                    const session = await this.storageManager.getJSON(key);
+                    if (session && session.status === 'active') {
+                        this.activeSessions.set(session.sessionId, session);
+                    }
+                }
+                catch (error) {
+                    // Ignore individual errors
+                }
+            }
+        }
+        catch (error) {
+            logger.log('warn', `Failed to load active sessions: ${error.message}`);
+        }
+    }
+    /**
+     * Persist a session to storage
+     */
+    async persistSession(session) {
+        if (!this.storageManager) {
+            return;
+        }
+        const key = `${this.config.storagePrefix}/active/${session.sessionId}.json`;
+        try {
+            await this.storageManager.setJSON(key, session);
+        }
+        catch (error) {
+            logger.log('error', `Failed to persist session ${session.sessionId}: ${error.message}`);
+        }
+    }
+    /**
+     * Archive a completed session
+     */
+    async archiveSession(session) {
+        if (!this.storageManager) {
+            return;
+        }
+        try {
+            // Remove from active
+            const activeKey = `${this.config.storagePrefix}/active/${session.sessionId}.json`;
+            await this.storageManager.delete(activeKey);
+            // Add to archive with date-based path
+            const date = new Date(session.endTime);
+            const archiveKey = `${this.config.storagePrefix}/archive/${date.getFullYear()}/${String(date.getMonth() + 1).padStart(2, '0')}/${String(date.getDate()).padStart(2, '0')}/${session.sessionId}.json`;
+            await this.storageManager.setJSON(archiveKey, session);
+        }
+        catch (error) {
+            logger.log('error', `Failed to archive session ${session.sessionId}: ${error.message}`);
+        }
+    }
+    /**
+     * Get archived sessions for a time period
+     */
+    async getArchivedSessions(startTime, endTime) {
+        if (!this.storageManager) {
+            return [];
+        }
+        const sessions = [];
+        try {
+            const keys = await this.storageManager.list(`${this.config.storagePrefix}/archive/`);
+            for (const key of keys) {
+                try {
+                    const session = await this.storageManager.getJSON(key);
+                    if (session &&
+                        session.endTime > 0 &&
+                        session.startTime <= endTime &&
+                        session.endTime >= startTime) {
+                        sessions.push(session);
+                    }
+                }
+                catch (error) {
+                    // Ignore individual errors
+                }
+            }
+        }
+        catch (error) {
+            logger.log('warn', `Failed to get archived sessions: ${error.message}`);
+        }
+        return sessions;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.accounting.manager.js","sourceRoot":"","sources":["../../../ts/radius/classes.accounting.manager.ts"],"names":[],"mappings":"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"}

package/dist_ts/radius/classes.radius.server.d.ts

@@ -0,0 +1,171 @@
+import type { StorageManager } from '../storage/index.js';
+import { VlanManager, type IMacVlanMapping, type IVlanManagerConfig } from './classes.vlan.manager.js';
+import { AccountingManager, type IAccountingManagerConfig } from './classes.accounting.manager.js';
+/**
+ * RADIUS client (NAS) configuration
+ */
+export interface IRadiusClient {
+    /** Client name for identification */
+    name: string;
+    /** IP address or CIDR range */
+    ipRange: string;
+    /** Shared secret for this client */
+    secret: string;
+    /** Optional description */
+    description?: string;
+    /** Whether this client is enabled */
+    enabled: boolean;
+}
+/**
+ * RADIUS server configuration
+ */
+export interface IRadiusServerConfig {
+    /** Authentication port (default: 1812) */
+    authPort?: number;
+    /** Accounting port (default: 1813) */
+    acctPort?: number;
+    /** Bind address (default: 0.0.0.0) */
+    bindAddress?: string;
+    /** NAS clients configuration */
+    clients: IRadiusClient[];
+    /** VLAN assignment configuration */
+    vlanAssignment?: IVlanManagerConfig & {
+        /** Static MAC to VLAN mappings */
+        mappings?: Array<Omit<IMacVlanMapping, 'createdAt' | 'updatedAt'>>;
+    };
+    /** Accounting configuration */
+    accounting?: IAccountingManagerConfig & {
+        /** Whether accounting is enabled */
+        enabled: boolean;
+    };
+}
+/**
+ * RADIUS authentication result
+ */
+export interface IRadiusAuthResult {
+    /** Whether authentication was successful */
+    success: boolean;
+    /** Reject reason (if not successful) */
+    rejectReason?: string;
+    /** Reply message to send to client */
+    replyMessage?: string;
+    /** Session timeout in seconds */
+    sessionTimeout?: number;
+    /** Idle timeout in seconds */
+    idleTimeout?: number;
+    /** VLAN to assign */
+    vlanId?: number;
+    /** Framed IP address to assign */
+    framedIpAddress?: string;
+}
+/**
+ * Authentication request data from RADIUS
+ */
+export interface IAuthRequestData {
+    username: string;
+    password?: string;
+    nasIpAddress: string;
+    nasPort?: number;
+    nasPortType?: string;
+    nasIdentifier?: string;
+    calledStationId?: string;
+    callingStationId?: string;
+    serviceType?: string;
+    framedMtu?: number;
+}
+/**
+ * RADIUS Server wrapper that provides:
+ * - MAC Authentication Bypass (MAB) for network devices
+ * - VLAN assignment based on MAC address
+ * - Accounting for session tracking and billing
+ * - Integration with SmartProxy routing
+ */
+export declare class RadiusServer {
+    private radiusServer?;
+    private vlanManager;
+    private accountingManager;
+    private config;
+    private storageManager?;
+    private clientSecrets;
+    private running;
+    private stats;
+    constructor(config: IRadiusServerConfig, storageManager?: StorageManager);
+    /**
+     * Start the RADIUS server
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the RADIUS server
+     */
+    stop(): Promise<void>;
+    /**
+     * Handle authentication request
+     */
+    private handleAuthentication;
+    /**
+     * Handle accounting request
+     */
+    private handleAccounting;
+    /**
+     * Perform MAC Authentication Bypass
+     */
+    private performMabAuthentication;
+    /**
+     * Extract MAC address from authentication data
+     */
+    private extractMacAddress;
+    /**
+     * Check if a string looks like a MAC address
+     */
+    private looksLikeMac;
+    /**
+     * Normalize MAC address format
+     */
+    private normalizeMac;
+    /**
+     * Build client secrets map from configuration
+     */
+    private buildClientSecretsMap;
+    /**
+     * Get default secret for unknown clients
+     */
+    private getDefaultSecret;
+    /**
+     * Add a RADIUS client
+     */
+    addClient(client: IRadiusClient): Promise<void>;
+    /**
+     * Remove a RADIUS client
+     */
+    removeClient(name: string): boolean;
+    /**
+     * Get configured clients
+     */
+    getClients(): IRadiusClient[];
+    /**
+     * Get VLAN manager for direct access to VLAN operations
+     */
+    getVlanManager(): VlanManager;
+    /**
+     * Get accounting manager for direct access to accounting operations
+     */
+    getAccountingManager(): AccountingManager;
+    /**
+     * Get server statistics
+     */
+    getStats(): {
+        running: boolean;
+        uptime: number;
+        authRequests: number;
+        authAccepts: number;
+        authRejects: number;
+        accountingRequests: number;
+        activeSessions: number;
+        vlanMappings: number;
+        clients: number;
+    };
+    /**
+     * Check if server is running
+     */
+    isRunning(): boolean;
+}