packetgen 1.2.0 → 1.3.0

data/lib/packetgen/header/esp.rb

@@ -5,12 +5,12 @@ module PacketGen
     class CipherError < Error;end
 
     # A ESP header consists of:
-    # * a Security Parameters Index (#{spi}, {Int32} type),
+    # * a Security Parameters Index (#{spi}, {Types::Int32} type),
     # * a Sequence Number ({#sn}, +Int32+ type),
     # * a {#body} (variable length),
     # * an optional TFC padding ({#tfc}, variable length),
     # * an optional {#padding} (to align ESP on 32-bit boundary, variable length),
-    # * a {#pad_length} ({Int8}),
+    # * a {#pad_length} ({Types::Int8}),
     # * a Next header field ({#next}, +Int8+),
     # * and an optional Integrity Check Value ({#icv}, variable length).
     #
@@ -62,11 +62,7 @@ module PacketGen
     #
     #  pkt.esp.decrypt! cipher, intmode: hmac    # => true if ICV check OK
     # @author Sylvain Daubert
-    class ESP < Struct.new(:spi, :sn, :body, :tfc, :padding,
-                           :pad_length, :next, :icv)
-      include StructFu
-      include HeaderMethods
-      extend HeaderClassMethods
+    class ESP < Base
 
       # IP protocol number for ESP
       IP_PROTOCOL = 50
@@ -74,6 +70,38 @@ module PacketGen
       # Well-known UDP port for ESP
       UDP_PORT = 4500
 
+      # @!attribute spi
+      #  32-bit Security Parameter Index
+      #  @return [Integer]
+      define_field :spi, Types::Int32
+      # @!attribute sn
+      #  32-bit Sequence Number
+      #  @return [Integer]
+      define_field :sn, Types::Int32
+      # @!attribute body
+      #  @return [Types::String,Header::Base]
+      define_field :body, Types::String
+      # @!attribute tfc
+      #  Traffic Flow Confidentiality padding
+      #  @return [Types::String,Header::Base]
+      define_field :tfc, Types::String
+      # @!attribute padding
+      #  ESP padding
+      #  @return [Types::String,Header::Base]
+      define_field :padding, Types::String
+      # @!attribute pad_length
+      #  8-bit padding length
+      #  @return [Integer]
+      define_field :pad_length, Types::Int8
+      # @!attribute next
+      #  8-bit next protocol value
+      #  @return [Integer]
+      define_field :next, Types::Int8
+      # @!attribute icv
+      #  Integrity Check Value
+      #  @return [Types::String,Header::Base]
+      define_field :icv, Types::String
+
       # ICV (Integrity Check Value) length
       # @return [Integer]
       attr_accessor :icv_length
@@ -92,14 +120,7 @@ module PacketGen
       # @option options [::String] :icv Integrity Check Value
       def initialize(options={})
         @icv_length = options[:icv_length] || 0
-        super Int32.new(options[:spi]),
-              Int32.new(options[:sn]),
-              StructFu::String.new.read(options[:body]),
-              StructFu::String.new.read(options[:tfc]),
-              StructFu::String.new.read(options[:padding]),
-              Int8.new(options[:pad_length]),
-              Int8.new(options[:next]),
-              StructFu::String.new.read(options[:icv])
+        super
       end
 
       # Read a ESP packet from string.
@@ -111,7 +132,6 @@ module PacketGen
       # @return [self]
       def read(str)
         return self if str.nil?
-        raise ParseError, 'string too short for ESP' if str.size < self.sz
         force_binary str
         self[:spi].read str[0, 4]
         self[:sn].read str[4, 4]
@@ -124,58 +144,6 @@ module PacketGen
         self
       end
 
-      # Getter for SPI attribute
-      # @return [Integer]
-      def spi
-        self[:spi].to_i
-      end
-
-      # Setter for SPI attribute
-      # @param [Integer] val
-      # @return [Integer]
-      def spi=(val)
-        typecast val
-      end
-
-      # Getter for SN attribute
-      # @return [Integer]
-      def sn
-        self[:sn].to_i
-      end
-
-      # Setter for SN attribute
-      # @param [Integer] val
-      # @return [Integer]
-      def sn=(val)
-        typecast val
-      end
-
-      # Getter for +pad_length+ attribute
-      # @return [Integer]
-      def pad_length
-        self[:pad_length].to_i
-      end
-
-      # Setter for +pad_length+ attribute
-      # @param [Integer] val
-      # @return [Integer]
-      def pad_length=(val)
-        typecast val
-      end
-
-      # Getter for +next+ attribute
-      # @return [Integer]
-      def next
-        self[:next].to_i
-      end
-
-      # Setter for +next+ attribute
-      # @param [Integer] val
-      # @return [Integer]
-      def next=(val)
-        typecast val
-      end
-
       # Encrypt in-place ESP payload and trailer.
       #
       # This method removes all data from +tfc+ and +padding+ fields, as their
@@ -252,7 +220,7 @@ module PacketGen
         # as padding is used to pad for CBC mode, this is unused
         cipher.final
 
-        self[:body] = StructFu::String.new(iv) << enc_msg[0..-3]
+        self[:body] = Types::String.new(iv) << enc_msg[0..-3]
         self[:pad_length].read enc_msg[-2]
         self[:next].read enc_msg[-1]
 
@@ -364,7 +332,7 @@ module PacketGen
       def get_auth_data(opt)
         ad = self[:spi].to_s
         if opt[:esn]
-          @esn = StructFu::Int32.new(opt[:esn])
+          @esn = Types::Int32.new(opt[:esn])
           ad << @esn.to_s if @conf.authenticated?
         end
         ad << self[:sn].to_s

data/lib/packetgen/header/eth.rb

@@ -9,8 +9,8 @@ module PacketGen
     # An Ethernet header consists of:
     # * a destination MAC address ({MacAddr}),
     # * a source MAC address (MacAddr),
-    # * a {#ethertype} ({Int16}),
-    # * and a body (a {String} or another Header class).
+    # * a {#ethertype} ({Types::Int16}),
+    # * and a body (a {Types::String} or another Header class).
     #
     # == Create a Ethernet header
     #  # standalone
@@ -28,33 +28,30 @@ module PacketGen
     #  eth.body = "This is a body"
     #
     # @author Sylvain Daubert
-    class Eth < Struct.new(:dst, :src, :ethertype, :body)
-      include StructFu
-      include HeaderMethods
-      extend HeaderClassMethods
+    class Eth < Base
 
       # Ethernet MAC address, as a group of 6 bytes
       # @author Sylvain Daubert
-      class MacAddr < Struct.new(:a0, :a1, :a2, :a3, :a4, :a5)
-        include StructFu
+      class MacAddr < Base
+        # @!attribute a0
+        #  @return [Integer] first byte from MacAddr
+        define_field :a0, Types::Int8
+        # @!attribute a1
+        #  @return [Integer] second byte from MacAddr
+        define_field :a1, Types::Int8
+        # @!attribute a2
+        #  @return [Integer] third byte from MacAddr
+        define_field :a2, Types::Int8
+        # @!attribute a3
+        #  @return [Integer] fourth byte from MacAddr
+        define_field :a3, Types::Int8
+        # @!attribute a4
+        #  @return [Integer] fifth byte from MacAddr
+        define_field :a4, Types::Int8
+        # @!attribute a5
+        #  @return [Integer] sixth byte from MacAddr
+        define_field :a5, Types::Int8
         
-        # @param [Hash] options
-        # @option options [Integer] :a0
-        # @option options [Integer] :a1
-        # @option options [Integer] :a2
-        # @option options [Integer] :a3
-        # @option options [Integer] :a4
-        # @option options [Integer] :a5
-        def initialize(options={})
-          super Int8.new(options[:a0]),
-                Int8.new(options[:a1]),
-                Int8.new(options[:a2]),
-                Int8.new(options[:a3]),
-                Int8.new(options[:a4]),
-                Int8.new(options[:a5])
-
-        end
-
         # Read a human-readable string to populate +MacAddr+
         # @param [String] str
         # @return [self]
@@ -73,27 +70,10 @@ module PacketGen
           self
         end
 
-        # Read a +MacAddr+ from a binary string
-        # @param [String] str binary string
-        # @return [self]
-        def read(str)
-          return self if str.nil?
-          raise ParseError, 'string too short for Eth' if str.size < self.sz
-          force_binary str
-          [:a0, :a1, :a2, :a3, :a4, :a5].each_with_index do |byte, i|
-            self[byte].read str[i, 1]
-          end
-        end
-
-        [:a0, :a1, :a2, :a3, :a4, :a5].each do |sym|
-          class_eval "def #{sym}; self[:#{sym}].to_i; end\n" \
-                     "def #{sym}=(v); self[:#{sym}].read v; end"
-        end
-
         # +MacAddr+ in human readable form (colon format)
         # @return [String]
         def to_human
-          members.map { |m| "#{'%02x' % self[m]}" }.join(':')
+          fields.map { |m| "#{'%02x' % self[m]}" }.join(':')
         end
       end
 
@@ -104,69 +84,18 @@ module PacketGen
       # @private timeout for PCAPRUB
       PCAP_TIMEOUT = 1
 
-      # @param [Hash] options
-      # @option options [String] :dst MAC destination address
-      # @option options [String] :src MAC source address
-      # @option options [Integer] :ethertype
-      def initialize(options={})
-        super MacAddr.new.from_human(options[:dst] || '00:00:00:00:00:00'),
-              MacAddr.new.from_human(options[:src] || '00:00:00:00:00:00'),
-              Int16.new(options[:ethertype] || 0),
-              StructFu::String.new.read(options[:body])
-      end
-
-      # Read a Eth header from a string
-      # @param [String] str binary string
-      # @return [self]
-      def read(str)
-        return self if str.nil?
-        raise ParseError, 'string too short for Eth' if str.size < self.sz
-        force_binary str
-        self[:dst].read str[0, 6]
-        self[:src].read str[6, 6]
-        self[:ethertype].read str[12, 2]
-        self[:body].read str[14..-1]
-        self
-      end
-
-      # Get MAC destination address
-      # @return [String]
-      def dst
-        self[:dst].to_human
-      end
-
-      # Set MAC destination address
-      # @param [String] addr
-      # @return [String]
-      def dst=(addr)
-        self[:dst].from_human addr
-      end
-
-      # Get MAC source address
-      # @return [String]
-      def src
-        self[:src].to_human
-      end
-
-      # Set MAC source address
-      # @param [String] addr
-      # @return [String]
-      def src=(addr)
-        self[:src].from_human addr
-      end
-
-      # Get ethertype field
-      # @return [Integer]
-      def ethertype
-        self[:ethertype].to_i
-      end
-
-      # Set ethertype field
-      # @param [Integer] type
-      # @return [Integer]
-      def ethertype=(type)
-        self[:ethertype].value = type
-      end
+      # @!attribute dst
+      #  @return [MacAddr] Destination MAC address
+      define_field :dst, MacAddr, default: '00:00:00:00:00:00'
+      # @!attribute src
+      #  @return [MacAddr] Source MAC address
+      define_field :src, MacAddr, default: '00:00:00:00:00:00'
+      # @!attribute ethertype
+      #  @return [Integer] 16-bit integer to determine payload type
+      define_field :ethertype, Types::Int16, default: 0
+      # @!attribute body
+      #  @return [Types::String,Header::Base]
+      define_field :body, Types::String
 
       # send Eth packet on wire.
       # @param [String] iface interface name

data/lib/packetgen/header/icmp.rb

@@ -7,9 +7,9 @@ module PacketGen
   module Header
 
     # A ICMP header consists of:
-    # * a {#type} field ({Int8} type),
-    # * a {#code} field ({Int8} type),
-    # * a {#checksum} field ({Int16} type),
+    # * a {#type} field ({Types::Int8} type),
+    # * a {#code} field ({Types::Int8} type),
+    # * a {#checksum} field ({Types::Int16} type),
     # * and a {#body}.
     #
     # == Create a ICMP header
@@ -26,38 +26,26 @@ module PacketGen
     #  icmp.checksum = 0x248a
     #  icmp.body.read 'this is a body'
     # @author Sylvain Daubert
-    class ICMP < Struct.new(:type, :code, :checksum, :body)
-      include StructFu
-      include HeaderMethods
-      extend HeaderClassMethods
+    class ICMP < Base
 
       # ICMP internet protocol number
       IP_PROTOCOL = 1
 
-      # @param [Hash] options
-      # @option options [Integer] :type
-      # @option options [Integer] :code
-      # @option options [Integer] :checksum
-      # @option options [String] :body
-      def initialize(options={})
-        super Int8.new(options[:type]),
-              Int8.new(options[:code]),
-              Int16.new(options[:checksum]),
-              StructFu::String.new.read(options[:body])
-      end
-
-      # Read a ICMP header from a string
-      # @param [String] str binary string
-      # @return [self]
-      def read(str)
-        return self if str.nil?
-        raise ParseError, 'string too short for ICMP' if str.size < self.sz
-        force_binary str
-        self[:type].read str[0, 1]
-        self[:code].read str[1, 1]
-        self[:checksum].read str[2, 2]
-        self[:body].read str[4..-1]
-      end
+      # @!attribute type
+      #  8-bit ICMP type
+      #  @return [Integer]
+      define_field :type, Types::Int8
+      # @!attribute code
+      #  8-bit ICMP code
+      #  @return [Integer]
+      define_field :code, Types::Int8
+      # @!attribute checksum
+      #  16-bit ICMP checksum
+      #  @return [Integer]
+      define_field :checksum, Types::Int16
+      # @!attribute body
+      #  @return [Types::String,Header::Base]
+      define_field :body, Types::String
 
       # Compute checksum and set +checksum+ field
       # @return [Integer]
@@ -74,45 +62,6 @@ module PacketGen
         sum = ~sum & 0xffff
         self[:checksum].value = (sum == 0) ? 0xffff : sum
       end
-
-      # Getter for type attribute
-      # @return [Integer]
-      def type
-        self[:type].to_i
-      end
-
-      # Setter for type attribute
-      # @param [Integer] type
-      # @return [Integer]
-      def type=(type)
-        self[:type].value = type
-      end
-
-      # Getter for code attribute
-      # @return [Integer]
-      def code
-        self[:code].to_i
-      end
-
-      # Setter for code attribute
-      # @param [Integer] code
-      # @return [Integer]
-      def code=(code)
-        self[:code].value = code
-      end
-
-      # Getter for checksum attribute
-      # @return [Integer]
-      def checksum
-        self[:checksum].to_i
-      end
-
-      # Setter for checksum attribute
-      # @param [Integer] sum
-      # @return [Integer]
-      def checksum=(sum)
-        self[:checksum].value = sum
-      end
     end
 
     self.add_class ICMP

data/lib/packetgen/header/icmpv6.rb

@@ -7,9 +7,9 @@ module PacketGen
   module Header
 
     # A ICMPv6 header consists of:
-    # * a +type+ field ({Int8} type),
-    # * a +code+ field ({Int8} type),
-    # * a +checksum+ field ({Int16} type),
+    # * a +type+ field ({Types::Int8} type),
+    # * a +code+ field ({Types::Int8} type),
+    # * a +checksum+ field ({Types::Int16} type),
     # * and a +body+.
     #
     # == Create a ICMPv6 header