wg-metasploit_data_models 4.1.4.01 → 4.1.4.02

data/spec/spec_helper.rb

@@ -0,0 +1,148 @@
+# Configure Rails Environment
+ENV['RAILS_ENV'] = 'test'
+
+require 'rubygems'
+require 'bundler'
+Bundler.setup(:default, :test)
+
+# Require simplecov before loading ..dummy/config/environment.rb because it will cause metasploit_data_models/lib to
+# be loaded, which would result in Coverage not recording hits for any of the files.
+require 'simplecov'
+require 'coveralls'
+
+# if ENV['TRAVIS'] == 'true'
+#   # don't generate local report as it is inaccessible on travis-ci, which is why coveralls is being used.
+#   SimpleCov.formatter = Coveralls::SimpleCov::Formatter
+# else
+  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new([
+      # either generate the local report
+      SimpleCov::Formatter::HTMLFormatter
+  ])
+# end
+
+require File.expand_path('../dummy/config/environment.rb',  __FILE__)
+require 'rspec/rails'
+
+# full backtrace in logs so its easier to trace errors
+Rails.backtrace_cleaner.remove_silencers!
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+
+Dir["./spec/support/**/*.rb"].sort.each { |f| require f}
+
+roots = [
+    Metasploit::Concern::Engine.root,
+    Metasploit::Model::Engine.root,
+    MetasploitDataModels::Engine.root
+]
+
+roots.each do |root|
+  support_glob = File.join(root, 'spec', 'support', '**', '*.rb')
+
+  Dir.glob(support_glob) do |path|
+    require path
+  end
+end
+
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+
+  config.use_transactional_fixtures = true
+
+  # rspec-rails 3 will no longer automatically infer an example group's spec type
+  # from the file location. You can explicitly opt-in to the feature using this
+  # config option.
+  # To explicitly tag specs without using automatic inference, set the `:type`
+  # metadata manually:
+  #
+  #     describe ThingsController, :type => :controller do
+  #       # Equivalent to being in spec/controllers
+  #     end
+  config.infer_spec_type_from_file_location!
+
+  # Setting this config option `false` removes rspec-core's monkey patching of the
+  # top level methods like `describe`, `shared_examples_for` and `shared_context`
+  # on `main` and `Module`. The methods are always available through the `RSpec`
+  # module like `RSpec.describe` regardless of this setting.
+  # For backwards compatibility this defaults to `true`.
+  #
+  # https://relishapp.com/rspec/rspec-core/v/3-0/docs/configuration/global-namespace-dsl
+  config.expose_dsl_globally = false
+end
+
+Shoulda::Matchers.configure do |config|
+  config.integrate do |with|
+    with.library :active_record
+    with.library :active_model
+
+    with.test_framework :rspec
+  end
+end

data/spec/support/matchers/match_regex_exactly.rb

@@ -0,0 +1,28 @@
+# Checks that the string matches the
+RSpec::Matchers.define :match_string_exactly do |string|
+  failure_message do |regexp|
+    match = regexp.match(string)
+
+    failure_message = "expected #{regexp} to match #{string}"
+
+    if match
+      failure_message << ', but'
+
+      unless match.pre_match.empty?
+        failure_message << " pre-match is #{match.pre_match}"
+      end
+
+      unless match.post_match.empty?
+        failure_message << " post-match is #{match.post_match}"
+      end
+    end
+
+    failure_message
+  end
+
+  match do |regexp|
+    match = regexp.match(string)
+
+    match && match.pre_match.empty? && match.post_match.empty?
+  end
+end

data/spec/support/shared/contexts/rex/text.rb

@@ -0,0 +1,15 @@
+RSpec.shared_context 'Rex::Text' do
+  before(:example) do
+    rex_text = Module.new do
+      def self.ascii_safe_hex(str, whitespace=false)
+        if whitespace
+          str.gsub(/([\x00-\x20\x80-\xFF])/n){ |x| "\\x%.2x" % x.unpack("C*")[0] }
+        else
+          str.gsub(/([\x00-\x08\x0b\x0c\x0e-\x1f\x80-\xFF])/n){ |x| "\\x%.2x" % x.unpack("C*")[0]}
+        end
+      end
+    end
+
+    stub_const('Rex::Text', rex_text)
+  end
+end

data/spec/support/shared/examples/coerces_inet_column_type_to_string.rb

@@ -0,0 +1,15 @@
+RSpec.shared_examples_for 'coerces inet column type to string' do |column|
+  raise ArgumentError, 'must pass the column name' unless column
+
+  context 'with an inet column' do
+    let(:address) { '10.0.0.1' }
+
+    before(:example) do
+      subject.update_attribute column, address
+    end
+
+    it 'should cast the column as a string when fetching from the database' do
+      expect(subject.send(column)).to eq(address)
+    end
+  end
+end

data/spec/support/shared/examples/mdm/module/detail/does_not_support_stance_with_mtype.rb

@@ -0,0 +1,20 @@
+RSpec.shared_examples_for 'Mdm::Module::Detail does not support stance with mtype' do |mtype|
+  context "with #{mtype.inspect}" do
+    # define as a let so that lets from outer context can access option to set detail.
+    let(:mtype) do
+      mtype
+    end
+
+    it 'should return false for supports_stance?' do
+      expect(detail.supports_stance?).to eq(false)
+    end
+
+    context 'with nil stance' do
+      let(:stance) do
+        nil
+      end
+
+      it { is_expected.to be_valid }
+    end
+  end
+end

data/spec/support/shared/examples/mdm/module/detail/supports_stance_with_mtype.rb

@@ -0,0 +1,36 @@
+RSpec.shared_examples_for 'Mdm::Module::Detail supports stance with mtype' do |mtype|
+  context "with #{mtype.inspect}" do
+    # define as a let so that lets from outer context can access option to set detail.
+    let(:mtype) do
+      mtype
+    end
+
+    it 'should return true for supports_stance?' do
+      expect(detail.supports_stance?).to eq(true)
+    end
+
+    context 'with nil stance' do
+      let(:stance) do
+        nil
+      end
+
+      it { is_expected.to be_invalid }
+    end
+
+    context "with 'aggresive' stance" do
+      let(:stance) do
+        'aggressive'
+      end
+
+      it { is_expected.to be_valid }
+    end
+
+    context "with 'passive' stance" do
+      let(:stance) do
+        'passive'
+      end
+
+      it { is_expected.to be_valid }
+    end
+  end
+end

data/spec/support/shared/examples/metasploit_data_models/search/operation/ipaddress/match.rb

@@ -0,0 +1,109 @@
+RSpec.shared_examples_for 'MetasploitDataModels::Search::Operation::IPAddress::*.match' do |options={}|
+  options.assert_valid_keys(4, 6)
+
+  subject(:match) {
+    described_class.match(formatted_value)
+  }
+
+  #
+  # Shared Examples
+  #
+
+  shared_examples_for 'match' do |boolean|
+    if boolean
+      it { is_expected.to be_a described_class }
+
+      it 'does not set #operator' do
+        expect(match.operator).to be_nil
+      end
+
+      it 'sets #value' do
+        expect(match.value).not_to be_nil
+      end
+    else
+      it { is_expected.to be_nil }
+    end
+  end
+
+  context 'with IPv4' do
+    ipv4 = options.fetch(4, [])
+    ipv4 = Set.new Array.wrap(ipv4)
+
+    key_set = Set.new([:cidr, :nmap, :range, :single])
+
+    unless key_set.superset?(ipv4)
+      unknown_keys = ipv4 - key_set
+
+      raise ArgumentError, "keys (#{unknown_keys.sort.to_sentence}) not in known keys (#{key_set.sort.to_sentence})"
+    end
+
+    context 'with CIDR' do
+      let(:formatted_value) {
+        '1.2.3.4/24'
+      }
+
+      it_should_behave_like 'match', ipv4.include?(:cidr)
+    end
+
+    context 'with NMAP' do
+      let(:formatted_value) {
+        '1-2,4.5,6-7.8-9,10-11.12,13'
+      }
+
+      it_should_behave_like 'match', ipv4.include?(:nmap)
+    end
+
+    context 'with range' do
+      let(:formatted_value) {
+        '1.2.3.4-5.6.7.8'
+      }
+
+      it_should_behave_like 'match', ipv4.include?(:range)
+    end
+
+    context 'with single' do
+      let(:formatted_value) {
+        '1.2.3.4'
+      }
+
+      it_should_behave_like 'match', ipv4.include?(:single)
+    end
+  end
+
+  context 'with IPv6' do
+    ipv6 = options.fetch(6, [])
+    ipv6 = Set.new Array.wrap(ipv6)
+
+    key_set = Set.new([:cidr, :range, :single])
+
+    unless key_set.superset?(ipv6)
+      unknown_keys = ipv6 - key_set
+
+      raise ArgumentError, "keys (#{unknown_keys.sort.to_sentence}) not in known keys (#{key_set.sort.to_sentence})"
+    end
+
+    context 'with CIDR' do
+      let(:formatted_value) {
+        '1:2:3:4:5:6:7:8/48'
+      }
+
+      it_should_behave_like 'match', ipv6.include?(:cidr)
+    end
+
+    context 'with range' do
+      let(:formatted_value) {
+        '1:2:3:4:5:6:7:8-9:10:11:12:13:14:15:16'
+      }
+
+      it_should_behave_like 'match', ipv6.include?(:range)
+    end
+
+    context 'with single' do
+      let(:formatted_value) {
+        '1:2:3:4:5:6:7:8'
+      }
+
+      it_should_behave_like 'match', ipv6.include?(:single)
+    end
+  end
+end

data/spec/support/shared/examples/metasploit_data_models/search/visitor/includes/visit/with_children.rb

@@ -0,0 +1,38 @@
+RSpec.shared_examples_for 'MetasploitDataModels::Search::Visitor::Includes#visit with #children' do
+  let(:children) do
+    2.times.collect { |n|
+      double("Child #{n}")
+    }
+  end
+
+  let(:node) do
+    node_class.new(
+        :children => children
+    )
+  end
+
+  it 'should visit each child' do
+    # needed for call to visit subject
+    expect(visitor).to receive(:visit).with(node).and_call_original
+
+    children.each do |child|
+      expect(visitor).to receive(:visit).with(child).and_return([])
+    end
+
+    visit
+  end
+
+  it 'should return Array of all child visits' do
+    child_visits = []
+
+    expect(visitor).to receive(:visit).with(node).and_call_original
+
+    children.each_with_index do |child, i|
+      child_visit = ["Visited Child #{i}"]
+      allow(visitor).to receive(:visit).with(child).and_return(child_visit)
+      child_visits.concat(child_visit)
+    end
+
+    expect(visit).to eq(child_visits)
+  end
+end

data/spec/support/shared/examples/metasploit_data_models/search/visitor/includes/visit/with_metasploit_model_search_operation_base.rb

@@ -0,0 +1,26 @@
+RSpec.shared_examples_for 'MetasploitDataModels::Search::Visitor::Includes#visit with Metasploit::Model::Search::Operation::Base' do
+  let(:operator) do
+    double('Operation Operator')
+  end
+
+  let(:node) do
+    node_class.new(
+        :operator => operator
+    )
+  end
+
+  it 'should visit operator' do
+    expect(visitor).to receive(:visit).with(node).and_call_original
+    expect(visitor).to receive(:visit).with(operator).and_return([])
+
+    visit
+  end
+
+  it 'should return operator visit' do
+    operator_visit = ["Visited Operator"]
+    expect(visitor).to receive(:visit).with(node).and_call_original
+    allow(visitor).to receive(:visit).with(operator).and_return(operator_visit)
+
+    expect(visit).to eq(operator_visit)
+  end
+end

data/spec/support/shared/examples/metasploit_data_models/search/visitor/relation/visit/matching_record.rb

@@ -0,0 +1,50 @@
+RSpec.shared_examples_for 'MetasploitDataModels::Search::Visitor::Relation#visit matching record' do |options={}|
+  options.assert_valid_keys(:attribute, :association)
+
+  attribute = options.fetch(:attribute)
+  association = options[:association]
+
+  def self.nested_hash_to_array(association)
+    case association
+      when Hash
+        hash = association
+        keys = hash.keys
+
+        unless keys.length == 1
+          raise ArgumentError, 'Only single key Hashes are allowed to nest associations'
+        end
+
+        parent_association = keys.first
+        child_association = hash[parent_association]
+
+        [parent_association, *nested_hash_to_array(child_association)]
+      when Symbol
+        [association]
+      when nil
+        []
+      else
+        raise TypeError, "Cannot convert #{association.class} (#{association}) to array"
+    end
+  end
+
+  associations = nested_hash_to_array(association)
+  messages = [*associations, attribute]
+  formatted_operator = messages.map(&:to_s).join('.')
+
+  context "with #{formatted_operator}" do
+    let(:formatted) do
+      "#{formatted_operator}:\"#{value}\""
+    end
+
+    let(:value) do
+      messages.inject(matching_record) { |instance, message|
+        # wrap in array so singel and plural associatins can be handled the same
+        Array.wrap(instance.send(message)).first
+      }
+    end
+
+    it 'should find only matching record' do
+      expect(visit).to match_array([matching_record])
+    end
+  end
+end

data/spec/support/shared/examples/metasploit_data_models/search/visitor/where/visit/with_equality.rb

@@ -0,0 +1,34 @@
+RSpec.shared_examples_for 'MetasploitDataModels::Search::Visitor::Where#visit with equality operation' do
+  let(:node) do
+    node_class.new(
+        :operator => operator,
+        :value => value
+    )
+  end
+
+  let(:operator) do
+    Metasploit::Model::Search::Operator::Attribute.new(
+        # any class that responds to arel_table
+        :klass => Mdm::Host
+    )
+  end
+
+  let(:value) do
+    "value"
+  end
+
+  it 'should visit operation.operator with attribute_visitor' do
+    expect(visitor.attribute_visitor).to receive(:visit).with(operator).and_call_original
+
+    visit
+  end
+
+  it 'should call eq on Arel::Attributes::Attribute from attribute_visitor' do
+    attribute = double('Visited Operator')
+    allow(visitor.attribute_visitor).to receive(:visit).with(operator).and_return(attribute)
+
+    expect(attribute).to receive(:eq).with(value)
+
+    visit
+  end
+end

data/spec/support/shared/examples/metasploit_data_models/search/visitor/where/visit/with_metasploit_model_search_group_base.rb

@@ -0,0 +1,51 @@
+RSpec.shared_examples_for 'MetasploitDataModels::Search::Visitor::Where#visit with Metasploit::Model::Search*::Group::Base' do |options={}|
+  options.assert_valid_keys(:arel_class)
+
+  arel_class = options.fetch(:arel_class)
+
+  let(:children) do
+    2.times.collect { |n|
+      double("Group Child #{n}")
+    }
+  end
+
+  let(:node) do
+    node_class.new(
+        :children => children
+    )
+  end
+
+  it 'should visit each child' do
+    expect(visitor).to receive(:visit).with(node).and_call_original
+
+    children.each do |child|
+      expect(visitor).to receive(:visit).with(child).and_return(Arel::Nodes::Equality.new(1, 1))
+    end
+
+    visit
+  end
+
+  it "should combine children AREL with #{arel_class}" do
+    allow(visitor).to receive(:visit).with(node).and_call_original
+    child_visits = []
+
+    children.each_with_index do |child, i|
+      child_visit = Arel::Nodes::Equality.new(i, i)
+      allow(visitor).to receive(:visit).with(child).and_return(child_visit)
+      child_visits << child_visit
+    end
+
+    root = visit
+
+    if root.is_a? Arel::Nodes::Grouping
+      arel_pair = root.expr
+    else
+      arel_pair = root
+    end
+
+    expect(arel_pair).to be_a arel_class
+
+    expect(arel_pair.left).to eq(child_visits[0])
+    expect(arel_pair.right).to eq(child_visits[1])
+  end
+end