@push.rocks/smartproxy 21.1.2 → 21.1.5

package/dist_ts/proxies/smart-proxy/utils/route-validator.js

@@ -0,0 +1,405 @@
+import { logger } from '../../../core/utils/logger.js';
+/**
+ * Validates route configurations for correctness and safety
+ */
+export class RouteValidator {
+    static { this.VALID_TLS_MODES = ['terminate', 'passthrough', 'terminate-and-reencrypt']; }
+    static { this.VALID_ACTION_TYPES = ['forward', 'socket-handler']; }
+    static { this.VALID_PROTOCOLS = ['tcp', 'http', 'https', 'ws', 'wss']; }
+    static { this.MAX_PORTS = 100; }
+    static { this.MAX_DOMAINS = 1000; }
+    static { this.MAX_HEADER_SIZE = 8192; }
+    /**
+     * Validate a single route configuration
+     */
+    static validateRoute(route) {
+        const errors = [];
+        // Validate route has a name
+        if (!route.name || typeof route.name !== 'string') {
+            errors.push('Route must have a valid name');
+        }
+        // Validate match criteria
+        if (!route.match) {
+            errors.push('Route must have match criteria');
+        }
+        else {
+            // Validate ports
+            if (route.match.ports) {
+                const ports = Array.isArray(route.match.ports) ? route.match.ports : [route.match.ports];
+                if (ports.length > this.MAX_PORTS) {
+                    errors.push(`Too many ports specified (max ${this.MAX_PORTS})`);
+                }
+                for (const port of ports) {
+                    if (typeof port === 'number') {
+                        if (!this.isValidPort(port)) {
+                            errors.push(`Invalid port: ${port}. Must be between 1 and 65535`);
+                        }
+                    }
+                    else if (typeof port === 'object' && 'from' in port && 'to' in port) {
+                        if (!this.isValidPort(port.from)) {
+                            errors.push(`Invalid port range start: ${port.from}. Must be between 1 and 65535`);
+                        }
+                        if (!this.isValidPort(port.to)) {
+                            errors.push(`Invalid port range end: ${port.to}. Must be between 1 and 65535`);
+                        }
+                        if (port.from > port.to) {
+                            errors.push(`Invalid port range: ${port.from}-${port.to} (start > end)`);
+                        }
+                    }
+                    else {
+                        errors.push(`Invalid port configuration: ${JSON.stringify(port)}`);
+                    }
+                }
+            }
+            // Validate domains
+            if (route.match.domains) {
+                const domains = Array.isArray(route.match.domains) ? route.match.domains : [route.match.domains];
+                if (domains.length > this.MAX_DOMAINS) {
+                    errors.push(`Too many domains specified (max ${this.MAX_DOMAINS})`);
+                }
+                for (const domain of domains) {
+                    if (!this.isValidDomain(domain)) {
+                        errors.push(`Invalid domain pattern: ${domain}`);
+                    }
+                }
+            }
+            // Validate paths
+            if (route.match.path) {
+                const paths = Array.isArray(route.match.path) ? route.match.path : [route.match.path];
+                for (const path of paths) {
+                    if (!this.isValidPath(path)) {
+                        errors.push(`Invalid path pattern: ${path}`);
+                    }
+                }
+            }
+            // Validate client IPs
+            if (route.match.clientIp) {
+                const ips = Array.isArray(route.match.clientIp) ? route.match.clientIp : [route.match.clientIp];
+                for (const ip of ips) {
+                    if (!this.isValidIPPattern(ip)) {
+                        errors.push(`Invalid IP pattern: ${ip}`);
+                    }
+                }
+            }
+            // Validate headers
+            if (route.match.headers) {
+                for (const [key, value] of Object.entries(route.match.headers)) {
+                    if (key.length > 256) {
+                        errors.push(`Header name too long: ${key}`);
+                    }
+                    const headerValue = String(value);
+                    if (headerValue.length > this.MAX_HEADER_SIZE) {
+                        errors.push(`Header value too long for ${key} (max ${this.MAX_HEADER_SIZE} bytes)`);
+                    }
+                    if (!/^[\x20-\x7E]+$/.test(key)) {
+                        errors.push(`Invalid header name: ${key} (must be printable ASCII)`);
+                    }
+                }
+            }
+            // Protocol validation removed - not part of IRouteMatch interface
+        }
+        // Validate action
+        if (!route.action) {
+            errors.push('Route must have an action');
+        }
+        else {
+            // Validate action type
+            if (!route.action.type || !this.VALID_ACTION_TYPES.includes(route.action.type)) {
+                errors.push(`Invalid action type: ${route.action.type}. Must be one of: ${this.VALID_ACTION_TYPES.join(', ')}`);
+            }
+            // Validate socket-handler
+            if (route.action.type === 'socket-handler') {
+                if (typeof route.action.socketHandler !== 'function') {
+                    errors.push('socket-handler action requires a socketHandler function');
+                }
+            }
+            // Validate forward target
+            if (route.action.type === 'forward') {
+                if (!route.action.targets || route.action.targets.length === 0) {
+                    errors.push('Forward action must have at least one target');
+                }
+                else {
+                    for (const target of route.action.targets) {
+                        if (!target.host) {
+                            errors.push('Target must have a host');
+                        }
+                        else if (typeof target.host !== 'string' && !Array.isArray(target.host) && typeof target.host !== 'function') {
+                            errors.push('Target host must be a string, array of strings, or function');
+                        }
+                        if (target.port) {
+                            if (typeof target.port === 'number' && !this.isValidPort(target.port)) {
+                                errors.push(`Invalid target port: ${target.port}`);
+                            }
+                            else if (target.port !== 'preserve' && typeof target.port !== 'function' && typeof target.port !== 'number') {
+                                errors.push(`Invalid target port configuration: ${target.port}`);
+                            }
+                        }
+                    }
+                }
+            }
+            // Validate TLS settings
+            if (route.action.tls) {
+                if (route.action.tls.mode && !this.VALID_TLS_MODES.includes(route.action.tls.mode)) {
+                    errors.push(`Invalid TLS mode: ${route.action.tls.mode}. Must be one of: ${this.VALID_TLS_MODES.join(', ')}`);
+                }
+                if (route.action.tls.certificate) {
+                    if (route.action.tls.certificate !== 'auto' && typeof route.action.tls.certificate !== 'object') {
+                        errors.push('TLS certificate must be "auto" or a certificate configuration object');
+                    }
+                }
+                if (route.action.tls.versions) {
+                    for (const version of route.action.tls.versions) {
+                        if (!['TLSv1', 'TLSv1.1', 'TLSv1.2', 'TLSv1.3'].includes(version)) {
+                            errors.push(`Invalid TLS version: ${version}`);
+                        }
+                    }
+                }
+            }
+        }
+        // Validate security settings
+        if (route.security) {
+            // Validate IP allow/block lists
+            if (route.security.ipAllowList) {
+                const allowList = Array.isArray(route.security.ipAllowList) ? route.security.ipAllowList : [route.security.ipAllowList];
+                for (const ip of allowList) {
+                    if (!this.isValidIPPattern(ip)) {
+                        errors.push(`Invalid IP pattern in allow list: ${ip}`);
+                    }
+                }
+            }
+            if (route.security.ipBlockList) {
+                const blockList = Array.isArray(route.security.ipBlockList) ? route.security.ipBlockList : [route.security.ipBlockList];
+                for (const ip of blockList) {
+                    if (!this.isValidIPPattern(ip)) {
+                        errors.push(`Invalid IP pattern in block list: ${ip}`);
+                    }
+                }
+            }
+            // Validate rate limits
+            if (route.security.rateLimit) {
+                if (route.security.rateLimit.maxRequests && route.security.rateLimit.maxRequests < 0) {
+                    errors.push('Rate limit maxRequests must be positive');
+                }
+                if (route.security.rateLimit.window && route.security.rateLimit.window < 0) {
+                    errors.push('Rate limit window must be positive');
+                }
+            }
+            // Validate connection limits
+            if (route.security.maxConnections && route.security.maxConnections < 0) {
+                errors.push('Max connections must be positive');
+            }
+        }
+        // Validate priority
+        if (route.priority !== undefined && (route.priority < 0 || route.priority > 10000)) {
+            errors.push('Priority must be between 0 and 10000');
+        }
+        return {
+            valid: errors.length === 0,
+            errors
+        };
+    }
+    /**
+     * Validate multiple route configurations
+     */
+    static validateRoutes(routes) {
+        const errorMap = new Map();
+        let valid = true;
+        // Check for duplicate route names
+        const routeNames = new Set();
+        for (const route of routes) {
+            if (route.name && routeNames.has(route.name)) {
+                const existingErrors = errorMap.get(route.name) || [];
+                existingErrors.push('Duplicate route name');
+                errorMap.set(route.name, existingErrors);
+                valid = false;
+            }
+            routeNames.add(route.name);
+        }
+        // Validate each route
+        for (const route of routes) {
+            const result = this.validateRoute(route);
+            if (!result.valid) {
+                errorMap.set(route.name || 'unnamed', result.errors);
+                valid = false;
+            }
+        }
+        // Check for conflicting routes
+        const conflicts = this.findRouteConflicts(routes);
+        if (conflicts.length > 0) {
+            for (const conflict of conflicts) {
+                const existingErrors = errorMap.get(conflict.route) || [];
+                existingErrors.push(conflict.message);
+                errorMap.set(conflict.route, existingErrors);
+            }
+            valid = false;
+        }
+        return { valid, errors: errorMap };
+    }
+    /**
+     * Find potential conflicts between routes
+     */
+    static findRouteConflicts(routes) {
+        const conflicts = [];
+        // Group routes by port
+        const portMap = new Map();
+        for (const route of routes) {
+            if (route.match?.ports) {
+                const ports = Array.isArray(route.match.ports) ? route.match.ports : [route.match.ports];
+                // Expand port ranges to individual ports
+                const expandedPorts = [];
+                for (const port of ports) {
+                    if (typeof port === 'number') {
+                        expandedPorts.push(port);
+                    }
+                    else if (typeof port === 'object' && 'from' in port && 'to' in port) {
+                        for (let p = port.from; p <= port.to; p++) {
+                            expandedPorts.push(p);
+                        }
+                    }
+                }
+                for (const port of expandedPorts) {
+                    const routesOnPort = portMap.get(port) || [];
+                    routesOnPort.push(route);
+                    portMap.set(port, routesOnPort);
+                }
+            }
+        }
+        // Check for conflicting catch-all routes on the same port
+        for (const [port, routesOnPort] of portMap) {
+            const catchAllRoutes = routesOnPort.filter(r => !r.match.domains ||
+                (Array.isArray(r.match.domains) && r.match.domains.includes('*')) ||
+                r.match.domains === '*');
+            if (catchAllRoutes.length > 1) {
+                for (const route of catchAllRoutes) {
+                    conflicts.push({
+                        route: route.name,
+                        message: `Multiple catch-all routes on port ${port}`
+                    });
+                }
+            }
+        }
+        return conflicts;
+    }
+    /**
+     * Validate port number
+     */
+    static isValidPort(port) {
+        return Number.isInteger(port) && port >= 1 && port <= 65535;
+    }
+    /**
+     * Validate domain pattern
+     */
+    static isValidDomain(domain) {
+        if (!domain || typeof domain !== 'string')
+            return false;
+        if (domain === '*')
+            return true;
+        // Basic domain pattern validation
+        const domainPattern = /^(\*\.)?([a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)*[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$/;
+        return domainPattern.test(domain) || domain === 'localhost';
+    }
+    /**
+     * Validate path pattern
+     */
+    static isValidPath(path) {
+        if (!path || typeof path !== 'string')
+            return false;
+        if (!path.startsWith('/'))
+            return false;
+        // Check for invalid characters
+        if (!/^[a-zA-Z0-9/_*:{}.-]+$/.test(path))
+            return false;
+        // Validate parameter syntax
+        const paramPattern = /\{[a-zA-Z_][a-zA-Z0-9_]*\}/g;
+        const params = path.match(paramPattern) || [];
+        for (const param of params) {
+            if (param.length > 32)
+                return false;
+        }
+        return true;
+    }
+    /**
+     * Validate IP pattern
+     */
+    static isValidIPPattern(ip) {
+        if (!ip || typeof ip !== 'string')
+            return false;
+        if (ip === '*')
+            return true;
+        // Check for CIDR notation
+        if (ip.includes('/')) {
+            const [addr, prefix] = ip.split('/');
+            const prefixNum = parseInt(prefix, 10);
+            if (addr.includes(':')) {
+                // IPv6 CIDR
+                return this.isValidIPv6(addr) && prefixNum >= 0 && prefixNum <= 128;
+            }
+            else {
+                // IPv4 CIDR
+                return this.isValidIPv4(addr) && prefixNum >= 0 && prefixNum <= 32;
+            }
+        }
+        // Check for range
+        if (ip.includes('-')) {
+            const [start, end] = ip.split('-');
+            return (this.isValidIPv4(start) && this.isValidIPv4(end)) ||
+                (this.isValidIPv6(start) && this.isValidIPv6(end));
+        }
+        // Check for wildcards in IPv4
+        if (ip.includes('*') && !ip.includes(':')) {
+            const parts = ip.split('.');
+            if (parts.length !== 4)
+                return false;
+            for (const part of parts) {
+                if (part !== '*' && !/^\d{1,3}$/.test(part))
+                    return false;
+                if (part !== '*' && parseInt(part, 10) > 255)
+                    return false;
+            }
+            return true;
+        }
+        // Regular IP address
+        return this.isValidIPv4(ip) || this.isValidIPv6(ip);
+    }
+    /**
+     * Validate IPv4 address
+     */
+    static isValidIPv4(ip) {
+        const parts = ip.split('.');
+        if (parts.length !== 4)
+            return false;
+        for (const part of parts) {
+            const num = parseInt(part, 10);
+            if (isNaN(num) || num < 0 || num > 255)
+                return false;
+        }
+        return true;
+    }
+    /**
+     * Validate IPv6 address
+     */
+    static isValidIPv6(ip) {
+        // Simple IPv6 validation
+        const ipv6Pattern = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|::[0-9a-fA-F]{0,4}(:[0-9a-fA-F]{1,4}){0,6}|::1|::)$/;
+        return ipv6Pattern.test(ip);
+    }
+    /**
+     * Log validation errors
+     */
+    static logValidationErrors(errors) {
+        for (const [routeName, routeErrors] of errors) {
+            logger.log('error', `Route validation failed for ${routeName}:`, {
+                route: routeName,
+                errors: routeErrors,
+                component: 'route-validator'
+            });
+            for (const error of routeErrors) {
+                logger.log('error', `  - ${error}`, {
+                    route: routeName,
+                    component: 'route-validator'
+                });
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"route-validator.js","sourceRoot":"","sources":["../../../../ts/proxies/smart-proxy/utils/route-validator.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartproxy",
-  "version": "21.1.2",
+  "version": "21.1.5",
   "private": false,
   "description": "A powerful proxy package with unified route-based configuration for high traffic management. Features include SSL/TLS support, flexible routing patterns, WebSocket handling, advanced security options, and automatic ACME certificate management.",
   "main": "dist_ts/index.js",
@@ -13,7 +13,8 @@
     "@git.zone/tsrun": "^1.2.44",
     "@git.zone/tstest": "^2.3.1",
     "@types/node": "^22.15.29",
-    "typescript": "^5.8.3"
+    "typescript": "^5.8.3",
+    "why-is-node-running": "^3.2.2"
   },
   "dependencies": {
     "@push.rocks/lik": "^6.2.2",