wg-metasploit_data_models 4.1.4.01 → 4.1.4.02

data/spec/app/models/mdm/workspace_spec.rb

@@ -0,0 +1,500 @@
+RSpec.describe Mdm::Workspace, type: :model do
+  subject(:workspace) do
+    FactoryBot.build(:mdm_workspace)
+  end
+
+  let(:default) do
+    'default'
+  end
+
+  it_should_behave_like 'Metasploit::Concern.run'
+
+  context 'factory' do
+    it 'should be valid' do
+      workspace = FactoryBot.build(:mdm_workspace)
+      expect(workspace).to be_valid
+    end
+  end
+
+  context '#destroy' do
+    it 'should successfully destroy the object and dependent objects' do
+      workspace = FactoryBot.create(:mdm_workspace)
+      listener = FactoryBot.create(:mdm_listener, :workspace => workspace)
+      task = FactoryBot.create(:mdm_task, :workspace => workspace)
+
+      expect {
+        workspace.destroy
+      }.to_not raise_error
+      expect {
+        workspace.reload
+      }.to raise_error(ActiveRecord::RecordNotFound)
+      expect {
+        listener.reload
+      }.to raise_error(ActiveRecord::RecordNotFound)
+      expect {
+        task.reload
+      }.to raise_error(ActiveRecord::RecordNotFound)
+    end
+  end
+
+  context 'associations' do
+    it { is_expected.to have_many(:clients).class_name('Mdm::Client').through(:hosts) }
+    it { is_expected.to have_many(:creds).class_name('Mdm::Cred').through(:services) }
+    it { is_expected.to have_many(:events).class_name('Mdm::Event') }
+    it { is_expected.to have_many(:exploited_hosts).class_name('Mdm::ExploitedHost').through(:hosts) }
+    it { is_expected.to have_many(:hosts).class_name('Mdm::Host') }
+    it { is_expected.to have_many(:listeners).class_name('Mdm::Listener').dependent(:destroy) }
+    it { is_expected.to have_many(:loots).class_name('Mdm::Loot').through(:hosts) }
+    it { is_expected.to have_many(:notes).class_name('Mdm::Note') }
+    it { is_expected.to belong_to(:owner).class_name('Mdm::User').with_foreign_key('owner_id') }
+    it { is_expected.to have_many(:services).class_name('Mdm::Service').through(:hosts).with_foreign_key('service_id') }
+    it { is_expected.to have_many(:sessions).class_name('Mdm::Session').through(:hosts) }
+    it { is_expected.to have_many(:tasks).class_name('Mdm::Task').dependent(:destroy).order('created_at DESC') }
+    it { is_expected.to have_and_belong_to_many(:users).class_name('Mdm::User') }
+    it { is_expected.to have_many(:vulns).class_name('Mdm::Vuln').through(:hosts) }
+  end
+
+  context 'callbacks' do
+    context 'before_save' do
+      context '#normalize' do
+        it 'should be called' do
+          expect(workspace).to receive(:normalize)
+          workspace.run_callbacks(:save)
+        end
+      end
+    end
+  end
+
+  context 'columns' do
+    it { is_expected.to have_db_column(:boundary).of_type(:string).with_options(:limit => 4 * (2 ** 10)) }
+    it { is_expected.to have_db_column(:description).of_type(:string).with_options(:limit => 4 * (2 ** 10)) }
+    it { is_expected.to have_db_column(:limit_to_network).of_type(:boolean).with_options(:default => false, :null => false) }
+    it { is_expected.to have_db_column(:name).of_type(:string) }
+    it { is_expected.to have_db_column(:owner_id).of_type(:integer) }
+
+    context 'timestamps' do
+      it { is_expected.to have_db_column(:created_at).of_type(:datetime).with_options(:null => false) }
+      it { is_expected.to have_db_column(:updated_at).of_type(:datetime).with_options(:null => false) }
+    end
+  end
+
+  context 'CONSTANTS' do
+    it 'should define the DEFAULT name' do
+      expect(described_class::DEFAULT).to eq(default)
+    end
+  end
+
+  context 'validations' do
+    context 'description' do
+      it { is_expected.to validate_length_of(:description).is_at_most(4 * (2 ** 10)) }
+    end
+
+    context 'name' do
+      it { is_expected.to validate_length_of(:name).is_at_most(2**8 - 1) }
+      it { is_expected.to validate_presence_of :name }
+      it { is_expected.to validate_uniqueness_of :name }
+    end
+  end
+
+  context 'methods' do
+    let(:hosts) do
+      FactoryBot.create_list(:mdm_host, 2, :workspace => workspace)
+    end
+
+    let(:other_hosts) do
+      FactoryBot.create_list(:mdm_host, 2, :workspace => other_workspace)
+    end
+
+    let(:other_services) do
+      other_hosts.collect do |host|
+        FactoryBot.create(:mdm_service, :host => host)
+      end
+    end
+
+    let(:other_web_sites) do
+      other_services.collect { |service|
+        FactoryBot.create(:mdm_web_site, :service => service)
+      }
+    end
+
+    let(:other_workspace) do
+      FactoryBot.create(:mdm_workspace)
+    end
+
+    let(:services) do
+      hosts.collect do |host|
+        FactoryBot.create(:mdm_service, :host => host)
+      end
+    end
+
+    let(:web_sites) do
+      services.collect { |service|
+        FactoryBot.create(:mdm_web_site, :service => service)
+      }
+    end
+
+    context '#creds' do
+      #
+      # Let!s (let + before(:each))
+      #
+
+      let!(:creds) do
+        services.collect do |service|
+          FactoryBot.create(:mdm_cred, :service => service)
+        end
+      end
+
+      let!(:other_creds) do
+        other_services.collect do |service|
+          FactoryBot.create(:mdm_cred, :service => service)
+        end
+      end
+
+      it 'should be an ActiveRecord::Relation' do
+        expect(workspace.creds).to be_a ActiveRecord::Relation
+      end
+
+      it 'should include services' do
+        # to_a to make query return instances
+        found_creds = workspace.creds.to_a
+
+        expect(found_creds.length).to be > 0
+
+        expect(
+            found_creds.none? { |found_cred|
+              found_cred.service.nil?
+            }
+        ).to eq(true)
+      end
+
+      it 'should return only Mdm::Creds from hosts in workspace' do
+        found_creds = workspace.creds
+
+        expect(found_creds.length).to eq(creds.length)
+
+        expect(
+            found_creds.all? { |cred|
+              cred.service.host.workspace == workspace
+            }
+        ).to eq(true)
+      end
+    end
+
+    context 'default' do
+      context 'with default workspace' do
+        before(:example) do
+          FactoryBot.create(
+              :mdm_workspace,
+              :name => default
+          )
+        end
+
+        it 'should not create workspace' do
+          workspace = nil
+
+          expect {
+            workspace = described_class.default
+          }.to change(Mdm::Workspace, :count).by(0)
+
+          expect(workspace).to be_default
+        end
+      end
+
+      context 'without default workspace' do
+        it 'should create workspace' do
+          workspace = nil
+
+          expect {
+            workspace = described_class.default
+          }.to change(Mdm::Workspace, :count).by(1)
+
+          expect(workspace).to be_default
+        end
+      end
+    end
+
+    context '#default?' do
+      subject do
+        workspace.default?
+      end
+
+      context 'with DEFAULT name' do
+        before(:example) do
+          workspace.name = default
+        end
+
+        it { is_expected.to eq(true) }
+      end
+
+      context 'without DEFAULT name' do
+        it { is_expected.to eq(false) }
+      end
+    end
+
+    context '#each_cred' do
+      it 'should pass each of the #creds to the block' do
+        creds = FactoryBot.create_list(:mdm_cred, 2)
+        allow(workspace).to receive(:creds).and_return(creds)
+
+        expect { |block|
+          workspace.each_cred(&block)
+        }.to yield_successive_args(*creds)
+      end
+    end
+
+    context '#each_host_tag' do
+      it 'should pass each of the #host_tags to the block' do
+        tags = FactoryBot.create_list(:mdm_tag, 2)
+        expect(workspace).to receive(:host_tags).and_return(tags)
+
+        expect { |block|
+          workspace.each_host_tag(&block)
+        }.to yield_successive_args(*tags)
+      end
+    end
+
+    context '#host_tags' do
+      let(:host_tags) do
+        workspace.host_tags
+      end
+
+      #
+      # lets
+      #
+
+      let(:other_tags) do
+        FactoryBot.create_list(
+            :mdm_tag,
+            2
+        )
+      end
+
+      let(:tags) do
+        FactoryBot.create_list(
+            :mdm_tag,
+            2
+        )
+      end
+
+      #
+      # Let!s (let + before(:each))
+      #
+
+      let!(:first_host_tags) do
+        host_tags = []
+
+        hosts.zip(tags) do |host, tag|
+          host_tag = FactoryBot.create(:mdm_host_tag, :host => host, :tag => tag)
+
+          host_tags << host_tag
+        end
+
+        host_tags
+      end
+
+      let!(:second_host_tags) do
+        host_tags = []
+
+        other_hosts.zip(other_tags) do |host, tag|
+          host_tag = FactoryBot.create(:mdm_host_tag, :host => host, :tag => tag)
+
+          host_tags << host_tag
+        end
+
+        host_tags
+      end
+
+      it 'should return an ActiveRecord::Relation' do
+        expect(workspace.host_tags).to be_a ActiveRecord::Relation
+      end
+
+      it 'should return only Mdm::Tags from hosts in the workspace' do
+        expect(host_tags.length).to eq(tags.length)
+
+        expect(
+            host_tags.all? { |tag|
+              tag.hosts.any? { |host|
+                host.workspace == workspace
+              }
+            }
+        ).to eq(true)
+      end
+    end
+
+    context '#normalize' do
+      let(:normalize) do
+        workspace.send(:normalize)
+      end
+
+      before(:example) do
+        workspace.boundary = boundary
+      end
+
+      context 'with boundary' do
+        let(:boundary) do
+          " #{stripped_boundary} "
+        end
+
+        let(:stripped_boundary) do
+          '192.168.0.1'
+        end
+
+        it "should remove spaces" do
+          normalize
+
+          expect(workspace.boundary).to eq(stripped_boundary)
+        end
+      end
+
+      context 'without boundary' do
+        let(:boundary) do
+          nil
+        end
+
+        it 'should not raise error' do
+          expect {
+            normalize
+          }.to_not raise_error
+        end
+      end
+    end
+
+    context '#web_forms' do
+
+      subject do
+        workspace.web_forms
+      end
+
+      #
+      # Let!s (let + before(:each))
+      #
+
+      let!(:other_web_forms) do
+        other_web_sites.collect { |web_site|
+          FactoryBot.create(:web_form, :web_site => web_site)
+        }
+      end
+
+      let!(:web_forms) do
+        web_sites.collect { |web_site|
+          FactoryBot.create(:web_form, :web_site => web_site)
+        }
+      end
+
+      it 'should return an ActiveRecord:Relation' do
+        is_expected.to be_a ActiveRecord::Relation
+      end
+
+      it 'should return only Mdm::WebPages from hosts in the workspace' do
+        found_web_forms = workspace.web_forms
+
+        expect(found_web_forms.length).to eq(web_forms.length)
+
+        expect(
+            found_web_forms.all? { |web_form|
+              web_form.web_site.service.host.workspace == workspace
+            }
+        ).to eq(true)
+      end
+    end
+
+    context '#web_sites' do
+      subject do
+        workspace.web_sites
+      end
+
+      #
+      # Let!s (let + before(:each))
+      #
+
+      before(:example) do
+        other_web_sites
+        web_sites
+      end
+
+      it 'should return an ActiveRecord:Relation' do
+        is_expected.to be_a ActiveRecord::Relation
+      end
+
+      it 'should return only Mdm::WebVulns from hosts in the workspace' do
+        # there are more web sites than those in the workspace
+        expect(Mdm::WebSite.count).to be > web_sites.count
+
+        found_web_sites = workspace.web_sites
+
+        expect(found_web_sites.length).to eq(web_sites.count)
+
+        expect(
+            found_web_sites.all? { |web_site|
+              web_site.service.host.workspace == workspace
+            }
+        ).to eq(true)
+      end
+    end
+
+    context '#web_vulns' do
+      subject do
+        workspace.web_vulns
+      end
+
+      #
+      # Let!s (let + before(:each))
+      #
+
+      let!(:other_web_vulns) do
+        other_web_sites.collect { |web_site|
+          FactoryBot.create(:mdm_web_vuln, :web_site => web_site)
+        }
+      end
+
+      let!(:web_vulns) do
+        web_sites.collect { |web_site|
+          FactoryBot.create(:mdm_web_vuln, :web_site => web_site)
+        }
+      end
+
+      it 'should return an ActiveRecord:Relation' do
+        is_expected.to be_a ActiveRecord::Relation
+      end
+
+      it 'should return only Mdm::WebVulns from hosts in the workspace' do
+        expect(Mdm::WebVuln.count).to be > web_vulns.length
+
+        found_web_vulns = workspace.web_vulns
+
+        expect(found_web_vulns.length).to eq(web_vulns.length)
+
+        expect(
+            found_web_vulns.all? { |web_vuln|
+              web_vuln.web_site.service.host.workspace == workspace
+            }
+        ).to eq(true)
+      end
+    end
+
+    context '#web_unique_forms' do
+      let(:rejected_address) do
+        hosts[1].address
+      end
+
+      let(:selected_address) do
+        hosts[0].address
+      end
+
+      it 'should return an ActiveRecord:Relation',
+         :pending => 'https://www.pivotaltracker.com/story/show/43219917' do
+        is_expected.to be_a ActiveRecord::Relation
+      end
+
+      it "should reject #unique_web_forms from host addresses that aren't in addresses" do
+        web_forms = workspace.web_unique_forms([selected_address])
+
+        expect(
+            web_forms.all? { |web_form|
+              expect(web_form.web_site.service.host.address.to_s).to eq(selected_address)
+            }
+        ).to eq(true)
+      end
+    end
+  end
+end

data/spec/app/models/metasploit_data_models/automatic_exploitation/match_result_spec.rb

@@ -0,0 +1,86 @@
+RSpec.describe MetasploitDataModels::AutomaticExploitation::MatchResult, type: :model do
+  it_should_behave_like 'Metasploit::Concern.run'
+
+  context "database" do
+    it { is_expected.to have_db_column(:match_id).of_type(:integer) }
+    it { is_expected.to have_db_index(:match_id) }
+    it { is_expected.to have_db_column(:run_id).of_type(:integer) }
+    it { is_expected.to have_db_index(:run_id) }
+  end
+
+  context 'associations' do
+    it { is_expected.to belong_to(:match).class_name('MetasploitDataModels::AutomaticExploitation::Match') }
+    it { is_expected.to belong_to(:run).class_name('MetasploitDataModels::AutomaticExploitation::Run') }
+  end
+
+  context 'scopes' do
+    before do
+      match_failed    = FactoryBot.create(:automatic_exploitation_match)
+      match_succeeded = FactoryBot.create(:automatic_exploitation_match)
+      run             = FactoryBot.create(:automatic_exploitation_run)
+
+      described_class.create do |match_result|
+        match_result.match = match_failed
+        match_result.run   = run
+        match_result.state = MetasploitDataModels::AutomaticExploitation::MatchResult::SUCCEEDED
+      end
+
+      described_class.create do |match_result|
+        match_result.match = match_succeeded
+        match_result.run   = run
+        match_result.state = MetasploitDataModels::AutomaticExploitation::MatchResult::FAILED
+      end
+    end
+
+    context 'succeeded' do
+      subject(:succeeded) do
+        described_class.succeeded
+      end
+
+      specify 'returns only successful results' do
+        expect(succeeded.count).to eq(1)
+        expect(succeeded.first.state).to eq(MetasploitDataModels::AutomaticExploitation::MatchResult::SUCCEEDED)
+      end
+    end
+
+    context 'failed' do
+      subject(:failed) do
+        described_class.failed
+      end
+
+      specify 'returns only failed results' do
+        expect(failed.count).to eq(1)
+        expect(failed.first.state).to eq(MetasploitDataModels::AutomaticExploitation::MatchResult::FAILED)
+      end
+    end
+  end
+
+  context 'validations' do
+    context 'state' do
+      subject(:match_result) do
+        FactoryBot.build(:automatic_exploitation_match_result, state: state)
+      end
+      context 'with nil' do
+        let(:state) { nil }
+        specify do
+          expect(match_result).not_to be_valid
+          expect(match_result.errors[:state]).to include("can't be blank")
+        end
+      end
+      context 'with "asdf"' do
+        let(:state) { "asdf" }
+        specify do
+          expect(match_result).not_to be_valid
+          expect(match_result.errors[:state]).to include("is not included in the list")
+        end
+      end
+      context 'with "succeeded"' do
+        let(:state) { MetasploitDataModels::AutomaticExploitation::MatchResult::SUCCEEDED }
+        specify do
+          expect(match_result).to be_valid
+        end
+      end
+    end
+  end
+
+end

data/spec/app/models/metasploit_data_models/automatic_exploitation/match_set_spec.rb

@@ -0,0 +1,46 @@
+RSpec.describe MetasploitDataModels::AutomaticExploitation::MatchSet, type: :model do
+  describe "database" do
+    describe "foreign_keys" do
+      it { is_expected.to have_db_column(:workspace_id).of_type(:integer) }
+      it { is_expected.to have_db_column(:user_id).of_type(:integer) }
+    end
+
+    describe "indices" do
+      it { is_expected.to have_db_index(:user_id) }
+      it { is_expected.to have_db_index(:workspace_id) }
+    end
+  end
+
+  describe "associations" do
+    it { is_expected.to have_many(:matches).class_name('MetasploitDataModels::AutomaticExploitation::Match') }
+    it { is_expected.to have_many(:matches).inverse_of(:match_set) }
+    it { is_expected.to have_many(:runs).class_name('MetasploitDataModels::AutomaticExploitation::Run') }
+    it { is_expected.to have_many(:runs).inverse_of(:match_set) }
+    it { is_expected.to belong_to(:user).class_name('Mdm::User') }
+    it { is_expected.to belong_to(:user).inverse_of(:automatic_exploitation_match_sets) }
+    it { is_expected.to belong_to(:workspace).class_name('Mdm::Workspace') }
+    it { is_expected.to belong_to(:workspace).inverse_of(:automatic_exploitation_match_sets) }
+  end
+
+  describe "validations" do
+    subject(:match_set){ FactoryBot.build(:automatic_exploitation_match_set)}
+
+    describe "missing user" do
+      before(:example) do
+        match_set.user = nil
+      end
+
+      it{ is_expected.to be_invalid }
+    end
+
+    describe "missing workspace" do
+      before(:example) do
+        match_set.workspace = nil
+      end
+
+      it{ is_expected.to be_invalid }
+    end
+
+  end
+
+end

data/spec/app/models/metasploit_data_models/automatic_exploitation/match_spec.rb

@@ -0,0 +1,37 @@
+RSpec.describe MetasploitDataModels::AutomaticExploitation::Match, type: :model do
+  it_should_behave_like 'Metasploit::Concern.run'
+
+  describe "associations" do
+    describe "connecting to a Mdm::Module::Detail" do
+      let(:vuln){ FactoryBot.create(:mdm_vuln) }
+      let(:module_detail){FactoryBot.create(:mdm_module_detail)}
+
+      subject(:automatic_exploitation_match){ described_class.new }
+
+      before(:example) do
+        automatic_exploitation_match.matchable = vuln
+        automatic_exploitation_match.module_fullname = module_detail.fullname
+        automatic_exploitation_match.save!
+      end
+
+      it 'should point to the Mdm::Module::Detail with a fullname corresponding to #module_fullname' do
+        expect(automatic_exploitation_match.module_detail).to eq(module_detail)
+      end
+    end
+
+    describe "deleting the associated Mdm::Module::Detail" do
+      subject(:automatic_exploitation_match){ FactoryBot.create(:automatic_exploitation_match) }
+      let(:match_id){ automatic_exploitation_match.id }
+
+      before(:example) do
+        automatic_exploitation_match.module_detail.destroy
+      end
+
+      it 'should still exist in the DB' do
+        the_match = MetasploitDataModels::AutomaticExploitation::Match.find(match_id)
+        expect(the_match).to_not be_blank
+      end
+    end
+
+  end
+end

data/spec/app/models/metasploit_data_models/automatic_exploitation/run_spec.rb

@@ -0,0 +1,38 @@
+RSpec.describe MetasploitDataModels::AutomaticExploitation::Run, type: :model do
+  subject(:run) { FactoryBot.create(:automatic_exploitation_run) }
+
+
+  describe "database" do
+    describe "columns" do
+      it { is_expected.to have_db_column(:workspace_id).of_type(:integer) }
+      it { is_expected.to have_db_index(:workspace_id) }
+      it { is_expected.to have_db_column(:user_id).of_type(:integer) }
+      it { is_expected.to have_db_index(:user_id) }
+    end
+  end
+
+  describe "associations" do
+    it { is_expected.to belong_to(:match_set).class_name('MetasploitDataModels::AutomaticExploitation::MatchSet') }
+    it { is_expected.to belong_to(:workspace).class_name('Mdm::Workspace') }
+    it { is_expected.to belong_to(:workspace).inverse_of(:automatic_exploitation_runs) }
+    it { is_expected.to belong_to(:user).class_name('Mdm::User') }
+    it { is_expected.to belong_to(:user).inverse_of(:automatic_exploitation_runs) }
+    it { is_expected.to have_many(:match_results) }
+  end
+
+  describe "destroying" do
+    describe "associated MatchResults" do
+      before(:example) do
+        match_set = FactoryBot.create(:automatic_exploitation_match_set)
+        match = FactoryBot.create(:automatic_exploitation_match, match_set: match_set)
+        run.match_set = match_set
+        FactoryBot.create(:automatic_exploitation_match_result, match: match, run: run)
+      end
+
+      it 'should happen when you delete the Run' do
+        expect { run.destroy }.to change { MetasploitDataModels::AutomaticExploitation::MatchResult.count }.by(-1)
+      end
+    end
+
+  end
+end