packetgen 3.2.0 → 3.2.2

data/lib/packetgen/types/array.rb

@@ -62,7 +62,7 @@ module PacketGen
       HUMAN_SEPARATOR = ','
 
       # rubocop:disable Naming/AccessorMethodName
-      class <<self
+      class << self
         # Get class set with {.set_of}.
         # @return [Class]
         # @since 3.0.0
@@ -154,20 +154,16 @@ module PacketGen
         self
       end
 
-      # Populate object from a string
-      # @param [String] str
+      # Populate object from a string or from an array of hashes
+      # @param [String, Array<Hash>] data
       # @return [self]
-      def read(str)
+      def read(data)
         clear
-        return self if str.nil?
-        return self if @counter&.to_i&.zero?
-
-        str = read_with_length_from(str)
-        until str.empty?
-          obj = create_object_from_str(str)
-          @array << obj
-          str.slice!(0, obj.sz)
-          break if @counter && self.size == @counter.to_i
+        case data
+        when ::Array
+          read_from_array(data)
+        else
+          read_from_string(data)
         end
         self
       end
@@ -198,6 +194,28 @@ module PacketGen
 
       private
 
+      # rubocop:disable Metrics/CyclomaticComplexity
+
+      def read_from_string(str)
+        return self if str.nil? || @counter&.to_i&.zero?
+
+        str = read_with_length_from(str)
+        until str.empty? || (@counter && self.size == @counter.to_i)
+          obj = create_object_from_str(str)
+          @array << obj
+          str.slice!(0, obj.sz)
+        end
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+
+      def read_from_array(ary)
+        return self if ary.empty?
+
+        ary.each do |hsh|
+          self << hsh
+        end
+      end
+
       def record_from_hash(hsh)
         obj_klass = self.class.set_of_klass
         raise NotImplementedError, 'class should define #record_from_hash or declare type of elements in set with .set_of' unless obj_klass
@@ -228,18 +246,22 @@ module PacketGen
     class ArrayOfInt8 < Array
       set_of Int8
     end
+
     # Specialized array to handle serie of {Int16}.
     class ArrayOfInt16 < Array
       set_of Int16
     end
+
     # Specialized array to handle serie of {Int16le}.
     class ArrayOfInt16le < Array
       set_of Int16le
     end
+
     # Specialized array to handle serie of {Int32}.
     class ArrayOfInt32 < Types::Array
       set_of Types::Int32
     end
+
     # Specialized array to handle serie of {Int32le}.
     class ArrayOfInt32le < Types::Array
       set_of Types::Int32le

data/lib/packetgen/types/fields.rb

@@ -115,7 +115,7 @@ module PacketGen
       # @private bit field definitions
       @bit_fields = {}
 
-      class <<self
+      class << self
         # Get field definitions for this class.
         # @return [Hash]
         # @since 3.1.0
@@ -282,7 +282,7 @@ module PacketGen
           type = field_defs[attr].type
           raise TypeError, "#{attr} is not a PacketGen::Types::Int" unless type < Types::Int
 
-          total_size = type.new.width * 8
+          total_size = type.new.nbits
           idx = total_size - 1
 
           until args.empty?
@@ -358,15 +358,15 @@ module PacketGen
           clear_mask = compute_clear_mask(total_size, field_mask)
 
           class_eval <<-METHODS
-          def #{name}?
-            val = (self[:#{attr}].to_i & #{field_mask}) >> #{shift}
-            val != 0
-          end
-          def #{name}=(v)
-            val = v ? 1 : 0
-            self[:#{attr}].value = self[:#{attr}].to_i & #{clear_mask}
-            self[:#{attr}].value |= val << #{shift}
-          end
+          def #{name}?                                                  # def bit?
+            val = (self[:#{attr}].to_i & #{field_mask}) >> #{shift}     #   val = (self[:attr}].to_i & 1}) >> 1
+            val != 0                                                    #   val != 0
+          end                                                           # end
+          def #{name}=(v)                                               # def bit=(v)
+            val = v ? 1 : 0                                             #   val = v ? 1 : 0
+            self[:#{attr}].value = self[:#{attr}].to_i & #{clear_mask}  #   self[:attr].value = self[:attr].to_i & 0xfffd
+            self[:#{attr}].value |= val << #{shift}                     #   self[:attr].value |= val << 1
+          end                                                           # end
           METHODS
         end
 
@@ -375,13 +375,13 @@ module PacketGen
           clear_mask = compute_clear_mask(total_size, field_mask)
 
           class_eval <<-METHODS
-          def #{name}
-            (self[:#{attr}].to_i & #{field_mask}) >> #{shift}
-          end
-          def #{name}=(v)
-            self[:#{attr}].value = self[:#{attr}].to_i & #{clear_mask}
-            self[:#{attr}].value |= (v & #{2**size - 1}) << #{shift}
-          end
+          def #{name}                                                   # def multibit
+            (self[:#{attr}].to_i & #{field_mask}) >> #{shift}           #   (self[:attr].to_i & 6) >> 1
+          end                                                           # end
+          def #{name}=(v)                                               # def multibit=(v)
+            self[:#{attr}].value = self[:#{attr}].to_i & #{clear_mask}  #   self[:attr].value = self[:attr].to_i & 0xfff9
+            self[:#{attr}].value |= (v & #{2**size - 1}) << #{shift}    #   self[:attr].value |= (v & 3) << 1
+          end                                                           # end
           METHODS
         end
 
@@ -523,7 +523,7 @@ module PacketGen
       # Return object as a hash
       # @return [Hash] keys: attributes, values: attribute values
       def to_h
-        Hash[fields.map { |f| [f, @fields[f].to_human] }]
+        fields.map { |f| [f, @fields[f].to_human] }.to_h
       end
 
       # Get offset of given field in {Fields} structure.

data/lib/packetgen/types/int.rb

@@ -89,6 +89,13 @@ module PacketGen
         format_str % [to_i.to_s, to_i]
       end
 
+      # Return the number of bits used to encode this Int
+      # @return [Integer]
+      # @since 3.2.1
+      def nbits
+        width * 8
+      end
+
       private
 
       def format_str

data/lib/packetgen/types/oui.rb

@@ -32,7 +32,7 @@ module PacketGen
       def from_human(str)
         return self if str.nil?
 
-        bytes = str.split(/:/)
+        bytes = str.split(':')
         raise ArgumentError, 'not a OUI' unless bytes.size == 3
 
         self[:b2].read(bytes[0].to_i(16))

data/lib/packetgen/types/tlv.rb

@@ -56,12 +56,8 @@ module PacketGen
       def initialize(options={})
         Deprecation.deprecated_class(self.class, AbstractTLV)
         super
-        self[:type] = options[:t].new(self.type) if options[:t]
-        self[:length] = options[:l].new(self.length) if options[:l]
-        self[:value] = options[:v].new if options[:v]
-        self.type = options[:type] if options[:type]
-        self.value = options[:value] if options[:value]
-        self.length = options[:length] if options[:length]
+        initialize_types(options)
+        initialize_values(options)
       end
 
       # Populate object from a binary string
@@ -137,9 +133,9 @@ module PacketGen
                      else
                        '%s'
                      end
-        @lenstr ||= "%-#{(2**(self[:length].width * 8) - 1).to_s.size}u"
-        "#{name} type:#{@typestr} length:#{@lenstr} value:#{value.inspect}" % [human_type,
-                                                                               length]
+        lenstr = "%-#{(2**self[:length].nbits - 1).to_s.size}u"
+        "#{name} type:#{@typestr} length:#{lenstr} value:#{value.inspect}" % [human_type,
+                                                                              length]
       end
 
       private
@@ -147,6 +143,18 @@ module PacketGen
       def human_types?
         self.class.const_defined? :TYPES
       end
+
+      def initialize_types(options)
+        self[:type] = options[:t].new(self.type) if options[:t]
+        self[:length] = options[:l].new(self.length) if options[:l]
+        self[:value] = options[:v].new if options[:v]
+      end
+
+      def initialize_values(options)
+        self.type = options[:type] if options[:type]
+        self.value = options[:value] if options[:value]
+        self.length = options[:length] if options[:length]
+      end
     end
   end
 end

data/lib/packetgen/unknown_packet.rb

@@ -61,7 +61,8 @@ module PacketGen
 
     # @return [String]
     def inspect
-      # TODO
+      str = Inspect.dashed_line(self.class)
+      str << Inspect.inspect_body(body)
     end
 
     # equality if {#to_s} is equal
@@ -74,7 +75,7 @@ module PacketGen
     # @return [Boolean]
     def ===(other)
       case other
-      when UnknwonPacket
+      when UnknownPacket
         self == other
       else
         false

data/lib/packetgen/utils.rb

@@ -16,21 +16,62 @@ module PacketGen
   # @author Sylvain Daubert
   # @since 2.1.3
   module Utils
+    # @private
+    ARP_FILTER = 'arp src %<ipaddr>s and ether dst %<hwaddr>s'
+    # @private
+    MITM_FILTER = '((ip src %<target1>s and not ip dst %<local_ip>s) or' \
+                  ' (ip src %<target2>s and not ip dst %<local_ip>s) or' \
+                  ' (ip dst %<target1>s and not ip src %<local_ip>s) or' \
+                  ' (ip dst %<target2>s and not ip src %<local_ip>s))' \
+                  ' and ether dst %<local_mac>s'
+
+    # @private
+    ARP_PATH = '/usr/sbin/arp'
+    # @private
+    IP_PATH = '/usr/bin/ip'
+    # @private
+    ARP_LINE_RE = /\((\d+\.\d+\.\d+\.\d+)\) at (([a-fA-F0-9]{2}:){5}[a-fA-F0-9]{2})(?: \[ether\])? on (\w+)/.freeze
+    # @private
+    IP_LINE_RE = /^(\d+\.\d+\.\d+\.\d+) dev (\w+) lladdr (([a-fA-F0-9]{2}:){5}[a-fA-F0-9]{2})/.freeze
+
     # Get local ARP cache
     # @return [Hash] key: IP address, value: array containing MAC address and
     #    interface name
     def self.arp_cache
-      raw_cache = `/usr/sbin/arp -an`
+      return self.cache_from_arp_command if File.exist?(ARP_PATH)
+      return self.cache_from_ip_command if File.exist?(IP_PATH)
+
+      {}
+    end
+
+    # @private
+    def self.cache_from_arp_command(raw_cache=nil)
+      raw_cache ||= `#{ARP_PATH} -an`
 
       cache = {}
       raw_cache.split("\n").each do |line|
-        match = line.match(/\((\d+\.\d+\.\d+\.\d+)\) at (([a-fA-F0-9]{2}:){5}[a-fA-F0-9]{2})(?: \[ether\])? on (\w+)/)
+        match = line.match(ARP_LINE_RE)
         cache[match[1]] = [match[2], match[4]] if match
       end
 
       cache
     end
 
+    # @private
+    def self.cache_from_ip_command(raw_cache=nil)
+      raw_cache ||= `#{IP_PATH} neigh`
+
+      cache = {}
+      raw_cache.split("\n").each do |line|
+        match = line.match(IP_LINE_RE)
+        cache[match[1]] = [match[3], match[2]] if match
+      end
+
+      cache
+    end
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize
+
     # Get MAC address from an IP address, or nil if this IP address is unknown
     # on local network.
     # @param [String] ipaddr dotted-octet IP address
@@ -40,7 +81,7 @@ module PacketGen
     # @option options [Boolean] :no_cache if +true+, do not query local ARP
     #   cache and always send an ARP request on wire. Default to +false+
     # @option options [Integer] :timeout timeout in seconds before stopping
-    #   request. Default to 2.
+    #   request. Default to 1.
     # @return [String,nil]
     # @raise [RuntimeError] user don't have permission to capture packets on network device.
     def self.arp(ipaddr, options={})
@@ -57,10 +98,10 @@ module PacketGen
                                   spa: Config.instance.ipaddr(iface),
                                   tpa: ipaddr)
 
-      capture = Capture.new(iface: iface, timeout: timeout, max: 1,
-                            filter: "arp src #{ipaddr} and ether dst #{my_hwaddr}")
+      capture = Capture.new(iface: iface, timeout: timeout, max: 1, filter: ARP_FILTER % { ipaddr: ipaddr, hwaddr: my_hwaddr })
       cap_thread = Thread.new { capture.start }
 
+      sleep 0.1
       arp_pkt.to_w(iface)
       cap_thread.join
 
@@ -70,6 +111,7 @@ module PacketGen
         break pkt.arp.sha.to_s if pkt.arp.spa.to_s == ipaddr
       end
     end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize
 
     # Do ARP spoofing on given IP address. Call to this method blocks.
     # @note This method is provided for test purpose.
@@ -122,39 +164,40 @@ module PacketGen
     #   end
     # @since 2.2.0
     # @raise [RuntimeError] user don't have permission to capture packets on network device.
-    def self.mitm(target1, target2, options={})
+    def self.mitm(target1, target2, options={}, &block)
       options = { iface: PacketGen.default_iface }.merge(options)
 
-      mac1 = arp(target1)
-      mac2 = arp(target2)
-
       spoofer = Utils::ARPSpoofer.new(options)
       spoofer.add target1, target2, options
       spoofer.add target2, target1, options
 
-      my_mac = Config.instance.hwaddr(options[:iface])
-      my_ip = Config.instance.ipaddr(options[:iface])
+      cfg = Config.instance
+      my_mac = cfg.hwaddr(options[:iface])
       capture = Capture.new(iface: options[:iface],
-                            filter: "((ip src #{target1} and not ip dst #{my_ip}) or" \
-                                    " (ip src #{target2} and not ip dst #{my_ip}) or" \
-                                    " (ip dst #{target1} and not ip src #{my_ip}) or" \
-                                    " (ip dst #{target2} and not ip src #{my_ip}))" \
-                                    " and ether dst #{my_mac}")
+                            filter: MITM_FILTER % { target1: target1, target2: target2, local_ip: cfg.ipaddr(options[:iface]), local_mac: my_mac })
 
       spoofer.start_all
+      mitm_core(capture, target1, target2, my_mac, &block)
+      spoofer.stop_all
+    end
+
+    # @private
+    def self.mitm_core(capture, target1, target2, my_mac)
+      mac1 = arp(target1)
+      mac2 = arp(target2)
+
       capture.start do |pkt|
         modified_pkt = yield pkt
         iph = modified_pkt.ip
         l2 = modified_pkt.is?('Dot11') ? modified_pkt.dot11 : modified_pkt.eth
 
-        if (iph.src == target1) || (iph.dst == target2)
-          l2.dst = mac2
-        elsif (iph.src == target2) || (iph.dst == target1)
-          l2.dst = mac1
-        else
-          next
-        end
-        modified_pkt.to_w(options[:iface])
+        l2.src = my_mac
+        l2.dst = if (iph.src == target1) || (iph.dst == target2)
+                   mac2
+                 else # (iph.src == target2) || (iph.dst == target1)
+                   mac1
+                 end
+        modified_pkt.to_w(capture.iface)
       end
     end
   end

data/lib/packetgen/version.rb

@@ -10,5 +10,5 @@
 # @author Sylvain Daubert
 module PacketGen
   # PacketGen version
-  VERSION = '3.2.0'
+  VERSION = '3.2.2'
 end

data/lib/packetgen.rb

@@ -39,9 +39,9 @@ module PacketGen
 
     def message
       "#{prev_hdr.class} knowns no layer association with #{hdr.protocol_name}. " \
-          "Try #{prev_hdr.class}.bind_layer(#{hdr.class}, " \
-          "#{prev_hdr.method_name}_proto_field: " \
-          "<value_for_#{hdr.method_name}>)"
+        "Try #{prev_hdr.class}.bind_layer(#{hdr.class}, " \
+        "#{prev_hdr.method_name}_proto_field: " \
+        "<value_for_#{hdr.method_name}>)"
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: packetgen
 version: !ruby/object:Gem::Version
-  version: 3.2.0
+  version: 3.2.2
 platform: ruby
 authors:
 - Sylvain Daubert
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-04-20 00:00:00.000000000 Z
+date: 2022-12-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: interfacez
@@ -260,7 +260,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.4.0
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="