@push.rocks/smartproxy 18.0.2 → 18.2.0

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

@@ -0,0 +1,401 @@
+import * as plugins from '../../plugins.js';
+import { NetworkProxy } from '../network-proxy/index.js';
+import { CertStore } from './cert-store.js';
+export class SmartCertManager {
+    constructor(routes, certDir = './certs', acmeOptions) {
+        this.routes = routes;
+        this.certDir = certDir;
+        this.acmeOptions = acmeOptions;
+        this.smartAcme = null;
+        this.networkProxy = null;
+        this.renewalTimer = null;
+        this.pendingChallenges = new Map();
+        this.challengeRoute = null;
+        // Track certificate status by route name
+        this.certStatus = new Map();
+        this.certStore = new CertStore(certDir);
+    }
+    setNetworkProxy(networkProxy) {
+        this.networkProxy = networkProxy;
+    }
+    /**
+     * Set callback for updating routes (used for challenge routes)
+     */
+    setUpdateRoutesCallback(callback) {
+        this.updateRoutesCallback = callback;
+    }
+    /**
+     * Initialize certificate manager and provision certificates for all routes
+     */
+    async initialize() {
+        // Create certificate directory if it doesn't exist
+        await this.certStore.initialize();
+        // Initialize SmartAcme if we have any ACME routes
+        const hasAcmeRoutes = this.routes.some(r => r.action.tls?.certificate === 'auto');
+        if (hasAcmeRoutes && this.acmeOptions?.email) {
+            // Create HTTP-01 challenge handler
+            const http01Handler = new plugins.smartacme.handlers.Http01MemoryHandler();
+            // Set up challenge handler integration with our routing
+            this.setupChallengeHandler(http01Handler);
+            // Create SmartAcme instance with built-in MemoryCertManager and HTTP-01 handler
+            this.smartAcme = new plugins.smartacme.SmartAcme({
+                accountEmail: this.acmeOptions.email,
+                environment: this.acmeOptions.useProduction ? 'production' : 'integration',
+                certManager: new plugins.smartacme.certmanagers.MemoryCertManager(),
+                challengeHandlers: [http01Handler]
+            });
+            await this.smartAcme.start();
+        }
+        // Provision certificates for all routes
+        await this.provisionAllCertificates();
+        // Start renewal timer
+        this.startRenewalTimer();
+    }
+    /**
+     * Provision certificates for all routes that need them
+     */
+    async provisionAllCertificates() {
+        const certRoutes = this.routes.filter(r => r.action.tls?.mode === 'terminate' ||
+            r.action.tls?.mode === 'terminate-and-reencrypt');
+        for (const route of certRoutes) {
+            try {
+                await this.provisionCertificate(route);
+            }
+            catch (error) {
+                console.error(`Failed to provision certificate for route ${route.name}: ${error}`);
+            }
+        }
+    }
+    /**
+     * Provision certificate for a single route
+     */
+    async provisionCertificate(route) {
+        const tls = route.action.tls;
+        if (!tls || (tls.mode !== 'terminate' && tls.mode !== 'terminate-and-reencrypt')) {
+            return;
+        }
+        const domains = this.extractDomainsFromRoute(route);
+        if (domains.length === 0) {
+            console.warn(`Route ${route.name} has TLS termination but no domains`);
+            return;
+        }
+        const primaryDomain = domains[0];
+        if (tls.certificate === 'auto') {
+            // ACME certificate
+            await this.provisionAcmeCertificate(route, domains);
+        }
+        else if (typeof tls.certificate === 'object') {
+            // Static certificate
+            await this.provisionStaticCertificate(route, primaryDomain, tls.certificate);
+        }
+    }
+    /**
+     * Provision ACME certificate
+     */
+    async provisionAcmeCertificate(route, domains) {
+        if (!this.smartAcme) {
+            throw new Error('SmartAcme not initialized');
+        }
+        const primaryDomain = domains[0];
+        const routeName = route.name || primaryDomain;
+        // Check if we already have a valid certificate
+        const existingCert = await this.certStore.getCertificate(routeName);
+        if (existingCert && this.isCertificateValid(existingCert)) {
+            console.log(`Using existing valid certificate for ${primaryDomain}`);
+            await this.applyCertificate(primaryDomain, existingCert);
+            this.updateCertStatus(routeName, 'valid', 'acme', existingCert);
+            return;
+        }
+        console.log(`Requesting ACME certificate for ${domains.join(', ')}`);
+        this.updateCertStatus(routeName, 'pending', 'acme');
+        try {
+            // Add challenge route before requesting certificate
+            await this.addChallengeRoute();
+            try {
+                // Use smartacme to get certificate
+                const cert = await this.smartAcme.getCertificateForDomain(primaryDomain);
+                // SmartAcme's Cert object has these properties:
+                // - publicKey: The certificate PEM string  
+                // - privateKey: The private key PEM string
+                // - csr: Certificate signing request
+                // - validUntil: Timestamp in milliseconds
+                // - domainName: The domain name
+                const certData = {
+                    cert: cert.publicKey,
+                    key: cert.privateKey,
+                    ca: cert.publicKey, // Use same as cert for now
+                    expiryDate: new Date(cert.validUntil),
+                    issueDate: new Date(cert.created)
+                };
+                await this.certStore.saveCertificate(routeName, certData);
+                await this.applyCertificate(primaryDomain, certData);
+                this.updateCertStatus(routeName, 'valid', 'acme', certData);
+                console.log(`Successfully provisioned ACME certificate for ${primaryDomain}`);
+            }
+            catch (error) {
+                console.error(`Failed to provision ACME certificate for ${primaryDomain}: ${error}`);
+                this.updateCertStatus(routeName, 'error', 'acme', undefined, error.message);
+                throw error;
+            }
+            finally {
+                // Always remove challenge route after provisioning
+                await this.removeChallengeRoute();
+            }
+        }
+        catch (error) {
+            // Handle outer try-catch from adding challenge route
+            console.error(`Failed to setup ACME challenge for ${primaryDomain}: ${error}`);
+            this.updateCertStatus(routeName, 'error', 'acme', undefined, error.message);
+            throw error;
+        }
+    }
+    /**
+     * Provision static certificate
+     */
+    async provisionStaticCertificate(route, domain, certConfig) {
+        const routeName = route.name || domain;
+        try {
+            let key = certConfig.key;
+            let cert = certConfig.cert;
+            // Load from files if paths are provided
+            if (certConfig.keyFile) {
+                const keyFile = await plugins.smartfile.SmartFile.fromFilePath(certConfig.keyFile);
+                key = keyFile.contents.toString();
+            }
+            if (certConfig.certFile) {
+                const certFile = await plugins.smartfile.SmartFile.fromFilePath(certConfig.certFile);
+                cert = certFile.contents.toString();
+            }
+            // Parse certificate to get dates
+            // Parse certificate to get dates - for now just use defaults
+            // TODO: Implement actual certificate parsing if needed
+            const certInfo = { validTo: new Date(Date.now() + 90 * 24 * 60 * 60 * 1000), validFrom: new Date() };
+            const certData = {
+                cert,
+                key,
+                expiryDate: certInfo.validTo,
+                issueDate: certInfo.validFrom
+            };
+            // Save to store for consistency
+            await this.certStore.saveCertificate(routeName, certData);
+            await this.applyCertificate(domain, certData);
+            this.updateCertStatus(routeName, 'valid', 'static', certData);
+            console.log(`Successfully loaded static certificate for ${domain}`);
+        }
+        catch (error) {
+            console.error(`Failed to provision static certificate for ${domain}: ${error}`);
+            this.updateCertStatus(routeName, 'error', 'static', undefined, error.message);
+            throw error;
+        }
+    }
+    /**
+     * Apply certificate to NetworkProxy
+     */
+    async applyCertificate(domain, certData) {
+        if (!this.networkProxy) {
+            console.warn('NetworkProxy not set, cannot apply certificate');
+            return;
+        }
+        // Apply certificate to NetworkProxy
+        this.networkProxy.updateCertificate(domain, certData.cert, certData.key);
+        // Also apply for wildcard if it's a subdomain
+        if (domain.includes('.') && !domain.startsWith('*.')) {
+            const parts = domain.split('.');
+            if (parts.length >= 2) {
+                const wildcardDomain = `*.${parts.slice(-2).join('.')}`;
+                this.networkProxy.updateCertificate(wildcardDomain, certData.cert, certData.key);
+            }
+        }
+    }
+    /**
+     * Extract domains from route configuration
+     */
+    extractDomainsFromRoute(route) {
+        if (!route.match.domains) {
+            return [];
+        }
+        const domains = Array.isArray(route.match.domains)
+            ? route.match.domains
+            : [route.match.domains];
+        // Filter out wildcards and patterns
+        return domains.filter(d => !d.includes('*') &&
+            !d.includes('{') &&
+            d.includes('.'));
+    }
+    /**
+     * Check if certificate is valid
+     */
+    isCertificateValid(cert) {
+        const now = new Date();
+        const expiryThreshold = new Date(now.getTime() + 30 * 24 * 60 * 60 * 1000); // 30 days
+        return cert.expiryDate > expiryThreshold;
+    }
+    /**
+     * Add challenge route to SmartProxy
+     */
+    async addChallengeRoute() {
+        if (!this.updateRoutesCallback) {
+            throw new Error('No route update callback set');
+        }
+        if (!this.challengeRoute) {
+            throw new Error('Challenge route not initialized');
+        }
+        const challengeRoute = this.challengeRoute;
+        const updatedRoutes = [...this.routes, challengeRoute];
+        await this.updateRoutesCallback(updatedRoutes);
+    }
+    /**
+     * Remove challenge route from SmartProxy
+     */
+    async removeChallengeRoute() {
+        if (!this.updateRoutesCallback) {
+            return;
+        }
+        const filteredRoutes = this.routes.filter(r => r.name !== 'acme-challenge');
+        await this.updateRoutesCallback(filteredRoutes);
+    }
+    /**
+     * Start renewal timer
+     */
+    startRenewalTimer() {
+        // Check for renewals every 12 hours
+        this.renewalTimer = setInterval(() => {
+            this.checkAndRenewCertificates();
+        }, 12 * 60 * 60 * 1000);
+        // Also do an immediate check
+        this.checkAndRenewCertificates();
+    }
+    /**
+     * Check and renew certificates that are expiring
+     */
+    async checkAndRenewCertificates() {
+        for (const route of this.routes) {
+            if (route.action.tls?.certificate === 'auto') {
+                const routeName = route.name || this.extractDomainsFromRoute(route)[0];
+                const cert = await this.certStore.getCertificate(routeName);
+                if (cert && !this.isCertificateValid(cert)) {
+                    console.log(`Certificate for ${routeName} needs renewal`);
+                    try {
+                        await this.provisionCertificate(route);
+                    }
+                    catch (error) {
+                        console.error(`Failed to renew certificate for ${routeName}: ${error}`);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Update certificate status
+     */
+    updateCertStatus(routeName, status, source, certData, error) {
+        this.certStatus.set(routeName, {
+            domain: routeName,
+            status,
+            source,
+            expiryDate: certData?.expiryDate,
+            issueDate: certData?.issueDate,
+            error
+        });
+    }
+    /**
+     * Get certificate status for a route
+     */
+    getCertificateStatus(routeName) {
+        return this.certStatus.get(routeName);
+    }
+    /**
+     * Force renewal of a certificate
+     */
+    async renewCertificate(routeName) {
+        const route = this.routes.find(r => r.name === routeName);
+        if (!route) {
+            throw new Error(`Route ${routeName} not found`);
+        }
+        // Remove existing certificate to force renewal
+        await this.certStore.deleteCertificate(routeName);
+        await this.provisionCertificate(route);
+    }
+    /**
+     * Setup challenge handler integration with SmartProxy routing
+     */
+    setupChallengeHandler(http01Handler) {
+        // Create a challenge route that delegates to SmartAcme's HTTP-01 handler
+        const challengeRoute = {
+            name: 'acme-challenge',
+            priority: 1000, // High priority
+            match: {
+                ports: 80,
+                path: '/.well-known/acme-challenge/*'
+            },
+            action: {
+                type: 'static',
+                handler: async (context) => {
+                    // Extract the token from the path
+                    const token = context.path?.split('/').pop();
+                    if (!token) {
+                        return { status: 404, body: 'Not found' };
+                    }
+                    // Create mock request/response objects for SmartAcme
+                    const mockReq = {
+                        url: context.path,
+                        method: 'GET',
+                        headers: context.headers || {}
+                    };
+                    let responseData = null;
+                    const mockRes = {
+                        statusCode: 200,
+                        setHeader: (name, value) => { },
+                        end: (data) => {
+                            responseData = data;
+                        }
+                    };
+                    // Use SmartAcme's handler
+                    const handled = await new Promise((resolve) => {
+                        http01Handler.handleRequest(mockReq, mockRes, () => {
+                            resolve(false);
+                        });
+                        // Give it a moment to process
+                        setTimeout(() => resolve(true), 100);
+                    });
+                    if (handled && responseData) {
+                        return {
+                            status: mockRes.statusCode,
+                            headers: { 'Content-Type': 'text/plain' },
+                            body: responseData
+                        };
+                    }
+                    else {
+                        return { status: 404, body: 'Not found' };
+                    }
+                }
+            }
+        };
+        // Store the challenge route to add it when needed
+        this.challengeRoute = challengeRoute;
+    }
+    /**
+     * Stop certificate manager
+     */
+    async stop() {
+        if (this.renewalTimer) {
+            clearInterval(this.renewalTimer);
+            this.renewalTimer = null;
+        }
+        if (this.smartAcme) {
+            await this.smartAcme.stop();
+        }
+        // Remove any active challenge routes
+        if (this.pendingChallenges.size > 0) {
+            this.pendingChallenges.clear();
+            await this.removeChallengeRoute();
+        }
+    }
+    /**
+     * Get ACME options (for recreating after route updates)
+     */
+    getAcmeOptions() {
+        return this.acmeOptions;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"certificate-manager.js","sourceRoot":"","sources":["../../../ts/proxies/smart-proxy/certificate-manager.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,168 @@
+import * as plugins from '../../plugins.js';
+import { RouteManager } from './route-manager.js';
+import type { ISmartProxyOptions } from './models/interfaces.js';
+import type { IRouteConfig } from './models/route-types.js';
+/**
+ * SmartProxy - Pure route-based API
+ *
+ * SmartProxy is a unified proxy system that works with routes to define connection handling behavior.
+ * Each route contains matching criteria (ports, domains, etc.) and an action to take (forward, redirect, block).
+ *
+ * Configuration is provided through a set of routes, with each route defining:
+ * - What to match (ports, domains, paths, client IPs)
+ * - What to do with matching traffic (forward, redirect, block)
+ * - How to handle TLS (passthrough, terminate, terminate-and-reencrypt)
+ * - Security settings (IP restrictions, connection limits)
+ * - Advanced options (timeout, headers, etc.)
+ */
+export declare class SmartProxy extends plugins.EventEmitter {
+    private portManager;
+    private connectionLogger;
+    private isShuttingDown;
+    private connectionManager;
+    private securityManager;
+    private tlsManager;
+    private networkProxyBridge;
+    private timeoutManager;
+    routeManager: RouteManager;
+    private routeConnectionHandler;
+    private nftablesManager;
+    private port80Handler;
+    private certProvisioner?;
+    /**
+     * Constructor for SmartProxy
+     *
+     * @param settingsArg Configuration options containing routes and other settings
+     * Routes define how traffic is matched and handled, with each route having:
+     * - match: criteria for matching traffic (ports, domains, paths, IPs)
+     * - action: what to do with matched traffic (forward, redirect, block)
+     *
+     * Example:
+     * ```ts
+     * const proxy = new SmartProxy({
+     *   routes: [
+     *     {
+     *       match: {
+     *         ports: 443,
+     *         domains: ['example.com', '*.example.com']
+     *       },
+     *       action: {
+     *         type: 'forward',
+     *         target: { host: '10.0.0.1', port: 8443 },
+     *         tls: { mode: 'passthrough' }
+     *       }
+     *     }
+     *   ],
+     *   defaults: {
+     *     target: { host: 'localhost', port: 8080 },
+     *     security: { ipAllowList: ['*'] }
+     *   }
+     * });
+     * ```
+     */
+    constructor(settingsArg: ISmartProxyOptions);
+    /**
+     * The settings for the SmartProxy
+     */
+    settings: ISmartProxyOptions;
+    /**
+     * Initialize the Port80Handler for ACME certificate management
+     */
+    private initializePort80Handler;
+    /**
+     * Start the proxy server with support for both configuration types
+     */
+    start(): Promise<void>;
+    /**
+     * Extract domain configurations from routes for certificate provisioning
+     *
+     * Note: This method has been removed as we now work directly with routes
+     */
+    /**
+     * Stop the proxy server
+     */
+    stop(): Promise<void>;
+    /**
+     * Updates the domain configurations for the proxy
+     *
+     * Note: This legacy method has been removed. Use updateRoutes instead.
+     */
+    updateDomainConfigs(): Promise<void>;
+    /**
+     * Update routes with new configuration
+     *
+     * This method replaces the current route configuration with the provided routes.
+     * It also provisions certificates for routes that require TLS termination and have
+     * `certificate: 'auto'` set in their TLS configuration.
+     *
+     * @param newRoutes Array of route configurations to use
+     *
+     * Example:
+     * ```ts
+     * proxy.updateRoutes([
+     *   {
+     *     match: { ports: 443, domains: 'secure.example.com' },
+     *     action: {
+     *       type: 'forward',
+     *       target: { host: '10.0.0.1', port: 8443 },
+     *       tls: { mode: 'terminate', certificate: 'auto' }
+     *     }
+     *   }
+     * ]);
+     * ```
+     */
+    updateRoutes(newRoutes: IRouteConfig[]): Promise<void>;
+    /**
+     * Request a certificate for a specific domain
+     *
+     * @param domain The domain to request a certificate for
+     * @param routeName Optional route name to associate with the certificate
+     */
+    requestCertificate(domain: string, routeName?: string): Promise<boolean>;
+    /**
+     * Validates if a domain name is valid for certificate issuance
+     */
+    private isValidDomain;
+    /**
+     * Add a new listening port without changing the route configuration
+     *
+     * This allows you to add a port listener without updating routes.
+     * Useful for preparing to listen on a port before adding routes for it.
+     *
+     * @param port The port to start listening on
+     * @returns Promise that resolves when the port is listening
+     */
+    addListeningPort(port: number): Promise<void>;
+    /**
+     * Stop listening on a specific port without changing the route configuration
+     *
+     * This allows you to stop a port listener without updating routes.
+     * Useful for temporary maintenance or port changes.
+     *
+     * @param port The port to stop listening on
+     * @returns Promise that resolves when the port is closed
+     */
+    removeListeningPort(port: number): Promise<void>;
+    /**
+     * Get a list of all ports currently being listened on
+     *
+     * @returns Array of port numbers
+     */
+    getListeningPorts(): number[];
+    /**
+     * Get statistics about current connections
+     */
+    getStatistics(): any;
+    /**
+     * Get a list of eligible domains for ACME certificates
+     */
+    getEligibleDomainsForCertificates(): string[];
+    /**
+     * Get NFTables status
+     */
+    getNfTablesStatus(): Promise<Record<string, any>>;
+    /**
+     * Get status of certificates managed by Port80Handler
+     */
+    getCertificateStatus(): any;
+}