@push.rocks/smartproxy 3.37.0 → 3.37.2

package/dist_ts/classes.snihandler.d.ts

@@ -0,0 +1,45 @@
+import { Buffer } from 'buffer';
+/**
+ * SNI (Server Name Indication) handler for TLS connections.
+ * Provides robust extraction of SNI values from TLS ClientHello messages.
+ */
+export declare class SniHandler {
+    private static readonly TLS_HANDSHAKE_RECORD_TYPE;
+    private static readonly TLS_CLIENT_HELLO_HANDSHAKE_TYPE;
+    private static readonly TLS_SNI_EXTENSION_TYPE;
+    private static readonly TLS_SESSION_TICKET_EXTENSION_TYPE;
+    private static readonly TLS_SNI_HOST_NAME_TYPE;
+    /**
+     * 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: Buffer): boolean;
+    /**
+     * 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: Buffer): boolean;
+    /**
+     * 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: Buffer, enableLogging?: boolean): string | undefined;
+    /**
+     * Attempts to extract SNI from an initial ClientHello packet and handles
+     * session resumption edge cases more robustly than the standard extraction.
+     *
+     * This method is specifically designed for Chrome and other browsers that
+     * may send different ClientHello formats during session resumption.
+     *
+     * @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 extractSNIWithResumptionSupport(buffer: Buffer, enableLogging?: boolean): string | undefined;
+}

package/dist_ts/classes.snihandler.js

@@ -0,0 +1,274 @@
+import { Buffer } from 'buffer';
+/**
+ * SNI (Server Name Indication) handler for TLS connections.
+ * Provides robust extraction of SNI values from TLS ClientHello messages.
+ */
+export class SniHandler {
+    // TLS record types and constants
+    static { this.TLS_HANDSHAKE_RECORD_TYPE = 22; }
+    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; }
+    /**
+     * 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 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;
+    }
+    /**
+     * 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;
+            // 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 {
+                    // Skip this extension
+                    pos += extensionLength;
+                }
+            }
+            // Log if we found a session ticket but no SNI
+            if (hasSessionTicket) {
+                log('Session ticket present but no SNI found - possible resumption scenario');
+            }
+            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 an initial ClientHello packet and handles
+     * session resumption edge cases more robustly than the standard extraction.
+     *
+     * This method is specifically designed for Chrome and other browsers that
+     * may send different ClientHello formats during session resumption.
+     *
+     * @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 extractSNIWithResumptionSupport(buffer, enableLogging = false) {
+        // First try the standard SNI extraction
+        const standardSni = this.extractSNI(buffer, enableLogging);
+        if (standardSni) {
+            return standardSni;
+        }
+        // If standard extraction failed and we have a valid ClientHello,
+        // this might be a session resumption with non-standard format
+        if (this.isClientHello(buffer)) {
+            if (enableLogging) {
+                console.log('[SNI Extraction] Detected ClientHello without standard SNI, possible session resumption');
+            }
+            // Additional handling could be implemented here for specific browser behaviors
+            // For now, this is a placeholder for future improvements
+        }
+        return undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.snihandler.js","sourceRoot":"","sources":["../ts/classes.snihandler.ts"],"names":[],"mappings":"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"}

package/dist_ts/index.d.ts

@@ -3,3 +3,4 @@ export * from './classes.networkproxy.js';
 export * from './classes.portproxy.js';
 export * from './classes.port80handler.js';
 export * from './classes.sslredirect.js';
+export * from './classes.snihandler.js';

package/dist_ts/index.js

@@ -3,4 +3,5 @@ export * from './classes.networkproxy.js';
 export * from './classes.portproxy.js';
 export * from './classes.port80handler.js';
 export * from './classes.sslredirect.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsMEJBQTBCLENBQUMifQ==
+export * from './classes.snihandler.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyx5QkFBeUIsQ0FBQyJ9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartproxy",
-  "version": "3.37.0",
+  "version": "3.37.2",
   "private": false,
   "description": "A powerful proxy package that effectively handles high traffic, with features such as SSL/TLS support, port proxying, WebSocket handling, dynamic routing with authentication options, and automatic ACME certificate management.",
   "main": "dist_ts/index.js",

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartproxy',
-  version: '3.37.0',
+  version: '3.37.2',
   description: 'A powerful proxy package that effectively handles high traffic, with features such as SSL/TLS support, port proxying, WebSocket handling, dynamic routing with authentication options, and automatic ACME certificate management.'
 }