Class: Msf::ModuleManager

Inherits:
Object
  • Object
show all
Includes:
Enumerable, Framework::Offspring, Cache, Loading, ModulePaths, ModuleSets, Reloading
Defined in:
lib/msf/core/module_manager.rb

Overview

TODO:

add unload support

Upper management decided to throw in some middle management because the modules were getting out of hand. This bad boy takes care of the work of managing the interaction with modules in terms of loading and instantiation.

Defined Under Namespace

Modules: Cache, Loading, ModulePaths, ModuleSets, Reloading

Constant Summary collapse

TYPE_BY_DIRECTORY =

Maps module type directory to its module type.

Msf::Modules::Loader::Base::DIRECTORY_BY_TYPE.invert

Constants included from Loading

Loading::LOADER_CLASSES

Instance Attribute Summary collapse

Attributes included from ModuleSets

#enablement_by_type, #module_set_by_type

Attributes included from ModulePaths

#module_paths

Attributes included from Loading

#module_load_error_by_path, #module_load_warnings

Attributes included from Cache

#module_info_by_path

Attributes included from Framework::Offspring

#framework

Instance Method Summary collapse

Methods included from Reloading

#reload_module, #reload_modules

Methods included from ModuleSets

#auxiliary, #encoders, #evasion, #exploits, #init_module_set, #module_names, #module_set, #module_types, #nops, #payloads, #post, #type_enabled?

Methods included from ModulePaths

#add_module_path, #remove_module_path

Methods included from Loading

#file_changed?, #load_modules, #loaders, #on_module_load

Methods included from Cache

#cache_empty?, #cache_in_memory, #load_cached_module, #module_info_by_path_from_database!, #refresh_cache_from_database, #refresh_cache_from_module_files

Constructor Details

#initialize(framework, types = Msf::MODULE_TYPES) ⇒ ModuleManager

Returns a new instance of ModuleManager.

Parameters:

  • framework (Msf::Framework)

    The framework for which this instance is managing the modules.

  • types (Array<String>) (defaults to: Msf::MODULE_TYPES)

    List of module types to load. Defaults to all module types in Msf::MODULE_TYPES.


130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
# File 'lib/msf/core/module_manager.rb', line 130

def initialize(framework, types=Msf::MODULE_TYPES)
  #
  # defaults
  #

  self.module_info_by_path = {}
  self.enablement_by_type = {}
  self.module_load_error_by_path = {}
  self.module_load_warnings = {}
  self.module_paths = []
  self.module_set_by_type = {}
  self.aliases = {}
  self.inv_aliases = self.aliases.invert

  #
  # from arguments
  #

  self.framework = framework

  types.each { |type|
    init_module_set(type)
  }
end

Instance Attribute Details

#aliasesObject (protected)

Returns the value of attribute aliases


157
158
159
# File 'lib/msf/core/module_manager.rb', line 157

def aliases
  @aliases
end

#inv_aliasesObject (protected)

Returns the value of attribute inv_aliases


157
158
159
# File 'lib/msf/core/module_manager.rb', line 157

def inv_aliases
  @inv_aliases
end

Instance Method Details

#[](key) ⇒ Object


47
48
49
50
51
52
53
54
55
56
57
# File 'lib/msf/core/module_manager.rb', line 47

def [](key)
  names = key.split("/")
  type = names.shift

  module_set = module_set_by_type[type]

  return unless module_set

  module_reference_name = names.join("/")
  module_set[module_reference_name]
end

#auto_subscribe_module(klass) ⇒ void (protected)

This method returns an undefined value.

This method automatically subscribes a module to whatever event providers it wishes to monitor. This can be used to allow modules to automatically execute or perform other tasks when certain events occur. For instance, when a new host is detected, other auxiliary modules may wish to run such that they can collect more information about the host that was detected.

Parameters:


168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
# File 'lib/msf/core/module_manager.rb', line 168

def auto_subscribe_module(klass)

  # If auto-subscription is enabled (which it is by default), figure out
  # if it subscribes to any particular interfaces.
  inst = nil

  #
  # Exploit event subscriber check
  #
  if (klass.include?(Msf::ExploitEvent) == true)
    framework.events.add_exploit_subscriber((inst) ? inst : (inst = klass.new))
  end

  #
  # Session event subscriber check
  #
  if (klass.include?(Msf::SessionEvent) == true)
    framework.events.add_session_subscriber((inst) ? inst : (inst = klass.new))
  end
end

#create(name, aliased_as: nil) ⇒ Msf::Module?

Creates a module instance using the supplied reference name.

Parameters:

  • name (String)

    A module reference name. It may optionally be prefixed with a "<type>/", in which case the module will be created from the Msf::ModuleSet for the given <type>. Otherwise, we step through all sets until we find one that matches.

Returns:

  • (Msf::Module, nil)

    Instance of the named module or nil if it could not be created.


67
68
69
70
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
106
107
108
109
110
111
112
# File 'lib/msf/core/module_manager.rb', line 67

def create(name, aliased_as: nil)
  # First, a direct alias check
  return create(self.aliases[name], aliased_as: name) if self.aliases[name]

  # Check to see if it has a module type prefix.  If it does,
  # try to load it from the specific module set for that type.
  names = name.split("/")
  potential_type_or_directory = names.first

  # if first name is a type
  if Msf::Modules::Loader::Base::DIRECTORY_BY_TYPE.has_key? potential_type_or_directory
    type = potential_type_or_directory
  # if first name is a type directory
  else
    type = TYPE_BY_DIRECTORY[potential_type_or_directory]
  end

  module_instance = nil
  if type
    module_set = module_set_by_type[type]

    # First element in names is the type, so skip it
    module_reference_name = names[1 .. -1].join("/")
    module_instance = module_set.create(module_reference_name)
  else
    # Then we don't have a type, so we have to step through each set
    # to see if we can create this module.
    module_set_by_type.each do |type, set|
      if aliased = self.aliases["#{type}/#{name}"]
        module_instance = create(aliased, aliased_as: "#{type}/#{name}")
      else
        module_reference_name = names.join("/")
        module_instance = set.create(module_reference_name)
      end
      break if module_instance
    end
  end

  if module_instance
    # If the module instance is populated by one of the recursive `create`
    # calls this field may be set and we'll want to keep its original value
    module_instance.aliased_as ||= aliased_as
  end

  module_instance
end

#each {|name, mod_class| ... } ⇒ Object

Iterate over all modules in all sets

Yield Parameters:

  • name (String)

    The module's reference name

  • mod_class (Msf::Module)

    A module class


119
120
121
122
123
124
125
# File 'lib/msf/core/module_manager.rb', line 119

def each
  module_set_by_type.each do |type, set|
    set.each do |name, mod_class|
      yield name, mod_class
    end
  end
end