iotsploit-core 0.0.6__py3-none-any.whl

iotsploit_core/core/exploit_spec.py

@@ -0,0 +1,73 @@
+import pluggy
+from typing import Any, Dict, Optional
+from dataclasses import dataclass
+
+hookspec = pluggy.HookspecMarker("exploit_mgr")
+
+@dataclass
+class AsyncExploitResult:
+    status: bool = None
+    message: str = ""
+    progress: float = 0
+    data: Dict[str, Any] = None
+
+    def update(self, status=None, message=None, progress=None, data=None):
+        if status is not None:
+            self.status = status
+        if message is not None:
+            self.message = message
+        if progress is not None:
+            self.progress = progress
+        if data is not None:
+            self.data = data
+
+class ExploitResult:
+    def __init__(self, success: bool, message: str, data: Dict[str, Any]):
+        self.success = success
+        self.message = message
+        self.data = data
+
+    def __repr__(self):
+        return f"ExploitResult(success={self.success}, message={self.message}, data={self.data})"
+
+class ExploitPluginSpec:
+    @hookspec
+    def initialize(self, ctx: Optional[Any] = None, device_plugin: Optional[Any] = None):
+        """
+        Initialize the exploit plugin.
+
+        Notes:
+        - This project supports two initialization styles:
+          - New style: initialize(ctx) where ctx is a platform backend context (e.g., PluginContext)
+          - Legacy style: initialize() or initialize(device_plugin)
+        - Hookspec must declare all argument names used by hookimpls; otherwise pluggy will reject plugins.
+        
+        :param ctx: Platform/backend context object (e.g., PluginContext), optional
+        :param device_plugin: Legacy device plugin instance (e.g., JLinkAbility, USBAbility), optional
+        """
+
+    @hookspec
+    def execute(self, target: Optional[Any] = None, parameters: Optional[dict] = None) -> ExploitResult:
+        """
+        Execute the exploit on the specified target using the initialized device plugin.
+        
+        :param target: The target of the exploit (e.g., an address or identifier)
+        :param parameters: Dictionary of parameters for the exploit
+        :return: An ExploitResult object containing the result of the exploit
+        """
+
+    @hookspec
+    async def execute_async(self, target: Optional[Any] = None, parameters: Optional[dict] = None) -> AsyncExploitResult:
+        """
+        Execute the exploit asynchronously on the specified target using the initialized device plugin.
+        
+        :param target: The target of the exploit (e.g., an address or identifier)
+        :param parameters: Dictionary of parameters for the exploit
+        :return: An AsyncExploitResult object containing the result of the exploit
+        """
+
+    @hookspec
+    def cleanup(self):
+        """
+        Perform any necessary cleanup after the exploit execution.
+        """

iotsploit_core/core/stream_manager.py

@@ -0,0 +1,157 @@
+from __future__ import annotations
+
+"""Core stream facade (no Django/Channels hard dependency).
+
+This module intentionally avoids importing Django/Channels/Redis at import time, so that
+`iotsploit_core.core` can be imported in standalone contexts. In a Django runtime, a real
+backend should be injected during app startup (composition root).
+"""
+
+import asyncio
+from queue import Queue
+from typing import Dict, Optional
+
+from iotsploit_core.domain.stream import StreamAction, StreamData, StreamSource, StreamType
+from iotsploit_core.ports.stream_backend import StreamBackend
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+# Re-export domain stream types for backward compatibility with existing imports.
+__all__ = [
+    "StreamType",
+    "StreamSource",
+    "StreamAction",
+    "StreamData",
+    "StreamWrapper",
+    "StreamManager",
+]
+
+
+class StreamWrapper:
+    """Wrapper class to handle async operations for stream management."""
+
+    def __init__(self, stream_manager):
+        self.stream_manager = stream_manager
+
+    def _get_or_create_loop(self):
+        try:
+            loop = asyncio.get_event_loop()
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+        return loop
+
+    def register_stream(self, channel):
+        loop = self._get_or_create_loop()
+        if loop.is_running():
+            return loop.create_task(self.stream_manager.register_stream(channel))
+        return loop.run_until_complete(self.stream_manager.register_stream(channel))
+
+    def unregister_stream(self, channel):
+        loop = self._get_or_create_loop()
+        if loop.is_running():
+            return loop.create_task(self.stream_manager.unregister_stream(channel))
+        return loop.run_until_complete(self.stream_manager.unregister_stream(channel))
+
+    def stop_broadcast(self, channel):
+        loop = self._get_or_create_loop()
+        if loop.is_running():
+            return loop.create_task(self.stream_manager.stop_broadcast(channel))
+        return loop.run_until_complete(self.stream_manager.stop_broadcast(channel))
+
+    def broadcast_data(self, stream_data):
+        loop = self._get_or_create_loop()
+        if loop.is_running():
+            return loop.create_task(self.stream_manager.broadcast_data(stream_data))
+        return loop.run_until_complete(self.stream_manager.broadcast_data(stream_data))
+
+
+class _NoopStreamBackend:
+    """Fallback stream manager when Django/Channels is unavailable.
+
+    Keeps API shape compatible but does not broadcast over WebSocket.
+    """
+
+    def __init__(self):
+        self._client_queues: Dict[str, Queue] = {}
+
+    async def register_stream(self, channel: str):
+        if channel not in self._client_queues:
+            self._client_queues[channel] = Queue()
+
+    async def unregister_stream(self, channel: str):
+        self._client_queues.pop(channel, None)
+
+    async def broadcast_data(self, stream_data: StreamData):
+        # For CLIENT source, enqueue so server-side can consume.
+        if stream_data.source == StreamSource.CLIENT:
+            q = self._client_queues.get(stream_data.channel)
+            if q is not None:
+                q.put(stream_data)
+
+    async def stop_broadcast(self, channel: str):
+        return
+
+    def get_active_channels(self):
+        return list(self._client_queues.keys())
+
+    def get_broadcast_channels(self):
+        return []
+
+    def get_client_data(self) -> Optional[StreamData]:
+        for ch in list(self._client_queues.keys()):
+            q = self._client_queues[ch]
+            if not q.empty():
+                return q.get_nowait()
+        return None
+
+
+class StreamManager:
+    """Core stream manager that delegates to an injected backend.
+
+    Default backend is a Noop implementation. Django wiring should inject a real backend
+    during app startup (composition root).
+    """
+
+    _instance = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(self):
+        if hasattr(self, "_backend"):
+            return
+        self._backend: StreamBackend = _NoopStreamBackend()
+
+    @classmethod
+    def configure_backend(cls, backend: StreamBackend) -> None:
+        """Wire a backend implementation (to be called from Django wiring)."""
+
+        inst = cls()
+        inst._backend = backend
+
+    # Delegate API
+    async def register_stream(self, channel: str):
+        return await self._backend.register_stream(channel)
+
+    async def unregister_stream(self, channel: str):
+        return await self._backend.unregister_stream(channel)
+
+    async def broadcast_data(self, stream_data: StreamData):
+        return await self._backend.broadcast_data(stream_data)
+
+    async def stop_broadcast(self, channel: str):
+        return await self._backend.stop_broadcast(channel)
+
+    def get_active_channels(self):
+        return self._backend.get_active_channels()
+
+    def get_broadcast_channels(self):
+        return self._backend.get_broadcast_channels()
+
+    def get_client_data(self) -> Optional[StreamData]:
+        return self._backend.get_client_data()

iotsploit_core/core/tool_config.py

@@ -0,0 +1,430 @@
+#!/usr/bin/env python3
+"""
+JSON-based Tool Configuration Management
+=======================================
+
+Manages tool configurations using JSON files instead of hardcoded Python dictionaries.
+This allows for easy modification of tool definitions without code changes.
+"""
+
+import json
+import logging
+from pathlib import Path
+from typing import Dict, List, Optional, Any, Union
+from dataclasses import dataclass, field, asdict
+from enum import Enum
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class ToolConfig:
+    """Tool configuration data structure"""
+    name: str
+    aliases: List[str] = field(default_factory=list)
+    min_version: Optional[str] = None
+    platforms: List[str] = field(default_factory=lambda: ['linux', 'darwin', 'windows'])
+    path: Optional[str] = None
+    description: Optional[str] = None
+    category: Optional[str] = None
+    required: bool = False
+    install_hint: Optional[str] = None
+    version_command: List[str] = field(default_factory=lambda: ['--version'])
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for JSON serialization"""
+        return asdict(self)
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'ToolConfig':
+        """Create from dictionary loaded from JSON"""
+        # Filter out fields that are not part of ToolConfig constructor
+        # These fields are runtime fields that should not be passed to constructor
+        excluded_fields = {
+            'version', 'status', 'last_checked', 'metadata', 'dependencies',
+            'max_version'
+        }
+        
+        # Create a filtered copy of the data
+        filtered_data = {k: v for k, v in data.items() if k not in excluded_fields}
+        
+        return cls(**filtered_data)
+
+class ToolConfigManager:
+    """Manages tool configurations from JSON files"""
+    
+    def __init__(self, config_dir: Optional[Union[str, Path]] = None):
+        self.config_dir = Path(config_dir) if config_dir else self._get_default_config_dir()
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+        self.logger = logging.getLogger("tool_config")
+        self._tool_configs: Dict[str, ToolConfig] = {}
+        self._category_configs: Dict[str, Dict[str, Any]] = {}
+        
+        # Load configurations
+        self._load_all_configs()
+    
+    def _get_default_config_dir(self) -> Path:
+        """Get default configuration directory"""
+        # Use project root/configs/tools
+        project_root = Path(__file__).parent.parent.parent
+        return project_root / "configs" / "tools"
+    
+    def _load_all_configs(self):
+        """Load all tool configurations from JSON files"""
+        self.logger.info(f"Loading tool configurations from {self.config_dir}")
+        
+        # Load category configurations
+        self._load_category_configs()
+        
+        # Load individual tool configurations
+        self._load_tool_configs()
+        
+        self.logger.info(f"Loaded {len(self._tool_configs)} tool configurations")
+    
+    def _load_category_configs(self):
+        """Load category configuration files"""
+        category_files = list(self.config_dir.glob("*_category.json"))
+        
+        for category_file in category_files:
+            try:
+                with open(category_file, 'r', encoding='utf-8') as f:
+                    category_data = json.load(f)
+                
+                category_name = category_file.stem.replace('_category', '')
+                self._category_configs[category_name] = category_data
+                
+                self.logger.debug(f"Loaded category config: {category_name}")
+                
+            except Exception as e:
+                self.logger.error(f"Failed to load category config {category_file}: {e}")
+    
+    def _load_tool_configs(self):
+        """Load tool configuration files"""
+        # Load from category files
+        for category_name, category_data in self._category_configs.items():
+            tools = category_data.get('tools', [])
+            for tool_data in tools:
+                try:
+                    # Add category info to tool
+                    tool_data['category'] = category_name
+                    tool_config = ToolConfig.from_dict(tool_data)
+                    self._tool_configs[tool_config.name] = tool_config
+                    
+                    # Also register aliases
+                    for alias in tool_config.aliases:
+                        self._tool_configs[alias] = tool_config
+                        
+                except Exception as e:
+                    self.logger.error(f"Failed to load tool config {tool_data.get('name', 'unknown')}: {e}")
+        
+        # Load individual tool files
+        tool_files = [f for f in self.config_dir.glob("*.json") if not f.name.endswith('_category.json')]
+        
+        for tool_file in tool_files:
+            try:
+                with open(tool_file, 'r', encoding='utf-8') as f:
+                    tool_data = json.load(f)
+                
+                # Handle different JSON structures
+                if 'tools' in tool_data and isinstance(tool_data['tools'], list):
+                    # This is a tools collection file (like tools.json)
+                    tools = tool_data['tools']
+                    for tool_item in tools:
+                        try:
+                            tool_config = ToolConfig.from_dict(tool_item)
+                            self._tool_configs[tool_config.name] = tool_config
+                            
+                            # Also register aliases
+                            for alias in tool_config.aliases:
+                                self._tool_configs[alias] = tool_config
+                        except Exception as e:
+                            self.logger.error(f"Failed to load tool {tool_item.get('name', 'unknown')} from {tool_file.name}: {e}")
+                
+                elif isinstance(tool_data, list):
+                    # This is an array of tools
+                    tools = tool_data
+                    for tool_item in tools:
+                        try:
+                            tool_config = ToolConfig.from_dict(tool_item)
+                            self._tool_configs[tool_config.name] = tool_config
+                            
+                            # Also register aliases
+                            for alias in tool_config.aliases:
+                                self._tool_configs[alias] = tool_config
+                        except Exception as e:
+                            self.logger.error(f"Failed to load tool {tool_item.get('name', 'unknown')} from {tool_file.name}: {e}")
+                
+                elif 'name' in tool_data:
+                    # This is a single tool configuration
+                    tool_config = ToolConfig.from_dict(tool_data)
+                    self._tool_configs[tool_config.name] = tool_config
+                    
+                    # Also register aliases
+                    for alias in tool_config.aliases:
+                        self._tool_configs[alias] = tool_config
+                
+                else:
+                    self.logger.warning(f"Unrecognized tool config format in {tool_file.name}")
+                
+                self.logger.debug(f"Loaded tool config file: {tool_file.name}")
+                
+            except Exception as e:
+                self.logger.error(f"Failed to load tool config {tool_file}: {e}")
+    
+    def get_tool_config(self, tool_name: str) -> Optional[ToolConfig]:
+        """Get tool configuration by name or alias"""
+        return self._tool_configs.get(tool_name)
+    
+    def get_tools_by_category(self, category: str) -> List[ToolConfig]:
+        """Get all tools in a specific category"""
+        return [config for config in self._tool_configs.values() 
+                if config.category == category and config.name in self._tool_configs]
+    
+    def get_all_categories(self) -> List[str]:
+        """Get list of all categories"""
+        categories = set()
+        for config in self._tool_configs.values():
+            if config.category:
+                categories.add(config.category)
+        return sorted(list(categories))
+    
+    def get_category_info(self, category: str) -> Optional[Dict[str, Any]]:
+        """Get category information"""
+        return self._category_configs.get(category)
+    
+    def add_tool_config(self, tool_config: ToolConfig, save: bool = True) -> bool:
+        """Add a new tool configuration"""
+        try:
+            self._tool_configs[tool_config.name] = tool_config
+            
+            # Register aliases
+            for alias in tool_config.aliases:
+                self._tool_configs[alias] = tool_config
+            
+            if save:
+                self._save_tool_config(tool_config)
+            
+            self.logger.info(f"Added tool configuration: {tool_config.name}")
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"Failed to add tool config {tool_config.name}: {e}")
+            return False
+    
+    def _save_tool_config(self, tool_config: ToolConfig):
+        """Save tool configuration to JSON file"""
+        if tool_config.category:
+            # Save to category file
+            category_file = self.config_dir / f"{tool_config.category}_category.json"
+            
+            if category_file.exists():
+                with open(category_file, 'r', encoding='utf-8') as f:
+                    category_data = json.load(f)
+            else:
+                category_data = {
+                    "name": tool_config.category.title(),
+                    "description": f"Tools for {tool_config.category}",
+                    "tools": []
+                }
+            
+            # Add or update tool in category
+            tools = category_data.get('tools', [])
+            tool_dict = tool_config.to_dict()
+            del tool_dict['category']  # Don't store category in tool data
+            
+            # Remove existing tool if present
+            tools = [t for t in tools if t.get('name') != tool_config.name]
+            tools.append(tool_dict)
+            
+            category_data['tools'] = tools
+            
+            with open(category_file, 'w', encoding='utf-8') as f:
+                json.dump(category_data, f, indent=2, ensure_ascii=False)
+        else:
+            # Save as individual tool file
+            tool_file = self.config_dir / f"{tool_config.name}.json"
+            with open(tool_file, 'w', encoding='utf-8') as f:
+                json.dump(tool_config.to_dict(), f, indent=2, ensure_ascii=False)
+    
+    def remove_tool_config(self, tool_name: str) -> bool:
+        """Remove tool configuration"""
+        try:
+            if tool_name in self._tool_configs:
+                tool_config = self._tool_configs[tool_name]
+                
+                # Remove from memory
+                del self._tool_configs[tool_name]
+                for alias in tool_config.aliases:
+                    if alias in self._tool_configs:
+                        del self._tool_configs[alias]
+                
+                # Remove from file
+                self._remove_tool_from_file(tool_config)
+                
+                self.logger.info(f"Removed tool configuration: {tool_name}")
+                return True
+            else:
+                self.logger.warning(f"Tool configuration not found: {tool_name}")
+                return False
+                
+        except Exception as e:
+            self.logger.error(f"Failed to remove tool config {tool_name}: {e}")
+            return False
+    
+    def _remove_tool_from_file(self, tool_config: ToolConfig):
+        """Remove tool from its configuration file"""
+        if tool_config.category:
+            # Remove from category file
+            category_file = self.config_dir / f"{tool_config.category}_category.json"
+            
+            if category_file.exists():
+                with open(category_file, 'r', encoding='utf-8') as f:
+                    category_data = json.load(f)
+                
+                tools = category_data.get('tools', [])
+                tools = [t for t in tools if t.get('name') != tool_config.name]
+                category_data['tools'] = tools
+                
+                with open(category_file, 'w', encoding='utf-8') as f:
+                    json.dump(category_data, f, indent=2, ensure_ascii=False)
+        else:
+            # Remove individual tool file
+            tool_file = self.config_dir / f"{tool_config.name}.json"
+            if tool_file.exists():
+                tool_file.unlink()
+    
+    def reload_configs(self):
+        """Reload all configurations from files"""
+        self._tool_configs.clear()
+        self._category_configs.clear()
+        self._load_all_configs()
+        self.logger.info("Reloaded all tool configurations")
+    
+    def export_config(self, output_file: Union[str, Path]) -> bool:
+        """Export all configurations to a single JSON file"""
+        try:
+            output_path = Path(output_file)
+            
+            export_data = {
+                "categories": self._category_configs,
+                "tools": {name: config.to_dict() for name, config in self._tool_configs.items()
+                         if name == config.name}  # Only export primary names, not aliases
+            }
+            
+            with open(output_path, 'w', encoding='utf-8') as f:
+                json.dump(export_data, f, indent=2, ensure_ascii=False)
+            
+            self.logger.info(f"Exported configurations to {output_path}")
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"Failed to export configurations: {e}")
+            return False
+    
+    def import_config(self, input_file: Union[str, Path]) -> bool:
+        """Import configurations from a JSON file"""
+        try:
+            input_path = Path(input_file)
+            
+            with open(input_path, 'r', encoding='utf-8') as f:
+                import_data = json.load(f)
+            
+            # Import categories
+            categories = import_data.get('categories', {})
+            for category_name, category_data in categories.items():
+                self._category_configs[category_name] = category_data
+            
+            # Import tools
+            tools = import_data.get('tools', {})
+            for tool_name, tool_data in tools.items():
+                tool_config = ToolConfig.from_dict(tool_data)
+                self._tool_configs[tool_config.name] = tool_config
+                
+                # Register aliases
+                for alias in tool_config.aliases:
+                    self._tool_configs[alias] = tool_config
+            
+            self.logger.info(f"Imported configurations from {input_path}")
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"Failed to import configurations: {e}")
+            return False
+    
+    def validate_configs(self) -> Dict[str, List[str]]:
+        """Validate all tool configurations"""
+        issues = {
+            'missing_required_fields': [],
+            'invalid_platforms': [],
+            'duplicate_names': [],
+            'invalid_categories': []
+        }
+        
+        seen_names = set()
+        valid_platforms = {'linux', 'darwin', 'windows'}
+        
+        for tool_name, config in self._tool_configs.items():
+            # Skip aliases
+            if tool_name != config.name:
+                continue
+            
+            # Check required fields
+            if not config.name:
+                issues['missing_required_fields'].append(f"Tool missing name")
+            
+            # Check for duplicates
+            if config.name in seen_names:
+                issues['duplicate_names'].append(config.name)
+            seen_names.add(config.name)
+            
+            # Check platforms
+            for platform in config.platforms:
+                if platform not in valid_platforms:
+                    issues['invalid_platforms'].append(f"{config.name}: {platform}")
+            
+            # Check category exists
+            if config.category and config.category not in self._category_configs:
+                issues['invalid_categories'].append(f"{config.name}: {config.category}")
+        
+        return issues
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Get statistics about loaded configurations"""
+        unique_tools = {config.name: config for config in self._tool_configs.values()}
+        
+        stats = {
+            'total_tools': len(unique_tools),
+            'total_aliases': len(self._tool_configs) - len(unique_tools),
+            'categories': len(self._category_configs),
+            'tools_by_category': {},
+            'tools_by_platform': {'linux': 0, 'darwin': 0, 'windows': 0},
+            'required_tools': 0,
+            'optional_tools': 0
+        }
+        
+        for config in unique_tools.values():
+            # Count by category
+            category = config.category or 'uncategorized'
+            stats['tools_by_category'][category] = stats['tools_by_category'].get(category, 0) + 1
+            
+            # Count by platform
+            for platform in config.platforms:
+                if platform in stats['tools_by_platform']:
+                    stats['tools_by_platform'][platform] += 1
+            
+            # Count required vs optional
+            if config.required:
+                stats['required_tools'] += 1
+            else:
+                stats['optional_tools'] += 1
+        
+        return stats
+
+# Singleton instance
+_config_manager = None
+
+def get_tool_config_manager() -> ToolConfigManager:
+    """Get singleton tool configuration manager"""
+    global _config_manager
+    if _config_manager is None:
+        _config_manager = ToolConfigManager()
+    return _config_manager