packetfu 1.1.13 → 2.0.0

data/lib/packetfu/protos/icmpv6.rb

@@ -23,7 +23,7 @@ module PacketFu
   #  icmpv6_pkt.ipv6_saddr="2000::1234"
   #  icmpv6_pkt.ipv6_daddr="2000::5678"
   #
-  #  icmpv6_pkt.recalc	
+  #  icmpv6_pkt.recalc
   #  icmpv6_pkt.to_f('/tmp/icmpv6.pcap')
   #
   # == Parameters
@@ -49,13 +49,6 @@ module PacketFu
       return true
     end
 
-    def read(str=nil, args={})
-      raise "Cannot parse `#{str}'" unless self.class.can_parse?(str)
-      @eth_header.read(str)
-      super(args)
-      self
-    end
-
     def initialize(args={})
       @eth_header = EthHeader.new(args).read(args[:eth])
       @ipv6_header = IPv6Header.new(args).read(args[:ipv6])
@@ -72,12 +65,7 @@ module PacketFu
 
     # Calculates the checksum for the object.
     def icmpv6_calc_sum
-      checksum = 0
-
-      # Compute sum on pseudo-header
-      [ipv6_src, ipv6_dst].each do |iaddr|
-        8.times { |i| checksum += (iaddr >> (i*16)) & 0xffff }
-      end
+      checksum = ipv6_calc_sum_on_addr
       checksum += PacketFu::ICMPv6Header::PROTOCOL_NUMBER
       checksum += ipv6_len
       # Then compute it on ICMPv6 header + payload
@@ -96,9 +84,8 @@ module PacketFu
     end
 
     # Recalculates the calculatable fields for ICMPv6.
-    def icmpv6_recalc(arg=:all)
-      arg = arg.intern if arg.respond_to? :intern
-      case arg
+    def icmpv6_recalc(arg = :all)
+      case arg.to_sym
       when :icmpv6_sum
         self.icmpv6_sum = icmpv6_calc_sum
       when :all

data/lib/packetfu/protos/ip/header.rb

@@ -107,7 +107,7 @@ module PacketFu
   #   Int16            :ip_len,   Default: calculated
   #   Int16            :ip_id,    Default: calculated  # IRL, hardly random.
   #   Int16            :ip_frag,  Default: 0           # TODO: Break out the bits
-  #   Int8             :ip_ttl,   Default: 0xff        # Changes per flavor
+  #   Int8             :ip_ttl,   Default: 64          # https://www.iana.org/assignments/ip-parameters/ip-parameters.xml
   #   Int8             :ip_proto, Default: 0x01        # TCP: 0x06, UDP 0x11, ICMP 0x01
   #   Int16            :ip_sum,   Default: calculated
   #   Octets           :ip_src
@@ -131,7 +131,7 @@ module PacketFu
         Int16.new(args[:ip_len] || 20),
         Int16.new(args[:ip_id] || ip_calc_id),
         Int16.new(args[:ip_frag]),
-        Int8.new(args[:ip_ttl] || 32),
+        Int8.new(args[:ip_ttl] || 64),
         Int8.new(args[:ip_proto]),
         Int16.new(args[:ip_sum] || ip_calc_sum),
         Octets.new.read(args[:ip_src] || "\x00\x00\x00\x00"),

data/lib/packetfu/protos/ip/mixin.rb

@@ -40,5 +40,14 @@ module PacketFu
     def ip_ttl=(v); self.ip_header.ip_ttl= v; end
     def ip_v; self.ip_header.ip_v ; end
     def ip_v=(v); self.ip_header.ip_v= v; end
+
+    # Add method to each packet class on IP to ease checksum computation
+    def ip_calc_sum_on_addr(cksum=0)
+      checksum = cksum
+      checksum += (ip_src.to_i >> 16)
+      checksum += (ip_src.to_i & 0xffff)
+      checksum += (ip_dst.to_i >> 16)
+      checksum += (ip_dst.to_i & 0xffff)
+    end
   end
 end

data/lib/packetfu/protos/ip.rb

@@ -16,7 +16,6 @@ module PacketFu
   #   ip_pkt.ip_saddr="10.20.30.40"
   #   ip_pkt.ip_daddr="192.168.1.1"
   #   ip_pkt.ip_proto=1
-  #   ip_pkt.ip_ttl=64
   #   ip_pkt.ip_payload="\x00\x00\x12\x34\x00\x01\x00\x01"+
   #     "Lovingly hand-crafted echo responses delivered directly to your door."
   #   ip_pkt.recalc
@@ -54,13 +53,6 @@ module PacketFu
       end
     end
 
-    def read(str=nil, args={})
-      raise "Cannot parse `#{str}'" unless self.class.can_parse?(str)
-      @eth_header.read(str)
-      super(args)
-      self
-    end
-
     # Creates a new IPPacket object.
     def initialize(args={})
       @eth_header = EthHeader.new(args).read(args[:eth])

data/lib/packetfu/protos/ipv6/mixin.rb

@@ -28,5 +28,17 @@ module PacketFu
     def ipv6_daddr=(v); self.ipv6_header.ipv6_daddr= v; end
     def ipv6_src_readable; self.ipv6_header.ipv6_src_readable; end
     def ipv6_dst_readable; self.ipv6_header.ipv6_dst_readable; end
+    def ipv6?; not self.ipv6_header.nil?; end
+
+    # Add method to each packet class on IPv6 to ease checksum computation
+    def ipv6_calc_sum_on_addr(cksum=0)
+      checksum = cksum
+      [ipv6_src, ipv6_dst].each do |iaddr|
+        8.times do |i|
+          checksum += (iaddr >> (i * 16)) & 0xffff
+        end
+      end
+      checksum
+    end
   end
 end

data/lib/packetfu/protos/ipv6.rb

@@ -34,13 +34,6 @@ module PacketFu
       true
     end
 
-    def read(str=nil,args={})
-      raise "Cannot parse `#{str}'" unless self.class.can_parse?(str)
-      @eth_header.read(str)
-      super(args)
-      self
-    end
-
     def initialize(args={})
       @eth_header = (args[:eth] || EthHeader.new)
       @ipv6_header = (args[:ipv6]	|| IPv6Header.new)

data/lib/packetfu/protos/lldp.rb

@@ -8,7 +8,7 @@ require 'packetfu/protos/lldp/mixin'
 module PacketFu
 
   class LLDPPacket < Packet
-    MAGIC = Regexp.new("^\x01\x80\xc2\x00\x00[\x0e\x03\x00]", nil, "n")
+    MAGIC = Regexp.new("^\x01\x80\xc2\x00\x00[\x0e\x03\x00]".force_encoding('ASCII-8BIT'), Regexp::NOENCODING)
     include ::PacketFu::EthHeaderMixin
     include ::PacketFu::LLDPHeaderMixin
 
@@ -22,13 +22,6 @@ module PacketFu
       true
     end
 
-    def read(str=nil,args={})
-      raise "Cannot parse `#{str}'" unless self.class.can_parse?(str)
-      @eth_header.read(str)
-      super(args)
-      self
-    end
-
     def initialize(args={})
       @eth_header = EthHeader.new(args).read(args[:eth])
       @lldp_header = LLDPHeader.new(args).read(args[:lldp])

data/lib/packetfu/protos/tcp.rb

@@ -8,6 +8,9 @@ require 'packetfu/protos/tcp/mixin'
 require 'packetfu/protos/ip/header'
 require 'packetfu/protos/ip/mixin'
 
+require 'packetfu/protos/ipv6/header'
+require 'packetfu/protos/ipv6/mixin'
+
 module PacketFu
   # TCPPacket is used to construct TCP packets. They contain an EthHeader, an IPHeader, and a TCPHeader.
   #
@@ -25,6 +28,16 @@ module PacketFu
   #    tcp_pkt.recalc
   #    tcp_pkt.to_f('/tmp/tcp.pcap')
   #
+  #    tcp6_pkt = PacketFu::TCPPacket.new(:on_ipv6 => true)
+  #    tcp6_pkt.tcp_flags.syn=1
+  #    tcp6_pkt.tcp_dst=80
+  #    tcp6_pkt.tcp_win=5840
+  #    tcp6_pkt.tcp_options="mss:1460,sack.ok,ts:#{rand(0xffffffff)};0,nop,ws:7"
+  #    tcp6_pkt.ipv6_saddr="4::1"
+  #    tcp6_pkt.ipv6_daddr="12:3::4567"
+  #    tcp6_pkt.recalc
+  #    tcp6_pkt.to_f('/tmp/udp.pcap')
+  #
   # == Parameters
   #  :eth
   #    A pre-generated EthHeader object.
@@ -41,42 +54,58 @@ module PacketFu
   class TCPPacket < Packet
     include ::PacketFu::EthHeaderMixin
     include ::PacketFu::IPHeaderMixin
+    include ::PacketFu::IPv6HeaderMixin
     include ::PacketFu::TCPHeaderMixin
 
-    attr_accessor :eth_header, :ip_header, :tcp_header
+    attr_accessor :eth_header, :ip_header, :ipv6_header, :tcp_header
 
     def self.can_parse?(str)
       return false unless str.size >= 54
       return false unless EthPacket.can_parse? str
-      return false unless IPPacket.can_parse? str
-      return false unless str[23,1] == "\x06"
-      return true
+      if IPPacket.can_parse? str
+        return true if str[23,1] == "\x06"
+      elsif IPv6Packet.can_parse? str
+        return true if str[20,1] == "\x06"
+      end
+      return false
     end
 
     def read(str=nil, args={})
-      raise "Cannot parse `#{str}'" unless self.class.can_parse?(str)
-      @eth_header.read(str)
-
+      super
       # Strip off any extra data, if we are asked to do so.
       if args[:strip]
         tcp_body_len = self.ip_len - self.ip_hlen - (self.tcp_hlen * 4)
         @tcp_header.body.read(@tcp_header.body.to_s[0,tcp_body_len])
+        tcp_calc_sum
+        @ip_header.ip_recalc
       end
-      super(args)
       self
     end
 
     def initialize(args={})
-      @eth_header = 	(args[:eth] || EthHeader.new)
-      @ip_header 	= 	(args[:ip]	|| IPHeader.new)
-      @tcp_header = 	(args[:tcp] || TCPHeader.new)
-      @tcp_header.flavor = args[:flavor].to_s.downcase
+      if args[:on_ipv6] or args[:ipv6]
+        @eth_header = EthHeader.new(args.merge(:eth_proto => 0x86dd)).read(args[:eth])
+        @ipv6_header = IPv6Header.new(args).read(args[:ipv6])
+        @tcp_header = TCPHeader.new(args).read(args[:tcp])
+
+        @ipv6_header.body = @tcp_header
+        @eth_header.body = @ipv6_header
+        @headers = [@eth_header, @ipv6_header, @tcp_header]
+
+        @ipv6_header.ipv6_next = 0x06
+      else
+        @eth_header = EthHeader.new(args.merge(:eth_proto => 0x0800)).read(args[:eth])
+        @ip_header = IPHeader.new(args).read(args[:ip])
+        @tcp_header = TCPHeader.new(args).read(args[:tcp])
 
-      @ip_header.body = @tcp_header
-      @eth_header.body = @ip_header
-      @headers = [@eth_header, @ip_header, @tcp_header]
+        @ip_header.body = @tcp_header
+        @eth_header.body = @ip_header
+        @headers = [@eth_header, @ip_header, @tcp_header]
+
+        @ip_header.ip_proto = 0x06
+      end
+      @tcp_header.flavor = args[:flavor].to_s.downcase
 
-      @ip_header.ip_proto=0x06
       super
       if args[:flavor]
         tcp_calc_flavor(@tcp_header.flavor)
@@ -118,12 +147,16 @@ module PacketFu
     # from the IP header, too.
     #++
     def tcp_calc_sum
-      checksum =  (ip_src.to_i >> 16)
-      checksum += (ip_src.to_i & 0xffff)
-      checksum += (ip_dst.to_i >> 16)
-      checksum += (ip_dst.to_i & 0xffff)
+      if @ipv6_header
+        checksum = ipv6_calc_sum_on_addr
+        tcp_len = ipv6_len
+      else
+        checksum = ip_calc_sum_on_addr
+        tcp_len = ip_len.to_i - ((ip_hl.to_i) * 4)
+      end
+
       checksum += 0x06 # TCP Protocol.
-      checksum +=	(ip_len.to_i - ((ip_hl.to_i) * 4))
+      checksum += tcp_len
       checksum += tcp_src
       checksum += tcp_dst
       checksum += (tcp_seq.to_i >> 16)
@@ -140,8 +173,8 @@ module PacketFu
 
       chk_tcp_opts = (tcp_opts.to_s.size % 2 == 0 ? tcp_opts.to_s : tcp_opts.to_s + "\x00") 
       chk_tcp_opts.unpack("n*").each {|x| checksum = checksum + x }
-      if (ip_len - ((ip_hl + tcp_hlen) * 4)) >= 0
-        real_tcp_payload = payload[0,( ip_len - ((ip_hl + tcp_hlen) * 4) )] # Can't forget those pesky FCSes!
+      if (tcp_len - (tcp_hlen * 4)) >= 0
+        real_tcp_payload = payload[0, (tcp_len - (tcp_hlen * 4))] # Can't forget those pesky FCSes!
       else
         real_tcp_payload = payload # Something's amiss here so don't bother figuring out where the real payload is.
       end
@@ -181,19 +214,29 @@ module PacketFu
     # source and dest information, packet flags, sequence
     # number, and IPID.
     def peek_format
-      peek_data = ["T  "]
-      peek_data << "%-5d" % self.to_s.size
-      peek_data << "%-21s" % "#{self.ip_saddr}:#{self.tcp_src}"
-      peek_data << "->"
-      peek_data << "%21s" % "#{self.ip_daddr}:#{self.tcp_dst}"
+      if ipv6?
+        peek_data = ["6T "]
+        peek_data << "%-5d" % self.to_s.size
+        peek_data << "%-31s" % "#{self.ipv6_saddr}:#{self.tcp_src}"
+        peek_data << "->"
+        peek_data << "%31s" % "#{self.ipv6_daddr}:#{self.tcp_dst}"
+      else
+        peek_data = ["T  "]
+        peek_data << "%-5d" % self.to_s.size
+        peek_data << "%-21s" % "#{self.ip_saddr}:#{self.tcp_src}"
+        peek_data << "->"
+        peek_data << "%21s" % "#{self.ip_daddr}:#{self.tcp_dst}"
+      end
       flags = ' ['
       flags << self.tcp_flags_dotmap
       flags << '] '
       peek_data << flags
       peek_data << "S:"
       peek_data << "%08x" % self.tcp_seq
-      peek_data << "|I:"
-      peek_data << "%04x" % self.ip_id
+      unless ipv6?
+        peek_data << "|I:"
+        peek_data << "%04x" % self.ip_id
+      end
       peek_data.join
     end
 

data/lib/packetfu/protos/udp/header.rb

@@ -10,7 +10,7 @@ module PacketFu
   #  Int16   :udp_src
   #  Int16   :udp_dst
   #  Int16   :udp_len  Default: calculated
-  #  Int16   :udp_sum  Default: 0. Often calculated. 
+  #  Int16   :udp_sum  Default: 0. Often calculated.
   #  String  :body
   class UDPHeader < Struct.new(:udp_src, :udp_dst, :udp_len, :udp_sum, :body)
 
@@ -66,9 +66,8 @@ module PacketFu
     end
 
     # Recalculates calculated fields for UDP.
-    def udp_recalc(args=:all)
-      arg = arg.intern if arg.respond_to? :intern
-      case args
+    def udp_recalc(arg = :all)
+      case arg.to_sym
       when :udp_len
         self.udp_len = udp_calc_len
       when :all
@@ -92,7 +91,7 @@ module PacketFu
     def udp_dport
       self.udp_dst
     end
-    
+
     # Equivalent to udp_dst=
     def udp_dport=(arg)
       self.udp_dst=(arg)

data/lib/packetfu/protos/udp.rb

@@ -64,13 +64,13 @@ module PacketFu
     end
 
     def read(str=nil, args={})
-      raise "Cannot parse `#{str}'" unless self.class.can_parse?(str)
-      @eth_header.read(str)
+      super
       if args[:strip]
         udp_body_len = self.ip_len - self.ip_hlen - 8
         @udp_header.body.read(@udp_header.body.to_s[0,udp_body_len])
+        udp_calc_sum
+        @ip_header.ip_recalc unless ipv6?
       end
-      super(args)
       self
     end
 
@@ -103,19 +103,12 @@ module PacketFu
     def udp_calc_sum
       # This is /not/ delegated down to @udp_header since we need info
       # from the IP header, too.
-      checksum = 0
       if @ipv6_header
-        [ipv6_src, ipv6_dst].each do |iaddr|
-          8.times do |i|
-            checksum += (iaddr >> (i * 16)) & 0xffff
-          end
-        end
+        checksum = ipv6_calc_sum_on_addr
       else
-        checksum += (ip_src.to_i >> 16)
-        checksum += (ip_src.to_i & 0xffff)
-        checksum += (ip_dst.to_i >> 16)
-        checksum += (ip_dst.to_i & 0xffff)
+        checksum = ip_calc_sum_on_addr
       end
+
       checksum += 0x11
       checksum += udp_len.to_i
       checksum += udp_src.to_i
@@ -179,11 +172,6 @@ module PacketFu
       end
     end
 
-    # Is that packet an UDP on IPv6 packet ?
-    def ipv6?
-      not @ipv6_header.nil?
-    end
-
   end
 
 end

data/lib/packetfu/structfu.rb

@@ -18,7 +18,7 @@ module StructFu
   # expected type for that element.
   def typecast(i)
     c = caller[0].match(/.*`([^']+)='/)[1]
-    self[c.intern].read i
+    self[c.to_sym].read i
   end
 
   # Used like typecast(), but specifically for casting Strings to StructFu::Strings.

data/lib/packetfu/version.rb

@@ -2,7 +2,7 @@
 module PacketFu
 
   # Check the repo's for version release histories
-  VERSION = "1.1.13"
+  VERSION = "2.0.0"
 
   # Returns PacketFu::VERSION
   def self.version

data/packetfu.gemspec

@@ -1,4 +1,3 @@
-require 'rake'
 require './lib/packetfu/version'
 
 Gem::Specification.new do |s|
@@ -14,26 +13,19 @@ Gem::Specification.new do |s|
     ease and fun they expect from Ruby.
   }
   s.files       = `git ls-files`.split($/)
-  s.license     = 'BSD'
-  s.required_ruby_version = '>= 2.1.0'
-  s.add_dependency('pcaprub')
+  s.license     = 'BSD-3-Clause'
+  s.required_ruby_version = '>= 2.7.0'
+  s.add_dependency('pcaprub', '~> 0.13.1')
   s.add_development_dependency('rake')
-  s.add_development_dependency('rspec')
-  s.add_development_dependency('rspec-its')
-  s.add_development_dependency('sdoc')
-  s.add_development_dependency('pry')
-  s.add_development_dependency('coveralls')
-
+  s.add_development_dependency('rspec', '~> 3.0')
+  s.add_development_dependency('rspec-its', '~> 1.2')
+  s.add_development_dependency('sdoc', '~> 0.4')
+  s.add_development_dependency('pry-byebug')
+  s.add_development_dependency('coveralls', '~> 0.8')
 
   s.extra_rdoc_files  = %w[.document README.md]
   s.test_files        = (s.files & (Dir['spec/**/*_spec.rb'] + Dir['test/test_*.rb']) )
-  s.rubyforge_project = 'packetfu'
-
-  cert = File.expand_path("~/.ssh/gem-private_key_todb.pem")
-
-  if File.exist?(cert) and File.readable?(cert)
-    s.signing_key = cert
-    s.cert_chain = ['gem-public_cert.pem']
-  end
 
+  s.cert_chain = ['certs/todb.pem']
+  s.signing_key = File.expand_path("~/.ssh/gem-private_key.pem") if $0 =~ /gem\z/
 end

data/spec/arp_spec.rb

@@ -190,7 +190,7 @@ describe ARPPacket do
       expect(@temp_file.read).to eql("")
 
       @arp_packet.to_f(@temp_file.path, 'a')
-      expect(File.exists?(@temp_file.path)).to be(true)
+      expect(File.exist?(@temp_file.path)).to be(true)
       expect(@temp_file.read.size).to be >= 76
     end
   end

data/spec/capture_spec.rb

@@ -0,0 +1,137 @@
+# -*- coding: binary -*-
+require 'spec_helper'
+require 'packetfu/protos/eth'
+require 'packetfu/protos/ip'
+require 'packetfu/protos/ipv6'
+require 'packetfu/protos/tcp'
+require 'packetfu/protos/icmp'
+require 'packetfu/config'
+require 'packetfu/pcap'
+require 'packetfu/utils'
+require 'tempfile'
+
+include PacketFu
+
+describe Capture do
+
+  if Process.uid != 0
+    warn "Not running as root, PacketFu::Capture capabilities that require root will be skipped"
+  end
+
+  context "when creating an object from scratch" do
+    before :each do
+      @capture = PacketFu::Capture.new
+    end
+
+    it "should have sane defaults" do
+      expect(@capture.array).to be_kind_of(Array)
+      expect(@capture.stream).to be_kind_of(Array)
+      expect(@capture.iface).to be_kind_of(String)
+      expect(@capture.snaplen).to eql(65535)
+      expect(@capture.promisc).to eql(false)
+      expect(@capture.timeout).to eql(1)
+
+      # Requires root/sudo to get this...
+      if Process.uid == 0
+        expect(@capture.filter).to eql(nil)
+      else
+        expect{@capture.filter}.to raise_error(RuntimeError)
+      end
+    end
+
+    it "should allow creating a capture 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,
+          :filter => "not port 22",
+        }
+        @capture = PacketFu::Capture.new(options)
+
+        expect(@capture.array).to be_kind_of(Array)
+        expect(@capture.stream).to be_kind_of(PCAPRUB::Pcap)
+        expect(@capture.iface).to eql(options[:iface])
+        expect(@capture.snaplen).to eql(options[:snaplen])
+        expect(@capture.promisc).to eql(options[:promisc])
+        expect(@capture.timeout).to eql(options[:timeout])
+        expect(@capture.filter).to eql(options[:filter])
+        expect(@capture.bpf).to eql(options[:filter])
+      end
+    end
+  end
+
+  context "when capturing traffic on the wire" do
+    # Can only run this if we're root
+    if Process.uid == 0
+      it "should capture an ICMP echo request from the wire" do
+        daddr = PacketFu::Utils.rand_routable_daddr.to_s
+
+        def do_capture_test(daddr)
+          begin
+            Timeout::timeout(3) {
+              cap = PacketFu::Capture.new(:iface => PacketFu::Utils::default_int, :start => true)
+              cap.stream.each do |p|
+                pkt = PacketFu::Packet.parse p
+                next unless pkt.is_icmp?
+
+                if pkt.ip_daddr == daddr and pkt.icmp_type == 8
+                  return true
+                end
+              end
+            }
+          rescue Timeout::Error
+            return false
+          end
+        end
+
+        capture_thread = Thread.new { expect(do_capture_test(daddr)).to eql(true) }
+        %x{ping -c 1 #{daddr}}
+        capture_thread.join
+      end
+
+      it "should capture only capture ICMP echo requests we ask for from the wire" do
+        daddr = PacketFu::Utils.rand_routable_daddr.to_s
+        daddr2 = PacketFu::Utils.rand_routable_daddr.to_s
+
+        def do_bpf_capture_test(daddr, daddr2)
+          count = 0
+          valid_icmp = false
+          invalid_icmp = false
+
+          begin
+            Timeout::timeout(3) {
+              cap = PacketFu::Capture.new(:iface => PacketFu::Utils::default_int, :start => true, :filter => "icmp and dst host #{daddr}")
+              cap.stream.each do |p|
+                pkt = PacketFu::Packet.parse p
+                next unless pkt.is_icmp?
+                count += 1
+
+                if pkt.ip_daddr == daddr and pkt.icmp_type == 8
+                  valid_icmp = true
+                elsif pkt.ip_daddr == daddr2 and pkt.icmp_type == 8
+                  invalid_icmp = true
+                end
+              end
+            }
+          rescue Timeout::Error
+            ### do nothing, we need to wait for the timeout anyways
+          end
+
+          if count == 1 && valid_icmp == true && invalid_icmp == false
+            return true
+          else
+            return false
+          end
+        end
+
+        capture_thread = Thread.new { expect(do_bpf_capture_test(daddr,daddr2)).to eql(true) }
+        %x{ping -c 1 #{daddr}}
+        %x{ping -c 1 #{daddr2}}
+        capture_thread.join
+      end
+    end
+  end
+end

data/spec/eth_spec.rb

@@ -130,7 +130,7 @@ describe EthPacket do
       expect(@temp_file.read).to eql("")
 
       @eth_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 >= 30
     end
 

data/spec/icmp_spec.rb

@@ -87,7 +87,7 @@ describe ICMPPacket, "when read from a pcap file" do
       expect(@temp_file.read).to eql("")
 
       @icmp_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 >= 79
     end
 

data/spec/icmpv6_spec.rb

@@ -80,7 +80,7 @@ describe ICMPv6Packet, "when read from a pcap file" do
       expect(@temp_file.read).to eql("")
 
       @icmpv6_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 >= 79
     end