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

data/lib/metasploit/model/module/target/platform.rb

@@ -0,0 +1,42 @@
+module Metasploit
+  module Model
+    module Module
+      module Target
+        # Model that joins {Metasploit::Model::Platform} and {Metasploit::Model::Module::Target}.
+        module Platform
+          extend ActiveModel::Naming
+          extend ActiveSupport::Concern
+
+          include Metasploit::Model::Translation
+
+          included do
+            include ActiveModel::Validations
+
+            #
+            # Validations
+            #
+
+            validates :module_target,
+                      presence: true
+            validates :platform,
+                      presence: true
+          end
+
+          #
+          # Associations
+          #
+
+          # @!attribute [rw] module_target
+          #   The module target that supports {#platform}.
+          #
+          #   @return [Metasploit::Model::Module::Target]
+
+          # @!attribute [rw] platform
+          #   The platform supported by the {#module_target}.
+          #
+          #   @return [Metasploit::Model::Platform]
+        end
+      end
+    end
+  end
+end

data/lib/metasploit/model/module/type.rb

@@ -0,0 +1,44 @@
+module Metasploit
+  module Model
+    module Module
+      # Defines constants for {Metasploit::Model::Module} types as used in {Metasploit::Model::Module::Ancestor}.
+      module Type
+        #
+        # CONSTANTS
+        #
+
+        # Symbolizes any module type is allowed.
+        ANY = '_any_'
+        # Auxiliary modules
+        AUX = 'auxiliary'
+        # Encoder modules
+        ENCODER = 'encoder'
+        # Exploit modules
+        EXPLOIT = 'exploit'
+        # No operation modules
+        NOP = 'nop'
+        # Payload modules
+        PAYLOAD = 'payload'
+        # Post-exploitation modules
+        POST = 'post'
+
+        # Array<String> of all supported module types (except {ANY} since that's a symbolic type)
+        ALL = [
+            AUX,
+            ENCODER,
+            EXPLOIT,
+            NOP,
+            PAYLOAD,
+            POST
+        ]
+
+        # Array<String> of all module types that aren't {PAYLOAD} because {PAYLOAD}
+        # {Metasploit::Model::Module::Ancestor#contents} define `Modules` instead of `Classes` and so need to be loaded
+        # differently.
+        NON_PAYLOAD = ALL.reject { |module_type|
+          module_type == PAYLOAD
+        }
+      end
+    end
+  end
+end

data/lib/metasploit/model/nilify_blanks.rb

@@ -0,0 +1,53 @@
+module Metasploit
+  module Model
+    # Registers before validation callback to convert the given attributes to `nil` if they are blank.  This can be used
+    # to normalize empty attributes to NULL in the database so queries don't have to handle both `= ''` and `IS NULL`.
+    module NilifyBlanks
+      extend ActiveSupport::Concern
+
+      included do
+        include ActiveModel::Validations
+        include ActiveModel::Validations::Callbacks
+
+        before_validation :nilify_blanks
+      end
+
+      # Adds DSL methods once NilifyBlanks is included so that attributes where blanks should be changed to `nil` can be
+      # declared.
+      module ClassMethods
+        # Declares that `attributes` should be changed to `nil` before validation if they are blank.
+        #
+        # @param attributes [Enumerable<Symbol>] one or more attribute names
+        # @return [void]
+        def nilify_blank(*attributes)
+          nilify_blank_attribute_set.merge(attributes)
+        end
+
+        # Set of all attributes registered with {#nilify_blank}.
+        #
+        # @return [Set<Symbol>]
+        def nilify_blank_attribute_set
+          @nilify_blank_attribute_set ||= Set.new
+        end
+      end
+
+      #
+      # Instance Methods
+      #
+
+      # Before validation callback to change any attributes in {ClassMethods#nilify_blank_attribute_set} that are blank to
+      # `nil`.
+      #
+      # @return [void]
+      def nilify_blanks
+        self.class.nilify_blank_attribute_set.each do |attribute|
+          value = send(attribute)
+
+          if value.respond_to? :blank? and value.blank?
+            send("#{attribute}=", nil)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metasploit/model/platform.rb

@@ -0,0 +1,250 @@
+module Metasploit
+  module Model
+    # Code shared between `Mdm::Platform` and `Metasploit::Framework::Platform`.
+    module Platform
+      extend ActiveModel::Naming
+      extend ActiveSupport::Concern
+
+      include Metasploit::Model::Translation
+
+      #
+      # CONSTANTS
+      #
+
+      # Platforms are seeded in a hierarchy with deeper levels refining higher levels, so 'Windows 98 SE' is a
+      # refinement of 'Windows 98', which is a refinement of 'Windows'.
+      SEED_RELATIVE_NAME_TREE = {
+          'AIX' => nil,
+          'Android' => nil,
+          'BSD' => nil,
+          'BSDi' => nil,
+          'Cisco' => nil,
+          'Firefox' => nil,
+          'FreeBSD' => nil,
+          'HPUX' => nil,
+          'IRIX' => nil,
+          'Java' => nil,
+          'Javascript' => nil,
+          'Linux' => nil,
+          'NetBSD' => nil,
+          'Netware' => nil,
+          'NodeJS' => nil,
+          'OpenBSD' => nil,
+          'OSX' => nil,
+          'PHP' => nil,
+          'Python' => nil,
+          'Ruby' => nil,
+          'Solaris' => {
+              '4' => nil,
+              '5' => nil,
+              '6' => nil,
+              '7' => nil,
+              '8' => nil,
+              '9' => nil,
+              '10' => nil
+          },
+          'Windows' => {
+              '95' => nil,
+              '98' => {
+                  'FE' => nil,
+                  'SE' => nil
+              },
+              'ME' => nil,
+              'NT' => {
+                  'SP0' => nil,
+                  'SP1' => nil,
+                  'SP2' => nil,
+                  'SP3' => nil,
+                  'SP4' => nil,
+                  'SP5' => nil,
+                  'SP6' => nil,
+                  'SP6a' => nil
+              },
+              '2000' => {
+                 'SP0' => nil,
+                 'SP1' => nil,
+                 'SP2' => nil,
+                 'SP3' => nil,
+                 'SP4' => nil
+              },
+              'XP' => {
+                  'SP0' => nil,
+                  'SP1' => nil,
+                  'SP2' => nil,
+                  'SP3' => nil
+              },
+              '2003' => {
+                  'SP0' => nil,
+                  'SP1' => nil
+              },
+              'Vista' => {
+                  'SP0' => nil,
+                  'SP1' => nil
+              },
+              '7' => nil
+          },
+          'UNIX' => nil
+      }
+
+      included do
+        include ActiveModel::MassAssignmentSecurity
+        include ActiveModel::Validations
+        include Metasploit::Model::Derivation
+        include Metasploit::Model::Search
+
+        #
+        # Derivations
+        #
+
+        derives :fully_qualified_name, :validate => true
+
+        #
+        # Mass Assignment Security
+        #
+
+        attr_accessible :relative_name
+
+        #
+        # Search
+        #
+
+        search_attribute :fully_qualified_name,
+                         type: {
+                             set: :string
+                         }
+
+        #
+        # Validation
+        #
+
+        validates :fully_qualified_name,
+                  inclusion: {
+                      in: Metasploit::Model::Platform.fully_qualified_name_set
+                  }
+        validates :relative_name,
+                  presence: true
+      end
+
+      # Adds {#fully_qualified_name_set} to class.
+      module ClassMethods
+        # Set of valid {Metasploit::Model::Platform#fully_qualified_name}.
+        #
+        # @return [Set<String>]
+        def fully_qualified_name_set
+          Metasploit::Model::Platform.fully_qualified_name_set
+        end
+      end
+
+      #
+      # Attributes
+      #
+
+      # @!attribute [rw] fully_qualified_name
+      #   The fully qualified name of this platform, as would be used in the platform list in a metasploit-framework
+      #   module.
+      #
+      #   @return [String]
+
+      # @!attribute [rw] parent
+      #   The parent platform of this platform.  For example, Windows is parent of Windows 98, which is the parent of
+      #   Windows 98 FE.
+      #
+      #   @return [nil] if this is a top-level platform, such as Windows or Linux.
+      #   @return [Metasploit::Model::Platform]
+
+      # @!attribute [rw] relative_name
+      #   The name of this platform relative to the {#fully_qualified_name} of {#parent}.
+      #
+      #   @return [String]
+
+      #
+      # Methods
+      #
+
+      # Derives {#fully_qualified_name} from {#parent}'s {#fully_qualified_name} and this platform's {#relative_name}.
+      #
+      # @return [nil] if {#relative_name} is blank.
+      # @return [String] {#relative_name} if {#parent} is `nil`.
+      # @return [String] '<{#parent} {#relative_name}> <{#relative_name}>' if {#parent} is not `nil`.
+      def derived_fully_qualified_name
+        if relative_name.present?
+          if parent
+            "#{parent.fully_qualified_name} #{relative_name}"
+          else
+            relative_name
+          end
+        end
+      end
+
+      # @note Not defined in `ClassMethods` because consumers should always refer back to {Metasploit::Model::Platform}
+      #   when seeding.
+      #
+      # @param options [Hash{Symbol => Object, Hash}]
+      # @option options [Object] :parent (nil) The parent object to which to attach the children.
+      # @option options [Hash{String => nil,Hash}] :grandchildren_by_child_relative_name
+      #   ({SEED_RELATIVE_NAME_TREE}) Maps {#relative_name} of children under :parent to their children
+      #   (grandchildren of parent).  Grandchildren can be `nil` or another recursive `Hash` of names and their
+      #   descendants.
+      # @yield [attributes] Block should construct child object using attributes.
+      # @yieldparam attributes [Hash{Symbol => Object,String}] Hash containing attributes for child object, include
+      #   :parent for {#parent} and :relative_name for {#relative_name}.
+      # @yieldreturn [Object] child derived from :parent and :relative_name to be used as the parent for
+      #   grandchildren.
+      # @return [void]
+      def self.each_seed_attributes(options={}, &block)
+        options.assert_valid_keys(:parent, :grandchildren_by_child_relative_name)
+
+        parent = options[:parent]
+        grandchildren_by_child_relative_name = options.fetch(
+            :grandchildren_by_child_relative_name,
+            SEED_RELATIVE_NAME_TREE
+        )
+
+        grandchildren_by_child_relative_name.each do |child_relative_name, great_grandchildren_by_grandchild_relative_name|
+          attributes = {
+              parent: parent,
+              relative_name: child_relative_name
+          }
+          child = block.call(attributes)
+
+          if great_grandchildren_by_grandchild_relative_name
+            each_seed_attributes(
+                grandchildren_by_child_relative_name: great_grandchildren_by_grandchild_relative_name,
+                parent: child,
+                &block
+            )
+          end
+        end
+      end
+
+      # List of valid {#fully_qualified_name} derived from {SEED_RELATIVE_NAME_TREE}.
+      #
+      # @return [Array<String>]
+      def self.fully_qualified_name_set
+        unless instance_variable_defined? :@fully_qualified_name_set
+          @fully_qualified_name_set = Set.new
+
+          each_seed_attributes do |attributes|
+            parent = attributes.fetch(:parent)
+            relative_name = attributes.fetch(:relative_name)
+
+            if parent
+              fully_qualified_name = "#{parent} #{relative_name}"
+            else
+              fully_qualified_name = relative_name
+            end
+
+            @fully_qualified_name_set.add fully_qualified_name
+
+            # yieldreturn
+            fully_qualified_name
+          end
+
+          @fully_qualified_name_set.freeze
+        end
+
+        @fully_qualified_name_set
+      end
+    end
+  end
+end

data/lib/metasploit/model/real_pathname.rb

@@ -0,0 +1,18 @@
+module Metasploit
+  module Model
+    # Adds {#real_pathname} to class, which will convert `#real_path` `String` to a `Pathname`.
+    module RealPathname
+      # `#real_path` as a `Pathname`.
+      #
+      # @return [Pathname] unless `#real_path` is `nil`.
+      # @return [nil] if `#real_path` is `nil`.
+      def real_pathname
+        if real_path
+          Pathname.new(real_path)
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/metasploit/model/reference.rb

@@ -0,0 +1,108 @@
+module Metasploit
+  module Model
+    # Code shared between `Mdm::Reference` and `Metasploit::Framework::Reference`.
+    module Reference
+      extend ActiveModel::Naming
+      extend ActiveSupport::Concern
+
+      include Metasploit::Model::Translation
+
+      included do
+        include ActiveModel::MassAssignmentSecurity
+        include ActiveModel::Validations
+        include Metasploit::Model::Derivation
+        include Metasploit::Model::Search
+
+        #
+        # Derivations
+        #
+
+        derives :url, :validate => false
+
+        #
+        # Mass Assignment Security
+        #
+
+        attr_accessible :designation
+        attr_accessible :url
+
+        #
+        # Search Attributes
+        #
+
+        search_attribute :designation, :type => :string
+        search_attribute :url, :type => :string
+
+        #
+        # Validations
+        #
+
+        validates :designation,
+                  :presence => {
+                      :if => :authority?
+                  },
+                  :nil => {
+                      :unless => :authority?
+                  }
+        validates :url,
+                  :presence => {
+                      :unless => :authority?
+                  }
+      end
+
+      #
+      # Associations
+      #
+
+      # @!attribute [rw] authority
+      #   The {Metasploit::Model::Authority authority} that assigned {#designation}.
+      #
+      #   @return [Metasploit::Model::Authority, nil]
+
+      # @!attribute [r] module_instances
+      #   {Metasploit::Model::Module::Instance Modules} that exploit this reference or describe a proof-of-concept (PoC)
+      #   code that the module is based on.
+      #
+      #   @return [Array<Metasploit::Model::Module::Instance>]
+
+      #
+      # Attributes
+      #
+
+      # @!attribute [rw] designation
+      #   A designation (usually a string of numbers and dashes) assigned by {#authority}.
+      #
+      #   @return [String, nil]
+
+      # @!attribute [rw] url
+      #   URL to web page with information about referenced exploit.
+      #
+      #   @return [String, nil]
+
+      #
+      # Instance Methods
+      #
+
+      # Returns whether {#authority} is not `nil`.
+      #
+      # @return [true] unless {#authority} is `nil`.
+      # @return [false] if {#authority} is `nil`.
+      def authority?
+        authority.present?
+      end
+
+      # Derives {#url} based how {#authority} routes {#designation designations} to a URL.
+      #
+      # @return [String, nil]
+      def derived_url
+        derived = nil
+
+        if authority and designation.present?
+          derived = authority.designation_url(designation)
+        end
+
+        derived
+      end
+    end
+  end
+end