Help detect missing plugin dependencies.

Author: fuzyll

binaryninjacore.h

@@ -3280,6 +3280,34 @@ extern "C"
 		ScriptExecutionCancelled
 	};
 
+	BN_ENUM(uint8_t, BNPluginDependencyDecision)
+	{
+		PluginDependencyReinstall,
+		PluginDependencyDisable,
+		PluginDependencyLoadAnyway
+	};
+
+	typedef struct BNPluginDependencyIssue
+	{
+		const char* repository;
+		const char* name;
+		const char* path;
+		const char* dependencies;
+	} BNPluginDependencyIssue;
+
+	typedef struct BNPluginDependencyStartupCallbacks
+	{
+		void* context;
+		bool (*checkDependencies)(void* ctxt, const BNPluginDependencyIssue* issues, size_t count,
+			BNPluginDependencyDecision* decisions);
+	} BNPluginDependencyStartupCallbacks;
+
+	typedef struct BNScriptingProviderModuleInstalledCallbacks
+	{
+		void* context;
+		bool (*moduleInstalled)(void* ctxt, const char* modules);
+	} BNScriptingProviderModuleInstalledCallbacks;
+
 
 	typedef struct BNScriptingInstanceCallbacks
 	{
@@ -8127,6 +8155,10 @@ extern "C"
 	BINARYNINJACOREAPI bool BNLoadScriptingProviderModule(
 	    BNScriptingProvider* provider, const char* repository, const char* module, bool force);
 	BINARYNINJACOREAPI bool BNInstallScriptingProviderModules(BNScriptingProvider* provider, const char* modules);
+	BINARYNINJACOREAPI bool BNIsScriptingProviderModuleInstalled(BNScriptingProvider* provider, const char* modules);
+	BINARYNINJACOREAPI void BNSetScriptingProviderModuleInstalledCallback(BNScriptingProvider* provider,
+	    BNScriptingProviderModuleInstalledCallbacks* callbacks);
+	BINARYNINJACOREAPI void BNSetPluginDependencyStartupCallback(BNPluginDependencyStartupCallbacks* callbacks);
 
 	BINARYNINJACOREAPI BNScriptingInstance* BNInitScriptingInstance(
 	    BNScriptingProvider* provider, BNScriptingInstanceCallbacks* callbacks);

python/requirementcheck.py

@@ -0,0 +1,68 @@
+# Copyright (c) 2015-2026 Vector 35 Inc
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to
+# deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+# sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+
+
+import json
+from typing import Dict, Iterable, List, Optional
+
+
+def pip_requirements_from_dependency_metadata(dependencies: bytes) -> List[str]:
+	raw_text = dependencies.decode("utf-8")
+	try:
+        # Dependencies might be specified in JSON format, which we need to translate to text.
+		dependencies_json = json.loads(raw_text)
+		dependency_text = dependencies_json.get("pip", "")
+	except json.JSONDecodeError:
+		# If we can't parse input as JSON, it's probably already in text format.
+		dependency_text = raw_text
+	return [line.split('#', 1)[0].strip() for line in dependency_text.split('\n') if line.split('#', 1)[0].strip()]
+
+
+def pip_requirements_satisfied(requirements: Iterable[str], installed_versions: Optional[Dict[str, str]] = None) -> bool:
+	try:
+		from importlib import metadata as importlib_metadata
+		from packaging.requirements import Requirement
+		from packaging.utils import canonicalize_name
+	except Exception:
+		from importlib import metadata as importlib_metadata
+		from pip._vendor.packaging.requirements import Requirement
+		from pip._vendor.packaging.utils import canonicalize_name
+
+	if installed_versions is None:
+		installed_versions = {}
+		for dist in importlib_metadata.distributions():
+			name = dist.metadata.get("Name")
+			if name:
+				installed_versions[canonicalize_name(name)] = dist.version
+	else:
+		installed_versions = {canonicalize_name(name): version for name, version in installed_versions.items()}
+
+	for requirement_text in requirements:
+		requirement = Requirement(requirement_text)
+		if requirement.marker is not None and not requirement.marker.evaluate():
+			continue
+
+		version = installed_versions.get(canonicalize_name(requirement.name))
+		if version is None:
+			return False
+		if requirement.specifier and not requirement.specifier.contains(version, prereleases=True):
+			return False
+
+	return True

python/scriptingprovider.py

@@ -50,6 +50,7 @@
 from . import function
 from . import log
 from .pluginmanager import RepositoryManager
+from .requirementcheck import pip_requirements_from_dependency_metadata, pip_requirements_satisfied
 from .enums import ScriptingProviderExecuteResult, ScriptingProviderInputReadyState
 from .settings import Settings
 from .enums import SettingsScope
@@ -476,8 +477,11 @@ def register(self) -> None:
 		self._cb.createInstance = self._cb.createInstance.__class__(self._create_instance)
 		self._cb.loadModule = self._cb.loadModule.__class__(self._load_module)
 		self._cb.installModules = self._cb.installModules.__class__(self._install_modules)
-		self._cb.moduleInstalled = self._cb.installModules.__class__(self._module_installed)
 		self.handle = core.BNRegisterScriptingProvider(self.__class__.name, self.__class__.apiName, self._cb)
+		self._module_installed_cb = core.BNScriptingProviderModuleInstalledCallbacks()
+		self._module_installed_cb.context = None
+		self._module_installed_cb.moduleInstalled = self._module_installed_cb.moduleInstalled.__class__(self._module_installed)
+		core.BNSetScriptingProviderModuleInstalledCallback(self.handle, self._module_installed_cb)
 		self.__class__._registered_providers.append(self)
 
 	def _create_instance(self, ctxt):
@@ -505,7 +509,7 @@ def _load_module(self, ctx, repo_path: bytes, plugin_path: bytes, force: bool) -
 	def _install_modules(self, ctx, modules: bytes) -> bool:
 		return False
 
-	def _module_installed(self, ctx, module: str) -> bool:
+	def _module_installed(self, ctx, modules: bytes) -> bool:
 		return False
 
 
@@ -1291,12 +1295,7 @@ def _get_python_environment(self, using_bundled_python: bool=False) -> Optional[
 
 	def _install_modules(self, ctx, _modules: bytes) -> bool:
 		# This callback should not be called directly
-		dependencies_json = json.loads(_modules.decode("utf-8"))
-		modules = ""
-		if "pip" in dependencies_json:
-			if len(dependencies_json["pip"].strip()) == 0:
-				return True
-			modules = [line.split('#', 1)[0].strip() for line in dependencies_json["pip"].split('\n') if line.split('#', 1)[0].strip()]
+		modules = pip_requirements_from_dependency_metadata(_modules)
 		if len(modules) == 0:
 			return True
 		python_lib = settings.Settings().get_string("python.interpreter")
@@ -1358,10 +1357,21 @@ def _install_modules(self, ctx, _modules: bytes) -> bool:
 			)
 		return status
 
-	def _module_installed(self, ctx, module: str) -> bool:
-		if self._python_bin is None:
+	def _module_installed(self, ctx, _modules: bytes) -> bool:
+		try:
+			modules = pip_requirements_from_dependency_metadata(_modules)
+		except Exception:
+			logger.log_error_for_exception("Failed to parse plugin dependency metadata")
+			return False
+
+		if len(modules) == 0:
+			return True
+
+		try:
+			return pip_requirements_satisfied(modules)
+		except Exception:
+			logger.log_error_for_exception("Failed to check plugin dependency requirements")
 			return False
-		return re.split('>|=|,', module.strip(), 1)[0] in self._satisfied_dependencies(self._python_bin)
 
 	@classmethod
 	def register_magic_variable(