iotsploit-cli 0.0.6__py3-none-any.whl

iotsploit_cli/commands/plugin_commands.py

@@ -0,0 +1,249 @@
+#!/usr/bin/env python
+
+import cmd2
+from cmd2 import ansi
+from .base_commands import BaseCommands
+from iotsploit_core.core.exploit_spec import ExploitResult
+from iotsploit_django.tools.input_mgr import Input_Mgr
+from iotsploit_django.adapters.django.plugins.models import Plugin
+from iotsploit_django.adapters.django.plugins.models import PluginGroup, PluginGroupTree
+from iotsploit_core.utils import iots_logger
+
+logger = iots_logger.get_logger(__name__)
+
+
+class PluginCommands(BaseCommands):
+    """Plugin-related commands for the SAT Shell"""
+
+    @cmd2.with_category('Plugin Commands')
+    def do_list_plugins(self, arg):
+        'List all available plugins'
+        plugins = self.plugin_manager.list_plugins()
+        
+        if plugins:
+            logger.info(ansi.style("Available plugins:", fg=ansi.Fg.CYAN))
+            for plugin in plugins:
+                logger.info(ansi.style(f"  - {plugin}", fg=ansi.Fg.CYAN))
+        else:
+            logger.info(ansi.style("No plugins available.", fg=ansi.Fg.YELLOW))
+
+    do_lsp = do_list_plugins
+
+    @cmd2.with_category('Plugin Commands')
+    def do_execute_plugin(self, arg):
+        'Execute a specific plugin'
+        plugins = self.plugin_manager.list_plugins()
+        
+        if not plugins:
+            logger.info(ansi.style("No plugins available to execute.", fg=ansi.Fg.YELLOW))
+            return
+
+        if not arg:
+            choice = Input_Mgr.Instance().single_choice(
+                "Please select a plugin to execute",
+                plugins
+            )
+        else:
+            choice = arg
+
+        if choice not in plugins:
+            logger.error(ansi.style(f"Plugin '{choice}' not found.", fg=ansi.Fg.RED))
+            return
+
+        logger.info(ansi.style(f"Executing plugin: {choice}", fg=ansi.Fg.CYAN))
+        try:
+            # Get the plugin instance to access its parameters
+            plugin_instance = self.plugin_manager.get_plugin(choice)
+            if not plugin_instance:
+                logger.error(ansi.style(f"Could not get plugin instance for '{choice}'", fg=ansi.Fg.RED))
+                return
+                
+            # Get plugin info with parameters
+            plugin_info = plugin_instance.get_info()
+            plugin_params = plugin_info.get('Parameters', {})
+            
+            # Get current target from target manager
+            target_manager = self.target_manager
+            current_target = target_manager.get_current_target()
+            
+            # Prepare target dictionary
+            target_dict = {}
+            
+            # If we have a target, include its properties
+            if current_target:
+                # Add target properties to target dictionary
+                target_dict = current_target.get_info() if hasattr(current_target, 'get_info') else {}
+            
+            # Prompt for required parameters that are not in the target
+            for param_name, param_info in plugin_params.items():
+                if param_name not in target_dict and param_info.get('required', False):
+                    param_type = param_info.get('type', 'str')
+                    description = param_info.get('description', f"Enter {param_name}")
+                    default = param_info.get('default')
+                    validation = param_info.get('validation', {})
+                    
+                    if param_type == 'str':
+                        if 'choices' in validation:
+                            # Use single_choice for string with choices
+                            value = Input_Mgr.Instance().single_choice(
+                                f"{description} (Choose one)",
+                                validation['choices']
+                            )
+                        else:
+                            # Regular string input
+                            value = Input_Mgr.Instance().string_input(description)
+                    elif param_type == 'int':
+                        # Integer input with optional min/max validation
+                        min_val = validation.get('min')
+                        max_val = validation.get('max')
+                        value = Input_Mgr.Instance().int_input(
+                            description,
+                            min_val=min_val,
+                            max_val=max_val
+                        )
+                    elif param_type == 'bool':
+                        # Boolean input
+                        value = Input_Mgr.Instance().yes_no_input(
+                            description,
+                            default=default if default is not None else True
+                        )
+                    else:
+                        # Default to string for unknown types
+                        value = Input_Mgr.Instance().string_input(description)
+                    
+                    # Add to target dict
+                    target_dict[param_name] = value
+            
+            logger.debug(f"Executing plugin with target configuration: {target_dict}")
+            
+            # Now execute the plugin with our target dictionary
+            result = self.plugin_manager.execute_plugin(choice, target=target_dict)
+            
+            # Check if this is an async execution
+            if isinstance(result, dict) and result.get('execution_type') == 'async':
+                task_id = result.get('task_id')
+                logger.info(ansi.style(f"Plugin running asynchronously with task ID: {task_id}", fg=ansi.Fg.CYAN))
+                
+                # Ask user if they want to wait for results
+                wait_for_results = Input_Mgr.Instance().yes_no_input(
+                    "Do you want to wait for the asynchronous task to complete?",
+                    default=True
+                )
+                
+                if wait_for_results:
+                    # Import celery here to avoid circular imports
+                    try:
+                        from celery.result import AsyncResult
+                        from iotsploit_django.tasks import celery_app
+                        import time
+
+                        task_result = AsyncResult(task_id, app=celery_app)
+                        
+                        # Poll for results with a progress bar
+                        progress = 0
+                        start_time = time.time()
+                        
+                        logger.info(ansi.style("Waiting for task to complete...", fg=ansi.Fg.CYAN))
+                        
+                        while not task_result.ready():
+                            # Try to get progress information
+                            task_info = task_result.info
+                            
+                            if isinstance(task_info, dict):
+                                new_progress = task_info.get('progress', 0)
+                                message = task_info.get('message', 'Processing...')
+                                
+                                # Only update if progress has changed
+                                if new_progress != progress:
+                                    progress = new_progress
+                                    # Print progress bar
+                                    bar_length = 50
+                                    filled_length = int(bar_length * progress / 100)
+                                    bar = '█' * filled_length + '-' * (bar_length - filled_length)
+                                    logger.info(f"Progress: [{bar}] {progress:.1f}% - {message}")
+                            
+                            # Sleep briefly before checking again
+                            time.sleep(0.5)
+                            
+                            # Add a timeout to prevent infinite waiting
+                            if time.time() - start_time > 300:  # 5 minutes
+                                logger.warning(ansi.style("Timeout waiting for task to complete", fg=ansi.Fg.YELLOW))
+                                break
+                        
+                        # Get final result
+                        final_result = task_result.get(timeout=5)  # 5 second timeout for final result
+                        
+                        logger.info(ansi.style("Async plugin execution completed", fg=ansi.Fg.GREEN))
+                        if isinstance(final_result, dict):
+                            logger.info(ansi.style("Plugin execution result:", fg=ansi.Fg.GREEN))
+                            for key, value in final_result.items():
+                                logger.info(f"{key}: {value}")
+                        else:
+                            logger.info(f"Result: {final_result}")
+                    
+                    except ImportError as e:
+                        logger.error(ansi.style(f"Error importing Celery modules: {str(e)}", fg=ansi.Fg.RED))
+                    except Exception as e:
+                        logger.error(ansi.style(f"Error getting async result: {str(e)}", fg=ansi.Fg.RED))
+                        logger.debug("Detailed error:", exc_info=True)
+                
+                # Display initial async info regardless
+                logger.info(ansi.style("Initial async task info:", fg=ansi.Fg.GREEN))
+                logger.info(str(result))
+                
+            elif isinstance(result, ExploitResult):
+                logger.info(ansi.style("Plugin execution result:", fg=ansi.Fg.GREEN))
+                logger.info(f"Success: {result.success}")
+                logger.info(f"Message: {result.message}")
+                logger.info(f"Data: {result.data}")
+            else:
+                logger.info(ansi.style("Plugin execution result:", fg=ansi.Fg.GREEN))
+                logger.info(str(result))
+        except Exception as e:
+            logger.error(ansi.style(f"Error executing plugin: {str(e)}", fg=ansi.Fg.RED))
+            logger.debug("Detailed error:", exc_info=True)
+
+    do_exec = do_execute_plugin
+
+    @cmd2.with_category('Plugin Commands')
+    def do_flash_plugins(self, arg):
+        'Refresh and reload all plugins from installed packages and entry points'
+        try:
+            logger.info(ansi.style("Starting plugin refresh...", fg=ansi.Fg.CYAN))
+            
+            # Get current plugin count
+            initial_plugins = len(self.plugin_manager.list_plugins())
+            
+            # Run auto-discovery
+            self.plugin_manager.auto_discover_plugins()
+            
+            # Get new plugin count
+            final_plugins = len(self.plugin_manager.list_plugins())
+            
+            # Calculate changes
+            if final_plugins > initial_plugins:
+                logger.info(ansi.style(
+                    f"Plugin refresh complete! Added {final_plugins - initial_plugins} new plugins.", 
+                    fg=ansi.Fg.GREEN
+                ))
+            elif final_plugins < initial_plugins:
+                logger.info(ansi.style(
+                    f"Plugin refresh complete! Removed {initial_plugins - final_plugins} plugins.", 
+                    fg=ansi.Fg.YELLOW
+                ))
+            else:
+                logger.info(ansi.style(
+                    "Plugin refresh complete! No changes detected.", 
+                    fg=ansi.Fg.CYAN
+                ))
+            
+            # Display current plugins
+            logger.info(ansi.style("\nCurrent plugins:", fg=ansi.Fg.CYAN))
+            for plugin in self.plugin_manager.list_plugins():
+                logger.info(ansi.style(f"  - {plugin}", fg=ansi.Fg.CYAN))
+                
+        except Exception as e:
+            logger.error(ansi.style(f"Error refreshing plugins: {str(e)}", fg=ansi.Fg.RED))
+            logger.debug("Detailed error:", exc_info=True)
+
+    do_fp = do_flash_plugins

iotsploit_cli/commands/system_commands.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python
+
+import cmd2
+from cmd2 import ansi
+from .base_commands import BaseCommands
+from iotsploit_core.core.exploit_spec import ExploitResult
+from iotsploit_django.tools.input_mgr import Input_Mgr
+from iotsploit_core.utils import iots_logger
+
+logger = iots_logger.get_logger(__name__)
+
+
+class SystemCommands(BaseCommands):
+    """System-related commands for the SAT Shell"""
+
+    @cmd2.with_category('System Commands')
+    def do_exploit(self, arg):
+        'Execute all plugins in the IotSploit System'
+        logger.info(ansi.style("Executing all plugins in the IotSploit System", fg=ansi.Fg.CYAN))
+        
+        results = self.plugin_manager.exploit()
+        
+        if not results:
+            logger.warning(ansi.style("No results returned from any plugins", fg=ansi.Fg.YELLOW))
+        else:
+            # Log the results
+            for plugin_name, result in results.items():
+                if result is None:
+                    logger.warning(ansi.style(f"Plugin {plugin_name} returned no result", fg=ansi.Fg.YELLOW))
+                elif isinstance(result, ExploitResult):
+                    logger.info(ansi.style(f"Plugin {plugin_name} execution result:", fg=ansi.Fg.GREEN))
+                    logger.info(f"Success: {result.success}")
+                    logger.info(f"Message: {result.message}")
+                    logger.info(f"Data: {result.data}")
+                else:
+                    logger.info(ansi.style(f"Plugin {plugin_name} execution result:", fg=ansi.Fg.GREEN))
+                    logger.info(str(result))
+        
+        logger.info(ansi.style("Exploit execution completed", fg=ansi.Fg.CYAN))
+
+    @cmd2.with_category('System Commands')
+    def do_exit(self, arg):
+        'Exit Console'
+        if self.django_server_process:
+            self.do_stop_server(arg)
+        self._cleanup_devices()
+        logger.info("IotSploit Shell Quit. ByeBye~")
+        return True
+
+    @cmd2.with_category('System Commands')
+    def do_set_log_level(self, arg):
+        'Set the logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)'
+        valid_levels = ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL']
+        
+        if not arg:
+            # If no argument provided, let user select from valid levels
+            selected_level = Input_Mgr.Instance().single_choice(
+                "Select logging level",
+                valid_levels
+            )
+        else:
+            # If argument provided, validate it
+            selected_level = arg.upper()
+            if selected_level not in valid_levels:
+                logger.error(ansi.style(f"Invalid log level. Choose from: {', '.join(valid_levels)}", fg=ansi.Fg.RED))
+                return
+
+        try:
+            # Set the log level via core logger (affects all core-managed loggers)
+            iots_logger.set_level(selected_level)
+            logger.info(ansi.style(f"Log level set to {selected_level}", fg=ansi.Fg.GREEN))
+        except Exception as e:
+            logger.error(ansi.style(f"Error setting log level: {str(e)}", fg=ansi.Fg.RED))
+            logger.debug("Detailed error:", exc_info=True)
+
+    # Add an alias for set_log_level
+    do_sll = do_set_log_level 

iotsploit_cli/commands/target_commands.py

@@ -0,0 +1,246 @@
+#!/usr/bin/env python
+
+import cmd2
+from cmd2 import ansi
+from .base_commands import BaseCommands
+from iotsploit_django.tools.input_mgr import Input_Mgr
+from iotsploit_core.utils import iots_logger
+
+logger = iots_logger.get_logger(__name__)
+
+
+class TargetCommands(BaseCommands):
+    """Target-related commands for the SAT Shell"""
+
+    @cmd2.with_category('Target Commands')
+    def do_list_targets(self, arg):
+        'List all targets stored in the database'
+        try:
+            targets = self.target_manager.get_all_targets()
+            
+            if not targets:
+                logger.info(ansi.style("No targets found in the database.", fg=ansi.Fg.YELLOW))
+                return
+
+            logger.info(ansi.style("Targets in the database:", fg=ansi.Fg.CYAN))
+            for target in targets:
+                logger.info(ansi.style(f"  - ID: {target['target_id']}", fg=ansi.Fg.GREEN))
+                logger.info(f"    Name: {target['name']}")
+                logger.info(f"    Type: {target['type']}")
+                logger.info(f"    Status: {target['status']}")
+                
+                # All target types now have ip_address and location
+                logger.info(f"    IP Address: {target.get('ip_address', 'N/A')}")
+                logger.info(f"    Location: {target.get('location', 'N/A')}")
+                
+                logger.info(f"    Properties: {target['properties']}")
+                logger.info("    ---")
+
+        except Exception as e:
+            logger.error(ansi.style(f"Error listing targets: {str(e)}", fg=ansi.Fg.RED))
+
+    do_lst = do_list_targets
+
+    @cmd2.with_category('Target Commands')
+    def do_target_select(self, arg):
+        'Select a target from available targets'
+        try:
+            targets = self.target_manager.get_all_targets()
+            
+            if not targets:
+                logger.info(ansi.style("No targets found in the database.", fg=ansi.Fg.YELLOW))
+                return
+
+            # Create list of target choices for display
+            # Show all targets with their type, and IP if available
+            target_choices = []
+            for t in targets:
+                ip_part = f" - {t['ip_address']}" if t.get('ip_address') else ""
+                target_choices.append(f"{t['name']} ({t['type']}){ip_part}")
+            
+            # Use Input_Mgr for target selection
+            selected_choice = Input_Mgr.Instance().single_choice(
+                "Select target for operation:",
+                target_choices
+            )
+            
+            # Find the index of the selected choice
+            selected_index = target_choices.index(selected_choice)
+            
+            # Convert the selected target dictionary to a Vehicle instance using create_target_instance
+            selected_target_dict = targets[selected_index]
+            selected_target = self.target_manager.create_target_instance(selected_target_dict)
+            
+            # Set the selected target as current
+            self.target_manager.set_current_target(selected_target)
+            
+            logger.info(ansi.style(f"Selected target: {selected_target.name}", fg=ansi.Fg.GREEN))
+
+        except Exception as e:
+            logger.error(ansi.style(f"Error selecting target: {str(e)}", fg=ansi.Fg.RED))
+
+    @cmd2.with_category('Target Commands')
+    def do_edit_target(self, arg):
+        'Edit an existing target in the database'
+        try:
+            # Get all targets
+            targets = self.target_manager.get_all_targets()
+            if not targets:
+                logger.warning(ansi.style("No targets available to edit.", fg=ansi.Fg.YELLOW))
+                return
+
+            # Create list of target choices
+            target_choices = [f"{t['name']} ({t['target_id']})" for t in targets]
+            
+            # Let user select a target
+            selected = Input_Mgr.Instance().single_choice(
+                "Select target to edit",
+                target_choices
+            )
+            
+            # Get target ID from selection (take the last parentheses group)
+            target_id = selected.split('(')[-1].split(')')[0]
+            target = next(t for t in targets if t['target_id'] == target_id)
+            
+            # Fields that can be edited
+            editable_fields = {
+                'name': str,
+                'status': str,
+                'ip_address': str,
+                'location': str
+            }
+            
+            # Let user select which field to edit
+            field_choices = list(editable_fields.keys()) + ['properties']
+            field = Input_Mgr.Instance().single_choice(
+                "Select field to edit",
+                field_choices
+            )
+            
+            if field == 'properties':
+                # Handle properties editing
+                print("\nCurrent properties:")
+                for key, value in target['properties'].items():
+                    print(f"{key}: {value}")
+                
+                # Let user choose to add/edit/delete property
+                action = Input_Mgr.Instance().single_choice(
+                    "Select action",
+                    ['Add property', 'Edit property', 'Delete property']
+                )
+                
+                if action == 'Add property':
+                    key = Input_Mgr.Instance().string_input("Enter property name")
+                    value = Input_Mgr.Instance().string_input("Enter property value")
+                    target['properties'][key] = value
+                
+                elif action == 'Edit property':
+                    if not target['properties']:
+                        logger.warning(ansi.style("No properties to edit.", fg=ansi.Fg.YELLOW))
+                        return
+                    prop_key = Input_Mgr.Instance().single_choice(
+                        "Select property to edit",
+                        list(target['properties'].keys())
+                    )
+                    new_value = Input_Mgr.Instance().string_input(
+                        f"Enter new value for {prop_key}"
+                    )
+                    target['properties'][prop_key] = new_value
+                
+                elif action == 'Delete property':
+                    if not target['properties']:
+                        logger.warning(ansi.style("No properties to delete.", fg=ansi.Fg.YELLOW))
+                        return
+                    prop_key = Input_Mgr.Instance().single_choice(
+                        "Select property to delete",
+                        list(target['properties'].keys())
+                    )
+                    del target['properties'][prop_key]
+            
+            else:
+                # Handle regular field editing
+                current_value = target.get(field, '')
+                new_value = Input_Mgr.Instance().string_input(
+                    f"Enter new value for {field}"
+                )
+                target[field] = new_value
+            
+            # Update the target in the database
+            success = self.target_manager.update_target(target)
+            
+            if success:
+                logger.info(ansi.style(f"Successfully updated target {target_id}", fg=ansi.Fg.GREEN))
+            else:
+                logger.error(ansi.style(f"Failed to update target {target_id}", fg=ansi.Fg.RED))
+
+        except Exception as e:
+            logger.error(ansi.style(f"Error editing target: {str(e)}", fg=ansi.Fg.RED))
+            logger.debug("Detailed error:", exc_info=True)
+
+    do_et = do_edit_target
+
+    @cmd2.with_category('Target Commands')
+    def do_target_import(self, arg):
+        'Import targets from JSON file (optional, only when needed)'
+        try:
+            if not arg:
+                json_file = Input_Mgr.Instance().string_input(
+                    "Enter JSON file path (default: conf/target.json)"
+                ) or "conf/target.json"
+            else:
+                json_file = arg.strip()
+            
+            # Check if file exists
+            import os
+            if not os.path.exists(json_file):
+                logger.error(ansi.style(f"File not found: {json_file}", fg=ansi.Fg.RED))
+                return
+            
+            # Check existing targets
+            existing_targets = self.target_manager.get_all_targets()
+            if existing_targets:
+                logger.warning(ansi.style(f"Database already contains {len(existing_targets)} targets:", fg=ansi.Fg.YELLOW))
+                for target in existing_targets:
+                    logger.info(f"  - {target['name']} ({target['target_id']})")
+                
+                overwrite = Input_Mgr.Instance().single_choice(
+                    "How to handle existing targets?",
+                    ["Skip existing (recommended)", "Overwrite existing", "Cancel import"]
+                )
+                
+                if overwrite == "Cancel import":
+                    logger.info("Import cancelled")
+                    return
+                
+                force_overwrite = (overwrite == "Overwrite existing")
+            else:
+                force_overwrite = False
+            
+            # Import targets
+            self.target_manager.parse_and_set_target_from_json(json_file, force_overwrite)
+            logger.info(ansi.style(f"Import completed from {json_file}", fg=ansi.Fg.GREEN))
+            
+        except Exception as e:
+            logger.error(ansi.style(f"Error importing targets: {str(e)}", fg=ansi.Fg.RED))
+
+    @cmd2.with_category('Target Commands')
+    def do_target_export(self, arg):
+        'Export current database targets to JSON file'
+        try:
+            if not arg:
+                json_file = Input_Mgr.Instance().string_input(
+                    "Enter export file path (default: conf/target_export.json)"
+                ) or "conf/target_export.json"
+            else:
+                json_file = arg.strip()
+            
+            # Export targets
+            success = self.target_manager.export_targets_to_json(json_file, backup_original=True)
+            
+            if success:
+                logger.info(ansi.style(f"Successfully exported targets to {json_file}", fg=ansi.Fg.GREEN))
+            else:
+                logger.error(ansi.style("Failed to export targets", fg=ansi.Fg.RED))
+                
+        except Exception as e:
+            logger.error(ansi.style(f"Error exporting targets: {str(e)}", fg=ansi.Fg.RED))