packetfu 1.1.2 → 1.1.3

data/test/tcp_spec.rb

@@ -0,0 +1,101 @@
+$:.unshift File.join(File.expand_path(File.dirname(__FILE__)), "..", "lib")
+require 'packetfu'
+
+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 }
+end
+
+def tcp_hlen_numeric(i)
+	unusual_numeric_handling_headers(:tcp_hlen,i)
+end
+
+def tcp_reserved_numeric(i)
+	unusual_numeric_handling_headers(:tcp_reserved,i)
+end
+
+def tcp_ecn_numeric(i)
+	unusual_numeric_handling_headers(:tcp_ecn,i)
+end
+
+
+describe TCPPacket do
+
+	subject do
+		bytes = PcapFile.file_to_array("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 "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
+
+end
+

data/test/test_arp.rb

@@ -0,0 +1,135 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+$:.unshift File.join(File.expand_path(File.dirname(__FILE__)), "..", "lib")
+require 'packetfu'
+class ArpTest < Test::Unit::TestCase
+	include PacketFu
+
+	def test_arp_header
+		a = ARPHeader.new
+		assert_kind_of ARPHeader, a 
+		assert_kind_of StructFu::Int16, a[:arp_hw]
+		assert_kind_of Fixnum, a.arp_hw
+		assert_kind_of Octets, a[:arp_src_ip]
+		assert_kind_of String, a.arp_src_ip
+		assert_kind_of EthMac, a[:arp_dst_mac]
+		assert_kind_of String, a.arp_dst_mac
+		assert_kind_of StructFu::String, a.body 
+	end
+
+	def test_read_header
+		a = ARPHeader.new
+		sample_arp = "000108000604000200032f1a74dec0a80102001b1151b7cec0a80169"
+		sample_arp = sample_arp.scan(/../).map {|x| x.to_i(16)}.pack("C*")
+		a.read(sample_arp)
+		assert_equal(sample_arp, a.to_s)
+		assert_equal("192.168.1.105", a.arp_daddr_ip)
+		assert_equal("192.168.1.2", a.arp_saddr_ip)
+		assert_equal("00:1b:11:51:b7:ce", a.arp_daddr_mac)
+		assert_equal("00:03:2f:1a:74:de", a.arp_saddr_mac)
+	end
+
+	def test_arp_read
+		a = ARPPacket.new
+		sample_arp = "001b1151b7ce00032f1a74de0806000108000604000200032f1a74dec0a80102001b1151b7cec0a80169c0a80169"
+		sample_arp = sample_arp.scan(/../).map {|x| x.to_i(16)}.pack("C*")
+		a.read(sample_arp)
+		assert_equal(sample_arp, a.to_s)
+	end
+
+	def test_write_ip
+		a = ARPPacket.new
+		a.arp_saddr_ip="1.2.3.4"
+		a.arp_daddr_ip="5.6.7.8"
+		assert_equal("1.2.3.4",a.arp_saddr_ip)
+		assert_equal("5.6.7.8",a.arp_daddr_ip)
+		assert_equal("\x01\x02\x03\x04",a.arp_src_ip)
+		assert_equal("\x05\x06\x07\x08",a.arp_dst_ip)
+	end
+
+	def test_write_mac
+		a = ARPPacket.new
+		a.arp_saddr_mac = "00:01:02:03:04:05"
+		a.arp_daddr_mac = "00:06:07:08:09:0a"
+		assert_equal("00:01:02:03:04:05",a.arp_saddr_mac)
+		assert_equal("00:06:07:08:09:0a",a.arp_daddr_mac)
+		assert_equal("\x00\x01\x02\x03\x04\x05",a.arp_src_mac)
+		assert_equal("\x00\x06\x07\x08\x09\x0a",a.arp_dst_mac)
+	end
+
+	def test_arp_flavors
+		a = ARPPacket.new(:flavor => "Windows")
+		assert_equal("\x00" * 64, a.payload)
+		a = ARPPacket.new(:flavor => "Linux")
+		assert_equal(32, a.payload.size)
+		a = ARPPacket.new(:flavor => :hp_deskjet)
+		assert_equal(18, a.payload.size)
+		a = ARPPacket.new
+		assert_equal("\x00" * 18, a.payload)
+	end
+
+	def test_arp_create
+		sample_arp = "000108000604000200032f1a74dec0a80102001b1151b7cec0a80169"
+		sample_arp = sample_arp.scan(/../).map {|x| x.to_i(16)}.pack("C*")
+		a = ARPPacket.new
+		assert_kind_of ARPPacket, a
+		a.arp_hw = 1
+		a.arp_proto = 0x0800
+		a.arp_hw_len = 6
+		a.arp_proto_len = 4 
+		a.arp_opcode = 2
+		a.arp_src_mac = "\x00\x03\x2f\x1a\x74\xde"
+		a.arp_src_ip = "\xc0\xa8\x01\x02"
+		a.arp_dst_mac = "\x00\x1b\x11\x51\xb7\xce"
+		a.arp_dst_ip = "\xc0\xa8\x01\x69"
+		a.payload = ""
+		assert_equal(sample_arp,a.to_s[14,0xffff])
+	end
+
+	def test_arp_new
+		sample_arp = "000108000604000200032f1a74dec0a80102001b1151b7cec0a80169c0a80169"
+		sample_arp = sample_arp.scan(/../).map {|x| x.to_i(16)}.pack("C*")
+		arp = ARPPacket.new(:arp_hw => 1, :arp_proto => 0x0800,
+											 :arp_opcode => 2, :arp_src_ip => "\xc0\xa8\x01\x02")
+		assert_kind_of ARPPacket, arp
+		arp.arp_hw_len = 6
+		arp.arp_proto_len = 4 
+		arp.arp_src_mac = "\x00\x03\x2f\x1a\x74\xde"
+		arp.arp_dst_mac = "\x00\x1b\x11\x51\xb7\xce"
+		arp.arp_dst_ip = "\xc0\xa8\x01\x69"
+		arp.payload = "\xc0\xa8\x01\x69"
+		assert_equal(sample_arp,arp.to_s[14,0xffff])
+	end
+
+	def test_arp_peek
+		a = ARPPacket.new
+		puts "\n"
+		puts "ARP Peek format: "
+		puts a.peek
+		puts "\n"
+		assert(a.peek.size <= 80)
+	end
+
+	def test_arp_pcap
+		a = ARPPacket.new
+		assert_kind_of ARPPacket, a
+		a.to_f('arp_test.pcap','w')
+		a.arp_hw = 1
+		a.arp_proto = 0x0800
+		a.arp_hw_len = 6
+		a.arp_proto_len = 4 
+		a.arp_opcode = 2
+		a.arp_src_mac = "\x00\x03\x2f\x1a\x74\xde"
+		a.arp_src_ip = "\xc0\xa8\x01\x02"
+		a.arp_dst_mac = "\x00\x1b\x11\x51\xb7\xce"
+		a.arp_dst_ip = "\xc0\xa8\x01\x69"
+		a.payload = ""
+		a.eth_daddr = "00:1b:11:51:b7:ce"
+		a.eth_saddr = "00:03:2f:1a:74:de"
+		a.to_f('arp_test.pcap','a')
+	end
+	
+end
+
+
+# vim: nowrap sw=2 sts=0 ts=2 ff=unix ft=ruby

data/test/test_eth.rb

@@ -0,0 +1,91 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+$:.unshift File.join(File.expand_path(File.dirname(__FILE__)), "..", "lib")
+require 'packetfu'
+puts "Testing #{PacketFu.version}: #{$0}"
+
+class EthTest < Test::Unit::TestCase
+
+	def test_ethmac
+		dst = "\x00\x03\x2f\x1a\x74\xde"
+		e = PacketFu::EthMac.new
+		e.read dst
+		assert_equal(dst, e.to_s)
+		assert_equal(0x32f, e.oui.oui)
+		assert_equal("\x1a\x74\xde", e.nic.to_s)
+		assert_equal(222, e.nic.n2)
+	end
+
+	def test_ethmac_ipad
+		dst = "\x7c\x6d\x62\x01\x02\x03"
+		e = PacketFu::EthMac.new
+		e.read dst
+		assert_equal(dst, e.to_s)
+		assert_equal(0x6d62, e.oui.oui)
+	end
+
+	def test_ethmac_class
+		src = "\x00\x1b\x11\x51\xb7\xce"
+		e = PacketFu::EthMac.new
+		e.read src
+		assert_instance_of(PacketFu::EthMac, e)
+	end
+
+	def test_eth
+		header = "00032f1a74de001b1151b7ce0800".scan(/../).map { |x| x.to_i(16) }.pack("C*")
+		src = "\x00\x1b\x11\x51\xb7\xce"
+		dst = "\x00\x03\x2f\x1a\x74\xde"
+		e = PacketFu::EthHeader.new
+		e.eth_dst = dst
+		e.eth_src = src
+		e.eth_proto = "\x08\x00"
+		assert_equal(header, e.to_s)
+		assert_equal(header, PacketFu::EthHeader.new.read(header).to_s)
+	end
+
+	def test_macaddr
+		dst = "\x00\x03\x2f\x1a\x74\xde"
+		dstmac = "00:03:2f:1a:74:de"
+		assert_equal(dstmac,PacketFu::EthHeader.str2mac(dst))
+		assert_equal(dst, PacketFu::EthHeader.mac2str(dstmac))
+	end
+
+end
+
+class EthPacketTest < Test::Unit::TestCase
+	include PacketFu
+
+	def test_eth_create
+		sample_packet = PcapFile.new.file_to_array(:f => 'sample.pcap')[0]
+		e = EthPacket.new
+		header = "00032f1a74de001b1151b7ce0800".scan(/../).map { |x| x.to_i(16) }.pack("C*")
+		assert_kind_of EthPacket, e
+		assert_kind_of EthHeader, e.headers[0]
+		assert e.is_eth?
+		assert !e.is_tcp?
+		e.eth_dst = "\x00\x03\x2f\x1a\x74\xde"
+		e.eth_src = "\x00\x1b\x11\x51\xb7\xce"
+		e.eth_proto = 0x0800
+		assert_equal header, e.to_s[0,14]
+	end
+
+	def test_eth_new
+		p = EthPacket.new(
+		:eth_dst => "\x00\x03\x2f\x1a\x74\xde",
+		:eth_src => "\x00\x1b\x11\x51\xb7\xce",
+		:eth_proto => 0x0800)
+		header = "00032f1a74de001b1151b7ce0800".scan(/../).map { |x| x.to_i(16) }.pack("C*")
+		assert_equal header, p.to_s[0,14]
+	end
+
+	def test_eth_write
+		p = EthPacket.new(
+		:eth_dst => "\x00\x03\x2f\x1a\x74\xde",
+		:eth_src => "\x00\x1b\x11\x51\xb7\xce",
+		:eth_proto => 0x0800)
+		p.to_f('eth_test.pcap')
+	end
+
+end
+
+# vim: nowrap sw=2 sts=0 ts=2 ff=unix ft=ruby

data/test/test_hsrp.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+$:.unshift File.join(File.expand_path(File.dirname(__FILE__)), "..", "lib")
+require 'packetfu'
+
+class HSRPTest < Test::Unit::TestCase
+	include PacketFu
+
+	def test_hsrp_read
+		sample_packet = PcapFile.new.file_to_array(:f => 'sample_hsrp_pcapr.cap')[0]
+		pkt = Packet.parse(sample_packet)
+		assert pkt.is_hsrp?
+		assert pkt.is_udp?
+		assert_equal(0x2d8d, pkt.udp_sum.to_i)
+		# pkt.to_f('udp_test.pcap','a')
+	end
+
+end
+
+# vim: nowrap sw=2 sts=0 ts=2 ff=unix ft=ruby

data/test/test_icmp.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+$:.unshift File.join(File.expand_path(File.dirname(__FILE__)), "..", "lib")
+require 'packetfu'
+
+class ICMPTest < Test::Unit::TestCase
+	include PacketFu
+
+	def test_icmp_header_new
+		i = ICMPHeader.new
+		assert_kind_of ICMPHeader, i
+		assert_equal("\x00\x00\xff\xff", i.to_s)
+		i.icmp_type = 1
+		i.icmp_recalc :icmp_sum
+		assert_equal("\x01\x00\xfe\xff", i.to_s)
+	end
+
+	def test_icmp_peek
+		i = ICMPPacket.new
+		i.ip_saddr = "10.20.30.40"
+		i.ip_daddr = "50.60.70.80"
+		i.payload = "abcdefghijklmnopqrstuvwxyz"
+		i.recalc
+		puts "\n"
+		puts "ICMP Peek format: "
+		puts i.peek
+		assert (i.peek.size <= 80)
+	end
+
+	def test_icmp_pcap
+		i = ICMPPacket.new
+		assert_kind_of ICMPPacket, i
+		i.recalc
+		i.to_f('icmp_test.pcap')
+		i.ip_saddr = "10.20.30.40"
+		i.ip_daddr = "50.60.70.80"
+		i.payload = "\x00\x01\x00\01abcdefghijklmnopqrstuvwxyz"
+		i.icmp_code = 8
+		i.recalc
+		i.to_f('icmp_test.pcap','a')
+		assert File.exists?('icmp_test.pcap')
+	end
+
+	def test_icmp_read
+		sample_packet = PcapFile.new.file_to_array(:f => 'sample.pcap')[2]
+		pkt = Packet.parse(sample_packet)
+		assert_kind_of ICMPPacket, pkt
+		assert_equal(0x4d58, pkt.icmp_sum.to_i)
+		assert_equal(8, pkt.icmp_type.to_i)
+	end
+
+end
+
+# vim: nowrap sw=2 sts=0 ts=2 ff=unix ft=ruby

data/test/test_inject.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+$:.unshift File.join(File.expand_path(File.dirname(__FILE__)), "..", "lib")
+require 'packetfu'
+
+
+class InjectTest < 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_to_w
+		assert_equal(Process.euid, 0, "TEST FAIL: This test must be run as root")
+		conf = PacketFu::Utils.whoami?(:iface => (ENV['IFACE'] || 'lo'))
+		p = PacketFu::UDPPacket.new(:config => conf)
+		p.udp_dport = 12345
+		p.udp_sport = 12345
+		p.payload = "PacketFu test packet"
+		p.recalc
+		assert p.to_w
+	end
+
+end
+
+
+# vim: nowrap sw=2 sts=0 ts=2 ff=unix ft=ruby

data/test/test_invalid.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+$:.unshift File.join(File.expand_path(File.dirname(__FILE__)), "..", "lib")
+require 'packetfu'
+
+class InvalidTest < Test::Unit::TestCase
+	include PacketFu
+
+	def test_create_invalid
+		p = InvalidPacket.new
+		assert_kind_of InvalidPacket, p
+		assert_kind_of Packet, p
+		assert p.is_invalid?
+		assert_equal false, p.is_eth?
+		assert_not_equal EthPacket, p.class
+	end
+
+	# Sadly, the only way to generate an "InvalidPacket" is
+	# to read a packet that's less than 14 bytes. Otherwise,
+	# it's presumed to be an EthPacket. TODO: Fix this assumption!
+	def test_parse_invalid
+		p = Packet.parse("A" * 13)
+		assert_kind_of InvalidPacket, p
+	end
+
+end
+
+# vim: nowrap sw=2 sts=0 ts=2 ff=unix ft=ruby