packetfu 1.1.10 → 1.1.11

data/spec/tcp_spec.rb

@@ -1,101 +1,100 @@
-$:.unshift File.join(File.expand_path(File.dirname(__FILE__)), "..", "lib")
-require 'packetfu'
+require 'spec_helper'
 
 include PacketFu
 
 def unusual_numeric_handling_headers(header,i)
-	camelized_header = header.to_s.split("_").map {|x| x.capitalize}.join
-	header_class = PacketFu.const_get camelized_header
-	specify { subject.send(header).should == i }
-	specify { subject.send(header).should be_kind_of Integer }
-	specify { subject.headers.last[header].should be_kind_of header_class }
+  camelized_header = header.to_s.split("_").map {|x| x.capitalize}.join
+  header_class = PacketFu.const_get camelized_header
+  specify { subject.send(header).should == i }
+  specify { subject.send(header).should be_kind_of Integer }
+  specify { subject.headers.last[header].should be_kind_of header_class }
 end
 
 def tcp_hlen_numeric(i)
-	unusual_numeric_handling_headers(:tcp_hlen,i)
+  unusual_numeric_handling_headers(:tcp_hlen,i)
 end
 
 def tcp_reserved_numeric(i)
-	unusual_numeric_handling_headers(:tcp_reserved,i)
+  unusual_numeric_handling_headers(:tcp_reserved,i)
 end
 
 def tcp_ecn_numeric(i)
-	unusual_numeric_handling_headers(:tcp_ecn,i)
+  unusual_numeric_handling_headers(:tcp_ecn,i)
 end
 
 
 describe TCPPacket do
 
-	subject do
-		bytes = PcapFile.file_to_array(File.join(File.dirname(__FILE__), "sample2.pcap"))[2]
-		packet = Packet.parse(bytes)
-	end
+  subject do
+    bytes = PcapFile.file_to_array(File.join(File.dirname(__FILE__), "sample2.pcap"))[2]
+    packet = Packet.parse(bytes)
+  end
 
-	context "TcpHlen reading and setting" do
-		context "TcpHlen set via #read" do
-			tcp_hlen_numeric(8)
-		end
-		context "TcpHlen set via an Integer for the setter" do
-			(0..15).each do |i|
-				context "i is #{i}" do
-					before { subject.tcp_hlen = i }
-					tcp_hlen_numeric(i)
-				end
-			end
-		end
-		context "TcpHlen set via a String for the setter" do
-			before { subject.tcp_hlen = "\x60" }
-			tcp_hlen_numeric(6)
-		end
-		context "TcpHlen set via a TcpHlen for the setter" do
-			before { subject.tcp_hlen = TcpHlen.new(:hlen => 7) }
-			tcp_hlen_numeric(7)
-		end
-	end
+  context "TcpHlen reading and setting" do
+    context "TcpHlen set via #read" do
+      tcp_hlen_numeric(8)
+    end
+    context "TcpHlen set via an Integer for the setter" do
+      (0..15).each do |i|
+        context "i is #{i}" do
+          before { subject.tcp_hlen = i }
+          tcp_hlen_numeric(i)
+        end
+      end
+    end
+    context "TcpHlen set via a String for the setter" do
+      before { subject.tcp_hlen = "\x60" }
+      tcp_hlen_numeric(6)
+    end
+    context "TcpHlen set via a TcpHlen for the setter" do
+      before { subject.tcp_hlen = TcpHlen.new(:hlen => 7) }
+      tcp_hlen_numeric(7)
+    end
+  end
 
-	context "TcpReserved reading and setting" do
-		context "TcpReserved set via #read" do
-			tcp_reserved_numeric(0)
-		end
-		context "TcpReserved set via an Integer for the setter" do
-			(0..7).each do |i|
-				context "i is #{i}" do
-					before { subject.tcp_reserved = i }
-					tcp_reserved_numeric(i)
-				end
-			end
-		end
-		context "TcpReserved set via a String for the setter" do
-			before { subject.tcp_reserved = "\x03" }
-			tcp_reserved_numeric(3)
-		end
-		context "TcpReserved set via a TcpReserved for the setter" do
-			before { subject.tcp_reserved = TcpReserved.new(:r1 => 1, :r2 => 0, :r3 => 1) }
-			tcp_reserved_numeric(5)
-		end
-	end
+  context "TcpReserved reading and setting" do
+    context "TcpReserved set via #read" do
+      tcp_reserved_numeric(0)
+    end
+    context "TcpReserved set via an Integer for the setter" do
+      (0..7).each do |i|
+        context "i is #{i}" do
+          before { subject.tcp_reserved = i }
+          tcp_reserved_numeric(i)
+        end
+      end
+    end
+    context "TcpReserved set via a String for the setter" do
+      before { subject.tcp_reserved = "\x03" }
+      tcp_reserved_numeric(3)
+    end
+    context "TcpReserved set via a TcpReserved for the setter" do
+      before { subject.tcp_reserved = TcpReserved.new(:r1 => 1, :r2 => 0, :r3 => 1) }
+      tcp_reserved_numeric(5)
+    end
+  end
 
-	context "TcpEcn reading and setting" do
-		context "TcpEcn set via #read" do
-			tcp_ecn_numeric(0)
-		end
-		context "TcpEcn set via an Integer for the setter" do
-			(0..7).each do |i|
-				context "i is #{i}" do
-					before { subject.tcp_ecn = i }
-					tcp_ecn_numeric(i)
-				end
-			end
-		end
-		context "TcpEcn set via a String for the setter" do
-			before { subject.tcp_ecn = "\x00\xc0" }
-			tcp_ecn_numeric(3)
-		end
-		context "TcpEcn set via a TcpEcn for the setter" do
-			before { subject.tcp_ecn = TcpEcn.new(:n => 1, :c => 0, :e => 1) }
-			tcp_ecn_numeric(5)
-		end
-	end
+  context "TcpEcn reading and setting" do
+    context "TcpEcn set via #read" do
+      tcp_ecn_numeric(0)
+    end
+    context "TcpEcn set via an Integer for the setter" do
+      (0..7).each do |i|
+        context "i is #{i}" do
+          before { subject.tcp_ecn = i }
+          tcp_ecn_numeric(i)
+        end
+      end
+    end
+    context "TcpEcn set via a String for the setter" do
+      before { subject.tcp_ecn = "\x00\xc0" }
+      tcp_ecn_numeric(3)
+    end
+    context "TcpEcn set via a TcpEcn for the setter" do
+      before { subject.tcp_ecn = TcpEcn.new(:n => 1, :c => 0, :e => 1) }
+      tcp_ecn_numeric(5)
+    end
+  end
 
 end
 

data/spec/udp_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+include PacketFu
+
+
+describe UDPPacket do
+
+  context "new" do
+
+    it "should create UDP on IPv4 packets by default" do
+      udp = UDPPacket.new
+      expect(udp.ip_header).to be_a(IPHeader)
+      expect(udp.ipv6_header).to be_nil
+    end
+
+    it "should create UDP on IPv6 packets" do
+      udp = UDPPacket.new(:on_ipv6 => true)
+      expect(udp.ip_header).to be_nil
+      expect(udp.ipv6_header).to be_a(IPv6Header)
+
+      udp.ipv6_saddr = "::1"
+      udp.ipv6_daddr = "::2"
+      udp.udp_src = 41000
+      udp.udp_dst = 42000
+      udp.payload = "\0" * 16
+      udp.recalc
+      expect(udp.udp_sum).to eq(0xbb82)
+      expect(udp.udp_len).to eq(24)
+    end
+
+  end
+end

data/spec/utils_spec.rb

@@ -0,0 +1,95 @@
+# -*- coding: binary -*-
+
+require 'spec_helper'
+
+include PacketFu
+
+describe Utils do
+  context "when using ifconfig" do
+    it "should prevent non-interface values" do
+      expect {
+        PacketFu::Utils.ifconfig("not_an_interface")
+      }.to raise_error(ArgumentError, /interface does not exist$/)
+    end
+
+    it "should work on Mac OSX Yosemite" do
+      stub_const("RUBY_PLATFORM", "x86_64-darwin14")
+      mac_osx_reply = "ifconfig en0\n" + 
+                      "en0: flags=8863<UP,BROADCAST,SMART,RUNNING,SIMPLEX,MULTICAST> mtu 1500\n" +
+                      "ether 78:31:c1:ce:39:bc\n" +
+                      "inet6 fe80::7a31:c1ff:fece:39bc%en0 prefixlen 64 scopeid 0x4\n" +
+                      "inet 192.168.10.173 netmask 0xffffff00 broadcast 192.168.10.255\n" +
+                      "nd6 options=1<PERFORMNUD>\n" +
+                      "media: autoselect\n" +
+                      "status: active\n"
+      allow(PacketFu::Utils).to receive(:ifconfig_data_string).and_return(mac_osx_reply)
+      util_reply = PacketFu::Utils.ifconfig("en0")
+
+      # Ensure we got a hash back
+      expect(util_reply).to be_a(::Hash)
+
+      # Ensure all our values parse correctly
+      expect(util_reply[:iface]).to eq("en0")
+      expect(util_reply[:eth_saddr]).to eq("78:31:c1:ce:39:bc")
+      expect(util_reply[:eth_src]).to eq("x1\xC1\xCE9\xBC")
+      expect(util_reply[:ip6_saddr]).to eq("fe80::7a31:c1ff:fece:39bc")
+      expect(util_reply[:ip6_obj]).to eq(IPAddr.new("fe80::7a31:c1ff:fece:39bc"))
+      expect(util_reply[:ip_saddr]).to eq("192.168.10.173")
+      expect(util_reply[:ip_src]).to eq("\xC0\xA8\n\xAD")
+      expect(util_reply[:ip4_obj]).to eq(IPAddr.new("192.168.10.0/24"))
+    end
+
+    it "should work on Ubuntu 14.04 LTS" do
+      stub_const("RUBY_PLATFORM", "x86_64-linux")
+      ubuntu_reply = "eth0      Link encap:Ethernet  HWaddr 00:0c:29:2a:e3:bd\n" + 
+                     "inet addr:192.168.10.174  Bcast:192.168.10.255  Mask:255.255.255.0\n" + 
+                     "inet6 addr: fe80::20c:29ff:fe2a:e3bd/64 Scope:Link\n" + 
+                     "UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1\n" + 
+                     "RX packets:65782 errors:0 dropped:0 overruns:0 frame:0\n" + 
+                     "TX packets:31354 errors:0 dropped:0 overruns:0 carrier:0\n" + 
+                     "collisions:0 txqueuelen:1000\n" + 
+                     "RX bytes:40583515 (40.5 MB)  TX bytes:3349554 (3.3 MB)"
+      allow(PacketFu::Utils).to receive(:ifconfig_data_string).and_return(ubuntu_reply)
+      util_reply = PacketFu::Utils.ifconfig("eth0")
+
+      # Ensure we got a hash back
+      expect(util_reply).to be_a(::Hash)
+
+      # Ensure all our values parse correctly
+      expect(util_reply[:iface]).to eq("eth0")
+      expect(util_reply[:eth_saddr]).to eq("00:0c:29:2a:e3:bd")
+      expect(util_reply[:eth_src]).to eq("\x00\f)*\xE3\xBD")
+      expect(util_reply[:ip6_saddr]).to eq("fe80::20c:29ff:fe2a:e3bd/64")
+      expect(util_reply[:ip6_obj]).to eq(IPAddr.new("fe80::20c:29ff:fe2a:e3bd/64"))
+      expect(util_reply[:ip_saddr]).to eq("192.168.10.174")
+      expect(util_reply[:ip_src]).to eq("\xC0\xA8\n\xAE")
+      expect(util_reply[:ip4_obj]).to eq(IPAddr.new("192.168.10.0/24"))
+    end
+
+    it "should work on FreeBSD" do
+      stub_const("RUBY_PLATFORM", "freebsd")
+      freebsd_reply = "dc0: flags=8843<UP,BROADCAST,RUNNING,SIMPLEX,MULTICAST> metric 0 mtu 1500\n" + 
+                      "options=80008<VLAN_MTU,LINKSTATE>\n" + 
+                      "ether 00:a0:cc:da:da:da\n" + 
+                      "inet 192.168.1.3 netmask 0xffffff00 broadcast 192.168.1.255\n" + 
+                      "media: Ethernet autoselect (100baseTX <full-duplex>)\n" + 
+                      "status: active"
+      allow(PacketFu::Utils).to receive(:ifconfig_data_string).and_return(freebsd_reply)
+      util_reply = PacketFu::Utils.ifconfig("dc0")
+
+      # Ensure we got a hash back
+      expect(util_reply).to be_a(::Hash)
+
+      # Ensure all our values parse correctly
+      expect(util_reply[:iface]).to eq("dc0")
+      expect(util_reply[:eth_saddr]).to eq("00:a0:cc:da:da:da")
+      expect(util_reply[:eth_src]).to eq("\x00\xA0\xCC\xDA\xDA\xDA")
+      expect(util_reply[:ip6_saddr]).to eq(nil)
+      expect(util_reply[:ip6_obj]).to eq(nil)
+      expect(util_reply[:ip_saddr]).to eq("192.168.1.3")
+      expect(util_reply[:ip_src]).to eq("\xC0\xA8\x01\x03")
+      expect(util_reply[:ip4_obj]).to eq(IPAddr.new("192.168.1.0/24"))
+    end
+
+  end
+end

data/test/all_tests.rb

@@ -3,10 +3,7 @@
 # Tested on:
 #
 #   ruby-1.9.3-head [ x86_64 ]  
-#   ruby-1.9.1-p378 [ x86_64 ]  
-#   ruby-1.8.6-p399 [ x86_64 ]  
-#   ruby-1.8.7-p334 [ x86_64 ] 
-#   ruby-1.9.2-p180 [ x86_64 ] 
+#   ruby-1.9.3-p484 [ x86_64 ]
 
 # Okay so the regular test/unit stuff screws up some of my
 # meta magic. I need to move these over to spec and see
@@ -23,19 +20,19 @@ puts "Testing PacketFu v#{PacketFu::VERSION}"
 dir = Dir.new(File.dirname(__FILE__))
 
 dir.each { |file|
-	next unless File.file? file
-	next unless file[/^test_.*rb$/]
-	next if file == $0
-	puts "Running #{file}..."
-	cmd = %x{ruby #{file}}
-	if cmd[/ 0 failures/] && cmd[/ 0 errors/] 
-		puts "#{file}: All passed"
-	else
-		puts "File: #{file} had failures or errors:"
-		puts "-" * 80
-		puts cmd
-		puts "-" * 80
-	end
+  next unless File.file? file
+  next unless file[/^test_.*rb$/]
+  next if file == $0
+  puts "Running #{file}..."
+  cmd = %x{ruby #{file}}
+  if cmd[/ 0 failures/] && cmd[/ 0 errors/] 
+    puts "#{file}: All passed"
+  else
+    puts "File: #{file} had failures or errors:"
+    puts "-" * 80
+    puts cmd
+    puts "-" * 80
+  end
 }
 
 # vim: nowrap sw=2 sts=0 ts=2 ff=unix ft=ruby

data/test/func_lldp.rb

@@ -6,12 +6,12 @@ $:.unshift File.join(File.expand_path(File.dirname(__FILE__)), "..", "lib")
 require 'packetfu'
 
 def lldp_pcap
-	fname = "./sample_lldp.pcap"
-	fname if File.readable? fname
+  fname = "./sample_lldp.pcap"
+  fname if File.readable? fname
 end
 
 def lldp_test()
-	raise RuntimeError, "Need a sample_lldp.pcap to check!" unless lldp_pcap
+  raise RuntimeError, "Need a sample_lldp.pcap to check!" unless lldp_pcap
   cap = PacketFu::PcapFile.new.file_to_array(:filename => lldp_pcap)
   cap.each do |p|
         pkt = PacketFu::Packet.parse p

data/test/ptest.rb

@@ -5,9 +5,9 @@ require 'packetfu'
 include PacketFu
 
 if Process.euid.zero? 
-	puts ">> Interface: " << Pcap.lookupdev
+  puts ">> Interface: " << Pcap.lookupdev
 else
-	puts ">> No interface access"
+  puts ">> No interface access"
 end	
 puts ">> Version: " << PacketFu.version
 

data/test/test_capture.rb

@@ -6,51 +6,51 @@ require 'packetfu'
 
 class CaptureTest < Test::Unit::TestCase
 
-	def test_cap
-		assert_nothing_raised { PacketFu::Capture }
-	end
-
-	def test_whoami
-		assert_nothing_raised { PacketFu::Utils.whoami?(:iface => (ENV['IFACE'] || 'lo')) }
-	end
-	
-	def test_new
-		cap = PacketFu::Capture.new
-		assert_kind_of PacketFu::Capture, cap
-		cap = PacketFu::Capture.new(
-			:filter => 'tcp and dst host 1.2.3.4'
-		)
-	end
-	
-	def test_filter
-		daddr = PacketFu::Utils.rand_routable_daddr.to_s
-		cap = PacketFu::Capture.new( :filter => "icmp and dst host #{daddr}")
-		cap.start
-		%x{ping -c 1 #{daddr}}
-		sleep 1
-		cap.save
-		assert cap.array.size == 1
-		pkt = PacketFu::Packet.parse(cap.array.first)
-		assert pkt.ip_daddr == daddr
-	end
-	
-	def test_no_filter
-		daddr = PacketFu::Utils.rand_routable_daddr.to_s
-		daddr2 = PacketFu::Utils.rand_routable_daddr.to_s
-		cap = PacketFu::Capture.new
-		cap.start
-		%x{ping -c 1 #{daddr}}
-		%x{ping -c 1 #{daddr2}}
-		sleep 1
-		cap.save
-		assert cap.array.size > 1
-	end
-
-	def test_bpf_alias
-		daddr = PacketFu::Utils.rand_routable_daddr.to_s
-		cap = PacketFu::Capture.new( :filter => "icmp and dst host #{daddr}")
-		assert cap.filter.object_id == cap.bpf.object_id
-	end
+  def test_cap
+    assert_nothing_raised { PacketFu::Capture }
+  end
+
+  def test_whoami
+    assert_nothing_raised { PacketFu::Utils.whoami?(:iface => PacketFu::Utils.default_int) }
+  end
+  
+  def test_new
+    cap = PacketFu::Capture.new
+    assert_kind_of PacketFu::Capture, cap
+    cap = PacketFu::Capture.new(
+      :filter => 'tcp and dst host 1.2.3.4'
+    )
+  end
+  
+  def test_filter
+    daddr = PacketFu::Utils.rand_routable_daddr.to_s
+    cap = PacketFu::Capture.new( :filter => "icmp and dst host #{daddr}")
+    cap.start
+    %x{ping -c 1 #{daddr}}
+    sleep 1
+    cap.save
+    assert cap.array.size == 1
+    pkt = PacketFu::Packet.parse(cap.array.first)
+    assert pkt.ip_daddr == daddr
+  end
+  
+  def test_no_filter
+    daddr = PacketFu::Utils.rand_routable_daddr.to_s
+    daddr2 = PacketFu::Utils.rand_routable_daddr.to_s
+    cap = PacketFu::Capture.new
+    cap.start
+    %x{ping -c 1 #{daddr}}
+    %x{ping -c 1 #{daddr2}}
+    sleep 1
+    cap.save
+    assert cap.array.size > 1
+  end
+
+  def test_bpf_alias
+    daddr = PacketFu::Utils.rand_routable_daddr.to_s
+    cap = PacketFu::Capture.new( :filter => "icmp and dst host #{daddr}")
+    assert cap.filter.object_id == cap.bpf.object_id
+  end
 
 end