@push.rocks/smartproxy 3.41.8 → 4.0.0

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

@@ -0,0 +1,109 @@
+import * as plugins from './plugins.js';
+/** Domain configuration with per-domain allowed port ranges */
+export interface IDomainConfig {
+    domains: string[];
+    allowedIPs: string[];
+    blockedIPs?: string[];
+    targetIPs?: string[];
+    portRanges?: Array<{
+        from: number;
+        to: number;
+    }>;
+    connectionTimeout?: number;
+    useNetworkProxy?: boolean;
+    networkProxyPort?: number;
+}
+/** Port proxy settings including global allowed port ranges */
+export interface IPortProxySettings {
+    fromPort: number;
+    toPort: number;
+    targetIP?: string;
+    domainConfigs: IDomainConfig[];
+    sniEnabled?: boolean;
+    defaultAllowedIPs?: string[];
+    defaultBlockedIPs?: string[];
+    preserveSourceIP?: boolean;
+    pfx?: Buffer;
+    key?: string | Buffer | Array<Buffer | string>;
+    passphrase?: string;
+    cert?: string | Buffer | Array<string | Buffer>;
+    ca?: string | Buffer | Array<string | Buffer>;
+    ciphers?: string;
+    honorCipherOrder?: boolean;
+    rejectUnauthorized?: boolean;
+    secureProtocol?: string;
+    servername?: string;
+    minVersion?: string;
+    maxVersion?: string;
+    initialDataTimeout?: number;
+    socketTimeout?: number;
+    inactivityCheckInterval?: number;
+    maxConnectionLifetime?: number;
+    inactivityTimeout?: number;
+    gracefulShutdownTimeout?: number;
+    globalPortRanges: Array<{
+        from: number;
+        to: number;
+    }>;
+    forwardAllGlobalRanges?: boolean;
+    noDelay?: boolean;
+    keepAlive?: boolean;
+    keepAliveInitialDelay?: number;
+    maxPendingDataSize?: number;
+    disableInactivityCheck?: boolean;
+    enableKeepAliveProbes?: boolean;
+    enableDetailedLogging?: boolean;
+    enableTlsDebugLogging?: boolean;
+    enableRandomizedTimeouts?: boolean;
+    allowSessionTicket?: boolean;
+    maxConnectionsPerIP?: number;
+    connectionRateLimitPerMinute?: number;
+    keepAliveTreatment?: 'standard' | 'extended' | 'immortal';
+    keepAliveInactivityMultiplier?: number;
+    extendedKeepAliveLifetime?: number;
+    useNetworkProxy?: number[];
+    networkProxyPort?: number;
+    acme?: {
+        enabled?: boolean;
+        port?: number;
+        contactEmail?: string;
+        useProduction?: boolean;
+        renewThresholdDays?: number;
+        autoRenew?: boolean;
+        certificateStore?: string;
+        skipConfiguredCerts?: boolean;
+    };
+}
+/**
+ * Enhanced connection record
+ */
+export interface IConnectionRecord {
+    id: string;
+    incoming: plugins.net.Socket;
+    outgoing: plugins.net.Socket | null;
+    incomingStartTime: number;
+    outgoingStartTime?: number;
+    outgoingClosedTime?: number;
+    lockedDomain?: string;
+    connectionClosed: boolean;
+    cleanupTimer?: NodeJS.Timeout;
+    lastActivity: number;
+    pendingData: Buffer[];
+    pendingDataSize: number;
+    bytesReceived: number;
+    bytesSent: number;
+    remoteIP: string;
+    localPort: number;
+    isTLS: boolean;
+    tlsHandshakeComplete: boolean;
+    hasReceivedInitialData: boolean;
+    domainConfig?: IDomainConfig;
+    hasKeepAlive: boolean;
+    inactivityWarningIssued?: boolean;
+    incomingTerminationReason?: string | null;
+    outgoingTerminationReason?: string | null;
+    usingNetworkProxy?: boolean;
+    renegotiationHandler?: (chunk: Buffer) => void;
+    isBrowserConnection?: boolean;
+    domainSwitches?: number;
+}

package/dist_ts/classes.pp.interfaces.js

@@ -0,0 +1,2 @@
+import * as plugins from './plugins.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5wcC5pbnRlcmZhY2VzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvY2xhc3Nlcy5wcC5pbnRlcmZhY2VzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sY0FBYyxDQUFDIn0=

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

@@ -0,0 +1,43 @@
+import * as plugins from './plugins.js';
+import { NetworkProxy } from './classes.networkproxy.js';
+import type { IConnectionRecord, IPortProxySettings } from './classes.pp.interfaces.js';
+/**
+ * Manages NetworkProxy integration for TLS termination
+ */
+export declare class NetworkProxyBridge {
+    private settings;
+    private networkProxy;
+    constructor(settings: IPortProxySettings);
+    /**
+     * Initialize NetworkProxy instance
+     */
+    initialize(): Promise<void>;
+    /**
+     * Get the NetworkProxy instance
+     */
+    getNetworkProxy(): NetworkProxy | null;
+    /**
+     * Get the NetworkProxy port
+     */
+    getNetworkProxyPort(): number;
+    /**
+     * Start NetworkProxy
+     */
+    start(): Promise<void>;
+    /**
+     * Stop NetworkProxy
+     */
+    stop(): Promise<void>;
+    /**
+     * Forwards a TLS connection to a NetworkProxy for handling
+     */
+    forwardToNetworkProxy(connectionId: string, socket: plugins.net.Socket, record: IConnectionRecord, initialData: Buffer, customProxyPort?: number, onError?: (reason: string) => void): void;
+    /**
+     * Synchronizes domain configurations to NetworkProxy
+     */
+    syncDomainConfigsToNetworkProxy(): Promise<void>;
+    /**
+     * Request a certificate for a specific domain
+     */
+    requestCertificate(domain: string): Promise<boolean>;
+}

package/dist_ts/classes.pp.networkproxybridge.js

@@ -0,0 +1,211 @@
+import * as plugins from './plugins.js';
+import { NetworkProxy } from './classes.networkproxy.js';
+/**
+ * Manages NetworkProxy integration for TLS termination
+ */
+export class NetworkProxyBridge {
+    constructor(settings) {
+        this.settings = settings;
+        this.networkProxy = null;
+    }
+    /**
+     * Initialize NetworkProxy instance
+     */
+    async initialize() {
+        if (!this.networkProxy && this.settings.useNetworkProxy && this.settings.useNetworkProxy.length > 0) {
+            // Configure NetworkProxy options based on PortProxy settings
+            const networkProxyOptions = {
+                port: this.settings.networkProxyPort,
+                portProxyIntegration: true,
+                logLevel: this.settings.enableDetailedLogging ? 'debug' : 'info',
+            };
+            // Add ACME settings if configured
+            if (this.settings.acme) {
+                networkProxyOptions.acme = { ...this.settings.acme };
+            }
+            this.networkProxy = new NetworkProxy(networkProxyOptions);
+            console.log(`Initialized NetworkProxy on port ${this.settings.networkProxyPort}`);
+            // Convert and apply domain configurations to NetworkProxy
+            await this.syncDomainConfigsToNetworkProxy();
+        }
+    }
+    /**
+     * Get the NetworkProxy instance
+     */
+    getNetworkProxy() {
+        return this.networkProxy;
+    }
+    /**
+     * Get the NetworkProxy port
+     */
+    getNetworkProxyPort() {
+        return this.networkProxy ? this.networkProxy.getListeningPort() : this.settings.networkProxyPort || 8443;
+    }
+    /**
+     * Start NetworkProxy
+     */
+    async start() {
+        if (this.networkProxy) {
+            await this.networkProxy.start();
+            console.log(`NetworkProxy started on port ${this.settings.networkProxyPort}`);
+            // Log ACME status
+            if (this.settings.acme?.enabled) {
+                console.log(`ACME certificate management is enabled (${this.settings.acme.useProduction ? 'Production' : 'Staging'} mode)`);
+                console.log(`ACME HTTP challenge server on port ${this.settings.acme.port}`);
+                // Register domains for ACME certificates if enabled
+                if (this.networkProxy.options.acme?.enabled) {
+                    console.log('Registering domains with ACME certificate manager...');
+                    // The NetworkProxy will handle this internally via registerDomainsWithAcmeManager()
+                }
+            }
+        }
+    }
+    /**
+     * Stop NetworkProxy
+     */
+    async stop() {
+        if (this.networkProxy) {
+            try {
+                console.log('Stopping NetworkProxy...');
+                await this.networkProxy.stop();
+                console.log('NetworkProxy stopped successfully');
+                // Log ACME shutdown if it was enabled
+                if (this.settings.acme?.enabled) {
+                    console.log('ACME certificate manager stopped');
+                }
+            }
+            catch (err) {
+                console.log(`Error stopping NetworkProxy: ${err}`);
+            }
+        }
+    }
+    /**
+     * Forwards a TLS connection to a NetworkProxy for handling
+     */
+    forwardToNetworkProxy(connectionId, socket, record, initialData, customProxyPort, onError) {
+        // Ensure NetworkProxy is initialized
+        if (!this.networkProxy) {
+            console.log(`[${connectionId}] NetworkProxy not initialized. Cannot forward connection.`);
+            if (onError) {
+                onError('network_proxy_not_initialized');
+            }
+            return;
+        }
+        // Use the custom port if provided, otherwise use the default NetworkProxy port
+        const proxyPort = customProxyPort || this.networkProxy.getListeningPort();
+        const proxyHost = 'localhost'; // Assuming NetworkProxy runs locally
+        if (this.settings.enableDetailedLogging) {
+            console.log(`[${connectionId}] Forwarding TLS connection to NetworkProxy at ${proxyHost}:${proxyPort}`);
+        }
+        // Create a connection to the NetworkProxy
+        const proxySocket = plugins.net.connect({
+            host: proxyHost,
+            port: proxyPort,
+        });
+        // Store the outgoing socket in the record
+        record.outgoing = proxySocket;
+        record.outgoingStartTime = Date.now();
+        record.usingNetworkProxy = true;
+        // Set up error handlers
+        proxySocket.on('error', (err) => {
+            console.log(`[${connectionId}] Error connecting to NetworkProxy: ${err.message}`);
+            if (onError) {
+                onError('network_proxy_connect_error');
+            }
+        });
+        // Handle connection to NetworkProxy
+        proxySocket.on('connect', () => {
+            if (this.settings.enableDetailedLogging) {
+                console.log(`[${connectionId}] Connected to NetworkProxy at ${proxyHost}:${proxyPort}`);
+            }
+            // First send the initial data that contains the TLS ClientHello
+            proxySocket.write(initialData);
+            // Now set up bidirectional piping between client and NetworkProxy
+            socket.pipe(proxySocket);
+            proxySocket.pipe(socket);
+            // Update activity on data transfer (caller should handle this)
+            if (this.settings.enableDetailedLogging) {
+                console.log(`[${connectionId}] TLS connection successfully forwarded to NetworkProxy`);
+            }
+        });
+    }
+    /**
+     * Synchronizes domain configurations to NetworkProxy
+     */
+    async syncDomainConfigsToNetworkProxy() {
+        if (!this.networkProxy) {
+            console.log('Cannot sync configurations - NetworkProxy not initialized');
+            return;
+        }
+        try {
+            // Get SSL certificates from assets
+            // Import fs directly since it's not in plugins
+            const fs = await import('fs');
+            let certPair;
+            try {
+                certPair = {
+                    key: fs.readFileSync('assets/certs/key.pem', 'utf8'),
+                    cert: fs.readFileSync('assets/certs/cert.pem', 'utf8'),
+                };
+            }
+            catch (certError) {
+                console.log(`Warning: Could not read default certificates: ${certError}`);
+                console.log('Using empty certificate placeholders - ACME will generate proper certificates if enabled');
+                // Use empty placeholders - NetworkProxy will use its internal defaults
+                // or ACME will generate proper ones if enabled
+                certPair = {
+                    key: '',
+                    cert: '',
+                };
+            }
+            // Convert domain configs to NetworkProxy configs
+            const proxyConfigs = this.networkProxy.convertPortProxyConfigs(this.settings.domainConfigs, certPair);
+            // Log ACME-eligible domains if ACME is enabled
+            if (this.settings.acme?.enabled) {
+                const acmeEligibleDomains = proxyConfigs
+                    .filter((config) => !config.hostName.includes('*')) // Exclude wildcards
+                    .map((config) => config.hostName);
+                if (acmeEligibleDomains.length > 0) {
+                    console.log(`Domains eligible for ACME certificates: ${acmeEligibleDomains.join(', ')}`);
+                }
+                else {
+                    console.log('No domains eligible for ACME certificates found in configuration');
+                }
+            }
+            // Update NetworkProxy with the converted configs
+            await this.networkProxy.updateProxyConfigs(proxyConfigs);
+            console.log(`Successfully synchronized ${proxyConfigs.length} domain configurations to NetworkProxy`);
+        }
+        catch (err) {
+            console.log(`Failed to sync configurations: ${err}`);
+        }
+    }
+    /**
+     * Request a certificate for a specific domain
+     */
+    async requestCertificate(domain) {
+        if (!this.networkProxy) {
+            console.log('Cannot request certificate - NetworkProxy not initialized');
+            return false;
+        }
+        if (!this.settings.acme?.enabled) {
+            console.log('Cannot request certificate - ACME is not enabled');
+            return false;
+        }
+        try {
+            const result = await this.networkProxy.requestCertificate(domain);
+            if (result) {
+                console.log(`Certificate request for ${domain} submitted successfully`);
+            }
+            else {
+                console.log(`Certificate request for ${domain} failed`);
+            }
+            return result;
+        }
+        catch (err) {
+            console.log(`Error requesting certificate: ${err}`);
+            return false;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.pp.networkproxybridge.js","sourceRoot":"","sources":["../ts/classes.pp.networkproxybridge.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,48 @@
+import type { IPortProxySettings, IDomainConfig } from './classes.pp.interfaces.js';
+import { DomainConfigManager } from './classes.pp.domainconfigmanager.js';
+/**
+ * PortProxy - Main class that coordinates all components
+ */
+export declare class PortProxy {
+    private netServers;
+    private connectionLogger;
+    private isShuttingDown;
+    private connectionManager;
+    private securityManager;
+    domainConfigManager: DomainConfigManager;
+    private tlsManager;
+    private networkProxyBridge;
+    private timeoutManager;
+    private acmeManager;
+    private portRangeManager;
+    private connectionHandler;
+    constructor(settingsArg: IPortProxySettings);
+    /**
+     * The settings for the port proxy
+     */
+    settings: IPortProxySettings;
+    /**
+     * Start the proxy server
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the proxy server
+     */
+    stop(): Promise<void>;
+    /**
+     * Updates the domain configurations for the proxy
+     */
+    updateDomainConfigs(newDomainConfigs: IDomainConfig[]): Promise<void>;
+    /**
+     * Updates the ACME certificate settings
+     */
+    updateAcmeSettings(acmeSettings: IPortProxySettings['acme']): Promise<void>;
+    /**
+     * Requests a certificate for a specific domain
+     */
+    requestCertificate(domain: string): Promise<boolean>;
+    /**
+     * Get statistics about current connections
+     */
+    getStatistics(): any;
+}