Skip loading external modules with unsupported runtimes

Author: adfoster-r7

lib/msf/core/module_manager/cache.rb

@@ -74,14 +74,15 @@ def cache_in_memory(class_or_module, options={})
   # @return [false] if a module with the given type and reference name does not exist in the cache.
   # @return (see Msf::Modules::Loader::Base#load_module)
   def load_cached_module(type, reference_name, cache_type: Msf::ModuleManager::Cache::MEMORY)
+    cached_metadata = nil
+
     case cache_type
     when Msf::ModuleManager::Cache::FILESYSTEM
       cached_metadata = Msf::Modules::Metadata::Cache.instance.get_module_reference(type: type, reference_name: reference_name)
       return false unless cached_metadata
 
       parent_path = get_parent_path(cached_metadata.path, type)
     when Msf::ModuleManager::Cache::MEMORY
-      cached_metadata = nil
       module_info = self.module_info_by_path.values.find { |inner_info|
         inner_info[:type] == type and inner_info[:reference_name] == reference_name
       }
@@ -92,16 +93,21 @@ def load_cached_module(type, reference_name, cache_type: Msf::ModuleManager::Cac
       raise ArgumentError, "#{cache_type} is not a valid cache type."
     end
 
-    try_load_module(parent_path, reference_name, type, cached_metadata: cached_metadata)
+    try_load_module(parent_path, type, reference_name, cached_metadata: cached_metadata)
   end
 
-  def try_load_module(parent_path, reference_name, type, cached_metadata: nil)
+  # @param [String] parent_path Root directory to load modules from
+  # @param [String] reference_name THe module reference name, without the type prefix
+  # @param [String] type Such as auxiliary, exploit, etc
+  # @param [nil,Msf::Modules::Metadata::Obj] cached_metadata
+  # @return [Boolean] True if loaded, false otherwise
+  def try_load_module(parent_path, type, reference_name, cached_metadata: nil)
     loaded = false
     # XXX borked
     loaders.each do |loader|
-      next unless cached_metadata || loader.loadable_module?(parent_path, type, reference_name)
-
-      loaded = loader.load_module(parent_path, type, reference_name, force: true, cached_metadata: cached_metadata)
+      if loader.loadable_module?(parent_path, type, reference_name, cached_metadata: cached_metadata)
+        loaded = loader.load_module(parent_path, type, reference_name, force: true, cached_metadata: cached_metadata)
+      end
 
       break if loaded
     end

lib/msf/core/modules/loader/base.rb

@@ -472,9 +472,9 @@ def module_path(parent_path, type, module_reference_name)
   #                   the path is not hidden (starts with '.')
   # @return [false] otherwise
   def module_path?(path)
-    path.ends_with?(MODULE_EXTENSION) &&
+    path.end_with?(MODULE_EXTENSION) &&
       File.file?(path) &&
-      !path.starts_with?(".") &&
+      !path.start_with?(".") &&
       !path.match?(UNIT_TEST_REGEX) &&
       !script_path?(path)
   end

lib/msf/core/modules/loader/directory.rb

@@ -12,8 +12,13 @@ def loadable?(path)
     File.directory?(path)
   end
 
-  def loadable_module?(parent_path, type, module_reference_name)
-    full_path = module_path(parent_path, type, module_reference_name)
+  # @param [String] parent_path Root directory to load modules from
+  # @param [String] type Such as auxiliary, exploit, etc
+  # @param [String] module_reference_name The module reference name, without the type prefix
+  # @param [nil,Msf::Modules::Metadata::Obj] cached_metadata
+  # @return [Boolean] True this loader can load the module, false otherwise
+  def loadable_module?(parent_path, type, module_reference_name, cached_metadata: nil)
+    full_path = cached_metadata&.path || module_path(parent_path, type, module_reference_name)
     module_path?(full_path)
   end
 

lib/msf/core/modules/loader/executable.rb

@@ -11,13 +11,39 @@ def loadable?(path)
     File.directory?(path)
   end
 
-  def loadable_module?(parent_path, type, module_reference_name)
-    full_path = module_path(parent_path, type, module_reference_name)
+  # @param [String] parent_path Root directory to load modules from
+  # @param [String] type Such as auxiliary, exploit, etc
+  # @param [String] module_reference_name The module reference name, without the type prefix
+  # @param [nil,Msf::Modules::Metadata::Obj] cached_metadata
+  # @return [Boolean] True this loader can load the module, false otherwise
+  def loadable_module?(parent_path, type, module_reference_name, cached_metadata: nil)
+    full_path = cached_metadata&.path || module_path(parent_path, type, module_reference_name)
     script_path?(full_path)
   end
 
   protected
 
+  def read_script_env_runtime(full_path)
+    # Extract the runtime from the first line of the script, i.e.
+    #   #!/usr/bin/env python
+    #   //usr/bin/env go run "$0" "$@"; exit "$?"
+    first_line = File.open(full_path, 'rb') { |f| f.gets }
+    first_line.to_s[%r{\A(?:#!|/)/usr/bin/env\s+(\w+)}, 1]
+  end
+
+  # @param [String] full_path The full path to the module file.
+  # @return [Boolean] True if the script's required runtime is available on the host, false otherwise
+  def script_runtime_available?(full_path)
+    return false unless script_path?(full_path)
+
+    # Modules currently use /usr/bin/env - in the future absolute paths may need to be supported
+    script_runtime = read_script_env_runtime(full_path)
+    return !!Rex::FileUtils.find_full_path(script_runtime) if script_runtime
+
+    # If the script runtime isn't known, we assume the script is executable
+    true
+  end
+
   # Yields the module_reference_name for each module file found under the directory path.
   #
   # @param [String] path The path to the directory.
@@ -90,10 +116,15 @@ def read_module_content(parent_path, type, module_reference_name)
   # @param (see Msf::Modules::Loader::Base#read_module_content_from_path)
   # @return (see Msf::Modules::Loader::Base#read_module_content_from_path)
   def read_module_content_from_path(full_path)
-    unless File.executable?(full_path)
+    unless script_path?(full_path)
       load_error(full_path, Errno::ENOENT.new)
       return ''
     end
+    unless script_runtime_available?(full_path)
+      load_error(full_path, RuntimeError.new("Unable to load module as the following runtime was not found on the path: #{read_script_env_runtime(full_path)}"))
+      return ''
+    end
+
     begin
       content = Msf::Modules::External::Shim.generate(full_path, @module_manager.framework)
       if content