3.41.5

changelog.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## 2025-03-12 - 3.41.5 - fix(portproxy)
+Enforce TLS handshake and SNI validation on port 443 by blocking non-TLS connections and terminating session resumption attempts without SNI when allowSessionTicket is disabled.
+
+- Added explicit check to block non-TLS connections on port 443 to ensure proper TLS usage.
+- Enhanced logging for TLS ClientHello to include details on SNI extraction and session resumption status.
+- Terminate connections with missing SNI by setting termination reasons ('session_ticket_blocked' or 'no_sni_blocked').
+- Ensured consistent rejection of non-TLS handshakes on standard HTTPS port.
+
+## 2025-03-12 - 3.41.4 - fix(tls/sni)
+Improve logging for TLS session resumption by extracting and logging SNI values from ClientHello messages.
+
+- Added logging to output the extracted SNI value during renegotiation, initial ClientHello and in the SNI handler.
+- Enhanced error handling during SNI extraction to aid troubleshooting of TLS session resumption issues.
+
+## 2025-03-12 - 3.41.3 - fix(TLS/SNI)
+Improve TLS session resumption handling and logging. Now, session resumption attempts are always logged with details, and connections without a proper SNI are rejected when allowSessionTicket is disabled. In addition, empty SNI extensions are explicitly treated as missing, ensuring stricter and more consistent TLS handshake validation.
+
+- Always log session resumption in both renegotiation and initial ClientHello processing.
+- Terminate connections that attempt session resumption without SNI when allowSessionTicket is false.
+- Treat empty SNI extensions as absence of SNI to improve consistency in TLS handshake processing.
+
+## 2025-03-11 - 3.41.2 - fix(SniHandler)
+Refactor hasSessionResumption to return detailed session resumption info
+
+- Changed the return type of hasSessionResumption from boolean to an object with properties isResumption and hasSNI
+- Updated early return conditions to return { isResumption: false, hasSNI: false } when buffer is too short or invalid
+- Modified corresponding documentation to reflect the new return type
+
 ## 2025-03-11 - 3.41.1 - fix(SniHandler)
 Improve TLS SNI session resumption handling: connections containing a session ticket are now only rejected when no SNI is present and allowSessionTicket is disabled. Updated return values and logging for clearer resumption detection.
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartproxy",
-  "version": "3.41.1",
+  "version": "3.41.5",
   "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",

ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartproxy',
-  version: '3.41.1',
+  version: '3.41.5',
   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.'
 }

ts/classes.portproxy.ts

@@ -943,20 +943,32 @@ export class PortProxy {
                 // Analyze for session resumption attempt (session ticket or PSK)
                 const resumptionInfo = SniHandler.hasSessionResumption(renegChunk, this.settings.enableTlsDebugLogging);
                 
-                // Only block if there's a session ticket without SNI
-                if (resumptionInfo.isResumption && !resumptionInfo.hasSNI) {
+                if (resumptionInfo.isResumption) {
+                  // Always log resumption attempt for easier debugging
+                  // Try to extract SNI for logging
+                  const extractedSNI = SniHandler.extractSNI(renegChunk, this.settings.enableTlsDebugLogging);
                   console.log(
-                    `[${connectionId}] Session ticket detected in renegotiation without SNI and allowSessionTicket=false. ` +
-                    `Terminating connection to force new TLS handshake.`
+                    `[${connectionId}] Session resumption detected in renegotiation. ` +
+                    `Has SNI: ${resumptionInfo.hasSNI ? 'Yes' : 'No'}, ` +
+                    `SNI value: ${extractedSNI || 'None'}, ` +
+                    `allowSessionTicket: ${this.settings.allowSessionTicket}`
                   );
-                  this.initiateCleanupOnce(record, 'session_ticket_blocked');
-                  return;
-                } else if (resumptionInfo.isResumption && resumptionInfo.hasSNI) {
-                  if (this.settings.enableTlsDebugLogging) {
+                  
+                  // Block if there's session resumption without SNI
+                  if (!resumptionInfo.hasSNI) {
                     console.log(
-                      `[${connectionId}] Session ticket with SNI detected in renegotiation. ` +
-                      `Allowing connection since SNI is present.`
+                      `[${connectionId}] Session resumption detected in renegotiation without SNI and allowSessionTicket=false. ` +
+                      `Terminating connection to force new TLS handshake.`
                     );
+                    this.initiateCleanupOnce(record, 'session_ticket_blocked');
+                    return;
+                  } else {
+                    if (this.settings.enableDetailedLogging) {
+                      console.log(
+                        `[${connectionId}] Session resumption with SNI detected in renegotiation. ` +
+                        `Allowing connection since SNI is present.`
+                      );
+                    }
                   }
                 }
               }
@@ -1565,20 +1577,48 @@ export class PortProxy {
 
           initialDataReceived = true;
           connectionRecord.hasReceivedInitialData = true;
+          
+          // Block non-TLS connections on port 443
+          // Always enforce TLS on standard HTTPS port
+          if (!SniHandler.isTlsHandshake(chunk) && localPort === 443) {
+            console.log(
+              `[${connectionId}] Non-TLS connection detected on port 443. ` +
+              `Terminating connection - only TLS traffic is allowed on standard HTTPS port.`
+            );
+            if (connectionRecord.incomingTerminationReason === null) {
+              connectionRecord.incomingTerminationReason = 'non_tls_blocked';
+              this.incrementTerminationStat('incoming', 'non_tls_blocked');
+            }
+            socket.end();
+            this.cleanupConnection(connectionRecord, 'non_tls_blocked');
+            return;
+          }
 
           // Check if this looks like a TLS handshake
           if (SniHandler.isTlsHandshake(chunk)) {
             connectionRecord.isTLS = true;
             
-            // Check for session tickets if allowSessionTicket is disabled
+            // Check for TLS ClientHello with either no SNI or session tickets
             if (this.settings.allowSessionTicket === false && SniHandler.isClientHello(chunk)) {
+              // Extract SNI first
+              const extractedSNI = SniHandler.extractSNI(chunk, this.settings.enableTlsDebugLogging);
+              const hasSNI = !!extractedSNI;
+              
               // Analyze for session resumption attempt
               const resumptionInfo = SniHandler.hasSessionResumption(chunk, this.settings.enableTlsDebugLogging);
               
-              // Only block if there's a session ticket without SNI
-              if (resumptionInfo.isResumption && !resumptionInfo.hasSNI) {
+              // Always log for debugging purposes
+              console.log(
+                `[${connectionId}] TLS ClientHello detected with allowSessionTicket=false. ` +
+                `Has SNI: ${hasSNI ? 'Yes' : 'No'}, ` +
+                `SNI value: ${extractedSNI || 'None'}, ` +
+                `Has session resumption: ${resumptionInfo.isResumption ? 'Yes' : 'No'}`
+              );
+              
+              // Block if this is a connection with session resumption but no SNI
+              if (resumptionInfo.isResumption && !hasSNI) {
                 console.log(
-                  `[${connectionId}] Session ticket detected in initial ClientHello without SNI and allowSessionTicket=false. ` +
+                  `[${connectionId}] Session resumption detected in initial ClientHello without SNI and allowSessionTicket=false. ` +
                   `Terminating connection to force new TLS handshake.`
                 );
                 if (connectionRecord.incomingTerminationReason === null) {
@@ -1588,13 +1628,22 @@ export class PortProxy {
                 socket.end();
                 this.cleanupConnection(connectionRecord, 'session_ticket_blocked');
                 return;
-              } else if (resumptionInfo.isResumption && resumptionInfo.hasSNI) {
-                if (this.settings.enableTlsDebugLogging) {
-                  console.log(
-                    `[${connectionId}] Session ticket with SNI detected in initial ClientHello. ` +
-                    `Allowing connection since SNI is present.`
-                  );
+              }
+              
+              // Also block if this is a TLS connection without SNI when allowSessionTicket is false
+              // This forces clients to send SNI which helps with routing
+              if (!hasSNI && localPort === 443) {
+                console.log(
+                  `[${connectionId}] TLS ClientHello detected on port 443 without SNI and allowSessionTicket=false. ` +
+                  `Terminating connection to force proper SNI in handshake.`
+                );
+                if (connectionRecord.incomingTerminationReason === null) {
+                  connectionRecord.incomingTerminationReason = 'no_sni_blocked';
+                  this.incrementTerminationStat('incoming', 'no_sni_blocked');
                 }
+                socket.end();
+                this.cleanupConnection(connectionRecord, 'no_sni_blocked');
+                return;
               }
             }
             
@@ -1931,6 +1980,22 @@ export class PortProxy {
             }
 
             initialDataReceived = true;
+            
+            // Block non-TLS connections on port 443
+            // Always enforce TLS on standard HTTPS port
+            if (!SniHandler.isTlsHandshake(chunk) && localPort === 443) {
+              console.log(
+                `[${connectionId}] Non-TLS connection detected on port 443 in SNI handler. ` +
+                `Terminating connection - only TLS traffic is allowed on standard HTTPS port.`
+              );
+              if (connectionRecord.incomingTerminationReason === null) {
+                connectionRecord.incomingTerminationReason = 'non_tls_blocked';
+                this.incrementTerminationStat('incoming', 'non_tls_blocked');
+              }
+              socket.end();
+              this.cleanupConnection(connectionRecord, 'non_tls_blocked');
+              return;
+            }
 
             // Try to extract SNI
             let serverName = '';
@@ -1949,25 +2014,37 @@ export class PortProxy {
                 // Analyze for session resumption attempt
                 const resumptionInfo = SniHandler.hasSessionResumption(chunk, this.settings.enableTlsDebugLogging);
                 
-                // Only block if there's a session ticket without SNI
-                if (resumptionInfo.isResumption && !resumptionInfo.hasSNI) {
+                if (resumptionInfo.isResumption) {
+                  // Always log resumption attempt for easier debugging
+                  // Try to extract SNI for logging
+                  const extractedSNI = SniHandler.extractSNI(chunk, this.settings.enableTlsDebugLogging);
                   console.log(
-                    `[${connectionId}] Session ticket detected in initial ClientHello without SNI and allowSessionTicket=false. ` +
-                    `Terminating connection to force new TLS handshake.`
+                    `[${connectionId}] Session resumption detected in SNI handler. ` +
+                    `Has SNI: ${resumptionInfo.hasSNI ? 'Yes' : 'No'}, ` +
+                    `SNI value: ${extractedSNI || 'None'}, ` +
+                    `allowSessionTicket: ${this.settings.allowSessionTicket}`
                   );
-                  if (connectionRecord.incomingTerminationReason === null) {
-                    connectionRecord.incomingTerminationReason = 'session_ticket_blocked';
-                    this.incrementTerminationStat('incoming', 'session_ticket_blocked');
-                  }
-                  socket.end();
-                  this.cleanupConnection(connectionRecord, 'session_ticket_blocked');
-                  return;
-                } else if (resumptionInfo.isResumption && resumptionInfo.hasSNI) {
-                  if (this.settings.enableTlsDebugLogging) {
+                  
+                  // Block if there's session resumption without SNI
+                  if (!resumptionInfo.hasSNI) {
                     console.log(
-                      `[${connectionId}] Session ticket with SNI detected in initial ClientHello. ` +
-                      `Allowing connection since SNI is present.`
+                      `[${connectionId}] Session resumption detected in SNI handler without SNI and allowSessionTicket=false. ` +
+                      `Terminating connection to force new TLS handshake.`
                     );
+                    if (connectionRecord.incomingTerminationReason === null) {
+                      connectionRecord.incomingTerminationReason = 'session_ticket_blocked';
+                      this.incrementTerminationStat('incoming', 'session_ticket_blocked');
+                    }
+                    socket.end();
+                    this.cleanupConnection(connectionRecord, 'session_ticket_blocked');
+                    return;
+                  } else {
+                    if (this.settings.enableDetailedLogging) {
+                      console.log(
+                        `[${connectionId}] Session resumption with SNI detected in SNI handler. ` +
+                        `Allowing connection since SNI is present.`
+                      );
+                    }
                   }
                 }
               }

ts/classes.snihandler.ts

@@ -285,12 +285,12 @@ export class SniHandler {
    * 
    * @param buffer - The buffer containing a ClientHello message
    * @param enableLogging - Whether to enable logging
-   * @returns true if the ClientHello contains session resumption mechanisms
+   * @returns Object containing details about session resumption and SNI presence
    */
   public static hasSessionResumption(
     buffer: Buffer,
     enableLogging: boolean = false
-  ): boolean {
+  ): { isResumption: boolean; hasSNI: boolean } {
     const log = (message: string) => {
       if (enableLogging) {
         console.log(`[Session Resumption] ${message}`);
@@ -298,7 +298,7 @@ export class SniHandler {
     };
     
     if (!this.isClientHello(buffer)) {
-      return false;
+      return { isResumption: false, hasSNI: false };
     }
     
     try {
@@ -306,7 +306,7 @@ export class SniHandler {
       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;
+      if (pos + 1 > buffer.length) return { isResumption: false, hasSNI: false };
       
       const sessionIdLength = buffer[pos];
       let hasNonEmptySessionId = sessionIdLength > 0;
@@ -319,17 +319,17 @@ export class SniHandler {
       pos += 1 + sessionIdLength;
       
       // Skip cipher suites
-      if (pos + 2 > buffer.length) return false;
+      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 false;
+      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 false;
+      if (pos + 2 > buffer.length) return { isResumption: false, hasSNI: false };
       
       // Look for session resumption extensions
       const extensionsLength = (buffer[pos] << 8) + buffer[pos + 1];
@@ -337,7 +337,7 @@ export class SniHandler {
       
       // Extensions end position
       const extensionsEnd = pos + extensionsLength;
-      if (extensionsEnd > buffer.length) return false;
+      if (extensionsEnd > buffer.length) return { isResumption: false, hasSNI: false };
       
       // Track resumption indicators
       let hasSessionTicket = false;
@@ -410,8 +410,42 @@ export class SniHandler {
                   pos += 2;
                   
                   if (extensionType === this.TLS_SNI_EXTENSION_TYPE) {
-                    hasSNI = true;
-                    log('Found SNI extension');
+                    // 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;
                   }
                   
@@ -438,6 +472,15 @@ export class SniHandler {
       }
       
       // 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