@push.rocks/smartproxy 21.1.7 → 22.4.2

package/ts/proxies/smart-proxy/utils/route-utils.ts

@@ -6,7 +6,7 @@
  */
 
 import type { IRouteConfig, IRouteMatch } from '../models/route-types.js';
-import { validateRouteConfig } from './route-validators.js';
+import { validateRouteConfig } from './route-validator.js';
 
 /**
  * Merge two route configurations

package/ts/proxies/smart-proxy/utils/route-validator.ts

@@ -1,5 +1,5 @@
 import { logger } from '../../../core/utils/logger.js';
-import type { IRouteConfig } from '../models/route-types.js';
+import type { IRouteConfig, IRouteMatch, IRouteAction, TPortRange } from '../models/route-types.js';
 
 /**
  * Validates route configurations for correctness and safety
@@ -439,8 +439,8 @@ export class RouteValidator {
    * Validate IPv6 address
    */
   private static isValidIPv6(ip: string): boolean {
-    // 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|::)$/;
+    // IPv6 validation including IPv6-mapped IPv4 addresses (::ffff:x.x.x.x)
+    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|::|::ffff:\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$/i;
     return ipv6Pattern.test(ip);
   }
 
@@ -454,7 +454,7 @@ export class RouteValidator {
         errors: routeErrors,
         component: 'route-validator'
       });
-      
+
       for (const error of routeErrors) {
         logger.log('error', `  - ${error}`, {
           route: routeName,
@@ -463,4 +463,274 @@ export class RouteValidator {
       }
     }
   }
+}
+
+// ============================================================================
+// Functional API (for backwards compatibility with route-validators.ts)
+// ============================================================================
+
+/**
+ * Validates a port range or port number
+ * @param port Port number, port range, or port function
+ * @returns True if valid, false otherwise
+ */
+export function isValidPort(port: any): boolean {
+  if (typeof port === 'number') {
+    return port > 0 && port < 65536;
+  } else if (Array.isArray(port)) {
+    return port.every(p =>
+      (typeof p === 'number' && p > 0 && p < 65536) ||
+      (typeof p === 'object' && 'from' in p && 'to' in p &&
+       p.from > 0 && p.from < 65536 && p.to > 0 && p.to < 65536)
+    );
+  } else if (typeof port === 'function') {
+    return true;
+  } else if (typeof port === 'object' && 'from' in port && 'to' in port) {
+    return port.from > 0 && port.from < 65536 && port.to > 0 && port.to < 65536;
+  }
+  return false;
+}
+
+/**
+ * Validates a domain string - supports wildcards, localhost, and IP addresses
+ * @param domain Domain string to validate
+ * @returns True if valid, false otherwise
+ */
+export function isValidDomain(domain: string): boolean {
+  if (!domain || typeof domain !== 'string') return false;
+  if (domain === '*') return true;
+  if (domain === 'localhost') return true;
+
+  const domainPatterns = [
+    // Standard domain with optional wildcard subdomain (*.example.com)
+    /^(\*\.)?([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])?$/,
+    // Wildcard prefix without dot (*example.com)
+    /^\*[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])?))*$/,
+    // IP address
+    /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/,
+    // IPv6 address
+    /^([0-9a-fA-F]{0,4}:){2,7}[0-9a-fA-F]{0,4}$/
+  ];
+
+  return domainPatterns.some(pattern => pattern.test(domain));
+}
+
+/**
+ * Validates a route match configuration
+ * @param match Route match configuration to validate
+ * @returns { valid: boolean, errors: string[] } Validation result
+ */
+export function validateRouteMatch(match: IRouteMatch): { valid: boolean; errors: string[] } {
+  const errors: string[] = [];
+
+  if (match.ports !== undefined) {
+    if (!isValidPort(match.ports)) {
+      errors.push('Invalid port number or port range in match.ports');
+    }
+  }
+
+  if (match.domains !== undefined) {
+    if (typeof match.domains === 'string') {
+      if (!isValidDomain(match.domains)) {
+        errors.push(`Invalid domain format: ${match.domains}`);
+      }
+    } else if (Array.isArray(match.domains)) {
+      for (const domain of match.domains) {
+        if (!isValidDomain(domain)) {
+          errors.push(`Invalid domain format: ${domain}`);
+        }
+      }
+    } else {
+      errors.push('Domains must be a string or an array of strings');
+    }
+  }
+
+  if (match.path !== undefined) {
+    if (typeof match.path !== 'string' || !match.path.startsWith('/')) {
+      errors.push('Path must be a string starting with /');
+    }
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+/**
+ * Validates a route action configuration
+ * @param action Route action configuration to validate
+ * @returns { valid: boolean, errors: string[] } Validation result
+ */
+export function validateRouteAction(action: IRouteAction): { valid: boolean; errors: string[] } {
+  const errors: string[] = [];
+
+  if (!action.type) {
+    errors.push('Action type is required');
+  } else if (!['forward', 'socket-handler'].includes(action.type)) {
+    errors.push(`Invalid action type: ${action.type}`);
+  }
+
+  if (action.type === 'forward') {
+    if (!action.targets || !Array.isArray(action.targets) || action.targets.length === 0) {
+      errors.push('Targets array is required for forward action');
+    } else {
+      action.targets.forEach((target, index) => {
+        if (!target.host) {
+          errors.push(`Target[${index}] host is required`);
+        } else if (typeof target.host !== 'string' &&
+                  !Array.isArray(target.host) &&
+                  typeof target.host !== 'function') {
+          errors.push(`Target[${index}] host must be a string, array of strings, or function`);
+        }
+
+        if (target.port === undefined) {
+          errors.push(`Target[${index}] port is required`);
+        } else if (typeof target.port !== 'number' &&
+                  typeof target.port !== 'function' &&
+                  target.port !== 'preserve') {
+          errors.push(`Target[${index}] port must be a number, 'preserve', or a function`);
+        } else if (typeof target.port === 'number' && !isValidPort(target.port)) {
+          errors.push(`Target[${index}] port must be between 1 and 65535`);
+        }
+
+        if (target.match) {
+          if (target.match.ports && !Array.isArray(target.match.ports)) {
+            errors.push(`Target[${index}] match.ports must be an array`);
+          }
+          if (target.match.method && !Array.isArray(target.match.method)) {
+            errors.push(`Target[${index}] match.method must be an array`);
+          }
+        }
+      });
+    }
+
+    if (action.tls) {
+      if (!['passthrough', 'terminate', 'terminate-and-reencrypt'].includes(action.tls.mode)) {
+        errors.push(`Invalid TLS mode: ${action.tls.mode}`);
+      }
+
+      if (['terminate', 'terminate-and-reencrypt'].includes(action.tls.mode)) {
+        if (action.tls.certificate !== 'auto' &&
+            (!action.tls.certificate || !action.tls.certificate.key || !action.tls.certificate.cert)) {
+          errors.push('Certificate must be "auto" or an object with key and cert properties');
+        }
+      }
+    }
+  }
+
+  if (action.type === 'socket-handler') {
+    if (!action.socketHandler) {
+      errors.push('Socket handler function is required for socket-handler action');
+    } else if (typeof action.socketHandler !== 'function') {
+      errors.push('Socket handler must be a function');
+    }
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+/**
+ * Validates a complete route configuration
+ * @param route Route configuration to validate
+ * @returns { valid: boolean, errors: string[] } Validation result
+ */
+export function validateRouteConfig(route: IRouteConfig): { valid: boolean; errors: string[] } {
+  const errors: string[] = [];
+
+  if (!route.match) {
+    errors.push('Route match configuration is required');
+  }
+
+  if (!route.action) {
+    errors.push('Route action configuration is required');
+  }
+
+  if (route.match) {
+    const matchValidation = validateRouteMatch(route.match);
+    if (!matchValidation.valid) {
+      errors.push(...matchValidation.errors.map(err => `Match: ${err}`));
+    }
+  }
+
+  if (route.action) {
+    const actionValidation = validateRouteAction(route.action);
+    if (!actionValidation.valid) {
+      errors.push(...actionValidation.errors.map(err => `Action: ${err}`));
+    }
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+/**
+ * Validate an array of route configurations
+ * @param routes Array of route configurations to validate
+ * @returns { valid: boolean, errors: { index: number, errors: string[] }[] } Validation result
+ */
+export function validateRoutes(routes: IRouteConfig[]): {
+  valid: boolean;
+  errors: { index: number; errors: string[] }[]
+} {
+  const results: { index: number; errors: string[] }[] = [];
+
+  routes.forEach((route, index) => {
+    const validation = validateRouteConfig(route);
+    if (!validation.valid) {
+      results.push({
+        index,
+        errors: validation.errors
+      });
+    }
+  });
+
+  return {
+    valid: results.length === 0,
+    errors: results
+  };
+}
+
+/**
+ * Check if a route configuration has the required properties for a specific action type
+ * @param route Route configuration to check
+ * @param actionType Expected action type
+ * @returns True if the route has the necessary properties, false otherwise
+ */
+export function hasRequiredPropertiesForAction(route: IRouteConfig, actionType: string): boolean {
+  if (!route.action || route.action.type !== actionType) {
+    return false;
+  }
+
+  switch (actionType) {
+    case 'forward':
+      return !!route.action.targets &&
+             Array.isArray(route.action.targets) &&
+             route.action.targets.length > 0 &&
+             route.action.targets.every(t => t.host && t.port !== undefined);
+    case 'socket-handler':
+      return !!route.action.socketHandler && typeof route.action.socketHandler === 'function';
+    default:
+      return false;
+  }
+}
+
+/**
+ * Throws an error if the route config is invalid, returns the config if valid
+ * Useful for immediate validation when creating routes
+ * @param route Route configuration to validate
+ * @returns The validated route configuration
+ * @throws Error if the route configuration is invalid
+ */
+export function assertValidRoute(route: IRouteConfig): IRouteConfig {
+  const validation = validateRouteConfig(route);
+  if (!validation.valid) {
+    throw new Error(`Invalid route configuration: ${validation.errors.join(', ')}`);
+  }
+  return route;
 }

package/ts/proxies/http-proxy/certificate-manager.ts

@@ -1,244 +0,0 @@
-import * as plugins from '../../plugins.js';
-import * as fs from 'fs';
-import * as path from 'path';
-import { fileURLToPath } from 'url';
-import { AsyncFileSystem } from '../../core/utils/fs-utils.js';
-import { type IHttpProxyOptions, type ICertificateEntry, type ILogger, createLogger } from './models/types.js';
-import type { IRouteConfig } from '../smart-proxy/models/route-types.js';
-
-/**
- * @deprecated This class is deprecated. Use SmartCertManager instead.
- * 
- * This is a stub implementation that maintains backward compatibility
- * while the functionality has been moved to SmartCertManager.
- */
-export class CertificateManager {
-  private defaultCertificates: { key: string; cert: string };
-  private certificateCache: Map<string, ICertificateEntry> = new Map();
-  private certificateStoreDir: string;
-  private logger: ILogger;
-  private httpsServer: plugins.https.Server | null = null;
-  private initialized = false;
-
-  constructor(private options: IHttpProxyOptions) {
-    this.certificateStoreDir = path.resolve(options.acme?.certificateStore || './certs');
-    this.logger = createLogger(options.logLevel || 'info');
-    
-    this.logger.warn('CertificateManager is deprecated - use SmartCertManager instead');
-    
-    // Initialize synchronously for backward compatibility but log warning
-    this.initializeSync();
-  }
-
-  /**
-   * Synchronous initialization for backward compatibility
-   * @deprecated This uses sync filesystem operations which block the event loop
-   */
-  private initializeSync(): void {
-    // 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();
-  }
-
-  /**
-   * Async initialization - preferred method
-   */
-  public async initialize(): Promise<void> {
-    if (this.initialized) return;
-    
-    // Ensure certificate store directory exists
-    try {
-      await AsyncFileSystem.ensureDir(this.certificateStoreDir);
-      this.logger.info(`Ensured certificate store directory: ${this.certificateStoreDir}`);
-    } catch (error) {
-      this.logger.warn(`Failed to create certificate store directory: ${error}`);
-    }
-    
-    await this.loadDefaultCertificatesAsync();
-    this.initialized = true;
-  }
-  
-  /**
-   * Loads default certificates from the filesystem
-   * @deprecated This uses sync filesystem operations which block the event loop
-   */
-  public loadDefaultCertificates(): void {
-    const __dirname = path.dirname(fileURLToPath(import.meta.url));
-    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('Loaded default certificates from filesystem (sync - deprecated)');
-    } catch (error) {
-      this.logger.error(`Failed to load default certificates: ${error}`);
-      this.generateSelfSignedCertificate();
-    }
-  }
-
-  /**
-   * Loads default certificates from the filesystem asynchronously
-   */
-  public async loadDefaultCertificatesAsync(): Promise<void> {
-    const __dirname = path.dirname(fileURLToPath(import.meta.url));
-    const certPath = path.join(__dirname, '..', '..', '..', 'assets', 'certs');
-
-    try {
-      const [key, cert] = await Promise.all([
-        AsyncFileSystem.readFile(path.join(certPath, 'key.pem')),
-        AsyncFileSystem.readFile(path.join(certPath, 'cert.pem'))
-      ]);
-      
-      this.defaultCertificates = { key, cert };
-      this.logger.info('Loaded default certificates from filesystem (async)');
-    } catch (error) {
-      this.logger.error(`Failed to load default certificates: ${error}`);
-      this.generateSelfSignedCertificate();
-    }
-  }
-
-  /**
-   * Generates self-signed certificates as fallback
-   */
-  private generateSelfSignedCertificate(): void {
-    // Generate a self-signed certificate using forge or similar
-    // For now, just use a placeholder
-    const selfSignedCert = `-----BEGIN CERTIFICATE-----
-MIIBkTCB+wIJAKHHIgIIA0/cMA0GCSqGSIb3DQEBBQUAMA0xCzAJBgNVBAYTAlVT
-MB4XDTE0MDEwMTAwMDAwMFoXDTI0MDEwMTAwMDAwMFowDTELMAkGA1UEBhMCVVMw
-gZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAMRiH0VwnOH3jCV7c6JFZWYrvuqy
------END CERTIFICATE-----`;
-    
-    const selfSignedKey = `-----BEGIN PRIVATE KEY-----
-MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAMRiH0VwnOH3jCV7
-c6JFZWYrvuqyALCLXj0pcr1iqNdHjegNXnkl5zjdaUjq4edNOKl7M1AlFiYjG2xk
------END PRIVATE KEY-----`;
-
-    this.defaultCertificates = {
-      key: selfSignedKey,
-      cert: selfSignedCert
-    };
-
-    this.logger.warn('Using self-signed certificate as fallback');
-  }
-
-  /**
-   * Gets the default certificates
-   */
-  public getDefaultCertificates(): { key: string; cert: string } {
-    return this.defaultCertificates;
-  }
-
-  /**
-   * @deprecated Use SmartCertManager instead
-   */
-  public setExternalPort80Handler(handler: any): void {
-    this.logger.warn('setExternalPort80Handler is deprecated - use SmartCertManager instead');
-  }
-
-  /**
-   * @deprecated Use SmartCertManager instead
-   */
-  public async updateRoutes(routes: IRouteConfig[]): Promise<void> {
-    this.logger.warn('updateRoutes is deprecated - use SmartCertManager instead');
-  }
-
-  /**
-   * Handles SNI callback to provide appropriate certificate
-   */
-  public handleSNI(domain: string, cb: (err: Error | null, ctx: plugins.tls.SecureContext) => void): void {
-    const certificate = this.getCachedCertificate(domain);
-    
-    if (certificate) {
-      const context = plugins.tls.createSecureContext({
-        key: certificate.key,
-        cert: certificate.cert
-      });
-      cb(null, context);
-      return;
-    }
-    
-    // Use default certificate if no domain-specific certificate found
-    const defaultContext = plugins.tls.createSecureContext({
-      key: this.defaultCertificates.key,
-      cert: this.defaultCertificates.cert
-    });
-    cb(null, defaultContext);
-  }
-
-  /**
-   * Updates a certificate in the cache
-   */
-  public updateCertificate(domain: string, cert: string, key: string): void {
-    this.certificateCache.set(domain, {
-      cert,
-      key,
-      expires: new Date(Date.now() + 90 * 24 * 60 * 60 * 1000) // 90 days
-    });
-    
-    this.logger.info(`Certificate updated for ${domain}`);
-  }
-
-  /**
-   * Gets a cached certificate
-   */
-  private getCachedCertificate(domain: string): ICertificateEntry | null {
-    return this.certificateCache.get(domain) || null;
-  }
-
-  /**
-   * @deprecated Use SmartCertManager instead
-   */
-  public async initializePort80Handler(): Promise<any> {
-    this.logger.warn('initializePort80Handler is deprecated - use SmartCertManager instead');
-    return null;
-  }
-
-  /**
-   * @deprecated Use SmartCertManager instead
-   */
-  public async stopPort80Handler(): Promise<void> {
-    this.logger.warn('stopPort80Handler is deprecated - use SmartCertManager instead');
-  }
-
-  /**
-   * @deprecated Use SmartCertManager instead
-   */
-  public registerDomainsWithPort80Handler(domains: string[]): void {
-    this.logger.warn('registerDomainsWithPort80Handler is deprecated - use SmartCertManager instead');
-  }
-
-  /**
-   * @deprecated Use SmartCertManager instead
-   */
-  public registerRoutesWithPort80Handler(routes: IRouteConfig[]): void {
-    this.logger.warn('registerRoutesWithPort80Handler is deprecated - use SmartCertManager instead');
-  }
-
-  /**
-   * Sets the HTTPS server for certificate updates
-   */
-  public setHttpsServer(server: plugins.https.Server): void {
-    this.httpsServer = server;
-  }
-
-  /**
-   * Gets statistics for metrics
-   */
-  public getStats() {
-    return {
-      cachedCertificates: this.certificateCache.size,
-      defaultCertEnabled: true
-    };
-  }
-}