@push.rocks/smartproxy 16.0.2 → 16.0.3

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

@@ -0,0 +1,65 @@
+import type { ILogger } from './models/types.js';
+import type { IRouteConfig } from '../smart-proxy/models/route-types.js';
+import type { IRouteContext } from '../../core/models/route-context.js';
+/**
+ * Manages security features for the NetworkProxy
+ * Implements Phase 5.4: Security features like IP filtering and rate limiting
+ */
+export declare class SecurityManager {
+    private logger;
+    private routes;
+    private ipFilterCache;
+    private rateLimits;
+    constructor(logger: ILogger, routes?: IRouteConfig[]);
+    /**
+     * Update the routes configuration
+     */
+    setRoutes(routes: IRouteConfig[]): void;
+    /**
+     * Check if a client is allowed to access a specific route
+     *
+     * @param route The route to check access for
+     * @param context The route context with client information
+     * @returns True if access is allowed, false otherwise
+     */
+    isAllowed(route: IRouteConfig, context: IRouteContext): boolean;
+    /**
+     * Check if an IP is allowed based on route security settings
+     */
+    private isIpAllowed;
+    /**
+     * Check if IP matches any pattern in the list
+     */
+    private ipMatchesPattern;
+    /**
+     * Check if IP matches CIDR notation
+     * Very basic implementation - for production use, consider a dedicated IP library
+     */
+    private ipMatchesCidr;
+    /**
+     * Check if request is within rate limit
+     */
+    private isWithinRateLimit;
+    /**
+     * Clean up expired rate limits
+     * Should be called periodically to prevent memory leaks
+     */
+    cleanupExpiredRateLimits(): void;
+    /**
+     * Check basic auth credentials
+     *
+     * @param route The route to check auth for
+     * @param username The provided username
+     * @param password The provided password
+     * @returns True if credentials are valid, false otherwise
+     */
+    checkBasicAuth(route: IRouteConfig, username: string, password: string): boolean;
+    /**
+     * Verify a JWT token
+     *
+     * @param route The route to verify the token for
+     * @param token The JWT token to verify
+     * @returns True if the token is valid, false otherwise
+     */
+    verifyJwtToken(route: IRouteConfig, token: string): boolean;
+}

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

@@ -0,0 +1,255 @@
+import * as plugins from '../../plugins.js';
+/**
+ * Manages security features for the NetworkProxy
+ * Implements Phase 5.4: Security features like IP filtering and rate limiting
+ */
+export class SecurityManager {
+    constructor(logger, routes = []) {
+        this.logger = logger;
+        this.routes = routes;
+        // Cache IP filtering results to avoid constant regex matching
+        this.ipFilterCache = new Map();
+        // Store rate limits per route and key
+        this.rateLimits = new Map();
+    }
+    /**
+     * Update the routes configuration
+     */
+    setRoutes(routes) {
+        this.routes = routes;
+        // Reset caches when routes change
+        this.ipFilterCache.clear();
+    }
+    /**
+     * Check if a client is allowed to access a specific route
+     *
+     * @param route The route to check access for
+     * @param context The route context with client information
+     * @returns True if access is allowed, false otherwise
+     */
+    isAllowed(route, context) {
+        if (!route.security) {
+            return true; // No security restrictions
+        }
+        // --- IP filtering ---
+        if (!this.isIpAllowed(route, context.clientIp)) {
+            this.logger.debug(`IP ${context.clientIp} is blocked for route ${route.name || route.id || 'unnamed'}`);
+            return false;
+        }
+        // --- Rate limiting ---
+        if (route.security.rateLimit?.enabled && !this.isWithinRateLimit(route, context)) {
+            this.logger.debug(`Rate limit exceeded for route ${route.name || route.id || 'unnamed'}`);
+            return false;
+        }
+        // --- Basic Auth (handled at HTTP level) ---
+        // Basic auth is not checked here as it requires HTTP headers
+        // and is handled in the RequestHandler
+        return true;
+    }
+    /**
+     * Check if an IP is allowed based on route security settings
+     */
+    isIpAllowed(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);
+        }
+        let allowed = true;
+        // Check block list first (deny has priority over allow)
+        if (route.security.ipBlockList && route.security.ipBlockList.length > 0) {
+            if (this.ipMatchesPattern(clientIp, route.security.ipBlockList)) {
+                allowed = false;
+            }
+        }
+        // Then check allow list (overrides block list if specified)
+        if (route.security.ipAllowList && route.security.ipAllowList.length > 0) {
+            // If allow list is specified, IP must match an entry to be allowed
+            allowed = this.ipMatchesPattern(clientIp, route.security.ipAllowList);
+        }
+        // Cache the result
+        routeCache.set(clientIp, allowed);
+        return allowed;
+    }
+    /**
+     * Check if IP matches any pattern in the list
+     */
+    ipMatchesPattern(ip, patterns) {
+        for (const pattern of patterns) {
+            // CIDR notation
+            if (pattern.includes('/')) {
+                if (this.ipMatchesCidr(ip, pattern)) {
+                    return true;
+                }
+            }
+            // Wildcard notation
+            else if (pattern.includes('*')) {
+                const regex = new RegExp('^' + pattern.replace(/\./g, '\\.').replace(/\*/g, '.*') + '$');
+                if (regex.test(ip)) {
+                    return true;
+                }
+            }
+            // Exact match
+            else if (pattern === ip) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Check if IP matches CIDR notation
+     * Very basic implementation - for production use, consider a dedicated IP library
+     */
+    ipMatchesCidr(ip, cidr) {
+        try {
+            const [subnet, bits] = cidr.split('/');
+            const mask = parseInt(bits, 10);
+            // Convert IP to numeric format
+            const ipParts = ip.split('.').map(part => parseInt(part, 10));
+            const subnetParts = subnet.split('.').map(part => parseInt(part, 10));
+            // Calculate the numeric IP and subnet
+            const ipNum = (ipParts[0] << 24) | (ipParts[1] << 16) | (ipParts[2] << 8) | ipParts[3];
+            const subnetNum = (subnetParts[0] << 24) | (subnetParts[1] << 16) | (subnetParts[2] << 8) | subnetParts[3];
+            // Calculate the mask
+            const maskNum = ~((1 << (32 - mask)) - 1);
+            // Check if IP is in subnet
+            return (ipNum & maskNum) === (subnetNum & maskNum);
+        }
+        catch (e) {
+            this.logger.error(`Invalid CIDR notation: ${cidr}`);
+            return false;
+        }
+    }
+    /**
+     * Check if 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;
+    }
+    /**
+     * Clean up expired rate limits
+     * Should be called periodically to prevent memory leaks
+     */
+    cleanupExpiredRateLimits() {
+        const now = Date.now();
+        for (const [routeId, routeLimits] of this.rateLimits.entries()) {
+            let removed = 0;
+            for (const [key, limit] of routeLimits.entries()) {
+                if (limit.expiry < now) {
+                    routeLimits.delete(key);
+                    removed++;
+                }
+            }
+            if (removed > 0) {
+                this.logger.debug(`Cleaned up ${removed} expired rate limits for route ${routeId}`);
+            }
+        }
+    }
+    /**
+     * Check basic auth credentials
+     *
+     * @param route The route to check auth for
+     * @param username The provided username
+     * @param password The provided password
+     * @returns True if credentials are valid, false otherwise
+     */
+    checkBasicAuth(route, username, password) {
+        if (!route.security?.basicAuth?.enabled) {
+            return true;
+        }
+        const basicAuth = route.security.basicAuth;
+        // Check credentials against configured users
+        for (const user of basicAuth.users) {
+            if (user.username === username && user.password === password) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Verify a JWT token
+     *
+     * @param route The route to verify the token for
+     * @param token The JWT token to verify
+     * @returns True if the token is valid, false otherwise
+     */
+    verifyJwtToken(route, token) {
+        if (!route.security?.jwtAuth?.enabled) {
+            return true;
+        }
+        try {
+            // This is a simplified version - in production you'd use a proper JWT library
+            const jwtAuth = route.security.jwtAuth;
+            // Verify structure
+            const parts = token.split('.');
+            if (parts.length !== 3) {
+                return false;
+            }
+            // Decode payload
+            const payload = JSON.parse(Buffer.from(parts[1], 'base64').toString());
+            // Check expiration
+            if (payload.exp && payload.exp < Math.floor(Date.now() / 1000)) {
+                return false;
+            }
+            // Check issuer
+            if (jwtAuth.issuer && payload.iss !== jwtAuth.issuer) {
+                return false;
+            }
+            // Check audience
+            if (jwtAuth.audience && payload.aud !== jwtAuth.audience) {
+                return false;
+            }
+            // In a real implementation, you'd also verify the signature
+            // using the secret and algorithm specified in jwtAuth
+            return true;
+        }
+        catch (err) {
+            this.logger.error(`Error verifying JWT: ${err}`);
+            return false;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"security-manager.js","sourceRoot":"","sources":["../../../ts/proxies/network-proxy/security-manager.ts"],"names":[],"mappings":"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"}

package/dist_ts/proxies/network-proxy/websocket-handler.d.ts

@@ -1,18 +1,29 @@
 import * as plugins from '../../plugins.js';
+import '../../core/models/socket-augmentation.js';
 import { type INetworkProxyOptions } from './models/types.js';
 import { ConnectionPool } from './connection-pool.js';
 import { ProxyRouter } from '../../http/router/index.js';
+import type { IRouteConfig } from '../smart-proxy/models/route-types.js';
 /**
  * Handles WebSocket connections and proxying
  */
 export declare class WebSocketHandler {
     private options;
     private connectionPool;
-    private router;
+    private legacyRouter;
+    private routes;
     private heartbeatInterval;
     private wsServer;
     private logger;
-    constructor(options: INetworkProxyOptions, connectionPool: ConnectionPool, router: ProxyRouter);
+    private contextCreator;
+    private routeRouter;
+    private securityManager;
+    constructor(options: INetworkProxyOptions, connectionPool: ConnectionPool, legacyRouter: ProxyRouter, // Legacy router for backward compatibility
+    routes?: IRouteConfig[]);
+    /**
+     * Set the route configurations
+     */
+    setRoutes(routes: IRouteConfig[]): void;
     /**
      * Initialize WebSocket server on an existing HTTPS server
      */