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

Attributes included from Loading

#module_load_error_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, #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?, #on_module_load

Methods included from Cache

#cache_empty?, #cache_in_memory, #load_cached_module, #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.


116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
 
# File 'lib/msf/core/module_manager.rb', line 116

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_paths = []
  self.module_set_by_type = {}

  #
  # from arguments
  #

  self.framework = framework

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

Instance Method Details

#[](key) ⇒ Object 


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

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

  module_set = module_set_by_type[type]

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

#create(name) ⇒ 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.


66
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
 
# File 'lib/msf/core/module_manager.rb', line 66

def create(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 |_, set|
      module_reference_name = names.join("/")
      module_instance = set.create(module_reference_name)
      break if module_instance
    end
  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


105
106
107
108
109
110
111
 
# File 'lib/msf/core/module_manager.rb', line 105

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