@push.rocks/smartproxy 3.41.7 → 4.0.0

package/dist_ts/classes.pp.snihandler.js

@@ -0,0 +1,1073 @@
+import { Buffer } from 'buffer';
+/**
+ * SNI (Server Name Indication) handler for TLS connections.
+ * Provides robust extraction of SNI values from TLS ClientHello messages
+ * with support for fragmented packets, TLS 1.3 resumption, Chrome-specific
+ * connection behaviors, and tab hibernation/reactivation scenarios.
+ */
+export class SniHandler {
+    // TLS record types and constants
+    static { this.TLS_HANDSHAKE_RECORD_TYPE = 22; }
+    static { this.TLS_APPLICATION_DATA_TYPE = 23; } // TLS Application Data record type
+    static { this.TLS_CLIENT_HELLO_HANDSHAKE_TYPE = 1; }
+    static { this.TLS_SNI_EXTENSION_TYPE = 0x0000; }
+    static { this.TLS_SESSION_TICKET_EXTENSION_TYPE = 0x0023; }
+    static { this.TLS_SNI_HOST_NAME_TYPE = 0; }
+    static { this.TLS_PSK_EXTENSION_TYPE = 0x0029; } // Pre-Shared Key extension type for TLS 1.3
+    static { this.TLS_PSK_KE_MODES_EXTENSION_TYPE = 0x002d; } // PSK Key Exchange Modes
+    static { this.TLS_EARLY_DATA_EXTENSION_TYPE = 0x002a; } // Early Data (0-RTT) extension
+    // Buffer for handling fragmented ClientHello messages
+    static { this.fragmentedBuffers = new Map(); }
+    static { this.fragmentTimeout = 1000; } // ms to wait for fragments before cleanup
+    /**
+     * Extract the client random value from a ClientHello message
+     *
+     * @param buffer - The buffer containing the ClientHello
+     * @returns The 32-byte client random or undefined if extraction fails
+     */
+    static extractClientRandom(buffer) {
+        try {
+            if (!this.isClientHello(buffer) || buffer.length < 46) {
+                return undefined;
+            }
+            // In a ClientHello message, the client random starts at position 11
+            // after record header (5 bytes), handshake type (1 byte),
+            // handshake length (3 bytes), and client version (2 bytes)
+            return buffer.slice(11, 11 + 32);
+        }
+        catch (error) {
+            return undefined;
+        }
+    }
+    /**
+     * Checks if a buffer contains a TLS handshake message (record type 22)
+     * @param buffer - The buffer to check
+     * @returns true if the buffer starts with a TLS handshake record type
+     */
+    static isTlsHandshake(buffer) {
+        return buffer.length > 0 && buffer[0] === this.TLS_HANDSHAKE_RECORD_TYPE;
+    }
+    /**
+     * Checks if a buffer contains TLS application data (record type 23)
+     * @param buffer - The buffer to check
+     * @returns true if the buffer starts with a TLS application data record type
+     */
+    static isTlsApplicationData(buffer) {
+        return buffer.length > 0 && buffer[0] === this.TLS_APPLICATION_DATA_TYPE;
+    }
+    /**
+     * Creates a connection ID based on source/destination information
+     * Used to track fragmented ClientHello messages across multiple packets
+     *
+     * @param connectionInfo - Object containing connection identifiers (IP/port)
+     * @returns A string ID for the connection
+     */
+    static createConnectionId(connectionInfo) {
+        const { sourceIp, sourcePort, destIp, destPort } = connectionInfo;
+        return `${sourceIp}:${sourcePort}-${destIp}:${destPort}`;
+    }
+    /**
+     * 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 enableLogging - Whether to enable logging
+     * @returns A complete buffer if reassembly is successful, or undefined if more fragments are needed
+     */
+    static handleFragmentedClientHello(buffer, connectionId, enableLogging = false) {
+        const log = (message) => {
+            if (enableLogging) {
+                console.log(`[SNI Fragment] ${message}`);
+            }
+        };
+        // Check if we've seen this connection before
+        if (!this.fragmentedBuffers.has(connectionId)) {
+            // New connection, start with this buffer
+            this.fragmentedBuffers.set(connectionId, buffer);
+            // Set timeout to clean up if we don't get a complete ClientHello
+            setTimeout(() => {
+                if (this.fragmentedBuffers.has(connectionId)) {
+                    this.fragmentedBuffers.delete(connectionId);
+                    log(`Connection ${connectionId} timed out waiting for complete ClientHello`);
+                }
+            }, this.fragmentTimeout);
+            // 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 existingBuffer = this.fragmentedBuffers.get(connectionId);
+            const newBuffer = Buffer.concat([existingBuffer, buffer]);
+            this.fragmentedBuffers.set(connectionId, newBuffer);
+            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] === this.TLS_CLIENT_HELLO_HANDSHAKE_TYPE) {
+                            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 ${this.TLS_HANDSHAKE_RECORD_TYPE})`);
+                                if (nextRecordType === this.TLS_HANDSHAKE_RECORD_TYPE) {
+                                    const handshakeType = newBuffer[recordLength + 5];
+                                    log(`Next handshake type: ${handshakeType} (looking for ${this.TLS_CLIENT_HELLO_HANDSHAKE_TYPE})`);
+                                    if (handshakeType === this.TLS_CLIENT_HELLO_HANDSHAKE_TYPE) {
+                                        // 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
+        }
+    }
+    /**
+     * Checks if a buffer contains a TLS ClientHello message
+     * @param buffer - The buffer to check
+     * @returns true if the buffer appears to be a 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] !== this.TLS_HANDSHAKE_RECORD_TYPE) {
+            return false;
+        }
+        // Skip version and length in TLS record header (5 bytes total)
+        // Check handshake type at byte 5 (must be CLIENT_HELLO)
+        return buffer[5] === this.TLS_CLIENT_HELLO_HANDSHAKE_TYPE;
+    }
+    /**
+     * Checks if a ClientHello message contains session resumption indicators
+     * such as session tickets or PSK (Pre-Shared Key) extensions.
+     *
+     * @param buffer - The buffer containing a ClientHello message
+     * @param enableLogging - Whether to enable logging
+     * @returns Object containing details about session resumption and SNI presence
+     */
+    static hasSessionResumption(buffer, enableLogging = false) {
+        const log = (message) => {
+            if (enableLogging) {
+                console.log(`[Session Resumption] ${message}`);
+            }
+        };
+        if (!this.isClientHello(buffer)) {
+            return { isResumption: false, hasSNI: false };
+        }
+        try {
+            // Check for session ID presence first
+            let pos = 5 + 1 + 3 + 2; // Position after handshake type, length and client version
+            pos += 32; // Skip client random
+            if (pos + 1 > buffer.length)
+                return { isResumption: false, hasSNI: false };
+            const sessionIdLength = buffer[pos];
+            let hasNonEmptySessionId = sessionIdLength > 0;
+            if (hasNonEmptySessionId) {
+                log(`Detected non-empty session ID (length: ${sessionIdLength})`);
+            }
+            // Continue to check for extensions
+            pos += 1 + sessionIdLength;
+            // Skip cipher suites
+            if (pos + 2 > buffer.length)
+                return { isResumption: false, hasSNI: false };
+            const cipherSuitesLength = (buffer[pos] << 8) + buffer[pos + 1];
+            pos += 2 + cipherSuitesLength;
+            // Skip compression methods
+            if (pos + 1 > buffer.length)
+                return { isResumption: false, hasSNI: false };
+            const compressionMethodsLength = buffer[pos];
+            pos += 1 + compressionMethodsLength;
+            // Check for extensions
+            if (pos + 2 > buffer.length)
+                return { isResumption: false, hasSNI: false };
+            // Look for session resumption extensions
+            const extensionsLength = (buffer[pos] << 8) + buffer[pos + 1];
+            pos += 2;
+            // Extensions end position
+            const extensionsEnd = pos + extensionsLength;
+            if (extensionsEnd > buffer.length)
+                return { isResumption: false, hasSNI: false };
+            // Track resumption indicators
+            let hasSessionTicket = false;
+            let hasPSK = false;
+            let hasEarlyData = false;
+            // Iterate through extensions
+            while (pos + 4 <= extensionsEnd) {
+                const extensionType = (buffer[pos] << 8) + buffer[pos + 1];
+                pos += 2;
+                const extensionLength = (buffer[pos] << 8) + buffer[pos + 1];
+                pos += 2;
+                if (extensionType === this.TLS_SESSION_TICKET_EXTENSION_TYPE) {
+                    log('Found session ticket extension');
+                    hasSessionTicket = true;
+                    // Check if session ticket has non-zero length (active ticket)
+                    if (extensionLength > 0) {
+                        log(`Session ticket has length ${extensionLength} - active ticket present`);
+                    }
+                }
+                else if (extensionType === this.TLS_PSK_EXTENSION_TYPE) {
+                    log('Found PSK extension (TLS 1.3 resumption mechanism)');
+                    hasPSK = true;
+                }
+                else if (extensionType === this.TLS_EARLY_DATA_EXTENSION_TYPE) {
+                    log('Found Early Data extension (TLS 1.3 0-RTT)');
+                    hasEarlyData = true;
+                }
+                // Skip extension data
+                pos += extensionLength;
+            }
+            // Check if SNI is included
+            let hasSNI = false;
+            // Reset position and scan again for SNI extension
+            pos = 5 + 1 + 3 + 2; // Reset to after handshake type, length and client version
+            pos += 32; // Skip client random
+            if (pos + 1 <= buffer.length) {
+                const sessionIdLength = buffer[pos];
+                pos += 1 + sessionIdLength;
+                // Skip cipher suites
+                if (pos + 2 <= buffer.length) {
+                    const cipherSuitesLength = (buffer[pos] << 8) + buffer[pos + 1];
+                    pos += 2 + cipherSuitesLength;
+                    // Skip compression methods
+                    if (pos + 1 <= buffer.length) {
+                        const compressionMethodsLength = buffer[pos];
+                        pos += 1 + compressionMethodsLength;
+                        // Check for extensions
+                        if (pos + 2 <= buffer.length) {
+                            const extensionsLength = (buffer[pos] << 8) + buffer[pos + 1];
+                            pos += 2;
+                            // Extensions end position
+                            const extensionsEnd = pos + extensionsLength;
+                            if (extensionsEnd <= buffer.length) {
+                                // Scan for SNI extension
+                                while (pos + 4 <= extensionsEnd) {
+                                    const extensionType = (buffer[pos] << 8) + buffer[pos + 1];
+                                    pos += 2;
+                                    const extensionLength = (buffer[pos] << 8) + buffer[pos + 1];
+                                    pos += 2;
+                                    if (extensionType === this.TLS_SNI_EXTENSION_TYPE) {
+                                        // Check that the SNI extension actually has content
+                                        if (extensionLength > 0) {
+                                            hasSNI = true;
+                                            // Try to extract the actual SNI value for logging
+                                            try {
+                                                // Skip to server_name_list_length (2 bytes)
+                                                const tempPos = pos;
+                                                if (tempPos + 2 <= extensionsEnd) {
+                                                    const nameListLength = (buffer[tempPos] << 8) + buffer[tempPos + 1];
+                                                    // Skip server_name_list_length (2 bytes)
+                                                    if (tempPos + 2 + 1 <= extensionsEnd) {
+                                                        // Check name_type (should be 0 for hostname)
+                                                        if (buffer[tempPos + 2] === 0) {
+                                                            // Skip name_type (1 byte)
+                                                            if (tempPos + 3 + 2 <= extensionsEnd) {
+                                                                // Get name_length (2 bytes)
+                                                                const nameLength = (buffer[tempPos + 3] << 8) + buffer[tempPos + 4];
+                                                                // Extract the hostname
+                                                                if (tempPos + 5 + nameLength <= extensionsEnd) {
+                                                                    const hostname = buffer
+                                                                        .slice(tempPos + 5, tempPos + 5 + nameLength)
+                                                                        .toString('utf8');
+                                                                    log(`Found SNI extension with server_name: ${hostname}`);
+                                                                }
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                            catch (e) {
+                                                log(`Error extracting SNI value: ${e}`);
+                                                log('Found SNI extension with length: ' + extensionLength);
+                                            }
+                                        }
+                                        else {
+                                            log('Found empty SNI extension, treating as no SNI');
+                                        }
+                                        break;
+                                    }
+                                    // Skip extension data
+                                    pos += extensionLength;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            // Consider it a resumption if any resumption mechanism is present
+            const isResumption = hasSessionTicket || hasPSK || hasEarlyData || (hasNonEmptySessionId && !hasPSK); // Legacy resumption
+            if (isResumption) {
+                log('Session resumption detected: ' +
+                    (hasSessionTicket ? 'session ticket, ' : '') +
+                    (hasPSK ? 'PSK, ' : '') +
+                    (hasEarlyData ? 'early data, ' : '') +
+                    (hasNonEmptySessionId ? 'session ID' : '') +
+                    (hasSNI ? ', with SNI' : ', without SNI'));
+            }
+            // Return an object with both flags
+            // For clarity: connections should be blocked if they have session resumption without SNI
+            if (isResumption) {
+                log(`Resumption summary - hasSNI: ${hasSNI ? 'yes' : 'no'}, resumption type: ${hasSessionTicket ? 'session ticket, ' : ''}${hasPSK ? 'PSK, ' : ''}${hasEarlyData ? 'early data, ' : ''}${hasNonEmptySessionId ? 'session ID' : ''}`);
+            }
+            return {
+                isResumption,
+                hasSNI,
+            };
+        }
+        catch (error) {
+            log(`Error checking for session resumption: ${error}`);
+            return { isResumption: false, hasSNI: false };
+        }
+    }
+    /**
+     * Detects characteristics of a tab reactivation TLS handshake
+     * These often have specific patterns in Chrome and other browsers
+     *
+     * @param buffer - The buffer containing a ClientHello message
+     * @param enableLogging - Whether to enable logging
+     * @returns true if this appears to be a tab reactivation handshake
+     */
+    static isTabReactivationHandshake(buffer, enableLogging = false) {
+        const log = (message) => {
+            if (enableLogging) {
+                console.log(`[Tab Reactivation] ${message}`);
+            }
+        };
+        if (!this.isClientHello(buffer)) {
+            return false;
+        }
+        try {
+            // Check for session ID presence (tab reactivation often has a session ID)
+            let pos = 5 + 1 + 3 + 2; // Position after handshake type, length and client version
+            pos += 32; // Skip client random
+            if (pos + 1 > buffer.length)
+                return false;
+            const sessionIdLength = buffer[pos];
+            // Non-empty session ID is a good indicator
+            if (sessionIdLength > 0) {
+                log(`Detected non-empty session ID (length: ${sessionIdLength})`);
+                // Skip to extensions
+                pos += 1 + sessionIdLength;
+                // Skip cipher suites
+                if (pos + 2 > buffer.length)
+                    return false;
+                const cipherSuitesLength = (buffer[pos] << 8) + buffer[pos + 1];
+                pos += 2 + cipherSuitesLength;
+                // Skip compression methods
+                if (pos + 1 > buffer.length)
+                    return false;
+                const compressionMethodsLength = buffer[pos];
+                pos += 1 + compressionMethodsLength;
+                // Check for extensions
+                if (pos + 2 > buffer.length)
+                    return false;
+                // Look for specific extensions that indicate tab reactivation
+                const extensionsLength = (buffer[pos] << 8) + buffer[pos + 1];
+                pos += 2;
+                // Extensions end position
+                const extensionsEnd = pos + extensionsLength;
+                if (extensionsEnd > buffer.length)
+                    return false;
+                // Tab reactivation often has session tickets but no SNI
+                let hasSessionTicket = false;
+                let hasSNI = false;
+                let hasPSK = false;
+                // Iterate through extensions
+                while (pos + 4 <= extensionsEnd) {
+                    const extensionType = (buffer[pos] << 8) + buffer[pos + 1];
+                    pos += 2;
+                    const extensionLength = (buffer[pos] << 8) + buffer[pos + 1];
+                    pos += 2;
+                    if (extensionType === this.TLS_SESSION_TICKET_EXTENSION_TYPE) {
+                        hasSessionTicket = true;
+                    }
+                    else if (extensionType === this.TLS_SNI_EXTENSION_TYPE) {
+                        hasSNI = true;
+                    }
+                    else if (extensionType === this.TLS_PSK_EXTENSION_TYPE) {
+                        hasPSK = true;
+                    }
+                    // Skip extension data
+                    pos += extensionLength;
+                }
+                // Pattern for tab reactivation: session identifier + (ticket or PSK) but no SNI
+                if ((hasSessionTicket || hasPSK) && !hasSNI) {
+                    log('Detected tab reactivation pattern: session resumption without SNI');
+                    return true;
+                }
+            }
+        }
+        catch (error) {
+            log(`Error checking for tab reactivation: ${error}`);
+        }
+        return false;
+    }
+    /**
+     * Extracts the SNI (Server Name Indication) from a TLS ClientHello message.
+     * Implements robust parsing with support for session resumption edge cases.
+     *
+     * @param buffer - The buffer containing the TLS ClientHello message
+     * @param enableLogging - Whether to enable detailed debug logging
+     * @returns The extracted server name or undefined if not found
+     */
+    static extractSNI(buffer, enableLogging = false) {
+        // Logging helper
+        const log = (message) => {
+            if (enableLogging) {
+                console.log(`[SNI Extraction] ${message}`);
+            }
+        };
+        try {
+            // Buffer must be at least 5 bytes (TLS record header)
+            if (buffer.length < 5) {
+                log('Buffer too small for TLS record header');
+                return undefined;
+            }
+            // Check record type (must be TLS_HANDSHAKE_RECORD_TYPE = 22)
+            if (buffer[0] !== this.TLS_HANDSHAKE_RECORD_TYPE) {
+                log(`Not a TLS handshake record: ${buffer[0]}`);
+                return undefined;
+            }
+            // Check TLS version
+            const majorVersion = buffer[1];
+            const minorVersion = buffer[2];
+            log(`TLS 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) {
+                log('Buffer smaller than expected record length');
+                return undefined;
+            }
+            // Start of handshake message in the buffer
+            let pos = 5;
+            // Check handshake type (must be CLIENT_HELLO = 1)
+            if (buffer[pos] !== this.TLS_CLIENT_HELLO_HANDSHAKE_TYPE) {
+                log(`Not a ClientHello message: ${buffer[pos]}`);
+                return undefined;
+            }
+            // 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;
+            // Skip client random (32 bytes)
+            pos += 32;
+            // Parse session ID
+            if (pos + 1 > buffer.length) {
+                log('Buffer too small for session ID length');
+                return undefined;
+            }
+            const sessionIdLength = buffer[pos];
+            log(`Session ID length: ${sessionIdLength}`);
+            // Skip session ID length (1 byte) and session ID
+            pos += 1 + sessionIdLength;
+            // Check if we have enough bytes left
+            if (pos + 2 > buffer.length) {
+                log('Buffer too small for cipher suites length');
+                return undefined;
+            }
+            // Parse cipher suites length (2 bytes, big-endian)
+            const cipherSuitesLength = (buffer[pos] << 8) + buffer[pos + 1];
+            log(`Cipher suites length: ${cipherSuitesLength}`);
+            // Skip cipher suites length (2 bytes) and cipher suites
+            pos += 2 + cipherSuitesLength;
+            // Check if we have enough bytes left
+            if (pos + 1 > buffer.length) {
+                log('Buffer too small for compression methods length');
+                return undefined;
+            }
+            // Parse compression methods length (1 byte)
+            const compressionMethodsLength = buffer[pos];
+            log(`Compression methods length: ${compressionMethodsLength}`);
+            // Skip compression methods length (1 byte) and compression methods
+            pos += 1 + compressionMethodsLength;
+            // Check if we have enough bytes for extensions length
+            if (pos + 2 > buffer.length) {
+                log('No extensions present or buffer too small');
+                return undefined;
+            }
+            // Parse extensions length (2 bytes, big-endian)
+            const extensionsLength = (buffer[pos] << 8) + buffer[pos + 1];
+            log(`Extensions length: ${extensionsLength}`);
+            // Skip extensions length (2 bytes)
+            pos += 2;
+            // Extensions end position
+            const extensionsEnd = pos + extensionsLength;
+            // Check if extensions length is valid
+            if (extensionsEnd > buffer.length) {
+                log('Extensions length exceeds buffer size');
+                return undefined;
+            }
+            // Track if we found session tickets (for improved resumption handling)
+            let hasSessionTicket = false;
+            let hasPskExtension = false;
+            // Iterate through extensions
+            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')}`);
+                // Skip extension type (2 bytes)
+                pos += 2;
+                // Parse extension length (2 bytes, big-endian)
+                const extensionLength = (buffer[pos] << 8) + buffer[pos + 1];
+                log(`Extension length: ${extensionLength}`);
+                // Skip extension length (2 bytes)
+                pos += 2;
+                // Check if this is the SNI extension
+                if (extensionType === this.TLS_SNI_EXTENSION_TYPE) {
+                    log('Found SNI extension');
+                    // Ensure we have enough bytes for the server name list
+                    if (pos + 2 > extensionsEnd) {
+                        log('Extension too small for server name list length');
+                        pos += extensionLength; // Skip this extension
+                        continue;
+                    }
+                    // Parse server name list length (2 bytes, big-endian)
+                    const serverNameListLength = (buffer[pos] << 8) + buffer[pos + 1];
+                    log(`Server name list length: ${serverNameListLength}`);
+                    // Skip server name list length (2 bytes)
+                    pos += 2;
+                    // Ensure server name list length is valid
+                    if (pos + serverNameListLength > extensionsEnd) {
+                        log('Server name list length exceeds extension size');
+                        break; // Exit the loop, extension parsing is broken
+                    }
+                    // End position of server name list
+                    const serverNameListEnd = pos + serverNameListLength;
+                    // Iterate through server names
+                    while (pos + 3 <= serverNameListEnd) {
+                        // Check name type (must be HOST_NAME_TYPE = 0 for hostname)
+                        const nameType = buffer[pos];
+                        log(`Name type: ${nameType}`);
+                        if (nameType !== this.TLS_SNI_HOST_NAME_TYPE) {
+                            log(`Unsupported name type: ${nameType}`);
+                            pos += 1; // Skip name type (1 byte)
+                            // Skip name length (2 bytes) and name data
+                            if (pos + 2 <= serverNameListEnd) {
+                                const nameLength = (buffer[pos] << 8) + buffer[pos + 1];
+                                pos += 2 + nameLength;
+                            }
+                            else {
+                                log('Invalid server name entry');
+                                break;
+                            }
+                            continue;
+                        }
+                        // Skip name type (1 byte)
+                        pos += 1;
+                        // Ensure we have enough bytes for name length
+                        if (pos + 2 > serverNameListEnd) {
+                            log('Server name entry too small for name length');
+                            break;
+                        }
+                        // Parse name length (2 bytes, big-endian)
+                        const nameLength = (buffer[pos] << 8) + buffer[pos + 1];
+                        log(`Name length: ${nameLength}`);
+                        // Skip name length (2 bytes)
+                        pos += 2;
+                        // Ensure we have enough bytes for the name
+                        if (pos + nameLength > serverNameListEnd) {
+                            log('Name length exceeds server name list size');
+                            break;
+                        }
+                        // Extract server name (hostname)
+                        const serverName = buffer.slice(pos, pos + nameLength).toString('utf8');
+                        log(`Extracted server name: ${serverName}`);
+                        return serverName;
+                    }
+                }
+                else if (extensionType === this.TLS_SESSION_TICKET_EXTENSION_TYPE) {
+                    // If we encounter a session ticket extension, mark it for later
+                    log('Found session ticket extension');
+                    hasSessionTicket = true;
+                    pos += extensionLength; // Skip this extension
+                }
+                else if (extensionType === this.TLS_PSK_EXTENSION_TYPE) {
+                    // TLS 1.3 PSK extension - mark for resumption support
+                    log('Found PSK extension (TLS 1.3 resumption indicator)');
+                    hasPskExtension = true;
+                    // We'll skip the extension here and process it separately if needed
+                    pos += extensionLength;
+                }
+                else {
+                    // Skip this extension
+                    pos += extensionLength;
+                }
+            }
+            // Log if we found session resumption indicators but no SNI
+            if (hasSessionTicket || hasPskExtension) {
+                log('Session resumption indicators present but no SNI found');
+            }
+            log('No SNI extension found in ClientHello');
+            return undefined;
+        }
+        catch (error) {
+            log(`Error parsing SNI: ${error instanceof Error ? error.message : String(error)}`);
+            return 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 enableLogging - Whether to enable detailed debug logging
+     * @returns The extracted server name or undefined if not found
+     */
+    static extractSNIFromPSKExtension(buffer, enableLogging = false) {
+        const log = (message) => {
+            if (enableLogging) {
+                console.log(`[PSK-SNI Extraction] ${message}`);
+            }
+        };
+        try {
+            // Ensure this is a ClientHello
+            if (!this.isClientHello(buffer)) {
+                log('Not a ClientHello message');
+                return undefined;
+            }
+            // Find the start position of extensions
+            let pos = 5; // Start after record header
+            // Skip handshake type (1 byte)
+            pos += 1;
+            // Skip handshake length (3 bytes)
+            pos += 3;
+            // Skip client version (2 bytes)
+            pos += 2;
+            // Skip client random (32 bytes)
+            pos += 32;
+            // Skip session ID
+            if (pos + 1 > buffer.length)
+                return undefined;
+            const sessionIdLength = buffer[pos];
+            pos += 1 + sessionIdLength;
+            // Skip cipher suites
+            if (pos + 2 > buffer.length)
+                return undefined;
+            const cipherSuitesLength = (buffer[pos] << 8) + buffer[pos + 1];
+            pos += 2 + cipherSuitesLength;
+            // Skip compression methods
+            if (pos + 1 > buffer.length)
+                return undefined;
+            const compressionMethodsLength = buffer[pos];
+            pos += 1 + compressionMethodsLength;
+            // Check if we have extensions
+            if (pos + 2 > buffer.length) {
+                log('No extensions present');
+                return undefined;
+            }
+            // Get extensions length
+            const extensionsLength = (buffer[pos] << 8) + buffer[pos + 1];
+            pos += 2;
+            // Extensions end position
+            const extensionsEnd = pos + extensionsLength;
+            if (extensionsEnd > buffer.length)
+                return undefined;
+            // Look for PSK extension
+            while (pos + 4 <= extensionsEnd) {
+                const extensionType = (buffer[pos] << 8) + buffer[pos + 1];
+                pos += 2;
+                const extensionLength = (buffer[pos] << 8) + buffer[pos + 1];
+                pos += 2;
+                if (extensionType === this.TLS_PSK_EXTENSION_TYPE) {
+                    log('Found PSK extension');
+                    // PSK extension structure:
+                    // 2 bytes: identities list length
+                    if (pos + 2 > extensionsEnd)
+                        break;
+                    const identitiesLength = (buffer[pos] << 8) + buffer[pos + 1];
+                    pos += 2;
+                    // End of identities list
+                    const identitiesEnd = pos + identitiesLength;
+                    if (identitiesEnd > extensionsEnd)
+                        break;
+                    // Process each PSK identity
+                    while (pos + 2 <= identitiesEnd) {
+                        // Identity length (2 bytes)
+                        if (pos + 2 > identitiesEnd)
+                            break;
+                        const identityLength = (buffer[pos] << 8) + buffer[pos + 1];
+                        pos += 2;
+                        if (pos + identityLength > identitiesEnd)
+                            break;
+                        // Try to extract hostname from identity
+                        // Chrome often embeds the hostname in the PSK identity
+                        // This is a heuristic as there's no standard format
+                        if (identityLength > 0) {
+                            const identity = buffer.slice(pos, pos + identityLength);
+                            // Skip identity bytes
+                            pos += identityLength;
+                            // Skip obfuscated ticket age (4 bytes)
+                            if (pos + 4 <= identitiesEnd) {
+                                pos += 4;
+                            }
+                            else {
+                                break;
+                            }
+                            // Try to parse the identity as UTF-8
+                            try {
+                                const identityStr = identity.toString('utf8');
+                                log(`PSK identity: ${identityStr}`);
+                                // Check if the identity contains hostname hints
+                                // Chrome often embeds the hostname in a known format
+                                // Try to extract using common patterns
+                                // Pattern 1: Look for domain name pattern
+                                const domainPattern = /([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?/i;
+                                const domainMatch = identityStr.match(domainPattern);
+                                if (domainMatch && domainMatch[0]) {
+                                    log(`Found domain in PSK identity: ${domainMatch[0]}`);
+                                    return domainMatch[0];
+                                }
+                                // Pattern 2: Chrome sometimes uses a specific format with delimiters
+                                // This is a heuristic approach since the format isn't standardized
+                                const parts = identityStr.split('|');
+                                if (parts.length > 1) {
+                                    for (const part of parts) {
+                                        if (part.includes('.') && !part.includes('/')) {
+                                            const possibleDomain = part.trim();
+                                            if (/^[a-z0-9.-]+$/i.test(possibleDomain)) {
+                                                log(`Found possible domain in PSK delimiter format: ${possibleDomain}`);
+                                                return possibleDomain;
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                            catch (e) {
+                                log('Failed to parse PSK identity as UTF-8');
+                            }
+                        }
+                    }
+                }
+                else {
+                    // Skip this extension
+                    pos += extensionLength;
+                }
+            }
+            log('No hostname found in PSK extension');
+            return undefined;
+        }
+        catch (error) {
+            log(`Error parsing PSK: ${error instanceof Error ? error.message : String(error)}`);
+            return undefined;
+        }
+    }
+    /**
+     * Checks if the buffer contains TLS 1.3 early data (0-RTT)
+     * @param buffer - The buffer to check
+     * @param enableLogging - Whether to enable logging
+     * @returns true if early data is detected
+     */
+    static hasEarlyData(buffer, enableLogging = false) {
+        const log = (message) => {
+            if (enableLogging) {
+                console.log(`[Early Data] ${message}`);
+            }
+        };
+        try {
+            // Check if this is a valid ClientHello first
+            if (!this.isClientHello(buffer)) {
+                return false;
+            }
+            // Find the extensions section
+            let pos = 5; // Start after record header
+            // Skip handshake type (1 byte)
+            pos += 1;
+            // Skip handshake length (3 bytes)
+            pos += 3;
+            // Skip client version (2 bytes)
+            pos += 2;
+            // Skip client random (32 bytes)
+            pos += 32;
+            // Skip session ID
+            if (pos + 1 > buffer.length)
+                return false;
+            const sessionIdLength = buffer[pos];
+            pos += 1 + sessionIdLength;
+            // Skip cipher suites
+            if (pos + 2 > buffer.length)
+                return false;
+            const cipherSuitesLength = (buffer[pos] << 8) + buffer[pos + 1];
+            pos += 2 + cipherSuitesLength;
+            // Skip compression methods
+            if (pos + 1 > buffer.length)
+                return false;
+            const compressionMethodsLength = buffer[pos];
+            pos += 1 + compressionMethodsLength;
+            // Check if we have extensions
+            if (pos + 2 > buffer.length)
+                return false;
+            // Get extensions length
+            const extensionsLength = (buffer[pos] << 8) + buffer[pos + 1];
+            pos += 2;
+            // Extensions end position
+            const extensionsEnd = pos + extensionsLength;
+            if (extensionsEnd > buffer.length)
+                return false;
+            // Look for early data extension
+            while (pos + 4 <= extensionsEnd) {
+                const extensionType = (buffer[pos] << 8) + buffer[pos + 1];
+                pos += 2;
+                const extensionLength = (buffer[pos] << 8) + buffer[pos + 1];
+                pos += 2;
+                if (extensionType === this.TLS_EARLY_DATA_EXTENSION_TYPE) {
+                    log('Early Data (0-RTT) extension detected');
+                    return true;
+                }
+                // Skip to next extension
+                pos += extensionLength;
+            }
+            return false;
+        }
+        catch (error) {
+            log(`Error checking for early data: ${error}`);
+            return false;
+        }
+    }
+    /**
+     * Attempts to extract SNI from an initial ClientHello packet and handles
+     * session resumption edge cases more robustly than the standard extraction.
+     *
+     * This method handles:
+     * 1. Standard SNI extraction
+     * 2. TLS 1.3 PSK-based resumption (Chrome, Firefox, etc.)
+     * 3. Session ticket-based resumption
+     * 4. Fragmented ClientHello messages
+     * 5. TLS 1.3 Early Data (0-RTT)
+     * 6. Chrome's connection racing behaviors
+     *
+     * @param buffer - The buffer containing the TLS ClientHello message
+     * @param connectionInfo - Optional connection information for fragment handling
+     * @param enableLogging - Whether to enable detailed debug logging
+     * @returns The extracted server name or undefined if not found
+     */
+    static extractSNIWithResumptionSupport(buffer, connectionInfo, enableLogging = false) {
+        const log = (message) => {
+            if (enableLogging) {
+                console.log(`[SNI Extraction] ${message}`);
+            }
+        };
+        // Log buffer details for debugging
+        if (enableLogging) {
+            log(`Buffer size: ${buffer.length} bytes`);
+            log(`Buffer starts with: ${buffer.slice(0, Math.min(10, buffer.length)).toString('hex')}`);
+            if (buffer.length >= 5) {
+                const recordType = buffer[0];
+                const majorVersion = buffer[1];
+                const minorVersion = buffer[2];
+                const recordLength = (buffer[3] << 8) + buffer[4];
+                log(`TLS Record: type=${recordType}, version=${majorVersion}.${minorVersion}, length=${recordLength}`);
+            }
+        }
+        // Check if we need to handle fragmented packets
+        let processBuffer = buffer;
+        if (connectionInfo) {
+            const connectionId = this.createConnectionId(connectionInfo);
+            const reassembledBuffer = this.handleFragmentedClientHello(buffer, connectionId, enableLogging);
+            if (!reassembledBuffer) {
+                log(`Waiting for more fragments on connection ${connectionId}`);
+                return undefined; // Need more fragments to complete ClientHello
+            }
+            processBuffer = reassembledBuffer;
+            log(`Using reassembled buffer of length ${processBuffer.length}`);
+        }
+        // First try the standard SNI extraction
+        const standardSni = this.extractSNI(processBuffer, enableLogging);
+        if (standardSni) {
+            log(`Found standard SNI: ${standardSni}`);
+            return standardSni;
+        }
+        // Check for session resumption when standard SNI extraction fails
+        if (this.isClientHello(processBuffer)) {
+            const resumptionInfo = this.hasSessionResumption(processBuffer, enableLogging);
+            if (resumptionInfo.isResumption) {
+                log(`Detected session resumption in ClientHello without standard SNI`);
+                // Try to extract SNI from PSK extension
+                const pskSni = this.extractSNIFromPSKExtension(processBuffer, enableLogging);
+                if (pskSni) {
+                    log(`Extracted SNI from PSK extension: ${pskSni}`);
+                    return pskSni;
+                }
+            }
+        }
+        // Log detailed info about the ClientHello when SNI extraction fails
+        if (this.isClientHello(processBuffer) && enableLogging) {
+            log(`SNI extraction failed for ClientHello. Buffer details:`);
+            if (processBuffer.length >= 43) {
+                // ClientHello with at least client random
+                const clientRandom = processBuffer.slice(11, 11 + 32).toString('hex');
+                log(`Client Random: ${clientRandom}`);
+                // Log session ID length and presence
+                const sessionIdLength = processBuffer[43];
+                log(`Session ID length: ${sessionIdLength}`);
+                if (sessionIdLength > 0 && processBuffer.length >= 44 + sessionIdLength) {
+                    const sessionId = processBuffer.slice(44, 44 + sessionIdLength).toString('hex');
+                    log(`Session ID: ${sessionId}`);
+                }
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Main entry point for SNI extraction that handles all edge cases.
+     * This should be called for each TLS packet received from a client.
+     *
+     * The method uses connection tracking to handle fragmented ClientHello
+     * messages and various TLS 1.3 behaviors, including Chrome's connection
+     * racing patterns.
+     *
+     * @param buffer - The buffer containing TLS data
+     * @param connectionInfo - Connection metadata (IPs and ports)
+     * @param enableLogging - Whether to enable detailed debug logging
+     * @param cachedSni - Optional cached SNI from previous connections (for racing detection)
+     * @returns The extracted server name or undefined if not found or more data needed
+     */
+    static processTlsPacket(buffer, connectionInfo, enableLogging = false, cachedSni) {
+        const log = (message) => {
+            if (enableLogging) {
+                console.log(`[TLS Packet] ${message}`);
+            }
+        };
+        // Add timestamp if not provided
+        if (!connectionInfo.timestamp) {
+            connectionInfo.timestamp = Date.now();
+        }
+        // Check if this is a TLS handshake or application data
+        if (!this.isTlsHandshake(buffer) && !this.isTlsApplicationData(buffer)) {
+            log('Not a TLS handshake or application data packet');
+            return undefined;
+        }
+        // Create connection ID for tracking
+        const connectionId = this.createConnectionId(connectionInfo);
+        log(`Processing TLS packet for connection ${connectionId}, buffer length: ${buffer.length}`);
+        // Handle application data with cached SNI (for connection racing)
+        if (this.isTlsApplicationData(buffer)) {
+            // First check if explicit cachedSni was provided
+            if (cachedSni) {
+                log(`Using provided cached SNI for application data: ${cachedSni}`);
+                return cachedSni;
+            }
+            log('Application data packet without cached SNI, cannot determine hostname');
+            return undefined;
+        }
+        // Enhanced session resumption detection
+        if (this.isClientHello(buffer)) {
+            const resumptionInfo = this.hasSessionResumption(buffer, enableLogging);
+            if (resumptionInfo.isResumption) {
+                log(`Session resumption detected in TLS packet`);
+                // Always try standard SNI extraction first
+                const standardSni = this.extractSNI(buffer, enableLogging);
+                if (standardSni) {
+                    log(`Found standard SNI in session resumption: ${standardSni}`);
+                    return standardSni;
+                }
+                // Enhanced session resumption SNI extraction
+                // Try extracting from PSK identity
+                const pskSni = this.extractSNIFromPSKExtension(buffer, enableLogging);
+                if (pskSni) {
+                    log(`Extracted SNI from PSK extension: ${pskSni}`);
+                    return pskSni;
+                }
+                // Additional check for SNI in session tickets
+                if (enableLogging) {
+                    log(`Checking for session ticket information to extract server name...`);
+                    // Log more details for debugging
+                    try {
+                        // Look at the raw buffer for patterns
+                        log(`Buffer hexdump (first 100 bytes): ${buffer.slice(0, 100).toString('hex')}`);
+                        // Try to find hostname-like patterns in the buffer
+                        const bufferStr = buffer.toString('utf8', 0, buffer.length);
+                        const hostnamePattern = /([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?/gi;
+                        const hostMatches = bufferStr.match(hostnamePattern);
+                        if (hostMatches && hostMatches.length > 0) {
+                            log(`Possible hostnames found in buffer: ${hostMatches.join(', ')}`);
+                            // Check if any match looks like a valid domain
+                            for (const match of hostMatches) {
+                                if (match.includes('.') && match.length > 3) {
+                                    log(`Potential SNI found in session data: ${match}`);
+                                    // Don't automatically use this - just log for debugging
+                                }
+                            }
+                        }
+                    }
+                    catch (e) {
+                        log(`Error scanning for patterns: ${e}`);
+                    }
+                }
+                log(`Session resumption without extractable SNI`);
+                // If allowSessionTicket=false, should be rejected by caller
+            }
+        }
+        // For handshake messages, try the full extraction process
+        const sni = this.extractSNIWithResumptionSupport(buffer, connectionInfo, enableLogging);
+        if (sni) {
+            log(`Successfully extracted SNI: ${sni}`);
+            return sni;
+        }
+        // If we couldn't extract an SNI, check if this is a valid ClientHello
+        if (this.isClientHello(buffer)) {
+            log('Valid ClientHello detected, but no SNI extracted - might need more data');
+        }
+        return undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.pp.snihandler.js","sourceRoot":"","sources":["../ts/classes.pp.snihandler.ts"],"names":[],"mappings":"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"}