@push.rocks/smartproxy 5.1.0 → 6.0.0

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

@@ -0,0 +1,133 @@
+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;
+    port80HandlerConfig?: {
+        enabled?: boolean;
+        port?: number;
+        contactEmail?: string;
+        useProduction?: boolean;
+        renewThresholdDays?: number;
+        autoRenew?: boolean;
+        certificateStore?: string;
+        skipConfiguredCerts?: boolean;
+        httpsRedirectPort?: number;
+        renewCheckIntervalHours?: number;
+        domainForwards?: Array<{
+            domain: string;
+            forwardConfig?: {
+                ip: string;
+                port: number;
+            };
+            acmeForwardConfig?: {
+                ip: string;
+                port: 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;
+    alertFallbackTimeout?: 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/smartproxy/classes.pp.interfaces.js

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

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

@@ -0,0 +1,57 @@
+import * as plugins from '../plugins.js';
+import { NetworkProxy } from '../networkproxy/classes.np.networkproxy.js';
+import { Port80Handler } from '../port80handler/classes.port80handler.js';
+import type { IConnectionRecord, IPortProxySettings } from './classes.pp.interfaces.js';
+/**
+ * Manages NetworkProxy integration for TLS termination
+ */
+export declare class NetworkProxyBridge {
+    private settings;
+    private networkProxy;
+    private port80Handler;
+    constructor(settings: IPortProxySettings);
+    /**
+     * Set the Port80Handler to use for certificate management
+     */
+    setPort80Handler(handler: Port80Handler): void;
+    /**
+     * Initialize NetworkProxy instance
+     */
+    initialize(): Promise<void>;
+    /**
+     * Handle certificate issuance or renewal events
+     */
+    private handleCertificateEvent;
+    /**
+     * Get the NetworkProxy instance
+     */
+    getNetworkProxy(): NetworkProxy | null;
+    /**
+     * Get the NetworkProxy port
+     */
+    getNetworkProxyPort(): number;
+    /**
+     * Start NetworkProxy
+     */
+    start(): Promise<void>;
+    /**
+     * Stop NetworkProxy
+     */
+    stop(): Promise<void>;
+    /**
+     * Register domains with Port80Handler
+     */
+    registerDomainsWithPort80Handler(domains: string[]): 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/smartproxy/classes.pp.networkproxybridge.js

@@ -0,0 +1,306 @@
+import * as plugins from '../plugins.js';
+import { NetworkProxy } from '../networkproxy/classes.np.networkproxy.js';
+import { Port80Handler, Port80HandlerEvents } from '../port80handler/classes.port80handler.js';
+/**
+ * Manages NetworkProxy integration for TLS termination
+ */
+export class NetworkProxyBridge {
+    constructor(settings) {
+        this.settings = settings;
+        this.networkProxy = null;
+        this.port80Handler = null;
+    }
+    /**
+     * Set the Port80Handler to use for certificate management
+     */
+    setPort80Handler(handler) {
+        this.port80Handler = handler;
+        // Register for certificate events
+        handler.on(Port80HandlerEvents.CERTIFICATE_ISSUED, this.handleCertificateEvent.bind(this));
+        handler.on(Port80HandlerEvents.CERTIFICATE_RENEWED, this.handleCertificateEvent.bind(this));
+        // If NetworkProxy is already initialized, connect it with Port80Handler
+        if (this.networkProxy) {
+            this.networkProxy.setExternalPort80Handler(handler);
+        }
+        console.log('Port80Handler connected to NetworkProxyBridge');
+    }
+    /**
+     * 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',
+                useExternalPort80Handler: !!this.port80Handler // Use Port80Handler if available
+            };
+            // Copy ACME settings for backward compatibility (if port80HandlerConfig not set)
+            if (!this.settings.port80HandlerConfig && this.settings.acme) {
+                networkProxyOptions.acme = { ...this.settings.acme };
+            }
+            this.networkProxy = new NetworkProxy(networkProxyOptions);
+            console.log(`Initialized NetworkProxy on port ${this.settings.networkProxyPort}`);
+            // Connect Port80Handler if available
+            if (this.port80Handler) {
+                this.networkProxy.setExternalPort80Handler(this.port80Handler);
+            }
+            // Convert and apply domain configurations to NetworkProxy
+            await this.syncDomainConfigsToNetworkProxy();
+        }
+    }
+    /**
+     * Handle certificate issuance or renewal events
+     */
+    handleCertificateEvent(data) {
+        if (!this.networkProxy)
+            return;
+        console.log(`Received certificate for ${data.domain} from Port80Handler, updating NetworkProxy`);
+        try {
+            // Find existing config for this domain
+            const existingConfigs = this.networkProxy.getProxyConfigs()
+                .filter(config => config.hostName === data.domain);
+            if (existingConfigs.length > 0) {
+                // Update existing configs with new certificate
+                for (const config of existingConfigs) {
+                    config.privateKey = data.privateKey;
+                    config.publicKey = data.certificate;
+                }
+                // Apply updated configs
+                this.networkProxy.updateProxyConfigs(existingConfigs)
+                    .then(() => console.log(`Updated certificate for ${data.domain} in NetworkProxy`))
+                    .catch(err => console.log(`Error updating certificate in NetworkProxy: ${err}`));
+            }
+            else {
+                // Create a new config for this domain
+                console.log(`No existing config found for ${data.domain}, creating new config in NetworkProxy`);
+            }
+        }
+        catch (err) {
+            console.log(`Error handling certificate event: ${err}`);
+        }
+    }
+    /**
+     * 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}`);
+        }
+    }
+    /**
+     * Stop NetworkProxy
+     */
+    async stop() {
+        if (this.networkProxy) {
+            try {
+                console.log('Stopping NetworkProxy...');
+                await this.networkProxy.stop();
+                console.log('NetworkProxy stopped successfully');
+            }
+            catch (err) {
+                console.log(`Error stopping NetworkProxy: ${err}`);
+            }
+        }
+    }
+    /**
+     * Register domains with Port80Handler
+     */
+    registerDomainsWithPort80Handler(domains) {
+        if (!this.port80Handler) {
+            console.log('Cannot register domains - Port80Handler not initialized');
+            return;
+        }
+        for (const domain of domains) {
+            // Skip wildcards
+            if (domain.includes('*')) {
+                console.log(`Skipping wildcard domain for ACME: ${domain}`);
+                continue;
+            }
+            // Register the domain
+            try {
+                this.port80Handler.addDomain({
+                    domainName: domain,
+                    sslRedirect: true,
+                    acmeMaintenance: true
+                });
+                console.log(`Registered domain with Port80Handler: ${domain}`);
+            }
+            catch (err) {
+                console.log(`Error registering domain ${domain} with Port80Handler: ${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
+            const acmeEnabled = this.settings.port80HandlerConfig?.enabled || this.settings.acme?.enabled;
+            if (acmeEnabled) {
+                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(', ')}`);
+                    // Register these domains with Port80Handler if available
+                    if (this.port80Handler) {
+                        this.registerDomainsWithPort80Handler(acmeEligibleDomains);
+                    }
+                }
+                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) {
+        // Delegate to Port80Handler if available
+        if (this.port80Handler) {
+            try {
+                // Check if the domain is already registered
+                const cert = this.port80Handler.getCertificate(domain);
+                if (cert) {
+                    console.log(`Certificate already exists for ${domain}`);
+                    return true;
+                }
+                // Register the domain for certificate issuance
+                this.port80Handler.addDomain({
+                    domainName: domain,
+                    sslRedirect: true,
+                    acmeMaintenance: true
+                });
+                console.log(`Domain ${domain} registered for certificate issuance`);
+                return true;
+            }
+            catch (err) {
+                console.log(`Error requesting certificate: ${err}`);
+                return false;
+            }
+        }
+        // Fall back to NetworkProxy if Port80Handler is not available
+        if (!this.networkProxy) {
+            console.log('Cannot request certificate - NetworkProxy not initialized');
+            return false;
+        }
+        if (!this.settings.port80HandlerConfig?.enabled && !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/smartproxy/classes.pp.networkproxybridge.ts"],"names":[],"mappings":"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"}

package/dist_ts/smartproxy/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[];
+}