wg-metasploit_data_models 4.1.4.01 → 4.1.4.02

data/app/models/mdm/workspace.rb

@@ -0,0 +1,286 @@
+# Workspace to separate different collections of {#hosts}.  Can be used to separate pentests against different networks
+# or different clients as reports are normally generated against all records in a workspace.
+class Mdm::Workspace < ApplicationRecord
+  #
+  # CONSTANTS
+  #
+
+  DEFAULT = 'default'
+
+  #
+  # Associations
+  #
+
+  # Automatic exploitation runs against this workspace.
+  has_many :automatic_exploitation_runs,
+           class_name: 'MetasploitDataModels::AutomaticExploitation::Run',
+           inverse_of: :workspace
+
+  # Automatic exploitation match sets generated against {#hosts} and {#services} in this workspace.
+  has_many :automatic_exploitation_match_sets,
+           class_name: 'MetasploitDataModels::AutomaticExploitation:MatchSet',
+           inverse_of: :workspace
+
+
+  # Events that occurred in this workspace.
+  has_many :events, dependent: :delete_all, :class_name => 'Mdm::Event'
+
+  # Hosts in this workspace.
+  has_many :hosts, :dependent => :destroy, :class_name => 'Mdm::Host'
+
+  # Listeners running for this workspace.
+  has_many :listeners, :dependent => :destroy, :class_name => 'Mdm::Listener'
+
+  # Notes about this workspace.
+  has_many :notes, :class_name => 'Mdm::Note'
+
+  # User that owns this workspace and has full permissions within this workspace even if they are not an
+  # {Mdm::User#admin administrator}.
+  belongs_to :owner, :class_name => 'Mdm::User', :foreign_key => 'owner_id'
+
+  # Tasks run inside this workspace.
+  has_many :tasks,
+           -> { order('created_at DESC') },
+           class_name: 'Mdm::Task',
+           dependent: :destroy
+
+  # Users that are allowed to use this workspace.  Does not necessarily include all users, as an {Mdm::User#admin
+  # administrator} can access any workspace, even ones where they are not a member.
+  has_and_belongs_to_many :users,
+                          -> { distinct },
+                          class_name: 'Mdm::User',
+                          join_table: 'workspace_members'
+
+  #
+  # through: :hosts
+  #
+
+  # Social engineering campaign or browser autopwn clients from {#hosts} in this workspace.
+  has_many :clients, :through => :hosts, :class_name => 'Mdm::Client'
+
+  # Hosts exploited in this workspace.
+  has_many :exploited_hosts, :through => :hosts, :class_name => 'Mdm::ExploitedHost'
+
+  # Loot gathered from {#hosts} in this workspace.
+  has_many :loots, :through => :hosts, :class_name => 'Mdm::Loot'
+
+  # Services running on {#hosts} in this workspace.
+  has_many :services,
+           class_name: 'Mdm::Service',
+           foreign_key: :service_id,
+           through: :hosts
+
+  # Vulnerabilities found on {#hosts} in this workspace.
+  has_many :vulns, :through => :hosts, :class_name => 'Mdm::Vuln'
+
+  # Sessions opened on {#hosts} in this workspace.
+  has_many :sessions, :through => :hosts, :class_name => 'Mdm::Session'
+  
+  # @deprecated Use `Mdm::Workspace#core_credentials` defined by `Metasploit::Credential::Engine` to get
+  #   `Metasploit::Credential::Core`s gathered from this workspace's {#hosts} and {#services}.
+  #
+  # Creds gathered from this workspace's {#hosts} and {#services}.
+  has_many :creds, :through => :services, :class_name => 'Mdm::Cred'
+
+  #
+  # Attributes
+  #
+
+  # @!attribute boundary
+  #   Comma separated list of IP ranges (in various formats) and IP addresses that users of this workspace are allowed
+  #   to interact with if {#limit_to_network} is `true`.
+  #
+  #   @return [String]
+
+  # @!attribute description
+  #   Long description (beyond {#name}) that explains the purpose of this workspace.
+  #
+  #   @return [String]
+
+  # @!attribute limit_to_network
+  #   Whether {#boundary} is respected.
+  #
+  #   @return [false] do not limit interactions to {#boundary}.
+  #   @return [true] limit interactions to {#boundary}.
+
+  # @!attribute name
+  #   Name of this workspace.
+  #
+  #   @return [String]
+
+  # @!attribute created_at
+  #   When this workspace was created.
+  #
+  #   @return [DateTime]
+
+  # @!attribute updated_at
+  #   The last time this workspace was updated.
+  #
+  #   @return [DateTime]
+
+  #
+  # Callbacks
+  #
+
+  before_save :normalize
+
+  #
+  # Validations
+  #
+
+  validates :name, :presence => true, :uniqueness => true, :length => {:maximum => 255}
+  validates :description, :length => {:maximum => 4096}
+
+  #
+  # Instance Methods
+  #
+
+  # @deprecated Use `Mdm::Workspace#credential_cores` when `Metasploit::Credential::Engine` is installed to get
+  #    `Metasploit::Credential::Core`s.  Use `Mdm::Service#logins` when `Metasploit::Credential::Engine` is installed to
+  #    get `Metasploit::Credential::Login`s.
+  #
+  # @return [ActiveRecord::Relation<Mdm::Cred>]
+  def creds
+    Mdm::Cred
+        .joins(service: :host)
+        .where(hosts: {
+            workspace_id: self.id
+        })
+  end
+
+  # Returns default {Mdm::Workspace}.
+  #
+  # @return [Mdm::Workspace]
+  def self.default
+    where(name: DEFAULT).first_or_create
+  end
+
+  # Whether this is the {default} workspace.
+  #
+  # @return [true] if this is the {default} workspace.
+  # @return [false] if this is not the {default} workspace.
+  def default?
+    name == DEFAULT
+  end
+
+  # @deprecated Use `workspace.credential_cores.each` when `Metasploit::Credential::Engine` is installed to enumerate
+  #   `Metasploit::Credential::Core`s.  Use `service.logins.each` when `Metasploit::Credential::Engine` is installed to
+  #   enumerate `Metasploit::Credential::Login`s.
+  #
+  # Enumerates each element of {#creds}.
+  #
+  # @yield [cred]
+  # @yieldparam cred [Mdm::Cred] Cred associated with {#hosts a host} or {#services a service} in this workspace.
+  # @yieldreturn [void]
+  # @return [void]
+  def each_cred(&block)
+    creds.each do |cred|
+      block.call(cred)
+    end
+  end
+
+  # Enumerates each element of {#host_tags}.
+  #
+  # @yield [tag]
+  # @yieldparam tag [Mdm::Tag] a tag on {#hosts}.
+  # @yieldreturn [void]
+  # @return [void]
+  def each_host_tag(&block)
+    host_tags.each do |host_tag|
+      block.call(host_tag)
+    end
+  end
+
+  # Tags on {#hosts}.
+  #
+  # @return [ActiveRecord::Relation<Mdm::Tag>]
+  def host_tags
+    Mdm::Tag
+        .joins(:hosts)
+        .where(hosts: {
+          workspace_id: self.id
+        })
+  end
+
+  # Web forms found on {#web_sites}.
+  #
+  # @return [ActiveRecord::Relation<Mdm::WebForm>]
+  def web_forms
+    Mdm::WebForm.joins(
+      Mdm::WebForm.join_association(:web_site),
+      Mdm::WebSite.join_association(:service),
+      Mdm::Service.join_association(:host),
+      Mdm::Host.join_association(:workspace)
+    ).where(Mdm::Workspace[:id].eq(id)).distinct
+  end
+
+
+  # Web pages  found on {#web_sites}.
+  #
+  # @return [ActiveRecord::Relation<Mdm::WebPage>]
+  def web_pages
+    Mdm::WebPage.joins(
+      Mdm::WebPage.join_association(:web_site),
+      Mdm::WebSite.join_association(:service),
+      Mdm::Service.join_association(:host),
+      Mdm::Host.join_association(:workspace)
+    ).where(Mdm::Workspace[:id].eq(id)).distinct
+  end
+
+  # Web sites running on {#services}.
+  #
+  # @return [ActiveRecord::Relation<Mdm::WebSite>]
+  def web_sites
+    Mdm::WebSite.joins(
+      Mdm::WebSite.join_association(:service),
+      Mdm::Service.join_association(:host),
+      Mdm::Host.join_association(:workspace)
+    ).where(Mdm::Workspace[:id].eq(id)).distinct
+  end
+
+  # Web vulnerability found on {#web_sites}.
+  #
+  # @return [ActiveRecord::Relation<Mdm::WebVuln>]
+  def web_vulns
+    Mdm::WebVuln.joins(
+      Mdm::WebVuln.join_association(:web_site),
+      Mdm::WebSite.join_association(:service),
+      Mdm::Service.join_association(:host),
+      Mdm::Host.join_association(:workspace)
+    ).where(Mdm::Workspace[:id].eq(id)).distinct
+  end
+
+  # Web forms on {#web_sites}.
+  #
+  # @return [ActiveRecord::Relation<Mdm::WebForm>]
+  def unique_web_forms
+    web_forms.select('web_forms.id, web_forms.web_site_id, web_forms.path, web_forms.method, web_forms.query')
+  end
+
+  # {#unique_web_forms} hosted on `addrs`.
+  #
+  # @param addrs [Array<IPAddr, String>] {Mdm::Host#address} for the {Mdm::Service#host} for the {Mdm::WebSite#service}
+  #   for the {Mdm::WebForm#web_site}.
+  # @return [Array<Mdm::WebForm>]
+  def web_unique_forms(addrs=nil)
+    forms = unique_web_forms
+    if addrs
+      forms.to_a.reject!{|f| not addrs.include?( f.web_site.service.host.address.to_s ) }
+    end
+    forms
+  end
+
+  private
+
+  # Strips {#boundary}.
+  #
+  # @return [void]
+  def normalize
+    boundary.strip! if boundary
+  end
+
+  public
+
+  Metasploit::Concern.run(self)
+end
+

data/app/models/metasploit_data_models/automatic_exploitation/match.rb

@@ -0,0 +1,43 @@
+# Matches {#matchable} {Mdm::Service} or {Mdm::Vuln} to a {#module_detail Metasploit Module} that can exploit it.
+class MetasploitDataModels::AutomaticExploitation::Match < ApplicationRecord
+  #
+  # Associations
+  #
+
+  # A (polymorphic) "matchable" entity like a {Mdm::Vuln} or {Mdm::Service}
+  #
+  # @return [Mdm::Service, Mdm::Vuln]
+  belongs_to :matchable, polymorphic: true
+
+  # The {MatchSet} this match is part of
+  has_many :match_results,
+           class_name: 'MetasploitDataModels::AutomaticExploitation::MatchResult',
+           inverse_of: :match
+
+  # The {MatchSet} this match is part of
+  belongs_to :match_set,
+             class_name: 'MetasploitDataModels::AutomaticExploitation::MatchSet',
+             inverse_of: :matches
+
+  # The Metasploit Module that this match connects to
+  belongs_to :module_detail,
+             class_name: 'Mdm::Module::Detail',
+             foreign_key: :module_fullname,
+             primary_key: :fullname
+
+  # Scope a match to a MetasploitDataModels::AutomaticExploitation::Run
+  scope :by_run_and_vuln,
+        ->(run,vuln){
+          joins(
+            MetasploitDataModels::AutomaticExploitation::Match.join_association(:match_set),
+            MetasploitDataModels::AutomaticExploitation::MatchSet.join_association(:runs)
+          ).where(
+            MetasploitDataModels::AutomaticExploitation::Run[:id].eq(run.id)
+          ).where(
+            MetasploitDataModels::AutomaticExploitation::Match[:matchable_id].eq(vuln.id),
+            MetasploitDataModels::AutomaticExploitation::Match[:matchable_type].eq("Mdm::Vuln")
+          )
+        }
+
+  Metasploit::Concern.run(self)
+end

data/app/models/metasploit_data_models/automatic_exploitation/match_result.rb

@@ -0,0 +1,71 @@
+# The result of {#run running} a {#match}.
+class MetasploitDataModels::AutomaticExploitation::MatchResult < ApplicationRecord
+  #
+  # CONSTANTS
+  #
+
+  # Running associated exploit did NOT create a session
+  FAILED = "failed"
+  # Running associated exploit created a session
+  SUCCEEDED = "succeeded"
+
+  # Valid values for {#state}
+  VALID_STATES = [FAILED, SUCCEEDED]
+
+  #
+  # Associations
+  #
+
+  # A {MetasploitDataModels::AutomaticExploitation::Match#module_detail Metasploit Module} matched to
+  # {MetasploitDataModels::AutomaticExploitation::Match#matchable Mdm::Host or Mdm::Service}.
+  belongs_to :match,
+             class_name: 'MetasploitDataModels::AutomaticExploitation::Match',
+             inverse_of: :match_results,
+             dependent: :destroy
+
+  # A mass automatic exploitation run.
+  belongs_to :run,
+             inverse_of: :match_results,
+             class_name: 'MetasploitDataModels::AutomaticExploitation::Run'
+
+  #
+  # Attributes
+  #
+
+  # @!attribute state
+  #   Whether the {#run} of {#match} succeeded.
+  #
+  #   @return ['failed', 'succeeded']
+
+  #
+  # Validations
+  #
+
+  # must be present and one of allowable values
+  validates :state,
+            presence: true,
+            inclusion: VALID_STATES
+
+  #
+  # Scopes
+  #
+
+  # Runs of {#match} that failed
+  scope :failed, lambda { where(state:"failed") }
+
+  # Runs of {#match} that succeeded
+  scope :succeeded, lambda { where(state:"succeeded") }
+
+  # Runs of {#match} by workspace ID
+  scope :by_workspace, lambda { |workspace_id|
+                       joins(
+                         MetasploitDataModels::AutomaticExploitation::MatchResult.join_association(:match),
+                         MetasploitDataModels::AutomaticExploitation::Match.join_association(:match_set)
+                       ).where(
+                         MetasploitDataModels::AutomaticExploitation::MatchSet[:workspace_id].eq(workspace_id),
+                       )
+                     }
+
+  Metasploit::Concern.run(self)
+end
+

data/app/models/metasploit_data_models/automatic_exploitation/match_set.rb

@@ -0,0 +1,40 @@
+# A set of {#matches automatic exploitation matches}.
+class MetasploitDataModels::AutomaticExploitation::MatchSet < ApplicationRecord
+  #
+  # Associations
+  #
+
+  # Runs of this set of {#matches}.
+  has_many :runs,
+           class_name: "MetasploitDataModels::AutomaticExploitation::Run",
+           inverse_of: :match_set
+
+  # Matches in this set.
+  has_many :matches,
+           class_name: "MetasploitDataModels::AutomaticExploitation::Match",
+           inverse_of: :match_set,
+           dependent: :destroy
+
+  # User that created this match set.
+  belongs_to :user,
+             inverse_of: :automatic_exploitation_match_sets,
+             class_name: "Mdm::User"
+
+  # Workspace in which this match set exists.
+  belongs_to :workspace,
+             inverse_of: :automatic_exploitation_match_sets,
+             class_name: "Mdm::Workspace"
+
+  #
+  # Validations
+  #
+
+  validates :user,
+            presence: true
+
+  validates :workspace,
+            presence: true
+
+
+  Metasploit::Concern.run(self)
+end

data/app/models/metasploit_data_models/automatic_exploitation/run.rb

@@ -0,0 +1,29 @@
+# Runs a {#match_set set of matches} to produce {#match_results results}.
+class MetasploitDataModels::AutomaticExploitation::Run < ApplicationRecord
+  #
+  # Associations
+  #
+
+  # Results of each match in {#match_set}.
+  has_many :match_results,
+           class_name:'MetasploitDataModels::AutomaticExploitation::MatchResult',
+           inverse_of: :run,
+           dependent: :destroy
+
+  # Set of matches to run
+  belongs_to :match_set,
+             class_name: 'MetasploitDataModels::AutomaticExploitation::MatchSet',
+             inverse_of: :runs
+
+  # User that initiated this run.
+  belongs_to :user,
+             class_name: "Mdm::User",
+             inverse_of: :automatic_exploitation_runs
+
+  # Workspace in which this run was performed.
+  belongs_to :workspace,
+             class_name: "Mdm::Workspace",
+             inverse_of: :automatic_exploitation_runs
+
+  Metasploit::Concern.run(self)
+end

data/app/models/metasploit_data_models/ip_address/v4/cidr.rb

@@ -0,0 +1,14 @@
+# An IPv4 CIDR (Classless InterDomain Routing) block composed of a
+# {MetasploitDataModels::IPAddress::V4::Single IPv4} {MetasploitDataModels::IPAddress::CIDR#address address} and
+# {MetasploitDataModels::IPAddress::CIDR#prefix_length prefix_length} written in the form `'a.b.c.d/prefix_length'`.
+#
+# @see https://en.wikipedia.org/wiki/Cidr#IPv6_CIDR_blocks
+class MetasploitDataModels::IPAddress::V4::CIDR < Metasploit::Model::Base
+  include MetasploitDataModels::IPAddress::CIDR
+
+  #
+  # CIDR
+  #
+
+  cidr address_class: MetasploitDataModels::IPAddress::V4::Single
+end

data/app/models/metasploit_data_models/ip_address/v4/nmap.rb

@@ -0,0 +1,14 @@
+# Nmap's octet range format composed of segments of comma separated list of segment numbers and segment number ranges.
+#
+# @example Nmap octect range format
+#   # equivalent to ['1.5.6.7', '3.5.6.7', '4.5.6.7']
+#   '1,3-4.5.6.7'
+#
+# @see http://nmap.org/book/man-target-specification.html
+class MetasploitDataModels::IPAddress::V4::Nmap < MetasploitDataModels::IPAddress::V4::Segmented
+  #
+  # Segments
+  #
+
+  segment class_name: 'MetasploitDataModels::IPAddress::V4::Segment::Nmap::List'
+end

data/app/models/metasploit_data_models/ip_address/v4/range.rb

@@ -0,0 +1,12 @@
+# A range of complete IPv4 addresses, separated by a `-`.
+class MetasploitDataModels::IPAddress::V4::Range < Metasploit::Model::Base
+  extend MetasploitDataModels::Match::Child
+
+  include MetasploitDataModels::IPAddress::Range
+
+  #
+  # Range Extremes
+  #
+
+  extremes class_name: 'MetasploitDataModels::IPAddress::V4::Single'
+end

data/app/models/metasploit_data_models/ip_address/v4/segment/nmap/list.rb

@@ -0,0 +1,125 @@
+# A comma separated list of {MetasploitDataModels::IPAddress::V4::Segment::Single segment numbers} and
+# {MetasploitDataModels::IPAddress::V4::Segment::Nmap::Range range of segment numbers} making up one segment of
+# {MetasploitDataModels::IPAddress::V4::Nmap}.
+class MetasploitDataModels::IPAddress::V4::Segment::Nmap::List < Metasploit::Model::Base
+
+  include MetasploitDataModels::Match::Parent
+
+  #
+  # CONSTANTS
+  #
+
+  # Either an individual {MetasploitDataModels::IPAddress::V4::Segment::Single segment number} or a
+  # {MetasploitDataModels::IPAddress::V4::Segment::Nmap::Range segment range}.
+  RANGE_OR_NUMBER_REGEXP = %r{
+      (?<range>#{parent::Range.regexp})
+      |
+      # range first because it contains a segment and if the range isn't first only the first part of the range will
+      # match.
+      (?<number>#{MetasploitDataModels::IPAddress::V4::Segment::Single::REGEXP})
+  }x
+  # Separator between number or ranges
+  SEPARATOR = ','
+  # Segment of an NMAP address, composed of comma separated {RANGE_OR_NUMBER_REGEXP segment numbers or ranges}.
+  REGEXP = /#{RANGE_OR_NUMBER_REGEXP}(#{SEPARATOR}#{RANGE_OR_NUMBER_REGEXP})*/
+
+  # Matches exactly an Nmap comma separated list of segment numbers and ranges.
+  MATCH_REGEXP = /\A#{REGEXP}\z/
+
+  #
+  # Attributes
+  #
+
+  # @!attribute value
+  #   The NMAP IPv4 octect range.
+  #
+  #   @return [Array<MetasploitDataModels::IPAddress::V4::Segment::Number, MetasploitDataModels::IPAddress::V4::Segment::Range>]
+  #     number and range in the order they appeared in formatted value.
+  attr_reader :value
+
+  #
+  # Match Children
+  #
+
+  match_children_named %w{
+    MetasploitDataModels::IPAddress::V4::Segment::Single
+    MetasploitDataModels::IPAddress::V4::Segment::Nmap::Range
+  }
+
+  #
+  #
+  # Validations
+  #
+  #
+
+  #
+  # Method Validations
+  #
+
+  validate :value_elements_valid
+  validate :value_is_array
+
+  #
+  # Attribute Validations
+  #
+
+  validates :value,
+            presence: true
+
+  #
+  # Instance Methods
+  #
+
+  # @return [String]
+  def to_s
+    if value.is_a? Array
+      value.map(&:to_s).join(SEPARATOR)
+    else
+      value.to_s
+    end
+  end
+
+  # Set {#value} to an `Array` of segment numbers and ranges.
+  #
+  # @param formatted_value [#to_s]
+  # @return [Array<MetasploitDataModels::IPAddress::V4::Segment::Single, MetasploitDataModels::IPAddress::V4::Segment::Nmap::Range>] a parsed `Array` of segment numbers and ranges.
+  # @return [#to_s] if `formatted_value` does not match {MATCH_REGEXP}.
+  def value=(formatted_value)
+    string = formatted_value.to_s
+    match = MATCH_REGEXP.match(string)
+
+    if match
+      ranges_or_numbers = string.split(SEPARATOR)
+
+      @value = ranges_or_numbers.map { |range_or_number|
+        match_child(range_or_number) || range_or_number
+      }
+    else
+      @value = formatted_value
+    end
+  end
+
+  private
+
+  # Validates that {#value}'s elements are all valid.
+  #
+  # @return [void]
+  def value_elements_valid
+    if value.is_a? Array
+      value.each_with_index do |element, index|
+        unless element.valid?
+          errors.add(:value, :element, element: element, index: index)
+        end
+      end
+    end
+  end
+
+  # Validates that {#value} is an `Array`.
+  #
+  # @return [void]
+  def value_is_array
+    unless value.is_a? Array
+      errors.add(:value, :array)
+    end
+  end
+end

data/app/models/metasploit_data_models/ip_address/v4/segment/nmap/range.rb

@@ -0,0 +1,12 @@
+# A range of segment number composed of a {#begin} and {#end} segment number, separated by a `-`.
+class MetasploitDataModels::IPAddress::V4::Segment::Nmap::Range < Metasploit::Model::Base
+  extend MetasploitDataModels::Match::Child
+
+  include MetasploitDataModels::IPAddress::Range
+
+  #
+  # Range Extremes
+  #
+
+  extremes class_name: 'MetasploitDataModels::IPAddress::V4::Segment::Single'
+end