metasploit_data_models 0.18.1-java → 0.19.0-java

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

@@ -3,6 +3,28 @@ require 'spec_helper'
 describe Mdm::Service do
   it_should_behave_like 'Metasploit::Concern.run'
 
+  context 'CONSTANTS' do
+    context 'PROTOS' do
+      subject(:protos) {
+        described_class::PROTOS
+      }
+
+      it { should include 'tcp' }
+      it { should include 'udp' }
+    end
+
+    context 'STATES' do
+      subject(:states) {
+        described_class::STATES
+      }
+
+      it { should include 'closed' }
+      it { should include 'filtered' }
+      it { should include 'open' }
+      it { should include 'unknown' }
+    end
+  end
+
   context "Associations" do
 
     it { should have_many(:task_services).class_name('Mdm::TaskService').dependent(:destroy) }
@@ -33,13 +55,13 @@ describe Mdm::Service do
       end
     end
 
-    context "search for 'snmp'" do
+    context "search for 'tcp'" do
       it "should find only services that match" do
-        snmp_service   = FactoryGirl.create(:mdm_service)
-        ftp_service    =  FactoryGirl.create(:mdm_service, :proto => 'ftp')
-        search_results = Mdm::Service.search('snmp')
-        search_results.should     include(snmp_service)
-        search_results.should_not include(ftp_service)
+        tcp_service   = FactoryGirl.create(:mdm_service, proto: 'tcp')
+        udp_service    =  FactoryGirl.create(:mdm_service, proto: 'udp')
+        search_results = Mdm::Service.search('tcp')
+        search_results.should     include(tcp_service)
+        search_results.should_not include(udp_service)
       end
     end
   end
@@ -98,44 +120,11 @@ describe Mdm::Service do
   end
 
   context "validations" do
-    let(:mdm_service) do
-      mdm_service = FactoryGirl.build(:mdm_service)
-      mdm_service.valid?
-      mdm_service
-    end
-
-    context "invalid" do
-      it "should validate presence of :port" do
-        mdm_service.port = nil
-        mdm_service.valid?
-        mdm_service.errors[:port][0].should include "is not a number"
-      end
+    subject(:mdm_service) {
+      FactoryGirl.build(:mdm_service)
+    }
 
-      it "should validate presence of :proto" do
-        mdm_service.proto = nil
-        mdm_service.valid?
-        mdm_service.errors[:proto][0].should include "can't be blank"
-      end
-
-      it "should not allow non-numeric value for port" do
-        mdm_service.port = Faker::Lorem.characters(4)
-        mdm_service.valid?
-        mdm_service.errors[:port][0].should include "is not a number"
-      end
-    end
-
-    context "valid" do
-      it "should allow numeric value for port" do
-        mdm_service.port = Faker::Number.number(4)
-        mdm_service.valid?
-        mdm_service.should have(0).errors_on(:port)
-      end
-
-      it "should allow proto" do
-        mdm_service.proto = "tcp"
-        mdm_service.valid?
-        mdm_service.should have(0).errors_on(:proto)
-      end
-    end
+    it { should validate_numericality_of(:port).only_integer }
+    it { should ensure_inclusion_of(:proto).in_array(described_class::PROTOS) }
   end
 end

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

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+describe MetasploitDataModels::IPAddress::V4::CIDR do
+  subject(:cidr) {
+    described_class.new(
+        value: formatted_value
+    )
+  }
+
+  let(:formatted_value) {
+    nil
+  }
+
+  it { should be_a MetasploitDataModels::IPAddress::CIDR }
+
+  context 'address_class' do
+    subject(:address_class) {
+      described_class.address_class
+    }
+
+    it { should == MetasploitDataModels::IPAddress::V4::Single }
+  end
+
+  context 'validations' do
+    let(:formatted_address) {
+      '1.2.3.4'
+    }
+
+    context 'with IPv4 CIDR notation' do
+      let(:formatted_prefix_length) {
+        '8'
+      }
+
+      let(:formatted_value) {
+        "#{formatted_address}/#{formatted_prefix_length}"
+      }
+
+      it { should be_valid }
+    end
+
+    context 'with IPv4 address' do
+      let(:formatted_value) {
+        formatted_address
+      }
+
+      it { should_not be_valid }
+
+      context 'errors' do
+        before(:each) do
+          cidr.valid?
+        end
+
+        context 'on #address' do
+          subject(:address_errors) {
+            cidr.errors[:address]
+          }
+
+          it { should be_empty }
+        end
+
+        context 'on #prefix_length' do
+          subject(:prefix_length_errors) {
+            cidr.errors[:prefix_length]
+          }
+
+          let(:blank_error) {
+            I18n.translate!('errors.messages.not_a_number')
+          }
+
+          it { should include(blank_error) }
+        end
+      end
+    end
+
+    context 'with IPv6 CIDR notation' do
+      let(:formatted_value) {
+        "#{formatted_address}/#{formatted_prefix_length}"
+      }
+
+      let(:formatted_address) {
+        '::1'
+      }
+
+      let(:formatted_prefix_length) {
+        '48'
+      }
+
+      it { should_not be_valid }
+
+      context 'errors' do
+        before(:each) do
+          cidr.valid?
+        end
+
+        context 'on #address' do
+          subject(:address_errors) {
+            cidr.errors[:address]
+          }
+
+          let(:invalid_error) {
+            I18n.translate!('errors.messages.invalid')
+          }
+
+          it { should include(invalid_error) }
+        end
+
+        context 'on #prefix_length' do
+          subject(:prefix_length_errors) {
+            cidr.errors[:prefix_length]
+          }
+
+          let(:too_big_error) {
+            I18n.translate!('errors.messages.less_than_or_equal_to', count: 32)
+          }
+
+          it { should include(too_big_error) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,151 @@
+require 'spec_helper'
+
+describe MetasploitDataModels::IPAddress::V4::Nmap do
+  subject(:nmap) {
+    described_class.new(
+        value: formatted_value
+    )
+  }
+
+  context 'validation' do
+    before(:each) do
+      nmap.valid?
+    end
+
+    context 'errors on #segments' do
+      subject(:segments_errors) {
+        nmap.errors[:segments]
+      }
+
+      context 'with segments' do
+        context 'with invalid segment' do
+          let(:error) {
+            I18n.translate!(
+                'metasploit.model.errors.models.metasploit_data_models/ip_address/v4/segmented.attributes.segments.segment_invalid',
+                index: 0,
+                segment: '5-4'
+            )
+          }
+
+          let(:formatted_value) {
+            '5-4.3.2.1'
+          }
+
+          it 'should include index of segment and segment value in the error' do
+            expect(segments_errors).to include(error)
+          end
+        end
+
+        context 'with valid segments' do
+          let(:formatted_value) {
+            '1.2.3.4'
+          }
+
+          it { should be_empty }
+        end
+      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 { should include length_error }
+      end
+    end
+  end
+
+  context 'regexp' do
+    subject(:regexp) {
+      described_class.regexp
+    }
+
+    it 'matches a normal IPv4 address because they are a generate form of Nmap format' do
+      expect(regexp).to match_string_exactly('1.2.3.4')
+    end
+
+    it 'matches an IPv4 Nmap address with comma separated list of numbers and ranges for each segment' do
+      expect(regexp).to match_string_exactly('1,2-3.4-5,6.7,8.9-10,11-12')
+    end
+  end
+
+  context '#value' do
+    subject(:value) {
+      nmap.value
+    }
+
+    context 'with nil' do
+      let(:formatted_value) {
+        nil
+      }
+
+      it { should be_nil }
+    end
+
+    context 'with matching formatted value' do
+      let(:formatted_value) {
+        '1.2-3.4,5-6.7-8,9'
+      }
+
+      it 'has 4 segments' do
+        expect(value.length).to eq(4)
+      end
+
+      it 'has MetasploitDataModels::IPAddress::V4::Segment::Nmap::List for segments' do
+        expect(
+            value.all? { |segment|
+              segment.is_a? MetasploitDataModels::IPAddress::V4::Segment::Nmap::List
+            }
+        ).to eq(true)
+      end
+
+      it 'has segments ordered from high to low' do
+        highest_segment = value[0]
+
+        expect(highest_segment.value[0]).to be_a MetasploitDataModels::IPAddress::V4::Segment::Single
+        expect(highest_segment.value[0].value).to eq(1)
+
+        high_middle_segment = value[1]
+
+        expect(high_middle_segment.value[0]).to be_a MetasploitDataModels::IPAddress::V4::Segment::Nmap::Range
+        expect(high_middle_segment.value[0].begin.value).to eq(2)
+        expect(high_middle_segment.value[0].end.value).to eq(3)
+
+        low_middle_segment = value[2]
+
+        expect(low_middle_segment.value[0]).to be_a MetasploitDataModels::IPAddress::V4::Segment::Single
+        expect(low_middle_segment.value[0].value).to eq(4)
+
+        expect(low_middle_segment.value[1]).to be_a MetasploitDataModels::IPAddress::V4::Segment::Nmap::Range
+        expect(low_middle_segment.value[1].begin.value).to eq(5)
+        expect(low_middle_segment.value[1].end.value).to eq(6)
+
+        low_segment = value[3]
+
+        expect(low_segment.value[0]).to be_a MetasploitDataModels::IPAddress::V4::Segment::Nmap::Range
+        expect(low_segment.value[0].begin.value).to eq(7)
+        expect(low_segment.value[0].end.value).to eq(8)
+
+        expect(low_segment.value[1]).to be_a MetasploitDataModels::IPAddress::V4::Segment::Single
+        expect(low_segment.value[1].value).to eq(9)
+      end
+    end
+
+    context 'without matching formatted value' do
+      let(:formatted_value) {
+        '::1'
+      }
+
+      it 'is the formated value' do
+        expect(value).to eq(formatted_value)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,300 @@
+require 'spec_helper'
+
+describe MetasploitDataModels::IPAddress::V4::Range do
+  subject(:range) {
+    described_class.new(
+        value: formatted_value
+    )
+  }
+
+  #
+  # lets
+  #
+
+  let(:formatted_value) {
+    nil
+  }
+
+  context 'validations' do
+    #
+    # lets
+    #
+
+    let(:presence_error) {
+      I18n.translate!('errors.messages.blank')
+    }
+
+    let(:invalid_error) {
+      I18n.translate!('errors.messages.invalid')
+    }
+
+    #
+    # Callbacks
+    #
+
+    before(:each) do
+      range.valid?
+    end
+
+    context 'errors on #begin' do
+      subject(:begin_errors) {
+        range.errors[:begin]
+      }
+
+      context '#begin' do
+        context 'with nil' do
+          let(:formatted_value) {
+            nil
+          }
+
+          it { should include presence_error }
+        end
+
+        context 'with MetasploitDataModels::IPAddress::V4::Single' do
+          context 'with valid' do
+            let(:formatted_value) {
+              '1.1.1.1-256.256.256.256'
+            }
+
+            it { should_not include invalid_error }
+          end
+
+          context 'without valid' do
+            let(:formatted_value) {
+              '256.256.256.256-257.257.257.257'
+            }
+
+            it { should include invalid_error }
+          end
+        end
+      end
+    end
+
+    context 'errors on #end' do
+      subject(:end_errors) {
+        range.errors[:end]
+      }
+
+      context '#end' do
+        context 'with nil' do
+          let(:formatted_value) {
+            nil
+          }
+
+          it { should include presence_error }
+        end
+
+        context 'with MetasploitDataModels::IPAddress::V4::Single' do
+          context 'with valid' do
+            let(:formatted_value) {
+              '256.256.256.256-1.1.1.1'
+            }
+
+            it { should_not include invalid_error }
+          end
+
+          context 'without valid' do
+            let(:formatted_value) {
+              '257.257.257.257-256.256.256.256'
+            }
+
+            it { should include invalid_error }
+          end
+        end
+      end
+    end
+
+    context 'errors on #value' do
+      subject(:value_errors) {
+        range.errors[:value]
+      }
+
+      let(:error) {
+        I18n.translate!(
+            'metasploit.model.errors.models.metasploit_data_models/ip_address/range.attributes.value.order',
+            begin: range.begin,
+            end: range.end
+        )
+      }
+
+      context 'with nil' do
+        let(:formatted_value) {
+          nil
+        }
+
+        it { should_not include error }
+      end
+
+      context 'with incomparables' do
+        let(:formatted_value) {
+          'a-1'
+        }
+
+        it { should_not include error }
+      end
+
+      context 'with numbers' do
+        context 'in order' do
+          let(:formatted_value) {
+            '1.1.1.1-2.2.2.2'
+          }
+
+          it { should_not include error }
+        end
+
+        context 'out of order' do
+          let(:formatted_value) {
+            '2.2.2.2-1.1.1.1'
+          }
+
+          it { should include error }
+        end
+      end
+    end
+  end
+
+  context 'match_regexp' do
+    subject(:match_regexp) do
+      described_class::match_regexp
+    end
+
+    it 'matches range exactly' do
+      expect(match_regexp).to match_string_exactly('1.1.1.1-255.255.255.255')
+    end
+  end
+
+  context 'regexp' do
+    subject(:regexp) {
+      described_class::regexp
+    }
+
+    it 'does not match a single IPv4 address' do
+      expect(regexp).not_to match('255.255.255.255')
+    end
+
+    it 'does not match separator by itself' do
+      expect(regexp).not_to match('-')
+    end
+
+    it 'does not match range with only one extreme' do
+      expect(regexp).not_to match('1.1.1.1-')
+      expect(regexp).not_to match('-255.255.255.255')
+    end
+
+    it 'matches range' do
+      expect(regexp).to match_string_exactly('1.1.1.1-255.255.255.255')
+    end
+  end
+
+  context '#to_s' do
+    subject(:to_s) {
+      range.to_s
+    }
+
+    context 'with Range' do
+      let(:formatted_value) {
+        '1.1.1.1-2.2.2.2'
+      }
+
+      it 'equals the original formatted value' do
+        expect(to_s).to eq(formatted_value)
+      end
+    end
+
+    context 'without Range' do
+      let(:formatted_value) {
+        '1..2'
+      }
+
+      it { should == '-' }
+    end
+  end
+
+  context '#value' do
+    subject(:value) {
+      range.value
+    }
+
+    context 'with -' do
+      context 'with extremes' do
+        let(:formatted_value) {
+          '1.1.1.1-2.2.2.2'
+        }
+
+        it { should be_a Range }
+
+        context 'Range#begin' do
+          subject(:range_begin) {
+            value.begin
+          }
+
+          it { should be_a MetasploitDataModels::IPAddress::V4::Single }
+
+          it "is value before '-'" do
+            expect(range_begin).to eq(MetasploitDataModels::IPAddress::V4::Single.new(value: '1.1.1.1'))
+          end
+        end
+
+        context 'Range#end' do
+          subject(:range_end) {
+            value.end
+          }
+
+          it { should be_a MetasploitDataModels::IPAddress::V4::Single }
+
+          it "is value after '-'" do
+            expect(range_end).to eq(MetasploitDataModels::IPAddress::V4::Single.new(value: '2.2.2.2'))
+          end
+        end
+      end
+
+      context 'without extremes' do
+        let(:formatted_value) {
+          '-'
+        }
+
+        it { should be_a Range }
+
+        context 'Range#begin' do
+          subject(:range_begin) {
+            value.begin
+          }
+
+          it { should be_a MetasploitDataModels::IPAddress::V4::Single }
+
+          context 'MetasploitDataModels::IPAddress::V4::Single#value' do
+            subject(:begin_value) {
+              range_begin.value
+            }
+
+            it { should == '' }
+          end
+        end
+
+        context 'Range#end' do
+          subject(:range_end) {
+            value.end
+          }
+
+          it { should be_a MetasploitDataModels::IPAddress::V4::Single }
+
+          context 'MetasploitDataModels::IPAddress::V4::Single#value' do
+            subject(:end_value) {
+              range_end.value
+            }
+
+            it { should == '' }
+          end
+        end
+      end
+    end
+
+    context 'without -' do
+      let(:formatted_value) do
+        '1'
+      end
+
+      it { should_not be_a Range }
+    end
+  end
+end