Update gui.py

Author: ProjectZeroDays

src/gui.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """
 AI-Driven Zero-Click Exploit Deployment Framework - Integrated GUI
-Auto-discovers and connects to available backend modules
+Uses backend adapters for proper module initialization
 """
 
 import tkinter as tk
@@ -12,110 +12,25 @@
 import random
 import sys
 import os
-import importlib
-import inspect
 from datetime import datetime
 from collections import deque
+from pathlib import Path
 
 # Add src directory to path
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
-
-# Auto-discover available modules
-AVAILABLE_MODULES = {}
-
-MODULE_MAPPING = {
-    'exploit': [
-        'src.exploit.exploit_module',
-        'src.exploit_module',
-        'exploit.exploit_module',
-        'exploit_module'
-    ],
-    'ai': [
-        'src.ai.ai_model',
-        'src.ai_model',
-        'ai.ai_model',
-        'ai_model'
-    ],
-    'device': [
-        'src.device_control.device_manager',
-        'src.device_manager',
-        'device_control.device_manager',
-        'device_manager'
-    ],
-    'botnet': [
-        'src.botnet.botnet_manager',
-        'src.botnet_manager',
-        'botnet.botnet_manager',
-        'botnet_manager'
-    ],
-    'monitor': [
-        'src.monitoring.real_time_monitor',
-        'src.real_time_monitor',
-        'monitoring.real_time_monitor',
-        'real_time_monitor'
-    ],
-    'post_exploit': [
-        'src.post_exploitation.post_exploit',
-        'src.post_exploit',
-        'post_exploitation.post_exploit',
-        'post_exploit'
-    ],
-    'encryptor': [
-        'src.encryption.polymorphic_encryptor',
-        'src.polymorphic_encryptor',
-        'encryption.polymorphic_encryptor',
-        'polymorphic_encryptor'
-    ],
-    'tunnel': [
-        'src.networking.reverse_doh',
-        'src.reverse_doh',
-        'networking.reverse_doh',
-        'reverse_doh'
-    ],
-    'sms': [
-        'src.social.sms_spoofing',
-        'src.sms_spoofing',
-        'social.sms_spoofing',
-        'sms_spoofing'
-    ],
-    'email': [
-        'src.social.email_spoofing',
-        'src.email_spoofing',
-        'social.email_spoofing',
-        'email_spoofing'
-    ]
-}
-
-def discover_modules():
-    """Auto-discover available framework modules"""
-    discovered = {}
-
-    for module_type, possible_paths in MODULE_MAPPING.items():
-        for path in possible_paths:
-            try:
-                module = importlib.import_module(path)
-                # Find the main class in the module
-                classes = [obj for name, obj in inspect.getmembers(module) 
-                          if inspect.isclass(obj) and obj.__module__ == path]
-
-                if classes:
-                    discovered[module_type] = {
-                        'module': module,
-                        'class': classes[0],
-                        'path': path
-                    }
-                    print(f"✓ Discovered {module_type}: {path}.{classes[0].__name__}")
-                    break
-            except ImportError:
-                continue
-            except Exception as e:
-                continue
-
-    return discovered
-
-# Discover modules at startup
-AVAILABLE_MODULES = discover_modules()
-FRAMEWORK_MODULES_AVAILABLE = len(AVAILABLE_MODULES) > 0
+sys.path.insert(0, str(Path(__file__).parent))
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+# Import adapters
+try:
+    from backend_adapters import (
+        ConfigManager, GUILogger, ExploitAdapter, BotnetAdapter,
+        AIAdapter, DeviceAdapter, MonitorAdapter, EncryptorAdapter,
+        TunnelAdapter, SocialAdapter
+    )
+    ADAPTERS_AVAILABLE = True
+except ImportError as e:
+    print(f"Adapters not available: {e}")
+    ADAPTERS_AVAILABLE = False
 
 # Modern styling constants
 COLORS = {
@@ -466,7 +381,7 @@ def save(self):
         self.destroy()
 
 class AIDeploymentFrameworkGUI:
-    """Main GUI Application with auto-discovered backend integration"""
+    """Main GUI Application with adapter-based backend integration"""
 
     def __init__(self, root):
         self.root = root
@@ -475,9 +390,14 @@ def __init__(self, root):
         self.root.configure(bg=COLORS['bg_dark'])
         self.root.minsize(1200, 700)
 
-        # Initialize backend modules
+        # Initialize configuration and logging
+        self.config = ConfigManager() if ADAPTERS_AVAILABLE else None
+        self.gui_logger = GUILogger('GUI') if ADAPTERS_AVAILABLE else None
+
+        # Initialize backend modules through adapters
         self.backend = {}
-        self._init_backend_modules()
+        if ADAPTERS_AVAILABLE:
+            self._init_backend_modules()
 
         # State
         self.running = False
@@ -500,32 +420,78 @@ def __init__(self, root):
         self.create_layout()
         self.create_status_bar()
 
+        # Connect logger to log panel after it's created
+        if self.gui_logger:
+            self.gui_logger.set_log_panel(self.log_panel)
+
         # Start background tasks
         self.start_monitoring()
 
         # Initial log
         self.log_panel.log('Framework initialized successfully', 'SUCCESS')
-        if FRAMEWORK_MODULES_AVAILABLE:
-            self.log_panel.log(f'Discovered {len(AVAILABLE_MODULES)} backend modules', 'SUCCESS')
-            for name in AVAILABLE_MODULES.keys():
-                self.log_panel.log(f'  ✓ {name} module loaded', 'DEBUG')
+        if ADAPTERS_AVAILABLE and self.backend:
+            self.log_panel.log(f'Backend adapters loaded: {len(self.backend)} modules', 'SUCCESS')
+            for name in self.backend.keys():
+                self.log_panel.log(f'  ✓ {name}', 'DEBUG')
         else:
-            self.log_panel.log('No backend modules found - Running in DEMO MODE', 'WARNING')
+            self.log_panel.log('Running in DEMO MODE', 'WARNING')
         self.log_panel.log('Zero-click exploit modules ready', 'INFO')
 
     def _init_backend_modules(self):
-        """Initialize discovered backend modules"""
-        global AVAILABLE_MODULES
+        """Initialize backend modules through adapters"""
+        try:
+            self.backend['exploit'] = ExploitAdapter(self.config, self.gui_logger)
+            print('✓ Exploit adapter initialized')
+        except Exception as e:
+            print(f'✗ Exploit adapter failed: {e}')
 
-        for module_name, module_info in AVAILABLE_MODULES.items():
-            try:
-                # Instantiate the class
-                cls = module_info['class']
-                instance = cls()
-                self.backend[module_name] = instance
-                print(f"✓ Initialized {module_name}: {cls.__name__}")
-            except Exception as e:
-                print(f"✗ Failed to initialize {module_name}: {e}")
+        try:
+            self.backend['botnet'] = BotnetAdapter(self.config, self.gui_logger)
+            print('✓ Botnet adapter initialized')
+        except Exception as e:
+            print(f'✗ Botnet adapter failed: {e}')
+
+        try:
+            self.backend['ai'] = AIAdapter(self.config, self.gui_logger)
+            print('✓ AI adapter initialized')
+        except Exception as e:
+            print(f'✗ AI adapter failed: {e}')
+
+        try:
+            self.backend['device'] = DeviceAdapter(self.config, self.gui_logger)
+            print('✓ Device adapter initialized')
+        except Exception as e:
+            print(f'✗ Device adapter failed: {e}')
+
+        try:
+            self.backend['monitor'] = MonitorAdapter(self.config, self.gui_logger)
+            print('✓ Monitor adapter initialized')
+        except Exception as e:
+            print(f'✗ Monitor adapter failed: {e}')
+
+        try:
+            self.backend['encryptor'] = EncryptorAdapter(self.config, self.gui_logger)
+            print('✓ Encryptor adapter initialized')
+        except Exception as e:
+            print(f'✗ Encryptor adapter failed: {e}')
+
+        try:
+            self.backend['tunnel'] = TunnelAdapter(self.config, self.gui_logger)
+            print('✓ Tunnel adapter initialized')
+        except Exception as e:
+            print(f'✗ Tunnel adapter failed: {e}')
+
+        try:
+            self.backend['sms'] = SocialAdapter('sms', self.config, self.gui_logger)
+            print('✓ SMS adapter initialized')
+        except Exception as e:
+            print(f'✗ SMS adapter failed: {e}')
+
+        try:
+            self.backend['email'] = SocialAdapter('email', self.config, self.gui_logger)
+            print('✓ Email adapter initialized')
+        except Exception as e:
+            print(f'✗ Email adapter failed: {e}')
 
     def create_menu(self):
         """Create application menu"""