iotsploit-platforms 0.0.6__py3-none-any.whl

iotsploit_platforms/__init__.py

@@ -0,0 +1,10 @@
+"""
+IoTSploit Platform Adapters Package.
+
+This package provides platform-specific implementations for WiFi, Input, and SSH backends.
+"""
+
+from iotsploit_platforms.selector import build_context, get_wifi_backend
+
+__version__ = "0.1.0"
+__all__ = ["get_wifi_backend", "build_context"]

iotsploit_platforms/adapters/__init__.py

@@ -0,0 +1,5 @@
+"""
+Platform adapter implementations.
+
+This module contains platform-specific adapter implementations.
+"""

iotsploit_platforms/adapters/platforms/__init__.py

@@ -0,0 +1,5 @@
+"""
+Platform-specific adapter implementations.
+
+This module contains platform-specific implementations organized by platform.
+"""

iotsploit_platforms/adapters/platforms/darwin/__init__.py

@@ -0,0 +1,7 @@
+"""
+Darwin (macOS) platform adapters.
+"""
+
+from iotsploit_platforms.adapters.platforms.darwin.wifi_backend import wifi_backend
+
+__all__ = ["wifi_backend"]

iotsploit_platforms/adapters/platforms/darwin/wifi_backend.py

@@ -0,0 +1,93 @@
+"""
+Darwin (macOS) WiFi Backend Implementation.
+
+This module provides macOS-specific WiFi backend implementation.
+Currently a placeholder implementation.
+"""
+
+import logging
+from typing import List, Optional, Dict, Any, Tuple
+
+from iotsploit_core.ports.wifi_backend import WifiBackend
+from iotsploit_core.utils.exceptions import NotSupportedError
+
+logger = logging.getLogger(__name__)
+
+
+class DarwinWifiBackend(WifiBackend):
+    """
+    Darwin (macOS) WiFi backend implementation.
+    
+    This is a placeholder implementation. Full implementation would use
+    macOS-specific APIs (e.g., airport, CoreWLAN framework).
+    """
+
+    def __init__(self, wifi_iface_name: Optional[str] = None):
+        """
+        Initialize Darwin WiFi backend.
+        
+        Args:
+            wifi_iface_name: WiFi interface name (optional on macOS)
+        """
+        self.wifi_iface_name = wifi_iface_name
+        self._wifi_mode = "IDLE"
+
+    def scan(self) -> List[Dict[str, Any]]:
+        """
+        Scan for available WiFi networks.
+        
+        Raises:
+            NotSupportedError: macOS WiFi scanning not yet implemented
+        """
+        raise NotSupportedError("WiFi scanning is not yet implemented on macOS")
+
+    def sta_connect(self, ssid: str, passwd: str) -> None:
+        """
+        Connect to a WiFi network in station (STA) mode.
+        
+        Raises:
+            NotSupportedError: macOS WiFi connection not yet implemented
+        """
+        raise NotSupportedError("WiFi station mode connection is not yet implemented on macOS")
+
+    def sta_disconnect(self) -> None:
+        """
+        Disconnect from the current WiFi network in station mode.
+        
+        Raises:
+            NotSupportedError: macOS WiFi disconnection not yet implemented
+        """
+        raise NotSupportedError("WiFi station mode disconnection is not yet implemented on macOS")
+
+    def ap_start(self, ssid: Optional[str] = None, passwd: Optional[str] = None, wpa_mode: int = 2) -> Tuple[str, str]:
+        """
+        Start WiFi access point (AP) mode.
+        
+        Raises:
+            NotSupportedError: macOS does not support WiFi AP mode
+        """
+        raise NotSupportedError("WiFi access point mode is not supported on macOS")
+
+    def ap_stop(self) -> None:
+        """
+        Stop WiFi access point (AP) mode.
+        
+        Raises:
+            NotSupportedError: macOS does not support WiFi AP mode
+        """
+        raise NotSupportedError("WiFi access point mode is not supported on macOS")
+
+    def status(self) -> Dict[str, Any]:
+        """
+        Get current WiFi status.
+        
+        Returns:
+            Dictionary containing current WiFi status information.
+        """
+        return {
+            "wifi_mode": self._wifi_mode,
+        }
+
+
+# Export the backend class
+wifi_backend = DarwinWifiBackend

iotsploit_platforms/adapters/platforms/linux/__init__.py

@@ -0,0 +1,7 @@
+"""
+Linux platform adapters.
+"""
+
+from iotsploit_platforms.adapters.platforms.linux.wifi_backend import wifi_backend
+
+__all__ = ["wifi_backend"]

iotsploit_platforms/adapters/platforms/linux/wifi_backend.py

@@ -0,0 +1,640 @@
+"""
+Linux WiFi Backend Implementation.
+
+This module provides Linux-specific WiFi backend implementation using
+NetworkManager's native libnm API via GObject Introspection.
+"""
+
+import logging
+import time
+import uuid
+from pathlib import Path
+from typing import List, Optional, Dict, Any, Tuple
+
+import gi
+gi.require_version('NM', '1.0')
+from gi.repository import NM, GLib
+
+from iotsploit_core.ports.wifi_backend import WifiBackend
+from iotsploit_core.utils.exceptions import NotSupportedError
+
+logger = logging.getLogger(__name__)
+
+# NetworkManager DBus constants (from NM headers / docs)
+_NM_ACTIVE_CONNECTION_STATE_ACTIVATED = 2
+
+
+class LinuxWifiBackend(WifiBackend):
+    """
+    Linux WiFi backend implementation using NetworkManager.
+    
+    Uses libnm (NetworkManager's native library) for all WiFi operations.
+    Supports station mode, access point mode, and network scanning.
+    """
+    # Keep consistent with upstream DBus hotspot example
+    _HOTSPOT_UUID = "2b0d0f1d-b79d-43af-bde1-71744625642e"
+
+    def __init__(self, wifi_iface_name: str = "wlan0", forward_eth_name: Optional[str] = None):
+        """
+        Initialize NetworkManager WiFi backend.
+        
+        Args:
+            wifi_iface_name: WiFi interface name (e.g., "wlan0", "wlp0s20f3")
+            forward_eth_name: Ethernet interface for forwarding (used for AP mode NAT)
+        """
+        self.wifi_iface_name = wifi_iface_name
+        self.forward_eth_name = forward_eth_name
+        
+        self._wifi_mode = "IDLE"
+        self._sta_conn_wifi_ssid = ""
+        self._sta_conn_wifi_passwd = ""
+        self._ap_ssid = ""
+        self._ap_passwd = ""
+        
+        # Connection IDs for tracking
+        self._active_connection_id: Optional[str] = None
+        self._hotspot_connection_id: Optional[str] = None
+        # Hotspot connection UUID/path (DBus profile reuse)
+        self._hotspot_connection_uuid: Optional[str] = None
+        self._hotspot_connection_path: Optional[str] = None
+        self._hotspot_active_connection_path: Optional[str] = None
+        
+        # Initialize NetworkManager client
+        self._client: Optional[NM.Client] = None
+        self._device: Optional[NM.DeviceWifi] = None
+        self._init_client()
+
+    def _init_client(self):
+        """Initialize NetworkManager client and find WiFi device."""
+        try:
+            self._client = NM.Client.new(None)
+            self._device = self._find_wifi_device()
+            logger.info(f"NetworkManager client initialized for {self.wifi_iface_name}")
+        except Exception as e:
+            logger.error(f"Failed to initialize NetworkManager client: {e}")
+            raise NotSupportedError(f"NetworkManager initialization failed: {e}")
+
+    def _find_wifi_device(self) -> NM.DeviceWifi:
+        """Find the WiFi device by interface name."""
+        devices = self._client.get_devices()
+        for device in devices:
+            if device.get_iface() == self.wifi_iface_name:
+                if isinstance(device, NM.DeviceWifi):
+                    return device
+                else:
+                    raise NotSupportedError(f"{self.wifi_iface_name} is not a WiFi device")
+        
+        # List available WiFi devices for debugging
+        wifi_devices = [d.get_iface() for d in devices if isinstance(d, NM.DeviceWifi)]
+        raise NotSupportedError(
+            f"WiFi device {self.wifi_iface_name} not found. "
+            f"Available WiFi devices: {wifi_devices}"
+        )
+
+    def _get_security_flags_string(self, ap: NM.AccessPoint) -> str:
+        """Convert AP security flags to string."""
+        wpa_flags = ap.get_wpa_flags()
+        rsn_flags = ap.get_rsn_flags()
+        
+        # Use integer constants instead of enum attributes for compatibility
+        # KEY_MGMT_PSK = 0x00000002 (from NetworkManager headers)
+        KEY_MGMT_PSK = 0x00000002
+        
+        if rsn_flags & KEY_MGMT_PSK:
+            return "WPA2"
+        elif wpa_flags & KEY_MGMT_PSK:
+            return "WPA"
+        elif ap.get_flags() & 0x0001:  # PRIVACY flag
+            return "WEP"
+        else:
+            return "OPEN"
+
+    def _wait_for_connection(self, timeout: int = 30) -> bool:
+        """Wait for connection to be established."""
+        start_time = time.time()
+        while time.time() - start_time < timeout:
+            state = self._device.get_state()
+            if state == NM.DeviceState.ACTIVATED:
+                return True
+            elif state in (NM.DeviceState.FAILED, NM.DeviceState.DISCONNECTED):
+                return False
+            time.sleep(0.5)
+        return False
+
+    def _find_connection_by_id(self, conn_id: str) -> Optional[NM.RemoteConnection]:
+        """Find a connection profile by ID."""
+        connections = self._client.get_connections()
+        for conn in connections:
+            if conn.get_id() == conn_id:
+                return conn
+        return None
+
+    def _delete_connection_by_id(self, conn_id: str) -> bool:
+        """Delete a connection profile by ID."""
+        conn = self._find_connection_by_id(conn_id)
+        if conn:
+            try:
+                conn.delete(None)
+                logger.info(f"Deleted connection: {conn_id}")
+                return True
+            except Exception as e:
+                logger.error(f"Failed to delete connection {conn_id}: {e}")
+        return False
+
+    def _get_or_make_hotspot_uuid(self) -> str:
+        """
+        Return a stable UUID for the hotspot profile.
+
+        We intentionally keep the UUID stable across runs so we can reuse the
+        same NetworkManager connection profile (per the upstream DBus example).
+        """
+        # Force using the same UUID as the provided example for consistency.
+        self._hotspot_connection_uuid = self._HOTSPOT_UUID
+        return self._hotspot_connection_uuid
+
+    def _ensure_hotspot_profile_dbus(
+        self,
+        ssid: str,
+        passwd: str,
+        band: str = "bg",
+        channel: int = 6,
+    ) -> Tuple["dbus.SystemBus", str, str]:
+        """
+        Ensure a NetworkManager hotspot profile exists (DBus), return (bus, devpath, connection_path).
+        """
+        try:
+            import dbus  # type: ignore
+        except Exception as e:  # pragma: no cover
+            raise NotSupportedError(f"dbus-python not available: {e}")
+
+        hotspot_uuid = self._get_or_make_hotspot_uuid()
+
+        # Build settings dicts (matches upstream example structure)
+        s_con = dbus.Dictionary(
+            {
+                "type": "802-11-wireless",
+                "uuid": hotspot_uuid,
+                # Keep a stable, human-readable id in NetworkManager UI
+                "id": f"iotsploit-hotspot-{self.wifi_iface_name}",
+                "autoconnect": dbus.Boolean(False),
+            }
+        )
+
+        s_wifi = dbus.Dictionary(
+            {
+                "ssid": dbus.ByteArray(ssid.encode("utf-8")),
+                "mode": "ap",
+                "band": band,
+                "channel": dbus.UInt32(int(channel)),
+            }
+        )
+
+        s_ip4 = dbus.Dictionary({"method": "shared"})
+        s_ip6 = dbus.Dictionary({"method": "ignore"})
+
+        con: Dict[str, Any] = {
+            "connection": s_con,
+            "802-11-wireless": s_wifi,
+            "ipv4": s_ip4,
+            "ipv6": s_ip6,
+        }
+
+        # WPA2-PSK (same as example). If passwd empty, we create an open AP.
+        if passwd:
+            s_wsec = dbus.Dictionary({"key-mgmt": "wpa-psk", "psk": passwd})
+            con["802-11-wireless-security"] = s_wsec
+
+        con = dbus.Dictionary(con)
+
+        bus = dbus.SystemBus()
+
+        # Find or create the connection profile under Settings
+        settings_proxy = bus.get_object(
+            "org.freedesktop.NetworkManager",
+            "/org/freedesktop/NetworkManager/Settings",
+        )
+        settings = dbus.Interface(settings_proxy, "org.freedesktop.NetworkManager.Settings")
+
+        connection_path = None
+        for path in settings.ListConnections():
+            proxy = bus.get_object("org.freedesktop.NetworkManager", path)
+            settings_connection = dbus.Interface(
+                proxy,
+                "org.freedesktop.NetworkManager.Settings.Connection",
+            )
+            config = settings_connection.GetSettings()
+            if config.get("connection", {}).get("uuid") == hotspot_uuid:
+                connection_path = path
+                break
+
+        if not connection_path:
+            connection_path = settings.AddConnection(con)
+            logger.info(f"Created hotspot profile via DBus: uuid={hotspot_uuid} path={connection_path}")
+        else:
+            logger.info(f"Reusing hotspot profile via DBus: uuid={hotspot_uuid} path={connection_path}")
+
+        # Resolve device path by interface name
+        nm_proxy = bus.get_object("org.freedesktop.NetworkManager", "/org/freedesktop/NetworkManager")
+        nm = dbus.Interface(nm_proxy, "org.freedesktop.NetworkManager")
+        devpath = nm.GetDeviceByIpIface(self.wifi_iface_name)
+
+        # Cache for stop/status usage
+        self._hotspot_connection_path = str(connection_path)
+
+        return bus, str(devpath), str(connection_path)
+
+    def _wait_hotspot_activated_dbus(self, bus: "dbus.SystemBus", acpath: str, timeout: int = 10) -> bool:
+        """Wait until the active connection reaches ACTIVATED (DBus)."""
+        import dbus  # type: ignore
+
+        proxy = bus.get_object("org.freedesktop.NetworkManager", acpath)
+        active_props = dbus.Interface(proxy, "org.freedesktop.DBus.Properties")
+
+        start = time.time()
+        while time.time() < start + timeout:
+            try:
+                state = int(
+                    active_props.Get(
+                        "org.freedesktop.NetworkManager.Connection.Active",
+                        "State",
+                    )
+                )
+            except Exception:
+                state = -1
+            if state == _NM_ACTIVE_CONNECTION_STATE_ACTIVATED:
+                return True
+            time.sleep(1)
+
+        return False
+
+    def _get_ap_clients(self) -> List[Dict[str, Any]]:
+        """
+        Get connected clients from DHCP leases.
+        
+        NetworkManager uses dnsmasq for DHCP in shared mode.
+        This method parses the DHCP lease files to get connected clients.
+        """
+        client_list = []
+        try:
+            # NetworkManager stores leases in /var/lib/NetworkManager/dnsmasq-*.leases
+            lease_dir = Path("/var/lib/NetworkManager")
+            if lease_dir.exists():
+                lease_files = list(lease_dir.glob("dnsmasq-*.leases"))
+                for lease_file in lease_files:
+                    try:
+                        with open(lease_file, 'r') as f:
+                            for line in f:
+                                parts = line.strip().split()
+                                if len(parts) >= 4:
+                                    client_list.append({
+                                        "mac": parts[1],
+                                        "ip": parts[2],
+                                        "name": parts[3] if len(parts) > 3 else "",
+                                    })
+                    except Exception as e:
+                        logger.warning(f"Failed to read lease file {lease_file}: {e}")
+            
+            # Fallback: try traditional dnsmasq location
+            if not client_list:
+                traditional_lease = Path("/var/lib/misc/dnsmasq.leases")
+                if traditional_lease.exists():
+                    try:
+                        with open(traditional_lease, 'r') as f:
+                            for line in f:
+                                parts = line.strip().split()
+                                if len(parts) >= 4:
+                                    client_list.append({
+                                        "mac": parts[1],
+                                        "ip": parts[2],
+                                        "name": parts[3] if len(parts) > 3 else "",
+                                    })
+                    except Exception as e:
+                        logger.warning(f"Failed to read traditional lease file: {e}")
+        except Exception as e:
+            logger.warning(f"Failed to get AP clients from DHCP leases: {e}")
+        
+        return client_list
+
+    # ==================== Public API ====================
+
+    def scan(self) -> List[Dict[str, Any]]:
+        """
+        Scan for available WiFi networks.
+        
+        Returns:
+            List of dictionaries containing WiFi network information.
+        """
+        logger.info("Start WiFi scan via NetworkManager")
+        
+        # Request a new scan
+        try:
+            self._device.request_scan(None)
+        except Exception as e:
+            logger.warning(f"Scan request failed (may already be scanning): {e}")
+        
+        # Wait for scan to complete
+        time.sleep(3)
+        
+        # Get access points
+        access_points = self._device.get_access_points()
+        
+        result_list = []
+        seen_ssids = set()  # Deduplicate by SSID
+        
+        for ap in access_points:
+            ssid_bytes = ap.get_ssid()
+            if ssid_bytes is None:
+                continue
+            
+            ssid = ssid_bytes.get_data().decode('utf-8', errors='ignore')
+            if not ssid or ssid in seen_ssids:
+                continue
+            
+            seen_ssids.add(ssid)
+            
+            result_list.append({
+                "ssid": ssid,
+                "bssid": ap.get_bssid(),
+                "signal": ap.get_strength(),
+                "security": self._get_security_flags_string(ap),
+                "frequency": ap.get_frequency(),
+            })
+            logger.info(f"Found WiFi: {ssid} ({ap.get_bssid()})")
+        
+        logger.info(f"Scan complete. Found {len(result_list)} networks.")
+        return result_list
+
+    def sta_connect(self, ssid: str, passwd: str) -> None:
+        """
+        Connect to a WiFi network in station (STA) mode.
+        
+        Args:
+            ssid: Network SSID to connect to
+            passwd: Network password (empty string for open networks)
+        """
+        logger.info(f"Connecting to WiFi: {ssid}")
+        
+        # Check if already connected to this network
+        if (self._wifi_mode == "STA" and 
+            self._sta_conn_wifi_ssid == ssid and
+            self._sta_conn_wifi_passwd == passwd):
+            if self._device.get_state() == NM.DeviceState.ACTIVATED:
+                logger.info(f"Already connected to {ssid}, skipping")
+                return
+        
+        # Disconnect any existing connection first
+        self.sta_disconnect()
+        
+        # Store connection info
+        self._sta_conn_wifi_ssid = ssid
+        self._sta_conn_wifi_passwd = passwd
+        
+        # Create connection profile
+        connection_id = f"iotsploit-{ssid}-{uuid.uuid4().hex[:8]}"
+        
+        # Build connection settings
+        connection = NM.SimpleConnection.new()
+        
+        # Connection settings
+        s_con = NM.SettingConnection.new()
+        s_con.set_property(NM.SETTING_CONNECTION_ID, connection_id)
+        s_con.set_property(NM.SETTING_CONNECTION_UUID, str(uuid.uuid4()))
+        s_con.set_property(NM.SETTING_CONNECTION_TYPE, "802-11-wireless")
+        s_con.set_property(NM.SETTING_CONNECTION_AUTOCONNECT, False)
+        connection.add_setting(s_con)
+        
+        # Wireless settings
+        s_wifi = NM.SettingWireless.new()
+        s_wifi.set_property(NM.SETTING_WIRELESS_SSID, GLib.Bytes.new(ssid.encode('utf-8')))
+        s_wifi.set_property(NM.SETTING_WIRELESS_MODE, "infrastructure")
+        connection.add_setting(s_wifi)
+        
+        # Security settings (if password provided)
+        if passwd:
+            s_wifi_sec = NM.SettingWirelessSecurity.new()
+            s_wifi_sec.set_property(NM.SETTING_WIRELESS_SECURITY_KEY_MGMT, "wpa-psk")
+            s_wifi_sec.set_property(NM.SETTING_WIRELESS_SECURITY_PSK, passwd)
+            connection.add_setting(s_wifi_sec)
+        
+        # IPv4 settings (auto/DHCP)
+        s_ip4 = NM.SettingIP4Config.new()
+        s_ip4.set_property(NM.SETTING_IP_CONFIG_METHOD, "auto")
+        connection.add_setting(s_ip4)
+        
+        # IPv6 settings
+        s_ip6 = NM.SettingIP6Config.new()
+        s_ip6.set_property(NM.SETTING_IP_CONFIG_METHOD, "auto")
+        connection.add_setting(s_ip6)
+        
+        try:
+            # Add and activate connection
+            self._client.add_and_activate_connection(
+                connection,
+                self._device,
+                None,  # specific_object (AP path, optional)
+                None   # cancellable
+            )
+            
+            self._active_connection_id = connection_id
+            self._wifi_mode = "STA"
+            
+            # Wait for connection
+            if self._wait_for_connection(timeout=30):
+                logger.info(f"Successfully connected to {ssid}")
+            else:
+                logger.error(f"Connection to {ssid} timed out or failed")
+                raise ConnectionError(f"Failed to connect to {ssid}")
+                
+        except Exception as e:
+            logger.error(f"Failed to connect to {ssid}: {e}")
+            self._wifi_mode = "IDLE"
+            raise ConnectionError(f"Failed to connect to {ssid}: {e}")
+
+    def sta_disconnect(self) -> None:
+        """
+        Disconnect from the current WiFi network in station mode.
+        """
+        logger.info("Disconnecting from WiFi")
+        
+        if self._wifi_mode != "STA":
+            logger.info(f"Not in STA mode (current: {self._wifi_mode}), skipping disconnect")
+            return
+        
+        try:
+            # Disconnect the device
+            self._device.disconnect(None)
+            
+            # Wait for disconnection
+            time.sleep(1)
+            
+            # Clean up connection profile
+            if self._active_connection_id:
+                self._delete_connection_by_id(self._active_connection_id)
+                self._active_connection_id = None
+            
+            self._wifi_mode = "IDLE"
+            self._sta_conn_wifi_ssid = ""
+            self._sta_conn_wifi_passwd = ""
+            
+            logger.info("Disconnected from WiFi")
+            
+        except Exception as e:
+            logger.error(f"Error during disconnect: {e}")
+            self._wifi_mode = "IDLE"
+
+    def ap_start(self, ssid: Optional[str] = None, passwd: Optional[str] = None, wpa_mode: int = 2) -> Tuple[str, str]:
+        """
+        Start WiFi access point (AP) mode using NetworkManager hotspot.
+        
+        Args:
+            ssid: AP SSID (if None, a default will be generated)
+            passwd: AP password (if None, a default will be used)
+            wpa_mode: WPA mode (ignored, NetworkManager uses WPA2 by default)
+        
+        Returns:
+            Tuple of (ssid, passwd) that were actually used
+        """
+        # First disconnect any existing connection
+        self.sta_disconnect()
+        self.ap_stop()
+        
+        # Generate default SSID if not provided
+        if ssid is None:
+            hw_addr = self._device.get_hw_address()
+            ssid = f"SAT_{hw_addr[-5:-3]}{hw_addr[-2:]}"
+        
+        if passwd is None:
+            passwd = "12345678"
+        
+        logger.info(f"Starting AP mode: SSID={ssid}")
+
+        try:
+            import dbus  # type: ignore
+            from dbus.exceptions import DBusException  # type: ignore
+
+            bus, devpath, connection_path = self._ensure_hotspot_profile_dbus(
+                ssid=ssid,
+                passwd=passwd,
+                band="bg",
+                channel=6,
+            )
+
+            nm_proxy = bus.get_object("org.freedesktop.NetworkManager", "/org/freedesktop/NetworkManager")
+            nm = dbus.Interface(nm_proxy, "org.freedesktop.NetworkManager")
+
+            # ActivateConnection(connection, device, specific_object="/")
+            acpath = nm.ActivateConnection(connection_path, devpath, "/")
+            self._hotspot_active_connection_path = str(acpath)
+
+            if not self._wait_hotspot_activated_dbus(bus, str(acpath), timeout=10):
+                raise NotSupportedError("Failed to start access point (timeout waiting for ACTIVATED)")
+
+            logger.info(f"AP started successfully via DBus: {ssid}")
+
+        except DBusException as e:
+            # Common in headless/CLI: polkit cannot prompt -> PermissionDenied
+            dbus_name = ""
+            try:
+                dbus_name = e.get_dbus_name() or ""
+            except Exception:
+                dbus_name = ""
+
+            if dbus_name.endswith(".PermissionDenied") or "PermissionDenied" in str(e):
+                self._wifi_mode = "IDLE"
+                raise NotSupportedError(
+                    "启动热点被 NetworkManager 拒绝授权：Not authorized to share connections via wifi.\n"
+                    "这通常需要 polkit 授权（桌面环境会弹窗）或以 root 运行。\n"
+                    "如果你是在终端/无图形界面运行，请用 sudo 运行当前程序/命令再试。"
+                ) from e
+
+            self._wifi_mode = "IDLE"
+            raise NotSupportedError(f"Failed to start AP mode via DBus: {e}") from e
+        except Exception as e:
+            self._wifi_mode = "IDLE"
+            raise NotSupportedError(f"Failed to start AP mode via DBus: {e}") from e
+
+        # Update local state (common for both DBus/libnm paths)
+        self._ap_ssid = ssid
+        self._ap_passwd = passwd
+        self._wifi_mode = "AP"
+        return ssid, passwd
+
+    def ap_stop(self) -> None:
+        """
+        Stop WiFi access point (AP) mode.
+        """
+        logger.info("Stopping AP mode")
+        
+        if self._wifi_mode != "AP":
+            logger.info(f"Not in AP mode (current: {self._wifi_mode}), skipping")
+            return
+        
+        try:
+            import dbus  # type: ignore
+
+            bus = dbus.SystemBus()
+            nm_proxy = bus.get_object("org.freedesktop.NetworkManager", "/org/freedesktop/NetworkManager")
+            nm = dbus.Interface(nm_proxy, "org.freedesktop.NetworkManager")
+            devpath = nm.GetDeviceByIpIface(self.wifi_iface_name)
+
+            proxy = bus.get_object("org.freedesktop.NetworkManager", devpath)
+            device = dbus.Interface(proxy, "org.freedesktop.NetworkManager.Device")
+            device.Disconnect()
+
+            time.sleep(1)
+
+            # 重要：按 DBus 示例逻辑，默认不删除 hotspot profile，方便下次复用
+            self._hotspot_active_connection_path = None
+
+            self._wifi_mode = "IDLE"
+            self._ap_ssid = ""
+            self._ap_passwd = ""
+            
+            logger.info("AP stopped successfully")
+            
+        except Exception as e:
+            logger.error(f"Error stopping AP: {e}")
+            self._wifi_mode = "IDLE"
+
+    def status(self) -> Dict[str, Any]:
+        """
+        Get current WiFi status.
+        
+        Returns:
+            Dictionary containing current WiFi status information.
+        """
+        status_dict = {
+            "wifi_mode": self._wifi_mode,
+            "device_state": str(self._device.get_state().value_nick),
+            "hw_address": self._device.get_hw_address(),
+        }
+        
+        if self._wifi_mode == "STA":
+            status_dict["sta_conn_wifi_ssid"] = self._sta_conn_wifi_ssid
+            status_dict["sta_conn_wifi_passwd"] = self._sta_conn_wifi_passwd
+            
+            # Get active connection info
+            active_conn = self._device.get_active_connection()
+            if active_conn:
+                ip4_config = active_conn.get_ip4_config()
+                if ip4_config:
+                    addresses = ip4_config.get_addresses()
+                    if addresses:
+                        status_dict["sta_status"] = {
+                            "ip_address": addresses[0].get_address(),
+                            "state": active_conn.get_state().value_nick,
+                        }
+        
+        if self._wifi_mode == "AP":
+            status_dict["ap_ssid"] = self._ap_ssid
+            status_dict["ap_passwd"] = self._ap_passwd
+            
+            # Get connected clients from DHCP leases
+            status_dict["client_list"] = self._get_ap_clients()
+        
+        logger.info(f"Status: {status_dict}")
+        return status_dict
+
+
+# Export the backend class
+wifi_backend = LinuxWifiBackend

iotsploit_platforms/adapters/platforms/windows/__init__.py

@@ -0,0 +1,7 @@
+"""
+Windows platform adapters.
+"""
+
+from iotsploit_platforms.adapters.platforms.windows.wifi_backend import wifi_backend
+
+__all__ = ["wifi_backend"]

iotsploit_platforms/adapters/platforms/windows/wifi_backend.py

@@ -0,0 +1,93 @@
+"""
+Windows WiFi Backend Implementation.
+
+This module provides Windows-specific WiFi backend implementation.
+Currently a placeholder implementation.
+"""
+
+import logging
+from typing import List, Optional, Dict, Any, Tuple
+
+from iotsploit_core.ports.wifi_backend import WifiBackend
+from iotsploit_core.utils.exceptions import NotSupportedError
+
+logger = logging.getLogger(__name__)
+
+
+class WindowsWifiBackend(WifiBackend):
+    """
+    Windows WiFi backend implementation.
+    
+    This is a placeholder implementation. Full implementation would use
+    Windows-specific APIs (e.g., netsh, Windows WLAN API).
+    """
+
+    def __init__(self, wifi_iface_name: Optional[str] = None):
+        """
+        Initialize Windows WiFi backend.
+        
+        Args:
+            wifi_iface_name: WiFi interface name (optional on Windows)
+        """
+        self.wifi_iface_name = wifi_iface_name
+        self._wifi_mode = "IDLE"
+
+    def scan(self) -> List[Dict[str, Any]]:
+        """
+        Scan for available WiFi networks.
+        
+        Raises:
+            NotSupportedError: Windows WiFi scanning not yet implemented
+        """
+        raise NotSupportedError("WiFi scanning is not yet implemented on Windows")
+
+    def sta_connect(self, ssid: str, passwd: str) -> None:
+        """
+        Connect to a WiFi network in station (STA) mode.
+        
+        Raises:
+            NotSupportedError: Windows WiFi connection not yet implemented
+        """
+        raise NotSupportedError("WiFi station mode connection is not yet implemented on Windows")
+
+    def sta_disconnect(self) -> None:
+        """
+        Disconnect from the current WiFi network in station mode.
+        
+        Raises:
+            NotSupportedError: Windows WiFi disconnection not yet implemented
+        """
+        raise NotSupportedError("WiFi station mode disconnection is not yet implemented on Windows")
+
+    def ap_start(self, ssid: Optional[str] = None, passwd: Optional[str] = None, wpa_mode: int = 2) -> Tuple[str, str]:
+        """
+        Start WiFi access point (AP) mode.
+        
+        Raises:
+            NotSupportedError: Windows does not support WiFi AP mode
+        """
+        raise NotSupportedError("WiFi access point mode is not supported on Windows")
+
+    def ap_stop(self) -> None:
+        """
+        Stop WiFi access point (AP) mode.
+        
+        Raises:
+            NotSupportedError: Windows does not support WiFi AP mode
+        """
+        raise NotSupportedError("WiFi access point mode is not supported on Windows")
+
+    def status(self) -> Dict[str, Any]:
+        """
+        Get current WiFi status.
+        
+        Returns:
+            Dictionary containing current WiFi status information.
+        """
+        return {
+            "wifi_mode": self._wifi_mode,
+        }
+
+
+# Export the backend class
+wifi_backend = WindowsWifiBackend

iotsploit_platforms/platforms/__init__.py

@@ -0,0 +1,21 @@
+"""
+Platform Distribution Module (Scapy-Style).
+
+This module provides platform-specific backend implementations based on the
+current platform. It uses conditional imports to select the appropriate
+platform adapters at import time.
+"""
+
+from iotsploit_core.platforms.consts import LINUX, DARWIN, WINDOWS, PLATFORM
+from iotsploit_core.utils.exceptions import NotSupportedError
+
+if LINUX:
+    from iotsploit_platforms.adapters.platforms.linux import wifi_backend
+elif DARWIN:
+    from iotsploit_platforms.adapters.platforms.darwin import wifi_backend
+elif WINDOWS:
+    from iotsploit_platforms.adapters.platforms.windows import wifi_backend
+else:
+    raise NotSupportedError(f"Platform {PLATFORM} not supported")
+
+__all__ = ["wifi_backend"]

iotsploit_platforms/selector.py

@@ -0,0 +1,132 @@
+"""
+Platform Backend Selector.
+
+This module provides functions to select and instantiate platform-specific
+backends based on the current operating system. It serves as the main entry
+point for applications (CLI/Django/MCP) to obtain backend instances.
+
+The selector automatically chooses the appropriate implementation for the
+current platform and handles backend instantiation with proper parameters.
+
+Configuration is read from environment variables:
+- WiFi: IOTSPLOIT_WIFI_IFACE, IOTSPLOIT_WIFI_FORWARD_ETH
+- (Add more backends here as they are implemented)
+"""
+
+import inspect
+import os
+from typing import Optional
+
+from iotsploit_core.context import PluginContext
+from iotsploit_core.platforms.consts import LINUX
+from iotsploit_platforms.platforms import wifi_backend
+
+
+# =============================================================================
+# Backend Configuration from Environment
+# =============================================================================
+
+def _get_wifi_config() -> dict:
+    """Get WiFi backend configuration from environment variables."""
+    return {
+        "wifi_iface_name": os.getenv("IOTSPLOIT_WIFI_IFACE", "wlp6s0"),
+        "forward_eth_name": os.getenv("IOTSPLOIT_WIFI_FORWARD_ETH"),
+    }
+
+
+# TODO: Add more backend config functions as they are implemented
+# def _get_bluetooth_config() -> dict:
+#     return {
+#         "adapter": os.getenv("IOTSPLOIT_BLUETOOTH_ADAPTER", "hci0"),
+#     }
+
+
+# =============================================================================
+# Backend Factory Functions
+# =============================================================================
+
+def get_wifi_backend(
+    wifi_iface_name: Optional[str] = None,
+    forward_eth_name: Optional[str] = None
+) -> wifi_backend:
+    """
+    Get a WiFi backend instance for the current platform.
+    
+    This function automatically selects the appropriate WiFi backend
+    implementation based on the current operating system (Linux/Windows/macOS)
+    and returns an instantiated backend.
+    
+    Args:
+        wifi_iface_name: WiFi interface name. If None, reads from IOTSPLOIT_WIFI_IFACE env var.
+        forward_eth_name: Ethernet interface for forwarding. If None, reads from IOTSPLOIT_WIFI_FORWARD_ETH.
+    
+    Returns:
+        An instance of the platform-specific WiFi backend class
+        
+    Example:
+        >>> backend = get_wifi_backend()  # Uses env vars
+        >>> backend = get_wifi_backend(wifi_iface_name="wlan0")  # Override
+    """
+    # Get config from env if not provided
+    if wifi_iface_name is None or forward_eth_name is None:
+        env_config = _get_wifi_config()
+        if wifi_iface_name is None:
+            wifi_iface_name = env_config["wifi_iface_name"]
+        if forward_eth_name is None:
+            forward_eth_name = env_config["forward_eth_name"]
+    
+    # wifi_backend is the class imported from platforms/__init__.py
+    # which is already platform-specific (LinuxWifiBackend, WindowsWifiBackend, etc.)
+    
+    # Check if the constructor accepts forward_eth_name parameter
+    # Linux backend accepts it, Windows/Darwin don't
+    sig = inspect.signature(wifi_backend.__init__)
+    params = sig.parameters
+    
+    if 'forward_eth_name' in params:
+        # Linux backend - supports forward_eth_name
+        return wifi_backend(
+            wifi_iface_name=wifi_iface_name,
+            forward_eth_name=forward_eth_name
+        )
+    else:
+        # Windows/Darwin backend - only accepts wifi_iface_name
+        return wifi_backend(wifi_iface_name=wifi_iface_name)
+
+
+# =============================================================================
+# Context Builder (Main Entry Point)
+# =============================================================================
+
+def build_context() -> PluginContext:
+    """
+    Build a PluginContext with all available backends.
+    
+    This function creates a structured context object containing all
+    platform-specific backends. Configuration is automatically read from
+    environment variables.
+    
+    This is the recommended way to inject backends into plugins.
+    Adding a new backend only requires:
+    1. Add field to PluginContext
+    2. Add _get_xxx_config() function
+    3. Add get_xxx_backend() function
+    4. Add backend instance to PluginContext here
+    
+    Environment variables:
+    - WiFi: IOTSPLOIT_WIFI_IFACE, IOTSPLOIT_WIFI_FORWARD_ETH
+    - (More backends as implemented)
+    
+    Returns:
+        A PluginContext instance with all backends initialized
+        
+    Example:
+        >>> ctx = build_context()  # Reads config from env
+        >>> plugin.initialize(ctx)
+        >>> # Plugin can access ctx.wifi, ctx.bluetooth, etc.
+    """
+    return PluginContext(
+        wifi=get_wifi_backend(),  # Uses env vars automatically
+        # bluetooth=get_bluetooth_backend(),  # TODO: Add when implemented
+        # camera=get_camera_backend(),        # TODO: Add when implemented
+    )

iotsploit_platforms-0.0.6.dist-info/METADATA

@@ -0,0 +1,77 @@
+Metadata-Version: 2.3
+Name: iotsploit-platforms
+Version: 0.0.6
+Summary: IoTSploit platform-specific adapters (WiFi, Input, SSH backends)
+License: GPL-3.0-or-later
+Keywords: iot,security,testing,pentest,wifi,platform
+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: PyGObject (<3.51)
+Requires-Dist: dbus-python (>=1.4.0,<2.0.0)
+Requires-Dist: iotsploit-core (>=0.0.6,<0.0.7)
+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-platforms
+
+IoTSploit platform-specific adapters package.
+
+This package provides platform-specific implementations for WiFi, Input, and SSH backends across different operating systems.
+
+## Structure
+
+```
+iotsploit-platforms/
+├── src/
+│   └── iotsploit_platforms/
+│       ├── adapters/
+│       │   └── platforms/
+│       │       ├── linux/
+│       │       │   └── wifi_backend.py
+│       │       ├── windows/
+│       │       │   └── wifi_backend.py
+│       │       └── darwin/
+│       │           └── wifi_backend.py
+│       └── platforms/
+│           └── __init__.py  # Platform distribution module
+└── pyproject.toml
+```
+
+## Usage
+
+The platform distribution module automatically selects the appropriate backend based on the current platform:
+
+```python
+from iotsploit_platforms.platforms import wifi_backend
+
+# wifi_backend is the appropriate backend class for the current platform
+backend = wifi_backend(wifi_iface_name="wlan0")
+networks = backend.scan()
+```
+
+## Platform Support
+
+- **Linux**: Full WiFi backend implementation using pywifi, hostapd, and dnsmasq
+- **Windows**: Placeholder implementation (not yet implemented)
+- **Darwin (macOS)**: Placeholder implementation (not yet implemented)
+
+## Dependencies
+
+- `iotsploit-core`: Core interfaces and utilities
+- `pywifi`: WiFi operations on Linux
+- `netifaces`: Network interface information
+

iotsploit_platforms-0.0.6.dist-info/RECORD

@@ -0,0 +1,14 @@
+iotsploit_platforms/__init__.py,sha256=qIdcGSBfms7xHrTdjngKWHHyxlAwfHwfjMnUzYx3MKk,282
+iotsploit_platforms/adapters/__init__.py,sha256=t5j3JOE_1IwKyPZR52ZJS6vCzWQ6S6b60SLWdc4x_Zw,107
+iotsploit_platforms/adapters/platforms/__init__.py,sha256=cd_FlS_tHhdY8IevxcRajB62wZxUh7qV-9pJpjQ7mEM,130
+iotsploit_platforms/adapters/platforms/darwin/__init__.py,sha256=Kf9rdA5Iys-ETfusqwwwRyVsjsSgRtZKEQS8oJDwiJs,155
+iotsploit_platforms/adapters/platforms/darwin/wifi_backend.py,sha256=nwKtHp0UwoisLAh4Oe8ik1Q8FKCj3LqpOQt8veg3Amo,2839
+iotsploit_platforms/adapters/platforms/linux/__init__.py,sha256=sk8_KV-TUxowSisdml8XP9CnMLk7T2mD_3qcPh34erU,145
+iotsploit_platforms/adapters/platforms/linux/wifi_backend.py,sha256=6asQ8gNhRFk2xXweXR2_zUlWzP4cCWh07oCwSw4AFLg,24539
+iotsploit_platforms/adapters/platforms/windows/__init__.py,sha256=orEvxsa_mEK-Agp0IXdn679JLotLvum3aTP5SW2toV4,149
+iotsploit_platforms/adapters/platforms/windows/wifi_backend.py,sha256=MH9oytRnlegOiThDwqZH75HhTYToTUMer_mpq1dKkX4,2850
+iotsploit_platforms/platforms/__init__.py,sha256=-pOe3_AunsxV3qtFqb8ZDcVpnRKATOsqp4BJJHoG4-I,738
+iotsploit_platforms/selector.py,sha256=4r77t4U3CUtP5EJfD3d_BdewpId2Iwwz5YOW79ET1-Q,4930
+iotsploit_platforms-0.0.6.dist-info/METADATA,sha256=GzKDRfYw4z-lc0O51uUIEqu6wdmfeaD9eHuYUiOFLpA,2665
+iotsploit_platforms-0.0.6.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+iotsploit_platforms-0.0.6.dist-info/RECORD,,

iotsploit_platforms-0.0.6.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.0.1
+Root-Is-Purelib: true
+Tag: py3-none-any