@push.rocks/smartproxy 20.0.1 → 21.1.0

package/dist_ts/protocols/tls/sni/client-hello-parser.js

@@ -0,0 +1,463 @@
+import { Buffer } from 'buffer';
+import { TlsRecordType, TlsHandshakeType, TlsExtensionType, TlsUtils } from '../utils/tls-utils.js';
+/**
+ * Class for parsing TLS ClientHello messages
+ */
+export class ClientHelloParser {
+    // Buffer for handling fragmented ClientHello messages
+    static { this.fragmentedBuffers = new Map(); }
+    static { this.fragmentTimeout = 1000; } // ms to wait for fragments before cleanup
+    /**
+     * Clean up expired fragments
+     */
+    static cleanupExpiredFragments() {
+        const now = Date.now();
+        for (const [connectionId, info] of this.fragmentedBuffers.entries()) {
+            if (now - info.timestamp > this.fragmentTimeout) {
+                this.fragmentedBuffers.delete(connectionId);
+            }
+        }
+    }
+    /**
+     * 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, connectionId, logger) {
+        const log = logger || (() => { });
+        // Periodically clean up expired fragments
+        this.cleanupExpiredFragments();
+        // Check if we've seen this connection before
+        if (!this.fragmentedBuffers.has(connectionId)) {
+            // New connection, start with this buffer
+            this.fragmentedBuffers.set(connectionId, {
+                buffer,
+                timestamp: Date.now(),
+                connectionId
+            });
+            // Evaluate if this buffer already contains a complete ClientHello
+            try {
+                if (buffer.length >= 5) {
+                    // Get the record length from TLS header
+                    const recordLength = (buffer[3] << 8) + buffer[4] + 5; // +5 for the TLS record header itself
+                    log(`Initial buffer size: ${buffer.length}, expected record length: ${recordLength}`);
+                    // Check if this buffer already contains a complete TLS record
+                    if (buffer.length >= recordLength) {
+                        log(`Initial buffer contains complete ClientHello, length: ${buffer.length}`);
+                        return buffer;
+                    }
+                }
+                else {
+                    log(`Initial buffer too small (${buffer.length} bytes), needs at least 5 bytes for TLS header`);
+                }
+            }
+            catch (e) {
+                log(`Error checking initial buffer completeness: ${e}`);
+            }
+            log(`Started buffering connection ${connectionId}, initial size: ${buffer.length}`);
+            return undefined; // Need more fragments
+        }
+        else {
+            // Existing connection, append this buffer
+            const existingInfo = this.fragmentedBuffers.get(connectionId);
+            const newBuffer = Buffer.concat([existingInfo.buffer, buffer]);
+            // Update the buffer and timestamp
+            this.fragmentedBuffers.set(connectionId, {
+                ...existingInfo,
+                buffer: newBuffer,
+                timestamp: Date.now()
+            });
+            log(`Appended to buffer for ${connectionId}, new size: ${newBuffer.length}`);
+            // Check if we now have a complete ClientHello
+            try {
+                if (newBuffer.length >= 5) {
+                    // Get the record length from TLS header
+                    const recordLength = (newBuffer[3] << 8) + newBuffer[4] + 5; // +5 for the TLS record header itself
+                    log(`Reassembled buffer size: ${newBuffer.length}, expected record length: ${recordLength}`);
+                    // Check if we have a complete TLS record now
+                    if (newBuffer.length >= recordLength) {
+                        log(`Assembled complete ClientHello, length: ${newBuffer.length}, needed: ${recordLength}`);
+                        // Extract the complete TLS record (might be followed by more data)
+                        const completeRecord = newBuffer.slice(0, recordLength);
+                        // Check if this record is indeed a ClientHello (type 1) at position 5
+                        if (completeRecord.length > 5 &&
+                            completeRecord[5] === TlsHandshakeType.CLIENT_HELLO) {
+                            log(`Verified record is a ClientHello handshake message`);
+                            // Complete message received, remove from tracking
+                            this.fragmentedBuffers.delete(connectionId);
+                            return completeRecord;
+                        }
+                        else {
+                            log(`Record is complete but not a ClientHello handshake, continuing to buffer`);
+                            // This might be another TLS record type preceding the ClientHello
+                            // Try checking for a ClientHello starting at the end of this record
+                            if (newBuffer.length > recordLength + 5) {
+                                const nextRecordType = newBuffer[recordLength];
+                                log(`Next record type: ${nextRecordType} (looking for ${TlsRecordType.HANDSHAKE})`);
+                                if (nextRecordType === TlsRecordType.HANDSHAKE) {
+                                    const handshakeType = newBuffer[recordLength + 5];
+                                    log(`Next handshake type: ${handshakeType} (looking for ${TlsHandshakeType.CLIENT_HELLO})`);
+                                    if (handshakeType === TlsHandshakeType.CLIENT_HELLO) {
+                                        // Found a ClientHello in the next record, return the entire buffer
+                                        log(`Found ClientHello in subsequent record, returning full buffer`);
+                                        this.fragmentedBuffers.delete(connectionId);
+                                        return newBuffer;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            catch (e) {
+                log(`Error checking reassembled buffer completeness: ${e}`);
+            }
+            return undefined; // Still need more fragments
+        }
+    }
+    /**
+     * 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, logger) {
+        const log = logger || (() => { });
+        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];
+            log(`TLS record version: ${majorVersion}.${minorVersion}`);
+            // Parse record length (bytes 3-4, big-endian)
+            const recordLength = (buffer[3] << 8) + buffer[4];
+            log(`Record length: ${recordLength}`);
+            // 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];
+            log(`Handshake length: ${handshakeLength}`);
+            // Skip handshake length (3 bytes)
+            pos += 3;
+            // Check client version (2 bytes)
+            const clientMajorVersion = buffer[pos];
+            const clientMinorVersion = buffer[pos + 1];
+            log(`Client version: ${clientMajorVersion}.${clientMinorVersion}`);
+            // 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);
+            log(`Client random: ${result.random.toString('hex')}`);
+            // 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];
+            log(`Session ID length: ${sessionIdLength}`);
+            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);
+                log(`Session ID: ${result.sessionId.toString('hex')}`);
+            }
+            // 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];
+            log(`Cipher suites length: ${cipherSuitesLength}`);
+            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];
+            log(`Compression methods length: ${compressionMethodsLength}`);
+            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];
+            log(`Extensions length: ${extensionsLength}`);
+            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];
+                log(`Extension type: 0x${extensionType.toString(16).padStart(4, '0')}`);
+                pos += 2;
+                // Parse extension length (2 bytes, big-endian)
+                const extensionLength = (buffer[pos] << 8) + buffer[pos + 1];
+                log(`Extension length: ${extensionLength}`);
+                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,
+                    length: extensionLength,
+                    data: extensionData
+                });
+                // Track specific extension types
+                if (extensionType === TlsExtensionType.SERVER_NAME) {
+                    // Server Name Indication (SNI)
+                    this.parseServerNameExtension(extensionData, serverNames, logger);
+                }
+                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);
+            log(`Error parsing ClientHello: ${errorMessage}`);
+            result.error = errorMessage;
+            return result;
+        }
+    }
+    /**
+     * 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
+     */
+    static parseServerNameExtension(data, serverNames, logger) {
+        const log = logger || (() => { });
+        try {
+            // Need at least 2 bytes for server name list length
+            if (data.length < 2) {
+                log('SNI extension too small for server name list length');
+                return false;
+            }
+            // 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) {
+                log('SNI server name list exceeds extension data');
+                return false;
+            }
+            // 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 {
+                        log('Malformed SNI entry');
+                        return false;
+                    }
+                }
+                // Parse hostname length (2 bytes)
+                if (pos + 2 > listEnd) {
+                    log('SNI extension truncated');
+                    return false;
+                }
+                const nameLength = (data[pos] << 8) + data[pos + 1];
+                pos += 2;
+                // Extract hostname
+                if (pos + nameLength > listEnd) {
+                    log('SNI hostname truncated');
+                    return false;
+                }
+                // Extract the hostname as UTF-8
+                try {
+                    const hostname = data.slice(pos, pos + nameLength).toString('utf8');
+                    log(`Found SNI hostname: ${hostname}`);
+                    serverNames.push(hostname);
+                }
+                catch (err) {
+                    log(`Error extracting hostname: ${err}`);
+                }
+                // Move to next entry
+                pos += nameLength;
+            }
+            return serverNames.length > 0;
+        }
+        catch (error) {
+            log(`Error parsing SNI extension: ${error}`);
+            return false;
+        }
+    }
+    /**
+     * 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, logger) {
+        const log = logger || (() => { });
+        if (!TlsUtils.isClientHello(buffer)) {
+            return { isResumption: false, hasSNI: false };
+        }
+        const parseResult = this.parseClientHello(buffer, logger);
+        if (!parseResult.isValid) {
+            log(`ClientHello parse failed: ${parseResult.error}`);
+            return { isResumption: false, hasSNI: false };
+        }
+        // Check resumption indicators
+        const hasSessionId = parseResult.hasSessionId;
+        const hasSessionTicket = parseResult.hasSessionTicket;
+        const hasPsk = parseResult.hasPsk;
+        const hasEarlyData = parseResult.hasEarlyData;
+        // Check for SNI
+        const hasSNI = !!parseResult.serverNameList && parseResult.serverNameList.length > 0;
+        // Consider it a resumption if any resumption mechanism is present
+        const isResumption = hasSessionTicket || hasPsk || hasEarlyData ||
+            (hasSessionId && !hasPsk); // Legacy resumption
+        // Log details
+        if (isResumption) {
+            log('Session resumption detected: ' +
+                (hasSessionTicket ? 'session ticket, ' : '') +
+                (hasPsk ? 'PSK, ' : '') +
+                (hasEarlyData ? 'early data, ' : '') +
+                (hasSessionId ? 'session ID' : '') +
+                (hasSNI ? ', with SNI' : ', without SNI'));
+        }
+        return { isResumption, hasSNI };
+    }
+    /**
+     * 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, logger) {
+        const log = logger || (() => { });
+        if (!TlsUtils.isClientHello(buffer)) {
+            return false;
+        }
+        // Parse the ClientHello
+        const parseResult = this.parseClientHello(buffer, logger);
+        if (!parseResult.isValid) {
+            return false;
+        }
+        // Tab reactivation pattern: session identifier + (ticket or PSK) but no SNI
+        const hasSessionId = parseResult.hasSessionId;
+        const hasSessionTicket = parseResult.hasSessionTicket;
+        const hasPsk = parseResult.hasPsk;
+        const hasSNI = !!parseResult.serverNameList && parseResult.serverNameList.length > 0;
+        if ((hasSessionId && (hasSessionTicket || hasPsk)) && !hasSNI) {
+            log('Detected tab reactivation pattern: session resumption without SNI');
+            return true;
+        }
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"client-hello-parser.js","sourceRoot":"","sources":["../../../../ts/protocols/tls/sni/client-hello-parser.ts"],"names":[],"mappings":"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"}

package/dist_ts/protocols/tls/sni/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * TLS SNI (Server Name Indication) protocol utilities
+ */
+export * from './client-hello-parser.js';
+export * from './sni-extraction.js';

package/dist_ts/protocols/tls/sni/index.js

@@ -0,0 +1,6 @@
+/**
+ * TLS SNI (Server Name Indication) protocol utilities
+ */
+export * from './client-hello-parser.js';
+export * from './sni-extraction.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi90cy9wcm90b2NvbHMvdGxzL3NuaS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyxxQkFBcUIsQ0FBQyJ9

package/dist_ts/protocols/tls/sni/sni-extraction.d.ts

@@ -0,0 +1,58 @@
+import { Buffer } from 'buffer';
+import { type LoggerFunction } from './client-hello-parser.js';
+/**
+ * Connection tracking information
+ */
+export interface ConnectionInfo {
+    sourceIp: string;
+    sourcePort: number;
+    destIp: string;
+    destPort: number;
+    timestamp?: number;
+}
+/**
+ * Utilities for extracting SNI information from TLS handshakes
+ */
+export declare class SniExtraction {
+    /**
+     * Extracts the SNI (Server Name Indication) from a TLS ClientHello message.
+     *
+     * @param buffer The buffer containing the TLS ClientHello message
+     * @param logger Optional logging function
+     * @returns The extracted server name or undefined if not found
+     */
+    static extractSNI(buffer: Buffer, logger?: LoggerFunction): string | undefined;
+    /**
+     * Attempts to extract SNI from the PSK extension in a TLS 1.3 ClientHello.
+     *
+     * In TLS 1.3, when a client attempts to resume a session, it may include
+     * the server name in the PSK identity hint rather than in the SNI extension.
+     *
+     * @param buffer The buffer containing the TLS ClientHello message
+     * @param logger Optional logging function
+     * @returns The extracted server name or undefined if not found
+     */
+    static extractSNIFromPSKExtension(buffer: Buffer, logger?: LoggerFunction): string | undefined;
+    /**
+     * Main entry point for SNI extraction with support for fragmented messages
+     * and session resumption edge cases.
+     *
+     * @param buffer The buffer containing TLS data
+     * @param connectionInfo Connection tracking information
+     * @param logger Optional logging function
+     * @param cachedSni Optional previously cached SNI value
+     * @returns The extracted server name or undefined
+     */
+    static extractSNIWithResumptionSupport(buffer: Buffer, connectionInfo?: ConnectionInfo, logger?: LoggerFunction, cachedSni?: string): string | undefined;
+    /**
+     * Unified method for processing a TLS packet and extracting SNI.
+     * Main entry point for SNI extraction that handles all edge cases.
+     *
+     * @param buffer The buffer containing TLS data
+     * @param connectionInfo Connection tracking information
+     * @param logger Optional logging function
+     * @param cachedSni Optional previously cached SNI value
+     * @returns The extracted server name or undefined
+     */
+    static processTlsPacket(buffer: Buffer, connectionInfo: ConnectionInfo, logger?: LoggerFunction, cachedSni?: string): string | undefined;
+}