@serve.zone/dcrouter 11.0.22 → 11.0.23

package/dist_ts/opsserver/handlers/security.handler.js

@@ -0,0 +1,231 @@
+import * as plugins from '../../plugins.js';
+import * as interfaces from '../../../dist_ts_interfaces/index.js';
+import { MetricsManager } from '../../monitoring/index.js';
+export class SecurityHandler {
+    opsServerRef;
+    constructor(opsServerRef) {
+        this.opsServerRef = opsServerRef;
+        this.registerHandlers();
+    }
+    registerHandlers() {
+        // All security endpoints register directly on viewRouter (valid identity required via middleware)
+        const router = this.opsServerRef.viewRouter;
+        // Security Metrics Handler
+        router.addTypedHandler(new plugins.typedrequest.TypedHandler('getSecurityMetrics', async (dataArg, toolsArg) => {
+            const metrics = await this.collectSecurityMetrics();
+            return {
+                metrics: {
+                    blockedIPs: metrics.blockedIPs,
+                    reputationScores: metrics.reputationScores,
+                    spamDetected: metrics.spamDetection.detected,
+                    malwareDetected: metrics.malwareDetected,
+                    phishingDetected: metrics.phishingDetected,
+                    authenticationFailures: metrics.authFailures,
+                    suspiciousActivities: metrics.suspiciousActivities,
+                },
+                trends: dataArg.includeDetails ? {
+                    spam: metrics.trends.spam,
+                    malware: metrics.trends.malware,
+                    phishing: metrics.trends.phishing,
+                } : undefined,
+            };
+        }));
+        // Active Connections Handler
+        router.addTypedHandler(new plugins.typedrequest.TypedHandler('getActiveConnections', async (dataArg, toolsArg) => {
+            const connections = await this.getActiveConnections(dataArg.protocol, dataArg.state);
+            const connectionInfos = connections.map(conn => ({
+                id: conn.id,
+                remoteAddress: conn.source.ip,
+                localAddress: conn.destination.ip,
+                startTime: conn.startTime,
+                protocol: conn.type === 'http' ? 'https' : conn.type,
+                state: conn.status,
+                bytesReceived: Math.floor(conn.bytesTransferred / 2),
+                bytesSent: Math.floor(conn.bytesTransferred / 2),
+            }));
+            const summary = {
+                total: connectionInfos.length,
+                byProtocol: connectionInfos.reduce((acc, conn) => {
+                    acc[conn.protocol] = (acc[conn.protocol] || 0) + 1;
+                    return acc;
+                }, {}),
+                byState: connectionInfos.reduce((acc, conn) => {
+                    acc[conn.state] = (acc[conn.state] || 0) + 1;
+                    return acc;
+                }, {}),
+            };
+            return {
+                connections: connectionInfos,
+                summary,
+            };
+        }));
+        // Network Stats Handler - provides comprehensive network metrics
+        router.addTypedHandler(new plugins.typedrequest.TypedHandler('getNetworkStats', async (dataArg, toolsArg) => {
+            // Get network stats from MetricsManager if available
+            if (this.opsServerRef.dcRouterRef.metricsManager) {
+                const networkStats = await this.opsServerRef.dcRouterRef.metricsManager.getNetworkStats();
+                // Convert per-IP throughput Map to serializable array
+                const throughputByIP = [];
+                if (networkStats.throughputByIP) {
+                    for (const [ip, tp] of networkStats.throughputByIP) {
+                        throughputByIP.push({ ip, in: tp.in, out: tp.out });
+                    }
+                }
+                return {
+                    connectionsByIP: Array.from(networkStats.connectionsByIP.entries()).map(([ip, count]) => ({ ip, count })),
+                    throughputRate: networkStats.throughputRate,
+                    topIPs: networkStats.topIPs,
+                    totalDataTransferred: networkStats.totalDataTransferred,
+                    throughputHistory: networkStats.throughputHistory || [],
+                    throughputByIP,
+                    requestsPerSecond: networkStats.requestsPerSecond || 0,
+                    requestsTotal: networkStats.requestsTotal || 0,
+                };
+            }
+            // Fallback if MetricsManager not available
+            return {
+                connectionsByIP: [],
+                throughputRate: { bytesInPerSecond: 0, bytesOutPerSecond: 0 },
+                topIPs: [],
+                totalDataTransferred: { bytesIn: 0, bytesOut: 0 },
+                throughputHistory: [],
+                throughputByIP: [],
+                requestsPerSecond: 0,
+                requestsTotal: 0,
+            };
+        }));
+        // Rate Limit Status Handler
+        router.addTypedHandler(new plugins.typedrequest.TypedHandler('getRateLimitStatus', async (dataArg, toolsArg) => {
+            const status = await this.getRateLimitStatus(dataArg.domain, dataArg.ip);
+            const limits = status.limits.map(limit => ({
+                domain: limit.identifier,
+                currentRate: limit.current,
+                limit: limit.limit,
+                remaining: limit.limit - limit.current,
+                resetTime: limit.resetAt,
+                blocked: limit.status === 'limited',
+            }));
+            return {
+                limits,
+                globalLimit: dataArg.includeBlocked ? {
+                    current: limits.reduce((sum, l) => sum + l.currentRate, 0),
+                    limit: 1000, // Global limit
+                    remaining: 1000 - limits.reduce((sum, l) => sum + l.currentRate, 0),
+                } : undefined,
+            };
+        }));
+    }
+    async collectSecurityMetrics() {
+        // Get metrics from MetricsManager if available
+        if (this.opsServerRef.dcRouterRef.metricsManager) {
+            const securityStats = await this.opsServerRef.dcRouterRef.metricsManager.getSecurityStats();
+            return {
+                blockedIPs: [], // TODO: Track actual blocked IPs
+                reputationScores: {},
+                spamDetection: {
+                    detected: securityStats.spamDetected,
+                    falsePositives: 0,
+                },
+                malwareDetected: securityStats.malwareDetected,
+                phishingDetected: securityStats.phishingDetected,
+                authFailures: securityStats.authFailures,
+                suspiciousActivities: 0,
+                trends: {
+                    spam: [],
+                    malware: [],
+                    phishing: [],
+                },
+            };
+        }
+        // Fallback if MetricsManager not available
+        return {
+            blockedIPs: [],
+            reputationScores: {},
+            spamDetection: {
+                detected: 0,
+                falsePositives: 0,
+            },
+            malwareDetected: 0,
+            phishingDetected: 0,
+            authFailures: 0,
+            suspiciousActivities: 0,
+            trends: {
+                spam: [],
+                malware: [],
+                phishing: [],
+            },
+        };
+    }
+    async getActiveConnections(protocol, state) {
+        const connections = [];
+        // Get connection info and network stats from MetricsManager if available
+        if (this.opsServerRef.dcRouterRef.metricsManager) {
+            const connectionInfo = await this.opsServerRef.dcRouterRef.metricsManager.getConnectionInfo();
+            const networkStats = await this.opsServerRef.dcRouterRef.metricsManager.getNetworkStats();
+            // Use IP-based connection data from the new metrics API
+            if (networkStats.connectionsByIP && networkStats.connectionsByIP.size > 0) {
+                let connIndex = 0;
+                const publicIp = this.opsServerRef.dcRouterRef.options.publicIp || 'server';
+                for (const [ip, count] of networkStats.connectionsByIP) {
+                    // Create a connection entry for each active IP connection
+                    for (let i = 0; i < Math.min(count, 5); i++) { // Limit to 5 connections per IP for UI performance
+                        connections.push({
+                            id: `conn-${connIndex++}`,
+                            type: 'http',
+                            source: {
+                                ip: ip,
+                                port: Math.floor(Math.random() * 50000) + 10000, // High port range
+                            },
+                            destination: {
+                                ip: publicIp,
+                                port: 443,
+                                service: 'proxy',
+                            },
+                            startTime: Date.now() - Math.floor(Math.random() * 3600000), // Within last hour
+                            bytesTransferred: Math.floor(networkStats.totalDataTransferred.bytesIn / networkStats.connectionsByIP.size),
+                            status: 'active',
+                        });
+                    }
+                }
+            }
+            else if (connectionInfo.length > 0) {
+                // Fallback to route-based connection info if no IP data available
+                connectionInfo.forEach((info, index) => {
+                    connections.push({
+                        id: `conn-${index}`,
+                        type: 'http',
+                        source: {
+                            ip: 'unknown',
+                            port: 0,
+                        },
+                        destination: {
+                            ip: this.opsServerRef.dcRouterRef.options.publicIp || 'server',
+                            port: 443,
+                            service: info.source,
+                        },
+                        startTime: info.lastActivity.getTime(),
+                        bytesTransferred: 0,
+                        status: 'active',
+                    });
+                });
+            }
+        }
+        // Filter by protocol if specified
+        if (protocol) {
+            return connections.filter(conn => {
+                if (protocol === 'https' || protocol === 'http') {
+                    return conn.type === 'http';
+                }
+                return conn.type === protocol.replace('s', ''); // smtp/smtps -> smtp
+            });
+        }
+        return connections;
+    }
+    async getRateLimitStatus(domain, ip) {
+        // TODO: Implement actual rate limit status collection
+        return {
+            limits: [],
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"security.handler.js","sourceRoot":"","sources":["../../../../ts/opsserver/handlers/security.handler.ts"],"names":[],"mappings":"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"}

package/dist_ts/opsserver/handlers/stats.handler.d.ts

@@ -0,0 +1,11 @@
+import type { OpsServer } from '../classes.opsserver.js';
+export declare class StatsHandler {
+    private opsServerRef;
+    constructor(opsServerRef: OpsServer);
+    private registerHandlers;
+    private collectServerStats;
+    private collectEmailStats;
+    private collectDnsStats;
+    private getQueueStatus;
+    private checkHealthStatus;
+}