packetgen 2.1.3 → 2.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e306dbee54d246dd2044db6610ba27e3fb539215
-  data.tar.gz: 1103a3a6429fb2b4c8391750cdefa8c7d87ac323
+  metadata.gz: 36c2e8a9384d7c08723de6f529893d0dd42e5d8d
+  data.tar.gz: 0e91b3917d405a1a09b75a7863685645b52827d9
 SHA512:
-  metadata.gz: 592a69c18ea009c84374aa79125134ee136f0ed9050aefb8610ff484447f9cddc66685fcc3449733d2f6a1160de403d51a4465689029090815db45cdf292e12f
-  data.tar.gz: cf57d3f41ea4eaa30964086ec2a1127a0f2aae14a291b2fc7476819484aaa0a14a5c0681bda1f68ad7ba4aa84edc6196cb7684054ea94c22c91a5626eb2ac533
+  metadata.gz: 55414180e5ca3bcc69cee0a00a84cbe79635a2809d3f999d35a9d6fab725b5dfc153ea5cc087c10d08985caf10c60aa7ee23df2fb4537d7ca3d6924789f2e614
+  data.tar.gz: 51ea04c7c3a1544911ca26f4c6b8c066bc58aa0255a2dd6241f21b668fee9e16c7def036d62722c7e826f77947128225c1a56d5ee4ef27aa71d0eaff55352b5e

data/lib/packetgen/header.rb

@@ -93,6 +93,7 @@ require_relative 'header/icmpv6'
 require_relative 'header/gre'
 require_relative 'header/udp'
 require_relative 'header/tcp'
+require_relative 'header/eap'
 require_relative 'header/esp'
 require_relative 'header/ike'
 require_relative 'header/dns'

data/lib/packetgen/header/asn1_base.rb

@@ -15,8 +15,8 @@ module PacketGen
     # @author Sylvain Daubert
     class ASN1Base < RASN1::Model
 
-      # @api private
       # Reference on packet which owns this header
+      # @return [Packet,nil]
       attr_accessor :packet
 
       # Give protocol name for this class
@@ -65,6 +65,25 @@ module PacketGen
         true
       end
 
+      # @api private
+      # @since 2.1.4
+      # Set packet to which this header belongs
+      # @param [Packet] packet
+      # @return [Packet] packet
+      def packet=(packet)
+        @packet = packet
+        added_to_packet(packet)
+        @packet
+      end
+      
+      # @abstract This method is called when a header is added to a packet.
+      #   This base method does nothing but may be overriden by subclasses.
+      # @param [Packet] packet packet to which self is added
+      # @return [void]
+      # @since 2.1.4
+      def added_to_packet(packet)
+      end
+
       alias :parse :parse!
       alias :to_s :to_der
 

data/lib/packetgen/header/base.rb

@@ -35,7 +35,12 @@ module PacketGen
           when Proc
             fields.send "#{self[:key]}=", self[:value].call(nil)
           else
-            fields.send "#{self[:key]}=", self[:value]
+            attr = if self[:key].to_s.end_with?('?')
+                     self[:key].to_s[0..-2]
+                   else
+                     self[:key]
+                   end
+            fields.send "#{attr}=", self[:value]
           end
         end
       end
@@ -127,9 +132,9 @@ module PacketGen
         end
       end
 
-      # @api private
       # Reference on packet which owns this header
-      attr_accessor :packet
+      # @return [Packet,nil]
+      attr_reader :packet
 
       # On inheritage, create +@known_headers+ class variable
       # @param [Class] klass
@@ -217,6 +222,25 @@ module PacketGen
         true
       end
 
+      # @api private
+      # Set packet to which this header belongs
+      # @param [Packet] packet
+      # @return [Packet] packet
+      # @since 2.1.4
+      def packet=(packet)
+        @packet = packet
+        added_to_packet(packet)
+        @packet
+      end
+      
+      # @abstract This method is called when a header is added to a packet.
+      #   This base method does nothing but may be overriden by subclasses.
+      # @param [Packet] packet packet to which self is added
+      # @return [void]
+      # @since 2.1.4
+      def added_to_packet(packet)
+      end
+
       # @api private
       # Get +header+ id in packet headers array
       # @param [Header] header

data/lib/packetgen/header/dot11.rb

@@ -67,6 +67,7 @@ module PacketGen
         pcap = PCAPRUB::Pcap.open_live(iface, PCAP_SNAPLEN, PCAP_PROMISC,
                                        PCAP_TIMEOUT)
         pcap.inject self.to_s
+        pcap.close
       end
     end
     self.add_class PPI
@@ -127,6 +128,7 @@ module PacketGen
         pcap = PCAPRUB::Pcap.open_live(iface, PCAP_SNAPLEN, PCAP_PROMISC,
                                        PCAP_TIMEOUT)
         pcap.inject self.to_s
+        pcap.close
       end
     end
     self.add_class RadioTap
@@ -161,11 +163,15 @@ module PacketGen
     # Control frames may be created this way:
     #   pkt = PacketGen.gen('Dot11::Control', subtype: 13) # Ack control frame
     #   pkt.dot11_control     # => PacketGen::Header::Dot11::Control
+    #   # #dot11 is a shortcut for #dot11_control
+    #   pkt.dot11             # => PacketGen::Header::Dot11::Control
     #
     # === IEEE802.11 management frames
     # Management frames may be created this way:
     #   pkt = PacketGen.gen('Dot11::Management')
     #   pkt.dot11_management     # => PacketGen::Header::Dot11::Management
+    #   # #dot11 is a shortcut for #dot11_management
+    #   pkt.dot11                # => PacketGen::Header::Dot11::Management
     # Management frames are usually specialized, AssociationRequest by example:
     #   pkt.add('Dot11::AssoReq')
     #   pkt.dot11_assoreq        # => PacketGen::Header::Dot11::AssoReq
@@ -177,13 +183,14 @@ module PacketGen
     # Data frames may be created this way:
     #   pkt = PacketGen.gen('Dot11::Data')
     #   pkt.dot11_data     # => PacketGen::Header::Dot11::Data
+    #   # #dot11 is a shortcut for #dot11_data
+    #   pkt.dot11          # => PacketGen::Header::Dot11::Data
     #
     # == Parse Dot11 packets
     # When parsing a Dot11 packet, Dot11 subclass is created from +type+ value.
-    # Dot11 header should then be accessed through +Packet#dot11_management+,
-    # +Packet#dot11_control+ or +Packet#dot11_data+.
-    #
-    # A  +Packet#dot11+ may exist for unknown types.
+    # Dot11 header should then be accessed through +Packet#dot11+, whatever
+    # the frame type is. But, specialized methods also exist: by example,
+    # for a control frame, +Packet#dot11_control+ may also be used.
     #
     # == Send Dot11 packets
     # To send a Dot11 packet, a RadioTap header is needed:
@@ -366,8 +373,19 @@ module PacketGen
       def to_w(iface)
         pcap = PCAPRUB::Pcap.open_live(iface, PCAP_SNAPLEN, PCAP_PROMISC,
                                        PCAP_TIMEOUT)
-        str = self.to_s
-        pcap.inject str
+        pcap.inject self.to_s
+        pcap.close
+      end
+      
+      # Callback called when a Dot11 header is added to a packet
+      # Here, add +#dot11+ method as a shortcut to existing
+      # +#dot11_(control|management|data)+.
+      # @param [Packet] packet
+      # @return [void]
+      def added_to_packet(packet)
+        unless packet.respond_to? :dot11
+          packet.instance_eval("def dot11(arg=nil); header(#{self.class}, arg); end")
+        end
       end
 
       private

data/lib/packetgen/header/dot1x.rb

@@ -46,11 +46,30 @@ module PacketGen
       #  @return [Types::String,Header::Base]
       define_field :body, Types::String
 
+      # Populate object from string
+      # @param [String] str
+      # @return [self]
+      def read(str)
+        return self if str.nil?
+        self[:version].read(str[0, 1])
+        self[:type].read(str[1, 1])
+        self[:length].read(str[2, 2])
+        self[:body].read(str[4, self.length])
+        self
+      end
+
       # Get human readable type
       # @return [String]
       def human_type
         self[:type].to_human
       end
+
+      # Calculate and set body length
+      # @return [Integer]
+      # @since 2.1.4
+      def calc_length
+        self.length = body.sz
+      end
     end
 
     Eth.bind_header Dot1x, ethertype: Dot1x::ETHERTYPE

data/lib/packetgen/header/eap.rb

@@ -0,0 +1,238 @@
+# This file is part of PacketGen
+# See https://github.com/sdaubert/packetgen for more informations
+# Copyright (C) 2016 Sylvain Daubert <sylvain.daubert@laposte.net>
+# This program is published under MIT license.
+
+module PacketGen
+  module Header
+
+    # Extensible Authentication Protocol (EAP),
+    # {https://tools.ietf.org/html/rfc3748 RFC 3748}
+    #
+    # A EAP header has:
+    # * a {#code} field ({Types::Int8Enum}),
+    # * a {#id} field ({Types::Int8}),
+    # * a {#length} field ({Types::Int16}).
+    # Request (code 1) and Response (code 2) packets also have:
+    # * a {#type} field (+Types::Int8Enum+).
+    # And Expanded Types (type 254) packets also have:
+    # * a {#vendor_id} field ({Types::Int24}),
+    # * a {#vendor_type} field ({Types::Int32}).
+    # Finally, all packets have a {#body} ({Types::String}).
+    #
+    # == Create EAP headers
+    # An EAP header may be created this way:
+    #   # create a request header with default type (1)
+    #   eap = EAP.new(code: 1)   # => PacketGen::Header::EAP
+    #   # the same
+    #   eap = EAP.new(code: 'Request')   # => PacketGen::Header::EAP
+    #   # create a Response header of type Nak
+    #   nak = EAP.new(code: 'Response', type: 'Nak')
+    #
+    # === Specialized headers
+    # Some EAP has a specialized class:
+    # * EAP-MD5,
+    # * EAP-TLS,
+    # * EAP-TTLS,
+    # * EAP-FAST.
+    # Creating such a header is fairly simple:
+    #   # Generate a EAP-TLS Response (type is forced to 13)
+    #   eap = EAP::TLS.new(code: 2)     # => PacketGen::Header::EAP::TLS
+    #
+    # == Header accessors
+    # EAP headers may be accessed through +Packet#eap+ accessor.
+    # As EAP has specialized subclasses ({EAP::MD5}, {EAP::TLS}, {EAP::TTLS} and
+    # {EAP::FAST}), these headers may be accessed through +#eap_md5+, +#eap_tls+,
+    # +#eap_ttls+ and +#eap_fast+, respectively. But +#eap+ is still here as a
+    # shortcut.
+    #
+    # == Parse EAP packets
+    # When parsing an EAP packet, EAP subclass may be created from +type+ value.
+    #
+    # So result of parsing a EAP header may be a {EAP}, {EAP::MD5}, {EAP::TLS},
+    # {EAP::TTLS} or {EAP::FAST} instance. But this instance is still accessible
+    # through +Packet#eap+.
+    # @author Sylvain Daubert
+    # @since 2.1.4
+    class EAP < Base
+
+      # EAP known codes
+      CODES = {
+        'Request'   => 1,
+        'Response'  => 2,
+        'Success'   => 3,
+        'Failure'   => 4
+      }
+      
+      # EAP known request/response types
+      TYPES = {
+        'Identity'           => 1,
+        'Notification'       => 2,
+        'Nak'                => 3,
+        'MD5-Challenge'      => 4,
+        'One Time Password'  => 5,
+        'Generic Token Card' => 6,
+        'EAP-TLS'            => 13,
+        'EAP-TTLS'           => 21,
+        'EAP-FAST'           => 43,
+        'Expanded Types'     => 254,
+        'Experimental Use'   => 255
+      }
+
+      # @!attribute code
+      #  @return [Integer] 8-bit EAP code
+      define_field :code, Types::Int8Enum, enum: CODES
+
+      # @!attribute id
+      #  @return [Integer] 8-bit identifier
+      define_field :id, Types::Int8
+
+      # @!attribute length
+      #  @return [Integer] 16-bit length of EAP packet
+      define_field :length, Types::Int16, default: 4
+      
+      # @!attribute type
+      #  This field is present only for Request or Response packets,
+      #  with type different from Expanded Types (254).
+      #  @return [Integer] 8-bit request or response type
+      define_field :type, Types::Int8Enum, enum: TYPES, 
+                   optional: ->(eap) { eap.has_type? }
+                   
+      # @!attribute vendor_id
+      #  This field is present only for Request or Response packets,
+      #  with type equal to +Expanded Types+ (254).
+      #  @return [Integer] 24-bit vendor ID
+      define_field :vendor_id, Types::Int24,
+                   optional: ->(eap) { eap.has_type? and eap.type == 254 }
+      
+      # @!attribute vendor_type
+      #  This field is present only for Request or Response packets,
+      #  with type equal to +Expanded Types+ (254).
+      #  @return [Integer] 32-bit vendor type
+      define_field :vendor_type, Types::Int32,
+                   optional: ->(eap) { eap.has_type? and eap.type == 254 }
+
+      # @!attribute body
+      #  @return [Types::String, Header::Base]
+      define_field :body, Types::String
+      
+      # @return [EAP]
+      def initialize(options={})
+        super
+        calc_length if options[:length].nil?
+      end
+      
+      # @private
+      alias old_read read
+      
+      # Populate object from a binary string
+      # @param [String] str
+      # @return [Dot11] may return a subclass object if a more specific class
+      #   may be determined
+      def read(str)
+        if self.class == EAP
+          super str
+
+          if has_type?
+            obj = case self.type
+                  when 4
+                    EAP::MD5.new.read(str)
+                  when 13
+                    EAP::TLS.new.read(str)
+                  when 21
+                    EAP::TTLS.new.read(str)
+                  when 43
+                    EAP::FAST.new.read(str)
+                  else
+                    self
+                  end
+            return obj
+          else
+            return self
+          end
+        else
+          super str
+        end
+        self
+      end
+
+      # Get human readable code
+      # @return [String]
+      def human_code
+        self[:code].to_human
+      end
+      
+      # Get human readable type
+      # @return [String]
+      # @raise [ParseError] not a Request nor a Response packet
+      def human_type
+        raise ParseError, 'not a Request nor a Response' unless has_type?
+        self[:type].to_human
+      end
+      
+      # Is packet a request?
+      # @return [Boolean]
+      def request?
+        code == CODES['Request']
+      end
+      
+      # Is packet a response?
+      # @return [Boolean]
+      def response?
+        code == CODES['Response']
+      end
+      
+      # Is packet a success?
+      # @return [Boolean]
+      def success?
+        code == CODES['Success']
+      end
+      
+      # Is packet a failure?
+      # @return [Boolean]
+      def failure?
+        code == CODES['Failure']
+      end
+      
+      # Return an array of desired authentication types from a Nak packet
+      # @return [Array<Integer>]
+      # @raise [ParseError] not a Nak packet
+      def desired_auth_type
+        if code != 2 and type != 3
+          raise ParseError, 'not a Nak response'
+        end
+        body.to_s.unpack('C*')
+      end
+      
+      # Calculate length field from content
+      # @return [Integer]
+      def calc_length
+        self.length = sz
+      end
+
+      # Say is this EAP header has {#type} field
+      # @return [Boolean]
+      def has_type?
+        [1,2].include?(self.code)
+      end
+
+      # Callback called when a EAP header is added to a packet
+      # Here, add +#eap+ method as a shortcut to existing
+      # +#eap_(md5|tls|ttls|fast)+.
+      # @param [Packet] packet
+      # @return [void]
+      def added_to_packet(packet)
+        unless packet.respond_to? :eap
+          packet.instance_eval("def eap(arg=nil); header(#{self.class}, arg); end")
+        end
+      end
+    end
+    
+    Dot1x.bind_header EAP, type: 0
+  end
+end
+
+require_relative 'eap/md5'
+require_relative 'eap/tls'
+require_relative 'eap/ttls'
+require_relative 'eap/fast'

data/lib/packetgen/header/eap/fast.rb

@@ -0,0 +1,27 @@
+# This file is part of PacketGen
+# See https://github.com/sdaubert/packetgen for more informations
+# Copyright (C) 2016 Sylvain Daubert <sylvain.daubert@laposte.net>
+# This program is published under MIT license.
+
+module PacketGen
+  module Header
+    class EAP
+
+      # Extensible Authentication Protocol (EAP) - Flexible Authentication variable
+      # Secure Tunneling, {https://tools.ietf.org/html/rfc4851 RFC 4851}
+      #
+      # {EAP::FAST} has following fields:
+      # * {#flags} ({Types::Int8}),
+      # * optionally {#message_length} ({Types::Int32}), if +#l?+ is +true+,
+      # * {#body} ({Types::String}).
+      # @author Sylvain Daubert
+      # @since 2.1.4
+      class FAST < TTLS
+        # @return [EAP::FAST]
+        def initialize(options={})
+          super({ type: 43 }.merge!(options))
+        end
+      end
+    end
+  end
+end

data/lib/packetgen/header/eap/md5.rb

@@ -0,0 +1,34 @@
+# This file is part of PacketGen
+# See https://github.com/sdaubert/packetgen for more informations
+# Copyright (C) 2016 Sylvain Daubert <sylvain.daubert@laposte.net>
+# This program is published under MIT license.
+
+module PacketGen
+  module Header
+    class EAP
+
+      # Extensible Authentication Protocol (EAP) - 
+      # {https://tools.ietf.org/html/rfc3748#section-5.4 MD5 challenge}
+      # @author Sylvain Daubert
+      # @since 2.1.4
+      class MD5 < EAP
+        delete_field :body
+        # @!attribute value_size
+        #  @return [Integer] 8-bit value size
+        define_field :value_size, Types::Int8
+        # @!attribute value
+        #  @return [::String]
+        define_field :value, Types::String,
+                     builder: ->(h) { Types::String.new('', length_from: h[:value_size]) }
+        # @!attribute optional_name
+        #  @return [::String]
+        define_field :optional_name, Types::String
+
+        # @return [EAP::MD5]
+        def initialize(options={})
+          super({ type: 4 }.merge!(options))
+        end
+      end
+    end
+  end
+end

data/lib/packetgen/header/eap/tls.rb

@@ -0,0 +1,73 @@
+# This file is part of PacketGen
+# See https://github.com/sdaubert/packetgen for more informations
+# Copyright (C) 2016 Sylvain Daubert <sylvain.daubert@laposte.net>
+# This program is published under MIT license.
+
+module PacketGen
+  module Header
+    class EAP
+
+      # Extensible Authentication Protocol (EAP) - TLS,
+      # {https://tools.ietf.org/html/rfc5216 RFC 5216}
+      #
+      # {EAP::TLS} has following fields:
+      # * {#flags} ({Types::Int8}),
+      # * optionally {#tls_length} ({Types::Int32}), if +#l?+ is +true+,
+      # * {#body} ({Types::String}).
+      # @author Sylvain Daubert
+      # @since 2.1.4
+      class TLS < EAP
+        # @!attribute flags
+        #  @return [Integer] 8-bit flags
+        define_field_before :body, :flags, Types::Int8
+        
+        # @!attribute l
+        #  Say if length field is included. Defined on {#flags} field.
+        #  @return [Boolean]
+        # @!attribute m
+        #  Say if there are more fragments. Defined on {#flags} field.
+        #  @return [Boolean]
+        # @!attribute s
+        #  If set, this message is a TLS-Start. Defined on {#flags} field.
+        #  @return [Boolean]
+        define_bit_fields_on :flags, :l, :m, :s, :reserved, 5
+        alias :length_present? :l?
+        alias :more_fragments? :m?
+        alias :tls_start? :s?
+        
+        # @!attribute tls_length
+        #  TLS message length. This field provides the total length of the
+        #  TLS message or set of messages that is being fragmented. So, it
+        #  cannot be automatically calculated (no +#calc_length+ method).
+        #  @return [Integer] 32-bit TLS length
+        define_field_before :body, :tls_length, Types::Int32,
+                     optional: ->(h) { h.l? }
+
+        # @return [EAP::TLS]
+        def initialize(options={})
+          super({ type: 13 }.merge!(options))
+        end
+
+        # @return [String]
+        def inspect
+          str = Inspect.dashed_line(self.class, 2)
+          fields.each do |attr|
+            next if attr == :body
+            next unless is_present?(attr)
+            if attr == :flags
+              shift = Inspect.shift_level(2)
+              value = %i(l m s).map { |f| send("#{f}?") ? f.to_s : '.' }.join
+              value = '%-10s (0x%02x)' % [value, self.flags]
+              str << shift 
+              str << Inspect::FMT_ATTR % [self[attr].class.to_s.sub(/.*::/, ''),
+                                         attr, value]
+            else
+              str << Inspect.inspect_attribute(attr, self[attr], 2)
+            end
+          end
+          str
+        end
+      end
+    end
+  end
+end

data/lib/packetgen/header/eap/ttls.rb

@@ -0,0 +1,78 @@
+# This file is part of PacketGen
+# See https://github.com/sdaubert/packetgen for more informations
+# Copyright (C) 2016 Sylvain Daubert <sylvain.daubert@laposte.net>
+# This program is published under MIT license.
+
+module PacketGen
+  module Header
+    class EAP
+
+      # Extensible Authentication Protocol (EAP) - Tunneled-TLS,
+      # {https://tools.ietf.org/html/rfc5281 RFC 5281}
+      #
+      # {EAP::TTLS} has following fields:
+      # * {#flags} ({Types::Int8}),
+      # * optionally {#message_length} ({Types::Int32}), if +#l?+ is +true+,
+      # * {#body} ({Types::String}).
+      # @author Sylvain Daubert
+      # @since 2.1.4
+      class TTLS < EAP
+        # @!attribute flags
+        #  @return [Integer] 8-bit flags
+        define_field_before :body, :flags, Types::Int8
+        
+        # @!attribute l
+        #  Say if length field is included. Defined on {#flags} field.
+        #  @return [Boolean]
+        # @!attribute m
+        #  Say if there are more fragments. Defined on {#flags} field.
+        #  @return [Boolean]
+        # @!attribute s
+        #  If set, this message is a TLS-Start. Defined on {#flags} field.
+        #  @return [Boolean]
+        # @!attribute reserved
+        #  @return [Integer] 2-bit reserved integer
+        # @!attribute version
+        #  @return [Integer] 3-bit version
+        define_bit_fields_on :flags, :l, :m, :s, :reserved, 2, :version, 3
+        alias :length_present? :l?
+        alias :more_fragments? :m?
+        alias :tls_start? :s?
+        
+        # @!attribute message_length
+        #  Message length. This field provides the total length of the
+        #  raw data message sequence prior to fragmentation. So, it
+        #  cannot be automatically calculated (no +#calc_length+ method).
+        #  @return [Integer] 32-bit message length
+        define_field_before :body, :message_length, Types::Int32,
+                     optional: ->(h) { h.l? }
+
+        # @return [EAP::TTLS]
+        def initialize(options={})
+          super({ type: 21 }.merge!(options))
+        end
+
+        # @return [String]
+        def inspect
+          str = Inspect.dashed_line(self.class, 2)
+          fields.each do |attr|
+            next if attr == :body
+            next unless is_present?(attr)
+            if attr == :flags
+              shift = Inspect.shift_level(2)
+              value = %i(l m s).map { |f| send("#{f}?") ? f.to_s : '.' }.join
+              value = '%-10s (0x%02x)' % [value, self.flags]
+              str << shift 
+              str << Inspect::FMT_ATTR % [self[attr].class.to_s.sub(/.*::/, ''),
+                                         attr, value]
+              str << Inspect::FMT_ATTR % ['', 'version', self.version]
+            else
+              str << Inspect.inspect_attribute(attr, self[attr], 2)
+            end
+          end
+          str
+        end
+      end
+    end
+  end
+end

data/lib/packetgen/header/eth.rb

@@ -96,6 +96,7 @@ module PacketGen
       def to_w(iface)
         pcap = PCAPRUB::Pcap.open_live(iface, PCAP_SNAPLEN, PCAP_PROMISC, PCAP_TIMEOUT)
         pcap.inject self.to_s
+        pcap.close
       end
     end
 

data/lib/packetgen/header/ike/auth.rb

@@ -38,27 +38,26 @@ module PacketGen
         # Payload type number
         PAYLOAD_TYPE = 39
 
-        METHOD_RSA_SIGNATURE     = 1
-        METHOD_SHARED_KEY        = 2
-        METHOD_DSA_SIGNATURE     = 3
-        METHOD_ECDSA256          = 9
-        METHOD_ECDSA384          = 10
-        METHOD_ECDSA512          = 11
-        METHOD_PASSWORD          = 12
-        METHOD_NULL              = 13
-        METHOD_DIGITAL_SIGNATURE = 14
+        METHODS = {
+          'RSA_SIGNATURE'     => 1,
+          'SHARED_KEY'        => 2,
+          'DSA_SIGNATURE'     => 3,
+          'ECDSA256'          => 9,
+          'ECDSA384'          => 10,
+          'ECDSA512'          => 11,
+          'PASSWORD'          => 12,
+          'NULL'              => 13,
+          'DIGITAL_SIGNATURE' => 14
+        }
 
-        # @attribute :u32
-        #   32-bit word including ID Type and RESERVED fields
-        #   @return [Integer]
-        define_field_before :content, :u32, Types::Int32
         # @attribute [r] method
         #   8-bit Auth Method
         #   @return [Integer]
+        define_field_before :content, :method, Types::Int8Enum, enum: METHODS
         # @attribute reserved
         #   24-bit reserved field
         #   @return [Integer]
-        define_bit_fields_on :u32, :method, 8, :reserved, 24
+        define_field_before :content, :reserved, Types::Int24
 
         # Check authentication (see RFC 7296 §2.15)
         # @param [Packet] init_msg first IKE message sent by peer
@@ -83,10 +82,11 @@ module PacketGen
           signed_octets << prf(prf, sk_p, id.to_s[4, id.length - 4])
 
           case method
-          when METHOD_SHARED_KEY
+          when METHODS['SHARED_KEY']
             auth  = prf(prf(shared_secret, 'Key Pad for IKEv2'), signed_octets)
             auth == content
-          when METHOD_RSA_SIGNATURE, METHOD_ECDSA256, METHOD_ECDSA384, METHOD_ECDSA512
+          when METHODS['RSA_SIGNATURE'], METHODS['ECDSA256'], METHODS['ECDSA384'],
+               METHODS['ECDSA512']
             if packet.ike_cert
               # FIXME: Expect a ENCODING_X509_CERT_SIG
               #        Others types not supported for now...
@@ -122,46 +122,10 @@ module PacketGen
           end
         end
 
-        # Set Auth method
-        # @param [Integer,String] value
-        # @return [Integer]
-        def method=(value)
-          method = case value
-               when Integer
-                 value
-               else
-                 c = self.class.constants.grep(/METHOD_#{value}/).first
-                 c ? self.class.const_get(c) : nil
-               end
-          raise ArgumentError, "unknown auth method #{value.inspect}" unless method
-          self[:u32].value = (self[:u32].to_i & 0xffffff) | (method << 24)
-        end
-
         # Get authentication method name
         # @return [String]
         def human_method
-          name = self.class.constants.grep(/METHOD_/).
-                 select { |c| self.class.const_get(c) == method }.
-                 first || "method #{method}"
-          name.to_s.sub(/METHOD_/, '')
-        end
-
-        # @return [String]
-        def inspect
-          str = Inspect.dashed_line(self.class, 2)
-          fields.each do |attr|
-            case attr
-            when :body
-              next
-            when :u32
-              str << Inspect.shift_level(2)
-              str << Inspect::FMT_ATTR % ['Int8', :method, human_method]
-              str << Inspect.inspect_attribute(:reserved, self.reserved, 2)
-            else
-              str << Inspect.inspect_attribute(attr, self[attr], 2)
-            end
-          end
-          str
+          self[:method].to_human
         end
 
         private

data/lib/packetgen/header/ike/id.rb

@@ -40,80 +40,43 @@ module PacketGen
         # Payload type number
         PAYLOAD_TYPE = 35
 
-        TYPE_IPV4_ADDR   = 1
-        TYPE_FQDN        = 2
-        TYPE_RFC822_ADDR = 3
-        TYPE_IPV6_ADDR   = 5
-        TYPE_DER_ASN1_DN = 9
-        TYPE_DER_ASN1_GN = 10
-        TYPE_KEY_ID      = 11
+        TYPES = {
+          'IPV4_ADDR'   => 1,
+          'FQDN'        => 2,
+          'RFC822_ADDR' => 3,
+          'IPV6_ADDR'   => 5,
+          'DER_ASN1_DN' => 9,
+          'DER_ASN1_GN' => 10,
+          'KEY_ID'      => 11
+        }
 
-        # @attribute :u32
-        #   32-bit word including ID Type and RESERVED fields
-        #   @return [Integer]
-        define_field_before :content, :u32, Types::Int32
         # @attribute [r] type
         #   8-bit ID type
         #   @return [Integer]
+        define_field_before :content, :type, Types::Int8Enum, enum: TYPES
         # @attribute reserved
         #   24-bit reserved field
         #   @return [Integer]
-        define_bit_fields_on :u32, :type, 8, :reserved, 24
-
-        # Set ID type
-        # @param [Integer,String] value
-        # @return [Integer]
-        def type=(value)
-          type = case value
-               when Integer
-                 value
-               else
-                 c = self.class.constants.grep(/TYPE_#{value}/).first
-                 c ? self.class.const_get(c) : nil
-               end
-          raise ArgumentError, "unknown ID type #{value.inspect}" unless type
-          self[:u32].value = (self[:u32].to_i & 0xffffff) | (type << 24)
-        end
+        define_field_before :content, :reserved, Types::Int24
 
         # Get ID type name
         # @return [String]
         def human_type
-          name = self.class.constants.grep(/TYPE_/).
-                 select { |c| self.class.const_get(c) == type }.
-                 first || "type #{type}"
-          name.to_s.sub(/TYPE_/, '')
+          self[:type].to_human
         end
 
         # Get human readable content, from {#type}
         # @return [String]
         def human_content
           case type
-          when TYPE_IPV4_ADDR, TYPE_IPV4_ADDR
+          when TYPES['IPV4_ADDR'], TYPES['IPV4_ADDR']
             IPAddr.ntop(content)
-          when TYPE_DER_ASN1_DN, TYPE_DER_ASN1_GN
+          when TYPES['DER_ASN1_DN'], TYPES['DER_ASN1_GN']
             OpenSSL::X509::Name.new(content).to_s
           else
             content.inspect
           end
         end
-
-        # @return [String]
-        def inspect
-          str = Inspect.dashed_line(self.class, 2)
-          fields.each do |attr|
-            case attr
-            when :body
-              next
-            when :u32
-              str << Inspect.shift_level(2)
-              str << Inspect::FMT_ATTR % ['Int8', :type, human_type]
-              str << Inspect.inspect_attribute(:reserved, self.reserved, 2)
-            else
-              str << Inspect.inspect_attribute(attr, self[attr], 2)
-            end
-          end
-          str
-        end
       end
 
       # This class handles Identification - Responder payloads, denoted IDr.

data/lib/packetgen/header/ike/ts.rb

@@ -225,14 +225,10 @@ module PacketGen
         #   8-bit Number of TSs
         #   @return [Integer]
         define_field_before :body, :num_ts, Types::Int8
-        # @!attribute rsv1
-        #   First 8-bit RESERVED field
+        # @!attribute rsv
+        #   24-bit RESERVED field
         #   @return [Integer]
-        define_field_before :body, :rsv1, Types::Int8
-        # @!attribute rsv2
-        #   Last 16-bit RESERVED field
-        #   @return [Integer]
-        define_field_before :body, :rsv2, Types::Int16
+        define_field_before :body, :rsv, Types::Int24
 
         # @!attribute traffic_selectors
         #  Set of {TrafficSelector}
@@ -259,24 +255,6 @@ module PacketGen
           selectors.each { |p| p.calc_length }
           super
         end
-
-        # @return [String]
-        def inspect
-          str = Inspect.dashed_line(self.class, 2)
-          fields.each do |attr|
-            case attr
-            when :body, :rsv2
-              next
-            when :rsv1
-              str << Inspect.shift_level(2)
-              str << Inspect::FMT_ATTR % ['Int24', 'reserved',
-                                          (rsv1 << 16) | rsv2 ]
-            else
-              str << Inspect.inspect_attribute(attr, self[attr], 2)
-            end
-          end
-          str
-        end
       end
 
       class TSr < TSi

data/lib/packetgen/header/ip.rb

@@ -201,6 +201,7 @@ module PacketGen
         sock = Socket.new(Socket::AF_INET, Socket::SOCK_RAW, Socket::IPPROTO_RAW)
         sockaddrin = Socket.sockaddr_in(0, dst)
         sock.send to_s, 0, sockaddrin
+        sock.close
       end
 
       # @return [String]

data/lib/packetgen/header/ipv6.rb

@@ -196,6 +196,7 @@ module PacketGen
         pkt_info = Socket::AncillaryData.ipv6_pktinfo(Addrinfo.ip(src), ifaddr.ifindex)
 
         sock.sendmsg body.to_s, 0, sockaddrin, hop_limit, tc, pkt_info
+        sock.close
       end
 
       # @return [String]

data/lib/packetgen/inspect.rb

@@ -49,8 +49,10 @@ module PacketGen
     # @return [String]
     def self.inspect_attribute(attr, value, level=1)
       str = shift_level(level)
-      val = if value.is_a?(Types::Int) or value.is_a?(Integer)
-              int_dec_hex(value, value.to_s.size * 2)
+      val = if value.is_a?(Types::Enum)
+              "%-10s (0x%0#{value.sz * 2}x)" % [value.to_human, value.to_i]
+            elsif value.is_a?(Types::Int) or value.is_a?(Integer)
+              int_dec_hex(value, value.sz * 2)
             elsif value.respond_to? :to_human
               value.to_human
             else

data/lib/packetgen/packet.rb

@@ -209,11 +209,23 @@ module PacketGen
 
     # send packet on wire. Use first header +#to_w+ method.
     # @param [String] iface interface name. Default to first non-loopback interface
+    # @param [Boolean] calc call {#calc} on packet before sending it
+    # @param [Integer] number number of times to send the packets
+    # @param [Integer,Float] interval time, in seconds, between sending 2 packets
     # @return [void]
-    def to_w(iface=nil)
+    # @since 2.1.4 add `calc`, `number` and `interval` parameters
+    def to_w(iface=nil, calc: false, number: 1, interval: 1)
       iface ||= PacketGen.default_iface
       if @headers.first.respond_to? :to_w
-        @headers.first.to_w(iface)
+        self.calc if calc
+        if number == 1
+          @headers.first.to_w(iface)
+        else
+          number.times do
+            @headers.first.to_w(iface)
+            sleep interval
+          end
+        end
       else
         type = @headers.first.protocol_name
         raise WireError, "don't known how to send a #{type} packet on wire"
@@ -360,8 +372,8 @@ module PacketGen
       header.packet = self
       @headers << header unless previous_header
       unless respond_to? header.method_name
-        self.class.class_eval "def #{header.method_name}(arg=nil);" \
-                              "header(#{header.class}, arg); end"
+        self.instance_eval "def #{header.method_name}(arg=nil);" \
+                           "header(#{header.class}, arg); end"
       end
     end
 

data/lib/packetgen/pcapng/file.rb

@@ -151,9 +151,6 @@ module PacketGen
       end
 
       # Translates a {File} into an array of packets.
-      # Note that this strips out timestamps -- if you'd like to retain
-      # timestamps and other pcapng file information, you will want to
-      # use {#read} instead.
       # @param [Hash] options
       # @option options [String] :filename if given, object is cleared and filename
       #   is analyzed before generating array. Else, array is generated from +self+

data/lib/packetgen/types/fields.rb

@@ -293,34 +293,35 @@ module PacketGen
         @optional_fields = {}
 
         self.class.class_eval { @field_defs }.each do |field, ary|
-          default = ary[1].is_a?(Proc) ? ary[1].call : ary[1]
-          @fields[field] = if ary[2]
-                             ary[2].call(self)
-                           elsif ary[4]
-                             ary[0].new(ary[4])
-                           elsif !ary[5].empty?
-                             ary[0].new(ary[5])
+          type, default, builder, optional, enum, field_options = ary
+          default = default.call if default.is_a?(Proc)
+          @fields[field] = if builder
+                             builder.call(self)
+                           elsif enum
+                             type.new(enum)
+                           elsif !field_options.empty?
+                             type.new(field_options)
                            else
-                             ary[0].new
+                             type.new
                            end
 
           value = options[field] || default
-          if ary[0] < Types::Enum
+          if type < Types::Enum
             case value
             when ::String
               @fields[field].value = value
             else
               @fields[field].read(value)
             end
-          elsif ary[0] < Types::Int
+          elsif type < Types::Int
             @fields[field].read(value)
-          elsif ary[0] <= Types::String
+          elsif type <= Types::String
             @fields[field].read(value)
           else
             @fields[field].from_human(value) if @fields[field].respond_to? :from_human
           end
 
-          @optional_fields[field] = ary[3] if ary[3]
+          @optional_fields[field] = optional if optional
         end
         self.class.class_eval { @bit_fields }.each do |bit_field|
           self.send "#{bit_field}=", options[bit_field] if options[bit_field]
@@ -350,7 +351,7 @@ module PacketGen
 
       # Get all optional field name
       def optional_fields
-        fields.select { |f| is_optional?(f) }
+        @optional_fields.keys
       end
 
       # Say if this field is optional

data/lib/packetgen/types/int.rb

@@ -117,6 +117,67 @@ module PacketGen
       end
     end
 
+    # 3-byte integer
+    # @author Sylvain Daubert
+    # @since 2.1.4
+    class Int24 < Int
+      # @param [Integer,nil] value
+      # @param [:big, :little] endian
+      def initialize(value=nil, endian=:big)
+        super(value, endian, 3)
+      end
+
+      # Read an 3-byte Int from a binary string or an integer
+      # @param [Integer, String] value
+      # @return [self]
+      def read(value)
+        return self if value.nil?
+        @value =  if value.is_a?(Integer)
+                    value.to_i
+                  else
+                    up8 = down16 = 0
+                    if @endian == :big
+                      up8, down16 = value.to_s.unpack('Cn')
+                    else
+                      down16, up8 = value.to_s.unpack('vC')
+                    end
+                    (up8 << 16) | down16
+                  end
+        self
+      end
+
+      # @return [::String]
+      def to_s
+        up8 = to_i >> 16
+        down16 = to_i & 0xffff
+        if @endian == :little
+          [up8, down16].pack('Cn')
+        else
+          [down16, up8].pack('vC')
+        end
+      end
+    end
+
+    # big endian 3-byte integer
+    # @author Sylvain Daubert
+    # @since 2.1.4
+    class Int24be < Int24
+      undef endian=
+    end
+
+    # little endian 3-byte integer
+    # @author Sylvain Daubert
+    # @since 2.1.4
+    class Int24le < Int24
+      # @param [Integer,nil] value
+      undef endian=
+
+      # @param [Integer, nil] value
+      def initialize(value=nil)
+        super(value, :little)
+      end
+    end
+
     # 4-byte integer
     # @author Sylvain Daubert
     class Int32 < Int

data/lib/packetgen/version.rb

@@ -8,5 +8,5 @@
 # @author Sylvain Daubert
 module PacketGen
   # PacketGen version
-  VERSION = '2.1.3'
+  VERSION = '2.1.4'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: packetgen
 version: !ruby/object:Gem::Version
-  version: 2.1.3
+  version: 2.1.4
 platform: ruby
 authors:
 - Sylvain Daubert
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-01 00:00:00.000000000 Z
+date: 2017-11-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pcaprub
@@ -167,6 +167,11 @@ files:
 - lib/packetgen/header/dot11/sub_mngt.rb
 - lib/packetgen/header/dot1q.rb
 - lib/packetgen/header/dot1x.rb
+- lib/packetgen/header/eap.rb
+- lib/packetgen/header/eap/fast.rb
+- lib/packetgen/header/eap/md5.rb
+- lib/packetgen/header/eap/tls.rb
+- lib/packetgen/header/eap/ttls.rb
 - lib/packetgen/header/esp.rb
 - lib/packetgen/header/eth.rb
 - lib/packetgen/header/gre.rb