packetgen 3.1.6 → 3.2.1

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,6 +154,8 @@ module PacketGen
         self
       end
 
+      # rubocop:disable Metrics/CyclomaticComplexity
+
       # Populate object from a string
       # @param [String] str
       # @return [self]
@@ -171,6 +173,7 @@ module PacketGen
         end
         self
       end
+      # rubocop:enable Metrics/CyclomaticComplexity
 
       # Get size in bytes
       # @return [Integer]
@@ -228,18 +231,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/cstring.rb

@@ -17,8 +17,9 @@ module PacketGen
       extend Forwardable
       include Fieldable
 
-      def_delegators :@string, :[], :length, :size, :inspect, :==, :<<,
-                     :unpack, :force_encoding, :encoding, :index, :empty?
+      def_delegators :@string, :[], :length, :size, :inspect, :==,
+                     :unpack, :force_encoding, :encoding, :index, :empty?,
+                     :encode, :slice, :slice!
 
       # @return [::String]
       attr_reader :string
@@ -28,7 +29,7 @@ module PacketGen
       # @param [Hash] options
       # @option options [Integer] :static_length set a static length for this string
       def initialize(options={})
-        register_internal_string ''
+        register_internal_string(+'')
         @static_length = options[:static_length]
       end
 
@@ -37,9 +38,8 @@ module PacketGen
       def read(str)
         s = str.to_s
         s = s[0, static_length] if static_length?
-        idx = s.index(0.chr)
-        s = s[0, idx] unless idx.nil?
         register_internal_string s
+        remove_null_character
         self
       end
 
@@ -55,6 +55,15 @@ module PacketGen
         PacketGen.force_binary(s)
       end
 
+      # Append the given string to CString
+      # @param [#to_s] str
+      # @return [self]
+      def <<(str)
+        @string << str.to_s
+        remove_null_character
+        self
+      end
+
       # @return [Integer]
       def sz
         if static_length?
@@ -80,8 +89,7 @@ module PacketGen
 
       # @return [String]
       def to_human
-        idx = self.index(+"\x00".encode(self.encoding)) || self.sz
-        self[0, idx]
+        string
       end
 
       private
@@ -90,6 +98,11 @@ module PacketGen
         @string = str
         PacketGen.force_binary(@string)
       end
+
+      def remove_null_character
+        idx = string.index(0.chr)
+        register_internal_string(string[0, idx]) unless idx.nil?
+      end
     end
   end
 end

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/string.rb

@@ -18,8 +18,9 @@ module PacketGen
       include Fieldable
       include LengthFrom
 
-      def_delegators :@string, :[], :to_s, :length, :size, :inspect, :==, :<<,
-                     :unpack, :force_encoding, :encoding, :index, :empty?
+      def_delegators :@string, :[], :to_s, :length, :size, :inspect, :==,
+                     :unpack, :force_encoding, :encoding, :index, :empty?,
+                     :encode, :slice, :slice!, :[]=
 
       # @return [::String]
       attr_reader :string
@@ -31,11 +32,15 @@ module PacketGen
       #   takes length when reading
       # @option options [Integer] :static_length set a static length for this string
       def initialize(options={})
-        register_internal_string ''
+        register_internal_string(+'')
         initialize_length_from(options)
         @static_length = options[:static_length]
       end
 
+      def initialize_copy(_orig)
+        @string = @string.dup
+      end
+
       # @param [::String] str
       # @return [String] self
       def read(str)
@@ -68,6 +73,14 @@ module PacketGen
         inspect
       end
 
+      # Append the given string to String
+      # @param [#to_s] str
+      # @return [self]
+      def <<(str)
+        @string << str.to_s
+        self
+      end
+
       alias sz length
       alias to_human to_s
       alias from_human read

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

@@ -0,0 +1,84 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+# 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
+  # Unknown packet, minimaly mimicking a {Packet}.
+  #
+  # An unknown packet is generated when capturing packets, and a packet cannot
+  # be parsed.
+  # @since 3.2.0
+  class UnknownPacket
+    # List of headers. Always empty
+    # @return [Array]
+    attr_reader :headers
+
+    def initialize
+      @headers = [].freeze
+      @binary_str = PacketGen.force_binary('')
+    end
+
+    # Unknown packet, so unknown protocol.
+    # @return [false]
+    def is?(_protocol)
+      false
+    end
+
+    # Get packet body
+    # @return [Types]
+    def body
+      @binary_str
+    end
+    alias to_s body
+
+    # Set packet body
+    # @param [String] str
+    # @return [void]
+    def body=(str)
+      @binary_str = PacketGen.force_binary(str)
+    end
+
+    # Write packet to a PCapNG file on disk.
+    # @param [String] filename
+    # @return [Array] see return from {PcapNG::File#to_file}
+    # @see File
+    def to_f(filename)
+      PcapNG::File.new.read_array([self]).to_f(filename)
+    end
+    alias write to_f
+
+    # Read binary string
+    # @param [String] binary_string
+    # @return [self]
+    def parse(binary_str, _first_header: nil)
+      @binary_str = PacketGen.force_binary(binary_str)
+      self
+    end
+
+    # @return [String]
+    def inspect
+      # TODO
+    end
+
+    # equality if {#to_s} is equal
+    # @return [Boolean]
+    def ==(other)
+      to_s == other.to_s
+    end
+
+    # True only if +other+ is an {UnknownPacket} and +other == self+
+    # @return [Boolean]
+    def ===(other)
+      case other
+      when UnknwonPacket
+        self == other
+      else
+        false
+      end
+    end
+  end
+end

data/lib/packetgen/utils.rb

@@ -16,14 +16,31 @@ 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'
+
     # Get local ARP cache
     # @return [Hash] key: IP address, value: array containing MAC address and
     #    interface name
     def self.arp_cache
+      return self.cache_from_arp_command if File.exist?('/usr/sbin/arp')
+      return self.cache_from_ip_command if File.exist?('/usr/bin/ip')
+
+      {}
+    end
+
+    # @private
+    def self.cache_from_arp_command
       raw_cache = `/usr/sbin/arp -an`
 
       cache = {}
-      raw_cache.split(/\n/).each do |line|
+      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+)/)
         cache[match[1]] = [match[2], match[4]] if match
       end
@@ -31,6 +48,21 @@ module PacketGen
       cache
     end
 
+    # @private
+    def self.cache_from_ip_command
+      raw_cache = `ip neigh`
+
+      cache = {}
+      raw_cache.split("\n").each do |line|
+        match = line.match(/^(\d+\.\d+\.\d+\.\d+) dev (\w+) lladdr (([a-fA-F0-9]{2}:){5}[a-fA-F0-9]{2})/)
+        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,13 +72,13 @@ 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={})
       unless options[:no_cache]
         local_cache = self.arp_cache
-        return local_cache[ipaddr].first if local_cache.key? ipaddr
+        return local_cache[ipaddr].first if local_cache.key?(ipaddr)
       end
 
       iface = options[:iface] || PacketGen.default_iface
@@ -54,14 +86,13 @@ module PacketGen
       my_hwaddr = Config.instance.hwaddr(iface)
       arp_pkt = Packet.gen('Eth', dst: 'ff:ff:ff:ff:ff:ff', src: my_hwaddr)
                       .add('ARP', sha: Config.instance.hwaddr(iface),
-                           spa: Config.instance.ipaddr(iface), tpa: ipaddr)
+                                  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}")
-      cap_thread = Thread.new do
-        capture.start
-      end
+      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
 
@@ -71,6 +102,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.
@@ -126,36 +158,37 @@ module PacketGen
     def self.mitm(target1, target2, options={})
       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, &proc)
+      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.1.6'
+  VERSION = '3.2.1'
 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
 
@@ -95,7 +95,15 @@ module PacketGen
   # Get default network interface (ie. first non-loopback declared interface)
   # @return [String]
   def self.default_iface
-    Interfacez.default
+    return @default_iface if defined? @default_iface
+
+    @default_iface = Interfacez.raw_interface_addresses.each do |iface|
+      next unless iface.broadaddr
+      next unless Interfacez.ipv4_address_of(iface.name)
+      next unless Interfacez.ipv6_address_of(iface.name)
+
+      break iface.name
+    end
   end
 
   # Get loopback network interface
@@ -126,6 +134,7 @@ require 'packetgen/types'
 require 'packetgen/pcapng'
 require 'packetgen/pcap'
 require 'packetgen/packet'
+require 'packetgen/unknown_packet'
 require 'packetgen/capture'
 require 'packetgen/inject'
 require 'packetgen/proto'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: packetgen
 version: !ruby/object:Gem::Version
-  version: 3.1.6
+  version: 3.2.1
 platform: ruby
 authors:
 - Sylvain Daubert
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-12-04 00:00:00.000000000 Z
+date: 2021-12-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: interfacez
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.13.0
+        version: 0.12.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.13.0
+        version: 0.12.0
 - !ruby/object:Gem::Dependency
   name: rasn1
   requirement: !ruby/object:Gem::Requirement
@@ -233,6 +233,7 @@ files:
 - lib/packetgen/types/oui.rb
 - lib/packetgen/types/string.rb
 - lib/packetgen/types/tlv.rb
+- lib/packetgen/unknown_packet.rb
 - lib/packetgen/utils.rb
 - lib/packetgen/utils/arp_spoofer.rb
 - lib/packetgen/version.rb
@@ -259,15 +260,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6.2
+rubygems_version: 3.2.5
 signing_key: 
 specification_version: 4
 summary: Network packet generator and dissector