packetfu 1.1.8 → 1.1.9

data/test/test_ip.rb

@@ -4,46 +4,46 @@ $:.unshift File.join(File.expand_path(File.dirname(__FILE__)), "..", "lib")
 require 'packetfu'
 
 class IPTest < Test::Unit::TestCase
-	include PacketFu
+  include PacketFu
 
-	def test_ip_header_new
-		i = IPHeader.new
-		assert_kind_of IPHeader, i
-		i.ip_id = 0x1234
-		i.ip_recalc :ip_sum
-		assert_equal("E\000\000\024\0224\000\000 \000\210\267\000\000\000\000\000\000\000\000", i.to_s)
-	end
+  def test_ip_header_new
+    i = IPHeader.new
+    assert_kind_of IPHeader, i
+    i.ip_id = 0x1234
+    i.ip_recalc :ip_sum
+    assert_equal("E\000\000\024\0224\000\000 \000\210\267\000\000\000\000\000\000\000\000", i.to_s)
+  end
 
-	def test_ip_packet_new
-		i = IPPacket.new
-		assert i.is_ip?
-	end
+  def test_ip_packet_new
+    i = IPPacket.new
+    assert i.is_ip?
+  end
 
-	def test_ip_peek
-		i = IPPacket.new
-		i.ip_saddr = "1.2.3.4"
-		i.ip_daddr = "5.6.7.8"
-		i.ip_proto = 94
-		i.payload = '\x00' * 30
-		i.recalc
-		puts "\n"
-		puts "IP Peek format: "
-		puts i.peek
-		assert (i.peek.size <= 80)
-	end
+  def test_ip_peek
+    i = IPPacket.new
+    i.ip_saddr = "1.2.3.4"
+    i.ip_daddr = "5.6.7.8"
+    i.ip_proto = 94
+    i.payload = '\x00' * 30
+    i.recalc
+    puts "\n"
+    puts "IP Peek format: "
+    puts i.peek
+    assert (i.peek.size <= 80)
+  end
 
-	def test_ip_pcap
-		i = IPPacket.new
-		assert_kind_of IPPacket, i
-		i.recalc
-		i.to_f('ip_test.pcap')
-		i.ip_saddr = "1.2.3.4"
-		i.ip_daddr = "5.6.7.8"
-		i.ip_proto = 94
-		i.payload = "\x23" * 10
-		i.recalc
-		i.to_f('ip_test.pcap','a')
-	end
+  def test_ip_pcap
+    i = IPPacket.new
+    assert_kind_of IPPacket, i
+    i.recalc
+    i.to_f('ip_test.pcap')
+    i.ip_saddr = "1.2.3.4"
+    i.ip_daddr = "5.6.7.8"
+    i.ip_proto = 94
+    i.payload = "\x23" * 10
+    i.recalc
+    i.to_f('ip_test.pcap','a')
+  end
 
 end
 

data/test/test_ip6.rb

@@ -4,65 +4,65 @@ $:.unshift File.join(File.expand_path(File.dirname(__FILE__)), "..", "lib")
 require 'packetfu'
 
 class IPv6AddrTest < Test::Unit::TestCase
-	include PacketFu
+  include PacketFu
 
-	def test_addr_read
-		a = AddrIpv6.new
-		addr = "\xfe\x80\x00\x00\x00\x00\x00\x00\x02\x1a\xc5\xff\xfe\x00\x01\x52"
-		a.read(addr)
-		assert_equal(338288524927261089654170548082086773074, a.to_i)
-		assert_equal("fe80::21a:c5ff:fe00:152",a.to_x)
-	end
+  def test_addr_read
+    a = AddrIpv6.new
+    addr = "\xfe\x80\x00\x00\x00\x00\x00\x00\x02\x1a\xc5\xff\xfe\x00\x01\x52"
+    a.read(addr)
+    assert_equal(338288524927261089654170548082086773074, a.to_i)
+    assert_equal("fe80::21a:c5ff:fe00:152",a.to_x)
+  end
 
-	def test_octets_read_quad
-		a = AddrIpv6.new
-		addr = "fe80::21a:c5ff:fe00:152"
-		a.read_x(addr)
-		assert_equal(addr,a.to_x)
-	end
+  def test_octets_read_quad
+    a = AddrIpv6.new
+    addr = "fe80::21a:c5ff:fe00:152"
+    a.read_x(addr)
+    assert_equal(addr,a.to_x)
+  end
 
 end
 
 class IPv6Test < Test::Unit::TestCase
-	include PacketFu
+  include PacketFu
 
-	def test_ipv6_header_new
-		i = IPv6Header.new
-		assert_kind_of IPv6Header, i
-		assert_equal("`\000\000\000\000\000\000\377\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000", i.to_s)
-	end
+  def test_ipv6_header_new
+    i = IPv6Header.new
+    assert_kind_of IPv6Header, i
+    assert_equal("`\000\000\000\000\000\000\377\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000", i.to_s)
+  end
 
-	def test_ipv6_packet_new
-		i = IPv6Packet.new
-		assert i.is_ipv6?
-	end
+  def test_ipv6_packet_new
+    i = IPv6Packet.new
+    assert i.is_ipv6?
+  end
 
-	def test_ipv6_peek
-		i = IPv6Packet.new
-		i.ipv6_saddr = "fe80::1"
-		i.ipv6_daddr = "fe80::2"
-		i.ipv6_next = 0x11
-		i.payload = '\x00' * 30
-		i.recalc
-		puts "\n"
-		puts "IPv6 Peek format: "
-		puts i.peek
-		assert (i.peek.size <= 80)
-	end
+  def test_ipv6_peek
+    i = IPv6Packet.new
+    i.ipv6_saddr = "fe80::1"
+    i.ipv6_daddr = "fe80::2"
+    i.ipv6_next = 0x11
+    i.payload = '\x00' * 30
+    i.recalc
+    puts "\n"
+    puts "IPv6 Peek format: "
+    puts i.peek
+    assert (i.peek.size <= 80)
+  end
 
 =begin
-	def test_ipv6_pcap
-		i = IPPacket.new
-		assert_kind_of IPPacket, i
-		i.recalc
-		i.to_f('ip_test.pcap')
-		i.ip_saddr = "1.2.3.4"
-		i.ip_daddr = "5.6.7.8"
-		i.ip_proto = 94
-		i.payload = "\x23" * 10
-		i.recalc
-		i.to_f('ip_test.pcap','a')
-	end
+  def test_ipv6_pcap
+    i = IPPacket.new
+    assert_kind_of IPPacket, i
+    i.recalc
+    i.to_f('ip_test.pcap')
+    i.ip_saddr = "1.2.3.4"
+    i.ip_daddr = "5.6.7.8"
+    i.ip_proto = 94
+    i.payload = "\x23" * 10
+    i.recalc
+    i.to_f('ip_test.pcap','a')
+  end
 =end
 end
 # vim: nowrap sw=2 sts=0 ts=2 ff=unix ft=ruby

data/test/test_octets.rb

@@ -4,30 +4,30 @@ $:.unshift File.join(File.expand_path(File.dirname(__FILE__)), "..", "lib")
 require 'packetfu'
 
 class OctetsTest < Test::Unit::TestCase
-	include PacketFu
+  include PacketFu
 
-	def test_octets_read
-		o = Octets.new
-		o.read("\x04\x03\x02\x01")
-		assert_equal("4.3.2.1", o.to_x)
-	end
+  def test_octets_read
+    o = Octets.new
+    o.read("\x04\x03\x02\x01")
+    assert_equal("4.3.2.1", o.to_x)
+  end
 
-	def test_octets_read_quad
-		o = Octets.new
-		o.read_quad("1.2.3.4")
-		assert_equal("1.2.3.4", o.to_x)
-		assert_equal("\x01\x02\x03\x04", o.to_s)
-		assert_equal(0x01020304, o.to_i)
-	end
+  def test_octets_read_quad
+    o = Octets.new
+    o.read_quad("1.2.3.4")
+    assert_equal("1.2.3.4", o.to_x)
+    assert_equal("\x01\x02\x03\x04", o.to_s)
+    assert_equal(0x01020304, o.to_i)
+  end
 
-	def test_octets_single_octet
-		o = Octets.new
-		o.read("ABCD")
-		assert_equal(o.o1, 0x41)
-		assert_equal(o.o2, 0x42)
-		assert_equal(o.o3, 0x43)
-		assert_equal(o.o4, 0x44)
-	end
+  def test_octets_single_octet
+    o = Octets.new
+    o.read("ABCD")
+    assert_equal(o.o1, 0x41)
+    assert_equal(o.o2, 0x42)
+    assert_equal(o.o3, 0x43)
+    assert_equal(o.o4, 0x44)
+  end
 
 end
 

data/test/test_packet.rb

@@ -4,169 +4,169 @@ $:.unshift File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
 require 'packetfu'
 
 class NewPacketTest < Test::Unit::TestCase
-	include PacketFu
-	
-	def test_method_missing_and_respond_to
-		p = TCPPacket.new
-		assert p.respond_to?(:ip_len)
-		assert p.ip_len = 20
-		assert !(p.respond_to? :ip_bogus_header)
-		assert_raise NoMethodError do
-			p.bogus_header = 20
-		end
-	end
-
-	def test_more_method_missing_magic
-		p = UDPPacket.new
-		assert_kind_of(UDPPacket,p)
-		assert p.is_udp?
-		assert p.is_ip?
-		assert p.is_eth?
-		assert_equal(p.ip_hl,5)
-		assert p.layer
-		assert_raise NoMethodError do 
-			p.is_blue? 
-		end
-		assert_raise NoMethodError do
-		 	p.tcp_blue
-		end
-		assert_raise NoMethodError do 
-			p.udp_blue 
-		end
-		assert_raise NoMethodError do
-			p.blue
-		end
-	end
+  include PacketFu
+  
+  def test_method_missing_and_respond_to
+    p = TCPPacket.new
+    assert p.respond_to?(:ip_len)
+    assert p.ip_len = 20
+    assert !(p.respond_to? :ip_bogus_header)
+    assert_raise NoMethodError do
+      p.bogus_header = 20
+    end
+  end
+
+  def test_more_method_missing_magic
+    p = UDPPacket.new
+    assert_kind_of(UDPPacket,p)
+    assert p.is_udp?
+    assert p.is_ip?
+    assert p.is_eth?
+    assert_equal(p.ip_hl,5)
+    assert p.layer
+    assert_raise NoMethodError do 
+      p.is_blue? 
+    end
+    assert_raise NoMethodError do
+       p.tcp_blue
+    end
+    assert_raise NoMethodError do 
+      p.udp_blue 
+    end
+    assert_raise NoMethodError do
+      p.blue
+    end
+  end
 end
 
 class PacketStrippingTest < Test::Unit::TestCase
 
-	include PacketFu
+  include PacketFu
 
-	def test_arp_strip
-		pcaps = PcapFile.new.file_to_array(:f => 'sample.pcap')
-		p = Packet.parse(pcaps[5], :fix => true) # Really ARP request.
-		assert_kind_of(Packet,p)
-		assert_kind_of(ARPPacket,p)
-	end
+  def test_arp_strip
+    pcaps = PcapFile.new.file_to_array(:f => 'sample.pcap')
+    p = Packet.parse(pcaps[5], :fix => true) # Really ARP request.
+    assert_kind_of(Packet,p)
+    assert_kind_of(ARPPacket,p)
+  end
 
 end
 
 class PacketParsersTest < Test::Unit::TestCase
-	include PacketFu
-
-	def test_parse_eth_packet
-		assert_equal(EthPacket.layer, 1)
-		assert_equal(EthPacket.layer_symbol, :link)
-		pcaps = PcapFile.new.file_to_array(:f => 'sample.pcap')
-		p = Packet.parse(pcaps[5]) # Really ARP.
-		assert_kind_of(Packet,p)
-		assert_kind_of(EthHeader, p.headers[0])
-		assert p.is_eth?
-		assert_equal(pcaps[5],p.to_s)
-	end
-
-	def test_parse_arp_request
-		assert_equal(ARPPacket.layer, 2)
-		pcaps = PcapFile.new.file_to_array(:f => 'sample.pcap')
-		p = Packet.parse(pcaps[5]) # Really ARP request.
-		assert p.is_eth?
-		assert_kind_of(EthPacket,p)
-		assert_kind_of(ARPPacket,p)
-		assert p.is_arp?
-		assert_equal(p.to_s, pcaps[5])
-		assert_equal(1, p.arp_opcode.to_i)
-		assert_equal("\x00\x01", p.headers.last[:arp_opcode].to_s)
-	end
-
-	def test_parse_arp_reply
-		assert_equal(ARPPacket.layer, 2)
-		pcaps = PcapFile.new.file_to_array(:f => 'sample.pcap')
-		p = Packet.parse(pcaps[6]) # Really ARP reply.
-		assert_equal(p.to_s, pcaps[6])
-		assert_equal(2, p.arp_opcode.to_i)
-		assert_equal("\x00\x02", p.headers.last[:arp_opcode].to_s)
-	end
-
-	def test_parse_ip_packet
-		assert_equal(IPPacket.layer, 2)
-		pcaps = PcapFile.new.file_to_array(:f => 'sample.pcap')
-		p = Packet.parse(pcaps[0]) # Really DNS request 
-		assert_equal(p.to_s[0,20], pcaps[0][0,20])
-		assert_equal(p.to_s, pcaps[0])
-		assert_kind_of(EthPacket,p)
-		assert_kind_of(IPPacket,p)
-	end
-
-	def test_parse_tcp_packet
-		assert_equal(TCPPacket.layer, 3)
-		pcaps = PcapFile.new.file_to_array(:f => 'sample.pcap')
-		p = Packet.parse(pcaps[7]) # Really FIN/ACK
-		assert_equal(p.to_s, pcaps[7])
-		assert_kind_of(EthPacket,p)
-		assert_kind_of(IPPacket,p)
-		assert_kind_of(TCPPacket,p)
-	end
-
-	def test_parse_udp_packet
-		assert_equal(UDPPacket.layer, 3)
-		pcaps = PcapFile.new.file_to_array(:f => 'sample.pcap')
-		p = Packet.parse(pcaps[0]) # Really DNS request
-		assert_equal(p.to_s, pcaps[0])
-		assert_kind_of(EthPacket,p)
-		assert_kind_of(IPPacket,p)
-		assert_kind_of(UDPPacket,p)
-	end
-
-	def test_parse_icmp_packet
-		assert_equal(ICMPPacket.layer, 3)
-		assert_equal(ICMPPacket.layer_symbol, :transport)
-		pcaps = PcapFile.new.file_to_array(:f => 'sample.pcap')
-		p = Packet.parse(pcaps[3]) # Really ICMP reply
-		assert_equal(p.to_s, pcaps[3])
-		assert_kind_of(EthPacket,p)
-		assert_kind_of(IPPacket,p)
-		assert_kind_of(ICMPPacket,p)
-	end
-
-	def test_parse_invalid_packet
-		assert_equal(InvalidPacket.layer, 0)
-		assert_equal(InvalidPacket.layer_symbol, :invalid)
-		p = Packet.parse("\xff\xfe\x00\x01")
-		assert_equal(p.to_s, "\xff\xfe\x00\x01")
-		assert_kind_of(InvalidPacket,p)
-	end
-
-	def test_parse_ipv6_packet
-		assert_equal(IPv6Packet.layer, 2)
-		assert_equal(IPv6Packet.layer_symbol, :internet)
-		pcaps = PcapFile.new.file_to_array(:f => 'sample-ipv6.pcap')
-		p = Packet.parse(pcaps[0]) # Really an IPv6 packet 
-		assert_equal(p.to_s, pcaps[0])
-		assert_kind_of(EthPacket,p)
-		assert(!p.kind_of?(IPPacket), "Misidentified as an IP Packet!")
-		assert_kind_of(IPv6Packet,p)
-	end
-
-	def test_parse_hsrp_packet
-		assert_equal(HSRPPacket.layer, 4)
-		assert_equal(HSRPPacket.layer_symbol, :application)
-		pcaps = PcapFile.new.file_to_array(:f => 'sample_hsrp_pcapr.cap')
-		p = Packet.parse(pcaps[0]) # Really an HSRP Hello packet 
-		assert_equal(p.to_s, pcaps[0])
-		assert_kind_of(EthPacket,p)
-		assert_kind_of(IPPacket,p)
-		assert_kind_of(UDPPacket,p)
-		assert_kind_of(HSRPPacket,p)
-	end
-
-	def test_parse_hsrp_as_udp
-		assert_equal(:application, HSRPPacket.layer_symbol)
-		pcaps = PcapFile.new.file_to_array(:f => 'sample_hsrp_pcapr.cap')
-		p = Packet.parse(pcaps[0], :parse_app => false) # Really an HSRP Hello packet 
-		assert_kind_of(UDPPacket,p)
-		assert(!p.kind_of?(HSRPPacket), "Misidentified HSRP packet when we didn't want it!" )
-	end
+  include PacketFu
+
+  def test_parse_eth_packet
+    assert_equal(EthPacket.layer, 1)
+    assert_equal(EthPacket.layer_symbol, :link)
+    pcaps = PcapFile.new.file_to_array(:f => 'sample.pcap')
+    p = Packet.parse(pcaps[5]) # Really ARP.
+    assert_kind_of(Packet,p)
+    assert_kind_of(EthHeader, p.headers[0])
+    assert p.is_eth?
+    assert_equal(pcaps[5],p.to_s)
+  end
+
+  def test_parse_arp_request
+    assert_equal(ARPPacket.layer, 2)
+    pcaps = PcapFile.new.file_to_array(:f => 'sample.pcap')
+    p = Packet.parse(pcaps[5]) # Really ARP request.
+    assert p.is_eth?
+    assert_kind_of(EthPacket,p)
+    assert_kind_of(ARPPacket,p)
+    assert p.is_arp?
+    assert_equal(p.to_s, pcaps[5])
+    assert_equal(1, p.arp_opcode.to_i)
+    assert_equal("\x00\x01", p.headers.last[:arp_opcode].to_s)
+  end
+
+  def test_parse_arp_reply
+    assert_equal(ARPPacket.layer, 2)
+    pcaps = PcapFile.new.file_to_array(:f => 'sample.pcap')
+    p = Packet.parse(pcaps[6]) # Really ARP reply.
+    assert_equal(p.to_s, pcaps[6])
+    assert_equal(2, p.arp_opcode.to_i)
+    assert_equal("\x00\x02", p.headers.last[:arp_opcode].to_s)
+  end
+
+  def test_parse_ip_packet
+    assert_equal(IPPacket.layer, 2)
+    pcaps = PcapFile.new.file_to_array(:f => 'sample.pcap')
+    p = Packet.parse(pcaps[0]) # Really DNS request 
+    assert_equal(p.to_s[0,20], pcaps[0][0,20])
+    assert_equal(p.to_s, pcaps[0])
+    assert_kind_of(EthPacket,p)
+    assert_kind_of(IPPacket,p)
+  end
+
+  def test_parse_tcp_packet
+    assert_equal(TCPPacket.layer, 3)
+    pcaps = PcapFile.new.file_to_array(:f => 'sample.pcap')
+    p = Packet.parse(pcaps[7]) # Really FIN/ACK
+    assert_equal(p.to_s, pcaps[7])
+    assert_kind_of(EthPacket,p)
+    assert_kind_of(IPPacket,p)
+    assert_kind_of(TCPPacket,p)
+  end
+
+  def test_parse_udp_packet
+    assert_equal(UDPPacket.layer, 3)
+    pcaps = PcapFile.new.file_to_array(:f => 'sample.pcap')
+    p = Packet.parse(pcaps[0]) # Really DNS request
+    assert_equal(p.to_s, pcaps[0])
+    assert_kind_of(EthPacket,p)
+    assert_kind_of(IPPacket,p)
+    assert_kind_of(UDPPacket,p)
+  end
+
+  def test_parse_icmp_packet
+    assert_equal(ICMPPacket.layer, 3)
+    assert_equal(ICMPPacket.layer_symbol, :transport)
+    pcaps = PcapFile.new.file_to_array(:f => 'sample.pcap')
+    p = Packet.parse(pcaps[3]) # Really ICMP reply
+    assert_equal(p.to_s, pcaps[3])
+    assert_kind_of(EthPacket,p)
+    assert_kind_of(IPPacket,p)
+    assert_kind_of(ICMPPacket,p)
+  end
+
+  def test_parse_invalid_packet
+    assert_equal(InvalidPacket.layer, 0)
+    assert_equal(InvalidPacket.layer_symbol, :invalid)
+    p = Packet.parse("\xff\xfe\x00\x01")
+    assert_equal(p.to_s, "\xff\xfe\x00\x01")
+    assert_kind_of(InvalidPacket,p)
+  end
+
+  def test_parse_ipv6_packet
+    assert_equal(IPv6Packet.layer, 2)
+    assert_equal(IPv6Packet.layer_symbol, :internet)
+    pcaps = PcapFile.new.file_to_array(:f => 'sample-ipv6.pcap')
+    p = Packet.parse(pcaps[0]) # Really an IPv6 packet 
+    assert_equal(p.to_s, pcaps[0])
+    assert_kind_of(EthPacket,p)
+    assert(!p.kind_of?(IPPacket), "Misidentified as an IP Packet!")
+    assert_kind_of(IPv6Packet,p)
+  end
+
+  def test_parse_hsrp_packet
+    assert_equal(HSRPPacket.layer, 4)
+    assert_equal(HSRPPacket.layer_symbol, :application)
+    pcaps = PcapFile.new.file_to_array(:f => 'sample_hsrp_pcapr.cap')
+    p = Packet.parse(pcaps[0]) # Really an HSRP Hello packet 
+    assert_equal(p.to_s, pcaps[0])
+    assert_kind_of(EthPacket,p)
+    assert_kind_of(IPPacket,p)
+    assert_kind_of(UDPPacket,p)
+    assert_kind_of(HSRPPacket,p)
+  end
+
+  def test_parse_hsrp_as_udp
+    assert_equal(:application, HSRPPacket.layer_symbol)
+    pcaps = PcapFile.new.file_to_array(:f => 'sample_hsrp_pcapr.cap')
+    p = Packet.parse(pcaps[0], :parse_app => false) # Really an HSRP Hello packet 
+    assert_kind_of(UDPPacket,p)
+    assert(!p.kind_of?(HSRPPacket), "Misidentified HSRP packet when we didn't want it!" )
+  end
 
 end