packetfu 1.1.5 → 1.1.6

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

@@ -0,0 +1,247 @@
+module PacketFu
+	# EthOui is the Organizationally Unique Identifier portion of a MAC address, used in EthHeader.
+	#
+	# See the OUI list at http://standards.ieee.org/regauth/oui/oui.txt
+	#
+	# ==== Header Definition
+	#
+	#  Fixnum   :b0
+	#  Fixnum   :b1
+	#  Fixnum   :b2
+	#  Fixnum   :b3
+	#  Fixnum   :b4
+	#  Fixnum   :b5
+	#  Fixnum   :local
+	#  Fixnum   :multicast
+	#  Int16    :oui,       Default: 0x1ac5 :)
+	class EthOui < Struct.new(:b5, :b4, :b3, :b2, :b1, :b0, :local, :multicast, :oui)
+
+		# EthOui is unusual in that the bit values do not enjoy StructFu typing.
+		def initialize(args={})
+			args[:local] ||= 0 
+			args[:oui] ||= 0x1ac # :)
+			args.each_pair {|k,v| args[k] = 0 unless v} 
+			super(args[:b5], args[:b4], args[:b3], args[:b2], 
+						args[:b1], args[:b0], args[:local], args[:multicast], 
+						args[:oui])
+		end
+
+		# Returns the object in string form.
+		def to_s
+			byte = 0
+			byte += 0b10000000 if b5.to_i == 1
+			byte += 0b01000000 if b4.to_i == 1
+			byte += 0b00100000 if b3.to_i == 1
+			byte += 0b00010000 if b2.to_i == 1
+			byte += 0b00001000 if b1.to_i == 1
+			byte += 0b00000100 if b0.to_i == 1
+			byte += 0b00000010 if local.to_i == 1
+			byte += 0b00000001 if multicast.to_i == 1
+			[byte,oui].pack("Cn")
+		end
+
+		# Reads a string to populate the object.
+		def read(str)
+			force_binary(str)
+			return self if str.nil?
+			if 1.respond_to? :ord
+				byte = str[0].ord
+			else
+				byte = str[0]
+			end
+			self[:b5] =        byte & 0b10000000 == 0b10000000 ? 1 : 0
+			self[:b4] =        byte & 0b01000000 == 0b01000000 ? 1 : 0
+			self[:b3] =        byte & 0b00100000 == 0b00100000 ? 1 : 0
+			self[:b2] =        byte & 0b00010000 == 0b00010000 ? 1 : 0
+			self[:b1] =        byte & 0b00001000 == 0b00001000 ? 1 : 0
+			self[:b0] =        byte & 0b00000100 == 0b00000100 ? 1 : 0
+			self[:local] =     byte & 0b00000010 == 0b00000010 ? 1 : 0
+			self[:multicast] = byte & 0b00000001 == 0b00000001 ? 1 : 0
+			self[:oui] =       str[1,2].unpack("n").first
+			self
+		end
+
+	end
+
+  # EthNic is the Network Interface Controler portion of a MAC address, used in EthHeader.
+	#
+	# ==== Header Definition
+	#
+	#  Fixnum :n1
+	#  Fixnum :n2
+	#  Fixnum :n3
+	#
+	class EthNic < Struct.new(:n0, :n1, :n2)
+
+		# EthNic does not enjoy StructFu typing.
+		def initialize(args={})
+			args.each_pair {|k,v| args[k] = 0 unless v} 
+			super(args[:n0], args[:n1], args[:n2])
+		end
+
+		# Returns the object in string form.
+		def to_s
+			[n0,n1,n2].map {|x| x.to_i}.pack("C3")
+		end
+		
+		# Reads a string to populate the object.
+		def read(str)
+			force_binary(str)
+			return self if str.nil?
+			self[:n0], self[:n1], self[:n2] = str[0,3].unpack("C3")
+			self
+		end
+
+	end
+
+	# EthMac is the combination of an EthOui and EthNic, used in EthHeader.
+	#
+	# ==== Header Definition
+	#
+	#   EthOui :oui  # See EthOui
+	#   EthNic :nic  # See EthNic
+	class EthMac < Struct.new(:oui, :nic)
+
+		def initialize(args={})
+			super(
+			EthOui.new.read(args[:oui]),
+			EthNic.new.read(args[:nic]))
+		end
+
+		# Returns the object in string form.
+		def to_s
+			"#{self[:oui]}#{self[:nic]}"
+		end
+
+		# Reads a string to populate the object.
+		def read(str)
+			force_binary(str)
+			return self if str.nil?
+			self.oui.read str[0,3]
+			self.nic.read str[3,3]
+			self
+		end
+
+	end
+
+	# EthHeader is a complete Ethernet struct, used in EthPacket. 
+	# It's the base header for all other protocols, such as IPHeader, 
+	# TCPHeader, etc. 
+	#
+	# For more on the construction on MAC addresses, see 
+	# http://en.wikipedia.org/wiki/MAC_address
+	#
+	# TODO: Need to come up with a good way of dealing with vlan
+	# tagging. Having a usually empty struct member seems weird,
+	# but there may not be another way to do it if I want to preserve
+	# the Eth-ness of vlan-tagged 802.1Q packets. Also, may as well
+	# deal with 0x88a8 as well (http://en.wikipedia.org/wiki/802.1ad)
+	#
+	# ==== Header Definition
+	#
+	#  EthMac  :eth_dst                     # See EthMac
+	#  EthMac  :eth_src                     # See EthMac
+	#  Int16   :eth_proto, Default: 0x8000  # IP 0x0800, Arp 0x0806
+	#  String  :body
+	class EthHeader < Struct.new(:eth_dst, :eth_src, :eth_proto, :body)
+		include StructFu
+
+		def initialize(args={})
+			super(
+				EthMac.new.read(args[:eth_dst]),
+				EthMac.new.read(args[:eth_src]),
+				Int16.new(args[:eth_proto] || 0x0800),
+				StructFu::String.new.read(args[:body])
+			)
+		end
+
+		# Setter for the Ethernet destination address.
+		def eth_dst=(i); typecast(i); end
+		# Getter for the Ethernet destination address.
+		def eth_dst; self[:eth_dst].to_s; end
+		# Setter for the Ethernet source address.
+		def eth_src=(i); typecast(i); end
+		# Getter for the Ethernet source address.
+		def eth_src; self[:eth_src].to_s; end
+		# Setter for the Ethernet protocol number.
+		def eth_proto=(i); typecast(i); end
+		# Getter for the Ethernet protocol number.
+		def eth_proto; self[:eth_proto].to_i; end
+
+		# Returns the object in string form.
+		def to_s
+			self.to_a.map {|x| x.to_s}.join
+		end
+
+		# Reads a string to populate the object.
+		def read(str)
+			force_binary(str)
+			return self if str.nil?
+			self[:eth_dst].read str[0,6]
+			self[:eth_src].read str[6,6]
+			self[:eth_proto].read str[12,2]
+			self[:body].read str[14,str.size]
+			self
+		end
+
+		# Converts a readable MAC (11:22:33:44:55:66) to a binary string. 
+		# Readable MAC's may be split on colons, dots, spaces, or underscores.
+		#
+		# irb> PacketFu::EthHeader.mac2str("11:22:33:44:55:66")
+		#
+		# #=> "\021\"3DUf"
+		def self.mac2str(mac)
+			if mac.split(/[:\x2d\x2e\x5f]+/).size == 6
+				ret =	mac.split(/[:\x2d\x2e\x20\x5f]+/).collect {|x| x.to_i(16)}.pack("C6")
+			else
+				raise ArgumentError, "Unkown format for mac address."
+			end
+			return ret
+		end
+
+		# Converts a binary string to a readable MAC (11:22:33:44:55:66). 
+		#
+		# irb> PacketFu::EthHeader.str2mac("\x11\x22\x33\x44\x55\x66")
+		#
+		# #=> "11:22:33:44:55:66"
+		def self.str2mac(mac='')
+			if mac.to_s.size == 6 && mac.kind_of?(::String)
+				ret = mac.unpack("C6").map {|x| sprintf("%02x",x)}.join(":")
+			end
+		end
+
+		# Sets the source MAC address in a more readable way.
+		def eth_saddr=(mac)
+			mac = EthHeader.mac2str(mac)
+			self[:eth_src].read mac
+			self[:eth_src]
+		end
+
+		# Gets the source MAC address in a more readable way. 
+		def eth_saddr
+			EthHeader.str2mac(self[:eth_src].to_s)
+		end
+
+		# Set the destination MAC address in a more readable way.
+		def eth_daddr=(mac)
+			mac = EthHeader.mac2str(mac)
+			self[:eth_dst].read mac
+			self[:eth_dst]
+		end
+
+		# Gets the destination MAC address in a more readable way. 
+		def eth_daddr
+			EthHeader.str2mac(self[:eth_dst].to_s)
+		end
+
+		# Readability aliases
+
+		alias :eth_dst_readable :eth_daddr
+		alias :eth_src_readable :eth_saddr
+
+		def eth_proto_readable
+			"0x%04x" % eth_proto
+		end
+
+	end
+end

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

@@ -0,0 +1,20 @@
+module PacketFu
+	# This Mixin simplifies access to the EthHeaders. Mix this in with your 
+	# packet interface, and it will add methods that essentially delegate to
+	# the 'eth_header' method (assuming that it is a EthHeader object)
+  module EthHeaderMixin
+    def eth_daddr; self.eth_header.eth_daddr ; end
+    def eth_daddr=(v); self.eth_header.eth_daddr= v; end
+    def eth_dst; self.eth_header.eth_dst ; end
+    def eth_dst=(v); self.eth_header.eth_dst= v; end
+    def eth_dst_readable; self.eth_header.eth_dst_readable ; end
+    def eth_proto; self.eth_header.eth_proto ; end
+    def eth_proto=(v); self.eth_header.eth_proto= v; end
+    def eth_proto_readable; self.eth_header.eth_proto_readable ; end
+    def eth_saddr; self.eth_header.eth_saddr ; end
+    def eth_saddr=(v); self.eth_header.eth_saddr= v; end
+    def eth_src; self.eth_header.eth_src ; end
+    def eth_src=(v); self.eth_header.eth_src= v; end
+    def eth_src_readable; self.eth_header.eth_src_readable ; end
+  end
+end

data/lib/packetfu/protos/hsrp.rb

@@ -1,124 +1,16 @@
-module PacketFu
-
-	# HSRPHeader is a complete HSRP struct, used in HSRPPacket. HSRP is typically used for
-	# fault-tolerant default gateway in IP routing environment.
-	#
-	# For more on HSRP packets, see http://www.networksorcery.com/enp/protocol/hsrp.htm
-	#
-	# Submitted by fropert@packetfault.org. Thanks, Francois!
-	#
-	# ==== Header Definition
-	#
-	#   Int8    :hsrp_version      Default: 0     # Version
-	#   Int8    :hsrp_opcode                      # Opcode
-	#   Int8    :hsrp_state                       # State
-	#   Int8    :hsrp_hellotime    Default: 3     # Hello Time
-	#   Int8    :hsrp_holdtime     Default: 10    # Hold Time
-	#   Int8    :hsrp_priority                    # Priority
-	#   Int8    :hsrp_group                       # Group
-	#   Int8    :hsrp_reserved     Default: 0     # Reserved
-	#   String  :hsrp_password                    # Authentication Data
-	#   Octets  :hsrp_vip                         # Virtual IP Address
-	#   String  :body
-	class HSRPHeader < Struct.new(:hsrp_version, :hsrp_opcode, :hsrp_state,
-								  :hsrp_hellotime, :hsrp_holdtime,
-								  :hsrp_priority, :hsrp_group,
-								  :hsrp_reserved, :hsrp_password,
-								  :hsrp_vip, :body)
-
-		include StructFu
+require 'packetfu/protos/eth/header'
+require 'packetfu/protos/eth/mixin'
 
-		def initialize(args={})
-			super(
-				Int8.new(args[:hsrp_version] || 0),
-				Int8.new(args[:hsrp_opcode]),
-				Int8.new(args[:hsrp_state]),
-				Int8.new(args[:hsrp_hellotime] || 3),
-				Int8.new(args[:hsrp_holdtime] || 10),
-				Int8.new(args[:hsrp_priority]),
-				Int8.new(args[:hsrp_group]),
-				Int8.new(args[:hsrp_reserved] || 0),
-				StructFu::String.new.read(args[:hsrp_password] || "cisco\x00\x00\x00"),
-				Octets.new.read(args[:hsrp_vip] || ("\x00" * 4)),
-				StructFu::String.new.read(args[:body])
-			)
-		end
+require 'packetfu/protos/ip/header'
+require 'packetfu/protos/ip/mixin'
 
-		# Returns the object in string form.
-		def to_s
-			self.to_a.map {|x| x.to_s}.join
-		end
+require 'packetfu/protos/udp/header'
+require 'packetfu/protos/udp/mixin'
 
-		# Reads a string to populate the object.
-		def read(str)
-			force_binary(str)
-			return self if str.nil?
-			self[:hsrp_version].read(str[0,1])
-			self[:hsrp_opcode].read(str[1,1])
-			self[:hsrp_state].read(str[2,1])
-			self[:hsrp_hellotime].read(str[3,1])
-			self[:hsrp_holdtime].read(str[4,1])
-			self[:hsrp_priority].read(str[5,1])
-			self[:hsrp_group].read(str[6,1])
-			self[:hsrp_reserved].read(str[7,1])
-			self[:hsrp_password].read(str[8,8])
-			self[:hsrp_vip].read(str[16,4])
-			self[:body].read(str[20,str.size]) if str.size > 20
-			self
-		end
-
-		# Setter for the type.
-		def hsrp_version=(i); typecast i; end
-		# Getter for the type.
-		def hsrp_version; self[:hsrp_version].to_i; end
-		# Setter for the type.
-		def hsrp_opcode=(i); typecast i; end
-		# Getter for the type.
-		def hsrp_opcode; self[:hsrp_opcode].to_i; end
-		# Setter for the type.
-		def hsrp_state=(i); typecast i; end
-		# Getter for the type.
-		def hsrp_state; self[:hsrp_state].to_i; end
-		# Setter for the type.
-		def hsrp_hellotime=(i); typecast i; end
-		# Getter for the type.
-		def hsrp_hellotime; self[:hsrp_hellotime].to_i; end
-		# Setter for the type.
-		def hsrp_holdtime=(i); typecast i; end
-		# Getter for the type.
-		def hsrp_holdtime; self[:hsrp_holdtime].to_i; end
-		# Setter for the type.
-		def hsrp_priority=(i); typecast i; end
-		# Getter for the type.
-		def hsrp_priority; self[:hsrp_priority].to_i; end
-		# Setter for the type.
-		def hsrp_group=(i); typecast i; end
-		# Getter for the type.
-		def hsrp_group; self[:hsrp_group].to_i; end
-		# Setter for the type.
-		def hsrp_reserved=(i); typecast i; end
-		# Getter for the type.
-		def hsrp_reserved; self[:hsrp_reserved].to_i; end
-
-		def hsrp_addr=(addr)
-			self[:hsrp_vip].read_quad(addr)
-		end
-
-		# Returns a more readable IP source address.
-		def hsrp_addr
-			self[:hsrp_vip].to_x
-		end
-
-		# Readability aliases
-
-		alias :hsrp_vip_readable :hsrp_addr
-
-		def hsrp_password_readable
-			hsrp_password.to_s.inspect
-		end
-
-	end
+require 'packetfu/protos/hsrp/header'
+require 'packetfu/protos/hsrp/mixin'
 
+module PacketFu
 	# HSRPPacket is used to construct HSRP Packets. They contain an EthHeader, an IPHeader, and a UDPHeader.
 	#
 	# == Example
@@ -145,6 +37,10 @@ module PacketFu
 	#  :config
 	#   A hash of return address details, often the output of Utils.whoami?
 	class HSRPPacket < Packet
+    include ::PacketFu::EthHeaderMixin
+    include ::PacketFu::IPHeaderMixin
+    include ::PacketFu::UDPHeaderMixin
+    include ::PacketFu::HSRPHeaderMixin
 
 		attr_accessor :eth_header, :ip_header, :udp_header, :hsrp_header
 
@@ -165,12 +61,6 @@ module PacketFu
 		def read(str=nil, args={})
 			raise "Cannot parse `#{str}'" unless self.class.can_parse?(str)
 			@eth_header.read(str)
-			@ip_header.read(str[14,str.size])
-			@eth_header.body = @ip_header
-			@udp_header.read(str[14+(@ip_header.ip_hlen),str.size])
-			@ip_header.body = @udp_header
-			@hsrp_header.read(str[14+(@ip_header.ip_hlen)+8,str.size])
-			@udp_header.body = @hsrp_header
 			super(args)
 			self
 		end

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

@@ -0,0 +1,120 @@
+module PacketFu
+	# HSRPHeader is a complete HSRP struct, used in HSRPPacket. HSRP is typically used for
+	# fault-tolerant default gateway in IP routing environment.
+	#
+	# For more on HSRP packets, see http://www.networksorcery.com/enp/protocol/hsrp.htm
+	#
+	# Submitted by fropert@packetfault.org. Thanks, Francois!
+	#
+	# ==== Header Definition
+	#
+	#   Int8    :hsrp_version      Default: 0     # Version
+	#   Int8    :hsrp_opcode                      # Opcode
+	#   Int8    :hsrp_state                       # State
+	#   Int8    :hsrp_hellotime    Default: 3     # Hello Time
+	#   Int8    :hsrp_holdtime     Default: 10    # Hold Time
+	#   Int8    :hsrp_priority                    # Priority
+	#   Int8    :hsrp_group                       # Group
+	#   Int8    :hsrp_reserved     Default: 0     # Reserved
+	#   String  :hsrp_password                    # Authentication Data
+	#   Octets  :hsrp_vip                         # Virtual IP Address
+	#   String  :body
+	class HSRPHeader < Struct.new(:hsrp_version, :hsrp_opcode, :hsrp_state,
+								  :hsrp_hellotime, :hsrp_holdtime,
+								  :hsrp_priority, :hsrp_group,
+								  :hsrp_reserved, :hsrp_password,
+								  :hsrp_vip, :body)
+
+		include StructFu
+
+		def initialize(args={})
+			super(
+				Int8.new(args[:hsrp_version] || 0),
+				Int8.new(args[:hsrp_opcode]),
+				Int8.new(args[:hsrp_state]),
+				Int8.new(args[:hsrp_hellotime] || 3),
+				Int8.new(args[:hsrp_holdtime] || 10),
+				Int8.new(args[:hsrp_priority]),
+				Int8.new(args[:hsrp_group]),
+				Int8.new(args[:hsrp_reserved] || 0),
+				StructFu::String.new.read(args[:hsrp_password] || "cisco\x00\x00\x00"),
+				Octets.new.read(args[:hsrp_vip] || ("\x00" * 4)),
+				StructFu::String.new.read(args[:body])
+			)
+		end
+
+		# Returns the object in string form.
+		def to_s
+			self.to_a.map {|x| x.to_s}.join
+		end
+
+		# Reads a string to populate the object.
+		def read(str)
+			force_binary(str)
+			return self if str.nil?
+			self[:hsrp_version].read(str[0,1])
+			self[:hsrp_opcode].read(str[1,1])
+			self[:hsrp_state].read(str[2,1])
+			self[:hsrp_hellotime].read(str[3,1])
+			self[:hsrp_holdtime].read(str[4,1])
+			self[:hsrp_priority].read(str[5,1])
+			self[:hsrp_group].read(str[6,1])
+			self[:hsrp_reserved].read(str[7,1])
+			self[:hsrp_password].read(str[8,8])
+			self[:hsrp_vip].read(str[16,4])
+			self[:body].read(str[20,str.size]) if str.size > 20
+			self
+		end
+
+		# Setter for the type.
+		def hsrp_version=(i); typecast i; end
+		# Getter for the type.
+		def hsrp_version; self[:hsrp_version].to_i; end
+		# Setter for the type.
+		def hsrp_opcode=(i); typecast i; end
+		# Getter for the type.
+		def hsrp_opcode; self[:hsrp_opcode].to_i; end
+		# Setter for the type.
+		def hsrp_state=(i); typecast i; end
+		# Getter for the type.
+		def hsrp_state; self[:hsrp_state].to_i; end
+		# Setter for the type.
+		def hsrp_hellotime=(i); typecast i; end
+		# Getter for the type.
+		def hsrp_hellotime; self[:hsrp_hellotime].to_i; end
+		# Setter for the type.
+		def hsrp_holdtime=(i); typecast i; end
+		# Getter for the type.
+		def hsrp_holdtime; self[:hsrp_holdtime].to_i; end
+		# Setter for the type.
+		def hsrp_priority=(i); typecast i; end
+		# Getter for the type.
+		def hsrp_priority; self[:hsrp_priority].to_i; end
+		# Setter for the type.
+		def hsrp_group=(i); typecast i; end
+		# Getter for the type.
+		def hsrp_group; self[:hsrp_group].to_i; end
+		# Setter for the type.
+		def hsrp_reserved=(i); typecast i; end
+		# Getter for the type.
+		def hsrp_reserved; self[:hsrp_reserved].to_i; end
+
+		def hsrp_addr=(addr)
+			self[:hsrp_vip].read_quad(addr)
+		end
+
+		# Returns a more readable IP source address.
+		def hsrp_addr
+			self[:hsrp_vip].to_x
+		end
+
+		# Readability aliases
+
+		alias :hsrp_vip_readable :hsrp_addr
+
+		def hsrp_password_readable
+			hsrp_password.to_s.inspect
+		end
+
+	end
+end