@serve.zone/dcrouter 2.12.4

package/test/suite/smtpserver_connection/test.cm-07.abrupt-disconnection.ts

@@ -0,0 +1,321 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import * as net from 'net';
+import { startTestServer, stopTestServer } from '../../helpers/server.loader.js'
+import type { ITestServer } from '../../helpers/server.loader.js';
+const TEST_PORT = 2525;
+const TEST_TIMEOUT = 30000;
+
+let testServer: ITestServer;
+
+tap.test('setup - start SMTP server for abrupt disconnection tests', async () => {
+  testServer = await startTestServer({ port: TEST_PORT });
+  await new Promise(resolve => setTimeout(resolve, 1000));
+});
+
+tap.test('Abrupt Disconnection - should handle socket destruction without QUIT', async (tools) => {
+  const done = tools.defer();
+  
+  try {
+    const socket = net.createConnection({
+      host: 'localhost',
+      port: TEST_PORT,
+      timeout: TEST_TIMEOUT
+    });
+    
+    await new Promise<void>((resolve, reject) => {
+      socket.once('connect', () => resolve());
+      socket.once('error', reject);
+    });
+    
+    // Get banner
+    const banner = await new Promise<string>((resolve) => {
+      socket.once('data', (chunk) => resolve(chunk.toString()));
+    });
+    
+    expect(banner).toInclude('220');
+    
+    // Send EHLO
+    socket.write('EHLO testhost\r\n');
+    
+    await new Promise<string>((resolve) => {
+      let data = '';
+      const handler = (chunk: Buffer) => {
+        data += chunk.toString();
+        if (data.includes('\r\n') && (data.match(/^250 /m) || data.match(/^250-.*\r\n250 /ms))) {
+          socket.removeListener('data', handler);
+          resolve(data);
+        }
+      };
+      socket.on('data', handler);
+    });
+    
+    // Abruptly disconnect without QUIT
+    console.log('Destroying socket without QUIT...');
+    socket.destroy();
+    
+    // Wait a moment for server to handle the disconnection
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    
+    // Test server recovery - try new connection
+    console.log('Testing server recovery with new connection...');
+    const recoverySocket = net.createConnection({
+      host: 'localhost',
+      port: TEST_PORT,
+      timeout: TEST_TIMEOUT
+    });
+    
+    const recoveryConnected = await new Promise<boolean>((resolve) => {
+      recoverySocket.once('connect', () => resolve(true));
+      recoverySocket.once('error', () => resolve(false));
+      setTimeout(() => resolve(false), 5000);
+    });
+    
+    expect(recoveryConnected).toEqual(true);
+    
+    if (recoveryConnected) {
+      // Get banner from recovery connection
+      const recoveryBanner = await new Promise<string>((resolve) => {
+        recoverySocket.once('data', (chunk) => resolve(chunk.toString()));
+      });
+      
+      expect(recoveryBanner).toInclude('220');
+      console.log('Server recovered successfully, accepting new connections');
+      
+      // Clean up recovery connection properly
+      recoverySocket.write('QUIT\r\n');
+      recoverySocket.end();
+    }
+    
+  } finally {
+    done.resolve();
+  }
+});
+
+tap.test('Abrupt Disconnection - should handle multiple simultaneous abrupt disconnections', async (tools) => {
+  const done = tools.defer();
+  
+  try {
+    const connections = 5;
+    const sockets: net.Socket[] = [];
+    
+    // Create multiple connections
+    for (let i = 0; i < connections; i++) {
+      const socket = net.createConnection({
+        host: 'localhost',
+        port: TEST_PORT,
+        timeout: TEST_TIMEOUT
+      });
+      
+      await new Promise<void>((resolve, reject) => {
+        socket.once('connect', () => resolve());
+        socket.once('error', reject);
+      });
+      
+      // Get banner
+      await new Promise<void>((resolve) => {
+        socket.once('data', () => resolve());
+      });
+      
+      sockets.push(socket);
+    }
+    
+    console.log(`Created ${connections} connections`);
+    
+    // Abruptly disconnect all at once
+    console.log('Destroying all sockets simultaneously...');
+    sockets.forEach(socket => socket.destroy());
+    
+    // Wait for server to handle disconnections
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    
+    // Test that server still accepts new connections
+    console.log('Testing server stability after multiple abrupt disconnections...');
+    const testSocket = net.createConnection({
+      host: 'localhost',
+      port: TEST_PORT,
+      timeout: TEST_TIMEOUT
+    });
+    
+    const stillAccepting = await new Promise<boolean>((resolve) => {
+      testSocket.once('connect', () => resolve(true));
+      testSocket.once('error', () => resolve(false));
+      setTimeout(() => resolve(false), 5000);
+    });
+    
+    expect(stillAccepting).toEqual(true);
+    
+    if (stillAccepting) {
+      const banner = await new Promise<string>((resolve) => {
+        testSocket.once('data', (chunk) => resolve(chunk.toString()));
+      });
+      
+      expect(banner).toInclude('220');
+      console.log('Server remained stable after multiple abrupt disconnections');
+      
+      testSocket.write('QUIT\r\n');
+      testSocket.end();
+    }
+    
+  } finally {
+    done.resolve();
+  }
+});
+
+tap.test('Abrupt Disconnection - should handle disconnection during DATA transfer', async (tools) => {
+  const done = tools.defer();
+  
+  try {
+    const socket = net.createConnection({
+      host: 'localhost',
+      port: TEST_PORT,
+      timeout: TEST_TIMEOUT
+    });
+    
+    await new Promise<void>((resolve, reject) => {
+      socket.once('connect', () => resolve());
+      socket.once('error', reject);
+    });
+    
+    // Get banner
+    await new Promise<string>((resolve) => {
+      socket.once('data', (chunk) => resolve(chunk.toString()));
+    });
+    
+    // Send EHLO
+    socket.write('EHLO testhost\r\n');
+    await new Promise<string>((resolve) => {
+      let data = '';
+      const handler = (chunk: Buffer) => {
+        data += chunk.toString();
+        if (data.includes('\r\n') && (data.match(/^250 /m) || data.match(/^250-.*\r\n250 /ms))) {
+          socket.removeListener('data', handler);
+          resolve(data);
+        }
+      };
+      socket.on('data', handler);
+    });
+    
+    // Send MAIL FROM
+    socket.write('MAIL FROM:<sender@example.com>\r\n');
+    await new Promise<string>((resolve) => {
+      socket.once('data', (chunk) => resolve(chunk.toString()));
+    });
+    
+    // Send RCPT TO
+    socket.write('RCPT TO:<recipient@example.com>\r\n');
+    await new Promise<string>((resolve) => {
+      socket.once('data', (chunk) => resolve(chunk.toString()));
+    });
+    
+    // Start DATA
+    socket.write('DATA\r\n');
+    const dataResponse = await new Promise<string>((resolve) => {
+      socket.once('data', (chunk) => resolve(chunk.toString()));
+    });
+    
+    expect(dataResponse).toInclude('354');
+    
+    // Send partial email data then disconnect abruptly
+    socket.write('From: sender@example.com\r\n');
+    socket.write('To: recipient@example.com\r\n');
+    socket.write('Subject: Test ');
+    
+    console.log('Disconnecting during DATA transfer...');
+    socket.destroy();
+    
+    // Wait for server to handle disconnection
+    await new Promise(resolve => setTimeout(resolve, 1500));
+    
+    // Verify server can handle new connections
+    const newSocket = net.createConnection({
+      host: 'localhost',
+      port: TEST_PORT,
+      timeout: TEST_TIMEOUT
+    });
+    
+    const canConnect = await new Promise<boolean>((resolve) => {
+      newSocket.once('connect', () => resolve(true));
+      newSocket.once('error', () => resolve(false));
+      setTimeout(() => resolve(false), 5000);
+    });
+    
+    expect(canConnect).toEqual(true);
+    
+    if (canConnect) {
+      const banner = await new Promise<string>((resolve) => {
+        newSocket.once('data', (chunk) => resolve(chunk.toString()));
+      });
+      
+      expect(banner).toInclude('220');
+      console.log('Server recovered from disconnection during DATA transfer');
+      
+      newSocket.write('QUIT\r\n');
+      newSocket.end();
+    }
+    
+  } finally {
+    done.resolve();
+  }
+});
+
+tap.test('Abrupt Disconnection - should timeout idle connections', async (tools) => {
+  const done = tools.defer();
+  
+  try {
+    const socket = net.createConnection({
+      host: 'localhost',
+      port: TEST_PORT,
+      timeout: TEST_TIMEOUT
+    });
+    
+    await new Promise<void>((resolve, reject) => {
+      socket.once('connect', () => resolve());
+      socket.once('error', reject);
+    });
+    
+    // Get banner
+    const banner = await new Promise<string>((resolve) => {
+      socket.once('data', (chunk) => resolve(chunk.toString()));
+    });
+    
+    expect(banner).toInclude('220');
+    console.log('Connected, now testing idle timeout...');
+    
+    // Don't send any commands and wait for server to potentially timeout
+    // Most servers have a timeout of 5-10 minutes, so we'll test shorter
+    let disconnectedByServer = false;
+    
+    socket.on('close', () => {
+      disconnectedByServer = true;
+    });
+    
+    socket.on('end', () => {
+      disconnectedByServer = true;
+    });
+    
+    // Wait 10 seconds to see if server has a short idle timeout
+    await new Promise(resolve => setTimeout(resolve, 10000));
+    
+    if (!disconnectedByServer) {
+      console.log('Server maintains idle connections (no short timeout detected)');
+      // Send QUIT to close gracefully
+      socket.write('QUIT\r\n');
+      socket.end();
+    } else {
+      console.log('Server disconnected idle connection');
+    }
+    
+    // Either behavior is acceptable
+    expect(true).toEqual(true);
+    
+  } finally {
+    done.resolve();
+  }
+});
+
+tap.test('cleanup - stop SMTP server', async () => {
+  await stopTestServer(testServer);
+  expect(true).toEqual(true);
+});
+
+export default tap.start();

package/test/suite/smtpserver_connection/test.cm-08.tls-versions.ts

@@ -0,0 +1,361 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import * as net from 'net';
+import * as tls from 'tls';
+import { startTestServer, stopTestServer, type ITestServer } from '../../helpers/server.loader.js';
+const TEST_PORT = 2525;
+const TEST_TIMEOUT = 30000;
+
+let testServer: ITestServer;
+
+tap.test('setup - start SMTP server with TLS support for version tests', async () => {
+  testServer = await startTestServer({ 
+    port: TEST_PORT,
+    tlsEnabled: true
+  });
+  
+  await new Promise(resolve => setTimeout(resolve, 1000));
+  expect(testServer).toBeDefined();
+});
+
+tap.test('TLS Versions - should support STARTTLS capability', async (tools) => {
+  const done = tools.defer();
+  
+  try {
+    const socket = net.createConnection({
+      host: 'localhost',
+      port: TEST_PORT,
+      timeout: TEST_TIMEOUT
+    });
+    
+    await new Promise<void>((resolve, reject) => {
+      socket.once('connect', () => resolve());
+      socket.once('error', reject);
+    });
+    
+    // Get banner
+    await new Promise<string>((resolve) => {
+      socket.once('data', (chunk) => resolve(chunk.toString()));
+    });
+    
+    // Send EHLO
+    socket.write('EHLO testhost\r\n');
+    
+    const ehloResponse = await new Promise<string>((resolve) => {
+      let data = '';
+      const handler = (chunk: Buffer) => {
+        data += chunk.toString();
+        if (data.includes('\r\n') && (data.match(/^250 /m) || data.match(/^250-.*\r\n250 /ms))) {
+          socket.removeListener('data', handler);
+          resolve(data);
+        }
+      };
+      socket.on('data', handler);
+    });
+    
+    console.log('EHLO response:', ehloResponse);
+    
+    // Check for STARTTLS support
+    const supportsStarttls = ehloResponse.includes('250-STARTTLS') || ehloResponse.includes('250 STARTTLS');
+    console.log('STARTTLS supported:', supportsStarttls);
+    
+    if (supportsStarttls) {
+      // Test STARTTLS upgrade
+      socket.write('STARTTLS\r\n');
+      
+      const starttlsResponse = await new Promise<string>((resolve) => {
+        socket.once('data', (chunk) => resolve(chunk.toString()));
+      });
+      
+      expect(starttlsResponse).toInclude('220');
+      console.log('STARTTLS ready response received');
+      
+      // Would upgrade to TLS here in a real implementation
+      // For testing, we just verify the capability
+    }
+    
+    // Clean up
+    socket.write('QUIT\r\n');
+    socket.end();
+    
+    // STARTTLS is optional but common
+    expect(true).toEqual(true);
+    
+  } finally {
+    done.resolve();
+  }
+});
+
+tap.test('TLS Versions - should support modern TLS versions via STARTTLS', async (tools) => {
+  const done = tools.defer();
+  
+  try {
+    // Test TLS 1.2 via STARTTLS
+    console.log('Testing TLS 1.2 support via STARTTLS...');
+    const tls12Result = await testTlsVersionViaStartTls('TLSv1.2', TEST_PORT);
+    console.log('TLS 1.2 result:', tls12Result);
+    
+    // Test TLS 1.3 via STARTTLS
+    console.log('Testing TLS 1.3 support via STARTTLS...');
+    const tls13Result = await testTlsVersionViaStartTls('TLSv1.3', TEST_PORT);
+    console.log('TLS 1.3 result:', tls13Result);
+    
+    // At least one modern version should be supported
+    const supportsModernTls = tls12Result.success || tls13Result.success;
+    expect(supportsModernTls).toEqual(true);
+    
+    if (tls12Result.success) {
+      console.log('TLS 1.2 supported with cipher:', tls12Result.cipher);
+    }
+    if (tls13Result.success) {
+      console.log('TLS 1.3 supported with cipher:', tls13Result.cipher);
+    }
+    
+  } finally {
+    done.resolve();
+  }
+});
+
+tap.test('TLS Versions - should reject obsolete TLS versions via STARTTLS', async (tools) => {
+  const done = tools.defer();
+  
+  try {
+    // Test TLS 1.0 (should be rejected by modern servers)
+    console.log('Testing TLS 1.0 (obsolete) via STARTTLS...');
+    const tls10Result = await testTlsVersionViaStartTls('TLSv1', TEST_PORT);
+    
+    // Test TLS 1.1 (should be rejected by modern servers)
+    console.log('Testing TLS 1.1 (obsolete) via STARTTLS...');
+    const tls11Result = await testTlsVersionViaStartTls('TLSv1.1', TEST_PORT);
+    
+    // Modern servers should reject these old versions
+    // But some might still support them for compatibility
+    console.log(`TLS 1.0 ${tls10Result.success ? 'accepted (legacy support)' : 'rejected (good)'}`);
+    console.log(`TLS 1.1 ${tls11Result.success ? 'accepted (legacy support)' : 'rejected (good)'}`);
+    
+    // Either behavior is acceptable - log the results
+    expect(true).toEqual(true);
+    
+  } finally {
+    done.resolve();
+  }
+});
+
+tap.test('TLS Versions - should provide cipher information via STARTTLS', async (tools) => {
+  const done = tools.defer();
+  
+  try {
+    // Connect to plain SMTP port
+    const socket = net.createConnection({
+      host: 'localhost',
+      port: TEST_PORT,
+      timeout: TEST_TIMEOUT
+    });
+    
+    await new Promise<void>((resolve, reject) => {
+      socket.once('connect', () => resolve());
+      socket.once('error', reject);
+    });
+    
+    // Get banner
+    await new Promise<string>((resolve) => {
+      socket.once('data', (chunk) => resolve(chunk.toString()));
+    });
+    
+    // Send EHLO
+    socket.write('EHLO testhost\r\n');
+    
+    const ehloResponse = await new Promise<string>((resolve) => {
+      let data = '';
+      const handler = (chunk: Buffer) => {
+        data += chunk.toString();
+        if (data.includes('\r\n') && (data.match(/^250 /m) || data.match(/^250-.*\r\n250 /ms))) {
+          socket.removeListener('data', handler);
+          resolve(data);
+        }
+      };
+      socket.on('data', handler);
+    });
+    
+    // Check for STARTTLS
+    if (!ehloResponse.includes('STARTTLS')) {
+      console.log('Server does not support STARTTLS - skipping cipher info test');
+      socket.write('QUIT\r\n');
+      socket.end();
+      done.resolve();
+      return;
+    }
+    
+    // Send STARTTLS
+    socket.write('STARTTLS\r\n');
+    
+    await new Promise<string>((resolve) => {
+      socket.once('data', (chunk) => resolve(chunk.toString()));
+    });
+    
+    // Upgrade to TLS
+    const tlsSocket = tls.connect({
+      socket: socket,
+      servername: 'localhost',
+      rejectUnauthorized: false
+    });
+    
+    await new Promise<void>((resolve, reject) => {
+      tlsSocket.once('secureConnect', () => resolve());
+      tlsSocket.once('error', reject);
+    });
+    
+    // Get connection details
+    const cipher = tlsSocket.getCipher();
+    const protocol = tlsSocket.getProtocol();
+    const authorized = tlsSocket.authorized;
+    
+    console.log('TLS connection established via STARTTLS:');
+    console.log('- Protocol:', protocol);
+    console.log('- Cipher:', cipher?.name);
+    console.log('- Key exchange:', cipher?.standardName);
+    console.log('- Authorized:', authorized);
+    
+    if (protocol) {
+      expect(typeof protocol).toEqual('string');
+    }
+    if (cipher) {
+      expect(cipher.name).toBeDefined();
+    }
+    
+    // Clean up
+    tlsSocket.write('QUIT\r\n');
+    tlsSocket.end();
+    
+  } finally {
+    done.resolve();
+  }
+});
+
+// Helper function to test specific TLS version via STARTTLS
+async function testTlsVersionViaStartTls(version: string, port: number): Promise<{success: boolean, cipher?: any, error?: string}> {
+  return new Promise(async (resolve) => {
+    try {
+      // Connect to plain SMTP port
+      const socket = net.createConnection({
+        host: 'localhost',
+        port: port,
+        timeout: 5000
+      });
+      
+      await new Promise<void>((socketResolve, socketReject) => {
+        socket.once('connect', () => socketResolve());
+        socket.once('error', socketReject);
+      });
+      
+      // Get banner
+      await new Promise<string>((bannerResolve) => {
+        socket.once('data', (chunk) => bannerResolve(chunk.toString()));
+      });
+      
+      // Send EHLO
+      socket.write('EHLO testhost\r\n');
+      
+      const ehloResponse = await new Promise<string>((ehloResolve) => {
+        let data = '';
+        const handler = (chunk: Buffer) => {
+          data += chunk.toString();
+          if (data.includes('\r\n') && (data.match(/^250 /m) || data.match(/^250-.*\r\n250 /ms))) {
+            socket.removeListener('data', handler);
+            ehloResolve(data);
+          }
+        };
+        socket.on('data', handler);
+      });
+      
+      // Check for STARTTLS
+      if (!ehloResponse.includes('STARTTLS')) {
+        socket.destroy();
+        resolve({
+          success: false,
+          error: 'STARTTLS not supported'
+        });
+        return;
+      }
+      
+      // Send STARTTLS
+      socket.write('STARTTLS\r\n');
+      
+      await new Promise<string>((starttlsResolve) => {
+        socket.once('data', (chunk) => starttlsResolve(chunk.toString()));
+      });
+      
+      // Set up TLS options with version constraints
+      const tlsOptions: any = {
+        socket: socket,
+        servername: 'localhost',
+        rejectUnauthorized: false
+      };
+      
+      // Set version constraints based on requested version
+      switch (version) {
+        case 'TLSv1':
+          tlsOptions.minVersion = 'TLSv1';
+          tlsOptions.maxVersion = 'TLSv1';
+          break;
+        case 'TLSv1.1':
+          tlsOptions.minVersion = 'TLSv1.1';
+          tlsOptions.maxVersion = 'TLSv1.1';
+          break;
+        case 'TLSv1.2':
+          tlsOptions.minVersion = 'TLSv1.2';
+          tlsOptions.maxVersion = 'TLSv1.2';
+          break;
+        case 'TLSv1.3':
+          tlsOptions.minVersion = 'TLSv1.3';
+          tlsOptions.maxVersion = 'TLSv1.3';
+          break;
+      }
+      
+      // Upgrade to TLS
+      const tlsSocket = tls.connect(tlsOptions);
+      
+      tlsSocket.once('secureConnect', () => {
+        const cipher = tlsSocket.getCipher();
+        const protocol = tlsSocket.getProtocol();
+        
+        tlsSocket.destroy();
+        resolve({
+          success: true,
+          cipher: {
+            name: cipher?.name,
+            standardName: cipher?.standardName,
+            protocol: protocol
+          }
+        });
+      });
+      
+      tlsSocket.once('error', (error) => {
+        resolve({
+          success: false,
+          error: error.message
+        });
+      });
+      
+      setTimeout(() => {
+        tlsSocket.destroy();
+        resolve({
+          success: false,
+          error: 'TLS handshake timeout'
+        });
+      }, 5000);
+      
+    } catch (error) {
+      resolve({
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error'
+      });
+    }
+  });
+}
+
+tap.test('cleanup - stop SMTP server', async () => {
+  await stopTestServer(testServer);
+  expect(true).toEqual(true);
+});
+
+export default tap.start();