@push.rocks/smartproxy 20.0.1 → 21.1.0

package/dist_ts/detection/models/detection-types.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Type definitions for protocol detection
+ */
+/**
+ * Supported protocol types that can be detected
+ */
+export type TProtocolType = 'tls' | 'http' | 'unknown';
+/**
+ * HTTP method types
+ */
+export type THttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS' | 'CONNECT' | 'TRACE';
+/**
+ * TLS version identifiers
+ */
+export type TTlsVersion = 'SSLv3' | 'TLSv1.0' | 'TLSv1.1' | 'TLSv1.2' | 'TLSv1.3';
+/**
+ * Connection information extracted from protocol detection
+ */
+export interface IConnectionInfo {
+    /**
+     * The detected protocol type
+     */
+    protocol: TProtocolType;
+    /**
+     * Domain/hostname extracted from the connection
+     * - For TLS: from SNI extension
+     * - For HTTP: from Host header
+     */
+    domain?: string;
+    /**
+     * HTTP-specific fields
+     */
+    method?: THttpMethod;
+    path?: string;
+    httpVersion?: string;
+    headers?: Record<string, string>;
+    /**
+     * TLS-specific fields
+     */
+    tlsVersion?: TTlsVersion;
+    sni?: string;
+    alpn?: string[];
+    cipherSuites?: number[];
+}
+/**
+ * Result of protocol detection
+ */
+export interface IDetectionResult {
+    /**
+     * The detected protocol type
+     */
+    protocol: TProtocolType;
+    /**
+     * Extracted connection information
+     */
+    connectionInfo: IConnectionInfo;
+    /**
+     * Any remaining buffer data after detection headers
+     * This can be used to continue processing the stream
+     */
+    remainingBuffer?: Buffer;
+    /**
+     * Whether the detection is complete or needs more data
+     */
+    isComplete: boolean;
+    /**
+     * Minimum bytes needed for complete detection (if incomplete)
+     */
+    bytesNeeded?: number;
+}
+/**
+ * Options for protocol detection
+ */
+export interface IDetectionOptions {
+    /**
+     * Maximum bytes to buffer for detection (default: 8192)
+     */
+    maxBufferSize?: number;
+    /**
+     * Timeout for detection in milliseconds (default: 5000)
+     */
+    timeout?: number;
+    /**
+     * Whether to extract full headers or just essential info
+     */
+    extractFullHeaders?: boolean;
+}

package/dist_ts/detection/models/detection-types.js

@@ -0,0 +1,5 @@
+/**
+ * Type definitions for protocol detection
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGV0ZWN0aW9uLXR5cGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vdHMvZGV0ZWN0aW9uL21vZGVscy9kZXRlY3Rpb24tdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUcifQ==

package/dist_ts/detection/models/interfaces.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Interface definitions for protocol detection components
+ */
+import type { IDetectionResult, IDetectionOptions } from './detection-types.js';
+/**
+ * Interface for protocol detectors
+ */
+export interface IProtocolDetector {
+    /**
+     * Detect protocol from buffer data
+     * @param buffer The buffer to analyze
+     * @param options Detection options
+     * @returns Detection result or null if protocol cannot be determined
+     */
+    detect(buffer: Buffer, options?: IDetectionOptions): IDetectionResult | null;
+    /**
+     * Check if buffer potentially contains this protocol
+     * @param buffer The buffer to check
+     * @returns True if buffer might contain this protocol
+     */
+    canHandle(buffer: Buffer): boolean;
+    /**
+     * Get the minimum bytes needed for detection
+     */
+    getMinimumBytes(): number;
+}
+/**
+ * Interface for connection tracking during fragmented detection
+ */
+export interface IConnectionTracker {
+    /**
+     * Connection identifier
+     */
+    id: string;
+    /**
+     * Accumulated buffer data
+     */
+    buffer: Buffer;
+    /**
+     * Timestamp of first data
+     */
+    startTime: number;
+    /**
+     * Current detection state
+     */
+    state: 'detecting' | 'complete' | 'failed';
+    /**
+     * Partial detection result (if any)
+     */
+    partialResult?: Partial<IDetectionResult>;
+}
+/**
+ * Interface for buffer accumulator (handles fragmented data)
+ */
+export interface IBufferAccumulator {
+    /**
+     * Add data to accumulator
+     */
+    append(data: Buffer): void;
+    /**
+     * Get accumulated buffer
+     */
+    getBuffer(): Buffer;
+    /**
+     * Get buffer length
+     */
+    length(): number;
+    /**
+     * Clear accumulated data
+     */
+    clear(): void;
+    /**
+     * Check if accumulator has enough data
+     */
+    hasMinimumBytes(minBytes: number): boolean;
+}
+/**
+ * Detection events
+ */
+export interface IDetectionEvents {
+    /**
+     * Emitted when protocol is successfully detected
+     */
+    detected: (result: IDetectionResult) => void;
+    /**
+     * Emitted when detection fails
+     */
+    failed: (error: Error) => void;
+    /**
+     * Emitted when detection times out
+     */
+    timeout: () => void;
+    /**
+     * Emitted when more data is needed
+     */
+    needMoreData: (bytesNeeded: number) => void;
+}

package/dist_ts/detection/models/interfaces.js

@@ -0,0 +1,5 @@
+/**
+ * Interface definitions for protocol detection components
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3RzL2RldGVjdGlvbi9tb2RlbHMvaW50ZXJmYWNlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRyJ9

package/dist_ts/detection/protocol-detector-v2.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Protocol Detector V2
+ *
+ * Simplified protocol detection using the new architecture
+ */
+import type { IDetectionResult, IDetectionOptions } from './models/detection-types.js';
+import type { IConnectionContext } from '../protocols/common/types.js';
+/**
+ * Main protocol detector class - V2
+ */
+export declare class ProtocolDetectorV2 {
+    private fragmentManager;
+    private tlsDetector;
+    private httpDetector;
+    constructor();
+    /**
+     * Detect protocol from buffer data
+     */
+    detect(buffer: Buffer, options?: IDetectionOptions): Promise<IDetectionResult>;
+    /**
+     * Detect protocol with connection context for fragmented data
+     */
+    detectWithContext(buffer: Buffer, context: IConnectionContext, options?: IDetectionOptions): Promise<IDetectionResult>;
+    /**
+     * Clean up resources
+     */
+    cleanup(): void;
+    /**
+     * Destroy detector instance
+     */
+    destroy(): void;
+    /**
+     * Extract domain from connection info
+     */
+    static extractDomain(connectionInfo: any): string | undefined;
+    /**
+     * Create a connection context from parameters
+     */
+    static createConnectionContext(params: {
+        sourceIp?: string;
+        sourcePort?: number;
+        destIp?: string;
+        destPort?: number;
+        socketId?: string;
+    }): IConnectionContext;
+}

package/dist_ts/detection/protocol-detector-v2.js

@@ -0,0 +1,116 @@
+/**
+ * Protocol Detector V2
+ *
+ * Simplified protocol detection using the new architecture
+ */
+import { TlsDetectorV2 } from './detectors/tls-detector-v2.js';
+import { HttpDetectorV2 } from './detectors/http-detector-v2.js';
+import { DetectionFragmentManager } from './utils/fragment-manager.js';
+/**
+ * Main protocol detector class - V2
+ */
+export class ProtocolDetectorV2 {
+    constructor() {
+        this.fragmentManager = new DetectionFragmentManager();
+        this.tlsDetector = new TlsDetectorV2(this.fragmentManager);
+        this.httpDetector = new HttpDetectorV2(this.fragmentManager);
+    }
+    /**
+     * Detect protocol from buffer data
+     */
+    async detect(buffer, options) {
+        // Quick sanity check
+        if (!buffer || buffer.length === 0) {
+            return {
+                protocol: 'unknown',
+                connectionInfo: { protocol: 'unknown' },
+                isComplete: true
+            };
+        }
+        // Try TLS detection first (more specific)
+        if (this.tlsDetector.canHandle(buffer)) {
+            const tlsResult = this.tlsDetector.detect(buffer, options);
+            if (tlsResult) {
+                return tlsResult;
+            }
+        }
+        // Try HTTP detection
+        if (this.httpDetector.canHandle(buffer)) {
+            const httpResult = this.httpDetector.detect(buffer, options);
+            if (httpResult) {
+                return httpResult;
+            }
+        }
+        // Neither TLS nor HTTP
+        return {
+            protocol: 'unknown',
+            connectionInfo: { protocol: 'unknown' },
+            isComplete: true
+        };
+    }
+    /**
+     * Detect protocol with connection context for fragmented data
+     */
+    async detectWithContext(buffer, context, options) {
+        // Quick sanity check
+        if (!buffer || buffer.length === 0) {
+            return {
+                protocol: 'unknown',
+                connectionInfo: { protocol: 'unknown' },
+                isComplete: true
+            };
+        }
+        // First peek to determine protocol type
+        if (this.tlsDetector.canHandle(buffer)) {
+            const result = this.tlsDetector.detectWithContext(buffer, context, options);
+            if (result) {
+                return result;
+            }
+        }
+        if (this.httpDetector.canHandle(buffer)) {
+            const result = this.httpDetector.detectWithContext(buffer, context, options);
+            if (result) {
+                return result;
+            }
+        }
+        // Can't determine protocol
+        return {
+            protocol: 'unknown',
+            connectionInfo: { protocol: 'unknown' },
+            isComplete: false,
+            bytesNeeded: Math.max(this.tlsDetector.getMinimumBytes(), this.httpDetector.getMinimumBytes())
+        };
+    }
+    /**
+     * Clean up resources
+     */
+    cleanup() {
+        this.fragmentManager.cleanup();
+    }
+    /**
+     * Destroy detector instance
+     */
+    destroy() {
+        this.fragmentManager.destroy();
+    }
+    /**
+     * Extract domain from connection info
+     */
+    static extractDomain(connectionInfo) {
+        return connectionInfo.domain || connectionInfo.sni || connectionInfo.host;
+    }
+    /**
+     * Create a connection context from parameters
+     */
+    static createConnectionContext(params) {
+        return {
+            id: params.socketId,
+            sourceIp: params.sourceIp || 'unknown',
+            sourcePort: params.sourcePort || 0,
+            destIp: params.destIp || 'unknown',
+            destPort: params.destPort || 0,
+            timestamp: Date.now()
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/detection/protocol-detector.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Protocol Detector
+ *
+ * Simplified protocol detection using the new architecture
+ */
+import type { IDetectionResult, IDetectionOptions } from './models/detection-types.js';
+import type { IConnectionContext } from '../protocols/common/types.js';
+/**
+ * Main protocol detector class
+ */
+export declare class ProtocolDetector {
+    private static instance;
+    private fragmentManager;
+    private tlsDetector;
+    private httpDetector;
+    constructor();
+    private static getInstance;
+    /**
+     * Detect protocol from buffer data
+     */
+    static detect(buffer: Buffer, options?: IDetectionOptions): Promise<IDetectionResult>;
+    private detectInstance;
+    /**
+     * Detect protocol with connection tracking for fragmented data
+     * @deprecated Use detectWithContext instead
+     */
+    static detectWithConnectionTracking(buffer: Buffer, connectionId: string, options?: IDetectionOptions): Promise<IDetectionResult>;
+    /**
+     * Detect protocol with connection context for fragmented data
+     */
+    static detectWithContext(buffer: Buffer, context: IConnectionContext, options?: IDetectionOptions): Promise<IDetectionResult>;
+    private detectWithContextInstance;
+    /**
+     * Clean up resources
+     */
+    static cleanup(): void;
+    private cleanupInstance;
+    /**
+     * Destroy detector instance
+     */
+    static destroy(): void;
+    private destroyInstance;
+    /**
+     * Clean up old connection tracking entries
+     *
+     * @param maxAge Maximum age in milliseconds (default: 30 seconds)
+     */
+    static cleanupConnections(maxAge?: number): void;
+    /**
+     * Extract domain from connection info
+     */
+    static extractDomain(connectionInfo: any): string | undefined;
+    /**
+     * Create a connection ID from connection parameters
+     * @deprecated Use createConnectionContext instead
+     */
+    static createConnectionId(params: {
+        sourceIp?: string;
+        sourcePort?: number;
+        destIp?: string;
+        destPort?: number;
+        socketId?: string;
+    }): string;
+    /**
+     * Create a connection context from parameters
+     */
+    static createConnectionContext(params: {
+        sourceIp?: string;
+        sourcePort?: number;
+        destIp?: string;
+        destPort?: number;
+        socketId?: string;
+    }): IConnectionContext;
+}

package/dist_ts/detection/protocol-detector.js

@@ -0,0 +1,173 @@
+/**
+ * Protocol Detector
+ *
+ * Simplified protocol detection using the new architecture
+ */
+import { TlsDetector } from './detectors/tls-detector.js';
+import { HttpDetector } from './detectors/http-detector.js';
+import { DetectionFragmentManager } from './utils/fragment-manager.js';
+/**
+ * Main protocol detector class
+ */
+export class ProtocolDetector {
+    constructor() {
+        this.fragmentManager = new DetectionFragmentManager();
+        this.tlsDetector = new TlsDetector(this.fragmentManager);
+        this.httpDetector = new HttpDetector(this.fragmentManager);
+    }
+    static getInstance() {
+        if (!this.instance) {
+            this.instance = new ProtocolDetector();
+        }
+        return this.instance;
+    }
+    /**
+     * Detect protocol from buffer data
+     */
+    static async detect(buffer, options) {
+        return this.getInstance().detectInstance(buffer, options);
+    }
+    async detectInstance(buffer, options) {
+        // Quick sanity check
+        if (!buffer || buffer.length === 0) {
+            return {
+                protocol: 'unknown',
+                connectionInfo: { protocol: 'unknown' },
+                isComplete: true
+            };
+        }
+        // Try TLS detection first (more specific)
+        if (this.tlsDetector.canHandle(buffer)) {
+            const tlsResult = this.tlsDetector.detect(buffer, options);
+            if (tlsResult) {
+                return tlsResult;
+            }
+        }
+        // Try HTTP detection
+        if (this.httpDetector.canHandle(buffer)) {
+            const httpResult = this.httpDetector.detect(buffer, options);
+            if (httpResult) {
+                return httpResult;
+            }
+        }
+        // Neither TLS nor HTTP
+        return {
+            protocol: 'unknown',
+            connectionInfo: { protocol: 'unknown' },
+            isComplete: true
+        };
+    }
+    /**
+     * Detect protocol with connection tracking for fragmented data
+     * @deprecated Use detectWithContext instead
+     */
+    static async detectWithConnectionTracking(buffer, connectionId, options) {
+        // Convert connection ID to context
+        const context = {
+            id: connectionId,
+            sourceIp: 'unknown',
+            sourcePort: 0,
+            destIp: 'unknown',
+            destPort: 0,
+            timestamp: Date.now()
+        };
+        return this.getInstance().detectWithContextInstance(buffer, context, options);
+    }
+    /**
+     * Detect protocol with connection context for fragmented data
+     */
+    static async detectWithContext(buffer, context, options) {
+        return this.getInstance().detectWithContextInstance(buffer, context, options);
+    }
+    async detectWithContextInstance(buffer, context, options) {
+        // Quick sanity check
+        if (!buffer || buffer.length === 0) {
+            return {
+                protocol: 'unknown',
+                connectionInfo: { protocol: 'unknown' },
+                isComplete: true
+            };
+        }
+        // First peek to determine protocol type
+        if (this.tlsDetector.canHandle(buffer)) {
+            const result = this.tlsDetector.detectWithContext(buffer, context, options);
+            if (result) {
+                return result;
+            }
+        }
+        if (this.httpDetector.canHandle(buffer)) {
+            const result = this.httpDetector.detectWithContext(buffer, context, options);
+            if (result) {
+                return result;
+            }
+        }
+        // Can't determine protocol
+        return {
+            protocol: 'unknown',
+            connectionInfo: { protocol: 'unknown' },
+            isComplete: false,
+            bytesNeeded: Math.max(this.tlsDetector.getMinimumBytes(), this.httpDetector.getMinimumBytes())
+        };
+    }
+    /**
+     * Clean up resources
+     */
+    static cleanup() {
+        this.getInstance().cleanupInstance();
+    }
+    cleanupInstance() {
+        this.fragmentManager.cleanup();
+    }
+    /**
+     * Destroy detector instance
+     */
+    static destroy() {
+        this.getInstance().destroyInstance();
+        this.instance = null;
+    }
+    destroyInstance() {
+        this.fragmentManager.destroy();
+    }
+    /**
+     * Clean up old connection tracking entries
+     *
+     * @param maxAge Maximum age in milliseconds (default: 30 seconds)
+     */
+    static cleanupConnections(maxAge = 30000) {
+        // Cleanup is now handled internally by the fragment manager
+        this.getInstance().fragmentManager.cleanup();
+    }
+    /**
+     * Extract domain from connection info
+     */
+    static extractDomain(connectionInfo) {
+        return connectionInfo.domain || connectionInfo.sni || connectionInfo.host;
+    }
+    /**
+     * Create a connection ID from connection parameters
+     * @deprecated Use createConnectionContext instead
+     */
+    static createConnectionId(params) {
+        // If socketId is provided, use it
+        if (params.socketId) {
+            return params.socketId;
+        }
+        // Otherwise create from connection tuple
+        const { sourceIp = 'unknown', sourcePort = 0, destIp = 'unknown', destPort = 0 } = params;
+        return `${sourceIp}:${sourcePort}-${destIp}:${destPort}`;
+    }
+    /**
+     * Create a connection context from parameters
+     */
+    static createConnectionContext(params) {
+        return {
+            id: params.socketId,
+            sourceIp: params.sourceIp || 'unknown',
+            sourcePort: params.sourcePort || 0,
+            destIp: params.destIp || 'unknown',
+            destPort: params.destPort || 0,
+            timestamp: Date.now()
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/detection/utils/buffer-utils.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Buffer manipulation utilities for protocol detection
+ */
+/**
+ * BufferAccumulator class for handling fragmented data
+ */
+export declare class BufferAccumulator {
+    private chunks;
+    private totalLength;
+    /**
+     * Append data to the accumulator
+     */
+    append(data: Buffer): void;
+    /**
+     * Get the accumulated buffer
+     */
+    getBuffer(): Buffer;
+    /**
+     * Get current buffer length
+     */
+    length(): number;
+    /**
+     * Clear all accumulated data
+     */
+    clear(): void;
+    /**
+     * Check if accumulator has minimum bytes
+     */
+    hasMinimumBytes(minBytes: number): boolean;
+}
+/**
+ * Read a big-endian 16-bit integer from buffer
+ */
+export declare function readUInt16BE(buffer: Buffer, offset: number): number;
+/**
+ * Read a big-endian 24-bit integer from buffer
+ */
+export declare function readUInt24BE(buffer: Buffer, offset: number): number;
+/**
+ * Find a byte sequence in a buffer
+ */
+export declare function findSequence(buffer: Buffer, sequence: Buffer, startOffset?: number): number;
+/**
+ * Extract a line from buffer (up to CRLF or LF)
+ */
+export declare function extractLine(buffer: Buffer, startOffset?: number): {
+    line: string;
+    nextOffset: number;
+} | null;
+/**
+ * Check if buffer starts with a string (case-insensitive)
+ */
+export declare function startsWithString(buffer: Buffer, str: string, offset?: number): boolean;
+/**
+ * Safe buffer slice that doesn't throw on out-of-bounds
+ */
+export declare function safeSlice(buffer: Buffer, start: number, end?: number): Buffer;
+/**
+ * Check if buffer contains printable ASCII
+ */
+export declare function isPrintableAscii(buffer: Buffer, length?: number): boolean;