@push.rocks/smartproxy 21.0.0 → 21.1.1

package/changelog.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 2025-07-22 - 21.1.1 - fix(detection)
+Fix SNI detection in TLS detector
+
+- Restored proper TLS detector implementation with ClientHello parsing
+- Fixed imports to use new protocols module locations
+- Added missing detectWithContext method for fragmented detection
+- Fixed method names to match BufferAccumulator interface
+- Removed unused import readUInt24BE
+
+## 2025-07-21 - 21.1.0 - feat(protocols)
+Refactor protocol utilities into centralized protocols module
+
+- Moved TLS utilities from `ts/tls/` to `ts/protocols/tls/`
+- Created centralized protocol modules for HTTP, WebSocket, Proxy, and TLS
+- Core utilities now delegate to protocol modules for parsing and utilities
+- Maintains backward compatibility through re-exports in original locations
+- Improves code organization and separation of concerns
+
 ## 2025-07-22 - 21.0.0 - BREAKING_CHANGE(forwarding)
 Remove legacy forwarding module
 

package/dist_ts/core/utils/proxy-protocol.d.ts

@@ -1,24 +1,12 @@
 import * as plugins from '../../plugins.js';
-/**
- * Interface representing parsed PROXY protocol information
- */
-export interface IProxyInfo {
-    protocol: 'TCP4' | 'TCP6' | 'UNKNOWN';
-    sourceIP: string;
-    sourcePort: number;
-    destinationIP: string;
-    destinationPort: number;
-}
-/**
- * Interface for parse result including remaining data
- */
-export interface IProxyParseResult {
-    proxyInfo: IProxyInfo | null;
-    remainingData: Buffer;
-}
+import { type IProxyInfo, type IProxyParseResult } from '../../protocols/proxy/index.js';
+export type { IProxyInfo, IProxyParseResult } from '../../protocols/proxy/index.js';
 /**
  * Parser for PROXY protocol v1 (text format)
  * Spec: https://www.haproxy.org/download/1.8/doc/proxy-protocol.txt
+ *
+ * This class now delegates to the protocol parser but adds
+ * smartproxy-specific features like socket reading and logging
  */
 export declare class ProxyProtocolParser {
     static readonly PROXY_V1_SIGNATURE = "PROXY ";

package/dist_ts/core/utils/proxy-protocol.js

@@ -1,121 +1,37 @@
 import * as plugins from '../../plugins.js';
 import { logger } from './logger.js';
+import { ProxyProtocolParser as ProtocolParser } from '../../protocols/proxy/index.js';
 /**
  * Parser for PROXY protocol v1 (text format)
  * Spec: https://www.haproxy.org/download/1.8/doc/proxy-protocol.txt
+ *
+ * This class now delegates to the protocol parser but adds
+ * smartproxy-specific features like socket reading and logging
  */
 export class ProxyProtocolParser {
-    static { this.PROXY_V1_SIGNATURE = 'PROXY '; }
-    static { this.MAX_HEADER_LENGTH = 107; } // Max length for v1 header
-    static { this.HEADER_TERMINATOR = '\r\n'; }
+    static { this.PROXY_V1_SIGNATURE = ProtocolParser.PROXY_V1_SIGNATURE; }
+    static { this.MAX_HEADER_LENGTH = ProtocolParser.MAX_HEADER_LENGTH; }
+    static { this.HEADER_TERMINATOR = ProtocolParser.HEADER_TERMINATOR; }
     /**
      * Parse PROXY protocol v1 header from buffer
      * Returns proxy info and remaining data after header
      */
     static parse(data) {
-        // Check if buffer starts with PROXY signature
-        if (!data.toString('ascii', 0, 6).startsWith(this.PROXY_V1_SIGNATURE)) {
-            return {
-                proxyInfo: null,
-                remainingData: data
-            };
-        }
-        // Find header terminator
-        const headerEndIndex = data.indexOf(this.HEADER_TERMINATOR);
-        if (headerEndIndex === -1) {
-            // Header incomplete, need more data
-            if (data.length > this.MAX_HEADER_LENGTH) {
-                // Header too long, invalid
-                throw new Error('PROXY protocol header exceeds maximum length');
-            }
-            return {
-                proxyInfo: null,
-                remainingData: data
-            };
-        }
-        // Extract header line
-        const headerLine = data.toString('ascii', 0, headerEndIndex);
-        const remainingData = data.slice(headerEndIndex + 2); // Skip \r\n
-        // Parse header
-        const parts = headerLine.split(' ');
-        if (parts.length < 2) {
-            throw new Error(`Invalid PROXY protocol header format: ${headerLine}`);
-        }
-        const [signature, protocol] = parts;
-        // Validate protocol
-        if (!['TCP4', 'TCP6', 'UNKNOWN'].includes(protocol)) {
-            throw new Error(`Invalid PROXY protocol: ${protocol}`);
-        }
-        // For UNKNOWN protocol, ignore addresses
-        if (protocol === 'UNKNOWN') {
-            return {
-                proxyInfo: {
-                    protocol: 'UNKNOWN',
-                    sourceIP: '',
-                    sourcePort: 0,
-                    destinationIP: '',
-                    destinationPort: 0
-                },
-                remainingData
-            };
-        }
-        // For TCP4/TCP6, we need all 6 parts
-        if (parts.length !== 6) {
-            throw new Error(`Invalid PROXY protocol header format: ${headerLine}`);
-        }
-        const [, , srcIP, dstIP, srcPort, dstPort] = parts;
-        // Validate and parse ports
-        const sourcePort = parseInt(srcPort, 10);
-        const destinationPort = parseInt(dstPort, 10);
-        if (isNaN(sourcePort) || sourcePort < 0 || sourcePort > 65535) {
-            throw new Error(`Invalid source port: ${srcPort}`);
-        }
-        if (isNaN(destinationPort) || destinationPort < 0 || destinationPort > 65535) {
-            throw new Error(`Invalid destination port: ${dstPort}`);
-        }
-        // Validate IP addresses
-        const protocolType = protocol;
-        if (!this.isValidIP(srcIP, protocolType)) {
-            throw new Error(`Invalid source IP for ${protocol}: ${srcIP}`);
-        }
-        if (!this.isValidIP(dstIP, protocolType)) {
-            throw new Error(`Invalid destination IP for ${protocol}: ${dstIP}`);
-        }
-        return {
-            proxyInfo: {
-                protocol: protocol,
-                sourceIP: srcIP,
-                sourcePort,
-                destinationIP: dstIP,
-                destinationPort
-            },
-            remainingData
-        };
+        // Delegate to protocol parser
+        return ProtocolParser.parse(data);
     }
     /**
      * Generate PROXY protocol v1 header
      */
     static generate(info) {
-        if (info.protocol === 'UNKNOWN') {
-            return Buffer.from(`PROXY UNKNOWN\r\n`, 'ascii');
-        }
-        const header = `PROXY ${info.protocol} ${info.sourceIP} ${info.destinationIP} ${info.sourcePort} ${info.destinationPort}\r\n`;
-        if (header.length > this.MAX_HEADER_LENGTH) {
-            throw new Error('Generated PROXY protocol header exceeds maximum length');
-        }
-        return Buffer.from(header, 'ascii');
+        // Delegate to protocol parser
+        return ProtocolParser.generate(info);
     }
     /**
      * Validate IP address format
      */
     static isValidIP(ip, protocol) {
-        if (protocol === 'TCP4') {
-            return plugins.net.isIPv4(ip);
-        }
-        else if (protocol === 'TCP6') {
-            return plugins.net.isIPv6(ip);
-        }
-        return false;
+        return ProtocolParser.isValidIP(ip, protocol);
     }
     /**
      * Attempt to read a complete PROXY protocol header from a socket
@@ -198,4 +114,4 @@ export class ProxyProtocolParser {
         });
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,11 +1,10 @@
 /**
  * WebSocket utility functions
+ *
+ * This module provides smartproxy-specific WebSocket utilities
+ * and re-exports protocol utilities from the protocols module
  */
-/**
- * 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;
+export type { RawData } from '../../protocols/websocket/index.js';
 /**
  * Get the length of a WebSocket message regardless of its type
  * (handles all possible WebSocket message data types)
@@ -13,11 +12,11 @@ export type RawData = Buffer | ArrayBuffer | Buffer[] | any;
  * @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;
+export declare function getMessageSize(data: import('../../protocols/websocket/index.js').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;
+export declare function toBuffer(data: import('../../protocols/websocket/index.js').RawData): Buffer;

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

@@ -1,6 +1,11 @@
 /**
  * WebSocket utility functions
+ *
+ * This module provides smartproxy-specific WebSocket utilities
+ * and re-exports protocol utilities from the protocols module
  */
+// Import and re-export from protocols
+import { getMessageSize as protocolGetMessageSize, toBuffer as protocolToBuffer } from '../../protocols/websocket/index.js';
 /**
  * Get the length of a WebSocket message regardless of its type
  * (handles all possible WebSocket message data types)
@@ -9,40 +14,8 @@
  * @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;
-        }
-    }
+    // Delegate to protocol implementation
+    return protocolGetMessageSize(data);
 }
 /**
  * Convert any raw WebSocket data to Buffer for consistent handling
@@ -51,36 +24,7 @@ export function getMessageSize(data) {
  * @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);
-        }
-    }
+    // Delegate to protocol implementation
+    return protocolToBuffer(data);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2Vic29ja2V0LXV0aWxzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vdHMvY29yZS91dGlscy93ZWJzb2NrZXQtdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7O0dBS0c7QUFFSCxzQ0FBc0M7QUFDdEMsT0FBTyxFQUFFLGNBQWMsSUFBSSxzQkFBc0IsRUFBRSxRQUFRLElBQUksZ0JBQWdCLEVBQUUsTUFBTSxvQ0FBb0MsQ0FBQztBQUc1SDs7Ozs7O0dBTUc7QUFDSCxNQUFNLFVBQVUsY0FBYyxDQUFDLElBQTBEO0lBQ3ZGLHNDQUFzQztJQUN0QyxPQUFPLHNCQUFzQixDQUFDLElBQUksQ0FBQyxDQUFDO0FBQ3RDLENBQUM7QUFFRDs7Ozs7R0FLRztBQUNILE1BQU0sVUFBVSxRQUFRLENBQUMsSUFBMEQ7SUFDakYsc0NBQXNDO0lBQ3RDLE9BQU8sZ0JBQWdCLENBQUMsSUFBSSxDQUFDLENBQUM7QUFDaEMsQ0FBQyJ9

package/dist_ts/detection/detectors/http-detector-v2.d.ts

@@ -0,0 +1,33 @@
+/**
+ * HTTP Protocol Detector V2
+ *
+ * Simplified HTTP detection using the new architecture
+ */
+import type { IProtocolDetector } from '../models/interfaces.js';
+import type { IDetectionResult, IDetectionOptions } from '../models/detection-types.js';
+import type { IConnectionContext } from '../../protocols/common/types.js';
+import { DetectionFragmentManager } from '../utils/fragment-manager.js';
+/**
+ * Simplified HTTP detector
+ */
+export declare class HttpDetectorV2 implements IProtocolDetector {
+    private quickDetector;
+    private fragmentManager;
+    constructor(fragmentManager: DetectionFragmentManager);
+    /**
+     * Check if buffer can be handled by this detector
+     */
+    canHandle(buffer: Buffer): boolean;
+    /**
+     * Get minimum bytes needed for detection
+     */
+    getMinimumBytes(): number;
+    /**
+     * Detect HTTP protocol from buffer
+     */
+    detect(buffer: Buffer, options?: IDetectionOptions): IDetectionResult | null;
+    /**
+     * Handle fragmented detection
+     */
+    detectWithContext(buffer: Buffer, context: IConnectionContext, options?: IDetectionOptions): IDetectionResult | null;
+}

package/dist_ts/detection/detectors/http-detector-v2.js

@@ -0,0 +1,87 @@
+/**
+ * HTTP Protocol Detector V2
+ *
+ * Simplified HTTP detection using the new architecture
+ */
+import { QuickProtocolDetector } from './quick-detector.js';
+import { RoutingExtractor } from './routing-extractor.js';
+import { DetectionFragmentManager } from '../utils/fragment-manager.js';
+/**
+ * Simplified HTTP detector
+ */
+export class HttpDetectorV2 {
+    constructor(fragmentManager) {
+        this.quickDetector = new QuickProtocolDetector();
+        this.fragmentManager = fragmentManager;
+    }
+    /**
+     * Check if buffer can be handled by this detector
+     */
+    canHandle(buffer) {
+        const result = this.quickDetector.quickDetect(buffer);
+        return result.protocol === 'http' && result.confidence > 50;
+    }
+    /**
+     * Get minimum bytes needed for detection
+     */
+    getMinimumBytes() {
+        return 4; // "GET " minimum
+    }
+    /**
+     * Detect HTTP protocol from buffer
+     */
+    detect(buffer, options) {
+        // Quick detection first
+        const quickResult = this.quickDetector.quickDetect(buffer);
+        if (quickResult.protocol !== 'http' || quickResult.confidence < 50) {
+            return null;
+        }
+        // If we don't need full headers, we can return early
+        if (quickResult.confidence >= 95 && !options?.extractFullHeaders) {
+            return {
+                protocol: 'http',
+                connectionInfo: {
+                    protocol: 'http',
+                    method: quickResult.metadata?.method
+                },
+                isComplete: true
+            };
+        }
+        // Extract routing information if needed
+        const routing = RoutingExtractor.extract(buffer, 'http');
+        // Check if we have complete headers
+        const headersEnd = buffer.indexOf('\r\n\r\n');
+        const isComplete = headersEnd !== -1;
+        return {
+            protocol: 'http',
+            connectionInfo: {
+                protocol: 'http',
+                domain: routing?.domain,
+                path: routing?.path,
+                method: quickResult.metadata?.method
+            },
+            isComplete,
+            bytesNeeded: isComplete ? undefined : buffer.length + 512 // Need more for headers
+        };
+    }
+    /**
+     * Handle fragmented detection
+     */
+    detectWithContext(buffer, context, options) {
+        const handler = this.fragmentManager.getHandler('http');
+        const connectionId = DetectionFragmentManager.createConnectionId(context);
+        // Add fragment
+        const result = handler.addFragment(connectionId, buffer);
+        if (result.error) {
+            handler.complete(connectionId);
+            return null;
+        }
+        // Try detection on accumulated buffer
+        const detectResult = this.detect(result.buffer, options);
+        if (detectResult && detectResult.isComplete) {
+            handler.complete(connectionId);
+        }
+        return detectResult;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/detection/detectors/http-detector.d.ts

@@ -0,0 +1,33 @@
+/**
+ * HTTP Protocol Detector
+ *
+ * Simplified HTTP detection using the new architecture
+ */
+import type { IProtocolDetector } from '../models/interfaces.js';
+import type { IDetectionResult, IDetectionOptions } from '../models/detection-types.js';
+import type { IConnectionContext } from '../../protocols/common/types.js';
+import { DetectionFragmentManager } from '../utils/fragment-manager.js';
+/**
+ * Simplified HTTP detector
+ */
+export declare class HttpDetector implements IProtocolDetector {
+    private quickDetector;
+    private fragmentManager;
+    constructor(fragmentManager?: DetectionFragmentManager);
+    /**
+     * Check if buffer can be handled by this detector
+     */
+    canHandle(buffer: Buffer): boolean;
+    /**
+     * Get minimum bytes needed for detection
+     */
+    getMinimumBytes(): number;
+    /**
+     * Detect HTTP protocol from buffer
+     */
+    detect(buffer: Buffer, options?: IDetectionOptions): IDetectionResult | null;
+    /**
+     * Handle fragmented detection
+     */
+    detectWithContext(buffer: Buffer, context: IConnectionContext, options?: IDetectionOptions): IDetectionResult | null;
+}

package/dist_ts/detection/detectors/http-detector.js

@@ -0,0 +1,89 @@
+/**
+ * HTTP Protocol Detector
+ *
+ * Simplified HTTP detection using the new architecture
+ */
+import { QuickProtocolDetector } from './quick-detector.js';
+import { RoutingExtractor } from './routing-extractor.js';
+import { DetectionFragmentManager } from '../utils/fragment-manager.js';
+/**
+ * Simplified HTTP detector
+ */
+export class HttpDetector {
+    constructor(fragmentManager) {
+        this.quickDetector = new QuickProtocolDetector();
+        this.fragmentManager = fragmentManager || new DetectionFragmentManager();
+    }
+    /**
+     * Check if buffer can be handled by this detector
+     */
+    canHandle(buffer) {
+        const result = this.quickDetector.quickDetect(buffer);
+        return result.protocol === 'http' && result.confidence > 50;
+    }
+    /**
+     * Get minimum bytes needed for detection
+     */
+    getMinimumBytes() {
+        return 4; // "GET " minimum
+    }
+    /**
+     * Detect HTTP protocol from buffer
+     */
+    detect(buffer, options) {
+        // Quick detection first
+        const quickResult = this.quickDetector.quickDetect(buffer);
+        if (quickResult.protocol !== 'http' || quickResult.confidence < 50) {
+            return null;
+        }
+        // Extract routing information
+        const routing = RoutingExtractor.extract(buffer, 'http');
+        // If we don't need full headers, we can return early
+        if (quickResult.confidence >= 95 && !options?.extractFullHeaders) {
+            return {
+                protocol: 'http',
+                connectionInfo: {
+                    protocol: 'http',
+                    method: quickResult.metadata?.method,
+                    domain: routing?.domain,
+                    path: routing?.path
+                },
+                isComplete: true
+            };
+        }
+        // Check if we have complete headers
+        const headersEnd = buffer.indexOf('\r\n\r\n');
+        const isComplete = headersEnd !== -1;
+        return {
+            protocol: 'http',
+            connectionInfo: {
+                protocol: 'http',
+                domain: routing?.domain,
+                path: routing?.path,
+                method: quickResult.metadata?.method
+            },
+            isComplete,
+            bytesNeeded: isComplete ? undefined : buffer.length + 512 // Need more for headers
+        };
+    }
+    /**
+     * Handle fragmented detection
+     */
+    detectWithContext(buffer, context, options) {
+        const handler = this.fragmentManager.getHandler('http');
+        const connectionId = DetectionFragmentManager.createConnectionId(context);
+        // Add fragment
+        const result = handler.addFragment(connectionId, buffer);
+        if (result.error) {
+            handler.complete(connectionId);
+            return null;
+        }
+        // Try detection on accumulated buffer
+        const detectResult = this.detect(result.buffer, options);
+        if (detectResult && detectResult.isComplete) {
+            handler.complete(connectionId);
+        }
+        return detectResult;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/detection/detectors/quick-detector.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Quick Protocol Detector
+ *
+ * Lightweight protocol identification based on minimal bytes
+ * No parsing, just identification
+ */
+import type { IProtocolDetector, IProtocolDetectionResult } from '../../protocols/common/types.js';
+/**
+ * Quick protocol detector for fast identification
+ */
+export declare class QuickProtocolDetector implements IProtocolDetector {
+    /**
+     * Check if this detector can handle the data
+     */
+    canHandle(data: Buffer): boolean;
+    /**
+     * Perform quick detection based on first few bytes
+     */
+    quickDetect(data: Buffer): IProtocolDetectionResult;
+    /**
+     * Check if data looks like TLS
+     */
+    private checkTls;
+    /**
+     * Check if data looks like HTTP
+     */
+    private checkHttp;
+}