@push.rocks/smartproxy 16.0.2 → 16.0.4

package/dist_ts/core/utils/shared-security-manager.d.ts

@@ -0,0 +1,110 @@
+import type { IRouteConfig, IRouteContext } from '../../proxies/smart-proxy/models/route-types.js';
+import type { IIpValidationResult, ISecurityLogger } from './security-utils.js';
+/**
+ * Shared SecurityManager for use across proxy components
+ * Handles IP tracking, rate limiting, and authentication
+ */
+export declare class SharedSecurityManager {
+    private logger?;
+    private connectionsByIP;
+    private rateLimits;
+    private ipFilterCache;
+    private maxConnectionsPerIP;
+    private connectionRateLimitPerMinute;
+    private cleanupInterval;
+    /**
+     * Create a new SharedSecurityManager
+     *
+     * @param options - Configuration options
+     * @param logger - Logger instance
+     */
+    constructor(options: {
+        maxConnectionsPerIP?: number;
+        connectionRateLimitPerMinute?: number;
+        cleanupIntervalMs?: number;
+        routes?: IRouteConfig[];
+    }, logger?: ISecurityLogger);
+    /**
+     * Get connections count by IP
+     *
+     * @param ip - The IP address to check
+     * @returns Number of connections from this IP
+     */
+    getConnectionCountByIP(ip: string): number;
+    /**
+     * Track connection by IP
+     *
+     * @param ip - The IP address to track
+     * @param connectionId - The connection ID to associate
+     */
+    trackConnectionByIP(ip: string, connectionId: string): void;
+    /**
+     * Remove connection tracking for an IP
+     *
+     * @param ip - The IP address to update
+     * @param connectionId - The connection ID to remove
+     */
+    removeConnectionByIP(ip: string, connectionId: string): void;
+    /**
+     * Check if IP is authorized based on route security settings
+     *
+     * @param ip - The IP address to check
+     * @param allowedIPs - List of allowed IP patterns
+     * @param blockedIPs - List of blocked IP patterns
+     * @returns Whether the IP is authorized
+     */
+    isIPAuthorized(ip: string, allowedIPs?: string[], blockedIPs?: string[]): boolean;
+    /**
+     * Validate IP against rate limits and connection limits
+     *
+     * @param ip - The IP address to validate
+     * @returns Result with allowed status and reason if blocked
+     */
+    validateIP(ip: string): IIpValidationResult;
+    /**
+     * Check if a client is allowed to access a specific route
+     *
+     * @param route - The route to check
+     * @param context - The request context
+     * @returns Whether access is allowed
+     */
+    isAllowed(route: IRouteConfig, context: IRouteContext): boolean;
+    /**
+     * Check if a client IP is allowed for a route
+     *
+     * @param route - The route to check
+     * @param clientIp - The client IP
+     * @returns Whether the IP is allowed
+     */
+    private isClientIpAllowed;
+    /**
+     * Check if request is within rate limit
+     *
+     * @param route - The route to check
+     * @param context - The request context
+     * @returns Whether the request is within rate limit
+     */
+    private isWithinRateLimit;
+    /**
+     * Validate HTTP Basic Authentication
+     *
+     * @param route - The route to check
+     * @param authHeader - The Authorization header
+     * @returns Whether authentication is valid
+     */
+    validateBasicAuth(route: IRouteConfig, authHeader?: string): boolean;
+    /**
+     * Clean up caches to prevent memory leaks
+     */
+    private cleanupCaches;
+    /**
+     * Clear all IP tracking data (for shutdown)
+     */
+    clearIPTracking(): void;
+    /**
+     * Update routes for security checking
+     *
+     * @param routes - New routes to use
+     */
+    setRoutes(routes: IRouteConfig[]): void;
+}

package/dist_ts/core/utils/shared-security-manager.js

@@ -0,0 +1,252 @@
+import * as plugins from '../../plugins.js';
+import { isIPAuthorized, checkMaxConnections, checkConnectionRate, trackConnection, removeConnection, cleanupExpiredRateLimits, parseBasicAuthHeader } from './security-utils.js';
+/**
+ * Shared SecurityManager for use across proxy components
+ * Handles IP tracking, rate limiting, and authentication
+ */
+export class SharedSecurityManager {
+    /**
+     * Create a new SharedSecurityManager
+     *
+     * @param options - Configuration options
+     * @param logger - Logger instance
+     */
+    constructor(options, logger) {
+        this.logger = logger;
+        // IP connection tracking
+        this.connectionsByIP = new Map();
+        // Route-specific rate limiting
+        this.rateLimits = new Map();
+        // Cache IP filtering results to avoid constant regex matching
+        this.ipFilterCache = new Map();
+        // Cache cleanup interval
+        this.cleanupInterval = null;
+        this.maxConnectionsPerIP = options.maxConnectionsPerIP || 100;
+        this.connectionRateLimitPerMinute = options.connectionRateLimitPerMinute || 300;
+        // Set up logger with defaults if not provided
+        this.logger = logger || {
+            info: console.log,
+            warn: console.warn,
+            error: console.error
+        };
+        // Set up cache cleanup interval
+        const cleanupInterval = options.cleanupIntervalMs || 60000; // Default: 1 minute
+        this.cleanupInterval = setInterval(() => {
+            this.cleanupCaches();
+        }, cleanupInterval);
+        // Don't keep the process alive just for cleanup
+        if (this.cleanupInterval.unref) {
+            this.cleanupInterval.unref();
+        }
+    }
+    /**
+     * Get connections count by IP
+     *
+     * @param ip - The IP address to check
+     * @returns Number of connections from this IP
+     */
+    getConnectionCountByIP(ip) {
+        return this.connectionsByIP.get(ip)?.connections.size || 0;
+    }
+    /**
+     * Track connection by IP
+     *
+     * @param ip - The IP address to track
+     * @param connectionId - The connection ID to associate
+     */
+    trackConnectionByIP(ip, connectionId) {
+        trackConnection(ip, connectionId, this.connectionsByIP);
+    }
+    /**
+     * Remove connection tracking for an IP
+     *
+     * @param ip - The IP address to update
+     * @param connectionId - The connection ID to remove
+     */
+    removeConnectionByIP(ip, connectionId) {
+        removeConnection(ip, connectionId, this.connectionsByIP);
+    }
+    /**
+     * Check if IP is authorized based on route security settings
+     *
+     * @param ip - The IP address to check
+     * @param allowedIPs - List of allowed IP patterns
+     * @param blockedIPs - List of blocked IP patterns
+     * @returns Whether the IP is authorized
+     */
+    isIPAuthorized(ip, allowedIPs = ['*'], blockedIPs = []) {
+        return isIPAuthorized(ip, allowedIPs, blockedIPs);
+    }
+    /**
+     * Validate IP against rate limits and connection limits
+     *
+     * @param ip - The IP address to validate
+     * @returns Result with allowed status and reason if blocked
+     */
+    validateIP(ip) {
+        // Check connection count limit
+        const connectionResult = checkMaxConnections(ip, this.connectionsByIP, this.maxConnectionsPerIP);
+        if (!connectionResult.allowed) {
+            return connectionResult;
+        }
+        // Check connection rate limit
+        const rateResult = checkConnectionRate(ip, this.connectionsByIP, this.connectionRateLimitPerMinute);
+        if (!rateResult.allowed) {
+            return rateResult;
+        }
+        return { allowed: true };
+    }
+    /**
+     * Check if a client is allowed to access a specific route
+     *
+     * @param route - The route to check
+     * @param context - The request context
+     * @returns Whether access is allowed
+     */
+    isAllowed(route, context) {
+        if (!route.security) {
+            return true; // No security restrictions
+        }
+        // --- IP filtering ---
+        if (!this.isClientIpAllowed(route, context.clientIp)) {
+            this.logger?.debug?.(`IP ${context.clientIp} is blocked for route ${route.name || 'unnamed'}`);
+            return false;
+        }
+        // --- Rate limiting ---
+        if (route.security.rateLimit?.enabled && !this.isWithinRateLimit(route, context)) {
+            this.logger?.debug?.(`Rate limit exceeded for route ${route.name || 'unnamed'}`);
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Check if a client IP is allowed for a route
+     *
+     * @param route - The route to check
+     * @param clientIp - The client IP
+     * @returns Whether the IP is allowed
+     */
+    isClientIpAllowed(route, clientIp) {
+        if (!route.security) {
+            return true; // No security restrictions
+        }
+        const routeId = route.id || route.name || 'unnamed';
+        // Check cache first
+        if (!this.ipFilterCache.has(routeId)) {
+            this.ipFilterCache.set(routeId, new Map());
+        }
+        const routeCache = this.ipFilterCache.get(routeId);
+        if (routeCache.has(clientIp)) {
+            return routeCache.get(clientIp);
+        }
+        // Check IP against route security settings
+        const ipAllowList = route.security.ipAllowList || route.security.allowedIps;
+        const ipBlockList = route.security.ipBlockList || route.security.blockedIps;
+        const allowed = this.isIPAuthorized(clientIp, ipAllowList, ipBlockList);
+        // Cache the result
+        routeCache.set(clientIp, allowed);
+        return allowed;
+    }
+    /**
+     * Check if request is within rate limit
+     *
+     * @param route - The route to check
+     * @param context - The request context
+     * @returns Whether the request is within rate limit
+     */
+    isWithinRateLimit(route, context) {
+        if (!route.security?.rateLimit?.enabled) {
+            return true;
+        }
+        const rateLimit = route.security.rateLimit;
+        const routeId = route.id || route.name || 'unnamed';
+        // Determine rate limit key (by IP, path, or header)
+        let key = context.clientIp; // Default to IP
+        if (rateLimit.keyBy === 'path' && context.path) {
+            key = `${context.clientIp}:${context.path}`;
+        }
+        else if (rateLimit.keyBy === 'header' && rateLimit.headerName && context.headers) {
+            const headerValue = context.headers[rateLimit.headerName.toLowerCase()];
+            if (headerValue) {
+                key = `${context.clientIp}:${headerValue}`;
+            }
+        }
+        // Get or create rate limit tracking for this route
+        if (!this.rateLimits.has(routeId)) {
+            this.rateLimits.set(routeId, new Map());
+        }
+        const routeLimits = this.rateLimits.get(routeId);
+        const now = Date.now();
+        // Get or create rate limit tracking for this key
+        let limit = routeLimits.get(key);
+        if (!limit || limit.expiry < now) {
+            // Create new rate limit or reset expired one
+            limit = {
+                count: 1,
+                expiry: now + (rateLimit.window * 1000)
+            };
+            routeLimits.set(key, limit);
+            return true;
+        }
+        // Increment the counter
+        limit.count++;
+        // Check if rate limit is exceeded
+        return limit.count <= rateLimit.maxRequests;
+    }
+    /**
+     * Validate HTTP Basic Authentication
+     *
+     * @param route - The route to check
+     * @param authHeader - The Authorization header
+     * @returns Whether authentication is valid
+     */
+    validateBasicAuth(route, authHeader) {
+        // Skip if basic auth not enabled for route
+        if (!route.security?.basicAuth?.enabled) {
+            return true;
+        }
+        // No auth header means auth failed
+        if (!authHeader) {
+            return false;
+        }
+        // Parse auth header
+        const credentials = parseBasicAuthHeader(authHeader);
+        if (!credentials) {
+            return false;
+        }
+        // Check credentials against configured users
+        const { username, password } = credentials;
+        const users = route.security.basicAuth.users;
+        return users.some(user => user.username === username && user.password === password);
+    }
+    /**
+     * Clean up caches to prevent memory leaks
+     */
+    cleanupCaches() {
+        // Clean up rate limits
+        cleanupExpiredRateLimits(this.rateLimits, this.logger);
+        // IP filter cache doesn't need cleanup (tied to routes)
+    }
+    /**
+     * Clear all IP tracking data (for shutdown)
+     */
+    clearIPTracking() {
+        this.connectionsByIP.clear();
+        this.rateLimits.clear();
+        this.ipFilterCache.clear();
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = null;
+        }
+    }
+    /**
+     * Update routes for security checking
+     *
+     * @param routes - New routes to use
+     */
+    setRoutes(routes) {
+        // Only clear the IP filter cache - route-specific
+        this.ipFilterCache.clear();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"shared-security-manager.js","sourceRoot":"","sources":["../../../ts/core/utils/shared-security-manager.ts"],"names":[],"mappings":"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"}

package/dist_ts/core/utils/template-utils.d.ts

@@ -0,0 +1,37 @@
+import type { IRouteContext } from '../models/route-context.js';
+/**
+ * Utility class for resolving template variables in strings
+ */
+export declare class TemplateUtils {
+    /**
+     * Resolve template variables in a string using the route context
+     * Supports variables like {domain}, {path}, {clientIp}, etc.
+     *
+     * @param template The template string with {variables}
+     * @param context The route context with values
+     * @returns The resolved string
+     */
+    static resolveTemplateVariables(template: string, context: IRouteContext): string;
+    /**
+     * Safely convert a value to a string
+     *
+     * @param value Any value to convert to string
+     * @returns String representation or original match for complex objects
+     */
+    private static convertToString;
+    /**
+     * Resolve template variables in header values
+     *
+     * @param headers Header object with potential template variables
+     * @param context Route context for variable resolution
+     * @returns New header object with resolved values
+     */
+    static resolveHeaderTemplates(headers: Record<string, string>, context: IRouteContext): Record<string, string>;
+    /**
+     * Check if a string contains template variables
+     *
+     * @param str String to check for template variables
+     * @returns True if string contains template variables
+     */
+    static containsTemplateVariables(str: string): boolean;
+}

package/dist_ts/core/utils/template-utils.js

@@ -0,0 +1,104 @@
+/**
+ * Utility class for resolving template variables in strings
+ */
+export class TemplateUtils {
+    /**
+     * Resolve template variables in a string using the route context
+     * Supports variables like {domain}, {path}, {clientIp}, etc.
+     *
+     * @param template The template string with {variables}
+     * @param context The route context with values
+     * @returns The resolved string
+     */
+    static resolveTemplateVariables(template, context) {
+        if (!template) {
+            return template;
+        }
+        // Replace variables with values from context
+        return template.replace(/\{([a-zA-Z0-9_\.]+)\}/g, (match, varName) => {
+            // Handle nested properties with dot notation (e.g., {headers.host})
+            if (varName.includes('.')) {
+                const parts = varName.split('.');
+                let current = context;
+                // Traverse nested object structure
+                for (const part of parts) {
+                    if (current === undefined || current === null) {
+                        return match; // Return original if path doesn't exist
+                    }
+                    current = current[part];
+                }
+                // Return the resolved value if it exists
+                if (current !== undefined && current !== null) {
+                    return TemplateUtils.convertToString(current);
+                }
+                return match;
+            }
+            // Direct property access
+            const value = context[varName];
+            if (value === undefined) {
+                return match; // Keep the original {variable} if not found
+            }
+            // Convert value to string
+            return TemplateUtils.convertToString(value);
+        });
+    }
+    /**
+     * Safely convert a value to a string
+     *
+     * @param value Any value to convert to string
+     * @returns String representation or original match for complex objects
+     */
+    static convertToString(value) {
+        if (value === null || value === undefined) {
+            return '';
+        }
+        if (typeof value === 'string') {
+            return value;
+        }
+        if (typeof value === 'number' || typeof value === 'boolean') {
+            return value.toString();
+        }
+        if (Array.isArray(value)) {
+            return value.join(',');
+        }
+        if (typeof value === 'object') {
+            try {
+                return JSON.stringify(value);
+            }
+            catch (e) {
+                return '[Object]';
+            }
+        }
+        return String(value);
+    }
+    /**
+     * Resolve template variables in header values
+     *
+     * @param headers Header object with potential template variables
+     * @param context Route context for variable resolution
+     * @returns New header object with resolved values
+     */
+    static resolveHeaderTemplates(headers, context) {
+        const result = {};
+        for (const [key, value] of Object.entries(headers)) {
+            // Skip special directive headers (starting with !)
+            if (value.startsWith('!')) {
+                result[key] = value;
+                continue;
+            }
+            // Resolve template variables in the header value
+            result[key] = TemplateUtils.resolveTemplateVariables(value, context);
+        }
+        return result;
+    }
+    /**
+     * Check if a string contains template variables
+     *
+     * @param str String to check for template variables
+     * @returns True if string contains template variables
+     */
+    static containsTemplateVariables(str) {
+        return !!str && /\{([a-zA-Z0-9_\.]+)\}/g.test(str);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/core/utils/websocket-utils.d.ts

@@ -0,0 +1,23 @@
+/**
+ * WebSocket utility functions
+ */
+/**
+ * Type for WebSocket RawData that can be different types in different environments
+ * This matches the ws library's type definition
+ */
+export type RawData = Buffer | ArrayBuffer | Buffer[] | any;
+/**
+ * Get the length of a WebSocket message regardless of its type
+ * (handles all possible WebSocket message data types)
+ *
+ * @param data - The data message from WebSocket (could be any RawData type)
+ * @returns The length of the data in bytes
+ */
+export declare function getMessageSize(data: RawData): number;
+/**
+ * Convert any raw WebSocket data to Buffer for consistent handling
+ *
+ * @param data - The data message from WebSocket (could be any RawData type)
+ * @returns A Buffer containing the data
+ */
+export declare function toBuffer(data: RawData): Buffer;

package/dist_ts/core/utils/websocket-utils.js

@@ -0,0 +1,86 @@
+/**
+ * WebSocket utility functions
+ */
+/**
+ * Get the length of a WebSocket message regardless of its type
+ * (handles all possible WebSocket message data types)
+ *
+ * @param data - The data message from WebSocket (could be any RawData type)
+ * @returns The length of the data in bytes
+ */
+export function getMessageSize(data) {
+    if (typeof data === 'string') {
+        // For string data, get the byte length
+        return Buffer.from(data, 'utf8').length;
+    }
+    else if (data instanceof Buffer) {
+        // For Node.js Buffer
+        return data.length;
+    }
+    else if (data instanceof ArrayBuffer) {
+        // For ArrayBuffer
+        return data.byteLength;
+    }
+    else if (Array.isArray(data)) {
+        // For array of buffers, sum their lengths
+        return data.reduce((sum, chunk) => {
+            if (chunk instanceof Buffer) {
+                return sum + chunk.length;
+            }
+            else if (chunk instanceof ArrayBuffer) {
+                return sum + chunk.byteLength;
+            }
+            return sum;
+        }, 0);
+    }
+    else {
+        // For other types, try to determine the size or return 0
+        try {
+            return Buffer.from(data).length;
+        }
+        catch (e) {
+            console.warn('Could not determine message size', e);
+            return 0;
+        }
+    }
+}
+/**
+ * Convert any raw WebSocket data to Buffer for consistent handling
+ *
+ * @param data - The data message from WebSocket (could be any RawData type)
+ * @returns A Buffer containing the data
+ */
+export function toBuffer(data) {
+    if (typeof data === 'string') {
+        return Buffer.from(data, 'utf8');
+    }
+    else if (data instanceof Buffer) {
+        return data;
+    }
+    else if (data instanceof ArrayBuffer) {
+        return Buffer.from(data);
+    }
+    else if (Array.isArray(data)) {
+        // For array of buffers, concatenate them
+        return Buffer.concat(data.map(chunk => {
+            if (chunk instanceof Buffer) {
+                return chunk;
+            }
+            else if (chunk instanceof ArrayBuffer) {
+                return Buffer.from(chunk);
+            }
+            return Buffer.from(chunk);
+        }));
+    }
+    else {
+        // For other types, try to convert to Buffer or return empty Buffer
+        try {
+            return Buffer.from(data);
+        }
+        catch (e) {
+            console.warn('Could not convert message to Buffer', e);
+            return Buffer.alloc(0);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/http/router/index.d.ts

@@ -1,4 +1,8 @@
 /**
  * HTTP routing
  */
-export * from './proxy-router.js';
+export { ProxyRouter } from './proxy-router.js';
+export type { IPathPatternConfig } from './proxy-router.js';
+export type { PathPatternConfig as ProxyPathPatternConfig, RouterResult as ProxyRouterResult } from './proxy-router.js';
+export { RouteRouter } from './route-router.js';
+export type { PathPatternConfig as RoutePathPatternConfig, RouterResult as RouteRouterResult } from './route-router.js';

package/dist_ts/http/router/index.js

@@ -1,5 +1,7 @@
 /**
  * HTTP routing
  */
-export * from './proxy-router.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9odHRwL3JvdXRlci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsbUJBQW1CLENBQUMifQ==
+// Export selectively to avoid ambiguity between duplicate type names
+export { ProxyRouter } from './proxy-router.js';
+export { RouteRouter } from './route-router.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9odHRwL3JvdXRlci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILHFFQUFxRTtBQUNyRSxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFLaEQsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLG1CQUFtQixDQUFDIn0=