Module: Msf::ModuleManager::Loading

Extended by:
ActiveSupport::Concern
Included in:
Msf::ModuleManager
Defined in:
lib/msf/core/module_manager/loading.rb

Overview

Deals with loading modules for the Msf::ModuleManager

Constant Summary collapse

LOADER_CLASSES =

Classes that can be used to load modules.

[
    Msf::Modules::Loader::Directory,
    Msf::Modules::Loader::Executable # TODO: XXX: When this is the first loader we can load normal exploits, but not payloads
]

Instance Attribute Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#module_load_error_by_pathObject

Returns the value of attribute module_load_error_by_path


55
56
57
# File 'lib/msf/core/module_manager/loading.rb', line 55

def module_load_error_by_path
  @module_load_error_by_path
end

#module_load_warningsObject

Returns the value of attribute module_load_warnings


55
56
57
# File 'lib/msf/core/module_manager/loading.rb', line 55

def module_load_warnings
  @module_load_warnings
end

Instance Method Details

#file_changed?(path) ⇒ Boolean

Returns:

  • (Boolean)

27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
# File 'lib/msf/core/module_manager/loading.rb', line 27

def file_changed?(path)
  changed = false

  module_info = self.module_info_by_path[path]

  # if uncached then it counts as changed
  # Payloads can't be cached due to stage/stager matching
  if module_info.nil? or module_info[:type] == Msf::MODULE_PAYLOAD
    changed = true
  else
    begin
      current_modification_time = ::File.mtime(path).to_i
    rescue ::Errno::ENOENT
      # if the file does not exist now, that's a change
      changed = true
    else
      cached_modification_time = module_info[:modification_time].to_i

      # if the file's modification time's different from the cache, then it's changed
      if current_modification_time != cached_modification_time
        changed = true
      end
    end
  end

  changed
end

#load_modules(path, options = {}) ⇒ Hash{String => Integer} (protected)

Load all of the modules from the supplied directory or archive

Parameters:

  • path (String)

    Path to a directory

  • options (Hash) (defaults to: {})

Options Hash (options):

  • :force (Boolean)

    Whether the force loading the modules even if they are unchanged and already loaded.

  • :modules (Array)

    An array of regex patterns to search for specific modules

Returns:

  • (Hash{String => Integer})

    Maps module type to number of modules loaded


128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
# File 'lib/msf/core/module_manager/loading.rb', line 128

def load_modules(path, options={})
  options.assert_valid_keys(:force, :whitelist)

  count_by_type = {}

  loaders.each do |loader|
    if loader.loadable?(path)
      count_by_type.merge!(loader.load_modules(path, options)) do |key, prev, now|
        prev + now
      end
    end
  end

  count_by_type
end

#loadersObject (protected)

Return list of LOADER_CLASSES instances that load modules into this module manager


110
111
112
113
114
115
116
117
118
# File 'lib/msf/core/module_manager/loading.rb', line 110

def loaders
  unless instance_variable_defined? :@loaders
    @loaders = LOADER_CLASSES.collect { |klass|
      klass.new(self)
    }
  end

  @loaders
end

#on_module_load(class_or_module, type, reference_name, info = {}) ⇒ void

This method returns an undefined value.

Called when a module is initially loaded such that it can be categorized accordingly.

Parameters:

  • class_or_module (Class<Msf::Module>, ::Module)

    either a module Class or a payload Module.

  • type (String)

    The module type.

  • reference_name

    The module reference name.

  • info (Hash{String => Array}) (defaults to: {})

    additional information about the module

Options Hash (info):

  • 'files' (Array<String>)

    List of paths to the ruby source files where class_or_module is defined.

  • 'paths' (Array<String>)

    List of module reference names.

  • 'type' (String)

    The module type, should match positional type argument.


71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
# File 'lib/msf/core/module_manager/loading.rb', line 71

def on_module_load(class_or_module, type, reference_name, info={})
  module_set = module_set_by_type[type]
  module_set.add_module(class_or_module, reference_name, info)

  path = info['files'].first
  cache_in_memory(
      class_or_module,
      :path => path,
      :reference_name => reference_name,
      :type => type
  )

  # Automatically subscribe a wrapper around this module to the necessary
  # event providers based on whatever events it wishes to receive.
  auto_subscribe_module(class_or_module)

  # Notify the framework that a module was loaded
  framework.events.on_module_load(reference_name, class_or_module)

  # Clear and add aliases, if any (payloads cannot)

  if class_or_module.respond_to?(:realname) && aliased_as = self.inv_aliases[class_or_module.realname]
    aliased_as.each do |a|
      self.aliases.delete a
    end
    self.inv_aliases.delete class_or_module.realname
  end

  if class_or_module.respond_to? :aliases
    class_or_module.aliases.each do |a|
      self.aliases[a] = class_or_module.realname
    end
    self.inv_aliases[class_or_module.realname] = class_or_module.aliases unless class_or_module.aliases.empty?
  end
end