metasploit-model 0.24.1-java

data/app/models/metasploit/model/module/instance/spec/template.rb

@@ -0,0 +1,97 @@
+# Writes templates for the {#module_instance #module_instance's}
+# {Metasploit::Model::Module::Instance#module_class #module_class's} {Metasploit::Model::Module::Class#ancestors} to
+# disk.
+#
+# @example Update files after changing associations
+#   module_instance = FactoryGirl.build(
+#     :dummy_module_instance,
+#     module_architectures_length: 0
+#   )
+#   # factory already wrote template when build returned
+#
+#   # update associations
+#   architecture = FactoryGirl.generate :dummy_architecture
+#   module_instance.module_architectures = FactoryGirl.build_list(
+#     :dummy_module_architecture,
+#     1,
+#     architecture: architecture
+#   )
+#
+#   # Now the template on disk is different than the module_instance, so regenerate the template
+#   Metasploit::Model::Module::Instance::Spec::Template.write(module_instance: module_instance)
+class Metasploit::Model::Module::Instance::Spec::Template < Metasploit::Model::Base
+  extend Metasploit::Model::Spec::Template::Write
+
+  #
+  # Attributes
+  #
+
+  # @!attribute [rw] module_instance
+  #   The {Metasploit::Model::Module::Instance} whose {Metasploit::Model::Module::Instance#module_class} needs to be
+  #   templated in {#class_template}.
+  #
+  #   @return [Metasploit::Model::Module::Instance]
+  attr_accessor :module_instance
+
+  #
+  # Validations
+  #
+
+  validates :class_template,
+            presence: true
+  validates :module_instance,
+            presence: true
+  validate :class_template_valid
+
+  #
+  # Methods
+  #
+
+  # Template for {#module_instance} {Metasploit::Model::Module::Instance#module_class} with the addition of
+  # {#module_instance} to the {Metasploit::Model::Spec::Template#locals} and adding 'module/instances' to the front of
+  # the {Metasploit::Model::Spec::Template#search_pathnames}.
+  #
+  # @return [Metasploit::Model::Module::Class::Spec::Template] if {#module_instance} present.
+  # @return [nil] if {#module_instance} is `nil`.
+  def class_template
+    unless instance_variable_defined? :@class_template
+      if module_instance
+        class_template = Metasploit::Model::Module::Class::Spec::Template.new(
+            module_class: module_instance.module_class
+        )
+        class_template.ancestor_templates.each do |ancestor_template|
+          ancestor_template.locals[:module_instance] = module_instance
+
+          ancestor_template.search_pathnames.unshift(
+              Pathname.new('module/instances')
+          )
+        end
+
+        @class_template = class_template
+      else
+        @class_template = nil
+      end
+    end
+
+    @class_template
+  end
+
+  # @!method write
+  #   Writes {#class_template} to disk.
+  #
+  #   @return [void]
+  #   @raise (see Metasploit::Model::Spec::Template)
+  delegate :write,
+           to: :class_template
+
+  private
+
+  # Validates that {#class_template} is valid when present.
+  #
+  # @return [void]
+  def class_template_valid
+    if class_template && !class_template.valid?
+      errors.add(:class_template, :invalid, value: class_template)
+    end
+  end
+end

data/app/models/metasploit/model/search/group/base.rb

@@ -0,0 +1,21 @@
+# Groups together {Metasploit::Model::Search::Operation::Base operations} and/or or nested groups.
+class Metasploit::Model::Search::Group::Base < Metasploit::Model::Base
+  #
+  # Attributes
+  #
+
+  # @!attribute [rw] children
+  #   {Metasploit::Model::Search::Operation::Base Operations} or nested {Metasploit::Model::Search::Group::Base groups}.
+  #
+  #   @return [Array<Metasploit::Model::Search::Group::Base, Metasploit::Model::Search::Operation::Base>]
+  attr_accessor :children
+
+  #
+  # Validations
+  #
+
+  validates :children,
+            :length => {
+                :minimum => 1
+            }
+end

data/app/models/metasploit/model/search/group/intersection.rb

@@ -0,0 +1,4 @@
+# The intersection (ANDing) of {Metasploit::Model::Search::Operation::Base operations} and/or or nested groups.
+class Metasploit::Model::Search::Group::Intersection < Metasploit::Model::Search::Group::Base
+
+end

data/app/models/metasploit/model/search/group/union.rb

@@ -0,0 +1,4 @@
+# The union (ORing) of {Metasploit::Model::Search::Operation::Base operations} and/or or nested groups.
+class Metasploit::Model::Search::Group::Union < Metasploit::Model::Search::Group::Base
+
+end

data/app/models/metasploit/model/search/operation/base.rb

@@ -0,0 +1,39 @@
+# Base of all search operations that combine an {#operator} with the {#value} it is operating on.  Subclasses allow
+# validations specific to the {#operator} {Metasploit::Model::Search::Operator::Single#type type}.
+class Metasploit::Model::Search::Operation::Base < Metasploit::Model::Base
+  #
+  # Attributes
+  #
+
+  # @!attribute [rw] operator
+  #   The operator operating on {#value}.
+  #
+  #   @return [Metasploit::Model::Search::Operator::Base]
+  attr_accessor :operator
+
+  # @!attribute [rw] value
+  #   The value cast to the correct type from the formatted_value from the formatted operation.
+  #
+  #   @return [String]
+  attr_accessor :value
+
+  #
+  # Validations
+  #
+
+  validates :operator,
+            :presence => true
+  # validate_associated is defined by ActiveRecord, so have to do it manually here.
+  validate :operator_valid
+
+  private
+
+  # Validates that {#operator} is valid
+  #
+  # @return [void]
+  def operator_valid
+    if operator and !operator.valid?
+      errors.add(:operator, :invalid, :value => operator)
+    end
+  end
+end

data/app/models/metasploit/model/search/operation/boolean.rb

@@ -0,0 +1,36 @@
+# Search operation with {Metasploit::Model::Search::Operation::Base#operator} with `#type` `:boolean`.  Validates that
+# value is a proper boolean (`false` or `true`) or the `String` version of either.
+class Metasploit::Model::Search::Operation::Boolean < Metasploit::Model::Search::Operation::Base
+  #
+  # CONSTANTS
+  #
+
+  # Take a String formatted {#value} and returns its unformatted value for validation.
+  FORMATTED_VALUE_TO_VALUE = {
+      'false' => false,
+      'true' => true
+  }
+
+  #
+  # Validations
+  #
+
+  validates :value,
+            :inclusion => {
+                :in => [
+                    false,
+                    true
+                ],
+                :message => :boolean
+            }
+
+  # Sets {Metasploit::Model::Search::Operation::Base#value} by type casting String boolean to actual `false` or `true`.
+  #
+  # @param formatted_value [Object]
+  # @return [false] if `formatted_value` is `'false'`.
+  # @return [true] if `formatted_value` is `'true'`.
+  # @return [Object] `formatted_value` otherwise.
+  def value=(formatted_value)
+    @value = FORMATTED_VALUE_TO_VALUE.fetch(formatted_value, formatted_value)
+  end
+end

data/app/models/metasploit/model/search/operation/date.rb

@@ -0,0 +1,37 @@
+# Search operation with {Metasploit::Model::Search::Operation::Base#operator} with `#type` ':date'.  Validates that
+# value is `String` that can parsed with `Date.parse` or already a `Date`.
+class Metasploit::Model::Search::Operation::Date < Metasploit::Model::Search::Operation::Base
+  #
+  # Validations
+  #
+
+  validate :date_value
+
+  #
+  # Methods
+  #
+
+  # Sets {Metasploit::Model::Search::Operation::Base#value} by type casting String to actual Date.
+  #
+  # @param formatted_value [#to_s]
+  # @return [Date] if `formatted_value.to_s` is parseable with `Date.parse`.
+  # @return [#to_s] `formatted_value` if `formatted_value` is not parseable with `Date.parse`.
+  def value=(formatted_value)
+    begin
+      @value = Date.parse(formatted_value.to_s)
+    rescue ArgumentError
+      @value = formatted_value
+    end
+  end
+
+  private
+
+  # Validates that {#value} is a `Date`.
+  #
+  # @return [void]
+  def date_value
+    unless value.is_a? Date
+      errors.add(:value, :unparseable_date)
+    end
+  end
+end

data/app/models/metasploit/model/search/operation/integer.rb

@@ -0,0 +1,14 @@
+# Search operation with {Metasploit::Model::Search::Operation::Base#operator} with `#type` `:integer`.  Validates that
+# value is an integer.
+class Metasploit::Model::Search::Operation::Integer < Metasploit::Model::Search::Operation::Base
+  include Metasploit::Model::Search::Operation::Integer::Value
+
+  #
+  # Validations
+  #
+
+  validates :value,
+            :numericality => {
+                :only_integer => true
+            }
+end

data/app/models/metasploit/model/search/operation/null.rb

@@ -0,0 +1,26 @@
+# Operation that uses a {Metasploit::Model::Search::Operation::Null null operator}.
+class Metasploit::Model::Search::Operation::Null < Metasploit::Model::Search::Operation::Base
+  #
+  # Validations
+  #
+
+  validate :null_operator
+
+  #
+  # Methods
+  #
+
+  private
+
+  # Validates that {Metasploit::Model::Search::Operation::Base#operator} is a
+  # {Metasploit::Model::Search::Operator::Null}, as {Metasploit::Model::Search::Operation::Null} won't validate
+  # correctly (and be invalid) if {Metasploit::Model::Search::Operation::Base#operator} is not a
+  # {Metasploit::Model::Search::Operator::Null}.
+  #
+  # @return [void]
+  def null_operator
+    unless operator.is_a? Metasploit::Model::Search::Operator::Null
+      errors.add(:operator, :type, :type => Metasploit::Model::Search::Operator::Null)
+    end
+  end
+end

data/app/models/metasploit/model/search/operation/set.rb

@@ -0,0 +1,34 @@
+# Operation on an attribute that has a constrained Set of valid
+# {Metasploit::Model::Search::Operation::Base#value values}.
+class Metasploit::Model::Search::Operation::Set < Metasploit::Model::Search::Operation::Base
+  #
+  # Validations
+  #
+
+  validate :membership
+
+  private
+
+  # Validates that {#value} is a member of {Metasploit::Model::Search::Operation::Base#operator}
+  # {Metasploit::Model::Search::Operator::Attribute#attribute_set}.
+  #
+  # @return [void]
+  def membership
+    if operator
+      attribute_set = operator.attribute_set
+
+      unless attribute_set.include? value
+        # sort (because Sets are unordered) before inspecting so that lexigraphical sorting is NOT used
+        sorted = attribute_set.sort
+        # use inspect to differentiate between strings and integers or string and symbols
+        inspected = sorted.map(&:inspect)
+
+        # format as a human readable Set using { }
+        comma_separated = inspected.join(', ')
+        human_set = "{#{comma_separated}}"
+
+        errors.add(:value, :inclusion, set: human_set)
+      end
+    end
+  end
+end

data/app/models/metasploit/model/search/operation/set/integer.rb

@@ -0,0 +1,5 @@
+# Search operation on an attribute that has a `Set<Integer>` for acceptable
+# {Metasploit::Model::Search::Operation::Base values}.
+class Metasploit::Model::Search::Operation::Set::Integer < Metasploit::Model::Search::Operation::Set
+  include Metasploit::Model::Search::Operation::Integer::Value
+end

data/app/models/metasploit/model/search/operation/set/string.rb

@@ -0,0 +1,5 @@
+# Search operation on an attribute that has a `Set<String>` for acceptable
+# {Metasploit::Model::Search::Operation::Base values}.
+class Metasploit::Model::Search::Operation::Set::String < Metasploit::Model::Search::Operation::Set
+  include Metasploit::Model::Search::Operation::String::Value
+end

data/app/models/metasploit/model/search/operation/string.rb

@@ -0,0 +1,11 @@
+# Search operation with {Metasploit::Model::Search::Operation::Base#operator} with `#type` `:string`.
+class Metasploit::Model::Search::Operation::String < Metasploit::Model::Search::Operation::Base
+  include Metasploit::Model::Search::Operation::String::Value
+
+  #
+  # Validations
+  #
+
+  validates :value,
+            :presence => true
+end

data/app/models/metasploit/model/search/operation/union.rb

@@ -0,0 +1,59 @@
+# A union of one or more {#children child operations} from an operator's `#operate_on`, should be visited the same as
+# {Metasploit::Model::Search::Group::Base}.
+class Metasploit::Model::Search::Operation::Union < Metasploit::Model::Search::Operation::Base
+  #
+  # Attributes
+  #
+
+  # @!attribute [rw] children
+  #   Children operations of union.
+  #
+  #   @return [Array<Metasploit::Model::Search::Operation::Base>]
+  attr_writer :children
+
+  #
+  #
+  # Validations
+  #
+  #
+
+  #
+  # Method Validations
+  #
+
+  # validate_associated is defined by ActiveRecord, so have to do it manually here.
+  validate :children_valid
+
+  #
+  # Attribute Validations
+  #
+
+  validates :children,
+            :length => {
+                :minimum => 1
+            }
+
+  #
+  # Methods
+  #
+
+  def children
+    @children ||= []
+  end
+
+  private
+
+  # Validates that {#children} are valid
+  #
+  # @return [void]
+  def children_valid
+    if children.is_a? Enumerable
+      # can't use children.all?(&:valid?) as it will short-circuit and want all children to have validation errors
+      valids = children.map(&:valid?)
+
+      unless valids.all?
+        errors.add(:children, :invalid, value: children)
+      end
+    end
+  end
+end

data/app/models/metasploit/model/search/operator/association.rb

@@ -0,0 +1,43 @@
+# A search operator declared with
+# {Metasploit::Model::Search::Association::ClassMethods#search_association search_association}.
+class Metasploit::Model::Search::Operator::Association < Metasploit::Model::Search::Operator::Single
+  #
+  # Attributes
+  #
+
+  # @!attribute [rw] association
+  #   The association on which {Metasploit::Model::Search::Operator::Attribute#attribute} is declared searchable.
+  #
+  #   @return [Symbol] association on {Metasploit::Model::Search::Operator::Base#klass klass}.
+  attr_accessor :association
+
+  # @!attribute [rw] attribute_operator
+  #   The {Metasploit::Model::Search::Operator::Attribute operator} as declared on the {#association} class.
+  #
+  #   @return [Metasploit::Model::Search::Operator::Attribute]
+  attr_accessor :attribute_operator
+
+  #
+  # Validations
+  #
+
+  validates :association, :presence => true
+  validates :attribute_operator, :presence => true
+
+  #
+  # Methods
+  #
+
+  delegate :attribute,
+           :attribute_set,
+           :help,
+           :type,
+           :to => :attribute_operator
+
+  # The name of this operator.
+  #
+  # @return [String] <association>.<attribute>
+  def name
+    @name ||= "#{association}.#{attribute}".to_sym
+  end
+end