wg-metasploit_data_models 4.1.4.01 → 4.1.4.02

data/spec/app/models/metasploit_data_models/ip_address/v4/segment/single_spec.rb

@@ -0,0 +1,324 @@
+RSpec.describe MetasploitDataModels::IPAddress::V4::Segment::Single, type: :model do
+  subject(:single) {
+    described_class.new(
+        value: formatted_value
+    )
+  }
+
+  let(:formatted_value) {
+    nil
+  }
+
+  context 'validations' do
+    it 'validates value is only an integer between 0 and 255 inclusive' do
+      is_expected.to validate_numericality_of(:value).is_greater_than_or_equal_to(0).is_less_than_or_equal_to(255).only_integer
+    end
+  end
+
+  it 'can be used in a Range' do
+    expect {
+      Range.new(single, single)
+    }.not_to raise_error
+  end
+
+  context '#add_with_carry' do
+    subject(:add_with_carry) {
+      single.add_with_carry(*arguments)
+    }
+
+    let(:carry_out) {
+      add_with_carry[1]
+    }
+
+    let(:segment_out) {
+      add_with_carry[0]
+    }
+
+    context 'with carry' do
+      let(:arguments) {
+        [
+            other_single,
+            1
+        ]
+      }
+
+      context 'with overflow' do
+        let(:formatted_value) {
+          '255'
+        }
+
+        let(:other_single) {
+          described_class.new(value: 255)
+        }
+
+        it 'outputs a proper segment' do
+          expect(segment_out).to be_a described_class
+          expect(segment_out.value).to be <= 255
+          expect(segment_out.value).to eq(255)
+        end
+
+        it 'outputs a carry' do
+          expect(carry_out).to eq(1)
+        end
+      end
+
+      context 'without overflow' do
+        let(:formatted_value) {
+          '254'
+        }
+
+        let(:other_single) {
+          described_class.new(value: 0)
+        }
+
+        it 'outs a proper segment' do
+          expect(segment_out).to be_a described_class
+          expect(segment_out.value).to be <= 255
+          expect(segment_out.value).to eq(255)
+        end
+
+        it 'does not output a carry' do
+          expect(carry_out).to eq(0)
+        end
+      end
+    end
+
+    context 'without carry' do
+      let(:arguments) {
+        [
+            other_single
+        ]
+      }
+
+      context 'with overflow' do
+        let(:formatted_value) {
+          '255'
+        }
+
+        let(:other_single) {
+          described_class.new(value: 255)
+        }
+
+        it 'outputs a proper segment' do
+          expect(segment_out).to be_a described_class
+          expect(segment_out.value).to be <= 255
+          expect(segment_out.value).to eq(254)
+        end
+
+        it 'outputs a carry' do
+          expect(carry_out).to eq(1)
+        end
+      end
+
+      context 'without overflow' do
+        let(:formatted_value) {
+          '255'
+        }
+
+        let(:other_single) {
+          described_class.new(value: 0)
+        }
+
+        it 'outs a proper segment' do
+          expect(segment_out).to be_a described_class
+          expect(segment_out.value).to be <= 255
+          expect(segment_out.value).to eq(255)
+        end
+
+        it 'does not output a carry' do
+          expect(carry_out).to eq(0)
+        end
+      end
+    end
+  end
+
+  context 'bits' do
+    subject(:bits) {
+      described_class.bits
+    }
+
+    it { is_expected.to eq(8) }
+  end
+
+  context 'match_regexp' do
+    subject(:match_regexp) {
+      described_class.match_regexp
+    }
+
+    it 'matches segment number' do
+      expect(match_regexp).to match('255')
+    end
+
+    it 'does not match segment range' do
+      expect(match_regexp).not_to match('0-225')
+    end
+  end
+
+  context '#<=>' do
+    subject(:compare) {
+      single <=> other
+    }
+
+    let(:formatted_value) {
+      '1'
+    }
+
+    let(:other) {
+      double('Other')
+    }
+
+    it 'compares #values' do
+      other_value = double('other.value')
+      single_value = double('single.value')
+
+      expect(other).to receive(:value).and_return(other_value)
+      # have to use a double because can't expect().to receive on an Integer
+      expect(single).to receive(:value).and_return(single_value)
+      expect(single_value).to receive(:<=>).with(other_value)
+
+      compare
+    end
+  end
+
+  context '#succ' do
+    subject(:succ) {
+      single.succ
+    }
+
+    context '#value' do
+      context 'with nil' do
+        let(:formatted_value) {
+          nil
+        }
+
+        specify {
+          expect {
+            succ
+          }.not_to raise_error
+        }
+      end
+
+      context 'with number' do
+        let(:formatted_value) {
+          value.to_s
+        }
+
+        let(:value) {
+          1
+        }
+
+        it { is_expected.to be_a described_class }
+
+        context 'succ.value' do
+          it 'is succ of #value' do
+            expect(succ.value).to eq(value.succ)
+          end
+        end
+      end
+
+      context 'without number' do
+        let(:formatted_value) {
+          'a'
+        }
+
+        it { is_expected.to be_a described_class }
+
+        context 'succ.value' do
+          it 'is succ of #value' do
+            expect(succ.value).to eq(single.value.succ)
+          end
+        end
+      end
+    end
+  end
+
+  context '#to_s' do
+    subject(:call_to_s) {
+      single.to_s
+    }
+
+    #
+    # let
+    #
+
+    let(:value) {
+      double('#value')
+    }
+
+    #
+    # Callbacks
+    #
+
+    before(:example) do
+      allow(single).to receive(:value).and_return(value)
+    end
+
+    it 'delegates to #value' do
+      expect(value).to receive(:to_s)
+
+      call_to_s
+    end
+  end
+
+  context '#value' do
+    subject(:value) do
+      single.value
+    end
+
+    context 'with Integer' do
+      let(:formatted_value) do
+        1
+      end
+
+      it 'should pass through Integer' do
+        expect(value).to eq(formatted_value)
+      end
+    end
+
+    context 'with Integer#to_s' do
+      let(:formatted_value) do
+        integer.to_s
+      end
+
+      let(:integer) do
+        1
+      end
+
+      it 'should convert String to Integer' do
+        expect(value).to eq(integer)
+      end
+    end
+
+    context 'with mix text and numerals' do
+      let(:formatted_value) do
+        "#{integer}mix"
+      end
+
+      let(:integer) do
+        123
+      end
+
+      it 'should not extract the number' do
+        expect(value).not_to eq(integer)
+      end
+
+      it 'should pass through the full value' do
+        expect(value).to eq(formatted_value)
+      end
+    end
+
+    context 'with Float' do
+      let(:formatted_value) do
+        0.1
+      end
+
+      it 'should not truncate Float to Integer' do
+        expect(value).not_to eq(formatted_value.to_i)
+      end
+
+      it 'should pass through Float' do
+        expect(value).to eq(formatted_value)
+      end
+    end
+  end
+end

data/spec/app/models/metasploit_data_models/ip_address/v4/single_spec.rb

@@ -0,0 +1,181 @@
+RSpec.describe MetasploitDataModels::IPAddress::V4::Single, type: :model do
+  subject(:single) {
+    described_class.new(
+        value: formatted_value
+    )
+  }
+
+  context 'validation' do
+    before(:example) do
+      single.valid?
+    end
+
+    context 'errors on #segments' do
+      subject(:segments_errors) {
+        single.errors[:segments]
+      }
+
+      context 'with segments' do
+        let(:formatted_value) {
+          '1.2.3.4'
+        }
+
+        it { is_expected.to be_empty }
+      end
+
+      context 'without segments' do
+        let(:formatted_value) {
+          '::1'
+        }
+
+        let(:length_error) {
+          I18n.translate!(
+              'metasploit.model.errors.models.metasploit_data_models/ip_address/v4/segmented.attributes.segments.wrong_length',
+              count: 4
+          )
+        }
+
+        it { is_expected.to include length_error }
+      end
+    end
+  end
+
+  context '+' do
+    subject(:add) do
+      single + other
+    end
+
+    context 'with MetasploitDataModels::IPAddress::V4::Single' do
+      let(:other) {
+        described_class.new(
+            value: other_formatted_value
+        )
+      }
+
+      context 'with overflow' do
+        let(:formatted_value) {
+          '255.255.255.255'
+        }
+
+        let(:other_formatted_value) {
+          '0.0.0.1'
+        }
+
+        specify {
+          expect {
+            add
+          }.to raise_error(ArgumentError, "255.255.255.255 + 0.0.0.1 is not a valid IP address.  It is 0.0.0.0 with a carry (1)")
+        }
+      end
+
+      context 'without overflow' do
+        let(:formatted_value) {
+          '254.255.255.255'
+        }
+
+        context 'with ripple carry' do
+          let(:other_formatted_value) {
+            '0.0.0.1'
+          }
+
+          it 'propagates carry corretly' do
+            expect(add).to eq(described_class.new(value: '255.0.0.0'))
+          end
+        end
+
+        context 'without ripple carry' do
+          let(:formatted_value) do
+            '4.3.2.1'
+          end
+
+          let(:other_formatted_value) do
+            '5.4.3.2'
+          end
+
+          it 'adds the correct segments together' do
+            expect(add).to eq(described_class.new(value: '9.7.5.3'))
+          end
+        end
+      end
+    end
+
+    context 'without MetasploitDataMOdels::IPAddress::V4::Single' do
+      let(:formatted_value) {
+          '255.255.255.255'
+      }
+
+      let(:other) {
+        1
+      }
+
+      specify {
+        expect {
+          add
+        }.to raise_error(TypeError, "Cannot add #{other.class} to #{described_class}")
+      }
+    end
+  end
+
+  context 'regexp' do
+    subject(:regexp) {
+      described_class.regexp
+    }
+
+    it 'matches a normal IPv4 address' do
+      expect(regexp).to match_string_exactly('1.2.3.4')
+    end
+
+    it 'does matches an IPv4 Nmap address with comma separated list of numbers and ranges for each segment' do
+      expect(regexp).not_to match_string_exactly('1,2-3.4-5,6.7,8.9-10,11-12')
+    end
+  end
+
+  context '#value' do
+    subject(:value) {
+      single.value
+    }
+
+    context 'with nil' do
+      let(:formatted_value) {
+        nil
+      }
+
+      it { is_expected.to be_nil }
+    end
+
+    context 'with matching formatted value' do
+      let(:formatted_value) {
+        '1.2.3.4'
+      }
+
+      it 'has 4 segments' do
+        expect(value.length).to eq(4)
+      end
+
+      it 'has MetasploitDataModels::IPAddress::V4::Segment::Single for segments' do
+        expect(
+            value.all? { |segment|
+              segment.is_a? MetasploitDataModels::IPAddress::V4::Segment::Single
+            }
+        ).to eq(true)
+      end
+
+      it 'has segments ordered from high to low' do
+        expect(value[0].value).to eq(1)
+        expect(value[1].value).to eq(2)
+        expect(value[2].value).to eq(3)
+        expect(value[3].value).to eq(4)
+      end
+    end
+
+    context 'without matching formatted value' do
+      let(:formatted_value) {
+        '1.2-3.5.6'
+      }
+
+      it 'is the formated value' do
+        expect(value).to eq(formatted_value)
+      end
+    end
+  end
+end

data/spec/app/models/metasploit_data_models/module_run_spec.rb

@@ -0,0 +1,134 @@
+RSpec.describe MetasploitDataModels::ModuleRun, type: :model do
+
+  subject(:module_run){FactoryBot.build(:metasploit_data_models_module_run)}
+
+  context "database columns" do
+    it { is_expected.to have_db_column(:attempted_at).of_type(:datetime) }
+    it { is_expected.to have_db_column(:fail_detail).of_type(:text) }
+    it { is_expected.to have_db_column(:fail_reason).of_type(:string) }
+    it { is_expected.to have_db_column(:module_fullname).of_type(:text) }
+    it { is_expected.to have_db_column(:port).of_type(:integer) }
+    it { is_expected.to have_db_column(:proto).of_type(:string) }
+    it { is_expected.to have_db_column(:session_id).of_type(:integer) }
+    it { is_expected.to have_db_column(:status).of_type(:string) }
+    it { is_expected.to have_db_column(:trackable_id).of_type(:integer) }
+    it { is_expected.to have_db_column(:trackable_type).of_type(:string) }
+    it { is_expected.to have_db_column(:user_id).of_type(:integer) }
+    it { is_expected.to have_db_column(:username).of_type(:string) }
+  end
+
+  context "associations" do
+    it { is_expected.to belong_to(:user).class_name('Mdm::User') }
+    it { is_expected.to belong_to(:user).inverse_of(:module_runs) }
+    it { is_expected.to belong_to(:target_session).class_name('Mdm::Session') }
+    it { is_expected.to belong_to(:target_session).inverse_of(:target_module_runs) }
+    it { is_expected.to belong_to(:trackable) }
+    it { is_expected.to belong_to(:module_detail).class_name('Mdm::Module::Detail') }
+    it { is_expected.to belong_to(:module_detail).inverse_of(:module_runs) }
+    it { is_expected.to have_many(:loots).class_name('Mdm::Loot') }
+    it { is_expected.to have_many(:loots).inverse_of(:module_run) }
+    it { is_expected.to have_one(:spawned_session).class_name('Mdm::Session') }
+    it { is_expected.to have_one(:spawned_session).inverse_of(:originating_module_run) }
+  end
+
+  context "validations" do
+    describe "when a target_session is set on the module run" do
+      before(:example) do
+        module_run.target_session = FactoryBot.build(:mdm_session)
+      end
+
+      context "when the module is an exploit" do
+        context "and that exploit IS NOT local" do
+          before(:example) do
+            module_run.module_fullname = 'exploit/windows/mah-crazy-exploit'
+          end
+
+          it { is_expected.to_not be_valid }
+        end
+
+        context "and that exploit IS local" do
+          before(:example) do
+            module_run.module_fullname = 'exploit/windows/local/mah-crazy-exploit'
+          end
+
+          it { is_expected.to be_valid }
+        end
+      end
+    end
+
+    describe "when a spawned_session is set on the module run" do
+      before(:example) do
+        module_run.spawned_session  = FactoryBot.build(:mdm_session)
+      end
+
+      context "when the module is not an exploit" do
+
+        context "and it IS NOT a login scanner" do
+          before(:example) do
+            module_run.module_fullname = 'post/multi/gather/steal-minecraft-maps'
+          end
+
+          it { is_expected.to_not be_valid }
+        end
+
+        context "and it IS a login scanner" do
+          before(:example) do
+            module_run.module_fullname = 'auxiliary/scanner/ssh/ssh_login'
+          end
+
+          it { is_expected.to be_valid }
+        end
+      end
+    end
+
+    describe "attempted_at" do
+      before(:example){ module_run.attempted_at = nil }
+
+      it { is_expected.to_not be_valid } 
+    end
+
+    describe "content information" do
+      context "when there is no module_name" do
+        before(:example) do
+          module_run.module_fullname = nil
+        end
+
+        it { is_expected.to_not be_valid }
+      end
+    end
+
+
+    describe "status" do
+      describe "invalidity" do
+        before(:example) do
+          module_run.status = "invalid nonsense"
+        end
+
+        it { expect(module_run).to_not be_valid}
+      end
+
+      describe "validity" do
+        context "when the module run succeeded" do
+          before(:example){ module_run.status = MetasploitDataModels::ModuleRun::SUCCEED}
+
+          it{ expect(module_run).to be_valid }
+        end
+
+        context "when the module run went normally but failed" do
+          before(:example){ module_run.status = MetasploitDataModels::ModuleRun::FAIL}
+
+          it{ expect(module_run).to be_valid }
+        end
+
+        context "when the module run errored out" do
+          before(:example){ module_run.status = MetasploitDataModels::ModuleRun::ERROR}
+
+          it{ expect(module_run).to be_valid }
+        end
+
+      end
+
+    end
+  end
+end
+