@push.rocks/smartproxy 12.0.0 → 13.1.2

package/dist_ts/proxies/network-proxy/certificate-manager.d.ts

@@ -0,0 +1,77 @@
+import * as plugins from '../../plugins.js';
+import { type INetworkProxyOptions, type ICertificateEntry } from './models/types.js';
+import { Port80Handler } from '../../http/port80/port80-handler.js';
+/**
+ * Manages SSL certificates for NetworkProxy including ACME integration
+ */
+export declare class CertificateManager {
+    private options;
+    private defaultCertificates;
+    private certificateCache;
+    private port80Handler;
+    private externalPort80Handler;
+    private certificateStoreDir;
+    private logger;
+    private httpsServer;
+    constructor(options: INetworkProxyOptions);
+    /**
+     * Loads default certificates from the filesystem
+     */
+    loadDefaultCertificates(): void;
+    /**
+     * Set the HTTPS server reference for context updates
+     */
+    setHttpsServer(server: plugins.https.Server): void;
+    /**
+     * Get default certificates
+     */
+    getDefaultCertificates(): {
+        key: string;
+        cert: string;
+    };
+    /**
+     * Sets an external Port80Handler for certificate management
+     */
+    setExternalPort80Handler(handler: Port80Handler): void;
+    /**
+     * Handle newly issued or renewed certificates from Port80Handler
+     */
+    private handleCertificateIssued;
+    /**
+     * Handle certificate issuance failures
+     */
+    private handleCertificateFailed;
+    /**
+     * Saves certificate and private key to the filesystem
+     */
+    private saveCertificateToStore;
+    /**
+     * Handles SNI (Server Name Indication) for TLS connections
+     * Used by the HTTPS server to select the correct certificate for each domain
+     */
+    handleSNI(domain: string, cb: (err: Error | null, ctx: plugins.tls.SecureContext) => void): void;
+    /**
+     * Updates certificate in cache
+     */
+    updateCertificateCache(domain: string, certificate: string, privateKey: string, expiryDate?: Date): void;
+    /**
+     * Gets a certificate for a domain
+     */
+    getCertificate(domain: string): ICertificateEntry | undefined;
+    /**
+     * Requests a new certificate for a domain
+     */
+    requestCertificate(domain: string): Promise<boolean>;
+    /**
+     * Registers domains with Port80Handler for ACME certificate management
+     */
+    registerDomainsWithPort80Handler(domains: string[]): void;
+    /**
+     * Initialize internal Port80Handler
+     */
+    initializePort80Handler(): Promise<Port80Handler | null>;
+    /**
+     * Stop the Port80Handler if it was internally created
+     */
+    stopPort80Handler(): Promise<void>;
+}

package/dist_ts/proxies/network-proxy/certificate-manager.js

@@ -0,0 +1,373 @@
+import * as plugins from '../../plugins.js';
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { createLogger } from './models/types.js';
+import { Port80Handler } from '../../http/port80/port80-handler.js';
+import { CertificateEvents } from '../../certificate/events/certificate-events.js';
+import { buildPort80Handler } from '../../certificate/acme/acme-factory.js';
+import { subscribeToPort80Handler } from '../../core/utils/event-utils.js';
+/**
+ * Manages SSL certificates for NetworkProxy including ACME integration
+ */
+export class CertificateManager {
+    constructor(options) {
+        this.options = options;
+        this.certificateCache = new Map();
+        this.port80Handler = null;
+        this.externalPort80Handler = false;
+        this.httpsServer = null;
+        this.certificateStoreDir = path.resolve(options.acme?.certificateStore || './certs');
+        this.logger = createLogger(options.logLevel || 'info');
+        // Ensure certificate store directory exists
+        try {
+            if (!fs.existsSync(this.certificateStoreDir)) {
+                fs.mkdirSync(this.certificateStoreDir, { recursive: true });
+                this.logger.info(`Created certificate store directory: ${this.certificateStoreDir}`);
+            }
+        }
+        catch (error) {
+            this.logger.warn(`Failed to create certificate store directory: ${error}`);
+        }
+        this.loadDefaultCertificates();
+    }
+    /**
+     * Loads default certificates from the filesystem
+     */
+    loadDefaultCertificates() {
+        const __dirname = path.dirname(fileURLToPath(import.meta.url));
+        // Fix the path to look for certificates at the project root instead of inside ts directory
+        const certPath = path.join(__dirname, '..', '..', '..', 'assets', 'certs');
+        try {
+            this.defaultCertificates = {
+                key: fs.readFileSync(path.join(certPath, 'key.pem'), 'utf8'),
+                cert: fs.readFileSync(path.join(certPath, 'cert.pem'), 'utf8')
+            };
+            this.logger.info('Default certificates loaded successfully');
+        }
+        catch (error) {
+            this.logger.error('Error loading default certificates', error);
+            // Generate self-signed fallback certificates
+            try {
+                // This is a placeholder for actual certificate generation code
+                // In a real implementation, you would use a library like selfsigned to generate certs
+                this.defaultCertificates = {
+                    key: "FALLBACK_KEY_CONTENT",
+                    cert: "FALLBACK_CERT_CONTENT"
+                };
+                this.logger.warn('Using fallback self-signed certificates');
+            }
+            catch (fallbackError) {
+                this.logger.error('Failed to generate fallback certificates', fallbackError);
+                throw new Error('Could not load or generate SSL certificates');
+            }
+        }
+    }
+    /**
+     * Set the HTTPS server reference for context updates
+     */
+    setHttpsServer(server) {
+        this.httpsServer = server;
+    }
+    /**
+     * Get default certificates
+     */
+    getDefaultCertificates() {
+        return { ...this.defaultCertificates };
+    }
+    /**
+     * Sets an external Port80Handler for certificate management
+     */
+    setExternalPort80Handler(handler) {
+        if (this.port80Handler && !this.externalPort80Handler) {
+            this.logger.warn('Replacing existing internal Port80Handler with external handler');
+            // Clean up existing handler if needed
+            if (this.port80Handler !== handler) {
+                // Unregister event handlers to avoid memory leaks
+                this.port80Handler.removeAllListeners(CertificateEvents.CERTIFICATE_ISSUED);
+                this.port80Handler.removeAllListeners(CertificateEvents.CERTIFICATE_RENEWED);
+                this.port80Handler.removeAllListeners(CertificateEvents.CERTIFICATE_FAILED);
+                this.port80Handler.removeAllListeners(CertificateEvents.CERTIFICATE_EXPIRING);
+            }
+        }
+        // Set the external handler
+        this.port80Handler = handler;
+        this.externalPort80Handler = true;
+        // Subscribe to Port80Handler events
+        subscribeToPort80Handler(this.port80Handler, {
+            onCertificateIssued: this.handleCertificateIssued.bind(this),
+            onCertificateRenewed: this.handleCertificateIssued.bind(this),
+            onCertificateFailed: this.handleCertificateFailed.bind(this),
+            onCertificateExpiring: (data) => {
+                this.logger.info(`Certificate for ${data.domain} expires in ${data.daysRemaining} days`);
+            }
+        });
+        this.logger.info('External Port80Handler connected to CertificateManager');
+        // Register domains with Port80Handler if we have any certificates cached
+        if (this.certificateCache.size > 0) {
+            const domains = Array.from(this.certificateCache.keys())
+                .filter(domain => !domain.includes('*')); // Skip wildcard domains
+            this.registerDomainsWithPort80Handler(domains);
+        }
+    }
+    /**
+     * Handle newly issued or renewed certificates from Port80Handler
+     */
+    handleCertificateIssued(data) {
+        const { domain, certificate, privateKey, expiryDate } = data;
+        this.logger.info(`Certificate ${this.certificateCache.has(domain) ? 'renewed' : 'issued'} for ${domain}, valid until ${expiryDate.toISOString()}`);
+        // Update certificate in HTTPS server
+        this.updateCertificateCache(domain, certificate, privateKey, expiryDate);
+        // Save the certificate to the filesystem if not using external handler
+        if (!this.externalPort80Handler && this.options.acme?.certificateStore) {
+            this.saveCertificateToStore(domain, certificate, privateKey);
+        }
+    }
+    /**
+     * Handle certificate issuance failures
+     */
+    handleCertificateFailed(data) {
+        this.logger.error(`Certificate issuance failed for ${data.domain}: ${data.error}`);
+    }
+    /**
+     * Saves certificate and private key to the filesystem
+     */
+    saveCertificateToStore(domain, certificate, privateKey) {
+        try {
+            const certPath = path.join(this.certificateStoreDir, `${domain}.cert.pem`);
+            const keyPath = path.join(this.certificateStoreDir, `${domain}.key.pem`);
+            fs.writeFileSync(certPath, certificate);
+            fs.writeFileSync(keyPath, privateKey);
+            // Ensure private key has restricted permissions
+            try {
+                fs.chmodSync(keyPath, 0o600);
+            }
+            catch (error) {
+                this.logger.warn(`Failed to set permissions on private key for ${domain}: ${error}`);
+            }
+            this.logger.info(`Saved certificate for ${domain} to ${certPath}`);
+        }
+        catch (error) {
+            this.logger.error(`Failed to save certificate for ${domain}: ${error}`);
+        }
+    }
+    /**
+     * Handles SNI (Server Name Indication) for TLS connections
+     * Used by the HTTPS server to select the correct certificate for each domain
+     */
+    handleSNI(domain, cb) {
+        this.logger.debug(`SNI request for domain: ${domain}`);
+        // Check if we have a certificate for this domain
+        const certs = this.certificateCache.get(domain);
+        if (certs) {
+            try {
+                // Create TLS context with the cached certificate
+                const context = plugins.tls.createSecureContext({
+                    key: certs.key,
+                    cert: certs.cert
+                });
+                this.logger.debug(`Using cached certificate for ${domain}`);
+                cb(null, context);
+                return;
+            }
+            catch (err) {
+                this.logger.error(`Error creating secure context for ${domain}:`, err);
+            }
+        }
+        // No existing certificate: trigger dynamic provisioning via Port80Handler
+        if (this.port80Handler) {
+            try {
+                this.logger.info(`Triggering on-demand certificate retrieval for ${domain}`);
+                this.port80Handler.addDomain({
+                    domainName: domain,
+                    sslRedirect: false,
+                    acmeMaintenance: true
+                });
+            }
+            catch (err) {
+                this.logger.error(`Error registering domain for on-demand certificate: ${domain}`, err);
+            }
+        }
+        // Check if we should trigger certificate issuance
+        if (this.options.acme?.enabled && this.port80Handler && !domain.includes('*')) {
+            // Check if this domain is already registered
+            const certData = this.port80Handler.getCertificate(domain);
+            if (!certData) {
+                this.logger.info(`No certificate found for ${domain}, registering for issuance`);
+                // Register with new domain options format
+                const domainOptions = {
+                    domainName: domain,
+                    sslRedirect: true,
+                    acmeMaintenance: true
+                };
+                this.port80Handler.addDomain(domainOptions);
+            }
+        }
+        // Fall back to default certificate
+        try {
+            const context = plugins.tls.createSecureContext({
+                key: this.defaultCertificates.key,
+                cert: this.defaultCertificates.cert
+            });
+            this.logger.debug(`Using default certificate for ${domain}`);
+            cb(null, context);
+        }
+        catch (err) {
+            this.logger.error(`Error creating default secure context:`, err);
+            cb(new Error('Cannot create secure context'), null);
+        }
+    }
+    /**
+     * Updates certificate in cache
+     */
+    updateCertificateCache(domain, certificate, privateKey, expiryDate) {
+        // Update certificate context in HTTPS server if it's running
+        if (this.httpsServer) {
+            try {
+                this.httpsServer.addContext(domain, {
+                    key: privateKey,
+                    cert: certificate
+                });
+                this.logger.debug(`Updated SSL context for domain: ${domain}`);
+            }
+            catch (error) {
+                this.logger.error(`Error updating SSL context for domain ${domain}:`, error);
+            }
+        }
+        // Update certificate in cache
+        this.certificateCache.set(domain, {
+            key: privateKey,
+            cert: certificate,
+            expires: expiryDate
+        });
+    }
+    /**
+     * Gets a certificate for a domain
+     */
+    getCertificate(domain) {
+        return this.certificateCache.get(domain);
+    }
+    /**
+     * Requests a new certificate for a domain
+     */
+    async requestCertificate(domain) {
+        if (!this.options.acme?.enabled && !this.externalPort80Handler) {
+            this.logger.warn('ACME certificate management is not enabled');
+            return false;
+        }
+        if (!this.port80Handler) {
+            this.logger.error('Port80Handler is not initialized');
+            return false;
+        }
+        // Skip wildcard domains - can't get certs for these with HTTP-01 validation
+        if (domain.includes('*')) {
+            this.logger.error(`Cannot request certificate for wildcard domain: ${domain}`);
+            return false;
+        }
+        try {
+            // Use the new domain options format
+            const domainOptions = {
+                domainName: domain,
+                sslRedirect: true,
+                acmeMaintenance: true
+            };
+            this.port80Handler.addDomain(domainOptions);
+            this.logger.info(`Certificate request submitted for domain: ${domain}`);
+            return true;
+        }
+        catch (error) {
+            this.logger.error(`Error requesting certificate for domain ${domain}:`, error);
+            return false;
+        }
+    }
+    /**
+     * Registers domains with Port80Handler for ACME certificate management
+     */
+    registerDomainsWithPort80Handler(domains) {
+        if (!this.port80Handler) {
+            this.logger.warn('Port80Handler is not initialized');
+            return;
+        }
+        for (const domain of domains) {
+            // Skip wildcard domains - can't get certs for these with HTTP-01 validation
+            if (domain.includes('*')) {
+                this.logger.info(`Skipping wildcard domain for ACME: ${domain}`);
+                continue;
+            }
+            // Skip domains already with certificates if configured to do so
+            if (this.options.acme?.skipConfiguredCerts) {
+                const cachedCert = this.certificateCache.get(domain);
+                if (cachedCert) {
+                    this.logger.info(`Skipping domain with existing certificate: ${domain}`);
+                    continue;
+                }
+            }
+            // Register the domain for certificate issuance with new domain options format
+            const domainOptions = {
+                domainName: domain,
+                sslRedirect: true,
+                acmeMaintenance: true
+            };
+            this.port80Handler.addDomain(domainOptions);
+            this.logger.info(`Registered domain for ACME certificate issuance: ${domain}`);
+        }
+    }
+    /**
+     * Initialize internal Port80Handler
+     */
+    async initializePort80Handler() {
+        // Skip if using external handler
+        if (this.externalPort80Handler) {
+            this.logger.info('Using external Port80Handler, skipping initialization');
+            return this.port80Handler;
+        }
+        if (!this.options.acme?.enabled) {
+            return null;
+        }
+        // Build and configure Port80Handler
+        this.port80Handler = buildPort80Handler({
+            port: this.options.acme.port,
+            accountEmail: this.options.acme.accountEmail,
+            useProduction: this.options.acme.useProduction,
+            httpsRedirectPort: this.options.port, // Redirect to our HTTPS port
+            enabled: this.options.acme.enabled,
+            certificateStore: this.options.acme.certificateStore,
+            skipConfiguredCerts: this.options.acme.skipConfiguredCerts
+        });
+        // Subscribe to Port80Handler events
+        subscribeToPort80Handler(this.port80Handler, {
+            onCertificateIssued: this.handleCertificateIssued.bind(this),
+            onCertificateRenewed: this.handleCertificateIssued.bind(this),
+            onCertificateFailed: this.handleCertificateFailed.bind(this),
+            onCertificateExpiring: (data) => {
+                this.logger.info(`Certificate for ${data.domain} expires in ${data.daysRemaining} days`);
+            }
+        });
+        // Start the handler
+        try {
+            await this.port80Handler.start();
+            this.logger.info(`Port80Handler started on port ${this.options.acme.port}`);
+            return this.port80Handler;
+        }
+        catch (error) {
+            this.logger.error(`Failed to start Port80Handler: ${error}`);
+            this.port80Handler = null;
+            return null;
+        }
+    }
+    /**
+     * Stop the Port80Handler if it was internally created
+     */
+    async stopPort80Handler() {
+        if (this.port80Handler && !this.externalPort80Handler) {
+            try {
+                await this.port80Handler.stop();
+                this.logger.info('Port80Handler stopped');
+            }
+            catch (error) {
+                this.logger.error('Error stopping Port80Handler', error);
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"certificate-manager.js","sourceRoot":"","sources":["../../../ts/proxies/network-proxy/certificate-manager.ts"],"names":[],"mappings":"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"}

package/dist_ts/proxies/network-proxy/connection-pool.d.ts

@@ -0,0 +1,47 @@
+import * as plugins from '../../plugins.js';
+import { type INetworkProxyOptions } from './models/types.js';
+/**
+ * Manages a pool of backend connections for efficient reuse
+ */
+export declare class ConnectionPool {
+    private options;
+    private connectionPool;
+    private roundRobinPositions;
+    private logger;
+    constructor(options: INetworkProxyOptions);
+    /**
+     * Get a connection from the pool or create a new one
+     */
+    getConnection(host: string, port: number): Promise<plugins.net.Socket>;
+    /**
+     * Return a connection to the pool for reuse
+     */
+    returnConnection(socket: plugins.net.Socket, host: string, port: number): void;
+    /**
+     * Cleanup the connection pool by removing idle connections
+     * or reducing pool size if it exceeds the configured maximum
+     */
+    cleanupConnectionPool(): void;
+    /**
+     * Close all connections in the pool
+     */
+    closeAllConnections(): void;
+    /**
+     * Get load balancing target using round-robin
+     */
+    getNextTarget(targets: string[], port: number): {
+        host: string;
+        port: number;
+    };
+    /**
+     * Gets the connection pool status
+     */
+    getPoolStatus(): Record<string, {
+        total: number;
+        idle: number;
+    }>;
+    /**
+     * Setup a periodic cleanup task
+     */
+    setupPeriodicCleanup(interval?: number): NodeJS.Timeout;
+}