@push.rocks/smartproxy 12.0.0 → 13.1.2

package/dist_ts/proxies/smart-proxy/domain-config-manager.js

@@ -0,0 +1,255 @@
+import * as plugins from '../../plugins.js';
+import { ForwardingHandlerFactory } from '../../forwarding/factory/forwarding-factory.js';
+/**
+ * Manages domain configurations and target selection
+ */
+export class DomainConfigManager {
+    constructor(settings) {
+        this.settings = settings;
+        // Track round-robin indices for domain configs
+        this.domainTargetIndices = new Map();
+        // Cache forwarding handlers for each domain config
+        this.forwardingHandlers = new Map();
+    }
+    /**
+     * Updates the domain configurations
+     */
+    updateDomainConfigs(newDomainConfigs) {
+        this.settings.domainConfigs = newDomainConfigs;
+        // Reset target indices for removed configs
+        const currentConfigSet = new Set(newDomainConfigs);
+        for (const [config] of this.domainTargetIndices) {
+            if (!currentConfigSet.has(config)) {
+                this.domainTargetIndices.delete(config);
+            }
+        }
+        // Clear handlers for removed configs and create handlers for new configs
+        const handlersToRemove = [];
+        for (const [config] of this.forwardingHandlers) {
+            if (!currentConfigSet.has(config)) {
+                handlersToRemove.push(config);
+            }
+        }
+        // Remove handlers that are no longer needed
+        for (const config of handlersToRemove) {
+            this.forwardingHandlers.delete(config);
+        }
+        // Create handlers for new configs
+        for (const config of newDomainConfigs) {
+            if (!this.forwardingHandlers.has(config)) {
+                try {
+                    const handler = this.createForwardingHandler(config);
+                    this.forwardingHandlers.set(config, handler);
+                }
+                catch (err) {
+                    console.log(`Error creating forwarding handler for domain ${config.domains.join(', ')}: ${err}`);
+                }
+            }
+        }
+    }
+    /**
+     * Get all domain configurations
+     */
+    getDomainConfigs() {
+        return this.settings.domainConfigs;
+    }
+    /**
+     * Find domain config matching a server name
+     */
+    findDomainConfig(serverName) {
+        if (!serverName)
+            return undefined;
+        return this.settings.domainConfigs.find((config) => config.domains.some((d) => plugins.minimatch(serverName, d)));
+    }
+    /**
+     * Find domain config for a specific port
+     */
+    findDomainConfigForPort(port) {
+        return this.settings.domainConfigs.find((domain) => {
+            const portRanges = domain.forwarding?.advanced?.portRanges;
+            return portRanges &&
+                portRanges.length > 0 &&
+                this.isPortInRanges(port, portRanges);
+        });
+    }
+    /**
+     * Check if a port is within any of the given ranges
+     */
+    isPortInRanges(port, ranges) {
+        return ranges.some((range) => port >= range.from && port <= range.to);
+    }
+    /**
+     * Get target IP with round-robin support
+     */
+    getTargetIP(domainConfig) {
+        const targetHosts = Array.isArray(domainConfig.forwarding.target.host)
+            ? domainConfig.forwarding.target.host
+            : [domainConfig.forwarding.target.host];
+        if (targetHosts.length > 0) {
+            const currentIndex = this.domainTargetIndices.get(domainConfig) || 0;
+            const ip = targetHosts[currentIndex % targetHosts.length];
+            this.domainTargetIndices.set(domainConfig, currentIndex + 1);
+            return ip;
+        }
+        return this.settings.targetIP || 'localhost';
+    }
+    /**
+     * Get target host with round-robin support (for tests)
+     * This is just an alias for getTargetIP for easier test compatibility
+     */
+    getTargetHost(domainConfig) {
+        return this.getTargetIP(domainConfig);
+    }
+    /**
+     * Get target port from domain config
+     */
+    getTargetPort(domainConfig, defaultPort) {
+        return domainConfig.forwarding.target.port || defaultPort;
+    }
+    /**
+     * Checks if a domain should use NetworkProxy
+     */
+    shouldUseNetworkProxy(domainConfig) {
+        const forwardingType = this.getForwardingType(domainConfig);
+        return forwardingType === 'https-terminate-to-http' ||
+            forwardingType === 'https-terminate-to-https';
+    }
+    /**
+     * Gets the NetworkProxy port for a domain
+     */
+    getNetworkProxyPort(domainConfig) {
+        // First check if we should use NetworkProxy at all
+        if (!this.shouldUseNetworkProxy(domainConfig)) {
+            return undefined;
+        }
+        return domainConfig.forwarding.advanced?.networkProxyPort || this.settings.networkProxyPort;
+    }
+    /**
+     * Get effective allowed and blocked IPs for a domain
+     *
+     * This method combines domain-specific security rules from the forwarding configuration
+     * with global security defaults when necessary.
+     */
+    getEffectiveIPRules(domainConfig) {
+        // Start with empty arrays
+        const allowedIPs = [];
+        const blockedIPs = [];
+        // Add IPs from forwarding security settings if available
+        if (domainConfig.forwarding?.security?.allowedIps) {
+            allowedIPs.push(...domainConfig.forwarding.security.allowedIps);
+        }
+        else {
+            // If no allowed IPs are specified in forwarding config and global defaults exist, use them
+            if (this.settings.defaultAllowedIPs && this.settings.defaultAllowedIPs.length > 0) {
+                allowedIPs.push(...this.settings.defaultAllowedIPs);
+            }
+            else {
+                // Default to allow all if no specific rules
+                allowedIPs.push('*');
+            }
+        }
+        // Add blocked IPs from forwarding security settings if available
+        if (domainConfig.forwarding?.security?.blockedIps) {
+            blockedIPs.push(...domainConfig.forwarding.security.blockedIps);
+        }
+        // Always add global blocked IPs, even if domain has its own rules
+        // This ensures that global blocks take precedence
+        if (this.settings.defaultBlockedIPs && this.settings.defaultBlockedIPs.length > 0) {
+            // Add only unique IPs that aren't already in the list
+            for (const ip of this.settings.defaultBlockedIPs) {
+                if (!blockedIPs.includes(ip)) {
+                    blockedIPs.push(ip);
+                }
+            }
+        }
+        return {
+            allowedIPs,
+            blockedIPs
+        };
+    }
+    /**
+     * Get connection timeout for a domain
+     */
+    getConnectionTimeout(domainConfig) {
+        if (domainConfig?.forwarding.advanced?.timeout) {
+            return domainConfig.forwarding.advanced.timeout;
+        }
+        return this.settings.maxConnectionLifetime || 86400000; // 24 hours default
+    }
+    /**
+     * Creates a forwarding handler for a domain configuration
+     */
+    createForwardingHandler(domainConfig) {
+        // Create a new handler using the factory
+        const handler = ForwardingHandlerFactory.createHandler(domainConfig.forwarding);
+        // Initialize the handler
+        handler.initialize().catch(err => {
+            console.log(`Error initializing forwarding handler for ${domainConfig.domains.join(', ')}: ${err}`);
+        });
+        return handler;
+    }
+    /**
+     * Gets a forwarding handler for a domain config
+     * If no handler exists, creates one
+     */
+    getForwardingHandler(domainConfig) {
+        // If we already have a handler, return it
+        if (this.forwardingHandlers.has(domainConfig)) {
+            return this.forwardingHandlers.get(domainConfig);
+        }
+        // Otherwise create a new handler
+        const handler = this.createForwardingHandler(domainConfig);
+        this.forwardingHandlers.set(domainConfig, handler);
+        return handler;
+    }
+    /**
+     * Gets the forwarding type for a domain config
+     */
+    getForwardingType(domainConfig) {
+        if (!domainConfig?.forwarding)
+            return undefined;
+        return domainConfig.forwarding.type;
+    }
+    /**
+     * Checks if the forwarding type requires TLS termination
+     */
+    requiresTlsTermination(domainConfig) {
+        if (!domainConfig)
+            return false;
+        const forwardingType = this.getForwardingType(domainConfig);
+        return forwardingType === 'https-terminate-to-http' ||
+            forwardingType === 'https-terminate-to-https';
+    }
+    /**
+     * Checks if the forwarding type supports HTTP
+     */
+    supportsHttp(domainConfig) {
+        if (!domainConfig)
+            return false;
+        const forwardingType = this.getForwardingType(domainConfig);
+        // HTTP-only always supports HTTP
+        if (forwardingType === 'http-only')
+            return true;
+        // For termination types, check the HTTP settings
+        if (forwardingType === 'https-terminate-to-http' ||
+            forwardingType === 'https-terminate-to-https') {
+            // HTTP is supported by default for termination types
+            return domainConfig.forwarding?.http?.enabled !== false;
+        }
+        // HTTPS-passthrough doesn't support HTTP
+        return false;
+    }
+    /**
+     * Checks if HTTP requests should be redirected to HTTPS
+     */
+    shouldRedirectToHttps(domainConfig) {
+        if (!domainConfig?.forwarding)
+            return false;
+        // Only check for redirect if HTTP is enabled
+        if (this.supportsHttp(domainConfig)) {
+            return !!domainConfig.forwarding.http?.redirectToHttps;
+        }
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"domain-config-manager.js","sourceRoot":"","sources":["../../../ts/proxies/smart-proxy/domain-config-manager.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,13 @@
+/**
+ * SmartProxy implementation
+ */
+export * from './models/index.js';
+export { SmartProxy } from './smart-proxy.js';
+export { ConnectionManager } from './connection-manager.js';
+export { SecurityManager } from './security-manager.js';
+export { DomainConfigManager } from './domain-config-manager.js';
+export { TimeoutManager } from './timeout-manager.js';
+export { TlsManager } from './tls-manager.js';
+export { NetworkProxyBridge } from './network-proxy-bridge.js';
+export { PortRangeManager } from './port-range-manager.js';
+export { ConnectionHandler } from './connection-handler.js';

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

@@ -0,0 +1,17 @@
+/**
+ * SmartProxy implementation
+ */
+// Re-export models
+export * from './models/index.js';
+// Export the main SmartProxy class
+export { SmartProxy } from './smart-proxy.js';
+// Export supporting classes
+export { ConnectionManager } from './connection-manager.js';
+export { SecurityManager } from './security-manager.js';
+export { DomainConfigManager } from './domain-config-manager.js';
+export { TimeoutManager } from './timeout-manager.js';
+export { TlsManager } from './tls-manager.js';
+export { NetworkProxyBridge } from './network-proxy-bridge.js';
+export { PortRangeManager } from './port-range-manager.js';
+export { ConnectionHandler } from './connection-handler.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9wcm94aWVzL3NtYXJ0LXByb3h5L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsbUJBQW1CO0FBQ25CLGNBQWMsbUJBQW1CLENBQUM7QUFFbEMsbUNBQW1DO0FBQ25DLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUU5Qyw0QkFBNEI7QUFDNUIsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDNUQsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBQ3hELE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBQ2pFLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUN0RCxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDOUMsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFDL0QsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDM0QsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0seUJBQXlCLENBQUMifQ==

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

@@ -0,0 +1,4 @@
+/**
+ * SmartProxy models
+ */
+export * from './interfaces.js';

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

@@ -0,0 +1,5 @@
+/**
+ * SmartProxy models
+ */
+export * from './interfaces.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi90cy9wcm94aWVzL3NtYXJ0LXByb3h5L21vZGVscy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUNILGNBQWMsaUJBQWlCLENBQUMifQ==

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

@@ -0,0 +1,107 @@
+import * as plugins from '../../../plugins.js';
+import type { IForwardConfig } from '../../../forwarding/config/forwarding-types.js';
+/**
+ * Provision object for static or HTTP-01 certificate
+ */
+export type TSmartProxyCertProvisionObject = plugins.tsclass.network.ICert | 'http01';
+/**
+ * Domain configuration with forwarding configuration
+ */
+export interface IDomainConfig {
+    domains: string[];
+    forwarding: IForwardConfig;
+}
+/**
+ * Configuration options for the SmartProxy
+ */
+import type { IAcmeOptions } from '../../../certificate/models/certificate-types.js';
+export interface ISmartProxyOptions {
+    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?: IAcmeOptions;
+    /**
+     * Optional certificate provider callback. Return 'http01' to use HTTP-01 challenges,
+     * or a static certificate object for immediate provisioning.
+     */
+    certProvisionFunction?: (domain: string) => Promise<TSmartProxyCertProvisionObject>;
+}
+/**
+ * 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/proxies/smart-proxy/models/interfaces.js

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

package/dist_ts/proxies/smart-proxy/network-proxy-bridge.d.ts

@@ -0,0 +1,62 @@
+import * as plugins from '../../plugins.js';
+import { NetworkProxy } from '../network-proxy/index.js';
+import { Port80Handler } from '../../http/port80/port80-handler.js';
+import type { ICertificateData } from '../../certificate/models/certificate-types.js';
+import type { IConnectionRecord, ISmartProxyOptions } from './models/interfaces.js';
+/**
+ * Manages NetworkProxy integration for TLS termination
+ */
+export declare class NetworkProxyBridge {
+    private settings;
+    private networkProxy;
+    private port80Handler;
+    constructor(settings: ISmartProxyOptions);
+    /**
+     * 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;
+    /**
+     * Apply an external (static) certificate into NetworkProxy
+     */
+    applyExternalCertificate(data: ICertificateData): void;
+    /**
+     * 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>;
+}