Class Msf::Module
In: lib/msf/core/module.rb
Parent: Object

The module base class is responsible for providing the common interface that is used to interact with modules at the most basic levels, such as by inspecting a given module‘s attributes (name, dsecription, version, authors, etc) and by managing the module‘s data store.

Methods

alias   arch?   arch_to_s   author_to_s   auxiliary?   comm   compat   compatible?   debugging?   deregister_options   derived_implementor?   description   each_arch   each_author   encoder?   exploit?   file_path   framework   fullname   fullname   import_defaults   init_compat   is_usable   merge_check_key   merge_info   merge_info_advanced_options   merge_info_alias   merge_info_description   merge_info_evasion_options   merge_info_name   merge_info_options   merge_info_string   merge_info_version   name   new   nop?   orig_cls   payload?   platform?   platform_to_s   privileged?   rank   rank   rank_to_s   refname   register_advanced_options   register_evasion_options   register_options   set_defaults   share_datastore   shortname   shortname   type   type   update_info   validate   version  

Included Modules

Rex::Ui::Subscriber Framework::Offspring

Constants

UpdateableOptions = [ "Name", "Description", "Alias" ]   The list of options that support merging in an information hash.

Attributes

arch  [R]  The array of zero or more architectures.
author  [R]  The array of zero or more authors.
datastore  [R]  The module-specific datastore instance.
file_path  [RW]  The path from which the module was loaded.
job_id  [RW]  The job identifier that this module is running as, if any.
license  [R]  The license under which this module is provided.
options  [R]  The module-specific options.
orig_cls  [RW]  This attribute holds the non-duplicated copy of the module implementation. This attribute is used for reloading purposes so that it can be re-duplicated.
platform  [R]  The array of zero or more platforms.
privileged  [R]  Whether or not this module requires privileged access.
references  [R]  The reference count for the module.
refname  [RW]  The module‘s name that is assigned it it by the framework or derived from the path that the module is loaded from.

Public Class methods

is_usable()

This method allows modules to tell the framework if they are usable on the system that they are being loaded on in a generic fashion. By default, all modules are indicated as being usable. An example of where this is useful is if the module depends on something external to ruby, such as a binary.

new(info = {})

Creates an instance of an abstract module using the supplied information hash.

rank()

Returns this module‘s ranking.

rank_to_s()

Returns this module‘s ranking as a string representation.

type()

Class method to figure out what type of module this is

Public Instance methods

alias()

Returns the module‘s alias, if it has one. Otherwise, the module‘s name is returned.

arch?(what)

Return whether or not the module supports the supplied architecture.

arch_to_s()

Return a comma separated list of supported architectures, if any.

author_to_s()

Return a comma separated list of author for this module.

auxiliary?()

Returns true if this module is an auxiliary module.

comm()

The default communication subsystem for this module. We may need to move this somewhere else.

compat()

Returns the hash that describes this module‘s compatibilities.

compatible?(mod)

Returns whether or not this module is compatible with the supplied module.

debugging?()

Returns true if this module is being debugged. The debug flag is set by setting datastore[‘DEBUG’] to 1|true|yes

description()

Return the module‘s description.

each_arch(&block)

Enumerate each architecture.

each_author(&block)

Enumerate each author.

encoder?()

Returns true if this module is an encoder module.

exploit?()

Returns true if this module is an exploit module.

file_path()

The path to the file in which the module can be loaded from.

framework()

Returns the class reference to the framework

fullname()

Returns the module‘s framework full reference name. This is the short name that end-users work with (refname) plus the type of module prepended. Ex:

payloads/windows/shell/reverse_tcp

import_defaults(clear_datastore = true)

Imports default options into the module‘s datastore, optionally clearing all of the values currently set in the datastore.

name()

Return the module‘s name from the module information hash.

nop?()

Returns true if this module is a nop module.

orig_cls()

Returns the unduplicated class associated with this module.

payload?()

Returns true if this module is a payload module.

platform?(what)

Checks to see if this module is compatible with the supplied platform

platform_to_s()

Return a comma separated list of supported platforms, if any.

privileged?()

Returns whether or not the module requires or grants high privileges.

rank()

Returns the module‘s rank.

refname()

Returns the module‘s framework reference name. This is the short name that end-users work with. Ex:

windows/shell/reverse_tcp

share_datastore(ds)

Overrides the class’ own datastore with the one supplied. This is used to allow modules to share datastores, such as a payload sharing an exploit module‘s datastore.

shortname()

Returns the module‘s framework short name. This is a possibly conflicting name used for things like console prompts.

reverse_tcp

type()

Return the module‘s abstract type.

validate()

This method ensures that the options associated with this module all have valid values according to each required option in the option container.

version()

Return the module‘s version information.

Protected Instance methods

deregister_options(*names)

Removes the supplied options from the module‘s option container and data store.

derived_implementor?(parent, method_name)

Checks to see if a derived instance of a given module implements a method beyond the one that is provided by a base class. This is a pretty lame way of doing it, but I couldn‘t find a better one, so meh.

init_compat()

This method initializes the module‘s compatibility hashes by normalizing them into one single hash. As it stands, modules can define compatibility in their supplied info hash through: 

  Compat        - direct compat definitions
  PayloadCompat - payload compatibilities
  EncoderCompat - encoder compatibilities
  NopCompat     - nop compatibilities

In the end, the module specific compatibilities are merged as sub-hashes of the primary Compat hash key to make checks more uniform.

merge_check_key(info, name, val)

Checks and merges the supplied key/value pair in the supplied hash.

merge_info(info, opts)

Merges options in the info hash in a sane fashion, as some options require special attention.

merge_info_alias(info, val)

Merge aliases with an underscore delimiter.

merge_info_string(info, key, val, delim = ', ', inverse = false)

Merges a given key in the info hash with a delimiter.

register_advanced_options(options, owner = self.class)

Register advanced options with a specific owning class.

register_evasion_options(options, owner = self.class)

Register evasion options with a specific owning class.

register_options(options, owner = self.class)

Register options with a specific owning class.

set_defaults()

Sets the modules unsupplied info fields to their default values.

update_info(info, opts)

Updates information in the supplied info hash and merges other information. This method is used to override things like Name, Version, and Description without losing the ability to merge architectures, platforms, and options.

[Validate]