3.31.0

Fixed TypeScript errors caused by using 'connectionRecord' instead of 'record' in TLS renegotiation handlers.
The variable name mistake occurred when moving and restructuring the TLS handshake detection code.

🤖 Generated with [Claude Code](https://claude.ai/code)
Co-Authored-By: Claude <noreply@anthropic.com>

changelog.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## 2025-03-11 - 3.31.0 - feat(PortProxy)
+Improve TLS handshake SNI extraction and add session resumption tracking in PortProxy
+
+- Added ITlsSessionInfo interface and a global tlsSessionCache to track TLS session IDs for session resumption
+- Implemented a cleanup timer for the TLS session cache with startSessionCleanupTimer and stopSessionCleanupTimer
+- Enhanced extractSNIInfo to return detailed SNI information including session IDs, ticket details, and resumption status
+- Updated renegotiation handlers to use extractSNIInfo for proper SNI extraction during TLS rehandshake
+
+## 2025-03-11 - 3.30.8 - fix(core)
+No changes in this commit.
+
+
+## 2025-03-11 - 3.30.7 - fix(PortProxy)
+Improve TLS renegotiation SNI handling by first checking if the new SNI is allowed under the existing domain config. If not, attempt to find an alternative domain config and update the locked domain accordingly; otherwise, terminate the connection on SNI mismatch.
+
+- Added a preliminary check against the original domain config to allow re-handshakes if the new SNI matches allowed patterns.
+- If the original config does not allow, search for an alternative domain config and validate IP rules.
+- Update the locked domain when allowed, ensuring connection reuse with valid certificate context.
+- Terminate the connection if no suitable domain config is found or IP restrictions are violated.
+
+## 2025-03-11 - 3.30.6 - fix(PortProxy)
+Improve TLS renegotiation handling in PortProxy by validating the new SNI against allowed domain configurations. If the new SNI is permitted based on existing IP rules, update the locked domain to allow connection reuse; otherwise, terminate the connection to prevent misrouting.
+
+- Added logic to check if a new SNI during renegotiation is allowed by comparing IP rules from the matching domain configuration.
+- Updated detailed logging to indicate when a valid SNI change is accepted and when it results in a mismatch termination.
+
+## 2025-03-10 - 3.30.5 - fix(internal)
+No uncommitted changes detected; project files and tests remain unchanged.
+
+
 ## 2025-03-10 - 3.30.4 - fix(PortProxy)
 Fix TLS renegotiation handling and adjust TLS keep-alive timeouts in PortProxy implementation
 

package.json

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

ts/00_commitinfo_data.ts

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

ts/classes.portproxy.ts

@@ -100,14 +100,82 @@ interface IConnectionRecord {
   lastSleepDetection?: number; // Timestamp of the last sleep detection
 }
 
+/**
+ * Structure to track TLS session information for proper resumption handling
+ */
+interface ITlsSessionInfo {
+  domain: string;         // The SNI domain associated with this session
+  sessionId?: Buffer;     // The TLS session ID (if available)
+  ticketId?: string;      // Session ticket identifier for newer TLS versions
+  ticketTimestamp: number; // When this session was recorded
+}
+
+// Global cache of TLS session IDs to SNI domains
+// This ensures resumed sessions maintain their SNI binding
+const tlsSessionCache = new Map<string, ITlsSessionInfo>();
+
+// Reference to session cleanup timer so we can clear it
+let tlsSessionCleanupTimer: NodeJS.Timeout | null = null;
+
+// Start the cleanup timer for session cache
+function startSessionCleanupTimer() {
+  // Avoid creating multiple timers
+  if (tlsSessionCleanupTimer) {
+    clearInterval(tlsSessionCleanupTimer);
+  }
+  
+  // Create new cleanup timer
+  tlsSessionCleanupTimer = setInterval(() => {
+    const now = Date.now();
+    const expiryTime = 24 * 60 * 60 * 1000; // 24 hours
+    
+    for (const [sessionId, info] of tlsSessionCache.entries()) {
+      if (now - info.ticketTimestamp > expiryTime) {
+        tlsSessionCache.delete(sessionId);
+      }
+    }
+  }, 60 * 60 * 1000); // Clean up once per hour
+  
+  // Make sure the interval doesn't keep the process alive
+  if (tlsSessionCleanupTimer.unref) {
+    tlsSessionCleanupTimer.unref();
+  }
+}
+
+// Start the timer initially
+startSessionCleanupTimer();
+
+// Function to stop the cleanup timer (used during shutdown)
+function stopSessionCleanupTimer() {
+  if (tlsSessionCleanupTimer) {
+    clearInterval(tlsSessionCleanupTimer);
+    tlsSessionCleanupTimer = null;
+  }
+}
+
+/**
+ * Return type for the extractSNIInfo function
+ */
+interface ISNIExtractResult {
+  serverName?: string;      // The extracted SNI hostname
+  sessionId?: Buffer;       // The TLS session ID if present
+  sessionIdKey?: string;    // The hex string representation of session ID
+  sessionTicketId?: string; // Session ticket identifier for TLS 1.3+ resumption
+  hasSessionTicket?: boolean; // Whether a session ticket extension was found
+  isResumption: boolean;    // Whether this appears to be a session resumption
+  resumedDomain?: string;   // The domain associated with the session if resuming
+}
+
 /**
  * Extracts the SNI (Server Name Indication) from a TLS ClientHello packet.
  * Enhanced for robustness and detailed logging.
+ * Also extracts and tracks TLS Session IDs for session resumption handling.
+ * 
  * @param buffer - Buffer containing the TLS ClientHello.
  * @param enableLogging - Whether to enable detailed logging.
- * @returns The server name if found, otherwise undefined.
+ * @returns An object containing SNI and session information, or undefined if parsing fails.
  */
-function extractSNI(buffer: Buffer, enableLogging: boolean = false): string | undefined {
+function extractSNIInfo(buffer: Buffer, enableLogging: boolean = false): ISNIExtractResult | undefined {
   try {
     // Check if buffer is too small for TLS
     if (buffer.length < 5) {
@@ -153,9 +221,38 @@ function extractSNI(buffer: Buffer, enableLogging: boolean = false): string | un
 
     offset += 2 + 32; // Skip client version and random
 
-    // Session ID
+    // Extract Session ID for session resumption tracking
     const sessionIDLength = buffer.readUInt8(offset);
     if (enableLogging) console.log(`Session ID Length: ${sessionIDLength}`);
+    
+    // If there's a session ID, extract it
+    let sessionId: Buffer | undefined;
+    let sessionIdKey: string | undefined;
+    let isResumption = false;
+    let resumedDomain: string | undefined;
+    
+    if (sessionIDLength > 0) {
+      sessionId = Buffer.from(buffer.slice(offset + 1, offset + 1 + sessionIDLength));
+      
+      // Convert sessionId to a string key for our cache
+      sessionIdKey = sessionId.toString('hex');
+      
+      if (enableLogging) {
+        console.log(`Session ID: ${sessionIdKey}`);
+      }
+      
+      // Check if this is a session resumption attempt
+      if (tlsSessionCache.has(sessionIdKey)) {
+        const cachedInfo = tlsSessionCache.get(sessionIdKey)!;
+        resumedDomain = cachedInfo.domain;
+        isResumption = true;
+        
+        if (enableLogging) {
+          console.log(`TLS Session Resumption detected for domain: ${resumedDomain}`);
+        }
+      }
+    }
+    
     offset += 1 + sessionIDLength; // Skip session ID
 
     // Cipher suites
@@ -194,6 +291,10 @@ function extractSNI(buffer: Buffer, enableLogging: boolean = false): string | un
       return undefined;
     }
 
+    // Variables to track session tickets
+    let hasSessionTicket = false;
+    let sessionTicketId: string | undefined;
+    
     // Parse extensions
     while (offset + 4 <= extensionsEnd) {
       const extensionType = buffer.readUInt16BE(offset);
@@ -203,6 +304,33 @@ function extractSNI(buffer: Buffer, enableLogging: boolean = false): string | un
         console.log(`Extension Type: 0x${extensionType.toString(16)}, Length: ${extensionLength}`);
 
       offset += 4;
+      
+      // Check for Session Ticket extension (type 0x0023)
+      if (extensionType === 0x0023 && extensionLength > 0) {
+        hasSessionTicket = true;
+        
+        // Extract a hash of the ticket for tracking
+        if (extensionLength > 16) { // Ensure we have enough bytes to create a meaningful ID
+          const ticketBytes = buffer.slice(offset, offset + Math.min(16, extensionLength));
+          sessionTicketId = ticketBytes.toString('hex');
+          
+          if (enableLogging) {
+            console.log(`Session Ticket found, ID: ${sessionTicketId}`);
+            
+            // Check if this is a known session ticket
+            if (tlsSessionCache.has(`ticket:${sessionTicketId}`)) {
+              const cachedInfo = tlsSessionCache.get(`ticket:${sessionTicketId}`);
+              console.log(`TLS Session Ticket Resumption detected for domain: ${cachedInfo?.domain}`);
+              
+              // Set isResumption and resumedDomain if not already set
+              if (!isResumption && !resumedDomain) {
+                isResumption = true;
+                resumedDomain = cachedInfo?.domain;
+              }
+            }
+          }
+        }
+      }
 
       if (extensionType === 0x0000) {
         // SNI extension
@@ -245,7 +373,43 @@ function extractSNI(buffer: Buffer, enableLogging: boolean = false): string | un
 
             const serverName = buffer.toString('utf8', offset, offset + nameLen);
             if (enableLogging) console.log(`Extracted SNI: ${serverName}`);
-            return serverName;
+            
+            // Store the session ID to domain mapping for future resumptions
+            if (sessionIdKey && sessionId && serverName) {
+              tlsSessionCache.set(sessionIdKey, {
+                domain: serverName,
+                sessionId: sessionId,
+                ticketTimestamp: Date.now()
+              });
+              
+              if (enableLogging) {
+                console.log(`Stored session ${sessionIdKey} for domain ${serverName}`);
+              }
+            }
+            
+            // Also store session ticket information if present
+            if (sessionTicketId && serverName) {
+              tlsSessionCache.set(`ticket:${sessionTicketId}`, {
+                domain: serverName,
+                ticketId: sessionTicketId,
+                ticketTimestamp: Date.now()
+              });
+              
+              if (enableLogging) {
+                console.log(`Stored session ticket ${sessionTicketId} for domain ${serverName}`);
+              }
+            }
+            
+            // Return the complete extraction result
+            return {
+              serverName,
+              sessionId,
+              sessionIdKey,
+              sessionTicketId,
+              isResumption,
+              resumedDomain,
+              hasSessionTicket
+            };
           }
 
           offset += nameLen;
@@ -257,13 +421,46 @@ function extractSNI(buffer: Buffer, enableLogging: boolean = false): string | un
     }
 
     if (enableLogging) console.log('No SNI extension found');
-    return undefined;
+    
+    // Even without SNI, we might be dealing with a session resumption
+    if (isResumption && resumedDomain) {
+      return {
+        serverName: resumedDomain, // Use the domain from previous session
+        sessionId,
+        sessionIdKey,
+        sessionTicketId,
+        hasSessionTicket,
+        isResumption: true,
+        resumedDomain
+      };
+    }
+    
+    // Return a basic result with just the session info
+    return {
+      isResumption,
+      sessionId,
+      sessionIdKey,
+      sessionTicketId,
+      hasSessionTicket,
+      resumedDomain
+    };
   } catch (err) {
     console.log(`Error extracting SNI: ${err}`);
     return undefined;
   }
 }
 
+/**
+ * Legacy wrapper for extractSNIInfo to maintain backward compatibility
+ * @param buffer - Buffer containing the TLS ClientHello
+ * @param enableLogging - Whether to enable detailed logging
+ * @returns The server name if found, otherwise undefined
+ */
+function extractSNI(buffer: Buffer, enableLogging: boolean = false): string | undefined {
+  const result = extractSNIInfo(buffer, enableLogging);
+  return result?.serverName;
+}
+
 // Helper: Check if a port falls within any of the given port ranges
 const isPortInRanges = (port: number, ranges: Array<{ from: number; to: number }>): boolean => {
   return ranges.some((range) => port >= range.from && port <= range.to);
@@ -501,28 +698,17 @@ export class PortProxy {
         }
         this.cleanupConnection(record, 'client_closed');
       });
-
-      // Update activity on data transfer
+      
+      // Special handler for TLS handshake detection with NetworkProxy
       socket.on('data', (chunk: Buffer) => {
-        this.updateActivity(record);
-
-        // Check for potential TLS renegotiation or reconnection packets
+        // Check for TLS handshake packets (ContentType.handshake)
         if (chunk.length > 0 && chunk[0] === 22) {
-          // ContentType.handshake
-          if (this.settings.enableDetailedLogging) {
-            console.log(
-              `[${connectionId}] Detected potential TLS handshake data while connected to NetworkProxy`
-            );
-          }
-
-          // NOTE: We don't need to explicitly forward the renegotiation packets
-          // because socket.pipe(proxySocket) is already handling that.
-          // The pipe ensures all data (including renegotiation) flows through properly.
-          // Just update the activity timestamp to prevent timeouts
-          record.lastActivity = Date.now();
+          console.log(`[${connectionId}] Detected potential TLS handshake with NetworkProxy, updating activity`);
+          this.updateActivity(record);
         }
       });
 
+      // Update activity on data transfer from the proxy socket
       proxySocket.on('data', () => this.updateActivity(record));
 
       if (this.settings.enableDetailedLogging) {
@@ -778,6 +964,82 @@ export class PortProxy {
             return this.initiateCleanupOnce(record, 'write_error');
           }
 
+          // Set up the renegotiation listener *before* piping if this is a TLS connection with SNI
+          if (serverName && record.isTLS) {
+            // This listener handles TLS renegotiation detection
+            socket.on('data', (renegChunk) => {
+              if (renegChunk.length > 0 && renegChunk.readUInt8(0) === 22) {
+                // Always update activity timestamp for any handshake packet
+                this.updateActivity(record);
+                
+                try {
+                  // Extract all TLS information including session resumption data
+                  const sniInfo = extractSNIInfo(renegChunk, this.settings.enableTlsDebugLogging);
+                  let newSNI = sniInfo?.serverName;
+                  
+                  // Handle session resumption - if we recognize the session ID, we know what domain it belongs to
+                  if (sniInfo?.isResumption && sniInfo.resumedDomain) {
+                    console.log(`[${connectionId}] Rehandshake with session resumption for domain: ${sniInfo.resumedDomain}`);
+                    newSNI = sniInfo.resumedDomain;
+                  }
+                  
+                  // IMPORTANT: If we can't extract an SNI from renegotiation, we MUST allow it through
+                  if (newSNI === undefined) {
+                    console.log(`[${connectionId}] Rehandshake detected without SNI, allowing it through.`);
+                    return;
+                  }
+                  
+                  // Check if the SNI has changed
+                  if (newSNI !== serverName) {
+                    console.log(`[${connectionId}] Rehandshake with different SNI: ${newSNI} vs original ${serverName}`);
+                    
+                    // Allow if the new SNI matches existing domain config or find a new matching config
+                    let allowed = false;
+                    
+                    if (record.domainConfig) {
+                      allowed = record.domainConfig.domains.some(d => plugins.minimatch(newSNI, d));
+                    }
+                    
+                    if (!allowed) {
+                      const newDomainConfig = this.settings.domainConfigs.find((config) =>
+                        config.domains.some((d) => plugins.minimatch(newSNI, d))
+                      );
+                      
+                      if (newDomainConfig) {
+                        const effectiveAllowedIPs = [
+                          ...newDomainConfig.allowedIPs,
+                          ...(this.settings.defaultAllowedIPs || []),
+                        ];
+                        const effectiveBlockedIPs = [
+                          ...(newDomainConfig.blockedIPs || []),
+                          ...(this.settings.defaultBlockedIPs || []),
+                        ];
+                        
+                        allowed = isGlobIPAllowed(record.remoteIP, effectiveAllowedIPs, effectiveBlockedIPs);
+                        
+                        if (allowed) {
+                          record.domainConfig = newDomainConfig;
+                        }
+                      }
+                    }
+                    
+                    if (allowed) {
+                      console.log(`[${connectionId}] Updated domain for connection from ${record.remoteIP} to: ${newSNI}`);
+                      record.lockedDomain = newSNI;
+                    } else {
+                      console.log(`[${connectionId}] Rehandshake SNI ${newSNI} not allowed. Terminating connection.`);
+                      this.initiateCleanupOnce(record, 'sni_mismatch');
+                    }
+                  } else {
+                    console.log(`[${connectionId}] Rehandshake with same SNI: ${newSNI}`);
+                  }
+                } catch (err) {
+                  console.log(`[${connectionId}] Error processing renegotiation: ${err}. Allowing to continue.`);
+                }
+              }
+            });
+          }
+          
           // Now set up piping for future data and resume the socket
           socket.pipe(targetSocket);
           targetSocket.pipe(socket);
@@ -811,7 +1073,83 @@ export class PortProxy {
           }
         });
       } else {
-        // No pending data, so just set up piping
+        // Set up the renegotiation listener *before* piping if this is a TLS connection with SNI
+        if (serverName && record.isTLS) {
+          // This listener handles TLS renegotiation detection
+          socket.on('data', (renegChunk) => {
+            if (renegChunk.length > 0 && renegChunk.readUInt8(0) === 22) {
+              // Always update activity timestamp for any handshake packet
+              this.updateActivity(record);
+              
+              try {
+                // Extract all TLS information including session resumption data
+                const sniInfo = extractSNIInfo(renegChunk, this.settings.enableTlsDebugLogging);
+                let newSNI = sniInfo?.serverName;
+                
+                // Handle session resumption - if we recognize the session ID, we know what domain it belongs to
+                if (sniInfo?.isResumption && sniInfo.resumedDomain) {
+                  console.log(`[${connectionId}] Rehandshake with session resumption for domain: ${sniInfo.resumedDomain}`);
+                  newSNI = sniInfo.resumedDomain;
+                }
+                
+                // IMPORTANT: If we can't extract an SNI from renegotiation, we MUST allow it through
+                if (newSNI === undefined) {
+                  console.log(`[${connectionId}] Rehandshake detected without SNI, allowing it through.`);
+                  return;
+                }
+                
+                // Check if the SNI has changed
+                if (newSNI !== serverName) {
+                  console.log(`[${connectionId}] Rehandshake with different SNI: ${newSNI} vs original ${serverName}`);
+                  
+                  // Allow if the new SNI matches existing domain config or find a new matching config
+                  let allowed = false;
+                  
+                  if (record.domainConfig) {
+                    allowed = record.domainConfig.domains.some(d => plugins.minimatch(newSNI, d));
+                  }
+                  
+                  if (!allowed) {
+                    const newDomainConfig = this.settings.domainConfigs.find((config) =>
+                      config.domains.some((d) => plugins.minimatch(newSNI, d))
+                    );
+                    
+                    if (newDomainConfig) {
+                      const effectiveAllowedIPs = [
+                        ...newDomainConfig.allowedIPs,
+                        ...(this.settings.defaultAllowedIPs || []),
+                      ];
+                      const effectiveBlockedIPs = [
+                        ...(newDomainConfig.blockedIPs || []),
+                        ...(this.settings.defaultBlockedIPs || []),
+                      ];
+                      
+                      allowed = isGlobIPAllowed(record.remoteIP, effectiveAllowedIPs, effectiveBlockedIPs);
+                      
+                      if (allowed) {
+                        record.domainConfig = newDomainConfig;
+                      }
+                    }
+                  }
+                  
+                  if (allowed) {
+                    console.log(`[${connectionId}] Updated domain for connection from ${record.remoteIP} to: ${newSNI}`);
+                    record.lockedDomain = newSNI;
+                  } else {
+                    console.log(`[${connectionId}] Rehandshake SNI ${newSNI} not allowed. Terminating connection.`);
+                    this.initiateCleanupOnce(record, 'sni_mismatch');
+                  }
+                } else {
+                  console.log(`[${connectionId}] Rehandshake with same SNI: ${newSNI}`);
+                }
+              } catch (err) {
+                console.log(`[${connectionId}] Error processing renegotiation: ${err}. Allowing to continue.`);
+              }
+            }
+          });
+        }
+        
+        // Now set up piping
         socket.pipe(targetSocket);
         targetSocket.pipe(socket);
         socket.resume(); // Resume the socket after piping is established
@@ -848,50 +1186,8 @@ export class PortProxy {
       record.pendingData = [];
       record.pendingDataSize = 0;
 
-      // Add the renegotiation listener for SNI validation
-      if (serverName) {
-        // This listener will check for TLS renegotiation attempts
-        // Note: We don't need to explicitly forward the renegotiation packets
-        // since socket.pipe(targetSocket) is already set up earlier and handles that
-        socket.on('data', (renegChunk: Buffer) => {
-          if (renegChunk.length > 0 && renegChunk.readUInt8(0) === 22) {
-            try {
-              // Try to extract SNI from potential renegotiation
-              const newSNI = extractSNI(renegChunk, this.settings.enableTlsDebugLogging);
-              
-              // IMPORTANT: If we can't extract an SNI from renegotiation, we MUST allow it through
-              // Otherwise valid renegotiations that don't explicitly repeat the SNI will break
-              if (newSNI === undefined) {
-                if (this.settings.enableDetailedLogging) {
-                  console.log(
-                    `[${connectionId}] Rehandshake detected without SNI, allowing it through.`
-                  );
-                }
-                // Let it pass through - this is critical for Chrome's TLS handling
-                return;
-              }
-              
-              // Only block if we positively identify a different SNI
-              if (newSNI && newSNI !== record.lockedDomain) {
-                console.log(
-                  `[${connectionId}] Rehandshake detected with different SNI: ${newSNI} vs locked ${record.lockedDomain}. Terminating connection.`
-                );
-                this.initiateCleanupOnce(record, 'sni_mismatch');
-              } else if (newSNI && this.settings.enableDetailedLogging) {
-                console.log(
-                  `[${connectionId}] Rehandshake detected with same SNI: ${newSNI}. Allowing.`
-                );
-              }
-            } catch (err) {
-              // Always allow the renegotiation to continue if we encounter an error
-              // This ensures Chrome can complete its TLS renegotiation
-              console.log(
-                `[${connectionId}] Error processing potential renegotiation: ${err}. Allowing connection to continue.`
-              );
-            }
-          }
-        });
-      }
+      // Renegotiation detection is now handled before piping is established
+      // This ensures the data listener receives all packets properly
 
       // Set connection timeout with simpler logic
       if (record.cleanupTimer) {
@@ -1621,6 +1917,12 @@ export class PortProxy {
 
         // Save domain config in connection record
         connectionRecord.domainConfig = domainConfig;
+        
+        // Always set the lockedDomain, even for non-SNI connections
+        if (serverName) {
+          connectionRecord.lockedDomain = serverName;
+          console.log(`[${connectionId}] Locked connection to domain: ${serverName}`);
+        }
 
         // IP validation is skipped if allowedIPs is empty
         if (domainConfig) {
@@ -1789,7 +2091,17 @@ export class PortProxy {
               );
             }
 
-            serverName = extractSNI(chunk, this.settings.enableTlsDebugLogging) || '';
+            // Extract all TLS information including session resumption
+            const sniInfo = extractSNIInfo(chunk, this.settings.enableTlsDebugLogging);
+            
+            if (sniInfo?.isResumption && sniInfo.resumedDomain) {
+              // This is a session resumption with a known domain
+              serverName = sniInfo.resumedDomain;
+              console.log(`[${connectionId}] TLS Session resumption detected for domain: ${serverName}`);
+            } else {
+              // Normal SNI extraction
+              serverName = sniInfo?.serverName || '';
+            }
           }
 
           // Lock the connection to the negotiated SNI.
@@ -2105,6 +2417,9 @@ export class PortProxy {
   public async stop() {
     console.log('PortProxy shutting down...');
     this.isShuttingDown = true;
+    
+    // Stop the session cleanup timer
+    stopSessionCleanupTimer();
 
     // Stop accepting new connections
     const closeServerPromises: Promise<void>[] = this.netServers.map(