wg-metasploit_data_models 4.1.4.01 → 4.1.4.02

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

@@ -0,0 +1,119 @@
+RSpec.describe MetasploitDataModels::IPAddress::V4::CIDR, type: :model do
+  subject(:cidr) {
+    described_class.new(
+        value: formatted_value
+    )
+  }
+
+  let(:formatted_value) {
+    nil
+  }
+
+  it { is_expected.to be_a MetasploitDataModels::IPAddress::CIDR }
+
+  context 'address_class' do
+    subject(:address_class) {
+      described_class.address_class
+    }
+
+    it { is_expected.to eq(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 { is_expected.to be_valid }
+    end
+
+    context 'with IPv4 address' do
+      let(:formatted_value) {
+        formatted_address
+      }
+
+      it { is_expected.not_to be_valid }
+
+      context 'errors' do
+        before(:example) do
+          cidr.valid?
+        end
+
+        context 'on #address' do
+          subject(:address_errors) {
+            cidr.errors[:address]
+          }
+
+          it { is_expected.to 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 { is_expected.to 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 { is_expected.not_to be_valid }
+
+      context 'errors' do
+        before(:example) do
+          cidr.valid?
+        end
+
+        context 'on #address' do
+          subject(:address_errors) {
+            cidr.errors[:address]
+          }
+
+          let(:invalid_error) {
+            I18n.translate!('errors.messages.invalid')
+          }
+
+          it { is_expected.to 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 { is_expected.to 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,149 @@
+RSpec.describe MetasploitDataModels::IPAddress::V4::Nmap, type: :model do
+  subject(:nmap) {
+    described_class.new(
+        value: formatted_value
+    )
+  }
+
+  context 'validation' do
+    before(:example) 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 { is_expected.to 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 { is_expected.to 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 { is_expected.to 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,298 @@
+RSpec.describe MetasploitDataModels::IPAddress::V4::Range, type: :model 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(:example) 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 { is_expected.to 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 { is_expected.not_to include invalid_error }
+          end
+
+          context 'without valid' do
+            let(:formatted_value) {
+              '256.256.256.256-257.257.257.257'
+            }
+
+            it { is_expected.to 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 { is_expected.to 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 { is_expected.not_to include invalid_error }
+          end
+
+          context 'without valid' do
+            let(:formatted_value) {
+              '257.257.257.257-256.256.256.256'
+            }
+
+            it { is_expected.to 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 { is_expected.not_to include error }
+      end
+
+      context 'with incomparables' do
+        let(:formatted_value) {
+          'a-1'
+        }
+
+        it { is_expected.not_to include error }
+      end
+
+      context 'with numbers' do
+        context 'in order' do
+          let(:formatted_value) {
+            '1.1.1.1-2.2.2.2'
+          }
+
+          it { is_expected.not_to include error }
+        end
+
+        context 'out of order' do
+          let(:formatted_value) {
+            '2.2.2.2-1.1.1.1'
+          }
+
+          it { is_expected.to 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 { is_expected.to eq('-') }
+    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 { is_expected.to be_a Range }
+
+        context 'Range#begin' do
+          subject(:range_begin) {
+            value.begin
+          }
+
+          it { is_expected.to 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 { is_expected.to 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 { is_expected.to be_a Range }
+
+        context 'Range#begin' do
+          subject(:range_begin) {
+            value.begin
+          }
+
+          it { is_expected.to be_a MetasploitDataModels::IPAddress::V4::Single }
+
+          context 'MetasploitDataModels::IPAddress::V4::Single#value' do
+            subject(:begin_value) {
+              range_begin.value
+            }
+
+            it { is_expected.to eq('') }
+          end
+        end
+
+        context 'Range#end' do
+          subject(:range_end) {
+            value.end
+          }
+
+          it { is_expected.to be_a MetasploitDataModels::IPAddress::V4::Single }
+
+          context 'MetasploitDataModels::IPAddress::V4::Single#value' do
+            subject(:end_value) {
+              range_end.value
+            }
+
+            it { is_expected.to eq('') }
+          end
+        end
+      end
+    end
+
+    context 'without -' do
+      let(:formatted_value) do
+        '1'
+      end
+
+      it { is_expected.not_to be_a Range }
+    end
+  end
+end