@push.rocks/smartproxy 21.0.0 → 21.1.0

package/dist_ts/protocols/tls/parser.js

@@ -0,0 +1,294 @@
+/**
+ * TLS Protocol Parser
+ * Generic TLS parsing utilities separated from implementation logic
+ */
+import { Buffer } from 'buffer';
+import { TlsRecordType, TlsHandshakeType, TlsExtensionType } from './constants.js';
+/**
+ * TLS protocol parser utilities
+ */
+export class TlsParser {
+    /**
+     * Checks if a buffer contains a TLS handshake record
+     */
+    static isTlsHandshake(buffer) {
+        return buffer.length > 0 && buffer[0] === TlsRecordType.HANDSHAKE;
+    }
+    /**
+     * Checks if a buffer contains a TLS ClientHello message
+     */
+    static isClientHello(buffer) {
+        // Minimum ClientHello size (TLS record header + handshake header)
+        if (buffer.length < 9) {
+            return false;
+        }
+        // Check record type (must be TLS_HANDSHAKE_RECORD_TYPE)
+        if (buffer[0] !== TlsRecordType.HANDSHAKE) {
+            return false;
+        }
+        // Check handshake type at byte 5 (must be CLIENT_HELLO)
+        return buffer[5] === TlsHandshakeType.CLIENT_HELLO;
+    }
+    /**
+     * Gets the record length from a TLS record header
+     */
+    static getTlsRecordLength(buffer) {
+        if (buffer.length < 5) {
+            return -1;
+        }
+        // Bytes 3-4 contain the record length (big-endian)
+        return (buffer[3] << 8) + buffer[4];
+    }
+    /**
+     * Parses a TLS ClientHello message and extracts all components
+     */
+    static parseClientHello(buffer) {
+        const result = {
+            isValid: false,
+            hasSessionId: false,
+            extensions: [],
+            hasSessionTicket: false,
+            hasPsk: false,
+            hasEarlyData: false
+        };
+        try {
+            // Check basic validity
+            if (buffer.length < 5) {
+                result.error = 'Buffer too small for TLS record header';
+                return result;
+            }
+            // Check record type (must be HANDSHAKE)
+            if (buffer[0] !== TlsRecordType.HANDSHAKE) {
+                result.error = `Not a TLS handshake record: ${buffer[0]}`;
+                return result;
+            }
+            // Get TLS version from record header
+            const majorVersion = buffer[1];
+            const minorVersion = buffer[2];
+            result.version = [majorVersion, minorVersion];
+            // Parse record length (bytes 3-4, big-endian)
+            const recordLength = (buffer[3] << 8) + buffer[4];
+            // Validate record length against buffer size
+            if (buffer.length < recordLength + 5) {
+                result.error = 'Buffer smaller than expected record length';
+                return result;
+            }
+            // Start of handshake message in the buffer
+            let pos = 5;
+            // Check handshake type (must be CLIENT_HELLO)
+            if (buffer[pos] !== TlsHandshakeType.CLIENT_HELLO) {
+                result.error = `Not a ClientHello message: ${buffer[pos]}`;
+                return result;
+            }
+            // Skip handshake type (1 byte)
+            pos += 1;
+            // Parse handshake length (3 bytes, big-endian)
+            const handshakeLength = (buffer[pos] << 16) + (buffer[pos + 1] << 8) + buffer[pos + 2];
+            // Skip handshake length (3 bytes)
+            pos += 3;
+            // Skip client version (2 bytes)
+            pos += 2;
+            // Extract client random (32 bytes)
+            if (pos + 32 > buffer.length) {
+                result.error = 'Buffer too small for client random';
+                return result;
+            }
+            result.random = buffer.slice(pos, pos + 32);
+            // Skip client random (32 bytes)
+            pos += 32;
+            // Parse session ID
+            if (pos + 1 > buffer.length) {
+                result.error = 'Buffer too small for session ID length';
+                return result;
+            }
+            const sessionIdLength = buffer[pos];
+            pos += 1;
+            result.hasSessionId = sessionIdLength > 0;
+            if (sessionIdLength > 0) {
+                if (pos + sessionIdLength > buffer.length) {
+                    result.error = 'Buffer too small for session ID';
+                    return result;
+                }
+                result.sessionId = buffer.slice(pos, pos + sessionIdLength);
+            }
+            // Skip session ID
+            pos += sessionIdLength;
+            // Check if we have enough bytes left for cipher suites
+            if (pos + 2 > buffer.length) {
+                result.error = 'Buffer too small for cipher suites length';
+                return result;
+            }
+            // Parse cipher suites length (2 bytes, big-endian)
+            const cipherSuitesLength = (buffer[pos] << 8) + buffer[pos + 1];
+            pos += 2;
+            // Extract cipher suites
+            if (pos + cipherSuitesLength > buffer.length) {
+                result.error = 'Buffer too small for cipher suites';
+                return result;
+            }
+            result.cipherSuites = buffer.slice(pos, pos + cipherSuitesLength);
+            // Skip cipher suites
+            pos += cipherSuitesLength;
+            // Check if we have enough bytes left for compression methods
+            if (pos + 1 > buffer.length) {
+                result.error = 'Buffer too small for compression methods length';
+                return result;
+            }
+            // Parse compression methods length (1 byte)
+            const compressionMethodsLength = buffer[pos];
+            pos += 1;
+            // Extract compression methods
+            if (pos + compressionMethodsLength > buffer.length) {
+                result.error = 'Buffer too small for compression methods';
+                return result;
+            }
+            result.compressionMethods = buffer.slice(pos, pos + compressionMethodsLength);
+            // Skip compression methods
+            pos += compressionMethodsLength;
+            // Check if we have enough bytes for extensions length
+            if (pos + 2 > buffer.length) {
+                // No extensions present - this is valid for older TLS versions
+                result.isValid = true;
+                return result;
+            }
+            // Parse extensions length (2 bytes, big-endian)
+            const extensionsLength = (buffer[pos] << 8) + buffer[pos + 1];
+            pos += 2;
+            // Extensions end position
+            const extensionsEnd = pos + extensionsLength;
+            // Check if extensions length is valid
+            if (extensionsEnd > buffer.length) {
+                result.error = 'Extensions length exceeds buffer size';
+                return result;
+            }
+            // Iterate through extensions
+            const serverNames = [];
+            while (pos + 4 <= extensionsEnd) {
+                // Parse extension type (2 bytes, big-endian)
+                const extensionType = (buffer[pos] << 8) + buffer[pos + 1];
+                pos += 2;
+                // Parse extension length (2 bytes, big-endian)
+                const extensionLength = (buffer[pos] << 8) + buffer[pos + 1];
+                pos += 2;
+                // Extract extension data
+                if (pos + extensionLength > extensionsEnd) {
+                    result.error = `Extension ${extensionType} data exceeds bounds`;
+                    return result;
+                }
+                const extensionData = buffer.slice(pos, pos + extensionLength);
+                // Record all extensions
+                result.extensions.push({
+                    type: extensionType,
+                    data: extensionData
+                });
+                // Track specific extension types
+                if (extensionType === TlsExtensionType.SERVER_NAME) {
+                    // Server Name Indication (SNI)
+                    const sniNames = this.parseServerNameExtension(extensionData);
+                    serverNames.push(...sniNames);
+                }
+                else if (extensionType === TlsExtensionType.SESSION_TICKET) {
+                    // Session ticket
+                    result.hasSessionTicket = true;
+                }
+                else if (extensionType === TlsExtensionType.PRE_SHARED_KEY) {
+                    // TLS 1.3 PSK
+                    result.hasPsk = true;
+                }
+                else if (extensionType === TlsExtensionType.EARLY_DATA) {
+                    // TLS 1.3 Early Data (0-RTT)
+                    result.hasEarlyData = true;
+                }
+                // Move to next extension
+                pos += extensionLength;
+            }
+            // Store any server names found
+            if (serverNames.length > 0) {
+                result.serverNameList = serverNames;
+            }
+            // Mark as valid if we get here
+            result.isValid = true;
+            return result;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            result.error = errorMessage;
+            return result;
+        }
+    }
+    /**
+     * Parses the server name extension data and extracts hostnames
+     */
+    static parseServerNameExtension(data) {
+        const serverNames = [];
+        try {
+            // Need at least 2 bytes for server name list length
+            if (data.length < 2) {
+                return serverNames;
+            }
+            // Parse server name list length (2 bytes)
+            const listLength = (data[0] << 8) + data[1];
+            // Skip to first name entry
+            let pos = 2;
+            // End of list
+            const listEnd = pos + listLength;
+            // Validate length
+            if (listEnd > data.length) {
+                return serverNames;
+            }
+            // Process all name entries
+            while (pos + 3 <= listEnd) {
+                // Name type (1 byte)
+                const nameType = data[pos];
+                pos += 1;
+                // For hostname, type must be 0
+                if (nameType !== 0) {
+                    // Skip this entry
+                    if (pos + 2 <= listEnd) {
+                        const nameLength = (data[pos] << 8) + data[pos + 1];
+                        pos += 2 + nameLength;
+                        continue;
+                    }
+                    else {
+                        return serverNames;
+                    }
+                }
+                // Parse hostname length (2 bytes)
+                if (pos + 2 > listEnd) {
+                    return serverNames;
+                }
+                const nameLength = (data[pos] << 8) + data[pos + 1];
+                pos += 2;
+                // Extract hostname
+                if (pos + nameLength > listEnd) {
+                    return serverNames;
+                }
+                // Extract the hostname as UTF-8
+                try {
+                    const hostname = data.slice(pos, pos + nameLength).toString('utf8');
+                    serverNames.push(hostname);
+                }
+                catch (err) {
+                    // Ignore invalid hostnames
+                }
+                // Move to next entry
+                pos += nameLength;
+            }
+            return serverNames;
+        }
+        catch (error) {
+            return serverNames;
+        }
+    }
+    /**
+     * Extract SNI (Server Name Indication) from ClientHello
+     */
+    static extractSNI(buffer) {
+        const parseResult = this.parseClientHello(buffer);
+        if (!parseResult.isValid || !parseResult.serverNameList || parseResult.serverNameList.length === 0) {
+            return null;
+        }
+        return parseResult.serverNameList[0];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"parser.js","sourceRoot":"","sources":["../../../ts/protocols/tls/parser.ts"],"names":[],"mappings":"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"}

package/dist_ts/protocols/tls/sni/client-hello-parser.d.ts

@@ -0,0 +1,100 @@
+import { Buffer } from 'buffer';
+/**
+ * Interface for logging functions used by the parser
+ */
+export type LoggerFunction = (message: string) => void;
+/**
+ * Result of a session resumption check
+ */
+export interface SessionResumptionResult {
+    isResumption: boolean;
+    hasSNI: boolean;
+}
+/**
+ * Information about parsed TLS extensions
+ */
+export interface ExtensionInfo {
+    type: number;
+    length: number;
+    data: Buffer;
+}
+/**
+ * Result of a ClientHello parse operation
+ */
+export interface ClientHelloParseResult {
+    isValid: boolean;
+    version?: [number, number];
+    random?: Buffer;
+    sessionId?: Buffer;
+    hasSessionId: boolean;
+    cipherSuites?: Buffer;
+    compressionMethods?: Buffer;
+    extensions: ExtensionInfo[];
+    serverNameList?: string[];
+    hasSessionTicket: boolean;
+    hasPsk: boolean;
+    hasEarlyData: boolean;
+    error?: string;
+}
+/**
+ * Fragment tracking information
+ */
+export interface FragmentTrackingInfo {
+    buffer: Buffer;
+    timestamp: number;
+    connectionId: string;
+}
+/**
+ * Class for parsing TLS ClientHello messages
+ */
+export declare class ClientHelloParser {
+    private static fragmentedBuffers;
+    private static fragmentTimeout;
+    /**
+     * Clean up expired fragments
+     */
+    private static cleanupExpiredFragments;
+    /**
+     * Handles potential fragmented ClientHello messages by buffering and reassembling
+     * TLS record fragments that might span multiple TCP packets.
+     *
+     * @param buffer The current buffer fragment
+     * @param connectionId Unique identifier for the connection
+     * @param logger Optional logging function
+     * @returns A complete buffer if reassembly is successful, or undefined if more fragments are needed
+     */
+    static handleFragmentedClientHello(buffer: Buffer, connectionId: string, logger?: LoggerFunction): Buffer | undefined;
+    /**
+     * Parses a TLS ClientHello message and extracts all components
+     *
+     * @param buffer The buffer containing the ClientHello message
+     * @param logger Optional logging function
+     * @returns Parsed ClientHello or undefined if parsing failed
+     */
+    static parseClientHello(buffer: Buffer, logger?: LoggerFunction): ClientHelloParseResult;
+    /**
+     * Parses the server name extension data and extracts hostnames
+     *
+     * @param data Extension data buffer
+     * @param serverNames Array to populate with found server names
+     * @param logger Optional logging function
+     * @returns true if parsing succeeded
+     */
+    private static parseServerNameExtension;
+    /**
+     * Determines if a ClientHello contains session resumption indicators
+     *
+     * @param buffer The ClientHello buffer
+     * @param logger Optional logging function
+     * @returns Session resumption result
+     */
+    static hasSessionResumption(buffer: Buffer, logger?: LoggerFunction): SessionResumptionResult;
+    /**
+     * Checks if a ClientHello appears to be from a tab reactivation
+     *
+     * @param buffer The ClientHello buffer
+     * @param logger Optional logging function
+     * @returns true if it appears to be a tab reactivation
+     */
+    static isTabReactivationHandshake(buffer: Buffer, logger?: LoggerFunction): boolean;
+}