@push.rocks/smartproxy 12.0.0 → 13.1.2

package/dist_ts/proxies/network-proxy/websocket-handler.js

@@ -0,0 +1,188 @@
+import * as plugins from '../../plugins.js';
+import { createLogger } from './models/types.js';
+import { ConnectionPool } from './connection-pool.js';
+import { ProxyRouter } from '../../http/router/index.js';
+/**
+ * Handles WebSocket connections and proxying
+ */
+export class WebSocketHandler {
+    constructor(options, connectionPool, router) {
+        this.options = options;
+        this.connectionPool = connectionPool;
+        this.router = router;
+        this.heartbeatInterval = null;
+        this.wsServer = null;
+        this.logger = createLogger(options.logLevel || 'info');
+    }
+    /**
+     * Initialize WebSocket server on an existing HTTPS server
+     */
+    initialize(server) {
+        // Create WebSocket server
+        this.wsServer = new plugins.ws.WebSocketServer({
+            server: server,
+            clientTracking: true
+        });
+        // Handle WebSocket connections
+        this.wsServer.on('connection', (wsIncoming, req) => {
+            this.handleWebSocketConnection(wsIncoming, req);
+        });
+        // Start the heartbeat interval
+        this.startHeartbeat();
+        this.logger.info('WebSocket handler initialized');
+    }
+    /**
+     * Start the heartbeat interval to check for inactive WebSocket connections
+     */
+    startHeartbeat() {
+        // Clean up existing interval if any
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+        }
+        // Set up the heartbeat interval (check every 30 seconds)
+        this.heartbeatInterval = setInterval(() => {
+            if (!this.wsServer || this.wsServer.clients.size === 0) {
+                return; // Skip if no active connections
+            }
+            this.logger.debug(`WebSocket heartbeat check for ${this.wsServer.clients.size} clients`);
+            this.wsServer.clients.forEach((ws) => {
+                const wsWithHeartbeat = ws;
+                if (wsWithHeartbeat.isAlive === false) {
+                    this.logger.debug('Terminating inactive WebSocket connection');
+                    return wsWithHeartbeat.terminate();
+                }
+                wsWithHeartbeat.isAlive = false;
+                wsWithHeartbeat.ping();
+            });
+        }, 30000);
+        // Make sure the interval doesn't keep the process alive
+        if (this.heartbeatInterval.unref) {
+            this.heartbeatInterval.unref();
+        }
+    }
+    /**
+     * Handle a new WebSocket connection
+     */
+    handleWebSocketConnection(wsIncoming, req) {
+        try {
+            // Initialize heartbeat tracking
+            wsIncoming.isAlive = true;
+            wsIncoming.lastPong = Date.now();
+            // Handle pong messages to track liveness
+            wsIncoming.on('pong', () => {
+                wsIncoming.isAlive = true;
+                wsIncoming.lastPong = Date.now();
+            });
+            // Find target configuration based on request
+            const proxyConfig = this.router.routeReq(req);
+            if (!proxyConfig) {
+                this.logger.warn(`No proxy configuration for WebSocket host: ${req.headers.host}`);
+                wsIncoming.close(1008, 'No proxy configuration for this host');
+                return;
+            }
+            // Get destination target using round-robin if multiple targets
+            const destination = this.connectionPool.getNextTarget(proxyConfig.destinationIps, proxyConfig.destinationPorts[0]);
+            // Build target URL
+            const protocol = req.socket.encrypted ? 'wss' : 'ws';
+            const targetUrl = `${protocol}://${destination.host}:${destination.port}${req.url}`;
+            this.logger.debug(`WebSocket connection from ${req.socket.remoteAddress} to ${targetUrl}`);
+            // Create headers for outgoing WebSocket connection
+            const headers = {};
+            // Copy relevant headers from incoming request
+            for (const [key, value] of Object.entries(req.headers)) {
+                if (value && typeof value === 'string' &&
+                    key.toLowerCase() !== 'connection' &&
+                    key.toLowerCase() !== 'upgrade' &&
+                    key.toLowerCase() !== 'sec-websocket-key' &&
+                    key.toLowerCase() !== 'sec-websocket-version') {
+                    headers[key] = value;
+                }
+            }
+            // Override host header if needed
+            if (proxyConfig.rewriteHostHeader) {
+                headers['host'] = `${destination.host}:${destination.port}`;
+            }
+            // Create outgoing WebSocket connection
+            const wsOutgoing = new plugins.wsDefault(targetUrl, {
+                headers: headers,
+                followRedirects: true
+            });
+            // Handle connection errors
+            wsOutgoing.on('error', (err) => {
+                this.logger.error(`WebSocket target connection error: ${err.message}`);
+                if (wsIncoming.readyState === wsIncoming.OPEN) {
+                    wsIncoming.close(1011, 'Internal server error');
+                }
+            });
+            // Handle outgoing connection open
+            wsOutgoing.on('open', () => {
+                // Forward incoming messages to outgoing connection
+                wsIncoming.on('message', (data, isBinary) => {
+                    if (wsOutgoing.readyState === wsOutgoing.OPEN) {
+                        wsOutgoing.send(data, { binary: isBinary });
+                    }
+                });
+                // Forward outgoing messages to incoming connection
+                wsOutgoing.on('message', (data, isBinary) => {
+                    if (wsIncoming.readyState === wsIncoming.OPEN) {
+                        wsIncoming.send(data, { binary: isBinary });
+                    }
+                });
+                // Handle closing of connections
+                wsIncoming.on('close', (code, reason) => {
+                    this.logger.debug(`WebSocket client connection closed: ${code} ${reason}`);
+                    if (wsOutgoing.readyState === wsOutgoing.OPEN) {
+                        wsOutgoing.close(code, reason);
+                    }
+                });
+                wsOutgoing.on('close', (code, reason) => {
+                    this.logger.debug(`WebSocket target connection closed: ${code} ${reason}`);
+                    if (wsIncoming.readyState === wsIncoming.OPEN) {
+                        wsIncoming.close(code, reason);
+                    }
+                });
+                this.logger.debug(`WebSocket connection established: ${req.headers.host} -> ${destination.host}:${destination.port}`);
+            });
+        }
+        catch (error) {
+            this.logger.error(`Error handling WebSocket connection: ${error.message}`);
+            if (wsIncoming.readyState === wsIncoming.OPEN) {
+                wsIncoming.close(1011, 'Internal server error');
+            }
+        }
+    }
+    /**
+     * Get information about active WebSocket connections
+     */
+    getConnectionInfo() {
+        return {
+            activeConnections: this.wsServer ? this.wsServer.clients.size : 0
+        };
+    }
+    /**
+     * Shutdown the WebSocket handler
+     */
+    shutdown() {
+        // Stop heartbeat interval
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = null;
+        }
+        // Close all WebSocket connections
+        if (this.wsServer) {
+            this.logger.info(`Closing ${this.wsServer.clients.size} WebSocket connections`);
+            for (const client of this.wsServer.clients) {
+                try {
+                    client.terminate();
+                }
+                catch (error) {
+                    this.logger.error('Error terminating WebSocket client', error);
+                }
+            }
+            // Close the server
+            this.wsServer.close();
+            this.wsServer = null;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"websocket-handler.js","sourceRoot":"","sources":["../../../ts/proxies/network-proxy/websocket-handler.ts"],"names":[],"mappings":"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"}

package/dist_ts/proxies/nftables-proxy/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * NfTablesProxy implementation
+ */
+export * from './nftables-proxy.js';
+export * from './models/index.js';

package/dist_ts/proxies/nftables-proxy/index.js

@@ -0,0 +1,6 @@
+/**
+ * NfTablesProxy implementation
+ */
+export * from './nftables-proxy.js';
+export * from './models/index.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9wcm94aWVzL25mdGFibGVzLXByb3h5L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLG1CQUFtQixDQUFDIn0=

package/dist_ts/proxies/nftables-proxy/models/errors.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Custom error classes for better error handling
+ */
+export declare class NftBaseError extends Error {
+    constructor(message: string);
+}
+export declare class NftValidationError extends NftBaseError {
+    constructor(message: string);
+}
+export declare class NftExecutionError extends NftBaseError {
+    constructor(message: string);
+}
+export declare class NftResourceError extends NftBaseError {
+    constructor(message: string);
+}

package/dist_ts/proxies/nftables-proxy/models/errors.js

@@ -0,0 +1,28 @@
+/**
+ * Custom error classes for better error handling
+ */
+export class NftBaseError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'NftBaseError';
+    }
+}
+export class NftValidationError extends NftBaseError {
+    constructor(message) {
+        super(message);
+        this.name = 'NftValidationError';
+    }
+}
+export class NftExecutionError extends NftBaseError {
+    constructor(message) {
+        super(message);
+        this.name = 'NftExecutionError';
+    }
+}
+export class NftResourceError extends NftBaseError {
+    constructor(message) {
+        super(message);
+        this.name = 'NftResourceError';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vdHMvcHJveGllcy9uZnRhYmxlcy1wcm94eS9tb2RlbHMvZXJyb3JzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxPQUFPLFlBQWEsU0FBUSxLQUFLO0lBQ3JDLFlBQVksT0FBZTtRQUN6QixLQUFLLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDZixJQUFJLENBQUMsSUFBSSxHQUFHLGNBQWMsQ0FBQztJQUM3QixDQUFDO0NBQ0Y7QUFFRCxNQUFNLE9BQU8sa0JBQW1CLFNBQVEsWUFBWTtJQUNsRCxZQUFZLE9BQWU7UUFDekIsS0FBSyxDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBQ2YsSUFBSSxDQUFDLElBQUksR0FBRyxvQkFBb0IsQ0FBQztJQUNuQyxDQUFDO0NBQ0Y7QUFFRCxNQUFNLE9BQU8saUJBQWtCLFNBQVEsWUFBWTtJQUNqRCxZQUFZLE9BQWU7UUFDekIsS0FBSyxDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBQ2YsSUFBSSxDQUFDLElBQUksR0FBRyxtQkFBbUIsQ0FBQztJQUNsQyxDQUFDO0NBQ0Y7QUFFRCxNQUFNLE9BQU8sZ0JBQWlCLFNBQVEsWUFBWTtJQUNoRCxZQUFZLE9BQWU7UUFDekIsS0FBSyxDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBQ2YsSUFBSSxDQUFDLElBQUksR0FBRyxrQkFBa0IsQ0FBQztJQUNqQyxDQUFDO0NBQ0YifQ==

package/dist_ts/proxies/nftables-proxy/models/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Export all models
+ */
+export * from './interfaces.js';
+export * from './errors.js';

package/dist_ts/proxies/nftables-proxy/models/index.js

@@ -0,0 +1,6 @@
+/**
+ * Export all models
+ */
+export * from './interfaces.js';
+export * from './errors.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi90cy9wcm94aWVzL25mdGFibGVzLXByb3h5L21vZGVscy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUNILGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxhQUFhLENBQUMifQ==

package/dist_ts/proxies/nftables-proxy/models/interfaces.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Interfaces for NfTablesProxy
+ */
+/**
+ * Represents a port range for forwarding
+ */
+export interface PortRange {
+    from: number;
+    to: number;
+}
+export type IPortRange = PortRange;
+/**
+ * Settings for NfTablesProxy.
+ */
+export interface NfTableProxyOptions {
+    fromPort: number | PortRange | Array<number | PortRange>;
+    toPort: number | PortRange | Array<number | PortRange>;
+    toHost?: string;
+    preserveSourceIP?: boolean;
+    deleteOnExit?: boolean;
+    protocol?: 'tcp' | 'udp' | 'all';
+    enableLogging?: boolean;
+    ipv6Support?: boolean;
+    logFormat?: 'plain' | 'json';
+    allowedSourceIPs?: string[];
+    bannedSourceIPs?: string[];
+    useIPSets?: boolean;
+    forceCleanSlate?: boolean;
+    tableName?: string;
+    maxRetries?: number;
+    retryDelayMs?: number;
+    useAdvancedNAT?: boolean;
+    qos?: {
+        enabled: boolean;
+        maxRate?: string;
+        priority?: number;
+        markConnections?: boolean;
+    };
+    netProxyIntegration?: {
+        enabled: boolean;
+        redirectLocalhost?: boolean;
+        sslTerminationPort?: number;
+    };
+}
+export type INfTableProxySettings = NfTableProxyOptions;
+/**
+ * Interface for status reporting
+ */
+export interface NfTablesStatus {
+    active: boolean;
+    ruleCount: {
+        total: number;
+        added: number;
+        verified: number;
+    };
+    tablesConfigured: {
+        family: string;
+        tableName: string;
+    }[];
+    metrics: {
+        forwardedConnections?: number;
+        activeConnections?: number;
+        bytesForwarded?: {
+            sent: number;
+            received: number;
+        };
+    };
+    qosEnabled?: boolean;
+    ipSetsConfigured?: {
+        name: string;
+        elementCount: number;
+        type: string;
+    }[];
+}
+export type INfTablesStatus = NfTablesStatus;

package/dist_ts/proxies/nftables-proxy/models/interfaces.js

@@ -0,0 +1,5 @@
+/**
+ * Interfaces for NfTablesProxy
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3RzL3Byb3hpZXMvbmZ0YWJsZXMtcHJveHkvbW9kZWxzL2ludGVyZmFjZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUcifQ==

package/dist_ts/proxies/nftables-proxy/nftables-proxy.d.ts

@@ -0,0 +1,136 @@
+import type { NfTableProxyOptions, NfTablesStatus } from './models/index.js';
+/**
+ * NfTablesProxy sets up nftables NAT rules to forward TCP traffic.
+ * Enhanced with multi-port support, IPv6, connection tracking, metrics,
+ * and more advanced features.
+ */
+export declare class NfTablesProxy {
+    settings: NfTableProxyOptions;
+    private rules;
+    private ipSets;
+    private ruleTag;
+    private tableName;
+    private tempFilePath;
+    private static NFT_CMD;
+    constructor(settings: NfTableProxyOptions);
+    /**
+     * Validates settings to prevent command injection and ensure valid values
+     */
+    private validateSettings;
+    /**
+     * Normalizes port specifications into an array of port ranges
+     */
+    private normalizePortSpec;
+    /**
+     * Execute a command with retry capability
+     */
+    private executeWithRetry;
+    /**
+     * Execute system command synchronously with multiple attempts
+     */
+    private executeWithRetrySync;
+    /**
+     * Checks if nftables is available and the required modules are loaded
+     */
+    private checkNftablesAvailability;
+    /**
+     * Creates the necessary tables and chains
+     */
+    private setupTablesAndChains;
+    /**
+     * Creates IP sets for efficient filtering of large IP lists
+     */
+    private createIPSet;
+    /**
+     * Adds source IP filtering rules, potentially using IP sets for efficiency
+     */
+    private addSourceIPFilters;
+    /**
+     * Gets a comma-separated list of all ports from a port specification
+     */
+    private getAllPorts;
+    /**
+     * Configures advanced NAT with connection tracking
+     */
+    private setupAdvancedNAT;
+    /**
+     * Adds port forwarding rules
+     */
+    private addPortForwardingRules;
+    /**
+     * Adds port forwarding rules for the case where one toPortRange maps to multiple fromPortRanges
+     */
+    private addPortMappings;
+    /**
+     * Adds port forwarding rules for pairs of fromPortRanges and toPortRanges
+     */
+    private addPortPairMappings;
+    /**
+     * Setup quality of service rules
+     */
+    private addTrafficShaping;
+    /**
+     * Setup NetworkProxy integration rules
+     */
+    private setupNetworkProxyIntegration;
+    /**
+     * Verify that a rule was successfully applied
+     */
+    private verifyRuleApplication;
+    /**
+     * Rolls back rules in case of error during setup
+     */
+    private rollbackRules;
+    /**
+     * Checks if nftables table exists
+     */
+    private tableExists;
+    /**
+     * Get system metrics like connection counts
+     */
+    private getSystemMetrics;
+    /**
+     * Get status of IP sets
+     */
+    private getIPSetStatus;
+    /**
+     * Get detailed status about the current state of the proxy
+     */
+    getStatus(): Promise<NfTablesStatus>;
+    /**
+     * Performs a dry run to see what commands would be executed without actually applying them
+     */
+    dryRun(): Promise<string[]>;
+    /**
+     * Starts the proxy by setting up all nftables rules
+     */
+    start(): Promise<void>;
+    /**
+     * Stops the proxy by removing all added rules
+     */
+    stop(): Promise<void>;
+    /**
+     * Synchronous version of stop, for use in exit handlers
+     */
+    stopSync(): void;
+    /**
+     * Cleans up empty tables
+     */
+    private cleanupEmptyTables;
+    /**
+     * Synchronous version of cleanupEmptyTables
+     */
+    private cleanupEmptyTablesSync;
+    /**
+     * Removes all nftables rules created by this module
+     */
+    static cleanSlate(): Promise<void>;
+    /**
+     * Synchronous version of cleanSlate
+     */
+    static cleanSlateSync(): void;
+    /**
+     * Improved logging with structured output
+     */
+    private log;
+}