iotsploit-exploits 0.0.6__py3-none-any.whl

iotsploit_exploits/simple_rubber_duck.py

@@ -0,0 +1,183 @@
+#!/usr/bin/python3
+
+import pluggy
+import asyncio
+import os
+import sys
+from typing import Optional, Any
+
+from iotsploit_core.core.exploit_spec import ExploitResult, AsyncExploitResult
+from iotsploit_core.core.base_plugin import BasePlugin
+from facedancer.devices.keyboard import USBKeyboardDevice
+from facedancer.errors import EndEmulation
+from iotsploit_core.utils import iots_logger
+
+hookimpl = pluggy.HookimplMarker("exploit_mgr")
+
+class SimpleRubberDuckPlugin(BasePlugin):
+    """
+    A simplified USB rubber duck plugin that types text on a target system.
+    Uses Facedancer to emulate a USB keyboard device.
+    """
+    
+    def __init__(self):
+        super().__init__({
+            'Name': 'Simple Rubber Duck',
+            'Description': 'Simple USB keyboard emulator to type commands automatically.',
+            'License': 'GPL',
+            'Author': ['iotsploit'],
+            'RequiresRoot': False,
+            'Parameters': {
+                'text': {
+                    'type': 'str',
+                    'required': False,
+                    'description': 'Text to type on the target system',
+                    'default': 'echo Hello, from Simple Rubber Duck!\nid\nls -la\n'
+                },
+                'delay_before_typing': {
+                    'type': 'int',
+                    'required': False,
+                    'description': 'Time to wait in seconds before starting to type',
+                    'default': 2
+                },
+                'delay_after_typing': {
+                    'type': 'int',
+                    'required': False,
+                    'description': 'Time to wait in seconds after typing completes before ending the emulation',
+                    'default': 1
+                }
+            }
+        })
+        self.device = None
+        self.running = False
+        self.logger = iots_logger.get_logger("simple_rubber_duck")
+
+    @hookimpl
+    def initialize(self, device_plugin: Optional[Any] = None):
+        self.logger.info("Initializing SimpleRubberDuckPlugin")
+
+    def custom_facedancer_main(self, device, coroutine):
+        """
+        Custom implementation of Facedancer's main function that doesn't parse command line arguments.
+        This is needed when running inside Django where sys.argv contains Django's arguments.
+        """
+        self.logger.info("Starting custom Facedancer emulation")
+        try:
+            # Directly call the device's emulate method with our coroutine
+            device.emulate(coroutine)
+            self.logger.info("Facedancer emulation completed successfully")
+        except EndEmulation as e:
+            self.logger.info(f"Facedancer emulation ended: {str(e)}")
+        except KeyboardInterrupt:
+            self.logger.info("Facedancer emulation interrupted by user")
+        except Exception as e:
+            raise e
+
+    @hookimpl
+    def execute(self, target: Optional[Any] = None, parameters: Optional[dict] = None):
+        """
+        Primary execution method - synchronous version.
+        This is the preferred entry point for Celery tasks.
+        """
+        self.logger.info("Executing SimpleRubberDuckPlugin")
+        
+        try:
+            # Check if we already have a running instance
+            if self.running:
+                return ExploitResult(False, "An instance is already running", {})
+            
+            # Get parameters
+            parameters = parameters or {}
+            text = parameters.get('text', self.info['Parameters']['text']['default'])
+            delay_before_typing = parameters.get('delay_before_typing', 
+                                              self.info['Parameters']['delay_before_typing']['default'])
+            delay_after_typing = parameters.get('delay_after_typing',
+                                             self.info['Parameters']['delay_after_typing']['default'])
+            
+            # Initialize USB device
+            self.logger.info("Initializing USB keyboard device...")
+            try:
+                self.device = USBKeyboardDevice()
+                self.logger.info(f"USB keyboard device initialized")
+            except Exception as e:
+                self.logger.error(f"Failed to initialize USB keyboard device: {str(e)}")
+                return ExploitResult(False, f"Failed to initialize USB keyboard device: {str(e)}", {})
+            
+            # Set running flag
+            self.running = True
+            
+            # Define our typing coroutine - similar to rubber-ducky.py
+            async def type_text():
+                self.logger.info(f"Waiting {delay_before_typing} seconds before typing...")
+                await asyncio.sleep(delay_before_typing)
+                
+                self.logger.info(f"Typing text: {text}")
+                await self.device.type_string(text)
+                
+                self.logger.info("Typing complete.")
+                
+                # Wait a configurable amount of time to ensure all keystrokes are processed
+                self.logger.info(f"Waiting {delay_after_typing} seconds for keystrokes to be processed...")
+                await asyncio.sleep(delay_after_typing)
+                
+                # Raise EndEmulation to exit facedancer_main cleanly without requiring Ctrl+C
+                self.logger.info("Exiting facedancer emulation...")
+                raise EndEmulation("Typing completed successfully")
+            
+            try:
+                # Use our custom Facedancer main function to avoid argument parsing issues
+                self.logger.info("Starting Facedancer execution...")
+                self.custom_facedancer_main(self.device, type_text())
+                self.logger.info("Facedancer execution completed successfully")
+            except Exception as e:
+                self.logger.error(f"Error in Facedancer execution: {str(e)}")
+                if hasattr(e, '__traceback__'):
+                    import traceback
+                    self.logger.error(''.join(traceback.format_tb(e.__traceback__)))
+                self.running = False
+                return ExploitResult(False, f"Facedancer execution failed: {str(e)}", {})
+            
+            # Return success - at this point the operation is complete
+            return ExploitResult(True, "SimpleRubberDuck executed successfully", {
+                "status": "complete",
+                "message": "Device has typed all commands"
+            })
+            
+        except Exception as e:
+            self.running = False
+            self.logger.error(f"Error during SimpleRubberDuck execution: {str(e)}")
+            if hasattr(e, '__traceback__'):
+                import traceback
+                self.logger.error(''.join(traceback.format_tb(e.__traceback__)))
+            return ExploitResult(False, f"SimpleRubberDuck failed: {str(e)}", {})
+        finally:
+            # Reset the running flag
+            self.running = False
+
+    @hookimpl
+    def cleanup(self):
+        """Clean up resources when plugin execution is finished"""
+        self.logger.info("Cleaning up SimpleRubberDuckPlugin")
+        
+        try:
+            # Signal any running operations to stop
+            self.running = False
+            
+            # Disconnect the device if it exists
+            if hasattr(self, 'device') and self.device:
+                try:
+                    self.logger.info("Disconnecting USB keyboard device...")
+                    self.device.disconnect()
+                    self.logger.info("Keyboard Device disconnected")
+                except Exception as e:
+                    self.logger.error(f"Error disconnecting device: {str(e)}")
+                finally:
+                    self.device = None
+                
+            self.logger.info("Cleanup completed successfully")
+            
+        except Exception as e:
+            self.logger.error(f"Error during cleanup: {str(e)}")
+            if hasattr(e, '__traceback__'):
+                import traceback
+                self.logger.error(''.join(traceback.format_tb(e.__traceback__))) 

iotsploit_exploits/wifi_scan/wifi_scan.py

@@ -0,0 +1,242 @@
+#!/usr/bin/python3
+"""
+WiFi Scan Exploit Plugin.
+
+This plugin scans for surrounding WiFi networks using the WiFi backend
+injected via PluginContext. It demonstrates the backend injection mechanism
+and provides a simple way to discover available WiFi networks.
+"""
+
+import logging
+import pluggy
+from typing import Optional, Any, List, Dict
+
+from iotsploit_core.core.exploit_spec import ExploitResult, AsyncExploitResult
+from iotsploit_core.core.base_plugin import BasePlugin
+from iotsploit_core.context import PluginContext
+from iotsploit_core.utils import iots_logger
+
+logger = logging.getLogger(__name__)
+hookimpl = pluggy.HookimplMarker("exploit_mgr")
+
+
+class WifiScanPlugin(BasePlugin):
+    """
+    WiFi Scan Plugin - Scans for surrounding WiFi networks.
+    
+    This plugin uses the WiFi backend injected via PluginContext to scan
+    for available WiFi networks and returns their SSIDs and metadata.
+    """
+    
+    def __init__(self):
+        super().__init__({
+            'Name': 'WiFi Scan',
+            'Description': 'Scan for surrounding WiFi networks and list their SSIDs, BSSIDs, signal strength, and security information.',
+            'License': 'GPL',
+            'Author': ['iotsploit'],
+            'RequiresRoot': False,
+            'Parameters': {
+                'min_signal': {
+                    'type': 'int',
+                    'required': False,
+                    'description': 'Minimum signal strength to include in results (0-100)',
+                    'default': 0
+                },
+                'sort_by': {
+                    'type': 'str',
+                    'required': False,
+                    'description': 'Sort results by: signal, ssid, or bssid',
+                    'default': 'signal'
+                }
+            }
+        })
+        self.wifi_backend = None
+        self.logger = iots_logger.get_logger("wifi_scan")
+    
+    @hookimpl
+    def initialize(self, ctx: Optional[PluginContext] = None):
+        """
+        Initialize the plugin with platform backend context.
+
+        Args:
+            ctx: PluginContext containing backend instances (e.g., ctx.wifi)
+        """
+        self.logger.info("Initializing WifiScanPlugin")
+
+        if ctx is None or getattr(ctx, "wifi", None) is None:
+            self.logger.warning("WiFi backend not available in injected PluginContext")
+            self.wifi_backend = None
+            return
+
+        self.wifi_backend = ctx.wifi
+        self.logger.info("WiFi backend injected successfully")
+    
+    @hookimpl
+    def execute(self, target: Optional[Any] = None, parameters: Optional[dict] = None) -> ExploitResult:
+        """
+        Execute WiFi scan synchronously.
+        
+        Args:
+            target: Not used for WiFi scan
+            parameters: Optional parameters (min_signal, sort_by)
+        
+        Returns:
+            ExploitResult with scan results
+        """
+        self.logger.info("Executing WiFi scan")
+        
+        # Check if WiFi backend is available
+        if self.wifi_backend is None:
+            error_msg = "WiFi backend not available. Ensure PluginContext was injected."
+            self.logger.error(error_msg)
+            return ExploitResult(False, error_msg, {})
+        
+        try:
+            # Get parameters
+            params = parameters or {}
+            min_signal = params.get('min_signal', self.info['Parameters']['min_signal']['default'])
+            sort_by = params.get('sort_by', self.info['Parameters']['sort_by']['default'])
+            
+            # Perform scan
+            self.logger.info("Starting WiFi scan...")
+            networks = self.wifi_backend.scan()
+            
+            if not networks:
+                self.logger.warning("No WiFi networks found")
+                return ExploitResult(True, "Scan completed but no networks found", {
+                    "networks": [],
+                    "count": 0
+                })
+            
+            # Filter by minimum signal strength
+            if min_signal > 0:
+                filtered_networks = [
+                    net for net in networks 
+                    if net.get('signal', 0) >= min_signal
+                ]
+                self.logger.info(f"Filtered {len(networks)} networks to {len(filtered_networks)} (min_signal={min_signal})")
+                networks = filtered_networks
+            
+            # Sort results
+            if sort_by == 'signal':
+                networks = sorted(networks, key=lambda x: x.get('signal', 0), reverse=True)
+            elif sort_by == 'ssid':
+                networks = sorted(networks, key=lambda x: x.get('ssid', '').lower())
+            elif sort_by == 'bssid':
+                networks = sorted(networks, key=lambda x: x.get('bssid', '').lower())
+            
+            # Format results for display
+            result_data = {
+                "networks": networks,
+                "count": len(networks),
+                "scan_params": {
+                    "min_signal": min_signal,
+                    "sort_by": sort_by
+                }
+            }
+            
+            # Log summary
+            self.logger.info(f"WiFi scan completed: found {len(networks)} networks")
+            for net in networks[:5]:  # Log first 5 networks
+                ssid = net.get('ssid', 'Unknown')
+                signal = net.get('signal', 0)
+                security = net.get('security', 'Unknown')
+                self.logger.info(f"  - {ssid} (Signal: {signal}%, Security: {security})")
+            
+            return ExploitResult(True, f"Found {len(networks)} WiFi networks", result_data)
+            
+        except Exception as e:
+            error_msg = f"WiFi scan failed: {str(e)}"
+            self.logger.error(error_msg, exc_info=True)
+            return ExploitResult(False, error_msg, {})
+    
+    @hookimpl
+    async def execute_async(self, target: Optional[Any] = None, parameters: Optional[dict] = None) -> AsyncExploitResult:
+        """
+        Execute WiFi scan asynchronously.
+        
+        Args:
+            target: Not used for WiFi scan
+            parameters: Optional parameters (min_signal, sort_by)
+        
+        Returns:
+            AsyncExploitResult with scan results
+        """
+        self.logger.info("Executing WiFi scan (async)")
+        
+        # Check if WiFi backend is available
+        if self.wifi_backend is None:
+            error_msg = "WiFi backend not available. Ensure PluginContext was injected."
+            self.logger.error(error_msg)
+            return AsyncExploitResult(status=False, message=error_msg, data={})
+        
+        try:
+            # Get parameters
+            params = parameters or {}
+            min_signal = params.get('min_signal', self.info['Parameters']['min_signal']['default'])
+            sort_by = params.get('sort_by', self.info['Parameters']['sort_by']['default'])
+            
+            # Perform scan (scan() is synchronous but we're in async context)
+            self.logger.info("Starting WiFi scan...")
+            networks = self.wifi_backend.scan()
+            
+            if not networks:
+                self.logger.warning("No WiFi networks found")
+                return AsyncExploitResult(
+                    status=True,
+                    message="Scan completed but no networks found",
+                    data={"networks": [], "count": 0}
+                )
+            
+            # Filter by minimum signal strength
+            if min_signal > 0:
+                filtered_networks = [
+                    net for net in networks 
+                    if net.get('signal', 0) >= min_signal
+                ]
+                self.logger.info(f"Filtered {len(networks)} networks to {len(filtered_networks)} (min_signal={min_signal})")
+                networks = filtered_networks
+            
+            # Sort results
+            if sort_by == 'signal':
+                networks = sorted(networks, key=lambda x: x.get('signal', 0), reverse=True)
+            elif sort_by == 'ssid':
+                networks = sorted(networks, key=lambda x: x.get('ssid', '').lower())
+            elif sort_by == 'bssid':
+                networks = sorted(networks, key=lambda x: x.get('bssid', '').lower())
+            
+            # Format results
+            result_data = {
+                "networks": networks,
+                "count": len(networks),
+                "scan_params": {
+                    "min_signal": min_signal,
+                    "sort_by": sort_by
+                }
+            }
+            
+            # Log summary
+            self.logger.info(f"WiFi scan completed: found {len(networks)} networks")
+            for net in networks[:5]:  # Log first 5 networks
+                ssid = net.get('ssid', 'Unknown')
+                signal = net.get('signal', 0)
+                security = net.get('security', 'Unknown')
+                self.logger.info(f"  - {ssid} (Signal: {signal}%, Security: {security})")
+            
+            return AsyncExploitResult(
+                status=True,
+                message=f"Found {len(networks)} WiFi networks",
+                data=result_data
+            )
+            
+        except Exception as e:
+            error_msg = f"WiFi scan failed: {str(e)}"
+            self.logger.error(error_msg, exc_info=True)
+            return AsyncExploitResult(status=False, message=error_msg, data={})
+    
+    @hookimpl
+    def cleanup(self):
+        """Clean up resources when plugin execution is finished"""
+        self.logger.info("Cleaning up WifiScanPlugin")
+        # WiFi backend is managed by the context, no cleanup needed here
+        self.wifi_backend = None

iotsploit_exploits-0.0.6.dist-info/METADATA

@@ -0,0 +1,65 @@
+Metadata-Version: 2.3
+Name: iotsploit-exploits
+Version: 0.0.6
+Summary: Official IoTSploit exploit plugin package
+License: GPL-3.0-or-later
+Author: IoTSploit Team
+Author-email: support@iotsploit.org
+Requires-Python: >=3.10,<4.0
+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
+Requires-Dist: facedancer (>=3.0.6,<4.0)
+Requires-Dist: iotsploit-core (>=0.0.6,<0.0.7)
+Requires-Dist: iotsploit-django (>=0.0.6,<0.0.7)
+Requires-Dist: pwntools (>=4.12)
+Requires-Dist: pyserial (>=3.5)
+Requires-Dist: scapy (>=2.5)
+Description-Content-Type: text/markdown
+
+# iotsploit-exploits
+
+Official IoTSploit exploit plugin package. Contains all built-in exploit/security testing plugins.
+
+## Included Plugins
+
+| Plugin | Module | Description |
+|--------|--------|-------------|
+| Flood Attack | `iotsploit_exploits.flood_attack` | Network flood attack |
+| SYN Flood | `iotsploit_exploits.flood_attack` | TCP SYN flood attack |
+| WiFi Scan | `iotsploit_exploits.wifi_scan` | WiFi network scanner |
+| IP Scan | `iotsploit_exploits.ip_scan` | IP network scanner |
+| Nmap Scan | `iotsploit_exploits.nmap_scan` | Nmap-based scanner |
+| ADB Check | `iotsploit_exploits.adb_check` | Android Debug Bridge security check |
+| Hydra SSH | `iotsploit_exploits.hydra_ssh_attack` | Hydra SSH attack |
+| SSH Plugin | `iotsploit_exploits.plugin_ssh` | SSH connection plugin |
+| Serial Reader | `iotsploit_exploits.serial` | Picocom serial reader |
+| GreatFET Echo | `iotsploit_exploits.greatfet_echo` | FTDI echo emulation |
+| Rubber Duck | `iotsploit_exploits.greatfet_rubber_duck` | USB rubber duck attack |
+| Simple Rubber Duck | `iotsploit_exploits.simple_rubber_duck` | Simplified rubber duck |
+| Async Sleep | `iotsploit_exploits.demo` | Demo async plugin |
+| Stream Data | `iotsploit_exploits.demo` | Demo streaming plugin |
+
+## System Tool Dependencies
+
+Some plugins require system-level tools (not installable via pip):
+
+- **nmap_scan**: Requires `nmap` (`apt install nmap`)
+- **hydra_ssh_attack**: Requires `hydra` (`apt install hydra`)
+- **adb_check**: Requires `adb` (`apt install android-tools-adb`)
+
+## Installation
+
+```bash
+pip install iotsploit-exploits
+```
+
+For development:
+
+```bash
+pip install -e ./iotsploit-exploits
+```
+

iotsploit_exploits-0.0.6.dist-info/RECORD

@@ -0,0 +1,30 @@
+iotsploit_exploits/__init__.py,sha256=guANNqpExIjL6PKjJ4cGNP-h3oC4JlQVu57vJu1rPN4,49
+iotsploit_exploits/adb_check/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+iotsploit_exploits/adb_check/adb_check.py,sha256=MJKxmuSNakbhd_v86ecbhiBC-pH1U7uXZXT-KpG-o-I,22369
+iotsploit_exploits/demo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+iotsploit_exploits/demo/async_sleep_attack.py,sha256=CV7RZz_n0egyN1ZUG9iMpMCMaEWZZj_IFMYofqXjv-A,3553
+iotsploit_exploits/demo/stream_data_attack.py,sha256=-Vl118YkeS-niyJ6PTp08wNSHMxEvbdzuf9HSRPp-Fs,6661
+iotsploit_exploits/flood_attack/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+iotsploit_exploits/flood_attack/flood_attack.py,sha256=XyspX6L0tjdwgoK2Axdp3uzb8wssAUN_lxWwLdNvdjM,5094
+iotsploit_exploits/flood_attack/syn_flood_attack.py,sha256=htzhPDeaLSYvkD-srtIY6V5lyg6Gdf6kvVU3y5KrvpY,9071
+iotsploit_exploits/greatfet_echo.py,sha256=RcfuWGkNP0qLks3LW4cNmPT8x4qmpLvadWVxBPeye_o,4188
+iotsploit_exploits/greatfet_rubber_duck.py,sha256=r3iZVVV2s5yoTtWJBoqu0ECdMoh4n9dko2aZb4T6Rso,19314
+iotsploit_exploits/hydra_cracker/weak_pass.txt,sha256=TRaT9rdJ0eS3iBETr7Y4S4ZH93jGfSP7GIP8KPZh3-k,4847
+iotsploit_exploits/hydra_cracker/weak_pass_simple.txt,sha256=Lflu1RuGHbL8y7RlppWU-wUEhcPJlY4hd6HvOZrh1oQ,39
+iotsploit_exploits/hydra_ssh_attack.py,sha256=Z_AL3WkHNtFvHHx85pEh1_o-Gj8MhflVGuoCPTe71xk,6627
+iotsploit_exploits/ip_scan/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+iotsploit_exploits/ip_scan/ip_scan.py,sha256=Z624vuAIBrhhi44yFvS1ZeZKxH9QK0YNHKUq9m1GOIQ,7284
+iotsploit_exploits/nmap_scan/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+iotsploit_exploits/nmap_scan/nmap_scan.py,sha256=PL88bQVNl4vaSMN6Vyo1NEAbxxazlc46uM03FWu30DU,7403
+iotsploit_exploits/plugin_ssh.py,sha256=LOwWwqpADG2ZufNSkxbQKClxPyaFgWHrjI1-XV3L-KE,5250
+iotsploit_exploits/rubber_duck_scripts/linux_infogather.txt,sha256=ONOi41ZiWZM04hf4kF4okutNSpsoB_iT49YtVkSHtzw,2509
+iotsploit_exploits/rubber_duck_scripts/windows_payload.txt,sha256=_urWrg1jIjpFYuo6Ksdo001gv0rutn7rmtiK7cEm1I8,2525
+iotsploit_exploits/serial/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+iotsploit_exploits/serial/picocom_serial_reader.py,sha256=ecghWdPkohh-jUcCNFW2_Z7H81EYBQFQL999vTsq6oI,31453
+iotsploit_exploits/simple_rubber_duck.py,sha256=7eXl1T7nGK02RxLB8FQLKhdYhYgJirEFboDu5MhXm3U,8052
+iotsploit_exploits/wifi_scan/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+iotsploit_exploits/wifi_scan/wifi_scan.py,sha256=kcMq0crR99R5vRCOOcfmVEBrrLLZg85MyBcukeKGFoM,9619
+iotsploit_exploits-0.0.6.dist-info/METADATA,sha256=xPDpP3RnTHZMIIG7bdESoMlX_GHF44MOxWY-aeE-qlk,2497
+iotsploit_exploits-0.0.6.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+iotsploit_exploits-0.0.6.dist-info/entry_points.txt,sha256=7AfeJunmncgyIYDJN-SKBvqPzFN_98QIpYXSZpnrb-o,1059
+iotsploit_exploits-0.0.6.dist-info/RECORD,,

iotsploit_exploits-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

iotsploit_exploits-0.0.6.dist-info/entry_points.txt

@@ -0,0 +1,16 @@
+[iotsploit.exploit_plugins]
+adb_check=iotsploit_exploits.adb_check.adb_check:AdbSecurityCheckPlugin
+async_sleep_attack=iotsploit_exploits.demo.async_sleep_attack:AsyncSleepAttackPlugin
+flood_attack=iotsploit_exploits.flood_attack.flood_attack:FloodAttackPlugin
+greatfet_echo=iotsploit_exploits.greatfet_echo:FTDIEchoPlugin
+greatfet_rubber_duck=iotsploit_exploits.greatfet_rubber_duck:RubberDuckPlugin
+hydra_ssh_attack=iotsploit_exploits.hydra_ssh_attack:HydraSSHAttackPlugin
+ip_scan=iotsploit_exploits.ip_scan.ip_scan:IPScanPlugin
+nmap_scan=iotsploit_exploits.nmap_scan.nmap_scan:NmapScanPlugin
+picocom_serial_reader=iotsploit_exploits.serial.picocom_serial_reader:PicocomSerialReaderPlugin
+plugin_ssh=iotsploit_exploits.plugin_ssh:SSHPlugin
+simple_rubber_duck=iotsploit_exploits.simple_rubber_duck:SimpleRubberDuckPlugin
+stream_data_attack=iotsploit_exploits.demo.stream_data_attack:StreamDataAttackPlugin
+syn_flood_attack=iotsploit_exploits.flood_attack.syn_flood_attack:SynFloodAttackPlugin
+wifi_scan=iotsploit_exploits.wifi_scan.wifi_scan:WifiScanPlugin
+