iotsploit-django 0.0.6__tar.gz

iotsploit_django-0.0.6/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.3
+Name: iotsploit-django
+Version: 0.0.6
+Summary: IoTSploit Django ring package (HTTP/WS/ORM/Celery + composition root)
+License: GPL-3.0-or-later
+Keywords: iot,security,testing,pentest,django
+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
+Provides-Extra: platforms
+Requires-Dist: Django (>=4.2,<5.0)
+Requires-Dist: SQLAlchemy (>=2.0)
+Requires-Dist: aiohttp (>=3.9)
+Requires-Dist: asgiref (>=3.7)
+Requires-Dist: bluepy (>=1.3)
+Requires-Dist: celery (>=5.3)
+Requires-Dist: channels (>=4.0)
+Requires-Dist: channels-redis (>=4.1)
+Requires-Dist: colorlog (>=6.8)
+Requires-Dist: cryptography (>=41.0)
+Requires-Dist: daphne (>=4.0)
+Requires-Dist: django-cors-headers (>=4.0)
+Requires-Dist: django-csp (>=3.7,<4.0)
+Requires-Dist: django-extensions (>=3.2)
+Requires-Dist: elevate (>=0.1)
+Requires-Dist: iotsploit-core (>=0.0.6,<0.0.7)
+Requires-Dist: iotsploit-platforms (>=0.0.6,<0.0.7) ; extra == "platforms"
+Requires-Dist: mistune (>=3.0)
+Requires-Dist: netifaces (>=0.11)
+Requires-Dist: psutil (>=5.9)
+Requires-Dist: pwntools (>=4.11)
+Requires-Dist: pydantic (>=2.0)
+Requires-Dist: pyusb (>=1.2)
+Requires-Dist: pywifi (>=1.1)
+Requires-Dist: redis (>=5.0)
+Requires-Dist: requests (>=2.31)
+Requires-Dist: smbus2 (>=0.4)
+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-django
+
+`iotsploit-django` 是 IoTSploit 项目的 **Django 外圈（ring）**包：负责 HTTP/WS、ORM、Celery、Redis、以及对 `iotsploit-core` / `iosploit-fuzzer` 的组装注入（composition root）。
+
+> 当前：`iotsploit-django` 已成为 Django 外圈宿主（settings/urls/asgi/celery/ws/models 等已迁入），不再依赖 `sat_toolkit` 作为 Django app。
+
+
+

iotsploit_django-0.0.6/README.md

@@ -0,0 +1,7 @@
+# iotsploit-django
+
+`iotsploit-django` 是 IoTSploit 项目的 **Django 外圈（ring）**包：负责 HTTP/WS、ORM、Celery、Redis、以及对 `iotsploit-core` / `iosploit-fuzzer` 的组装注入（composition root）。
+
+> 当前：`iotsploit-django` 已成为 Django 外圈宿主（settings/urls/asgi/celery/ws/models 等已迁入），不再依赖 `sat_toolkit` 作为 Django app。
+
+

iotsploit_django-0.0.6/pyproject.toml

@@ -0,0 +1,68 @@
+[tool.poetry]
+name = "iotsploit-django"
+version = "0.0.6"
+description = "IoTSploit Django ring package (HTTP/WS/ORM/Celery + composition root)"
+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", "django"]
+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_django", from = "src" }]
+
+[tool.poetry.dependencies]
+python = ">=3.10,<4.0"
+iotsploit-core = "^0.0.6"
+iotsploit-platforms = { version = "^0.0.6", optional = true }
+Django = ">=4.2,<5.0"
+channels = ">=4.0"
+celery = ">=5.3"
+redis = ">=5.0"
+channels-redis = ">=4.1"
+daphne = ">=4.0"
+django-extensions = ">=3.2"
+django-cors-headers = ">=4.0"
+django-csp = ">=3.7,<4.0"
+mistune = ">=3.0"
+colorlog = ">=6.8"
+SQLAlchemy = ">=2.0"
+netifaces = ">=0.11"
+psutil = ">=5.9"
+requests = ">=2.31"
+cryptography = ">=41.0"
+pydantic = ">=2.0"
+aiohttp = ">=3.9"
+asgiref = ">=3.7"
+elevate = ">=0.1"
+pwntools = ">=4.11"
+bluepy = ">=1.3"
+pywifi = ">=1.1"
+smbus2 = ">=0.4"
+pyusb = ">=1.2"
+
+[tool.poetry.extras]
+platforms = ["iotsploit-platforms"]
+
+[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_django-0.0.6/src/iotsploit_django/__init__.py

@@ -0,0 +1,6 @@
+"""iotsploit-django: Django ring package for IoTSploit.
+
+Host package for the Django outer ring.
+"""
+
+

iotsploit_django-0.0.6/src/iotsploit_django/adapters/django/__init__.py

@@ -0,0 +1,3 @@
+"""Django-specific adapters (ORM, admin, settings bindings)."""
+
+

iotsploit_django-0.0.6/src/iotsploit_django/adapters/django/device_driver_manager_factory.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from iotsploit_django.adapters.django.driver_state_repo import DjangoDriverStateRepository
+from iotsploit_django.adapters.memory.driver_state_repo import MemoryDriverStateRepository
+from iotsploit_core.core.device_manager import DeviceDriverManager
+from iotsploit_django.config import DEVICE_PLUGINS_DIR
+
+
+def get_device_driver_manager(
+    *,
+    plugins_dir: str | Path | None = None,
+    usb_config_file: str | Path | None = None,
+    use_persistence: bool = True,
+) -> DeviceDriverManager:
+    """Composition root for Django runtime.
+
+    Core `DeviceDriverManager` is framework-free; this wires persistence adapters.
+    """
+
+    repo = DjangoDriverStateRepository() if use_persistence else MemoryDriverStateRepository()
+    # Ensure stable defaults regardless of CWD (Django/gunicorn may change working directory).
+    if plugins_dir is None:
+        plugins_dir = DEVICE_PLUGINS_DIR
+    if usb_config_file is None:
+        # repo_root/conf/usb_devices.json
+        usb_config_file = str(Path(__file__).resolve().parents[3] / "conf" / "usb_devices.json")
+    return DeviceDriverManager(
+        driver_state_repo=repo,
+        plugins_dir=plugins_dir,
+        usb_config_file=usb_config_file,
+    )
+
+

iotsploit_django-0.0.6/src/iotsploit_django/adapters/django/device_models.py

@@ -0,0 +1,251 @@
+"""
+SQLAlchemy ORM mappings for Device domain (adapter layer).
+
+Kept under Django adapters because runtime wiring currently uses Django settings to locate DB.
+"""
+
+from __future__ import annotations
+
+import datetime
+import json
+import os
+from typing import Any, Dict, List, Optional, Type
+
+from sqlalchemy import Boolean, Column, DateTime, Enum as SQLAlchemyEnum, JSON, String
+
+from iotsploit_django.adapters.django.sqlalchemy_database import get_default_sqlalchemy_db
+from iotsploit_core.domain.device import Device, DeviceType, SerialDevice, SocketCANDevice, USBDevice
+from iotsploit_django.tools.xlogger import xlog
+
+_db = get_default_sqlalchemy_db()
+Base = _db.Base
+engine = _db.engine
+SessionLocal = _db.SessionLocal
+
+
+class DeviceDBModel(Base):
+    __tablename__ = "devices"
+
+    device_id = Column(String, primary_key=True)
+    name = Column(String)
+    device_type = Column(SQLAlchemyEnum(DeviceType))
+    attributes = Column(JSON)
+
+    __mapper_args__ = {"polymorphic_on": device_type, "polymorphic_identity": "device"}
+
+    def __init__(self, device: Device):
+        self.device_id = device.device_id
+        self.name = device.name
+        self.device_type = device.device_type
+        self.attributes = device.attributes
+
+
+class SerialDeviceDBModel(DeviceDBModel):
+    __mapper_args__ = {"polymorphic_identity": DeviceType.Serial}
+
+    def __init__(self, device: SerialDevice):
+        super().__init__(device)
+        self.attributes["port"] = device.port
+        self.attributes["baud_rate"] = device.baud_rate
+
+
+class USBDeviceDBModel(DeviceDBModel):
+    __mapper_args__ = {"polymorphic_identity": DeviceType.USB}
+
+    def __init__(self, device: USBDevice):
+        super().__init__(device)
+        self.attributes["vendor_id"] = device.vendor_id
+        self.attributes["product_id"] = device.product_id
+
+
+class CANDeviceDBModel(DeviceDBModel):
+    __mapper_args__ = {"polymorphic_identity": DeviceType.CAN}
+
+    def __init__(self, device: SocketCANDevice):
+        super().__init__(device)
+        self.attributes["interface"] = device.interface
+
+
+class DeviceManager:
+    _instance = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(DeviceManager, cls).__new__(cls)
+            cls._instance.initialize()
+        return cls._instance
+
+    def initialize(self):
+        self.devices: Dict[DeviceType, Type[Device]] = {}
+        Base.metadata.create_all(engine)
+        self.Session = SessionLocal
+        self.current_device: Optional[Device] = None
+
+    @classmethod
+    def get_instance(cls):
+        return cls()
+
+    def register_device(self, device_type: DeviceType, device_class: Type[Device]):
+        self.devices[device_type] = device_class
+
+    def create_device(self, device_type: DeviceType, **kwargs) -> Device:
+        if device_type in self.devices:
+            device_class = self.devices[device_type]
+            device = device_class(**kwargs)
+            self.save_device(device)
+            return device
+        raise ValueError(f"No device type registered for: {device_type}")
+
+    def save_device(self, device: Device):
+        session = self.Session()
+        try:
+            existing_device = session.query(DeviceDBModel).filter_by(device_id=device.device_id).first()
+            if existing_device:
+                xlog.info(
+                    f"Device with device_id '{device.device_id}' already exists. Skipping insertion.",
+                    name="device_model",
+                )
+                return
+
+            if isinstance(device, SerialDevice):
+                device_model = SerialDeviceDBModel(device)
+            elif isinstance(device, USBDevice):
+                device_model = USBDeviceDBModel(device)
+            elif isinstance(device, SocketCANDevice):
+                device_model = CANDeviceDBModel(device)
+            else:
+                device_model = DeviceDBModel(device)
+
+            session.add(device_model)
+            session.commit()
+            xlog.info(
+                f"Device with device_id '{device.device_id}' has been added to the database.",
+                name="device_model",
+            )
+        except Exception as e:
+            session.rollback()
+            xlog.error(f"An error occurred while saving device '{device.device_id}': {e}", name="device_model")
+            raise
+        finally:
+            session.close()
+
+    def get_all_devices(self) -> List[Dict[str, Any]]:
+        session = self.Session()
+        try:
+            devices = session.query(DeviceDBModel).all()
+            result = []
+            for d in devices:
+                if d.device_type == DeviceType.Serial:
+                    device = SerialDevice(
+                        device_id=d.device_id,
+                        name=d.name,
+                        port=d.attributes.get("port", ""),
+                        baud_rate=d.attributes.get("baud_rate", 115200),
+                        attributes=d.attributes,
+                    )
+                elif d.device_type == DeviceType.USB:
+                    device = USBDevice(
+                        device_id=d.device_id,
+                        name=d.name,
+                        vendor_id=d.attributes.get("vendor_id", ""),
+                        product_id=d.attributes.get("product_id", ""),
+                        attributes=d.attributes,
+                    )
+                elif d.device_type == DeviceType.CAN:
+                    device = SocketCANDevice(
+                        device_id=d.device_id,
+                        name=d.name,
+                        interface=d.attributes.get("interface", "can0"),
+                        attributes=d.attributes,
+                    )
+                else:
+                    device = Device(
+                        device_id=d.device_id,
+                        name=d.name,
+                        device_type=d.device_type,
+                        attributes=d.attributes,
+                    )
+                result.append(device.to_dict())
+            return result
+        except Exception as e:
+            xlog.error(f"Error getting devices: {e}", name="device_model")
+            return []
+        finally:
+            session.close()
+
+    def parse_and_set_device_from_json(self, json_file_path: str):
+        import warnings
+
+        warnings.warn(
+            "parse_and_set_device_from_json is deprecated. "
+            "Devices are now auto-discovered by drivers or use 'device_import' CLI command.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
+        if not os.path.exists(json_file_path):
+            xlog.error(f"File not found: {json_file_path}", name="device_model")
+            return
+
+        with open(json_file_path, "r") as file:
+            data = json.load(file)
+
+        imported_count = 0
+        for device in data.get("devices", []):
+            device_type = DeviceType(device.get("device_type", "USB"))
+            device_class = self.devices.get(device_type, Device)
+
+            device_data: Dict[str, Any] = {
+                "device_id": device.get("device_id"),
+                "name": device.get("name"),
+                "attributes": device.get("attributes", {}),
+            }
+
+            if device_type == DeviceType.Serial:
+                device_data["port"] = device.get("port")
+                device_data["baud_rate"] = device.get("baud_rate")
+            elif device_type == DeviceType.USB:
+                device_data["vendor_id"] = device.get("vendor_id")
+                device_data["product_id"] = device.get("product_id")
+            elif device_type == DeviceType.CAN:
+                device_data["interface"] = device.get("interface", "can0")
+
+            device_instance = self.create_device(device_type, **device_data)
+            self.current_device = device_instance
+            imported_count += 1
+
+        xlog.info(
+            f"Imported {imported_count} devices from JSON file: {json_file_path}",
+            name="device_model",
+        )
+
+    def get_current_device(self) -> Optional[Device]:
+        return self.current_device
+
+    def set_current_device(self, device: Device):
+        self.current_device = device
+
+
+class DeviceDriverState(Base):
+    __tablename__ = "device_driver_states"
+
+    driver_name = Column(String, primary_key=True)
+    enabled = Column(Boolean, default=True)
+    description = Column(String, nullable=True)
+    last_updated = Column(DateTime, default=lambda: datetime.datetime.now())
+
+    def __init__(self, driver_name, enabled=True, description=None):
+        self.driver_name = driver_name
+        self.enabled = enabled
+        self.description = description
+        self.last_updated = datetime.datetime.now()
+
+    def to_dict(self):
+        return {
+            "driver_name": self.driver_name,
+            "enabled": self.enabled,
+            "description": self.description,
+            "last_updated": str(self.last_updated),
+        }
+
+

iotsploit_django-0.0.6/src/iotsploit_django/adapters/django/device_registry_factory.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from iotsploit_django.adapters.django.device_driver_manager_factory import get_device_driver_manager
+from iotsploit_core.core.device_registry import DeviceRegistry
+
+
+def get_device_registry(*, use_persistence: bool = True) -> DeviceRegistry:
+    """Composition root for Django runtime."""
+
+    driver_manager = get_device_driver_manager(use_persistence=use_persistence)
+    return DeviceRegistry.get_instance(driver_manager=driver_manager)
+
+

iotsploit_django-0.0.6/src/iotsploit_django/adapters/django/driver_state_repo.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+import datetime
+
+from iotsploit_django.adapters.django.device_models import DeviceDriverState
+from iotsploit_django.adapters.django.sqlalchemy_database import get_default_sqlalchemy_db
+
+
+class DjangoDriverStateRepository:
+    """SQLAlchemy-backed driver state repo (adapter layer).
+
+    NOTE: This uses the SQLAlchemy DB factory that is configured via Django settings.
+    """
+
+    def __init__(self) -> None:
+        self._db = get_default_sqlalchemy_db()
+        # Ensure the table exists; previously this was implicitly created via other model managers.
+        try:
+            self._db.Base.metadata.create_all(self._db.engine)
+        except Exception:
+            # Keep repository resilient; callers will treat missing persistence as "no saved states".
+            pass
+
+    def get_enabled(self, driver_name: str) -> bool | None:
+        session = self._db.SessionLocal()
+        try:
+            row = session.query(DeviceDriverState).filter_by(driver_name=driver_name).first()
+            return None if row is None else bool(row.enabled)
+        except Exception:
+            return None
+        finally:
+            session.close()
+
+    def set_enabled(self, driver_name: str, enabled: bool, description: str | None = None) -> None:
+        session = self._db.SessionLocal()
+        try:
+            row = session.query(DeviceDriverState).filter_by(driver_name=driver_name).first()
+            if row:
+                row.enabled = bool(enabled)
+                row.last_updated = datetime.datetime.now()
+                if description is not None:
+                    row.description = description
+            else:
+                row = DeviceDriverState(driver_name=driver_name, enabled=bool(enabled), description=description)
+                session.add(row)
+            session.commit()
+        except Exception:
+            session.rollback()
+        finally:
+            session.close()
+
+    def list_enabled(self) -> dict[str, bool]:
+        session = self._db.SessionLocal()
+        try:
+            rows = session.query(DeviceDriverState).all()
+            return {r.driver_name: bool(r.enabled) for r in rows}
+        except Exception:
+            return {}
+        finally:
+            session.close()
+
+

iotsploit_django-0.0.6/src/iotsploit_django/adapters/django/exploit_manager_factory.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from iotsploit_django.adapters.django.plugins.repos import DjangoPluginGroupRepository, DjangoPluginMetaRepository
+from iotsploit_django.adapters.django.task_runner import CeleryTaskRunner
+from iotsploit_django.adapters.memory.task_runner import InProcessTaskRunner
+from iotsploit_core.core.exploit_manager import ExploitPluginManager
+
+
+def get_exploit_plugin_manager(
+    *,
+    plugins_dir: str | Path | None = None,
+    use_celery: bool = True,
+) -> ExploitPluginManager:
+    """Composition root for Django runtime.
+
+    Core `ExploitPluginManager` is framework-free; this function wires Django ORM repos
+    and (optionally) Celery as the TaskRunner.
+    """
+
+    repo = DjangoPluginMetaRepository()
+    group_repo = DjangoPluginGroupRepository()
+    runner = CeleryTaskRunner() if use_celery else InProcessTaskRunner()
+
+    return ExploitPluginManager(
+        plugin_repo=repo,
+        group_repo=group_repo,
+        task_runner=runner,
+        plugins_dir=plugins_dir,
+    )
+
+

iotsploit_django-0.0.6/src/iotsploit_django/adapters/django/iot_fuzzer/__init__.py

@@ -0,0 +1,3 @@
+"""IoT Fuzzer Django adapter (Django ORM models, admin integration)."""
+
+