metasploit-model 0.24.1.pre.semantic.pre.versioning.pre.2.pre.0

data/spec/dummy/app/models/dummy/email_address.rb

@@ -0,0 +1,27 @@
+# Implementation of {Metasploit::Model::EmailAddress} to allow testing of {Metasploit::Model::EmailAddress} using an in-memory
+# ActiveModel and use of factories.
+class Dummy::EmailAddress < Metasploit::Model::Base
+  include Metasploit::Model::EmailAddress
+
+  #
+  # Attributes
+  #
+
+  # @!attribute [rw] domain
+  #   The domain part of the email address after the `'@'`.
+  #
+  #   @return [String]
+  attr_accessor :domain
+
+  # @!attribute [rw] full
+  #   The full email address.
+  #
+  #   @return [String] <{#local}>@<{#domain}
+  attr_accessor :full
+
+  # @!attribute [rw] local
+  #   The local part of the email address before the `'@'`.
+  #
+  #   @return [String]
+  attr_accessor :local
+end

data/spec/dummy/app/models/dummy/module/action.rb

@@ -0,0 +1,25 @@
+# Implementation of {Metasploit::Model::Module::Action} to allow testing of {Metasploit::Model::Module::Action}
+# using an in-memory ActiveModel and use of factories.
+class Dummy::Module::Action < Metasploit::Model::Base
+  include Metasploit::Model::Module::Action
+
+  #
+  # Associations
+  #
+
+  # @!attribute [rw] module_instance
+  #   Module that has this action.
+  #
+  #   @return [Dummy::Module::Instance]
+  attr_accessor :module_instance
+
+  #
+  # Attributes
+  #
+
+  # @!attribute [rw] name
+  #   The name of this action.
+  #
+  #   @return [String]
+  attr_accessor :name
+end

data/spec/dummy/app/models/dummy/module/ancestor.rb

@@ -0,0 +1,67 @@
+# Implementation of {Metasploit::Model::Module::Ancestor} to allow testing of {Metasploit::Model::Module::Ancestor}
+# using an in-memory ActiveModel and use of factories.
+class Dummy::Module::Ancestor < Metasploit::Model::Base
+  include Metasploit::Model::Module::Ancestor
+
+  #
+  # Attributes
+  #
+
+  # @!attribute [rw] full_name
+  #   Full name to module including {#module_type} and {#reference_name}
+  #
+  #   @return [String] <module_type>/<reference_name>
+  attr_accessor :full_name
+
+  # @!attribute [rw] handler_type
+  #   The handler type (in the case of singles) or (in the case of stagers) the handler type alias.  Handler type is
+  #   appended to the end of the single's or stage's {#reference_name} to get the
+  #   {Metasploit::Model::Module::Class#reference_name}.
+  #
+  #   @return [String] if {#handled?} is `true`.
+  #   @return [nil] if {#handled?} is `false`.
+  attr_accessor :handler_type
+
+  # @!attribute [rw] module_type
+  #   The type of module of this ancestor.
+  #
+  #   @return [String]
+  attr_accessor :module_type
+
+  # @!attribute [rw] parent_path
+  #   Module path on which this ancestor exists.
+  #
+  #   @return [Metasploit::Model::Module::Path]
+  attr_accessor :parent_path
+
+  # @!attribute [rw] payload_type
+  #   The type of payload module this ancestor is.
+  #
+  #   @return [String] if this is a payload module.
+  #   @return [nil] if this is not a payload module.
+  attr_accessor :payload_type
+
+  # @!attribute [rw] real_path
+  #   The real (absolute) path to this ancestor on-disk.
+  #
+  #   @return [String]
+  attr_accessor :real_path
+
+  # @!attribute [rw] real_path_modified_at
+  #   The modification time of {#real_path}.
+  #
+  #   @return [DateTime]
+  attr_accessor :real_path_modified_at
+
+  # @!attribute [rw] real_path_sha1_hex_digest
+  #   SHA1 hex digest of the contents of {#real_path}.
+  #
+  #   @return [String]
+  attr_accessor :real_path_sha1_hex_digest
+
+  # @!attribute [rw] reference_name
+  #   Reference name to this ancestor, scoped to {#module_type}.
+  #
+  #   @return [String]
+  attr_accessor :reference_name
+end

data/spec/dummy/app/models/dummy/module/architecture.rb

@@ -0,0 +1,19 @@
+class Dummy::Module::Architecture < Metasploit::Model::Base
+  include Metasploit::Model::Module::Architecture
+
+  #
+  # Attributes
+  #
+
+  # @!attribute [rw] architecture
+  #   The architecture supported by the {#module_instance}.
+  #
+  #   @return [Metasploit::Model::Architecture]
+  attr_accessor :architecture
+
+  # @!attribute [rw] module_instance
+  #   The module instance that supports {#architecture}.
+  #
+  #   @return [Metasploit::Model::Module::Instance]
+  attr_accessor :module_instance
+end

data/spec/dummy/app/models/dummy/module/author.rb

@@ -0,0 +1,28 @@
+# Implementation of {Metasploit::Model::Module::Author} to allow testing of {Metasploit::Model::Module::Author}
+# using an in-memory ActiveModel and use of factories.
+class Dummy::Module::Author < Metasploit::Model::Base
+  include Metasploit::Model::Module::Author
+
+  #
+  # Associations
+  #
+
+  # @!attribute [rw] author
+  #   Author who wrote the {#module_instance module}.
+  #
+  #   @return [Dummy::Author]
+  attr_accessor :author
+
+  # @!attribute [rw] email_address
+  #   Email address {#author} used when writing {#module_instance module}.
+  #
+  #   @return [Dummy::EmailAddress] if {#author} gave an email address.
+  #   @return [nil] if {#author} only gave a name.
+  attr_accessor :email_address
+
+  # @!attribute [rw] module_instance
+  #   Module written by {#author}.
+  #
+  #   @return [Dummy::Module::Instance]
+  attr_accessor :module_instance
+end

data/spec/dummy/app/models/dummy/module/class.rb

@@ -0,0 +1,69 @@
+# Implementation of {Metasploit::Model::Module::Class} to allow testing of {Metasploit::Model::Module::Class}
+# using an in-memory ActiveModel and use of factories.
+class Dummy::Module::Class < Metasploit::Model::Base
+  include Metasploit::Model::Module::Class
+
+  #
+  # Associations
+  #
+
+  # @!attribute [rw] rank
+  #   The reliability of the module and likelyhood that the module won't knock over the service or host being
+  #   exploited.  Bigger values is better.
+  #
+  #   @return [Dummy::Module::Rank]
+  attr_accessor :rank
+
+  # @!attribute [r] ancestors
+  #   The Class or Modules that were loaded to make this module Class.
+  #
+  #   @return [Array<Dummy::Module::Ancestor>]
+  attr_writer :ancestors
+
+  #
+  # Attributes
+  #
+
+  # @!attribute [rw] full_name
+  #   The full name (type + reference) for the Class<Msf::Module>.  This is merely a denormalized cache of
+  #   `"#{{#module_type}}/#{{#reference_name}}"` as full_name is used in numerous queries and reports.
+  #
+  #   @return [String]
+  attr_accessor :full_name
+
+  # @!attribute [rw] module_type
+  #   A denormalized cache of the {Metasploit::Model::Module::Class#module_type ancestors' module_types}, which
+  #   must all be the same.  This cache exists so that queries for modules of a given type don't need include the
+  #   {#ancestors}.
+  #
+  #   @return [String]
+  attr_accessor :module_type
+
+  # @!attribute [rw] payload_type
+  #   For payload modules, the {PAYLOAD_TYPES type} of payload, either 'single' or 'staged'.
+  #
+  #   @return [String] if {#payload?} is `true`.
+  #   @return [nil] if {#payload?} is `false`
+  attr_accessor :payload_type
+
+  # @!attribute [rw] reference_name
+  #   The reference name for the Class<Msf::Module>. For non-payloads, this will just be
+  #   {Mdm::Module::Ancestor#reference_name} for the only element in {#ancestors}.  For payloads composed of a
+  #   stage and stager, the reference name will be derived from the
+  #   {Metasplit::Model::Module::Ancestor#reference_name} of each element {#ancestors} or an alias defined in
+  #   those Modules.
+  #
+  #   @return [String
+  attr_accessor :reference_name
+
+  #
+  # Methods
+  #
+
+  # List of ancestors included in this module Class.
+  #
+  # @return [Array<Dummy::Module::Ancestor>]
+  def ancestors
+    @ancestors ||= []
+  end
+end

data/spec/dummy/app/models/dummy/module/instance.rb

@@ -0,0 +1,209 @@
+# Implementation of {Metasploit::Model::Module::Instance} to allow testing of {Metasploit::Model::Module::Instance}
+# using an in-memory ActiveModel and use of factories.
+class Dummy::Module::Instance < Metasploit::Model::Base
+  include Metasploit::Model::Association
+  include Metasploit::Model::Module::Instance
+
+  #
+  #
+  # Associations
+  #
+  #
+
+  association :actions, :class_name => 'Dummy::Module::Action'
+  association :architectures, :class_name => 'Dummy::Architecture'
+  association :authorities, :class_name => 'Dummy::Authority'
+  association :authors, :class_name => 'Dummy::Author'
+  association :email_addresses, :class_name => 'Dummy::EmailAddress'
+  association :module_class, :class_name => 'Dummy::Module::Class'
+  association :platforms, :class_name => 'Dummy::Platform'
+  association :rank, :class_name => 'Dummy::Module::Rank'
+  association :references, :class_name => 'Dummy::Reference'
+  association :targets, :class_name => 'Dummy::Module::Target'
+
+  # @!attribute [rw] actions
+  #   Auxiliary actions to perform when this running this module.
+  #
+  #   @return [Array<Dummy::Module::Action>]
+  def actions
+    @actions ||= []
+  end
+  attr_writer :actions
+
+  # @!attribute [rw] default_action
+  #   The default action in {#actions}.
+  #
+  #   @return [Dummy::Module::Action]
+  attr_accessor :default_action
+
+  # @!attribute [rw] default_target
+  #   The default target in {#targets}.
+  #
+  #   @return [Dummy::Module::Target]
+  attr_accessor :default_target
+
+  # @!attribute [rw] module_architectures
+  #   Joins this module instance to the {#architectures} it supports.
+  #
+  #   @return [Array<Dummy::Module::Architecture>]
+  def module_architectures
+    @module_architectures ||= []
+  end
+  attr_writer :module_architectures
+
+  # @!attribute [rw] module_authors
+  #   Joins this with {#authors} and {#email_addresses} to model the name and email address used for an author
+  #   entry in the module metadata.
+  #
+  #   @return [Array<Dummy::Module::Author>]
+  def module_authors
+    @module_authors ||= []
+  end
+  attr_writer :module_authors
+
+  # @!attribute [rw] module_class
+  #   Class-derived metadata to go along with the instance-derived metadata in this model.
+  #
+  #   @return [Dummy::Module::Class]
+  attr_accessor :module_class
+
+  # @!attribute [rw] module_platforms
+  #   Joins this with the {#platforms} it supports.
+  #
+  #   @return [Array<Dummy::Module::Platform>]
+  def module_platforms
+    @module_platforms ||= []
+  end
+  attr_writer :module_platforms
+
+  # @!attribute [rw] module_references
+  #   Joins this with the {#references} to the exploit of this module.
+  #
+  #   @return [Array<Dummy::Module::Reference>]
+  def module_references
+    @module_references ||= []
+  end
+  attr_writer :module_references
+
+  # @!attribute [rw] targets
+  #   Names of targets with different configurations that can be exploited by this module.
+  #
+  #   @return [Array<Dummy::Module::Target>]
+  def targets
+    @targets ||= []
+  end
+  attr_writer :targets
+
+  # @!attribute [r] architectures
+  #   The {Dummy::Architecture architectures} supported by this module.
+  #
+  #   @return [Array<Dummy::Architecture>]
+  def architectures
+    module_architectures.map(&:architecture)
+  end
+
+  # @!attribute [r] authors
+  #   The names of the authors of this module.
+  #
+  #   @return [Array<Dummy::Author>]
+  def authors
+    module_authors.map(&:author)
+  end
+
+  # @!attribute [r] email_addresses
+  #   The email addresses of the authors of this module.
+  #
+  #   @return [Array<Dummy::EmailAddress>]
+  def email_addresses
+    module_authors.map(&email_addresses).uniq
+  end
+
+  # @!attribute [r] platforms
+  #   Platforms supported by this module.
+  #
+  #   @return [Array<Dummy::Module::Platform>]
+  def platforms
+    module_platforms.map(&:platform)
+  end
+
+  # @!attribute [r] references
+  #   External references to the exploit or proof-of-concept (PoC) code in this module.
+  #
+  #   @return [Array<Dummy::Reference>]
+  def references
+    module_references.map(&:reference)
+  end
+
+  # @!attribute [r] vulns
+  #   Vulnerabilities with same {Dummy::Reference reference} as this module.
+  #
+  #   @return [Array<Dummy::Vuln>]
+  def vulns
+    references.inject(Set.new) { |vuln_set, reference|
+      vuln_set.merge(reference.vulns)
+    }
+  end
+
+  # @!attribute [r] vulnerable_hosts
+  #   Hosts vulnerable to this module.
+  #
+  #   @return [Array<Dummy::Host>]
+  def vulnerable_hosts
+    vulns.inject(Set.new) { |host_set, vuln|
+      host_set.add(vuln.host)
+    }
+  end
+
+  # @!attribute [r] vulnerable_services
+  #   Services vulnerable to this module.
+  #
+  #   @return [Array<Dummy::Service>]
+  def vulnerable_services
+    vulns.inject(Set.new) { |service_set, vuln|
+      service_set.merge(vuln)
+    }
+  end
+
+  #
+  # Attributes
+  #
+
+  # @!attribute [rw] description
+  #   A long, paragraph description of what the module does.
+  #
+  #   @return [String]
+  attr_accessor :description
+
+  # @!attribute [rw] disclosed_on
+  #   The date the vulnerability exploited by this module was disclosed to the public.
+  #
+  #   @return [Date, nil]
+  attr_accessor :disclosed_on
+
+  # @!attribute [rw] license
+  #   The name of the software license for the module's code.
+  #
+  #   @return [String]
+  attr_accessor :license
+
+  # @!attribute [rw] name
+  #   The human readable name of the module.  It is unrelated to {Dummy::Module::Class#full_name} or
+  #   {Dummy::Module::Class#reference_name} and is better thought of as a short summary of the
+  #   {#description}.
+  #
+  #   @return [String]
+  attr_accessor :name
+
+  # @!attribute [rw] privileged
+  #   Whether this module requires privileged access to run.
+  #
+  #   @return [Boolean]
+  attr_accessor :privileged
+
+  # @!attribute [rw] stance
+  #   Whether the module is active or passive.  `nil` if the
+  #   {Dummy::Module::Class#module_type module type} does not {#supports_stance? support stances}.
+  #
+  #   @return ['active', 'passive', nil]
+  attr_accessor :stance
+end