@push.rocks/smartproxy 21.1.7 → 22.6.0

package/dist_ts/proxies/smart-proxy/security-manager.d.ts

@@ -1,6 +1,7 @@
 import type { SmartProxy } from './smart-proxy.js';
 /**
  * Handles security aspects like IP tracking, rate limiting, and authorization
+ * for SmartProxy. This is a lightweight wrapper that uses shared utilities.
  */
 export declare class SecurityManager {
     private smartProxy;
@@ -9,7 +10,7 @@ export declare class SecurityManager {
     private cleanupInterval;
     constructor(smartProxy: SmartProxy);
     /**
-     * Get connections count by IP
+     * Get connections count by IP (checks normalized variants)
      */
     getConnectionCountByIP(ip: string): number;
     /**
@@ -38,17 +39,6 @@ export declare class SecurityManager {
      * @returns true if IP is authorized, false if blocked
      */
     isIPAuthorized(ip: string, allowedIPs: string[], blockedIPs?: string[]): boolean;
-    /**
-     * Check if the IP matches any of the glob patterns from security configuration
-     *
-     * This method checks IP addresses against glob patterns and handles IPv4/IPv6 normalization.
-     * It's used to implement IP filtering based on the route.security configuration.
-     *
-     * @param ip - The IP address to check
-     * @param patterns - Array of glob patterns from security.ipAllowList or ipBlockList
-     * @returns true if IP matches any pattern, false otherwise
-     */
-    private isGlobIPMatch;
     /**
      * Check if IP should be allowed considering connection rate and max connections
      * @returns Object with result and reason
@@ -57,6 +47,18 @@ export declare class SecurityManager {
         allowed: boolean;
         reason?: string;
     };
+    /**
+     * Atomically validate an IP and track the connection if allowed.
+     * This prevents race conditions where concurrent connections could bypass per-IP limits.
+     *
+     * @param ip - The IP address to validate
+     * @param connectionId - The connection ID to track if validation passes
+     * @returns Object with validation result and reason
+     */
+    validateAndTrackIP(ip: string, connectionId: string): {
+        allowed: boolean;
+        reason?: string;
+    };
     /**
      * Clears all IP tracking data (for shutdown)
      */

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

@@ -1,8 +1,9 @@
 import * as plugins from '../../plugins.js';
-import { logger } from '../../core/utils/logger.js';
 import { connectionLogDeduplicator } from '../../core/utils/log-deduplicator.js';
+import { isIPAuthorized, normalizeIP } from '../../core/utils/security-utils.js';
 /**
  * Handles security aspects like IP tracking, rate limiting, and authorization
+ * for SmartProxy. This is a lightweight wrapper that uses shared utilities.
  */
 export class SecurityManager {
     constructor(smartProxy) {
@@ -14,10 +15,18 @@ export class SecurityManager {
         this.startPeriodicCleanup();
     }
     /**
-     * Get connections count by IP
+     * Get connections count by IP (checks normalized variants)
      */
     getConnectionCountByIP(ip) {
-        return this.connectionsByIP.get(ip)?.size || 0;
+        // Check all normalized variants of the IP
+        const variants = normalizeIP(ip);
+        for (const variant of variants) {
+            const connections = this.connectionsByIP.get(variant);
+            if (connections) {
+                return connections.size;
+            }
+        }
+        return 0;
     }
     /**
      * Check and update connection rate for an IP
@@ -26,14 +35,24 @@ export class SecurityManager {
     checkConnectionRate(ip) {
         const now = Date.now();
         const minute = 60 * 1000;
-        if (!this.connectionRateByIP.has(ip)) {
-            this.connectionRateByIP.set(ip, [now]);
+        // Find existing rate tracking (check normalized variants)
+        const variants = normalizeIP(ip);
+        let existingKey = null;
+        for (const variant of variants) {
+            if (this.connectionRateByIP.has(variant)) {
+                existingKey = variant;
+                break;
+            }
+        }
+        const key = existingKey || ip;
+        if (!this.connectionRateByIP.has(key)) {
+            this.connectionRateByIP.set(key, [now]);
             return true;
         }
         // Get timestamps and filter out entries older than 1 minute
-        const timestamps = this.connectionRateByIP.get(ip).filter((time) => now - time < minute);
+        const timestamps = this.connectionRateByIP.get(key).filter((time) => now - time < minute);
         timestamps.push(now);
-        this.connectionRateByIP.set(ip, timestamps);
+        this.connectionRateByIP.set(key, timestamps);
         // Check if rate exceeds limit
         return timestamps.length <= this.smartProxy.settings.connectionRateLimitPerMinute;
     }
@@ -41,20 +60,35 @@ export class SecurityManager {
      * Track connection by IP
      */
     trackConnectionByIP(ip, connectionId) {
-        if (!this.connectionsByIP.has(ip)) {
-            this.connectionsByIP.set(ip, new Set());
+        // Check if any variant already exists
+        const variants = normalizeIP(ip);
+        let existingKey = null;
+        for (const variant of variants) {
+            if (this.connectionsByIP.has(variant)) {
+                existingKey = variant;
+                break;
+            }
+        }
+        const key = existingKey || ip;
+        if (!this.connectionsByIP.has(key)) {
+            this.connectionsByIP.set(key, new Set());
         }
-        this.connectionsByIP.get(ip).add(connectionId);
+        this.connectionsByIP.get(key).add(connectionId);
     }
     /**
      * Remove connection tracking for an IP
      */
     removeConnectionByIP(ip, connectionId) {
-        if (this.connectionsByIP.has(ip)) {
-            const connections = this.connectionsByIP.get(ip);
-            connections.delete(connectionId);
-            if (connections.size === 0) {
-                this.connectionsByIP.delete(ip);
+        // Check all variants to find where the connection is tracked
+        const variants = normalizeIP(ip);
+        for (const variant of variants) {
+            if (this.connectionsByIP.has(variant)) {
+                const connections = this.connectionsByIP.get(variant);
+                connections.delete(connectionId);
+                if (connections.size === 0) {
+                    this.connectionsByIP.delete(variant);
+                }
+                break;
             }
         }
     }
@@ -71,64 +105,7 @@ export class SecurityManager {
      * @returns true if IP is authorized, false if blocked
      */
     isIPAuthorized(ip, allowedIPs, blockedIPs = []) {
-        // Skip IP validation if allowedIPs is empty
-        if (!ip || (allowedIPs.length === 0 && blockedIPs.length === 0)) {
-            return true;
-        }
-        // First check if IP is blocked - blocked IPs take precedence
-        if (blockedIPs.length > 0 && this.isGlobIPMatch(ip, blockedIPs)) {
-            return false;
-        }
-        // Then check if IP is allowed
-        return this.isGlobIPMatch(ip, allowedIPs);
-    }
-    /**
-     * Check if the IP matches any of the glob patterns from security configuration
-     *
-     * This method checks IP addresses against glob patterns and handles IPv4/IPv6 normalization.
-     * It's used to implement IP filtering based on the route.security configuration.
-     *
-     * @param ip - The IP address to check
-     * @param patterns - Array of glob patterns from security.ipAllowList or ipBlockList
-     * @returns true if IP matches any pattern, false otherwise
-     */
-    isGlobIPMatch(ip, patterns) {
-        if (!ip || !patterns || patterns.length === 0)
-            return false;
-        // Handle IPv4/IPv6 normalization for proper matching
-        const normalizeIP = (ip) => {
-            if (!ip)
-                return [];
-            // Handle IPv4-mapped IPv6 addresses (::ffff:127.0.0.1)
-            if (ip.startsWith('::ffff:')) {
-                const ipv4 = ip.slice(7);
-                return [ip, ipv4];
-            }
-            // Handle IPv4 addresses by also checking IPv4-mapped form
-            if (/^\d{1,3}(\.\d{1,3}){3}$/.test(ip)) {
-                return [ip, `::ffff:${ip}`];
-            }
-            return [ip];
-        };
-        // Normalize the IP being checked
-        const normalizedIPVariants = normalizeIP(ip);
-        if (normalizedIPVariants.length === 0)
-            return false;
-        // Expand shorthand patterns and normalize IPs for consistent comparison
-        const expandShorthand = (pattern) => {
-            // Expand shorthand IP patterns like '192.168.*' to '192.168.*.*'
-            if (pattern.includes('*') && !pattern.includes(':')) {
-                const parts = pattern.split('.');
-                while (parts.length < 4) {
-                    parts.push('*');
-                }
-                return parts.join('.');
-            }
-            return pattern;
-        };
-        const expandedPatterns = patterns.map(expandShorthand).flatMap(normalizeIP);
-        // Check for any match between normalized IP variants and patterns
-        return normalizedIPVariants.some((ipVariant) => expandedPatterns.some((pattern) => plugins.minimatch(ipVariant, pattern)));
+        return isIPAuthorized(ip, allowedIPs, blockedIPs);
     }
     /**
      * Check if IP should be allowed considering connection rate and max connections
@@ -153,6 +130,35 @@ export class SecurityManager {
         }
         return { allowed: true };
     }
+    /**
+     * Atomically validate an IP and track the connection if allowed.
+     * This prevents race conditions where concurrent connections could bypass per-IP limits.
+     *
+     * @param ip - The IP address to validate
+     * @param connectionId - The connection ID to track if validation passes
+     * @returns Object with validation result and reason
+     */
+    validateAndTrackIP(ip, connectionId) {
+        // Check connection count limit BEFORE tracking
+        if (this.smartProxy.settings.maxConnectionsPerIP &&
+            this.getConnectionCountByIP(ip) >= this.smartProxy.settings.maxConnectionsPerIP) {
+            return {
+                allowed: false,
+                reason: `Maximum connections per IP (${this.smartProxy.settings.maxConnectionsPerIP}) exceeded`
+            };
+        }
+        // Check connection rate limit
+        if (this.smartProxy.settings.connectionRateLimitPerMinute &&
+            !this.checkConnectionRate(ip)) {
+            return {
+                allowed: false,
+                reason: `Connection rate limit (${this.smartProxy.settings.connectionRateLimitPerMinute}/min) exceeded`
+            };
+        }
+        // Validation passed - immediately track to prevent race conditions
+        this.trackConnectionByIP(ip, connectionId);
+        return { allowed: true };
+    }
     /**
      * Clears all IP tracking data (for shutdown)
      */
@@ -218,4 +224,4 @@ export class SecurityManager {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"security-manager.js","sourceRoot":"","sources":["../../../ts/proxies/smart-proxy/security-manager.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,208 +1,90 @@
 import * as plugins from '../../plugins.js';
-import { ConnectionManager } from './connection-manager.js';
-import { SecurityManager } from './security-manager.js';
-import { TlsManager } from './tls-manager.js';
-import { HttpProxyBridge } from './http-proxy-bridge.js';
-import { TimeoutManager } from './timeout-manager.js';
 import { SharedRouteManager as RouteManager } from '../../core/routing/route-manager.js';
-import { RouteConnectionHandler } from './route-connection-handler.js';
-import { NFTablesManager } from './nftables-manager.js';
-import { SmartCertManager, type ICertStatus } from './certificate-manager.js';
 import type { ISmartProxyOptions } from './models/interfaces.js';
 import type { IRouteConfig } from './models/route-types.js';
-import { AcmeStateManager } from './acme-state-manager.js';
-import { MetricsCollector } from './metrics-collector.js';
 import type { IMetrics } from './models/metrics-types.js';
 /**
- * SmartProxy - Pure route-based API
+ * SmartProxy - Rust-backed proxy engine with TypeScript configuration 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.)
+ * All networking (TCP, TLS, HTTP reverse proxy, connection management, security,
+ * NFTables) is handled by the Rust binary. TypeScript is only:
+ * - The npm module interface (types, route helpers)
+ * - The thin IPC wrapper (this class)
+ * - Socket-handler callback relay (for JS-defined handlers)
+ * - Certificate provisioning callbacks (certProvisionFunction)
  */
 export declare class SmartProxy extends plugins.EventEmitter {
-    private portManager;
-    private connectionLogger;
-    private isShuttingDown;
-    connectionManager: ConnectionManager;
-    securityManager: SecurityManager;
-    tlsManager: TlsManager;
-    httpProxyBridge: HttpProxyBridge;
-    timeoutManager: TimeoutManager;
+    settings: ISmartProxyOptions;
     routeManager: RouteManager;
-    routeConnectionHandler: RouteConnectionHandler;
-    nftablesManager: NFTablesManager;
-    certManager: SmartCertManager | null;
-    private globalChallengeRouteActive;
+    private bridge;
+    private preprocessor;
+    private socketHandlerServer;
+    private metricsAdapter;
     private routeUpdateLock;
-    acmeStateManager: AcmeStateManager;
-    metricsCollector: MetricsCollector;
-    private routeOrchestrator;
-    private portUsageMap;
-    /**
-     * 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: ['*'] }
-     *   }
-     * });
-     * ```
-     */
+    private stopping;
     constructor(settingsArg: ISmartProxyOptions);
     /**
-     * The settings for the SmartProxy
-     */
-    settings: ISmartProxyOptions;
-    /**
-     * Helper method to create and configure certificate manager
-     * This ensures consistent setup including the required ACME callback
-     */
-    private createCertificateManager;
-    /**
-     * Initialize certificate manager
-     */
-    private initializeCertificateManager;
-    /**
-     * Check if we have routes with static certificates
-     */
-    private hasStaticCertRoutes;
-    /**
-     * Start the proxy server with support for both configuration types
+     * Start the proxy.
+     * Spawns the Rust binary, configures socket relay if needed, sends routes, handles cert provisioning.
      */
     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 the proxy.
      */
     stop(): Promise<void>;
     /**
-     * Updates the domain configurations for the proxy
-     *
-     * Note: This legacy method has been removed. Use updateRoutes instead.
-     */
-    updateDomainConfigs(): Promise<void>;
-    /**
-     * Verify the challenge route has been properly removed from routes
-     */
-    private verifyChallengeRouteRemoved;
-    /**
-     * 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' }
-     *     }
-     *   }
-     * ]);
-     * ```
+     * Update routes atomically.
      */
     updateRoutes(newRoutes: IRouteConfig[]): Promise<void>;
     /**
-     * Manually provision a certificate for a route
+     * Provision a certificate for a named route.
      */
     provisionCertificate(routeName: string): Promise<void>;
     /**
-     * Force renewal of a certificate
+     * Force renewal of a certificate.
      */
     renewCertificate(routeName: string): Promise<void>;
     /**
-     * Get certificate status for a route
+     * Get certificate status for a route (async - calls Rust).
      */
-    getCertificateStatus(routeName: string): ICertStatus | undefined;
+    getCertificateStatus(routeName: string): Promise<any>;
     /**
-     * Get proxy metrics with clean API
-     *
-     * @returns IMetrics interface with grouped metrics methods
+     * Get the metrics interface.
      */
     getMetrics(): IMetrics;
     /**
-     * Validates if a domain name is valid for certificate issuance
+     * Get statistics (async - calls Rust).
      */
-    private isValidDomain;
+    getStatistics(): Promise<any>;
     /**
-     * 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
+     * Add a listening port at runtime.
      */
     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
+     * Remove a listening port at runtime.
      */
     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
+     * Get all currently listening ports (async - calls Rust).
      */
-    getStatistics(): any;
+    getListeningPorts(): Promise<number[]>;
     /**
-     * Get a list of eligible domains for ACME certificates
+     * Get eligible domains for ACME certificates (sync - reads local routes).
      */
     getEligibleDomainsForCertificates(): string[];
     /**
-     * Get NFTables status
+     * Get NFTables status (async - calls Rust).
      */
     getNfTablesStatus(): Promise<Record<string, any>>;
     /**
-     * Validate ACME configuration
+     * Build the Rust configuration object from TS settings.
      */
-    private validateAcmeConfiguration;
+    private buildRustConfig;
+    /**
+     * For routes with certificate: 'auto', call certProvisionFunction if set.
+     * If the callback returns a cert object, load it into Rust.
+     * If it returns 'http01', let Rust handle ACME.
+     */
+    private provisionCertificatesViaCallback;
+    private isValidDomain;
 }