Fix multi-layer encryption bugs and add performance visualization

Author: elon00

benchmark.py

@@ -0,0 +1,20 @@
+from luther_algorithm import LuthersGoldenAlgorithm
+import time
+
+golden = LuthersGoldenAlgorithm()
+print("Benchmarking Luther's Golden Algorithm...")
+
+data_sizes = [1000, 10000, 100000]
+
+for size in data_sizes:
+    data = b'A' * size
+    start = time.time()
+    for _ in range(10):
+        encrypted = golden.encrypt(data)
+        decrypted = golden.decrypt(encrypted)
+        assert data == decrypted
+    end = time.time()
+    avg_time = (end - start) / 10
+    print(f"Size {size} bytes: {avg_time:.4f} seconds per operation")
+
+print("Benchmark complete!")

luther_algorithm/luther_algorithm.py

@@ -76,11 +76,11 @@ def _super_encrypt_layer(self, data, layer):
         # Different encryption for each layer
         if layer == 0:
             # Layer 0: AES with deterministic quantum-derived key
-            seed = int.from_bytes(hashlib.sha256(data[:16]).digest(), 'big') % (2**16)
+            seed = 12345  # fixed seed for consistency
             key = hashlib.sha256(str(self._quantum_factor_parallel(seed)).encode()).digest()
             return self._aes_gcm(data, key, True)
         elif layer == 1:
-            # Layer 2: Post-quantum if available
+            # Layer 1: Post-quantum if available
             if self.pq:
                 ct, ss = encapsulate(self.kem_pk)
                 key = hashlib.sha256(ss).digest()
@@ -89,12 +89,13 @@ def _super_encrypt_layer(self, data, layer):
                 key = get_random_bytes(32)
                 return key + self._aes_gcm(data, key, True)
         else:
-            # Layer 3: Hybrid with quantum boost
+            # Layer 2: Hybrid with quantum boost
             key = get_random_bytes(32)
+            original_key = key
             if self.quantum_boost:
                 factors = self._quantum_factor_parallel(int.from_bytes(key, 'big') % 2**20)
                 key = hashlib.sha256(str(factors).encode()).digest()
-            return self._aes_gcm(data, key, True)
+            return original_key + self._aes_gcm(data, key, True)
 
     def encrypt(self, data, pub_key=None):
         """Super Golden encryption with adaptive intelligence and multiple layers"""
@@ -144,7 +145,7 @@ def _super_decrypt_layer(self, data, layer):
 
         # Reverse the encryption layers
         if layer == 2:
-            # Layer 3: Hybrid with quantum boost
+            # Layer 2: Hybrid with quantum boost
             key_size = 32
             key_data, enc = data[:key_size], data[key_size:]
             key = key_data
@@ -153,7 +154,7 @@ def _super_decrypt_layer(self, data, layer):
                 key = hashlib.sha256(str(factors).encode()).digest()
             return self._aes_gcm(enc, key, False)
         elif layer == 1:
-            # Layer 2: Post-quantum if available
+            # Layer 1: Post-quantum if available
             if self.pq:
                 key_size = 768
                 key_data, enc = data[:key_size], data[key_size:]
@@ -166,7 +167,7 @@ def _super_decrypt_layer(self, data, layer):
                 return self._aes_gcm(enc, key_data, False)
         else:
             # Layer 0: AES with deterministic quantum-derived key
-            seed = int.from_bytes(hashlib.sha256(data[:16]).digest(), 'big') % (2**16)
+            seed = 12345  # fixed seed for consistency
             key = hashlib.sha256(str(self._quantum_factor_parallel(seed)).encode()).digest()
             return self._aes_gcm(data, key, False)
 

visualize.py

@@ -0,0 +1,52 @@
+from luther_algorithm import LuthersGoldenAlgorithm
+import time
+
+golden = LuthersGoldenAlgorithm()
+print("=== LUTHER'S GOLDEN ALGORITHM PERFORMANCE VISUALIZATION ===")
+print()
+
+# Test different data sizes
+sizes = [100, 1000, 10000, 50000, 100000]
+results = []
+
+print("Running benchmarks...")
+for size in sizes:
+    data = b'A' * size
+    times = []
+    for _ in range(5):  # 5 runs for averaging
+        start = time.time()
+        encrypted = golden.encrypt(data)
+        decrypted = golden.decrypt(encrypted)
+        end = time.time()
+        times.append(end - start)
+        assert data == decrypted
+
+    avg_time = sum(times) / len(times)
+    overhead = len(encrypted) - size
+    results.append((size, avg_time, overhead))
+
+print("\nPERFORMANCE RESULTS:")
+print("=" * 60)
+print("Data Size | Time (sec) | Overhead | Efficiency")
+print("-" * 60)
+
+for size, avg_time, overhead in results:
+    efficiency = size / (size + overhead) * 100
+    print(f"{size:8d} | {avg_time:.6f} | {overhead:8d} | {efficiency:.1f}%")
+
+print("\nVISUALIZATION:")
+print("=" * 60)
+
+# Simple ASCII bar chart for time
+max_time = max(r[1] for r in results)
+for size, avg_time, _ in results:
+    bar_length = int(avg_time / max_time * 40)
+    bar = "#" * bar_length
+    print(f"{size:8d} | {bar}")
+
+print("\nSECURITY LEVEL:", golden.get_security_level())
+print("POST-QUANTUM:", "Available" if golden.pq else "Not Available")
+print("QUANTUM BOOST:", "Enabled" if golden.quantum_boost else "Disabled")
+print("ENCRYPTION LAYERS:", golden.layers)
+
+print("\n=== VISUALIZATION COMPLETE ===")