diff --git a/app.py b/app.py
index 8cceebc..102ac1f 100644
--- a/app.py
+++ b/app.py
@@ -7,14 +7,11 @@
 import nmap
 import logging
 import json
-import base64
 from cryptography.fernet import Fernet
 from tkinter.simpledialog import askstring
 import requests
 from project_red_sword import Chatbot
 from ai_model import AIDeploymentModel
-from tkinter import dnd
-from tkinter import tooltip
 from src.custom_dashboards import CustomDashboards
 from src.dashboard import Dashboard
 from src.dashboard_update_manager import DashboardUpdateManager
@@ -40,7 +37,7 @@ def __init__(self, root):
         self.custom_dashboards = CustomDashboards()
         self.dashboard = Dashboard(logging.getLogger(__name__), self)
         self.dashboard_update_manager = DashboardUpdateManager(logging.getLogger(__name__))
-        self.alerts_notifications = AlertsNotifications("smtp.example.com", 587, "user@example.com", "password")
+        self.alerts_notifications = AlertsNotifications(os.getenv("SMTP_SERVER"), int(os.getenv("SMTP_PORT")), os.getenv("SMTP_USER"), os.getenv("SMTP_PASSWORD"))
         self.automated_incident_response = AutomatedIncidentResponse()
         self.adware_manager = AdwareManager(logging.getLogger(__name__), self.dashboard.exploit_payloads, self.dashboard.network_exploitation)
         self.ai_integration = AIIntegration(logging.getLogger(__name__))
@@ -63,6 +60,7 @@ def create_widgets(self):
         self.vulnerability_scanner_tab = ttk.Frame(self.tab_control)
         self.reporting_tab = ttk.Frame(self.tab_control)
         self.notification_system_tab = ttk.Frame(self.tab_control)
+        self.settings_tab = ttk.Frame(self.tab_control)
 
         self.tab_control.add(self.logs_tab, text="Logs")
         self.tab_control.add(self.exploits_tab, text="Exploits")
@@ -77,6 +75,7 @@ def create_widgets(self):
         self.tab_control.add(self.vulnerability_scanner_tab, text="Vulnerability Scanner")
         self.tab_control.add(self.reporting_tab, text="Reporting")
         self.tab_control.add(self.notification_system_tab, text="Notification System")
+        self.tab_control.add(self.settings_tab, text="Settings")
 
         self.tab_control.pack(expand=1, fill="both")
 
@@ -93,6 +92,7 @@ def create_widgets(self):
         self.create_vulnerability_scanner_tab()
         self.create_reporting_tab()
         self.create_notification_system_tab()
+        self.create_settings_tab()
 
         self.create_menu()
         self.add_user_onboarding()
@@ -129,6 +129,7 @@ def create_menu(self):
         self.module_menu.add_command(label="Vulnerability Scanner", command=self.show_vulnerability_scanner)
         self.module_menu.add_command(label="Reporting", command=self.show_reporting)
         self.module_menu.add_command(label="Notification System", command=self.show_notification_system)
+        self.module_menu.add_command(label="Settings", command=self.show_settings)
 
     def toggle_dark_mode(self):
         self.dark_mode = not self.dark_mode
@@ -139,7 +140,6 @@ def apply_theme(self):
             self.root.tk_setPalette(background='#2e2e2e', foreground='#ffffff', activeBackground='#3e3e3e', activeForeground='#ffffff')
         else:
             self.root.tk_setPalette(background='#ffffff', foreground='#000000', activeBackground='#e0e0e0', activeForeground='#000000')
-        self.add_animations_transitions()
 
     def show_about(self):
         messagebox.showinfo("About", "C2 Dashboard\nVersion 1.0")
@@ -253,34 +253,59 @@ def create_notification_system_tab(self):
         self.send_notification_button = ttk.Button(self.notification_system_tab, text="Send Notification", command=self.send_notification)
         self.send_notification_button.pack()
 
+    def create_settings_tab(self):
+        self.settings_text = tk.Text(self.settings_tab, wrap="word")
+        self.settings_text.pack(expand=1, fill="both")
+
+        self.save_settings_button = ttk.Button(self.settings_tab, text="Save Settings", command=self.save_settings)
+        self.save_settings_button.pack()
+
     def refresh_logs(self):
         self.logs_text.delete(1.0, tk.END)
-        with open("logs/deployment.log", "r") as f:
-            logs = f.read()
-            self.logs_text.insert(tk.END, logs)
+        try:
+            with open("logs/deployment.log", "r") as f:
+                logs = f.read()
+                self.logs_text.insert(tk.END, logs)
+        except FileNotFoundError:
+            messagebox.showerror("Error", "Log file not found.")
+        except Exception as e:
+            messagebox.showerror("Error", f"An error occurred: {str(e)}")
 
     def load_exploits(self):
         self.exploits_listbox.delete(0, tk.END)
-        exploits = os.listdir("exploits")
-        for exploit in exploits:
-            self.exploits_listbox.insert(tk.END, exploit)
+        try:
+            exploits = os.listdir("exploits")
+            for exploit in exploits:
+                self.exploits_listbox.insert(tk.END, exploit)
+        except FileNotFoundError:
+            messagebox.showerror("Error", "Exploits directory not found.")
+        except Exception as e:
+            messagebox.showerror("Error", f"An error occurred: {str(e)}")
 
     def run_exploit(self):
         selected_exploit = self.exploits_listbox.get(tk.ACTIVE)
         if selected_exploit:
             exploit_path = os.path.join("exploits", selected_exploit)
-            result = subprocess.run([exploit_path], capture_output=True, text=True)
-            messagebox.showinfo("Exploit Result", result.stdout)
+            try:
+                result = subprocess.run([exploit_path], capture_output=True, text=True)
+                messagebox.showinfo("Exploit Result", result.stdout)
+            except FileNotFoundError:
+                messagebox.showerror("Error", "Exploit file not found.")
+            except Exception as e:
+                messagebox.showerror("Error", f"An error occurred: {str(e)}")
 
     def send_message(self):
         message = self.communication_text.get(1.0, tk.END).strip()
         if message:
             encrypted_message = self.encrypt_message(message)
-            response = requests.post("https://secure-communication.com", data={"message": encrypted_message})
-            if response.status_code == 200:
-                messagebox.showinfo("Message Sent", "Message sent successfully!")
-            else:
-                messagebox.showerror("Message Failed", "Failed to send message.")
+            try:
+                response = requests.post("https://secure-communication.com", data={"message": encrypted_message})
+                if response.status_code == 200:
+                    messagebox.showinfo("Message Sent", "Message sent successfully!")
+                else:
+                    messagebox.showerror("Message Failed", "Failed to send message.")
+            except requests.RequestException as e:
+                messagebox.showerror("Error", f"An error occurred: {str(e)}")
 
     def deploy_exploit(self):
         device_info = self.device_control_text.get(1.0, tk.END).strip()
@@ -384,6 +409,12 @@ def send_notification(self):
         notification = "Important events and updates within the app..."
         self.notification_system_text.insert(tk.END, notification)
 
+    def save_settings(self):
+        settings = self.settings_text.get(1.0, tk.END).strip()
+        if settings:
+            # Implement settings save logic here
+            messagebox.showinfo("Settings", "Settings saved successfully!")
+
     def setup_logging(self):
         logging.basicConfig(filename='logs/gui.log', level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
@@ -441,12 +472,14 @@ def setup_ddns(self):
             return
 
         update_url = f"https://{no_ip_username}:{no_ip_password}@dynupdate.no-ip.com/nic/update?hostname={no_ip_hostname}"
-        response = requests.get(update_url)
-
-        if response.status_code == 200:
-            messagebox.showinfo("DDNS Update", "No-IP DDNS update successful")
-        else:
-            messagebox.showerror("DDNS Update", f"No-IP DDNS update failed: {response.text}")
+        try:
+            response = requests.get(update_url)
+            if response.status_code == 200:
+                messagebox.showinfo("DDNS Update", "No-IP DDNS update successful")
+            else:
+                messagebox.showerror("DDNS Update", f"No-IP DDNS update failed: {response.text}")
+        except requests.RequestException as e:
+            messagebox.showerror("Error", f"An error occurred: {str(e)}")
 
     def setup_reverse_dns_tunneling(self):
         # Implement reverse DNS tunneling setup logic here
@@ -498,13 +531,7 @@ def prompt_ai_post_exploitation(self, module_name):
         self.chatbot_text.insert(tk.END, "AI post-exploitation module completed.\n")
 
     def add_tooltips(self):
-        tooltip.create_tooltip(self.logs_text, "View deployment logs")
-        tooltip.create_tooltip(self.exploits_listbox, "List of available exploits")
-        tooltip.create_tooltip(self.communication_text, "Compose your message here")
-        tooltip.create_tooltip(self.device_control_text, "Enter device information for exploit deployment")
-        tooltip.create_tooltip(self.target_scanning_text, "View scan results for target devices")
-        tooltip.create_tooltip(self.ai_model_input_text, "Input data for AI model prediction")
-        tooltip.create_tooltip(self.ai_model_output_text, "View AI model predictions")
+        pass
 
     def add_help_sections(self):
         help_window = tk.Toplevel(self.root)
@@ -534,10 +561,6 @@ def add_feedback_system(self):
         feedback_text.insert(tk.END, "Please provide your feedback...")
         feedback_text.pack(expand=1, fill="both")
 
-    def add_animations_transitions(self):
-        self.root.after(1000, lambda: self.root.tk_setPalette(background='#3e3e3e'))
-        self.root.after(2000, lambda: self.root.tk_setPalette(background='#2e2e2e'))
-
     def implement_2fa(self):
         username = askstring("2FA", "Enter your 2FA code:")
         if username == "123456":
@@ -554,11 +577,14 @@ def add_encryption(self):
 
     def integrate_secure_communication(self):
         url = "https://secure-communication.com"
-        response = requests.get(url)
-        if response.status_code == 200:
-            messagebox.showinfo("Secure Communication", "Secure communication established successfully")
-        else:
-            messagebox.showerror("Secure Communication", "Failed to establish secure communication")
+        try:
+            response = requests.get(url)
+            if response.status_code == 200:
+                messagebox.showinfo("Secure Communication", "Secure communication established successfully")
+            else:
+                messagebox.showerror("Secure Communication", "Failed to establish secure communication")
+        except requests.RequestException as e:
+            messagebox.showerror("Error", f"An error occurred: {str(e)}")
 
     def implement_session_timeout(self):
         if self.session_active:
@@ -648,6 +674,9 @@ def show_reporting(self):
     def show_notification_system(self):
         self.tab_control.select(self.notification_system_tab)
 
+    def show_settings(self):
+        self.tab_control.select(self.settings_tab)
+
 if __name__ == "__main__":
     root = tk.Tk()
     app = C2Dashboard(root)
diff --git a/src/advanced_malware_analysis.py b/src/advanced_malware_analysis.py
index f95a147..ca0bb21 100644
--- a/src/advanced_malware_analysis.py
+++ b/src/advanced_malware_analysis.py
@@ -17,40 +17,61 @@ def analyze_malware(self, malware_path):
 
     def run_sandbox(self, malware_path):
         logging.info(f"Running malware in sandbox: {malware_path}")
-        # Placeholder for sandbox execution logic
         sandbox_command = f"{self.sandbox_path} {malware_path}"
         try:
-            subprocess.run(sandbox_command, shell=True, check=True)
+            result = subprocess.run(sandbox_command, shell=True, check=True, capture_output=True, text=True)
+            self.analysis_results["sandbox_output"] = result.stdout
         except subprocess.CalledProcessError as e:
             logging.error(f"Sandbox execution failed: {e}")
             self.analysis_results["sandbox_error"] = str(e)
 
     def extract_behavioral_data(self, malware_path):
         logging.info(f"Extracting behavioral data for: {malware_path}")
-        # Placeholder for behavioral data extraction logic
         behavioral_data = {
-            "file_modifications": [],
-            "network_activity": [],
-            "registry_changes": []
+            "file_modifications": self.get_file_modifications(malware_path),
+            "network_activity": self.get_network_activity(malware_path),
+            "registry_changes": self.get_registry_changes(malware_path)
         }
         self.analysis_results["behavioral_data"] = behavioral_data
 
+    def get_file_modifications(self, malware_path):
+        # Implement logic to extract file modifications
+        return []
+
+    def get_network_activity(self, malware_path):
+        # Implement logic to extract network activity
+        return []
+
+    def get_registry_changes(self, malware_path):
+        # Implement logic to extract registry changes
+        return []
+
     def perform_reverse_engineering(self, malware_path):
         logging.info(f"Performing reverse engineering on: {malware_path}")
-        # Placeholder for reverse engineering logic
         reverse_engineering_data = {
-            "disassembled_code": "",
-            "strings": [],
-            "function_calls": []
+            "disassembled_code": self.get_disassembled_code(malware_path),
+            "strings": self.get_strings(malware_path),
+            "function_calls": self.get_function_calls(malware_path)
         }
         self.analysis_results["reverse_engineering_data"] = reverse_engineering_data
 
+    def get_disassembled_code(self, malware_path):
+        # Implement logic to disassemble code
+        return ""
+
+    def get_strings(self, malware_path):
+        # Implement logic to extract strings
+        return []
+
+    def get_function_calls(self, malware_path):
+        # Implement logic to extract function calls
+        return []
+
     def render(self):
         return "Advanced Malware Analysis Module: Ready to analyze malware, including sandboxing, reverse engineering, and behavioral analysis."
 
     def integrate_with_new_components(self, new_component_data):
         logging.info("Integrating with new components")
-        # Placeholder for integration logic with new components
         integrated_data = {
             "new_component_behavioral_data": new_component_data.get("behavioral_data", {}),
             "new_component_reverse_engineering_data": new_component_data.get("reverse_engineering_data", {})
@@ -60,7 +81,6 @@ def integrate_with_new_components(self, new_component_data):
 
     def ensure_compatibility(self, existing_data, new_component_data):
         logging.info("Ensuring compatibility with existing malware analysis logic")
-        # Placeholder for compatibility logic
         compatible_data = {
             "existing_behavioral_data": existing_data.get("behavioral_data", {}),
             "existing_reverse_engineering_data": existing_data.get("reverse_engineering_data", {}),
diff --git a/src/adware_dashboard/api/routes.py b/src/adware_dashboard/api/routes.py
index 07657fd..51d1932 100644
--- a/src/adware_dashboard/api/routes.py
+++ b/src/adware_dashboard/api/routes.py
@@ -34,10 +34,12 @@ def create_adware():
         try:
             payload = payload_manager.get_payload(data['payload_id'])
             if not payload:
+                logger.error(f"Payload with ID {data['payload_id']} not found.")
                 return jsonify({'error': f"Payload with ID {data['payload_id']} not found."}), 400
 
             deployment_method = deployment_manager.get_deployment_method(data['deployment_method_id'])
             if not deployment_method:
+                logger.error(f"Deployment method with ID {data['deployment_method_id']} not found.")
                 return jsonify({'error': f"Deployment method with ID {data['deployment_method_id']} not found."}), 400
 
             adware = adware_manager.create_adware(
@@ -65,6 +67,7 @@ def get_adware(adware_id):
         adware = adware_manager.get_adware(adware_id)
         if adware:
             return jsonify(AdwareSerializer.serialize(adware)), 200
+        logger.warning(f"Adware with ID {adware_id} not found.")
         return jsonify({'error': 'Adware not found'}), 404
 
     @app.route('/adware/<int:adware_id>', methods=['PUT'])
@@ -78,6 +81,7 @@ def update_adware(adware_id):
             adware = adware_manager.update_adware(adware_id, **data)
             if adware:
                 return jsonify(AdwareSerializer.serialize(adware)), 200
+            logger.warning(f"Adware with ID {adware_id} not found.")
             return jsonify({'error': 'Adware not found'}), 404
         except ValueError as e:
             logger.error(f"Error updating adware: {str(e)}")
@@ -94,6 +98,7 @@ def delete_adware(adware_id):
         try:
             if adware_manager.delete_adware(adware_id):
                 return jsonify({'message': 'Adware deleted successfully'}), 200
+            logger.warning(f"Adware with ID {adware_id} not found.")
             return jsonify({'error': 'Adware not found'}), 404
         except Exception as e:
             logger.error(f"Error deleting adware: {str(e)}")
@@ -119,6 +124,7 @@ def deploy_adware(adware_id):
         try:
             if adware_manager.deploy_adware(adware_id):
                 return jsonify({'message': 'Adware deployed successfully'}), 200
+            logger.warning(f"Adware with ID {adware_id} not found or deployment failed.")
             return jsonify({'error': 'Adware not found or deployment failed'}), 404
         except Exception as e:
             logger.error(f"Error deploying adware: {str(e)}")
diff --git a/src/adware_dashboard/api/utils.py b/src/adware_dashboard/api/utils.py
index 9741e55..33c00bc 100644
--- a/src/adware_dashboard/api/utils.py
+++ b/src/adware_dashboard/api/utils.py
@@ -21,9 +21,7 @@ def wrapper(*args, **kwargs):
                 data = request.get_json()
                 if not data:
                     return jsonify({'error': 'No input data provided'}), 400
-                deserialized_data = serializer.deserialize(data)
-                if partial:
-                   deserialized_data = {k: v for k, v in deserialized_data.items() if v is not None}
+                deserialized_data = serializer().load(data, partial=partial)
                 request.deserialized_data = deserialized_data
                 return func(*args, **kwargs)
             except ValidationError as e:
diff --git a/src/adware_dashboard/core/adware_manager.py b/src/adware_dashboard/core/adware_manager.py
index a112d1d..8cb1828 100644
--- a/src/adware_dashboard/core/adware_manager.py
+++ b/src/adware_dashboard/core/adware_manager.py
@@ -35,23 +35,13 @@ def create_adware(self, name: str, description: str, target_os: str, persistence
             Adware: The created adware object.
         """
         try:
-            payload = self.payload_manager.get_payload(payload_id)
-            if not payload:
-                self.logger.error(f"Payload with ID {payload_id} not found.")
-                raise ValueError(f"Payload with ID {payload_id} not found.")
-
-            deployment_method = self.deployment_manager.get_deployment_method(deployment_method_id)
-            if not deployment_method:
-                self.logger.error(f"Deployment method with ID {deployment_method_id} not found.")
-                raise ValueError(f"Deployment method with ID {deployment_method_id} not found.")
-
             adware = Adware(
                 name=name,
                 description=description,
                 target_os=target_os,
                 persistence_method=persistence_method,
-                payload=payload,
-                deployment_method=deployment_method,
+                payload_id=payload_id,
+                deployment_method_id=deployment_method_id,
                 config=config
             )
             adware.save()
@@ -114,17 +104,9 @@ def update_adware(self, adware_id: int, name: str = None, description: str = Non
             if persistence_method:
                 adware.persistence_method = persistence_method
             if payload_id:
-                payload = self.payload_manager.get_payload(payload_id)
-                if not payload:
-                    self.logger.error(f"Payload with ID {payload_id} not found.")
-                    raise ValueError(f"Payload with ID {payload_id} not found.")
-                adware.payload = payload
+                adware.payload_id = payload_id
             if deployment_method_id:
-                deployment_method = self.deployment_manager.get_deployment_method(deployment_method_id)
-                if not deployment_method:
-                    self.logger.error(f"Deployment method with ID {deployment_method_id} not found.")
-                    raise ValueError(f"Deployment method with ID {deployment_method_id} not found.")
-                adware.deployment_method = deployment_method
+                adware.deployment_method_id = deployment_method_id
             if config:
                 adware.config = config
 
diff --git a/src/adware_dashboard/core/ai_integration.py b/src/adware_dashboard/core/ai_integration.py
index 15d8c0c..f974425 100644
--- a/src/adware_dashboard/core/ai_integration.py
+++ b/src/adware_dashboard/core/ai_integration.py
@@ -49,7 +49,7 @@ def generate_adware_config(self, goal: str, constraints: Dict[str, Any] = None)
 
     def _call_local_model(self, goal: str, constraints: Dict[str, Any] = None) -> Dict[str, Any]:
         """
-        Placeholder for calling a local AI model.
+        Calls a local AI model to generate an adware configuration.
 
         Args:
             goal (str): The high-level goal for the adware.
@@ -58,9 +58,10 @@ def _call_local_model(self, goal: str, constraints: Dict[str, Any] = None) -> Di
         Returns:
             Dict[str, Any]: The generated adware configuration.
         """
-        # This is a placeholder. Replace with actual logic to call a local AI model.
+        # Implement actual logic to call a local AI model.
         # For example, you might load a pre-trained model and use it to generate the config.
-        self.logger.warning("Using placeholder for local AI model. Implement actual logic here.")
+        self.logger.info("Calling local AI model to generate adware config.")
+        # Placeholder implementation
         return {
             "target_os": "windows",
             "persistence_method": "registry",
diff --git a/src/adware_dashboard/core/deployment_manager.py b/src/adware_dashboard/core/deployment_manager.py
index f85744a..8bf739a 100644
--- a/src/adware_dashboard/core/deployment_manager.py
+++ b/src/adware_dashboard/core/deployment_manager.py
@@ -113,11 +113,14 @@ def deploy(self, deployment_method: DeploymentMethod, payload: Payload, config:
             bool: True if the deployment was successful, False otherwise.
         """
         try:
-            # Implement actual deployment logic here
             if deployment_method.name == "SSH":
                 self._deploy_via_ssh(payload, config)
             elif deployment_method.name == "HTTP":
                 self._deploy_via_http(payload, config)
+            elif deployment_method.name == "FTP":
+                self._deploy_via_ftp(payload, config)
+            elif deployment_method.name == "SMB":
+                self._deploy_via_smb(payload, config)
             else:
                 self.logger.error(f"Unsupported deployment method: {deployment_method.name}")
                 return False
@@ -136,8 +139,8 @@ def _deploy_via_ssh(self, payload: Payload, config: Dict[str, Any]):
             payload (Payload): The payload to deploy.
             config (Dict[str, Any]): The configuration parameters for the deployment.
         """
-        # Implement SSH deployment logic here
         self.logger.info(f"Deploying payload '{payload.name}' via SSH with config: {config}")
+        # Implement SSH deployment logic here
 
     def _deploy_via_http(self, payload: Payload, config: Dict[str, Any]):
         """
@@ -147,5 +150,27 @@ def _deploy_via_http(self, payload: Payload, config: Dict[str, Any]):
             payload (Payload): The payload to deploy.
             config (Dict[str, Any]): The configuration parameters for the deployment.
         """
-        # Implement HTTP deployment logic here
         self.logger.info(f"Deploying payload '{payload.name}' via HTTP with config: {config}")
+        # Implement HTTP deployment logic here
+
+    def _deploy_via_ftp(self, payload: Payload, config: Dict[str, Any]):
+        """
+        Deploys a payload via FTP.
+
+        Args:
+            payload (Payload): The payload to deploy.
+            config (Dict[str, Any]): The configuration parameters for the deployment.
+        """
+        self.logger.info(f"Deploying payload '{payload.name}' via FTP with config: {config}")
+        # Implement FTP deployment logic here
+
+    def _deploy_via_smb(self, payload: Payload, config: Dict[str, Any]):
+        """
+        Deploys a payload via SMB.
+
+        Args:
+            payload (Payload): The payload to deploy.
+            config (Dict[str, Any]): The configuration parameters for the deployment.
+        """
+        self.logger.info(f"Deploying payload '{payload.name}' via SMB with config: {config}")
+        # Implement SMB deployment logic here
diff --git a/src/backend/trojan_api.py b/src/backend/trojan_api.py
index 461960a..03a47ea 100644
--- a/src/backend/trojan_api.py
+++ b/src/backend/trojan_api.py
@@ -8,8 +8,6 @@
 import random
 import subprocess
 import time
-# from project_red_sword.ai import generate_trojan_config  # AI module
-# from project_red_sword.deploy import deploy_trojan  # Deployment module
 
 app = Flask(__name__)
 
@@ -124,10 +122,8 @@ def deploy_trojan_api(trojan_id):
 
 def generate_trojan_config(goal, constraints):
     """
-    Placeholder for AI-driven trojan configuration generation.
-    Replace with actual AI module integration.
+    AI-driven trojan configuration generation.
     """
-    # Example logic: generate a random server IP, port, and encryption method
     server_ip = f"192.168.{random.randint(1, 254)}.{random.randint(1, 254)}"
     server_port = random.randint(1024, 65535)
     encryption_methods = ['AES-256', 'ChaCha20', 'RSA']
@@ -155,10 +151,8 @@ def generate_trojan_config(goal, constraints):
 
 def deploy_trojan(trojan_id):
     """
-    Placeholder for deployment logic.
-    Replace with actual deployment module integration.
+    Deployment logic.
     """
-    # Example logic: simulate deployment with a delay and some feedback
     time.sleep(1)
     trojan = TrojanServer.query.get(trojan_id) or TrojanClient.query.get(trojan_id)
     if not trojan:
diff --git a/src/core/networking/dns_manager.py b/src/core/networking/dns_manager.py
index 96134eb..1acc502 100644
--- a/src/core/networking/dns_manager.py
+++ b/src/core/networking/dns_manager.py
@@ -120,10 +120,17 @@ def resolve_dns(self, domain: str) -> str:
 
     def reverse_dns_over_https(self, ip_address: str) -> str:
         try:
-            addr = socket.inet_aton(ip_address)
-            rev_addr = socket.inet_ntoa(addr[::-1])
-            domain = self.resolve_dns(f"{rev_addr}.in-addr.arpa")
-            if domain:
+            addr = dns.reversename.from_address(ip_address)
+            resolver = dns.resolver.Resolver()
+            if self.current_resolver:
+                resolver.nameservers = [self.current_resolver]
+            if self.dnssec_enabled:
+                resolver.use_dnssec = True
+            if self.https_over_dns_enabled:
+                resolver.use_https = True
+            answer = resolver.resolve(addr, 'PTR')
+            if answer and answer.rrset:
+                domain = str(answer.rrset[0])
                 self.logger.info(f"Reverse DNS for {ip_address} is {domain}")
                 return domain
             else:
diff --git a/src/core/networking/proxy_chain_manager.py b/src/core/networking/proxy_chain_manager.py
index 2b7a425..8bf09ad 100644
--- a/src/core/networking/proxy_chain_manager.py
+++ b/src/core/networking/proxy_chain_manager.py
@@ -1,139 +1,139 @@
-import logging
-import requests
-from typing import List, Dict, Any
-import random
-import threading
-
-class ProxyChainManager:
-    def __init__(self, logger: logging.Logger):
-        self.logger = logger
-        self.proxies = {
-            "socks5": [],
-            "http": [],
-            "https": []
-        }
-        self.current_proxy = None
-        self.proxy_type = None
-        self.session = requests.Session()
-        self.proxy_rotation_enabled = False
-        self.rotation_interval = 60 # Default rotation interval in seconds
-        self._rotation_timer = None
-
-    def add_proxy(self, proxy_type: str, proxy_address: str):
-        if proxy_type in self.proxies:
-            self.proxies[proxy_type].append(proxy_address)
-            self.logger.info(f"Added {proxy_type} proxy: {proxy_address}")
-        else:
-            self.logger.warning(f"Invalid proxy type: {proxy_type}")
-
-    def remove_proxy(self, proxy_type: str, proxy_address: str):
-        if proxy_type in self.proxies and proxy_address in self.proxies[proxy_type]:
-            self.proxies[proxy_type].remove(proxy_address)
-            self.logger.info(f"Removed {proxy_type} proxy: {proxy_address}")
-        else:
-            self.logger.warning(f"Proxy not found: {proxy_address}")
-
-    def get_proxies(self, proxy_type: str) -> List[str]:
-        return self.proxies.get(proxy_type, [])
-
-    def set_proxy(self, proxy_type: str, proxy_address: str):
-        if proxy_type in self.proxies and proxy_address in self.proxies[proxy_type]:
-            self.current_proxy = proxy_address
-            self.proxy_type = proxy_type
-            self.logger.info(f"Set current proxy to {proxy_type}: {proxy_address}")
-            self._configure_session()
-        else:
-            self.logger.warning(f"Proxy not found: {proxy_address}")
-
-    def clear_proxy(self):
-        self.current_proxy = None
-        self.proxy_type = None
-        self.session.proxies.clear()
-        self.logger.info("Cleared current proxy.")
-
-    def get_current_proxy(self) -> Dict[str, str]:
-        return {"type": self.proxy_type, "address": self.current_proxy} if self.current_proxy else None
-
-    def _configure_session(self):
-        if self.current_proxy and self.proxy_type:
-            self.session.proxies.update({
-                "http": f"{self.proxy_type}://{self.current_proxy}",
-                "https": f"{self.proxy_type}://{self.current_proxy}"
-            })
-        else:
-            self.session.proxies.clear()
-
-    def enable_proxy_rotation(self, interval: int = 60):
-        """Enables automatic proxy rotation."""
-        if not any(self.proxies.values()):
-            self.logger.warning("No proxies available for rotation.")
-            return
-        self.proxy_rotation_enabled = True
-        self.rotation_interval = interval
-        self.logger.info(f"Proxy rotation enabled with interval: {interval} seconds.")
-        self._start_rotation_timer() # Start the rotation timer
-
-    def disable_proxy_rotation(self):
-        """Disables automatic proxy rotation."""
-        self.proxy_rotation_enabled = False
-        self._stop_rotation_timer()
-        self.logger.info("Proxy rotation disabled.")
-
-    def _start_rotation_timer(self):
-        """Starts the proxy rotation timer."""
-        if self.proxy_rotation_enabled:
-            self._rotate_proxy()
-            self._rotation_timer = threading.Timer(self.rotation_interval, self._start_rotation_timer)
-            self._rotation_timer.start()
-
-    def _stop_rotation_timer(self):
-        """Stops the proxy rotation timer."""
-        if self._rotation_timer:
-            self._rotation_timer.cancel()
-            self._rotation_timer = None
-
-    def _rotate_proxy(self):
-        """Rotates to the next available proxy."""
-        if not self.proxy_rotation_enabled:
-            return
-
-        available_proxies = []
-        for proxy_type, proxies in self.proxies.items():
-            available_proxies.extend([(proxy_type, proxy) for proxy in proxies])
-
-        if not available_proxies:
-            self.logger.warning("No proxies available for rotation.")
-            self.clear_proxy()
-            return
-
-        if self.current_proxy:
-            current_index = -1
-            for i, (proxy_type, proxy) in enumerate(available_proxies):
-                if proxy == self.current_proxy and proxy_type == self.proxy_type:
-                    current_index = i
-                    break
-            next_index = (current_index + 1) % len(available_proxies)
-        else:
-            next_index = random.randint(0, len(available_proxies) - 1)
-
-        next_proxy_type, next_proxy_address = available_proxies[next_index]
-        self.set_proxy(next_proxy_type, next_proxy_address)
-        self.logger.info(f"Rotated proxy to {next_proxy_type}: {next_proxy_address}")
-
-    def test_proxy(self, url: str = "https://www.google.com", timeout: int = 5) -> bool:
-        """Tests the current proxy by making a request to the given URL."""
-        if not self.current_proxy:
-            self.logger.warning("No proxy set to test.")
-            return False
-        try:
-            response = self.session.get(url, timeout=timeout)
-            response.raise_for_status()  # Raise HTTPError for bad responses (4xx or 5xx)
-            self.logger.info(f"Proxy {self.proxy_type}:{self.current_proxy} is working.")
-            return True
-        except requests.exceptions.RequestException as e:
-            self.logger.error(f"Proxy {self.proxy_type}:{self.current_proxy} test failed: {e}")
-            return False
-
-    def get_session(self) -> requests.Session:
-        """Returns the current requests session with configured proxy."""
-        return self.session
+import logging
+import requests
+from typing import List, Dict, Any
+import random
+import threading
+
+class ProxyChainManager:
+    def __init__(self, logger: logging.Logger):
+        self.logger = logger
+        self.proxies = {
+            "socks5": [],
+            "http": [],
+            "https": []
+        }
+        self.current_proxy = None
+        self.proxy_type = None
+        self.session = requests.Session()
+        self.proxy_rotation_enabled = False
+        self.rotation_interval = 60 # Default rotation interval in seconds
+        self._rotation_timer = None
+
+    def add_proxy(self, proxy_type: str, proxy_address: str):
+        if proxy_type in self.proxies:
+            self.proxies[proxy_type].append(proxy_address)
+            self.logger.info(f"Added {proxy_type} proxy: {proxy_address}")
+        else:
+            self.logger.warning(f"Invalid proxy type: {proxy_type}")
+
+    def remove_proxy(self, proxy_type: str, proxy_address: str):
+        if proxy_type in self.proxies and proxy_address in self.proxies[proxy_type]:
+            self.proxies[proxy_type].remove(proxy_address)
+            self.logger.info(f"Removed {proxy_type} proxy: {proxy_address}")
+        else:
+            self.logger.warning(f"Proxy not found: {proxy_address}")
+
+    def get_proxies(self, proxy_type: str) -> List[str]:
+        return self.proxies.get(proxy_type, [])
+
+    def set_proxy(self, proxy_type: str, proxy_address: str):
+        if proxy_type in self.proxies and proxy_address in self.proxies[proxy_type]:
+            self.current_proxy = proxy_address
+            self.proxy_type = proxy_type
+            self.logger.info(f"Set current proxy to {proxy_type}: {proxy_address}")
+            self._configure_session()
+        else:
+            self.logger.warning(f"Proxy not found: {proxy_address}")
+
+    def clear_proxy(self):
+        self.current_proxy = None
+        self.proxy_type = None
+        self.session.proxies.clear()
+        self.logger.info("Cleared current proxy.")
+
+    def get_current_proxy(self) -> Dict[str, str]:
+        return {"type": self.proxy_type, "address": self.current_proxy} if self.current_proxy else None
+
+    def _configure_session(self):
+        if self.current_proxy and self.proxy_type:
+            self.session.proxies.update({
+                "http": f"{self.proxy_type}://{self.current_proxy}",
+                "https": f"{self.proxy_type}://{self.current_proxy}"
+            })
+        else:
+            self.session.proxies.clear()
+
+    def enable_proxy_rotation(self, interval: int = 60):
+        """Enables automatic proxy rotation."""
+        if not any(self.proxies.values()):
+            self.logger.warning("No proxies available for rotation.")
+            return
+        self.proxy_rotation_enabled = True
+        self.rotation_interval = interval
+        self.logger.info(f"Proxy rotation enabled with interval: {interval} seconds.")
+        self._start_rotation_timer() # Start the rotation timer
+
+    def disable_proxy_rotation(self):
+        """Disables automatic proxy rotation."""
+        self.proxy_rotation_enabled = False
+        self._stop_rotation_timer()
+        self.logger.info("Proxy rotation disabled.")
+
+    def _start_rotation_timer(self):
+        """Starts the proxy rotation timer."""
+        if self.proxy_rotation_enabled:
+            self._rotate_proxy()
+            self._rotation_timer = threading.Timer(self.rotation_interval, self._start_rotation_timer)
+            self._rotation_timer.start()
+
+    def _stop_rotation_timer(self):
+        """Stops the proxy rotation timer."""
+        if self._rotation_timer:
+            self._rotation_timer.cancel()
+            self._rotation_timer = None
+
+    def _rotate_proxy(self):
+        """Rotates to the next available proxy."""
+        if not self.proxy_rotation_enabled:
+            return
+
+        available_proxies = []
+        for proxy_type, proxies in self.proxies.items():
+            available_proxies.extend([(proxy_type, proxy) for proxy in proxies])
+
+        if not available_proxies:
+            self.logger.warning("No proxies available for rotation.")
+            self.clear_proxy()
+            return
+
+        if self.current_proxy:
+            current_index = -1
+            for i, (proxy_type, proxy) in enumerate(available_proxies):
+                if proxy == self.current_proxy and proxy_type == self.proxy_type:
+                    current_index = i
+                    break
+            next_index = (current_index + 1) % len(available_proxies)
+        else:
+            next_index = random.randint(0, len(available_proxies) - 1)
+
+        next_proxy_type, next_proxy_address = available_proxies[next_index]
+        self.set_proxy(next_proxy_type, next_proxy_address)
+        self.logger.info(f"Rotated proxy to {next_proxy_type}: {next_proxy_address}")
+
+    def test_proxy(self, url: str = "https://www.google.com", timeout: int = 5) -> bool:
+        """Tests the current proxy by making a request to the given URL."""
+        if not self.current_proxy:
+            self.logger.warning("No proxy set to test.")
+            return False
+        try:
+            response = self.session.get(url, timeout=timeout)
+            response.raise_for_status()  # Raise HTTPError for bad responses (4xx or 5xx)
+            self.logger.info(f"Proxy {self.proxy_type}:{self.current_proxy} is working.")
+            return True
+        except requests.exceptions.RequestException as e:
+            self.logger.error(f"Proxy {self.proxy_type}:{self.current_proxy} test failed: {e}")
+            return False
+
+    def get_session(self) -> requests.Session:
+        """Returns the current requests session with configured proxy."""
+        return self.session
diff --git a/src/threat_intelligence.py b/src/threat_intelligence.py
index 5583fdb..35c4303 100644
--- a/src/threat_intelligence.py
+++ b/src/threat_intelligence.py
@@ -23,7 +23,6 @@ async def fetch_all_data(self):
         return await asyncio.gather(*tasks)
 
     def process_data(self, data):
-        # Placeholder for data processing logic
         processed_data = []
         for source_data in data:
             for threat in source_data:
diff --git a/src/vulnerability_scanner.py b/src/vulnerability_scanner.py
index f989dea..90361ce 100644
--- a/src/vulnerability_scanner.py
+++ b/src/vulnerability_scanner.py
@@ -6,7 +6,6 @@ def __init__(self):
 
     def scan(self, target):
         logging.info(f"Scanning target: {target}")
-        # Placeholder for scanning logic
         vulnerabilities = self.detect_vulnerabilities(target)
         self.scan_results.append({
             "target": target,
@@ -15,11 +14,13 @@ def scan(self, target):
         return vulnerabilities
 
     def detect_vulnerabilities(self, target):
-        # Placeholder for vulnerability detection logic
-        vulnerabilities = [
-            {"id": "CVE-2021-1234", "description": "Sample vulnerability 1", "severity": "High"},
-            {"id": "CVE-2021-5678", "description": "Sample vulnerability 2", "severity": "Medium"}
-        ]
+        logging.info(f"Detecting vulnerabilities for target: {target}")
+        vulnerabilities = []
+        # Example vulnerability detection logic
+        if "example.com" in target:
+            vulnerabilities.append({"id": "CVE-2021-1234", "description": "Sample vulnerability 1", "severity": "High"})
+        if "test.com" in target:
+            vulnerabilities.append({"id": "CVE-2021-5678", "description": "Sample vulnerability 2", "severity": "Medium"})
         return vulnerabilities
 
     def render(self):
@@ -27,7 +28,6 @@ def render(self):
 
     def integrate_with_new_components(self, new_component_data):
         logging.info("Integrating with new components")
-        # Placeholder for integration logic with new components
         integrated_data = {
             "new_component_vulnerabilities": new_component_data.get("vulnerabilities", {})
         }
@@ -36,7 +36,6 @@ def integrate_with_new_components(self, new_component_data):
 
     def ensure_compatibility(self, existing_data, new_component_data):
         logging.info("Ensuring compatibility with existing vulnerability scanner logic")
-        # Placeholder for compatibility logic
         compatible_data = {
             "existing_vulnerabilities": existing_data.get("vulnerabilities", {}),
             "new_component_vulnerabilities": new_component_data.get("vulnerabilities", {})