packetfu 1.1.13 → 2.0.0

data/spec/inject_spec.rb

@@ -0,0 +1,95 @@
+# -*- coding: binary -*-
+require 'spec_helper'
+require 'packetfu/protos/eth'
+require 'packetfu/protos/ip'
+require 'packetfu/protos/ipv6'
+require 'packetfu/protos/tcp'
+require 'packetfu/protos/udp'
+require 'packetfu/protos/icmp'
+require 'packetfu/config'
+require 'packetfu/pcap'
+require 'packetfu/utils'
+require 'tempfile'
+
+include PacketFu
+
+describe Inject do
+  context "when creating an object from scratch" do
+    before :each do
+      @inject = PacketFu::Inject.new
+    end
+
+    it "should have sane defaults" do
+      expect(@inject.array).to be_kind_of(Array)
+      expect(@inject.stream).to be_kind_of(Array)
+      expect(@inject.iface).to be_kind_of(String)
+      expect(@inject.snaplen).to eql(65535)
+      expect(@inject.promisc).to eql(false)
+      expect(@inject.timeout).to eql(1)
+    end
+
+    it "should allow creating an inject object with non-std attributes" do
+      # Can only run this if we're root
+      if Process.uid == 0
+        options = {
+          :iface => PacketFu::Utils::default_int,
+          :snaplen => 0xfffe,
+          :promisc => true,
+          :timeout => 5,
+        }
+        @inject = PacketFu::Capture.new(options)
+
+        expect(@inject.array).to be_kind_of(Array)
+        expect(@inject.stream).to be_kind_of(Array)
+        expect(@inject.iface).to eql(options[:iface])
+        expect(@inject.snaplen).to eql(options[:snaplen])
+        expect(@inject.promisc).to eql(options[:promisc])
+        expect(@inject.timeout).to eql(options[:timeout])
+      end
+    end
+  end
+
+  context "when injecting on the wire" do
+    before :each do
+      @inject = PacketFu::Inject.new
+    end
+
+    it "should have sane defaults" do
+      expect(@inject.array).to be_kind_of(Array)
+      expect(@inject.stream).to be_kind_of(Array)
+      expect(@inject.iface).to be_kind_of(String)
+      expect(@inject.snaplen).to eql(65535)
+      expect(@inject.promisc).to eql(false)
+      expect(@inject.timeout).to eql(1)
+    end
+
+    # Can only run these if we're root
+    if Process.uid == 0
+      it "should allow creating an inject object with non-std attributes" do
+        udp_packet = PacketFu::UDPPacket.new(:iface => PacketFu::Utils::default_int)
+        udp_packet.ip_dst = PacketFu::Utils.rand_routable_daddr.to_s
+        udp_packet.udp_dport = 12345
+        udp_packet.udp_sport = 12345
+        udp_packet.payload = "PacketFu test packet"
+        udp_packet.recalc
+        
+        expect(udp_packet.to_w).to eql([1, 1, 62])
+      end
+
+      it "should allow creating an inject object with non-std attributes" do
+        packet_array = []
+
+        udp_packet = PacketFu::UDPPacket.new(:iface => PacketFu::Utils::default_int)
+        udp_packet.ip_dst = PacketFu::Utils.rand_routable_daddr.to_s
+        udp_packet.udp_dport = 12345
+        udp_packet.udp_sport = 12345
+        udp_packet.payload = "PacketFu test packet"
+        udp_packet.recalc
+        3.times { packet_array << udp_packet.to_s}
+        
+        inject = PacketFu::Inject.new(:iface => PacketFu::Utils::default_int)
+        expect(inject.array_to_wire(:array => packet_array)).to eql([3, 3, 186])
+      end
+    end
+  end 
+end

data/spec/ip_spec.rb

@@ -23,8 +23,30 @@ describe IPHeader do
       expect(@ip_header.ip_sum).to eql(65535)
       expect(@ip_header.ip_src).to eql(0)
       expect(@ip_header.ip_dst).to eql(0)
+      expect(@ip_header.ip_src).to be_a(Integer)
+      expect(@ip_header.ip_dst).to be_a(Integer)
       expect(@ip_header.body).to eql("")
     end
+
+    it "should parse a raw IPHeader" do
+      raw_header = "\x45\x10\x00\x4f\x16\xa9\x40\x00\x40\x06\xa2\x9c\xc0\xa8\x00\x02\xc0\xa8\x00\x01"
+      @ip_header.read(raw_header)
+
+      expect(@ip_header.ip_v).to eql(4)
+      expect(@ip_header.ip_hl).to eql(5)
+      expect(@ip_header.ip_tos).to eql(16)
+      expect(@ip_header.ip_len).to eql(79)
+      expect(@ip_header.ip_id).to be_kind_of(Integer)
+      expect(@ip_header.ip_frag).to eql(16384)
+      expect(@ip_header.ip_proto).to eql(6)
+      expect(@ip_header.ip_sum).to eql(41628)
+      expect(@ip_header.ip_src).to eql(3232235522)
+      expect(@ip_header.ip_dst).to eql(3232235521)
+      expect(@ip_header.ip_src).to be_a(Integer)
+      expect(@ip_header.ip_dst).to be_a(Integer)
+      expect(@ip_header.body).to eql("")
+    end
+
   end
 end
 
@@ -76,7 +98,7 @@ describe IPPacket do
       expect(@temp_file.read).to eql("")
 
       @ip_packet.to_f(@temp_file.path, 'a')
-      expect(File.exists?(@temp_file.path))
+      expect(File.exist?(@temp_file.path))
       expect(@temp_file.read.size).to be >= 49
     end
   end

data/spec/packetfu_spec.rb

@@ -7,7 +7,7 @@ require 'fake_packets'
 
 describe PacketFu, "version information" do
   it "reports a version number" do
-    PacketFu::VERSION.should match /^1\.[0-9]+\.[0-9]+(.pre)?$/
+    PacketFu::VERSION.should match /^[0123]\.[0-9]+\.[0-9]+(.pre)?$/
   end
   its(:version) {should eq PacketFu::VERSION}
 

data/spec/pcap_spec.rb

@@ -194,7 +194,7 @@ describe PcapFile do
 
     it "should read via #file_to_array and write via #to_f" do
       # TODO: Figure out why this is failing to write properly when converted to a Tempfile
-      File.unlink('out.pcap') if File.exists? 'out.pcap'
+      File.unlink('out.pcap') if File.exist? 'out.pcap'
       pcaps = PcapFile.new.file_to_array(:filename => 'test/sample.pcap')
       pcaps.each {|pkt|
         packet = Packet.parse pkt
@@ -279,8 +279,8 @@ describe Write do
       Write.array_to_file(:array => pkts, :file => @temp_file.path)
 
       pkts_new = Read.file_to_array(:file => @temp_file.path)
-      expect(pkts).to be_kind_of(Array)
-      expect(pkts.size).to eql(11)
+      expect(pkts_new).to be_kind_of(Array)
+      expect(pkts_new.size).to eql(11)
     end
   end
 end

data/spec/pcapng/file_spec.rb

@@ -45,7 +45,7 @@ module PacketFu
         it 'yields xPB object per read packet' do
           idx = 0
           @pcapng.readfile(@file) do |pkt|
-            expect(pkt).to be_a(@Pcapng::EPB)
+            expect(pkt).to be_a(PcapNG::EPB)
             idx += 1
           end
           expect(idx).to eq(11)

data/spec/spec_helper.rb

@@ -1,5 +1,7 @@
-require 'coveralls'
-Coveralls.wear!
+unless ENV['SKIP_COVERALLS']
+  require 'coveralls'
+  Coveralls.wear!
+end
 
 puts "rspec #{RSpec::Core::Version::STRING}"
 if RSpec::Core::Version::STRING[0] == '3'

data/spec/structfu_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
 describe StructFu, "mixin methods" do
-
   before :each do
     class StructClass
       include StructFu
@@ -10,42 +9,40 @@ describe StructFu, "mixin methods" do
   end
 
   it "should provide the basic StructFu methods" do
-    @sc.respond_to?(:sz).should be true
-    @sc.respond_to?(:len).should be true
-    @sc.respond_to?(:typecast).should be true
-    @sc.respond_to?(:body=).should be true
+    expect(@sc).to respond_to(:sz)
+    expect(@sc).to respond_to(:len)
+    expect(@sc).to respond_to(:typecast)
+    expect(@sc).to respond_to(:body=)
   end
 end
 
 describe StructFu::Int, "basic Int class" do
-
   before :each do
     @int = StructFu::Int.new(8)
   end
 
   it "should have an initial state" do
     new_int = StructFu::Int.new
-    new_int.value.should be_nil
-    new_int.endian.should be_nil
-    new_int.width.should be_nil
-    new_int.default.should == 0
+    expect(new_int.value).to be_nil
+    expect(new_int.endian).to be_nil
+    expect(new_int.width).to be_nil
+    expect(new_int.default).to eql(0)
   end
 
   it "should raise when to_s'ed directly" do
-    expect { @int.to_s}.to raise_error(StandardError, "StructFu::Int#to_s accessed, must be redefined.")
+    expect{ @int.to_s}.to raise_error(StandardError, "StructFu::Int#to_s accessed, must be redefined.")
   end
 
   it "should have a value of 8" do
-    @int.value.should == 8
-    @int.to_i.should == 8
-    @int.to_f.to_s.should == "8.0"
+    expect(@int.value).to eql(8)
+    expect(@int.to_i).to eql(8)
+    expect(@int.to_f.to_s).to eql("8.0")
   end
 
   it "should read an integer" do
     @int.read(7)
-    @int.to_i.should == 7
+    expect(@int.to_i).to eql(7)
   end
-
 end
 
 describe StructFu::Int8, "one byte value" do
@@ -56,82 +53,85 @@ describe StructFu::Int8, "one byte value" do
 
   it "should have an initial state" do
     new_int = StructFu::Int8.new
-    new_int.value.should be_nil
-    new_int.endian.should be_nil
-    new_int.width.should == 1
-    new_int.default.should == 0
+    expect(new_int.value).to be_nil
+    expect(new_int.endian).to be_nil
+    expect(new_int.width).to eql(1)
+    expect(new_int.default).to eql(0)
   end
 
   it "should print a one character packed string" do
-    @int.to_s.should == "\x0b"
+    expect(@int.to_s).to eql("\x0b")
   end
 
   it "should have a value of 11" do
-    @int.value.should == 11
-    @int.to_i.should == 11
-    @int.to_f.to_s.should == "11.0"
+    expect(@int.value).to eql(11)
+    expect(@int.to_i).to eql(11)
+    expect(@int.to_f.to_s).to eql("11.0")
   end
 
   it "should reset with a new integer" do
     @int.read(2)
-    @int.to_i.should == 2
-    @int.to_s.should == "\x02"
+    expect(@int.to_i).to eql(2)
+    expect(@int.to_s).to eql("\x02")
+
     @int.read(254)
-    @int.to_i.should == 254
-    @int.to_s.should == "\xfe".force_encoding("binary")
+    expect(@int.to_i).to eql(254)
+    expect(@int.to_s).to eql("\xfe".force_encoding("binary"))
   end
 
 end
 
 describe StructFu::Int16, "two byte value" do
-
   before :each do
     @int = StructFu::Int16.new(11)
   end
 
   it "should have an initial state" do
     new_int = StructFu::Int16.new
-    new_int.value.should be_nil
-    new_int.endian.should == :big
-    new_int.width.should == 2
-    new_int.default.should == 0
+    expect(new_int.value).to be_nil
+    expect(new_int.endian).to eql(:big)
+    expect(new_int.width).to eql(2)
+    expect(new_int.default).to eql(0)
   end
 
   it "should print a two character packed string" do
-    @int.to_s.should == "\x00\x0b".force_encoding("binary")
+    expect(@int.to_s).to eql("\x00\x0b".force_encoding("binary"))
   end
 
   it "should have a value of 11" do
-    @int.value.should == 11
-    @int.to_i.should == 11
-    @int.to_f.to_s.should == "11.0"
+    expect(@int.value).to eql(11)
+    expect(@int.to_i).to eql(11)
+    expect(@int.to_f.to_s).to eql("11.0")
   end
 
   it "should reset with a new integer" do
     @int.read(2)
-    @int.to_i.should == 2
-    @int.to_s.should == "\x00\x02"
+    expect(@int.to_i).to eql(2)
+    expect(@int.to_s).to eql("\x00\x02")
+
     @int.read(254)
-    @int.to_i.should == 254
-    @int.to_s.should == "\x00\xfe".force_encoding("binary")
+    expect(@int.to_i).to eql(254)
+    expect(@int.to_s).to eql("\x00\xfe".force_encoding("binary"))
   end
 
   it "should be able to set endianness" do
     int_be = StructFu::Int16.new(11,:big)
-    int_be.to_s.should == "\x00\x0b"
+    expect(int_be.to_s).to eql("\x00\x0b")
+
     int_le = StructFu::Int16.new(11,:little)
-    int_le.to_s.should == "\x0b\x00"
+    expect(int_le.to_s).to eql("\x0b\x00")
   end
 
   it "should be able to switch endianness" do
     @int.endian.should == :big
-    @int.to_s.should == "\x00\x0b"
+    expect(@int.to_s).to eql("\x00\x0b")
+
     @int.endian = :little
-    @int.endian.should == :little
+    expect(@int.endian).to eql(:little)
+
     @int.read(11)
-    @int.to_s.should == "\x0b\x00"
+    expect(@int.to_s).to eql("\x0b\x00")
   end
-
 end
 
 describe StructFu::Int16le, "2 byte little-endian value" do
@@ -141,7 +141,7 @@ describe StructFu::Int16le, "2 byte little-endian value" do
   end
 
   it "should behave pretty much like any other 16 bit int" do
-    @int.to_s.should == "\x0b\x00"
+    expect(@int.to_s).to eql("\x0b\x00")
   end
 
   it "should raise when you try to change endianness" do
@@ -158,7 +158,7 @@ describe StructFu::Int16be, "2 byte big-endian value" do
   end
 
   it "should behave pretty much like any other 16 bit int" do
-    @int.to_s.should == "\x00\x0b"
+    expect(@int.to_s).to eql("\x00\x0b")
   end
 
   it "should raise when you try to change endianness" do
@@ -176,45 +176,49 @@ describe StructFu::Int32, "four byte value" do
 
   it "should have an initial state" do
     new_int = StructFu::Int32.new
-    new_int.value.should be_nil
-    new_int.endian.should == :big
-    new_int.width.should == 4
-    new_int.default.should == 0
+    expect(new_int.value).to be_nil
+    expect(new_int.endian).to eql(:big)
+    expect(new_int.width).to eql(4)
+    expect(new_int.default).to eql(0)
   end
 
   it "should print a four character packed string" do
-    @int.to_s.should == "\x00\x00\x00\x0b"
+    expect(@int.to_s).to eql("\x00\x00\x00\x0b")
   end
 
   it "should have a value of 11" do
-    @int.value.should == 11
-    @int.to_i.should == 11
-    @int.to_f.to_s.should == "11.0"
+    expect(@int.value).to eql(11)
+    expect(@int.to_i).to eql(11)
+    expect(@int.to_f.to_s).to eql("11.0")
   end
 
   it "should reset with a new integer" do
     @int.read(2)
-    @int.to_i.should == 2
-    @int.to_s.should == "\x00\x00\x00\x02"
+    expect(@int.to_i).to eql(2)
+    expect(@int.to_s).to eql("\x00\x00\x00\x02")
+
     @int.read(254)
-    @int.to_i.should == 254
-    @int.to_s.should == "\x00\x00\x00\xfe".force_encoding("binary")
+    expect(@int.to_i).to eql(254)
+    expect(@int.to_s).to eql("\x00\x00\x00\xfe".force_encoding("binary"))
   end
 
   it "should be able to set endianness" do
     int_be = StructFu::Int32.new(11,:big)
-    int_be.to_s.should == "\x00\x00\x00\x0b"
+    expect(int_be.to_s).to eql("\x00\x00\x00\x0b")
+    
     int_le = StructFu::Int32.new(11,:little)
-    int_le.to_s.should == "\x0b\x00\x00\x00"
+    expect(int_le.to_s).to eql("\x0b\x00\x00\x00")
   end
 
   it "should be able to switch endianness" do
     @int.endian.should == :big
-    @int.to_s.should == "\x00\x00\x00\x0b"
+    expect(@int.to_s).to eql("\x00\x00\x00\x0b")
+
     @int.endian = :little
-    @int.endian.should == :little
+    expect(@int.endian).to eql(:little)
+    
     @int.read(11)
-    @int.to_s.should == "\x0b\x00\x00\x00"
+    expect(@int.to_s).to eql("\x0b\x00\x00\x00")
   end
 
 end
@@ -226,7 +230,7 @@ describe StructFu::Int32le, "4 byte little-endian value" do
   end
 
   it "should behave pretty much like any other 32 bit int" do
-    @int.to_s.should == "\x0b\x00\x00\x00"
+    expect(@int.to_s).to eql("\x0b\x00\x00\x00")
   end
 
   it "should raise when you try to change endianness" do
@@ -243,7 +247,7 @@ describe StructFu::Int32be, "4 byte big-endian value" do
   end
 
   it "should behave pretty much like any other 32 bit int" do
-    @int.to_s.should == "\x00\x00\x00\x0b"
+    expect(@int.to_s).to eql("\x00\x00\x00\x0b")
   end
 
   it "should raise when you try to change endianness" do
@@ -260,16 +264,16 @@ describe StructFu::String, "a sligtly more special String" do
   end
 
   it "should behave pretty much like a string" do
-    @str.should be_kind_of(String)
+    expect(@str).to be_kind_of(String)
   end
 
   it "should have a read method" do
-    @str.should respond_to(:read)
+    expect(@str).to respond_to(:read)
   end
 
   it "should read data like other StructFu things" do
     @str.read("hello")
-    @str.should == "hello"
+    expect(@str).to eql("hello")
   end
 
 end
@@ -282,17 +286,17 @@ describe StructFu::IntString do
 
   it "should have a length and value" do
     istr = StructFu::IntString.new("Avast!")
-    istr.to_s.should == "\x06Avast!"
+    expect(istr.to_s).to eql("\x06Avast!")
   end
 
   it "should have a 16-bit length and a value" do
     istr = StructFu::IntString.new("Avast!",StructFu::Int16)
-    istr.to_s.should == "\x00\x06Avast!"
+    expect(istr.to_s).to eql("\x00\x06Avast!")
   end
 
   it "should have a 32-bit length and a value" do
     istr = StructFu::IntString.new("Avast!",StructFu::Int32)
-    istr.to_s.should == "\x00\x00\x00\x06Avast!"
+    expect(istr.to_s).to eql("\x00\x00\x00\x06Avast!")
   end
 
   before :each do
@@ -300,35 +304,35 @@ describe StructFu::IntString do
   end
 
   it "should report the correct length with a new string" do
-    @istr.to_s.should == "\x00\x00\x00\x06Avast!"
+    expect(@istr.to_s).to eql("\x00\x00\x00\x06Avast!")
+
     @istr.string = "Ahoy!"
-    @istr.to_s.should == "\x00\x00\x00\x05Ahoy!"
+    expect(@istr.to_s).to eql("\x00\x00\x00\x05Ahoy!")
   end
 
   it "should report the correct length with a new string" do
     @istr.string = "Ahoy!"
-    @istr.to_s.should == "\x00\x00\x00\x05Ahoy!"
+    expect(@istr.to_s).to eql("\x00\x00\x00\x05Ahoy!")
   end
 
   it "should keep the old length with a new string" do
     @istr[:string] = "Ahoy!"
-    @istr.to_s.should == "\x00\x00\x00\x06Ahoy!"
+    expect(@istr.to_s).to eql("\x00\x00\x00\x06Ahoy!")
   end
 
   it "should allow for adjusting the length manually" do
     @istr.len = 16
-    @istr.to_s.should == "\x00\x00\x00\x10Avast!"
+    expect(@istr.to_s).to eql("\x00\x00\x00\x10Avast!")
   end
 
   it "should read in an expected string" do
     data = "\x00\x00\x00\x09Yo ho ho!"
     @istr.read(data)
-    @istr.to_s.should == data
+    expect(@istr.to_s).to eql(data)
   end
 
   it "should raise when a string is too short" do
     data = "\x01A"
-    expect { @istr.read(data) }.to raise_error(StandardError, "String is too short for type StructFu::Int32")
+    expect{ @istr.read(data) }.to raise_error(StandardError, "String is too short for type StructFu::Int32")
   end
-
 end