iotsploit-core 0.0.6__py3-none-any.whl

iotsploit_core/core/exploit_manager.py

@@ -0,0 +1,728 @@
+from __future__ import annotations
+
+import os
+# Disable pwntools terminal mode before any plugin imports to prevent
+# "argument must be an int, or have a fileno() method" errors in non-TTY environments
+os.environ.setdefault("PWNLIB_NOTERM", "1")
+
+import glob
+import importlib
+from importlib import metadata as importlib_metadata
+import importlib.util
+from pathlib import Path
+from typing import Optional, Callable, Any
+
+import pluggy
+
+from iotsploit_core.core.base_plugin import BasePlugin
+from iotsploit_core.core.exploit_spec import ExploitPluginSpec
+from iotsploit_core.domain.execution_plan import GroupStepSpec, PluginGroupSpec, PluginStepSpec
+from iotsploit_core.domain.plugin import PluginMeta
+from iotsploit_core.ports.plugin_repo import PluginGroupRepository, PluginMetaRepository
+from iotsploit_core.ports.task_runner import TaskRunner
+import logging
+
+logger = logging.getLogger(__name__)
+
+class ExploitPluginManager:
+    def __init__(
+        self,
+        *,
+        plugin_repo: PluginMetaRepository,
+        group_repo: PluginGroupRepository,
+        task_runner: TaskRunner,
+        plugins_dir: str | Path | None = None,
+        context_factory: Optional[Callable[[], Any]] = None,
+    ):
+        self._plugin_repo = plugin_repo
+        self._group_repo = group_repo
+        self._task_runner = task_runner
+        self._context_factory = context_factory
+
+        self.plugins = {}  # plugin_name -> plugin instance (loaded on demand)
+        self.plugin_registry = {}  # plugin_name -> {file_path, class_name}
+        self.pm = pluggy.PluginManager("exploit_mgr")
+        self.pm.add_hookspecs(ExploitPluginSpec)
+        self.plugins_dir = Path(plugins_dir) if plugins_dir is not None else self._default_plugins_dir()
+        self.load_plugins()
+        import atexit
+        atexit.register(self.cleanup_all_plugins)
+
+    @staticmethod
+    def _default_plugins_dir() -> Path | None:
+        env = os.getenv("IOTSPLOIT_EXPLOIT_PLUGINS_DIR") or os.getenv("SAT_EXPLOIT_PLUGINS_DIR")
+        if env:
+            return Path(env)
+        return None
+
+    @staticmethod
+    def _normalize_target_for_plugin(target):
+        """
+        Normalize target into a dict snapshot when possible.
+
+        Rationale:
+        - Django web path currently passes a domain object (e.g., Vehicle).
+        - sudo-runner / CLI often pass dict already.
+        - Plugins should not need Django imports; dict mode is the stable boundary.
+        """
+        if target is None:
+            return None
+        if isinstance(target, dict):
+            return target
+        # Domain targets implement get_info() to provide a serializable snapshot.
+        if hasattr(target, "get_info"):
+            try:
+                return target.get_info()
+            except Exception:
+                # Fall back to passing through if snapshot fails
+                return target
+        return target
+
+    def _ensure_context_injected(self, plugin_instance: BasePlugin) -> None:
+        """
+        Ensure plugin has backend context injected (idempotent).
+        
+        This method:
+        1. Checks if context was already injected (via _iots_ctx_injected flag)
+        2. If not, builds context using context_factory and calls plugin.initialize()
+        3. Marks plugin as injected to avoid duplicate initialization
+        
+        Note: context_factory is provided by the application layer (wiring),
+        keeping core free of platform/env dependencies.
+        
+        Args:
+            plugin_instance: Plugin instance to inject context into
+        """
+        # Skip if already injected (idempotent)
+        if getattr(plugin_instance, "_iots_ctx_injected", False):
+            return
+        
+        try:
+            # Initialize plugin right before execution.
+            # Important: NEVER call initialize(None). Prefer initialize(ctx), fallback to initialize().
+            if hasattr(plugin_instance, "initialize"):
+                if self._context_factory:
+                    ctx = self._context_factory()
+                    try:
+                        plugin_instance.initialize(ctx)
+                    except TypeError:
+                        # Legacy plugins may expose initialize() without params
+                        try:
+                            plugin_instance.initialize()
+                        except TypeError:
+                            logger.warning(
+                                "[exploit_mgr] Plugin initialize() signature mismatch; "
+                                "skipping initialization"
+                            )
+                else:
+                    # No context factory (no backend injection). Still try legacy initialize().
+                    try:
+                        plugin_instance.initialize()
+                    except TypeError:
+                        logger.debug(
+                            "[exploit_mgr] No context_factory and plugin initialize() requires args; "
+                            "skipping initialization for %s",
+                            plugin_instance.__class__.__name__,
+                        )
+            
+            # Mark as injected
+            plugin_instance._iots_ctx_injected = True
+            logger.debug("[exploit_mgr] Injected backend context into plugin")
+            
+        except Exception as e:
+            # Log error but don't fail execution (graceful degradation)
+            logger.warning(
+                "[exploit_mgr] Failed to inject backend context: %s. "
+                "Plugin may not have backend access.", str(e)
+            )
+
+    @staticmethod
+    def _iter_entry_points(group: str):
+        entry_points = importlib_metadata.entry_points()
+        if hasattr(entry_points, "select"):
+            return list(entry_points.select(group=group))
+        return list(entry_points.get(group, []))
+
+    def _upsert_plugin_meta(self, plugin_class: type[BasePlugin], module_path: str) -> str | None:
+        plugin_instance = plugin_class()
+        plugin_info = plugin_instance.get_info() or {}
+        plugin_name = plugin_info.get("Name", plugin_class.__name__)
+
+        meta = PluginMeta(
+            name=plugin_name,
+            module_path=module_path,
+            enabled=True,
+            description=str(plugin_info.get("Description", "") or ""),
+            license=str(plugin_info.get("License", "") or ""),
+            author=str(plugin_info.get("Author", "") or ""),
+            parameters=plugin_info.get("Parameters", None),
+        )
+        self._plugin_repo.upsert(meta)
+        logger.debug("[exploit_mgr] Upserted plugin meta: %s", plugin_name)
+        return plugin_name
+
+    def _discover_filesystem_plugins(self, plugins_dir: str | Path | None = None) -> set[str]:
+        discovered_plugins: set[str] = set()
+        plugins_dir = Path(plugins_dir) if plugins_dir is not None else self.plugins_dir
+
+        if plugins_dir is None:
+            return discovered_plugins
+        if not plugins_dir.exists():
+            logger.debug("[exploit_mgr] Legacy plugin directory does not exist: %s", plugins_dir)
+            return discovered_plugins
+
+        base_dir = os.path.abspath(str(plugins_dir))
+        plugin_files = glob.glob(f"{base_dir}/**/*.py", recursive=True)
+
+        for plugin_file in plugin_files:
+            try:
+                if "__init__.py" in plugin_file:
+                    continue
+
+                abs_path = os.path.abspath(plugin_file)
+                temp_mod_name = f"exploit_autodiscover_{hash(abs_path)}"
+                spec = importlib.util.spec_from_file_location(temp_mod_name, abs_path)
+                module = importlib.util.module_from_spec(spec)
+                if spec is None or spec.loader is None:
+                    logger.error("[exploit_mgr] Failed to create spec for %s", abs_path)
+                    continue
+                spec.loader.exec_module(module)
+
+                plugin_class = None
+                for _, obj in module.__dict__.items():
+                    if isinstance(obj, type) and issubclass(obj, BasePlugin) and obj != BasePlugin:
+                        plugin_class = obj
+                        break
+
+                if plugin_class is None:
+                    continue
+
+                plugin_name = self._upsert_plugin_meta(
+                    plugin_class,
+                    module_path=f"file://{abs_path}::{plugin_class.__name__}",
+                )
+                if plugin_name:
+                    discovered_plugins.add(plugin_name)
+            except Exception as e:
+                logger.error("[exploit_mgr] Error processing plugin file %s: %s", plugin_file, str(e))
+
+        return discovered_plugins
+
+    def _discover_entry_point_plugins(self) -> set[str]:
+        discovered_plugins: set[str] = set()
+        for entry_point in self._iter_entry_points("iotsploit.exploit_plugins"):
+            try:
+                plugin_class = entry_point.load()
+                if (
+                    not isinstance(plugin_class, type)
+                    or not issubclass(plugin_class, BasePlugin)
+                    or plugin_class is BasePlugin
+                ):
+                    logger.warning(
+                        "[exploit_mgr] Ignoring invalid exploit entry point %s -> %s",
+                        entry_point.name,
+                        entry_point.value,
+                    )
+                    continue
+
+                plugin_name = self._upsert_plugin_meta(
+                    plugin_class,
+                    module_path=f"{plugin_class.__module__}.{plugin_class.__name__}",
+                )
+                if plugin_name:
+                    discovered_plugins.add(plugin_name)
+            except Exception as e:
+                logger.error(
+                    "[exploit_mgr] Error loading exploit entry point %s: %s",
+                    entry_point.name,
+                    str(e),
+                )
+
+        return discovered_plugins
+
+    def auto_discover_plugins(self, plugins_dir: str | Path | None = None) -> None:
+        """
+        Automatically discover plugins from the legacy filesystem and packaged entry points.
+        Entry points run last so their dotted module paths take priority over legacy file paths.
+        """
+        if plugins_dir is None:
+            plugins_dir = self.plugins_dir
+        logger.debug("[exploit_mgr] Starting plugin auto-discovery in %s", plugins_dir)
+
+        discovered_plugins = set()
+
+        try:
+            discovered_plugins |= self._discover_filesystem_plugins(plugins_dir)
+            discovered_plugins |= self._discover_entry_point_plugins()
+
+            try:
+                disabled = self._plugin_repo.disable_missing(discovered_plugins)
+                if disabled:
+                    logger.debug("[exploit_mgr] Marked %d missing plugins as disabled", disabled)
+            except Exception as e:
+                logger.error("[exploit_mgr] Error disabling missing plugins: %s", str(e))
+
+            logger.debug("[exploit_mgr] Plugin auto-discovery completed")
+        except Exception as e:
+            logger.error("[exploit_mgr] Error during plugin discovery: %s", str(e))
+
+    def load_plugins(self):
+        """
+        Build registry from DB without importing modules. Instances load lazily on first use.
+        """
+        self.auto_discover_plugins(self.plugins_dir)
+        self.plugin_registry.clear()
+        self.plugins.clear()
+        for plugin_db in self._plugin_repo.list_enabled():
+            try:
+                module_path_field = plugin_db.module_path or ""
+                file_path = None
+                class_name = None
+
+                # Preferred: file path encoding "file://<abs_path>::<ClassName>"
+                if module_path_field.startswith("file://") and "::" in module_path_field:
+                    file_path = module_path_field[len("file://"):].split("::", 1)[0]
+                    class_name = module_path_field.split("::", 1)[1]
+                else:
+                    # Backward compatibility: dotted path "pkg.mod.Class"
+                    parts = module_path_field.rsplit('.', 1)
+                    if len(parts) == 2:
+                        # Try resolve to file by searching sys.modules/importlib; we still store it for fallback load
+                        file_path = module_path_field  # mark as dotted path
+                        class_name = parts[1]
+                    else:
+                        logger.warning(
+                            "[exploit_mgr] Invalid module path format for plugin %s: %s",
+                            plugin_db.name,
+                            module_path_field,
+                        )
+                        continue
+
+                self.plugin_registry[plugin_db.name] = {
+                    'file_or_module': file_path,
+                    'class_name': class_name,
+                }
+            except Exception as e:
+                logger.error("[exploit_mgr] Failed to index plugin %s: %s", plugin_db.name, str(e))
+
+    def load_plugin_groups(self) -> list[PluginGroupSpec]:
+        return self._group_repo.list_enabled_groups()
+
+    def initialize(self):
+        self.pm.hook.initialize()
+
+    def exploit(self):
+        self.pm.hook.execute()
+
+    def _load_plugin_instance(self, plugin_name: str) -> Optional[BasePlugin]:
+        """Load a plugin instance on demand using file-path import, then cache and register it."""
+        if plugin_name in self.plugins:
+            return self.plugins[plugin_name]
+
+        meta = self.plugin_registry.get(plugin_name)
+        if not meta:
+            logger.warning("[exploit_mgr] Plugin '%s' not found in registry or disabled.", plugin_name)
+            return None
+
+        file_or_module = meta.get('file_or_module')
+        class_name = meta.get('class_name')
+
+        try:
+            plugin_class = None
+            if file_or_module and os.path.isabs(file_or_module):
+                # File path import
+                temp_mod_name = f"exploit_runtime_{hash(file_or_module)}"
+                spec = importlib.util.spec_from_file_location(temp_mod_name, file_or_module)
+                if spec is None or spec.loader is None:
+                    raise ImportError(f"Failed to create spec for {file_or_module}")
+                module = importlib.util.module_from_spec(spec)
+                spec.loader.exec_module(module)
+                if hasattr(module, class_name):
+                    plugin_class = getattr(module, class_name)
+            else:
+                # Backward compatibility: dotted import
+                module_name = file_or_module.rsplit('.', 1)[0]
+                module = importlib.import_module(module_name)
+                if hasattr(module, class_name):
+                    plugin_class = getattr(module, class_name)
+
+            if not plugin_class or not issubclass(plugin_class, BasePlugin):
+                raise TypeError(f"Plugin class invalid or not a BasePlugin: {class_name}")
+
+            plugin_instance = plugin_class()
+            # Register to pluggy. Do NOT call initialize() here.
+            # Initialization (and backend injection) happens right before execution via _ensure_context_injected().
+            self.pm.register(plugin_instance)
+            self.plugins[plugin_name] = plugin_instance
+            logger.debug("[exploit_mgr] Lazily loaded and registered plugin: %s", plugin_name)
+            return plugin_instance
+        except Exception as e:
+            logger.error("[exploit_mgr] Failed to lazily load plugin %s: %s", plugin_name, str(e))
+            return None
+
+    async def execute_plugin_async(self, plugin_name, target=None, parameters=None):
+        """Execute a plugin asynchronously if it supports it, otherwise fall back to sync execution"""
+        plugin_instance = self._load_plugin_instance(plugin_name)
+        if not plugin_instance:
+            logger.warning("[exploit_mgr] Plugin '%s' not found or disabled.", plugin_name)
+            return None
+
+        # Normalize target for plugin boundary
+        target = self._normalize_target_for_plugin(target)
+        
+        # Inject backend context before execution
+        self._ensure_context_injected(plugin_instance)
+
+        # Check if plugin supports async execution
+        if hasattr(plugin_instance, 'execute_async'):
+            result = await plugin_instance.execute_async(target, parameters)
+        else:
+            # Fall back to synchronous execution
+            result = plugin_instance.execute(target, parameters)
+        
+        return result
+
+    def execute_plugin(self, plugin_name, target=None, parameters=None):
+        """
+        Execute a plugin with the given parameters.
+        """
+        return self._execute_plugin(plugin_name, target=target, parameters=parameters, force_async=None)
+
+    def _execute_plugin(self, plugin_name, target=None, parameters=None, *, force_async: bool | None = None):
+        plugin_instance = self._load_plugin_instance(plugin_name)
+        if not plugin_instance:
+            logger.warning("[exploit_mgr] Plugin '%s' not found or disabled.", plugin_name)
+            return None
+
+        try:
+            parameters = parameters or {}
+            # Normalize target for plugin boundary (dict snapshot preferred)
+            target = self._normalize_target_for_plugin(target)
+            
+            # Determine if we should execute asynchronously
+            if force_async is None:
+                should_execute_async = (
+                    hasattr(plugin_instance, 'execute_async') or  # Plugin supports async
+                    parameters.get('duration', 0) > 5 or          # Long running task
+                    parameters.get('stream', False) or            # Streaming data
+                    parameters.get('async', False)                # Explicitly requested async
+                )
+            else:
+                should_execute_async = bool(force_async)
+
+            if should_execute_async:
+                logger.info("[exploit_mgr] Starting async execution for plugin: %s", plugin_name)
+                
+                return self._task_runner.submit(
+                    plugin_name,
+                    target=target,
+                    parameters=parameters,
+                    context=None,
+                )
+            else:
+                # Execute synchronously
+                logger.info("[exploit_mgr] Executing plugin synchronously: %s", plugin_name)
+                
+                # Inject backend context before execution
+                self._ensure_context_injected(plugin_instance)
+                
+                result = plugin_instance.execute(target, parameters)
+                
+                # Format the result
+                if hasattr(result, 'success'):
+                    return {
+                        'success': result.success,
+                        'message': result.message if hasattr(result, 'message') else str(result),
+                        'data': result.data if hasattr(result, 'data') else None
+                    }
+                else:
+                    return {
+                        'message': str(result)
+                    }
+                
+        except Exception as e:
+            logger.error("[exploit_mgr] Error executing plugin %s: %s", plugin_name, str(e))
+            raise ValueError(f"Error executing plugin {plugin_name}: {str(e)}")
+
+    def execute_selected_plugins(self, plugin_names, target=None):
+        results = {}
+        for plugin_name in plugin_names:
+            try:
+                result = self.execute_plugin(plugin_name, target)
+                results[plugin_name] = result
+            except ValueError as e:
+                logger.warning("[exploit_mgr] Error executing plugin '%s': %s", plugin_name, str(e))
+        return results
+
+    def list_plugins(self):
+        """
+        Returns a list of all available plugins.
+        """
+        # Prefer registry keys to avoid forcing loads
+        return list(self.plugin_registry.keys())
+
+    def list_plugin_info(self):
+        logger.debug("[exploit_mgr] Starting to list plugin information")
+        plugin_info = {}
+        
+        # Use registry to avoid preloading all; load per plugin to get info
+        for plugin_name in self.plugin_registry.keys():
+            plugin_instance = self.plugins.get(plugin_name) or self._load_plugin_instance(plugin_name)
+            logger.debug("[exploit_mgr] Processing plugin: %s", plugin_name)
+            try:
+                if not plugin_instance:
+                    plugin_info[plugin_name] = {"error": "failed to load plugin"}
+                    continue
+                info = plugin_instance.get_info()
+                logger.debug("[exploit_mgr] Retrieved info for plugin %s: %s", plugin_name, info)
+                plugin_info[plugin_name] = info
+                
+            except Exception as e:
+                logger.error("[exploit_mgr] Error processing plugin %s: %s", plugin_name, str(e))
+                plugin_info[plugin_name] = {"error": str(e)}
+
+        logger.debug("[exploit_mgr] Completed listing plugin information. Total plugins: %d", len(plugin_info))
+        return plugin_info
+
+    def get_plugin(self, plugin_name: str) -> Optional[BasePlugin]:
+        """
+        Get a plugin instance by name.
+        
+        Args:
+            plugin_name (str): The name of the plugin to retrieve
+            
+        Returns:
+            Optional[BasePlugin]: The plugin instance if found, None otherwise
+        """
+        plugin_instance = self.plugins.get(plugin_name) or self._load_plugin_instance(plugin_name)
+        if not plugin_instance:
+            logger.warning("[exploit_mgr] Plugin '%s' not found or disabled.", plugin_name)
+            return None
+        return plugin_instance
+
+    def get_plugin_info(self, plugin_name: str) -> Optional[dict]:
+        """
+        Get plugin information by name.
+        
+        Args:
+            plugin_name (str): The name of the plugin to retrieve info for
+            
+        Returns:
+            Optional[dict]: The plugin info dictionary if found, None otherwise
+        """
+        plugin_instance = self.plugins.get(plugin_name) or self._load_plugin_instance(plugin_name)
+        if not plugin_instance:
+            logger.warning("[exploit_mgr] Plugin '%s' not found or disabled.", plugin_name)
+            return None
+        
+        try:
+            return plugin_instance.get_info()
+        except Exception as e:
+            logger.error("[exploit_mgr] Error getting info for plugin %s: %s", plugin_name, str(e))
+            return None
+
+    def execute_plugin_group(self, group_name, target=None, parameters=None, force_exec=True):
+        """
+        Execute the named plugin‑group *including* its nested groups and plugins.
+
+        The actual ordered execution and failure‑handling logic lives inside
+        PluginGroup.execute(), which honours:
+            • PluginSequence.sequence / ignore_fail
+            • PluginGroupTree.sequence / ignore_fail / force_exec
+        """
+        spec = self._group_repo.get_group(group_name)
+        if spec is None:
+            logger.error("[exploit_mgr] Plugin group '%s' does not exist", group_name)
+            return False
+
+        if not spec.enabled and not force_exec:
+            logger.warning("[exploit_mgr] Plugin group '%s' is disabled", group_name)
+            return False
+
+        logger.info("[exploit_mgr] Executing plugin group '%s'", group_name)
+        ok = self._execute_group_spec(spec, target=target, parameters=parameters, force_exec=force_exec, _stack=[])
+
+        if ok:
+            logger.info("[exploit_mgr] Plugin group '%s' executed successfully", group_name)
+        else:
+            logger.warning("[exploit_mgr] Plugin group '%s' finished with failures", group_name)
+        return ok
+
+    def _execute_group_spec(
+        self,
+        spec: PluginGroupSpec,
+        *,
+        target=None,
+        parameters=None,
+        force_exec: bool = True,
+        _stack: list[str],
+    ) -> bool:
+        if spec.name in _stack:
+            logger.error(
+                "[exploit_mgr] Detected cyclic PluginGroup reference: %s",
+                " -> ".join(_stack + [spec.name]),
+            )
+            return False
+
+        if not spec.enabled and not force_exec:
+            return True
+
+        overall_ok = True
+        stack2 = _stack + [spec.name]
+
+        # Merge and execute all steps in order.
+        steps: list[tuple[int, str, object]] = []
+        for s in spec.group_steps:
+            steps.append((s.sequence, "group", s))
+        for s in spec.plugin_steps:
+            steps.append((s.sequence, "plugin", s))
+        steps.sort(key=lambda t: t[0])
+
+        for _, kind, s in steps:
+            if kind == "group":
+                s = s  # type: ignore[assignment]
+                assert isinstance(s, GroupStepSpec)
+                child = self._group_repo.get_group(s.group_name)
+                if child is None:
+                    logger.error(
+                        "[exploit_mgr] Missing child PluginGroup '%s' referenced by '%s'",
+                        s.group_name,
+                        spec.name,
+                    )
+                    if not s.ignore_fail:
+                        return False
+                    overall_ok = False
+                    continue
+                ok = self._execute_group_spec(
+                    child,
+                    target=target,
+                    parameters=parameters,
+                    force_exec=s.force_exec,
+                    _stack=stack2,
+                )
+                if not ok:
+                    if not s.ignore_fail:
+                        return False
+                    overall_ok = False
+            else:
+                assert isinstance(s, PluginStepSpec)
+                try:
+                    result = self._execute_plugin(s.plugin_name, target=target, parameters=parameters, force_async=None)
+                    if isinstance(result, dict) and result.get("execution_type") == "async":
+                        ok = True
+                    elif isinstance(result, dict):
+                        ok = bool(result.get("success", True))
+                    else:
+                        ok = True if result is None else bool(result)
+                except Exception as e:
+                    logger.error("[exploit_mgr] Error executing plugin %s: %s", s.plugin_name, str(e))
+                    ok = False
+
+                if not ok:
+                    if not s.ignore_fail:
+                        return False
+                    overall_ok = False
+
+        return overall_ok
+
+    def cleanup_all_plugins(self):
+        """
+        Cleanup all registered plugins. This method is called automatically on program exit
+        and can also be called manually when needed.
+        """
+        logger.debug("[exploit_mgr] Starting cleanup of all plugins")
+        try:
+            # Guard: if __init__ failed part-way, destructor may still run.
+            if not hasattr(self, "pm"):
+                return
+            # Log registered plugins before cleanup using class names instead of name attribute
+            registered_plugins = [p.__class__.__name__ for p in self.pm.get_plugins()]
+            logger.debug("[exploit_mgr] Registered plugins for cleanup: %s", registered_plugins)
+            
+            # Call cleanup hook on all registered plugins
+            self.pm.hook.cleanup()
+            
+            # Clear plugin references
+            if hasattr(self, "plugins"):
+                self.plugins.clear()
+            logger.debug("[exploit_mgr] Successfully cleaned up all plugins")
+        except Exception as e:
+            logger.error("[exploit_mgr] Error during plugin cleanup: %s", str(e))
+
+    def __del__(self):
+        """
+        Destructor to ensure cleanup is called when the manager is destroyed
+        """
+        try:
+            # Avoid noisy errors during interpreter shutdown / partial init.
+            if hasattr(self, "pm"):
+                self.cleanup_all_plugins()
+        except Exception as e:
+            logger.error("[exploit_mgr] Error during ExploitPluginManager cleanup: %s", str(e))
+
+    def reload_plugin(self, plugin_name):
+        """
+        Reload a plugin after its code has been modified.
+        
+        Args:
+            plugin_name (str): The name of the plugin to reload
+            
+        Returns:
+            bool: True if the plugin was successfully reloaded, False otherwise
+        """
+        try:
+            # Refresh registry from repo (also re-discovers plugins on disk)
+            self.load_plugins()
+            meta = self.plugin_registry.get(plugin_name)
+            if not meta:
+                logger.error("[exploit_mgr] Plugin %s not found in registry", plugin_name)
+                return False
+
+            file_or_module = meta.get("file_or_module")
+            class_name = meta.get("class_name")
+
+            # Reload the module
+            try:
+                # First, unregister the existing plugin
+                if plugin_name in self.plugins:
+                    try:
+                        # best-effort cleanup
+                        old_inst = self.plugins[plugin_name]
+                        if hasattr(old_inst, 'cleanup'):
+                            old_inst.cleanup()
+                    except Exception:
+                        pass
+                    self.pm.unregister(self.plugins[plugin_name])
+                    del self.plugins[plugin_name]
+                
+                # Reload via file-path or dotted import
+                plugin_class = None
+                if file_or_module and os.path.isabs(file_or_module):
+                    temp_mod_name = f"exploit_runtime_{hash(file_or_module)}"
+                    spec = importlib.util.spec_from_file_location(temp_mod_name, file_or_module)
+                    if spec is None or spec.loader is None:
+                        raise ImportError(f"Failed to create spec for {file_or_module}")
+                    module = importlib.util.module_from_spec(spec)
+                    importlib.invalidate_caches()
+                    spec.loader.exec_module(module)
+                    plugin_class = getattr(module, class_name)
+                else:
+                    module_name = file_or_module.rsplit(".", 1)[0]
+                    module = importlib.import_module(module_name)
+                    importlib.reload(module)
+                    plugin_class = getattr(module, class_name)
+
+                plugin_instance = plugin_class()  # type: ignore[operator]
+                self.pm.register(plugin_instance)
+                # Do NOT call initialize() here.
+                # Initialization (and backend injection) happens right before execution via _ensure_context_injected().
+                self.plugins[plugin_name] = plugin_instance
+                
+                logger.debug("[exploit_mgr] Successfully reloaded plugin: %s", plugin_name)
+                return True
+            except Exception as e:
+                logger.error("[exploit_mgr] Error reloading plugin %s: %s", plugin_name, str(e))
+                return False
+        except Exception as e:
+            logger.error("[exploit_mgr] Error in reload_plugin: %s", str(e))
+            return False