@push.rocks/smartproxy 3.41.8 → 4.0.0

package/dist_ts/classes.pp.portproxy.js

@@ -0,0 +1,268 @@
+import * as plugins from './plugins.js';
+import { ConnectionManager } from './classes.pp.connectionmanager.js';
+import { SecurityManager } from './classes.pp.securitymanager.js';
+import { DomainConfigManager } from './classes.pp.domainconfigmanager.js';
+import { TlsManager } from './classes.pp.tlsmanager.js';
+import { NetworkProxyBridge } from './classes.pp.networkproxybridge.js';
+import { TimeoutManager } from './classes.pp.timeoutmanager.js';
+import { AcmeManager } from './classes.pp.acmemanager.js';
+import { PortRangeManager } from './classes.pp.portrangemanager.js';
+import { ConnectionHandler } from './classes.pp.connectionhandler.js';
+/**
+ * PortProxy - Main class that coordinates all components
+ */
+export class PortProxy {
+    constructor(settingsArg) {
+        this.netServers = [];
+        this.connectionLogger = null;
+        this.isShuttingDown = false;
+        // Set reasonable defaults for all settings
+        this.settings = {
+            ...settingsArg,
+            targetIP: settingsArg.targetIP || 'localhost',
+            initialDataTimeout: settingsArg.initialDataTimeout || 120000,
+            socketTimeout: settingsArg.socketTimeout || 3600000,
+            inactivityCheckInterval: settingsArg.inactivityCheckInterval || 60000,
+            maxConnectionLifetime: settingsArg.maxConnectionLifetime || 86400000,
+            inactivityTimeout: settingsArg.inactivityTimeout || 14400000,
+            gracefulShutdownTimeout: settingsArg.gracefulShutdownTimeout || 30000,
+            noDelay: settingsArg.noDelay !== undefined ? settingsArg.noDelay : true,
+            keepAlive: settingsArg.keepAlive !== undefined ? settingsArg.keepAlive : true,
+            keepAliveInitialDelay: settingsArg.keepAliveInitialDelay || 10000,
+            maxPendingDataSize: settingsArg.maxPendingDataSize || 10 * 1024 * 1024,
+            disableInactivityCheck: settingsArg.disableInactivityCheck || false,
+            enableKeepAliveProbes: settingsArg.enableKeepAliveProbes !== undefined ? settingsArg.enableKeepAliveProbes : true,
+            enableDetailedLogging: settingsArg.enableDetailedLogging || false,
+            enableTlsDebugLogging: settingsArg.enableTlsDebugLogging || false,
+            enableRandomizedTimeouts: settingsArg.enableRandomizedTimeouts || false,
+            allowSessionTicket: settingsArg.allowSessionTicket !== undefined ? settingsArg.allowSessionTicket : true,
+            maxConnectionsPerIP: settingsArg.maxConnectionsPerIP || 100,
+            connectionRateLimitPerMinute: settingsArg.connectionRateLimitPerMinute || 300,
+            keepAliveTreatment: settingsArg.keepAliveTreatment || 'extended',
+            keepAliveInactivityMultiplier: settingsArg.keepAliveInactivityMultiplier || 6,
+            extendedKeepAliveLifetime: settingsArg.extendedKeepAliveLifetime || 7 * 24 * 60 * 60 * 1000,
+            networkProxyPort: settingsArg.networkProxyPort || 8443,
+            acme: settingsArg.acme || {
+                enabled: false,
+                port: 80,
+                contactEmail: 'admin@example.com',
+                useProduction: false,
+                renewThresholdDays: 30,
+                autoRenew: true,
+                certificateStore: './certs',
+                skipConfiguredCerts: false,
+            },
+        };
+        // Initialize component managers
+        this.timeoutManager = new TimeoutManager(this.settings);
+        this.securityManager = new SecurityManager(this.settings);
+        this.connectionManager = new ConnectionManager(this.settings, this.securityManager, this.timeoutManager);
+        this.domainConfigManager = new DomainConfigManager(this.settings);
+        this.tlsManager = new TlsManager(this.settings);
+        this.networkProxyBridge = new NetworkProxyBridge(this.settings);
+        this.portRangeManager = new PortRangeManager(this.settings);
+        this.acmeManager = new AcmeManager(this.settings, this.networkProxyBridge);
+        // Initialize connection handler
+        this.connectionHandler = new ConnectionHandler(this.settings, this.connectionManager, this.securityManager, this.domainConfigManager, this.tlsManager, this.networkProxyBridge, this.timeoutManager, this.portRangeManager);
+    }
+    /**
+     * Start the proxy server
+     */
+    async start() {
+        // Don't start if already shutting down
+        if (this.isShuttingDown) {
+            console.log("Cannot start PortProxy while it's shutting down");
+            return;
+        }
+        // Initialize and start NetworkProxy if needed
+        if (this.settings.useNetworkProxy &&
+            this.settings.useNetworkProxy.length > 0) {
+            await this.networkProxyBridge.initialize();
+            await this.networkProxyBridge.start();
+        }
+        // Validate port configuration
+        const configWarnings = this.portRangeManager.validateConfiguration();
+        if (configWarnings.length > 0) {
+            console.log("Port configuration warnings:");
+            for (const warning of configWarnings) {
+                console.log(` - ${warning}`);
+            }
+        }
+        // Get listening ports from PortRangeManager
+        const listeningPorts = this.portRangeManager.getListeningPorts();
+        // Create servers for each port
+        for (const port of listeningPorts) {
+            const server = plugins.net.createServer((socket) => {
+                // Check if shutting down
+                if (this.isShuttingDown) {
+                    socket.end();
+                    socket.destroy();
+                    return;
+                }
+                // Delegate to connection handler
+                this.connectionHandler.handleConnection(socket);
+            }).on('error', (err) => {
+                console.log(`Server Error on port ${port}: ${err.message}`);
+            });
+            server.listen(port, () => {
+                const isNetworkProxyPort = this.settings.useNetworkProxy?.includes(port);
+                console.log(`PortProxy -> OK: Now listening on port ${port}${this.settings.sniEnabled && !isNetworkProxyPort ? ' (SNI passthrough enabled)' : ''}${isNetworkProxyPort ? ' (NetworkProxy forwarding enabled)' : ''}`);
+            });
+            this.netServers.push(server);
+        }
+        // Set up periodic connection logging and inactivity checks
+        this.connectionLogger = setInterval(() => {
+            // Immediately return if shutting down
+            if (this.isShuttingDown)
+                return;
+            // Perform inactivity check
+            this.connectionManager.performInactivityCheck();
+            // Log connection statistics
+            const now = Date.now();
+            let maxIncoming = 0;
+            let maxOutgoing = 0;
+            let tlsConnections = 0;
+            let nonTlsConnections = 0;
+            let completedTlsHandshakes = 0;
+            let pendingTlsHandshakes = 0;
+            let keepAliveConnections = 0;
+            let networkProxyConnections = 0;
+            // Get connection records for analysis
+            const connectionRecords = this.connectionManager.getConnections();
+            // Analyze active connections
+            for (const record of connectionRecords.values()) {
+                // Track connection stats
+                if (record.isTLS) {
+                    tlsConnections++;
+                    if (record.tlsHandshakeComplete) {
+                        completedTlsHandshakes++;
+                    }
+                    else {
+                        pendingTlsHandshakes++;
+                    }
+                }
+                else {
+                    nonTlsConnections++;
+                }
+                if (record.hasKeepAlive) {
+                    keepAliveConnections++;
+                }
+                if (record.usingNetworkProxy) {
+                    networkProxyConnections++;
+                }
+                maxIncoming = Math.max(maxIncoming, now - record.incomingStartTime);
+                if (record.outgoingStartTime) {
+                    maxOutgoing = Math.max(maxOutgoing, now - record.outgoingStartTime);
+                }
+            }
+            // Get termination stats
+            const terminationStats = this.connectionManager.getTerminationStats();
+            // Log detailed stats
+            console.log(`Active connections: ${connectionRecords.size}. ` +
+                `Types: TLS=${tlsConnections} (Completed=${completedTlsHandshakes}, Pending=${pendingTlsHandshakes}), ` +
+                `Non-TLS=${nonTlsConnections}, KeepAlive=${keepAliveConnections}, NetworkProxy=${networkProxyConnections}. ` +
+                `Longest running: IN=${plugins.prettyMs(maxIncoming)}, OUT=${plugins.prettyMs(maxOutgoing)}. ` +
+                `Termination stats: ${JSON.stringify({
+                    IN: terminationStats.incoming,
+                    OUT: terminationStats.outgoing,
+                })}`);
+        }, this.settings.inactivityCheckInterval || 60000);
+        // Make sure the interval doesn't keep the process alive
+        if (this.connectionLogger.unref) {
+            this.connectionLogger.unref();
+        }
+    }
+    /**
+     * Stop the proxy server
+     */
+    async stop() {
+        console.log('PortProxy shutting down...');
+        this.isShuttingDown = true;
+        // Stop accepting new connections
+        const closeServerPromises = this.netServers.map((server) => new Promise((resolve) => {
+            if (!server.listening) {
+                resolve();
+                return;
+            }
+            server.close((err) => {
+                if (err) {
+                    console.log(`Error closing server: ${err.message}`);
+                }
+                resolve();
+            });
+        }));
+        // Stop the connection logger
+        if (this.connectionLogger) {
+            clearInterval(this.connectionLogger);
+            this.connectionLogger = null;
+        }
+        // Wait for servers to close
+        await Promise.all(closeServerPromises);
+        console.log('All servers closed. Cleaning up active connections...');
+        // Clean up all active connections
+        this.connectionManager.clearConnections();
+        // Stop NetworkProxy
+        await this.networkProxyBridge.stop();
+        // Clear all servers
+        this.netServers = [];
+        console.log('PortProxy shutdown complete.');
+    }
+    /**
+     * Updates the domain configurations for the proxy
+     */
+    async updateDomainConfigs(newDomainConfigs) {
+        console.log(`Updating domain configurations (${newDomainConfigs.length} configs)`);
+        // Update domain configs in DomainConfigManager
+        this.domainConfigManager.updateDomainConfigs(newDomainConfigs);
+        // If NetworkProxy is initialized, resync the configurations
+        if (this.networkProxyBridge.getNetworkProxy()) {
+            await this.networkProxyBridge.syncDomainConfigsToNetworkProxy();
+        }
+    }
+    /**
+     * Updates the ACME certificate settings
+     */
+    async updateAcmeSettings(acmeSettings) {
+        console.log('Updating ACME certificate settings');
+        // Delegate to AcmeManager
+        await this.acmeManager.updateAcmeSettings(acmeSettings);
+    }
+    /**
+     * Requests a certificate for a specific domain
+     */
+    async requestCertificate(domain) {
+        // Delegate to AcmeManager
+        return this.acmeManager.requestCertificate(domain);
+    }
+    /**
+     * Get statistics about current connections
+     */
+    getStatistics() {
+        const connectionRecords = this.connectionManager.getConnections();
+        const terminationStats = this.connectionManager.getTerminationStats();
+        let tlsConnections = 0;
+        let nonTlsConnections = 0;
+        let keepAliveConnections = 0;
+        let networkProxyConnections = 0;
+        // Analyze active connections
+        for (const record of connectionRecords.values()) {
+            if (record.isTLS)
+                tlsConnections++;
+            else
+                nonTlsConnections++;
+            if (record.hasKeepAlive)
+                keepAliveConnections++;
+            if (record.usingNetworkProxy)
+                networkProxyConnections++;
+        }
+        return {
+            activeConnections: connectionRecords.size,
+            tlsConnections,
+            nonTlsConnections,
+            keepAliveConnections,
+            networkProxyConnections,
+            terminationStats
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.pp.portproxy.js","sourceRoot":"","sources":["../ts/classes.pp.portproxy.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.pp.portrangemanager.d.ts

@@ -0,0 +1,56 @@
+import type { IPortProxySettings } from './classes.pp.interfaces.js';
+/**
+ * Manages port ranges and port-based configuration
+ */
+export declare class PortRangeManager {
+    private settings;
+    constructor(settings: IPortProxySettings);
+    /**
+     * Get all ports that should be listened on
+     */
+    getListeningPorts(): Set<number>;
+    /**
+     * Check if a port should use NetworkProxy for forwarding
+     */
+    shouldUseNetworkProxy(port: number): boolean;
+    /**
+     * Check if port should use global forwarding
+     */
+    shouldUseGlobalForwarding(port: number): boolean;
+    /**
+     * Check if a port is in global ranges
+     */
+    isPortInGlobalRanges(port: number): boolean;
+    /**
+     * Check if a port falls within the specified ranges
+     */
+    isPortInRanges(port: number, ranges: Array<{
+        from: number;
+        to: number;
+    }>): boolean;
+    /**
+     * Get forwarding port for a specific listening port
+     * This determines what port to connect to on the target
+     */
+    getForwardingPort(listeningPort: number): number;
+    /**
+     * Find domain-specific port ranges that include a given port
+     */
+    findDomainPortRange(port: number): {
+        domainIndex: number;
+        range: {
+            from: number;
+            to: number;
+        };
+    } | undefined;
+    /**
+     * Get a list of all configured ports
+     * This includes the fromPort, NetworkProxy ports, and ports from all ranges
+     */
+    getAllConfiguredPorts(): number[];
+    /**
+     * Validate port configuration
+     * Returns array of warning messages
+     */
+    validateConfiguration(): string[];
+}

package/dist_ts/classes.pp.portrangemanager.js

@@ -0,0 +1,179 @@
+/**
+ * Manages port ranges and port-based configuration
+ */
+export class PortRangeManager {
+    constructor(settings) {
+        this.settings = settings;
+    }
+    /**
+     * Get all ports that should be listened on
+     */
+    getListeningPorts() {
+        const listeningPorts = new Set();
+        // Always include the main fromPort
+        listeningPorts.add(this.settings.fromPort);
+        // Add ports from global port ranges if defined
+        if (this.settings.globalPortRanges && this.settings.globalPortRanges.length > 0) {
+            for (const range of this.settings.globalPortRanges) {
+                for (let port = range.from; port <= range.to; port++) {
+                    listeningPorts.add(port);
+                }
+            }
+        }
+        return listeningPorts;
+    }
+    /**
+     * Check if a port should use NetworkProxy for forwarding
+     */
+    shouldUseNetworkProxy(port) {
+        return !!this.settings.useNetworkProxy && this.settings.useNetworkProxy.includes(port);
+    }
+    /**
+     * Check if port should use global forwarding
+     */
+    shouldUseGlobalForwarding(port) {
+        return (!!this.settings.forwardAllGlobalRanges &&
+            this.isPortInGlobalRanges(port));
+    }
+    /**
+     * Check if a port is in global ranges
+     */
+    isPortInGlobalRanges(port) {
+        return (this.settings.globalPortRanges &&
+            this.isPortInRanges(port, this.settings.globalPortRanges));
+    }
+    /**
+     * Check if a port falls within the specified ranges
+     */
+    isPortInRanges(port, ranges) {
+        return ranges.some((range) => port >= range.from && port <= range.to);
+    }
+    /**
+     * Get forwarding port for a specific listening port
+     * This determines what port to connect to on the target
+     */
+    getForwardingPort(listeningPort) {
+        // If using global forwarding, forward to the original port
+        if (this.settings.forwardAllGlobalRanges && this.isPortInGlobalRanges(listeningPort)) {
+            return listeningPort;
+        }
+        // Otherwise use the configured toPort
+        return this.settings.toPort;
+    }
+    /**
+     * Find domain-specific port ranges that include a given port
+     */
+    findDomainPortRange(port) {
+        for (let i = 0; i < this.settings.domainConfigs.length; i++) {
+            const domain = this.settings.domainConfigs[i];
+            if (domain.portRanges) {
+                for (const range of domain.portRanges) {
+                    if (port >= range.from && port <= range.to) {
+                        return { domainIndex: i, range };
+                    }
+                }
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Get a list of all configured ports
+     * This includes the fromPort, NetworkProxy ports, and ports from all ranges
+     */
+    getAllConfiguredPorts() {
+        const ports = new Set();
+        // Add main listening port
+        ports.add(this.settings.fromPort);
+        // Add NetworkProxy port if configured
+        if (this.settings.networkProxyPort) {
+            ports.add(this.settings.networkProxyPort);
+        }
+        // Add NetworkProxy ports
+        if (this.settings.useNetworkProxy) {
+            for (const port of this.settings.useNetworkProxy) {
+                ports.add(port);
+            }
+        }
+        // Add ACME HTTP challenge port if enabled
+        if (this.settings.acme?.enabled && this.settings.acme.port) {
+            ports.add(this.settings.acme.port);
+        }
+        // Add global port ranges
+        if (this.settings.globalPortRanges) {
+            for (const range of this.settings.globalPortRanges) {
+                for (let port = range.from; port <= range.to; port++) {
+                    ports.add(port);
+                }
+            }
+        }
+        // Add domain-specific port ranges
+        for (const domain of this.settings.domainConfigs) {
+            if (domain.portRanges) {
+                for (const range of domain.portRanges) {
+                    for (let port = range.from; port <= range.to; port++) {
+                        ports.add(port);
+                    }
+                }
+            }
+            // Add domain-specific NetworkProxy port if configured
+            if (domain.useNetworkProxy && domain.networkProxyPort) {
+                ports.add(domain.networkProxyPort);
+            }
+        }
+        return Array.from(ports);
+    }
+    /**
+     * Validate port configuration
+     * Returns array of warning messages
+     */
+    validateConfiguration() {
+        const warnings = [];
+        // Check for overlapping port ranges
+        const portMappings = new Map();
+        // Track global port ranges
+        if (this.settings.globalPortRanges) {
+            for (const range of this.settings.globalPortRanges) {
+                for (let port = range.from; port <= range.to; port++) {
+                    if (!portMappings.has(port)) {
+                        portMappings.set(port, []);
+                    }
+                    portMappings.get(port).push('Global Port Range');
+                }
+            }
+        }
+        // Track domain-specific port ranges
+        for (const domain of this.settings.domainConfigs) {
+            if (domain.portRanges) {
+                for (const range of domain.portRanges) {
+                    for (let port = range.from; port <= range.to; port++) {
+                        if (!portMappings.has(port)) {
+                            portMappings.set(port, []);
+                        }
+                        portMappings.get(port).push(`Domain: ${domain.domains.join(', ')}`);
+                    }
+                }
+            }
+        }
+        // Check for ports with multiple mappings
+        for (const [port, mappings] of portMappings.entries()) {
+            if (mappings.length > 1) {
+                warnings.push(`Port ${port} has multiple mappings: ${mappings.join(', ')}`);
+            }
+        }
+        // Check if main ports are used elsewhere
+        if (portMappings.has(this.settings.fromPort) && portMappings.get(this.settings.fromPort).length > 0) {
+            warnings.push(`Main listening port ${this.settings.fromPort} is also used in port ranges`);
+        }
+        if (this.settings.networkProxyPort && portMappings.has(this.settings.networkProxyPort)) {
+            warnings.push(`NetworkProxy port ${this.settings.networkProxyPort} is also used in port ranges`);
+        }
+        // Check ACME port
+        if (this.settings.acme?.enabled && this.settings.acme.port) {
+            if (portMappings.has(this.settings.acme.port)) {
+                warnings.push(`ACME HTTP challenge port ${this.settings.acme.port} is also used in port ranges`);
+            }
+        }
+        return warnings;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/classes.pp.securitymanager.d.ts

@@ -0,0 +1,47 @@
+import type { IPortProxySettings } from './classes.pp.interfaces.js';
+/**
+ * Handles security aspects like IP tracking, rate limiting, and authorization
+ */
+export declare class SecurityManager {
+    private settings;
+    private connectionsByIP;
+    private connectionRateByIP;
+    constructor(settings: IPortProxySettings);
+    /**
+     * Get connections count by IP
+     */
+    getConnectionCountByIP(ip: string): number;
+    /**
+     * Check and update connection rate for an IP
+     * @returns true if within rate limit, false if exceeding limit
+     */
+    checkConnectionRate(ip: string): boolean;
+    /**
+     * Track connection by IP
+     */
+    trackConnectionByIP(ip: string, connectionId: string): void;
+    /**
+     * Remove connection tracking for an IP
+     */
+    removeConnectionByIP(ip: string, connectionId: string): void;
+    /**
+     * Check if an IP is allowed using glob patterns
+     */
+    isIPAuthorized(ip: string, allowedIPs: string[], blockedIPs?: string[]): boolean;
+    /**
+     * Check if the IP matches any of the glob patterns
+     */
+    private isGlobIPMatch;
+    /**
+     * Check if IP should be allowed considering connection rate and max connections
+     * @returns Object with result and reason
+     */
+    validateIP(ip: string): {
+        allowed: boolean;
+        reason?: string;
+    };
+    /**
+     * Clears all IP tracking data (for shutdown)
+     */
+    clearIPTracking(): void;
+}