iotsploit-core 0.0.6__py3-none-any.whl

iotsploit_core/__init__.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+__all__ = ["__version__"]
+
+__version__ = "0.1.0"
+
+

iotsploit_core/context.py

@@ -0,0 +1,27 @@
+"""
+Plugin Context for Backend Injection.
+
+This module provides a typed context object for injecting platform-specific
+backends into plugins. This avoids magic string keys and provides better
+type safety and IDE support.
+"""
+
+from dataclasses import dataclass
+from typing import Optional
+
+from iotsploit_core.ports.wifi_backend import WifiBackend
+
+
+@dataclass
+class PluginContext:
+    """
+    Context object for injecting platform-specific backends into plugins.
+    
+    This provides a structured way to pass backends to plugins, avoiding
+    dictionary-based injection with magic string keys. As new backends are
+    added, they can be added as optional fields here.
+    
+    Attributes:
+        wifi: Optional WiFi backend instance
+    """
+    wifi: Optional[WifiBackend] = None

iotsploit_core/core/base_plugin.py

@@ -0,0 +1,290 @@
+import threading
+import logging
+from typing import Dict, Any, List, Optional
+from iotsploit_core.core.stream_manager import StreamManager, StreamWrapper
+from iotsploit_core.domain.device import Device
+from iotsploit_core.core.device_spec import DeviceState
+
+logger = logging.getLogger(__name__)
+
+class BasePlugin:
+    def __init__(self, info: Dict[str, Any] = None):
+        self.info = info or {}
+
+    def update_info(self, new_info: Dict[str, Any]):
+        self.info.update(new_info)
+
+    def get_info(self) -> Dict[str, Any]:
+        return self.info
+
+class BaseDeviceDriver(BasePlugin):
+    """Base class for device drivers implementing the DevicePluginSpec interface"""
+    
+    def __init__(self, info: Dict[str, Any] = None):
+        super().__init__(info)
+        # Device management
+        self.device = None
+        self._devices: Dict[str, Device] = {}
+        
+        # Stream management (core-safe: StreamManager is a facade that falls back to Noop if
+        # Django/Channels is unavailable).
+        self.stream_manager = StreamManager()
+        self.stream_wrapper = StreamWrapper(self.stream_manager)
+        
+        # Acquisition management
+        self.acquisition_thread = None
+        self.is_acquiring = threading.Event()
+
+        # 确保 supported_commands 总是存在
+        if not hasattr(self, 'supported_commands'):
+            self.supported_commands = {}  # format: {'command': 'description'}
+
+    def get_supported_commands(self) -> Dict[str, str]:
+        """Get dictionary of supported commands and their descriptions"""
+        if not hasattr(self, 'supported_commands'):
+            return {}
+        return self.supported_commands
+
+    # Base implementations of device lifecycle methods
+    def scan(self) -> List[Device]:
+        """Scan for available devices"""
+        try:
+            devices = self._scan_impl()
+            for device in devices:
+                self._register_device(device)
+            return devices
+        except Exception as e:
+            logger.error(f"Scan failed: {str(e)}")
+            raise
+
+    def initialize(self, device: Device) -> bool:
+        """Initialize device"""
+        try:
+            return self._initialize_impl(device)
+        except Exception as e:
+            logger.error(f"Initialization failed: {str(e)}")
+            raise
+
+    def connect(self, device: Device) -> bool:
+        """Connect to device"""
+        try:
+            return self._connect_impl(device)
+        except Exception as e:
+            logger.error(f"Connection failed: {str(e)}")
+            raise
+
+    def command(self, device: Device, command: str, args: Optional[Dict] = None) -> Optional[str]:
+        """Execute command"""
+        try:
+            return self._command_impl(device, command, args)
+        except Exception as e:
+            logger.error(f"Command execution failed: {str(e)}")
+            raise
+
+    def reset(self, device: Device) -> bool:
+        """Reset device"""
+        try:
+            return self._reset_impl(device)
+        except Exception as e:
+            logger.error(f"Reset failed: {str(e)}")
+            raise
+
+    def close(self, device: Device) -> bool:
+        """Close device"""
+        try:
+            return self._close_impl(device)
+        except Exception as e:
+            logger.error(f"Close failed: {str(e)}")
+            raise
+
+    def recovery(self, device: Device, recovery_type: str, **kwargs) -> dict:
+        """
+        Execute recovery operations on device
+        
+        Args:
+            device: Device to perform recovery on
+            recovery_type: Type of recovery operation (e.g., 'flash_firmware', 'openocd_attach')
+            **kwargs: Additional parameters for recovery operation
+            
+        Returns:
+            dict: Recovery operation result with standardized format
+        """
+        try:
+            logger.info(f"Starting recovery operation '{recovery_type}' on device {device.device_id}")
+            result = self._recovery_impl(device, recovery_type, **kwargs)
+            
+            # Ensure standardized response format
+            if not isinstance(result, dict):
+                result = {"status": "error", "message": "Invalid response format from recovery implementation"}
+            
+            # Add standard fields if missing
+            if "status" not in result:
+                result["status"] = "unknown"
+            if "message" not in result:
+                result["message"] = f"Recovery operation '{recovery_type}' completed"
+                
+            logger.info(f"Recovery operation '{recovery_type}' completed with status: {result.get('status')}")
+            return result
+            
+        except NotImplementedError:
+            return {
+                "status": "error",
+                "message": f"Recovery operation '{recovery_type}' not supported by this driver"
+            }
+        except Exception as e:
+            logger.error(f"Recovery operation failed: {str(e)}")
+            return {
+                "status": "error",
+                "message": f"Recovery operation failed: {str(e)}"
+            }
+
+    def get_supported_recovery_operations(self) -> list:
+        """
+        Get list of supported recovery operations for this driver
+        
+        Returns:
+            list: List of supported recovery operation names
+        """
+        try:
+            return self._get_supported_recovery_operations_impl()
+        except NotImplementedError:
+            return []
+        except Exception as e:
+            logger.error(f"Error getting supported recovery operations: {str(e)}")
+            return []
+
+    # Streaming and acquisition control
+    def start_streaming(self, device: Device):
+        """启动设备数据流（包括数据采集和WebSocket分发）"""
+        try:
+            logger.info(f"Starting streaming for device {device.device_id}")
+            self.stream_wrapper.register_stream(device.device_id)
+            self.start_acquisition(device)
+        except Exception as e:
+            logger.error(f"Failed to start streaming: {e}")
+            self.stop_streaming(device)
+            raise
+
+    def stop_streaming(self, device: Device):
+        """停止设备数据流（包括数据采集和WebSocket分发）"""
+        try:
+            logger.info(f"Stopping streaming for device {device.device_id}")
+            self.stop_acquisition(device)
+            self.stream_wrapper.unregister_stream(device.device_id)
+            self.stream_wrapper.stop_broadcast(device.device_id)
+        except Exception as e:
+            logger.error(f"Error stopping streaming: {e}")
+            raise
+
+    def start_acquisition(self, device: Device):
+        """启动设备数据采集（不包括WebSocket分发）"""
+        try:
+            logger.info(f"Starting data acquisition for device {device.device_id}")
+            self._setup_acquisition(device)
+            if not self.is_acquiring.is_set():
+                self.is_acquiring.set()
+                self.acquisition_thread = threading.Thread(
+                    target=self._acquisition_loop,
+                    name=f'{self.__class__.__name__}_Acquisition'
+                )
+                self.acquisition_thread.daemon = True
+                self.acquisition_thread.start()
+        except Exception as e:
+            logger.error(f"Failed to start acquisition: {e}")
+            self.stop_acquisition(device)
+            raise
+
+    def stop_acquisition(self, device: Device):
+        """停止设备数据采集（不包括WebSocket分发）"""
+        logger.info(f"Stopping data acquisition for device {device.device_id}")
+        self.is_acquiring.clear()
+        if self.acquisition_thread and self.acquisition_thread.is_alive():
+            self.acquisition_thread.join(timeout=1.0)
+            self.acquisition_thread = None
+        try:
+            self._cleanup_acquisition(device)
+        except Exception as e:
+            logger.error(f"Error in acquisition cleanup: {e}")
+            raise
+
+    # Methods to be implemented by derived classes
+    def _scan_impl(self) -> List[Device]:
+        """Implementation of device scanning"""
+        raise NotImplementedError
+
+    def _initialize_impl(self, device: Device) -> bool:
+        """Implementation of device initialization"""
+        raise NotImplementedError
+
+    def _connect_impl(self, device: Device) -> bool:
+        """Implementation of device connection"""
+        raise NotImplementedError
+
+    def _command_impl(self, device: Device, command: str, args: Optional[Dict] = None) -> Optional[str]:
+        """Implementation of command execution"""
+        raise NotImplementedError
+
+    def _reset_impl(self, device: Device) -> bool:
+        """Implementation of device reset"""
+        raise NotImplementedError
+
+    def _close_impl(self, device: Device) -> bool:
+        """Implementation of device closure"""
+        raise NotImplementedError
+
+    def _recovery_impl(self, device: Device, recovery_type: str, **kwargs) -> dict:
+        """
+        Implementation of recovery operations
+        
+        Args:
+            device: Device to perform recovery on
+            recovery_type: Type of recovery operation
+            **kwargs: Additional parameters
+            
+        Returns:
+            dict: Recovery result with format:
+                {
+                    "status": "success|error|warning",
+                    "message": "Human readable message",
+                    "execution_time": float,  # optional
+                    "details": dict  # optional additional details
+                }
+        """
+        raise NotImplementedError
+
+    def _get_supported_recovery_operations_impl(self) -> list:
+        """
+        Implementation of supported recovery operations listing
+        
+        Returns:
+            list: List of supported recovery operation names
+        """
+        raise NotImplementedError
+
+    def _setup_acquisition(self, device: Device):
+        """设备特定的采集初始化"""
+        pass
+
+    def _cleanup_acquisition(self, device: Device):
+        """设备特定的采集清理"""
+        pass
+
+    def _acquisition_loop(self):
+        """数据采集循环的具体实现"""
+        raise NotImplementedError
+
+    def get_device(self, device_id: str) -> Optional[Device]:
+        """获取设备实例"""
+        return self._devices.get(device_id)
+
+    def _register_device(self, device: Device):
+        """注册设备"""
+        self._devices[device.device_id] = device
+
+    def __del__(self):
+        """Cleanup when object is destroyed"""
+        try:
+            if self.device and hasattr(self, 'state') and self.state != DeviceState.DISCONNECTED:
+                self.close(self.device)
+        except Exception as e:
+            logger.error(f"Error during cleanup: {e}")

iotsploit_core/core/device_config.py

@@ -0,0 +1,105 @@
+"""
+DEPRECATED: This module is deprecated and will be removed in a future version.
+
+Device configuration is now managed entirely through the SQLite database.
+Use an application-layer adapter (e.g. Django/SQLAlchemy) instead.
+
+For importing devices from JSON, use the 'device_import' CLI command.
+"""
+import os
+import json
+import warnings
+from typing import Dict, Optional
+import logging
+from iotsploit_core.domain.device import Device, DeviceType
+from json import JSONEncoder
+
+logger = logging.getLogger(__name__)
+
+# Emit deprecation warning when module is imported
+warnings.warn(
+    "device_config module is deprecated. Device configuration is now managed through the database. "
+    "Use an application-layer adapter (e.g. Django/SQLAlchemy) instead.",
+    DeprecationWarning,
+    stacklevel=2
+)
+
+class DeviceJSONEncoder(JSONEncoder):
+    """自定义JSON编码器，处理特殊类型的序列化
+    
+    DEPRECATED: This class is deprecated. Use database storage instead.
+    """
+    def default(self, obj):
+        if isinstance(obj, DeviceType):
+            return obj.value
+        if isinstance(obj, Device):
+            # 使用 DeviceStore 中的序列化方法
+            from iotsploit_core.core.device_store import DeviceStore
+            return DeviceStore()._device_to_dict(obj)
+        return super().default(obj)
+
+class DeviceConfigManager:
+    """设备配置管理器
+    
+    DEPRECATED: This class is deprecated. 
+    Device configuration is now managed entirely through the SQLite database.
+    Use an application-layer adapter (e.g. Django/SQLAlchemy) for device operations.
+    """
+    
+    def __init__(self):
+        warnings.warn(
+            "DeviceConfigManager is deprecated. Use an application-layer adapter (e.g. Django/SQLAlchemy) instead.",
+            DeprecationWarning,
+            stacklevel=2
+        )
+        self.config_file = "conf/devices.json"
+        
+    def load_configs(self) -> Dict[str, Dict]:
+        """加载设备配置"""
+        if not os.path.exists(self.config_file):
+            return {"devices": []}
+            
+        try:
+            with open(self.config_file, 'r') as f:
+                return json.load(f)
+        except json.JSONDecodeError as e:
+            logger.error(f"Error decoding JSON from {self.config_file}: {e}")
+            return {"devices": []}
+        except Exception as e:
+            logger.error(f"Error loading config file {self.config_file}: {e}")
+            return {"devices": []}
+            
+    def save_device_config(self, device_dict: Dict):
+        """保存设备配置到持久化存储"""
+        try:
+            configs = self.load_configs()
+            # 确保configs中有devices键
+            if 'devices' not in configs:
+                configs['devices'] = []
+            
+            # 更新或添加设备配置
+            device_id = device_dict['device_id']
+            device_updated = False
+            for i, device in enumerate(configs['devices']):
+                if device.get('device_id') == device_id:
+                    configs['devices'][i] = device_dict
+                    device_updated = True
+                    break
+                
+            if not device_updated:
+                configs['devices'].append(device_dict)
+            
+            os.makedirs(os.path.dirname(self.config_file), exist_ok=True)
+            with open(self.config_file, 'w') as f:
+                json.dump(configs, f, indent=2, cls=DeviceJSONEncoder)
+                
+        except Exception as e:
+            logger.error(f"Error saving device configuration: {e}")
+            
+    def get_device_config(self, device_id: str) -> Optional[Dict]:
+        """获取特定设备的配置"""
+        configs = self.load_configs()
+        for device in configs.get('devices', []):
+            if device.get('device_id') == device_id:
+                return device
+        return None