@futdevpro/fsm-dynamo 1.16.4 → 1.16.7

package/scripts/crypto/stress-test-crypto.js

@@ -1,380 +1,380 @@
-/**
- * Crypto Stress Test - Valódi Világ Szimuláció
- * Teszteli a legkülönbözőbb edge case-eket és hosszú távú stabilitást
- */
-
-const { DyFM_Crypto } = require('../../build/_modules/crypto/index.js');
-const crypto = require('crypto');
-
-console.log('🔥 Crypto Stress Test - Valódi Világ Szimuláció\n');
-
-// Test 1: Különböző adattípusok és méretek
-console.log('1️⃣ Adattípus és Méret Stress Test:');
-const dataTypes = [
-  // Primitív típusok
-  'simple string',
-  42,
-  true,
-  null,
-  
-  // Komplex objektumok
-  { id: 1, name: 'test' },
-  [1, 2, 3, 'array'],
-  { nested: { deep: { value: true } } },
-  
-  // Nagy adatok
-  { data: 'x'.repeat(10000) }, // 10KB string
-  { array: Array.from({length: 1000}, (_, i) => i) }, // 1000 elemű tömb
-  
-  // Különleges karakterek
-  { hungarian: 'árvíztűrő tükörfúrógép' },
-  { chinese: '你好世界' },
-  { emoji: '🚀💻🔒🎯' },
-  { special: '!@#$%^&*()_+-=[]{}|;:,.<>?' },
-  
-  // Edge case-ek
-  { empty: {} },
-  { nulls: { a: null, b: null, c: null } },
-  { mixed: [null, '', 0, false, 'string', 123, true] } // Removed undefined as it gets filtered out
-];
-
-const testKey = 'stress-test-key-123';
-let allDataTypesPassed = true;
-
-dataTypes.forEach((data, index) => {
-  try {
-    console.log(`   Testing ${index + 1}: ${typeof data} - ${JSON.stringify(data).substring(0, 50)}...`);
-    const encrypted = DyFM_Crypto.encrypt(data, testKey);
-    const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
-    
-    // JSON.stringify összehasonlítás (null/undefined kezelés miatt)
-    const originalStr = JSON.stringify(data);
-    const decryptedStr = JSON.stringify(decrypted);
-    
-    if (originalStr !== decryptedStr) {
-      console.log(`   ❌ Test ${index + 1} failed: ${typeof data}`);
-      console.log(`      Original: ${originalStr.substring(0, 100)}...`);
-      console.log(`      Decrypted: ${decryptedStr.substring(0, 100)}...`);
-      allDataTypesPassed = false;
-    } else {
-      console.log(`   ✅ Test ${index + 1} passed: ${typeof data}`);
-    }
-  } catch (error) {
-    console.log(`   ❌ Test ${index + 1} crashed: ${typeof data} - ${error.message}`);
-    console.log(`      Data: ${JSON.stringify(data).substring(0, 100)}...`);
-    allDataTypesPassed = false;
-  }
-});
-
-console.log(`   Adattípusok teszt: ${allDataTypesPassed ? '✅ PASS' : '❌ FAIL'}`);
-
-// Test 2: Hosszú távú stabilitás szimuláció
-console.log('\n2️⃣ Hosszú Távú Stabilitás Szimuláció:');
-const longTermData = { id: 1, name: 'long-term-test', timestamp: new Date().toISOString() };
-const longTermKey = 'long-term-key-123';
-
-// 10,000 iteráció (valós életben ez évek lehet)
-const iterations = 10000;
-let longTermPassed = true;
-let lastEncrypted = null;
-
-console.log(`   Futtatás ${iterations.toLocaleString()} iteráció...`);
-
-for (let i = 0; i < iterations; i++) {
-  try {
-    const encrypted = DyFM_Crypto.encrypt(longTermData, longTermKey);
-    const decrypted = DyFM_Crypto.decrypt(encrypted, longTermKey);
-    
-    // Ellenőrizzük, hogy mindig ugyanazt kapjuk-e
-    if (lastEncrypted && lastEncrypted !== encrypted) {
-      console.log(`   ❌ Inkonzisztens eredmény iteráció ${i + 1}-nél`);
-      longTermPassed = false;
-      break;
-    }
-    
-    // Ellenőrizzük, hogy helyesen dekódolódik-e
-    if (JSON.stringify(decrypted) !== JSON.stringify(longTermData)) {
-      console.log(`   ❌ Dekódolási hiba iteráció ${i + 1}-nél`);
-      longTermPassed = false;
-      break;
-    }
-    
-    lastEncrypted = encrypted;
-    
-    // Progress jelzés
-    if ((i + 1) % 1000 === 0) {
-      process.stdout.write(`   ${i + 1}/${iterations} ✅\r`);
-    }
-  } catch (error) {
-    console.log(`\n   ❌ Hiba iteráció ${i + 1}-nél: ${error.message}`);
-    longTermPassed = false;
-    break;
-  }
-}
-
-console.log(`\n   Hosszú távú stabilitás: ${longTermPassed ? '✅ PASS' : '❌ FAIL'}`);
-
-// Test 3: Adatbázis szimuláció
-console.log('\n3️⃣ Adatbázis Szimuláció:');
-const dbScenarios = [
-  // MongoDB dokumentum
-  {
-    _id: '507f1f77bcf86cd799439011',
-    username: 'testuser',
-    email: 'test@example.com',
-    profile: {
-      firstName: 'John',
-      lastName: 'Doe',
-      age: 30,
-      preferences: {
-        theme: 'dark',
-        language: 'hu',
-        notifications: true
-      }
-    },
-    createdAt: new Date().toISOString(),
-    updatedAt: new Date().toISOString(),
-    __v: 0
-  },
-  
-  // PostgreSQL rekord
-  {
-    id: 1,
-    name: 'test_record',
-    description: 'This is a test record with special chars: áéíóöőúüű',
-    metadata: {
-      tags: ['test', 'demo', 'crypto'],
-      flags: [true, false, true],
-      numbers: [1, 2, 3, 4, 5]
-    },
-    created_at: '2024-01-01T00:00:00.000Z',
-    updated_at: '2024-12-31T23:59:59.999Z'
-  },
-  
-  // MySQL rekord
-  {
-    user_id: 12345,
-    username: 'mysql_user',
-    password_hash: 'hashed_password_123',
-    email: 'mysql@example.com',
-    is_active: 1,
-    last_login: '2024-12-31 23:59:59',
-    settings: JSON.stringify({
-      timezone: 'Europe/Budapest',
-      currency: 'HUF',
-      date_format: 'YYYY-MM-DD'
-    })
-  }
-];
-
-let dbTestPassed = true;
-dbScenarios.forEach((scenario, index) => {
-  try {
-    const encrypted = DyFM_Crypto.encrypt(scenario, testKey);
-    const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
-    
-    // Részletes összehasonlítás
-    const originalStr = JSON.stringify(scenario);
-    const decryptedStr = JSON.stringify(decrypted);
-    
-    if (originalStr !== decryptedStr) {
-      console.log(`   ❌ DB scenario ${index + 1} failed`);
-      console.log(`      Original keys: ${Object.keys(scenario).join(', ')}`);
-      console.log(`      Decrypted keys: ${Object.keys(decrypted).join(', ')}`);
-      dbTestPassed = false;
-    }
-  } catch (error) {
-    console.log(`   ❌ DB scenario ${index + 1} crashed: ${error.message}`);
-    dbTestPassed = false;
-  }
-});
-
-console.log(`   Adatbázis szimuláció: ${dbTestPassed ? '✅ PASS' : '❌ FAIL'}`);
-
-// Test 4: Hálózati kommunikáció szimuláció
-console.log('\n4️⃣ Hálózati Kommunikáció Szimuláció:');
-const networkScenarios = [
-  // HTTP Header
-  {
-    type: 'http_header',
-    data: {
-      'Authorization': 'Bearer token123',
-      'X-User-ID': 'user_456',
-      'X-Session-ID': 'session_789',
-      'X-Request-ID': crypto.randomUUID(),
-      'X-Timestamp': new Date().toISOString()
-    }
-  },
-  
-  // WebSocket üzenet
-  {
-    type: 'websocket_message',
-    data: {
-      event: 'user_action',
-      payload: {
-        action: 'button_click',
-        button_id: 'submit_form',
-        timestamp: Date.now(),
-        user_agent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
-      },
-      metadata: {
-        version: '1.0.0',
-        source: 'web_client',
-        correlation_id: crypto.randomUUID()
-      }
-    }
-  },
-  
-  // API Response
-  {
-    type: 'api_response',
-    data: {
-      success: true,
-      data: {
-        users: [
-          { id: 1, name: 'Alice', email: 'alice@example.com' },
-          { id: 2, name: 'Bob', email: 'bob@example.com' },
-          { id: 3, name: 'Charlie', email: 'charlie@example.com' }
-        ],
-        pagination: {
-          page: 1,
-          limit: 10,
-          total: 3,
-          has_next: false
-        }
-      },
-      timestamp: new Date().toISOString(),
-      request_id: crypto.randomUUID()
-    }
-  }
-];
-
-let networkTestPassed = true;
-networkScenarios.forEach((scenario, index) => {
-  try {
-    const encrypted = DyFM_Crypto.encrypt(scenario, testKey);
-    const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
-    
-    const originalStr = JSON.stringify(scenario);
-    const decryptedStr = JSON.stringify(decrypted);
-    
-    if (originalStr !== decryptedStr) {
-      console.log(`   ❌ Network scenario ${index + 1} failed: ${scenario.type}`);
-      networkTestPassed = false;
-    }
-  } catch (error) {
-    console.log(`   ❌ Network scenario ${index + 1} crashed: ${error.message}`);
-    networkTestPassed = false;
-  }
-});
-
-console.log(`   Hálózati kommunikáció: ${networkTestPassed ? '✅ PASS' : '❌ FAIL'}`);
-
-// Test 5: Különböző kulcsok és konfigurációk
-console.log('\n5️⃣ Különböző Kulcsok és Konfigurációk:');
-const keyScenarios = [
-  { key: 'simple-key', config: undefined },
-  { key: 'a'.repeat(100), config: undefined }, // 100 karakter hosszú
-  { key: 'special-chars!@#$%^&*()', config: undefined },
-  { key: 'unicode-ключ-世界', config: undefined },
-  { key: 'normal-key', config: { keyIterations: 500, keySize: 6 } },
-  { key: 'fast-key', config: { keyIterations: 100, keySize: 4 } },
-  { key: 'secure-key', config: { keyIterations: 2000, keySize: 10 } }
-];
-
-let keyTestPassed = true;
-const testData = { id: 1, name: 'key-test' };
-
-keyScenarios.forEach((scenario, index) => {
-  try {
-    const encrypted = DyFM_Crypto.encrypt(testData, scenario.key, scenario.config);
-    const decrypted = DyFM_Crypto.decrypt(encrypted, scenario.key, scenario.config);
-    
-    if (JSON.stringify(decrypted) !== JSON.stringify(testData)) {
-      console.log(`   ❌ Key scenario ${index + 1} failed: ${scenario.key.substring(0, 20)}...`);
-      keyTestPassed = false;
-    }
-  } catch (error) {
-    console.log(`   ❌ Key scenario ${index + 1} crashed: ${error.message}`);
-    keyTestPassed = false;
-  }
-});
-
-console.log(`   Kulcs és konfiguráció teszt: ${keyTestPassed ? '✅ PASS' : '❌ FAIL'}`);
-
-// Test 6: Memória és teljesítmény stress test
-console.log('\n6️⃣ Memória és Teljesítmény Stress Test:');
-const memoryData = { id: 1, data: 'x'.repeat(1000) }; // 1KB adat
-const memoryKey = 'memory-test-key';
-const memoryIterations = 10000;
-
-console.log(`   Futtatás ${memoryIterations.toLocaleString()} iteráció ${(memoryData.data.length / 1024).toFixed(1)}KB adattal...`);
-
-const startTime = Date.now();
-let memoryTestPassed = true;
-const encryptedResults = [];
-
-try {
-  for (let i = 0; i < memoryIterations; i++) {
-    const encrypted = DyFM_Crypto.encrypt(memoryData, memoryKey);
-    encryptedResults.push(encrypted);
-    
-    // Minden 1000. iterációban ellenőrizzük a memóriát
-    if ((i + 1) % 1000 === 0) {
-      const decrypted = DyFM_Crypto.decrypt(encrypted, memoryKey);
-      if (JSON.stringify(decrypted) !== JSON.stringify(memoryData)) {
-        console.log(`   ❌ Memória teszt hiba iteráció ${i + 1}-nél`);
-        memoryTestPassed = false;
-        break;
-      }
-      process.stdout.write(`   ${i + 1}/${memoryIterations} ✅\r`);
-    }
-  }
-} catch (error) {
-  console.log(`\n   ❌ Memória teszt crash: ${error.message}`);
-  memoryTestPassed = false;
-}
-
-const endTime = Date.now();
-const duration = endTime - startTime;
-const memoryUsage = process.memoryUsage();
-
-console.log(`\n   Memória teszt: ${memoryTestPassed ? '✅ PASS' : '❌ FAIL'}`);
-console.log(`   Időtartam: ${duration}ms`);
-console.log(`   Memória használat: ${(memoryUsage.heapUsed / 1024 / 1024).toFixed(2)}MB`);
-
-// Összesítés
-console.log('\n🎯 STRESS TEST ÖSSZESÍTÉS:');
-console.log('========================');
-
-const allTests = [
-  { name: 'Adattípusok', passed: allDataTypesPassed },
-  { name: 'Hosszú távú stabilitás', passed: longTermPassed },
-  { name: 'Adatbázis szimuláció', passed: dbTestPassed },
-  { name: 'Hálózati kommunikáció', passed: networkTestPassed },
-  { name: 'Kulcsok és konfigurációk', passed: keyTestPassed },
-  { name: 'Memória és teljesítmény', passed: memoryTestPassed }
-];
-
-const passedTests = allTests.filter(test => test.passed).length;
-const totalTests = allTests.length;
-
-allTests.forEach(test => {
-  console.log(`   ${test.passed ? '✅' : '❌'} ${test.name}`);
-});
-
-console.log(`\n📊 Eredmény: ${passedTests}/${totalTests} teszt sikeres`);
-console.log(`   Sikeresség: ${((passedTests / totalTests) * 100).toFixed(1)}%`);
-
-if (passedTests === totalTests) {
-  console.log('\n🎉 MINDEN TESZT SIKERES!');
-  console.log('   A kriptográfiai implementáció valóban stabil és megbízható!');
-  console.log('   Biztonságosan használható hosszú távon különböző rendszerek között.');
-} else {
-  console.log('\n⚠️   FIGYELEM: Néhány teszt nem sikerült!');
-  console.log('   A kriptográfiai implementáció további finomhangolásra szorul.');
-}
-
-// Memória tisztítás
-encryptedResults.length = 0;
+/**
+ * Crypto Stress Test - Valódi Világ Szimuláció
+ * Teszteli a legkülönbözőbb edge case-eket és hosszú távú stabilitást
+ */
+
+const { DyFM_Crypto } = require('../../build/_modules/crypto/index.js');
+const crypto = require('crypto');
+
+console.log('🔥 Crypto Stress Test - Valódi Világ Szimuláció\n');
+
+// Test 1: Különböző adattípusok és méretek
+console.log('1️⃣ Adattípus és Méret Stress Test:');
+const dataTypes = [
+  // Primitív típusok
+  'simple string',
+  42,
+  true,
+  null,
+  
+  // Komplex objektumok
+  { id: 1, name: 'test' },
+  [1, 2, 3, 'array'],
+  { nested: { deep: { value: true } } },
+  
+  // Nagy adatok
+  { data: 'x'.repeat(10000) }, // 10KB string
+  { array: Array.from({length: 1000}, (_, i) => i) }, // 1000 elemű tömb
+  
+  // Különleges karakterek
+  { hungarian: 'árvíztűrő tükörfúrógép' },
+  { chinese: '你好世界' },
+  { emoji: '🚀💻🔒🎯' },
+  { special: '!@#$%^&*()_+-=[]{}|;:,.<>?' },
+  
+  // Edge case-ek
+  { empty: {} },
+  { nulls: { a: null, b: null, c: null } },
+  { mixed: [null, '', 0, false, 'string', 123, true] } // Removed undefined as it gets filtered out
+];
+
+const testKey = 'stress-test-key-123';
+let allDataTypesPassed = true;
+
+dataTypes.forEach((data, index) => {
+  try {
+    console.log(`   Testing ${index + 1}: ${typeof data} - ${JSON.stringify(data).substring(0, 50)}...`);
+    const encrypted = DyFM_Crypto.encrypt(data, testKey);
+    const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
+    
+    // JSON.stringify összehasonlítás (null/undefined kezelés miatt)
+    const originalStr = JSON.stringify(data);
+    const decryptedStr = JSON.stringify(decrypted);
+    
+    if (originalStr !== decryptedStr) {
+      console.log(`   ❌ Test ${index + 1} failed: ${typeof data}`);
+      console.log(`      Original: ${originalStr.substring(0, 100)}...`);
+      console.log(`      Decrypted: ${decryptedStr.substring(0, 100)}...`);
+      allDataTypesPassed = false;
+    } else {
+      console.log(`   ✅ Test ${index + 1} passed: ${typeof data}`);
+    }
+  } catch (error) {
+    console.log(`   ❌ Test ${index + 1} crashed: ${typeof data} - ${error.message}`);
+    console.log(`      Data: ${JSON.stringify(data).substring(0, 100)}...`);
+    allDataTypesPassed = false;
+  }
+});
+
+console.log(`   Adattípusok teszt: ${allDataTypesPassed ? '✅ PASS' : '❌ FAIL'}`);
+
+// Test 2: Hosszú távú stabilitás szimuláció
+console.log('\n2️⃣ Hosszú Távú Stabilitás Szimuláció:');
+const longTermData = { id: 1, name: 'long-term-test', timestamp: new Date().toISOString() };
+const longTermKey = 'long-term-key-123';
+
+// 10,000 iteráció (valós életben ez évek lehet)
+const iterations = 10000;
+let longTermPassed = true;
+let lastEncrypted = null;
+
+console.log(`   Futtatás ${iterations.toLocaleString()} iteráció...`);
+
+for (let i = 0; i < iterations; i++) {
+  try {
+    const encrypted = DyFM_Crypto.encrypt(longTermData, longTermKey);
+    const decrypted = DyFM_Crypto.decrypt(encrypted, longTermKey);
+    
+    // Ellenőrizzük, hogy mindig ugyanazt kapjuk-e
+    if (lastEncrypted && lastEncrypted !== encrypted) {
+      console.log(`   ❌ Inkonzisztens eredmény iteráció ${i + 1}-nél`);
+      longTermPassed = false;
+      break;
+    }
+    
+    // Ellenőrizzük, hogy helyesen dekódolódik-e
+    if (JSON.stringify(decrypted) !== JSON.stringify(longTermData)) {
+      console.log(`   ❌ Dekódolási hiba iteráció ${i + 1}-nél`);
+      longTermPassed = false;
+      break;
+    }
+    
+    lastEncrypted = encrypted;
+    
+    // Progress jelzés
+    if ((i + 1) % 1000 === 0) {
+      process.stdout.write(`   ${i + 1}/${iterations} ✅\r`);
+    }
+  } catch (error) {
+    console.log(`\n   ❌ Hiba iteráció ${i + 1}-nél: ${error.message}`);
+    longTermPassed = false;
+    break;
+  }
+}
+
+console.log(`\n   Hosszú távú stabilitás: ${longTermPassed ? '✅ PASS' : '❌ FAIL'}`);
+
+// Test 3: Adatbázis szimuláció
+console.log('\n3️⃣ Adatbázis Szimuláció:');
+const dbScenarios = [
+  // MongoDB dokumentum
+  {
+    _id: '507f1f77bcf86cd799439011',
+    username: 'testuser',
+    email: 'test@example.com',
+    profile: {
+      firstName: 'John',
+      lastName: 'Doe',
+      age: 30,
+      preferences: {
+        theme: 'dark',
+        language: 'hu',
+        notifications: true
+      }
+    },
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    __v: 0
+  },
+  
+  // PostgreSQL rekord
+  {
+    id: 1,
+    name: 'test_record',
+    description: 'This is a test record with special chars: áéíóöőúüű',
+    metadata: {
+      tags: ['test', 'demo', 'crypto'],
+      flags: [true, false, true],
+      numbers: [1, 2, 3, 4, 5]
+    },
+    created_at: '2024-01-01T00:00:00.000Z',
+    updated_at: '2024-12-31T23:59:59.999Z'
+  },
+  
+  // MySQL rekord
+  {
+    user_id: 12345,
+    username: 'mysql_user',
+    password_hash: 'hashed_password_123',
+    email: 'mysql@example.com',
+    is_active: 1,
+    last_login: '2024-12-31 23:59:59',
+    settings: JSON.stringify({
+      timezone: 'Europe/Budapest',
+      currency: 'HUF',
+      date_format: 'YYYY-MM-DD'
+    })
+  }
+];
+
+let dbTestPassed = true;
+dbScenarios.forEach((scenario, index) => {
+  try {
+    const encrypted = DyFM_Crypto.encrypt(scenario, testKey);
+    const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
+    
+    // Részletes összehasonlítás
+    const originalStr = JSON.stringify(scenario);
+    const decryptedStr = JSON.stringify(decrypted);
+    
+    if (originalStr !== decryptedStr) {
+      console.log(`   ❌ DB scenario ${index + 1} failed`);
+      console.log(`      Original keys: ${Object.keys(scenario).join(', ')}`);
+      console.log(`      Decrypted keys: ${Object.keys(decrypted).join(', ')}`);
+      dbTestPassed = false;
+    }
+  } catch (error) {
+    console.log(`   ❌ DB scenario ${index + 1} crashed: ${error.message}`);
+    dbTestPassed = false;
+  }
+});
+
+console.log(`   Adatbázis szimuláció: ${dbTestPassed ? '✅ PASS' : '❌ FAIL'}`);
+
+// Test 4: Hálózati kommunikáció szimuláció
+console.log('\n4️⃣ Hálózati Kommunikáció Szimuláció:');
+const networkScenarios = [
+  // HTTP Header
+  {
+    type: 'http_header',
+    data: {
+      'Authorization': 'Bearer token123',
+      'X-User-ID': 'user_456',
+      'X-Session-ID': 'session_789',
+      'X-Request-ID': crypto.randomUUID(),
+      'X-Timestamp': new Date().toISOString()
+    }
+  },
+  
+  // WebSocket üzenet
+  {
+    type: 'websocket_message',
+    data: {
+      event: 'user_action',
+      payload: {
+        action: 'button_click',
+        button_id: 'submit_form',
+        timestamp: Date.now(),
+        user_agent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+      },
+      metadata: {
+        version: '1.0.0',
+        source: 'web_client',
+        correlation_id: crypto.randomUUID()
+      }
+    }
+  },
+  
+  // API Response
+  {
+    type: 'api_response',
+    data: {
+      success: true,
+      data: {
+        users: [
+          { id: 1, name: 'Alice', email: 'alice@example.com' },
+          { id: 2, name: 'Bob', email: 'bob@example.com' },
+          { id: 3, name: 'Charlie', email: 'charlie@example.com' }
+        ],
+        pagination: {
+          page: 1,
+          limit: 10,
+          total: 3,
+          has_next: false
+        }
+      },
+      timestamp: new Date().toISOString(),
+      request_id: crypto.randomUUID()
+    }
+  }
+];
+
+let networkTestPassed = true;
+networkScenarios.forEach((scenario, index) => {
+  try {
+    const encrypted = DyFM_Crypto.encrypt(scenario, testKey);
+    const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
+    
+    const originalStr = JSON.stringify(scenario);
+    const decryptedStr = JSON.stringify(decrypted);
+    
+    if (originalStr !== decryptedStr) {
+      console.log(`   ❌ Network scenario ${index + 1} failed: ${scenario.type}`);
+      networkTestPassed = false;
+    }
+  } catch (error) {
+    console.log(`   ❌ Network scenario ${index + 1} crashed: ${error.message}`);
+    networkTestPassed = false;
+  }
+});
+
+console.log(`   Hálózati kommunikáció: ${networkTestPassed ? '✅ PASS' : '❌ FAIL'}`);
+
+// Test 5: Különböző kulcsok és konfigurációk
+console.log('\n5️⃣ Különböző Kulcsok és Konfigurációk:');
+const keyScenarios = [
+  { key: 'simple-key', config: undefined },
+  { key: 'a'.repeat(100), config: undefined }, // 100 karakter hosszú
+  { key: 'special-chars!@#$%^&*()', config: undefined },
+  { key: 'unicode-ключ-世界', config: undefined },
+  { key: 'normal-key', config: { keyIterations: 500, keySize: 6 } },
+  { key: 'fast-key', config: { keyIterations: 100, keySize: 4 } },
+  { key: 'secure-key', config: { keyIterations: 2000, keySize: 10 } }
+];
+
+let keyTestPassed = true;
+const testData = { id: 1, name: 'key-test' };
+
+keyScenarios.forEach((scenario, index) => {
+  try {
+    const encrypted = DyFM_Crypto.encrypt(testData, scenario.key, scenario.config);
+    const decrypted = DyFM_Crypto.decrypt(encrypted, scenario.key, scenario.config);
+    
+    if (JSON.stringify(decrypted) !== JSON.stringify(testData)) {
+      console.log(`   ❌ Key scenario ${index + 1} failed: ${scenario.key.substring(0, 20)}...`);
+      keyTestPassed = false;
+    }
+  } catch (error) {
+    console.log(`   ❌ Key scenario ${index + 1} crashed: ${error.message}`);
+    keyTestPassed = false;
+  }
+});
+
+console.log(`   Kulcs és konfiguráció teszt: ${keyTestPassed ? '✅ PASS' : '❌ FAIL'}`);
+
+// Test 6: Memória és teljesítmény stress test
+console.log('\n6️⃣ Memória és Teljesítmény Stress Test:');
+const memoryData = { id: 1, data: 'x'.repeat(1000) }; // 1KB adat
+const memoryKey = 'memory-test-key';
+const memoryIterations = 10000;
+
+console.log(`   Futtatás ${memoryIterations.toLocaleString()} iteráció ${(memoryData.data.length / 1024).toFixed(1)}KB adattal...`);
+
+const startTime = Date.now();
+let memoryTestPassed = true;
+const encryptedResults = [];
+
+try {
+  for (let i = 0; i < memoryIterations; i++) {
+    const encrypted = DyFM_Crypto.encrypt(memoryData, memoryKey);
+    encryptedResults.push(encrypted);
+    
+    // Minden 1000. iterációban ellenőrizzük a memóriát
+    if ((i + 1) % 1000 === 0) {
+      const decrypted = DyFM_Crypto.decrypt(encrypted, memoryKey);
+      if (JSON.stringify(decrypted) !== JSON.stringify(memoryData)) {
+        console.log(`   ❌ Memória teszt hiba iteráció ${i + 1}-nél`);
+        memoryTestPassed = false;
+        break;
+      }
+      process.stdout.write(`   ${i + 1}/${memoryIterations} ✅\r`);
+    }
+  }
+} catch (error) {
+  console.log(`\n   ❌ Memória teszt crash: ${error.message}`);
+  memoryTestPassed = false;
+}
+
+const endTime = Date.now();
+const duration = endTime - startTime;
+const memoryUsage = process.memoryUsage();
+
+console.log(`\n   Memória teszt: ${memoryTestPassed ? '✅ PASS' : '❌ FAIL'}`);
+console.log(`   Időtartam: ${duration}ms`);
+console.log(`   Memória használat: ${(memoryUsage.heapUsed / 1024 / 1024).toFixed(2)}MB`);
+
+// Összesítés
+console.log('\n🎯 STRESS TEST ÖSSZESÍTÉS:');
+console.log('========================');
+
+const allTests = [
+  { name: 'Adattípusok', passed: allDataTypesPassed },
+  { name: 'Hosszú távú stabilitás', passed: longTermPassed },
+  { name: 'Adatbázis szimuláció', passed: dbTestPassed },
+  { name: 'Hálózati kommunikáció', passed: networkTestPassed },
+  { name: 'Kulcsok és konfigurációk', passed: keyTestPassed },
+  { name: 'Memória és teljesítmény', passed: memoryTestPassed }
+];
+
+const passedTests = allTests.filter(test => test.passed).length;
+const totalTests = allTests.length;
+
+allTests.forEach(test => {
+  console.log(`   ${test.passed ? '✅' : '❌'} ${test.name}`);
+});
+
+console.log(`\n📊 Eredmény: ${passedTests}/${totalTests} teszt sikeres`);
+console.log(`   Sikeresség: ${((passedTests / totalTests) * 100).toFixed(1)}%`);
+
+if (passedTests === totalTests) {
+  console.log('\n🎉 MINDEN TESZT SIKERES!');
+  console.log('   A kriptográfiai implementáció valóban stabil és megbízható!');
+  console.log('   Biztonságosan használható hosszú távon különböző rendszerek között.');
+} else {
+  console.log('\n⚠️   FIGYELEM: Néhány teszt nem sikerült!');
+  console.log('   A kriptográfiai implementáció további finomhangolásra szorul.');
+}
+
+// Memória tisztítás
+encryptedResults.length = 0;
 global.gc && global.gc(); // Garbage collection (ha elérhető)