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

data/lib/metasploit/model/configuration/autoload.rb

@@ -0,0 +1,109 @@
+require 'metasploit/model/configuration/child'
+
+# Defines methods for adding paths to `ActiveSupport::Dependencies.autoload_paths`.
+class Metasploit::Model::Configuration::Autoload < Metasploit::Model::Configuration::Child
+  #
+  # Attributes
+  #
+
+  # @!attribute [rw] relative_once_paths
+  #   Paths relative to {Metasploit::Model::Configuration::Child#configuration #configuration}
+  #   {Metasploit::Model::Configuration#root #root} that should only be autoloaded once.
+  #
+  #   @return [Array<String>]
+
+  # @!attribute [rw] relative_paths
+  #   Paths relative to {Metasploit::Model::Configuration::Child#configuration #configuration}
+  #   {Metasploit::Model::Configuration#root #root} that should be autoloaded more than once.
+  #
+  #   @return [Array<String>]
+
+  #
+  # Methods
+  #
+
+  # Combines {#once_paths} and {#paths} as both need to be added to
+  # `ActiveSupport::Dependencies.autoload_paths`.
+  #
+  # @return [Array<String>]
+  def all_paths
+    @all_paths ||= (once_paths + paths).uniq
+  end
+
+  # Eager loads all rb files under {#all_paths}.  Paths in {#all_paths} are sorted before loading, so that `app` will
+  # load before `lib`.  Files are required using `ActiveSupport::Dependencies::Loadable#require_dependency` so they
+  # interact with `ActiveSupport::Dependencies` loading correctly.
+  #
+  # @return [void]
+  def eager_load!
+    # sort to favor app over lib since it is assumed that app/models will define classes and lib will define modules
+    # included in those classes that are defined under the class namespaces, so the class needs to be required first
+    all_paths.sort.each do |load_path|
+      matcher = /\A#{Regexp.escape(load_path)}\/(.*)\.rb\Z/
+
+      Dir.glob("#{load_path}/**/*.rb").sort.each do |file|
+        require_dependency file.sub(matcher, '\1')
+      end
+    end
+  end
+
+  # {#relative_once_paths} converted to absolute paths.
+  #
+  # @return [Array<String>]
+  def once_paths
+    @once_paths ||= relative_once_paths.collect { |relative_path|
+      configuration.root.join(relative_path).to_path
+    }
+  end
+
+  # {#relative_paths} converted to absolute paths.
+  #
+  # @return [Array<String>]
+  def paths
+    @paths ||= relative_paths.collect { |relative_path|
+      configuration.root.join(relative_path).to_path
+    }
+  end
+
+  # Paths relative to {Metasploit::Model::Configuration#root} that are to be added to
+  # `ActiveSupport::Dependencies.autoload_paths` and `ActiveSupport::Dependencies.autoload_once_paths`.
+  #
+  # @return [Array<String>] Defaults to ['lib']
+  def relative_once_paths
+    @relative_once_paths ||= [
+        'lib'
+    ]
+  end
+
+  attr_writer :relative_once_paths
+
+  # Paths relative to {Metasploit::Model::Configuration#root} that are to be added to
+  # `ActiveSupport::Dependencies.autoload_paths`, but not `ActiveSupport::Dependencies.autoload_once_paths`
+  #
+  # @return [Array<String>] Defaults to ['app/models']
+  def relative_paths
+    @relative_paths ||= [
+        File.join('app', 'models')
+    ]
+  end
+
+  attr_writer :relative_paths
+
+  # Adds {#all_paths} to `ActiveSupport::Dependencies.autoload_paths` if they are not already there and adds
+  # {#once_paths} to `ActiveSupport::Dependencies.autoload_once_paths` if they are not already there.
+  #
+  # @return [void]
+  def setup
+    all_paths.each do |autoload_path|
+      unless ActiveSupport::Dependencies.autoload_paths.include? autoload_path
+        ActiveSupport::Dependencies.autoload_paths << autoload_path
+      end
+    end
+
+    once_paths.each do |autoload_once_path|
+      unless ActiveSupport::Dependencies.autoload_once_paths.include? autoload_once_path
+        ActiveSupport::Dependencies.autoload_once_paths << autoload_once_path
+      end
+    end
+  end
+end

data/lib/metasploit/model/configuration/child.rb

@@ -0,0 +1,12 @@
+# Child of a {Metasploit::Model::Configuration} that contains a reference to the {#configuration}.
+class Metasploit::Model::Configuration::Child
+  #
+  # Attributes
+  #
+
+  # @!attribute [rw] configuration
+  #   Main configuration.
+  #
+  #   @return [Metasploit::Model::Configuration::Autoload]
+  attr_accessor :configuration
+end

data/lib/metasploit/model/configuration/error.rb

@@ -0,0 +1,4 @@
+# Error raised by {Metasploit::Model::Configuration#root} if root is not configured.
+class Metasploit::Model::Configuration::Error < Metasploit::Model::Error
+
+end

data/lib/metasploit/model/configuration/i18n.rb

@@ -0,0 +1,54 @@
+require 'metasploit/model/configuration/child'
+
+# Defines methods for adding paths to `I18n.load_path`
+class Metasploit::Model::Configuration::I18n < Metasploit::Model::Configuration::Child
+  #
+  # Attributes
+  #
+
+  # @!attribute [rw] relative_directories
+  #   Paths relative to root that point to directories that contain locale files like `en.yml`.
+  #
+  #   @return [Array<String>] Defaults to ['config/locales']
+
+  # Absolute paths to directories under which to find I18n .yml files.
+  #
+  # @return [Array<String>]
+  def directories
+    @directories ||= relative_directories.collect { |relative_path|
+      configuration.root.join(relative_path).to_path
+    }
+  end
+
+  # Absolute paths to I18n .yml files.
+  #
+  # @return [Array<String>]
+  def paths
+    @paths ||= directories.flat_map { |directory|
+      glob = File.join(directory, '*.yml')
+      Dir.glob(glob)
+    }
+  end
+
+  # Relative paths to I18n directories.
+  #
+  # @return [Array<String>] Defaults to 'config/locales'
+  def relative_directories
+    @relative_directories ||= [
+        File.join('config', 'locales')
+    ]
+  end
+
+  attr_writer :relative_directories
+
+  # Adds {#paths} to `I18n.load_path` if they are not already there.
+  #
+  # @return [void]
+  def setup
+    paths.each do |path|
+      unless ::I18n.load_path.include? path
+        ::I18n.load_path << path
+      end
+    end
+  end
+end

data/lib/metasploit/model/configuration/parent.rb

@@ -0,0 +1,50 @@
+# DSL for declaring {Metasploit::Model::Configuration::Child children} of {Metasploit::Model::Configuration}
+module Metasploit::Model::Configuration::Parent
+  # Declares a {Metasploit::Model::Configuration::Child} with the given `name`.
+  #
+  # @param name [Symbol] The name of the child.
+  # @return [void]
+  def child(name)
+    child_class_attribute_name = "#{name}_class"
+    child_class_instance_variable_name = "@#{child_class_attribute_name}".to_sym
+    child_instance_variable_name = "@#{name}".to_sym
+
+    #
+    # Attributes
+    #
+
+    # @!attribute [rw] <name>_class
+    #   The `Class` used to create {#<name>}.
+    #
+    #   @return [Class]
+    attr_writer child_class_attribute_name
+
+    #
+    # Methods
+    #
+
+    define_method(name) do
+      unless instance_variable_defined? child_instance_variable_name
+        child_instance = send(child_class_attribute_name).new
+        child_instance.configuration = self
+
+        instance_variable_set child_instance_variable_name, child_instance
+      end
+
+      instance_variable_get child_instance_variable_name
+    end
+
+    define_method(child_class_attribute_name) do
+      child_class = instance_variable_get child_class_instance_variable_name
+
+      unless child_class
+        require "metasploit/model/configuration/#{name}"
+
+        child_class = "Metasploit::Model::Configuration::#{name.to_s.camelize}".constantize
+        instance_variable_set child_class_instance_variable_name, child_class
+      end
+
+      child_class
+    end
+  end
+end

data/lib/metasploit/model/configured.rb

@@ -0,0 +1,46 @@
+require 'active_support/core_ext/module/delegation'
+
+# Allows modules to be configured (using {Metasploit::Model::Configuration}) similar to Rails engines.
+#
+# @example Making gem module configurable
+#   module MyGem
+#     extend Metasploit::Model::Configured
+#
+#     # assumes __FILE__ is lib/my_gem.rb
+#     lib_my_gem_pathname = Pathname.new(___FILE__)
+#     lib_pathname = lib_my_gem_pathname.parent
+#     configuration.root = lib_pathname.parent
+#
+#     configuration.autoload.paths << 'app/models'
+#   end
+#
+#   # registers 'app/models' as an autoload_path with ActiveSupport::Dependencies
+#   MyGem.setup
+module Metasploit::Model::Configured
+  # The {Metasploit::Model::Configuration} for this configured `Module`.
+  #
+  # @return [Metasploit::Model::Configuration]
+  def configuration
+    unless instance_variable_defined? :@configuration
+      require 'metasploit/model/configuration'
+
+      @configuration = Metasploit::Model::Configuration.new
+    end
+
+    @configuration
+  end
+
+  # @!method root
+  #   The configured root.
+  #
+  #   @return (see Metasploit::Model::Configuration#root)
+  #
+  # @!method setup
+  #   Sets up the autoload and i18n paths for the configured gem.
+  #
+  #   @return (see Metasploit::Model::Configuration.setup)
+  #   @raise (see Metasploit::Model::Configuration.setup)
+  delegate :root,
+           :setup,
+           to: :configuration
+end

data/lib/metasploit/model/derivation.rb

@@ -0,0 +1,110 @@
+module Metasploit
+  module Model
+    # Allow to declare that attributes should be derived, which will set the attribute equal to derived_<attribute> if
+    # the attribute is `nil` before validation.  Optionally, it can be checked if the attribute matches the
+    # derived_<attribute> in a validation.
+    #
+    #
+    # @example Full setup
+    #   class Person < ActiveRecord::Base
+    #     include MetasploitDataModels::Derivation
+    #
+    #     #
+    #     # Attributes
+    #     #
+    #
+    #     # @!attributes [rw] first_name
+    #     #   First Name.
+    #     #
+    #     #   @return [String]
+    #
+    #     # @!attribute [rw] full_name
+    #     #   Full name. (Includes first and last name).
+    #     #
+    #     #   @return [String]
+    #
+    #     # @!attribute [rw] last_name
+    #     #   Last name.
+    #     #
+    #     #   @return [String]
+    #
+    #     #
+    #     # Derivations
+    #     #
+    #
+    #     derives :full_name
+    #
+    #     #
+    #     # Methods
+    #     #
+    #
+    #     # Derives {#full_name} from {#first_name} and {#last_name}.
+    #     #
+    #     # @return [String] "<first_name> <last_name>"
+    #     def derive_full_name
+    #       "#{first_name} #{last_name}"
+    #     end
+    #   end
+    module Derivation
+      extend ActiveSupport::Concern
+
+      included do
+        include ActiveModel::Validations
+        include ActiveModel::Validations::Callbacks
+
+        before_validation :derive
+      end
+
+      # Defines class methods include {#derives}, which can be used to declare derived attributes after mixing in
+      # {Metasploit::Model::Derivation}.
+      module ClassMethods
+        # Declares that the attribute should be derived using the derived_<attribute> method if it is `nil` before
+        # validation.
+        #
+        # @param attribute [Symbol] the name of the attribute.
+        # @param options [Hash{Symbol => Boolean}]
+        # @option options [Boolean] :validate (false) If `true`, validates `attribute` using {DerivationValidator}.  If
+        #   `false`, does no validation on `attribute`.
+        # @return [void]
+        def derives(attribute, options={})
+          options.assert_valid_keys(:validate)
+
+          validate = options.fetch(:validate, false)
+          validate_by_derived_attribute[attribute] = validate
+
+          if validate
+            validates attribute, :derivation => true
+          end
+        end
+
+        # Maps a derived attribute (declared with {#derives}) to whether the attribute should validate as a derivation.
+        #
+        # @return [Hash{Symbol => Boolean}]
+        def validate_by_derived_attribute
+          @validate_by_derived_attribute ||= {}
+        end
+      end
+
+      #
+      # Instance Methods
+      #
+
+      private
+
+      # Derives each attribute in {ClassMethods#validate_by_derived_attribute} if the attribute is `nil`.
+      #
+      # @return [void]
+      def derive
+        self.class.validate_by_derived_attribute.each_key do |attribute|
+          value = send(attribute)
+
+          # explicitly check for `nil` in case attribute is Boolean
+          if value.nil?
+            derived_value = send("derived_#{attribute}")
+            send("#{attribute}=", derived_value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metasploit/model/derivation/full_name.rb

@@ -0,0 +1,25 @@
+module Metasploit
+  module Model
+    module Derivation
+      # Methods for deriving full_name from module_type and reference_name in `Mdm::Module::Ancestor`,
+      # `Mdm::Module::Class`, `Metasploit::Framework::Module::Ancestor`, and `Metasploit::Framework::Module::Class`.
+      module FullName
+        # Derives full_name by combining module_type and reference_name in the same way used to create modules using
+        # Msf::ModuleManager#create in metasploit-framework.
+        #
+        # @return [String] <module_type>/<reference_name>
+        # @return [nil] if module_type is `nil`.
+        # @return [nil] if reference_name is `nil`.
+        def derived_full_name
+          derived = nil
+
+          if module_type and reference_name
+            derived = "#{module_type}/#{reference_name}"
+          end
+
+          derived
+        end
+      end
+    end
+  end
+end

data/lib/metasploit/model/email_address.rb

@@ -0,0 +1,128 @@
+module Metasploit
+  module Model
+    # Code shared between `Mdm::EmailAddress` and `Metasploit::Framework::EmailAddress`.
+    module EmailAddress
+      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 :domain, :validate => true
+        derives :full, :validate => true
+        derives :local, :validate => true
+
+        #
+        # Mass Assignment Security
+        #
+
+        attr_accessible :domain
+        attr_accessible :full
+        attr_accessible :local
+
+        #
+        # Search Attributes
+        #
+
+        search_attribute :domain, :type => :string
+        search_attribute :full, :type => :string
+        search_attribute :local, :type => :string
+
+        #
+        # Validations
+        #
+
+        validates :domain, :presence => true
+        validates :local, :presence => true
+      end
+
+      #
+      # Associations
+      #
+
+      # @!attribute [rw] module_authors
+      #   Credits where {#authors} used this email address for {#module_instances modules}.
+      #
+      #   @return [Array<Metasploit::Model::Module::Author>]
+
+      # @!attribute [r] authors
+      #   Authors that used this email address.
+      #
+      #   @return [Array<Metasploit::Model::Author>]
+
+      # @!attribute [r] module_instances
+      #   Modules where this email address was used.
+      #
+      #   @return [Array<Metasploit::Module::Instance>]
+
+      #
+      # Attributes
+      #
+
+      # @!attribute [rw] domain
+      #   The domain part of the email address after the `'@'`.
+      #
+      #   @return [String]
+
+      # @!attribute [rw] full
+      #   The full email address.
+      #
+      #   @return [String] <{#local}>@<{#domain}
+
+      # @!attribute [rw] local
+      #   The local part of the email address before the `'@'`.
+      #
+      #   @return [String]
+
+      #
+      # Methods
+      #
+
+      # Derives {#domain} from {#full}
+      #
+      # @return [String] if {#full} is present
+      # @return [nil] if {#full} is not present
+      def derived_domain
+        domain = nil
+
+        if full.present?
+          _local, domain = full.split('@', 2)
+        end
+
+        domain
+      end
+
+      # Derives {#full} from {#domain} and {#local}
+      #
+      # @return [String]
+      def derived_full
+        if domain.present? && local.present?
+          "#{local}@#{domain}"
+        end
+      end
+
+      # Derives {#local} from {#full}.
+      #
+      # @return [String] if {#full} is present
+      # @return [nil] if {#full} is not present
+      def derived_local
+        local = nil
+
+        if full.present?
+          local, _domain = full.split('@', 2)
+        end
+
+        local
+      end
+    end
+  end
+end