iotsploit-core 0.0.6__tar.gz

iotsploit_core-0.0.6/PKG-INFO

@@ -0,0 +1,117 @@
+Metadata-Version: 2.3
+Name: iotsploit-core
+Version: 0.0.6
+Summary: IoTSploit core library (domain + ports + core) - IoT security testing framework
+License: GPL-3.0-or-later
+Keywords: iot,security,testing,pentest,vulnerability
+Author: IoTSploit Team
+Author-email: support@iotsploit.org
+Requires-Python: >=3.10,<4.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Security
+Classifier: Topic :: System :: Hardware
+Requires-Dist: dataclasses-json (>=0.6.3,<0.7.0)
+Requires-Dist: pluggy (>=1.3.0,<2.0.0)
+Project-URL: Documentation, https://www.iotsploit.org/
+Project-URL: Homepage, https://www.iotsploit.org/
+Project-URL: Repository, https://github.com/TKXB/iotsploit
+Description-Content-Type: text/markdown
+
+# iotsploit-core
+
+Minimal, standalone **core** library extracted from `zeekr_sat_main`.
+
+- **What it is**: domain models + ports (interfaces) + core orchestration.
+- **What it is not**: Django/ORM/Celery/Channels integrations (those are application-layer adapters).
+
+## Install
+
+Poetry (recommended):
+
+```bash
+cd iotsploit-core
+poetry install
+```
+
+Pip editable:
+
+```bash
+pip install -e iotsploit-core
+```
+
+## Use (quick start)
+
+Verify it imports:
+
+```python
+import iotsploit_core
+print(iotsploit_core.__version__)
+```
+
+### Exploit plugins (manager)
+
+You wire this manager with **your own adapters** that implement `iotsploit_core.ports`.
+
+```python
+from iotsploit_core.core.exploit_manager import ExploitPluginManager
+
+mgr = ExploitPluginManager(
+    plugin_repo=...,   # implements PluginMetaRepository
+    group_repo=...,    # implements PluginGroupRepository
+    task_runner=...,   # implements TaskRunner (optional async delegation)
+)
+
+print(mgr.list_plugins())
+# mgr.execute_plugin("SomePlugin", target=..., parameters={...})
+```
+
+Default exploit plugin dir:
+- `IOTSPLOIT_EXPLOIT_PLUGINS_DIR` (or legacy `SAT_EXPLOIT_PLUGINS_DIR`)
+- fallback: `./plugins/exploits`
+
+### Device drivers (manager)
+
+```python
+from iotsploit_core.core.device_manager import DeviceDriverManager
+
+dm = DeviceDriverManager(
+    driver_state_repo=...,  # implements DriverStateRepository
+)
+
+print(dm.list_drivers())
+# dm.scan_devices("drv_xxx")
+```
+
+Default device plugin dir:
+- `IOTSPLOIT_DEVICE_PLUGINS_DIR` (or legacy `SAT_DEVICE_PLUGINS_DIR`)
+- fallback: `<repo_root>/plugins/devices`
+
+### Streaming (optional)
+
+Core uses a safe **Noop** backend by default. In a web runtime, inject a real backend:
+
+```python
+from iotsploit_core.core.stream_manager import StreamManager
+
+# StreamManager.configure_backend(MyBackend())
+```
+
+## Package layout
+
+- `iotsploit_core.domain`: pure dataclasses/enums (no I/O)
+- `iotsploit_core.ports`: interfaces to be implemented by adapters
+- `iotsploit_core.core`: orchestration (plugin/device/tool managers)
+
+## Notes
+
+- `iotsploit_core.core.device_config` is **deprecated** (device config should live in DB via app-layer adapters).
+
+

iotsploit_core-0.0.6/README.md

@@ -0,0 +1,89 @@
+# iotsploit-core
+
+Minimal, standalone **core** library extracted from `zeekr_sat_main`.
+
+- **What it is**: domain models + ports (interfaces) + core orchestration.
+- **What it is not**: Django/ORM/Celery/Channels integrations (those are application-layer adapters).
+
+## Install
+
+Poetry (recommended):
+
+```bash
+cd iotsploit-core
+poetry install
+```
+
+Pip editable:
+
+```bash
+pip install -e iotsploit-core
+```
+
+## Use (quick start)
+
+Verify it imports:
+
+```python
+import iotsploit_core
+print(iotsploit_core.__version__)
+```
+
+### Exploit plugins (manager)
+
+You wire this manager with **your own adapters** that implement `iotsploit_core.ports`.
+
+```python
+from iotsploit_core.core.exploit_manager import ExploitPluginManager
+
+mgr = ExploitPluginManager(
+    plugin_repo=...,   # implements PluginMetaRepository
+    group_repo=...,    # implements PluginGroupRepository
+    task_runner=...,   # implements TaskRunner (optional async delegation)
+)
+
+print(mgr.list_plugins())
+# mgr.execute_plugin("SomePlugin", target=..., parameters={...})
+```
+
+Default exploit plugin dir:
+- `IOTSPLOIT_EXPLOIT_PLUGINS_DIR` (or legacy `SAT_EXPLOIT_PLUGINS_DIR`)
+- fallback: `./plugins/exploits`
+
+### Device drivers (manager)
+
+```python
+from iotsploit_core.core.device_manager import DeviceDriverManager
+
+dm = DeviceDriverManager(
+    driver_state_repo=...,  # implements DriverStateRepository
+)
+
+print(dm.list_drivers())
+# dm.scan_devices("drv_xxx")
+```
+
+Default device plugin dir:
+- `IOTSPLOIT_DEVICE_PLUGINS_DIR` (or legacy `SAT_DEVICE_PLUGINS_DIR`)
+- fallback: `<repo_root>/plugins/devices`
+
+### Streaming (optional)
+
+Core uses a safe **Noop** backend by default. In a web runtime, inject a real backend:
+
+```python
+from iotsploit_core.core.stream_manager import StreamManager
+
+# StreamManager.configure_backend(MyBackend())
+```
+
+## Package layout
+
+- `iotsploit_core.domain`: pure dataclasses/enums (no I/O)
+- `iotsploit_core.ports`: interfaces to be implemented by adapters
+- `iotsploit_core.core`: orchestration (plugin/device/tool managers)
+
+## Notes
+
+- `iotsploit_core.core.device_config` is **deprecated** (device config should live in DB via app-layer adapters).
+

iotsploit_core-0.0.6/pyproject.toml

@@ -0,0 +1,40 @@
+[tool.poetry]
+name = "iotsploit-core"
+version = "0.0.6"
+description = "IoTSploit core library (domain + ports + core) - IoT security testing framework"
+authors = ["IoTSploit Team <support@iotsploit.org>"]
+readme = "README.md"
+license = "GPL-3.0-or-later"
+homepage = "https://www.iotsploit.org/"
+repository = "https://github.com/TKXB/iotsploit"
+documentation = "https://www.iotsploit.org/"
+keywords = ["iot", "security", "testing", "pentest", "vulnerability"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Information Technology",
+    "License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)",
+    "Topic :: Security",
+    "Topic :: System :: Hardware",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+packages = [{ include = "iotsploit_core", from = "src" }]
+
+[tool.poetry.dependencies]
+python = ">=3.10,<4.0"
+pluggy = "^1.3.0"
+dataclasses-json = "^0.6.3"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^7.4.0"
+
+[build-system]
+requires = ["poetry-core>=1.8.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = ["-q"]

iotsploit_core-0.0.6/src/iotsploit_core/__init__.py

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

iotsploit_core-0.0.6/src/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-0.0.6/src/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-0.0.6/src/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