packetgen 3.1.6 → 3.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d8959dbe60df80490d1ac31eaf40b05a206860bf6bed306997a66ca9c77dfb0b
-  data.tar.gz: 4615a1084f86e4b0ab216b3766dbde7d1b0b2b1e3c2e6b0d2e1a63aba1ff7bd6
+  metadata.gz: 79dc573da10eb15bbd9f38e0c84ecdf9a92d076980628635d1b9e240e3ca2210
+  data.tar.gz: 0ae2bafa08e5a4a0b176276a141b8c8326265873bb20d86a75e07bb7018275ac
 SHA512:
-  metadata.gz: 636f0dcea926b57cb7ec7a824744dfbcab9c6ddbb7f6749d8fda8f63fec410d20dcf199f362ae63878104725e94c7075d17f94b3f0dc8458b3d975e9521343da
-  data.tar.gz: 50e679400b1f882fbe2d3bc9e3ba5e01bb24dbe4a83b3372b999cbe0d1565703a7fc6afc08c437900e23b92c549c46ad422e3e76140254034c8840ba3a8ecb2e
+  metadata.gz: 7c405a57b79c4a9bf0d9032b34d7381b33e8c0705c554023f6a8131c19c48fb0118201d94da62e4f74b9d53551cdbcd434cb6363f27a84e5c3e8459cb28d613b
+  data.tar.gz: 835969235415864e05b227dd5f0fb48535e3f414e60852cf788d6d90bf29be9a3a8dcf9b636ce8d500d29720753246e11459da925fea3f72f6cb8e11291565b8

data/README.md

@@ -1,7 +1,6 @@
 
 [![Gem Version](https://badge.fury.io/rb/packetgen.svg)](https://badge.fury.io/rb/packetgen)
-[![Build Status](https://travis-ci.org/sdaubert/packetgen.svg?branch=master)](https://travis-ci.org/sdaubert/packetgen)
-
+[![Action status](https://github.com/sdaubert/packetgen/workflows/ci/badge.svg?branch=master)](https://github.com/sdaubert/packetgen/actions?query=workflow%3Aci)
 # PacketGen
 
 PacketGen provides simple ways to generate, send and capture network packets.

data/bin/pgconsole

@@ -31,7 +31,7 @@ class PgConsole
     define_method m, Utils.method(m).to_proc
   end
 
-  def get_binding
+  def console_binding
     binding
   end
 end
@@ -52,10 +52,10 @@ if use_pry
     }
   ]
   Pry.config.prompt_name = 'pg'
-  PgConsole.new.get_binding.pry
+  PgConsole.new.console_binding.pry
 else
   IRB.setup nil
-  irb = IRB::Irb.new(IRB::WorkSpace.new(PgConsole.new.get_binding))
+  irb = IRB::Irb.new(IRB::WorkSpace.new(PgConsole.new.console_binding))
   IRB.conf[:MAIN_CONTEXT] = irb.context
   irb.context.auto_indent_mode = true
   irb.context.prompt_i = 'pg> '

data/lib/packetgen/capture.rb

@@ -122,7 +122,11 @@ module PacketGen
     def add_packet(data, &block)
       raw_packets << data
       if @parse
-        packet = Packet.parse(data)
+        begin
+          packet = Packet.parse(data)
+        rescue ParseError
+          packet = UnknownPacket.new.parse(data)
+        end
         packets << packet
         block&.call(packet)
       elsif block

data/lib/packetgen/header/arp.rb

@@ -81,15 +81,7 @@ module PacketGen
       # @option options [String] :tha target hardware address
       # @option options [String] :tpa targetr internet address
       def initialize(options={})
-        options[:hrd] ||= options[:htype]
-        options[:pro] ||= options[:ptype]
-        options[:hln] ||= options[:hlen]
-        options[:pln] ||= options[:plen]
-        options[:op]  ||= options[:opcode]
-        options[:sha] ||= options[:src_mac]
-        options[:spa] ||= options[:src_ip]
-        options[:tha] ||= options[:dst_mac]
-        options[:tpa] ||= options[:dst_ip]
+        handle_options(options)
         super
       end
 
@@ -118,16 +110,35 @@ module PacketGen
         case opcode.to_i
         when 1
           self.opcode = 2
-          self.spa, self.tpa = self.tpa, self.spa
-          self.sha, self.tha = self.tha, self.sha
+          invert_addresses
         when 2
           self.opcode = 1
-          self.spa, self.tpa = self.tpa, self.spa
-          self.sha = self.tha
+          invert_addresses
           self[:tha].from_human('00:00:00:00:00:00')
         end
         self
       end
+
+      private
+
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def handle_options(options)
+        options[:hrd] ||= options[:htype]
+        options[:pro] ||= options[:ptype]
+        options[:hln] ||= options[:hlen]
+        options[:pln] ||= options[:plen]
+        options[:op]  ||= options[:opcode]
+        options[:sha] ||= options[:src_mac]
+        options[:spa] ||= options[:src_ip]
+        options[:tha] ||= options[:dst_mac]
+        options[:tpa] ||= options[:dst_ip]
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+      def invert_addresses
+        self.spa, self.tpa = self.tpa, self.spa
+        self.sha, self.tha = self.tha, self.sha
+      end
     end
 
     self.add_class ARP

data/lib/packetgen/header/asn1_base.rb

@@ -19,14 +19,20 @@ module PacketGen
     class ASN1Base < RASN1::Model
       include Headerable
 
-      # Define some methods from given ASN.1 fields to mimic {Base} attributes
-      # @param [Array<Symbol>] attributes
-      # @return [void]
-      def self.define_attributes(*attributes)
-        @attributes = attributes
-        attributes.each do |attr|
-          class_eval "def #{attr}; @elements[:#{attr}].value; end\n" \
-                     "def #{attr}=(v); @elements[:#{attr}].value = v; end"
+      class << self
+        # Define some methods from given ASN.1 fields to mimic {Base} attributes
+        # @param [Array<Symbol>] attributes
+        # @return [void]
+        def define_attributes(*attributes)
+          @attributes = attributes
+          attributes.each do |attr|
+            class_eval "def #{attr}; @elements[:#{attr}].value; end\n" \
+                       "def #{attr}=(v); @elements[:#{attr}].value = v; end"
+          end
+        end
+
+        def known_headers
+          @known_headers ||= {}.freeze
         end
       end
 
@@ -37,7 +43,11 @@ module PacketGen
       # @param [String] str
       # @return [ASN1Base] self
       def read(str)
-        parse(str, ber: true)
+        begin
+          parse(str, ber: true)
+        rescue RASN1::ASN1Error
+          # suppress exception to allow guessing
+        end
         self
       end
 

data/lib/packetgen/header/base.rb

@@ -142,7 +142,7 @@ module PacketGen
         klass.class_eval { @known_headers = {} }
       end
 
-      class <<self
+      class << self
         # @api private
         # Get known headers
         # @return [Hash] keys: header classes, values: hashes

data/lib/packetgen/header/dhcpv6/option.rb

@@ -53,19 +53,17 @@ module PacketGen
           # @param [Hash] options
           # @return [Option]
           def new(options={})
-            if self == Option
-              case options[:type]
-              when Integer
-                klass = Option.subclasses[options[:type]]
-                klass&.new(options)
-              when String
-                if DHCPv6.const_defined?(options[:type])
-                  klass = DHCPv6.const_get(options[:type])
-                  options.delete :type
-                  klass.new(options) if klass < Option
-                end
-              else
-                super
+            return super unless self == Option
+
+            case options[:type]
+            when Integer
+              klass = Option.subclasses[options[:type]]
+              klass&.new(options)
+            when String
+              if DHCPv6.const_defined?(options[:type])
+                klass = DHCPv6.const_get(options[:type])
+                options.delete :type
+                klass.new(options) if klass < Option
               end
             else
               super

data/lib/packetgen/header/dns/opt.rb

@@ -125,8 +125,8 @@ module PacketGen
         # @return [String]
         def to_human
           "#{name} #{human_type} UDPsize:#{udp_size} " \
-          "extRCODE:#{ext_rcode} EDNSversion:#{version} flags:#{human_flags} " \
-          "options:#{options.empty? ? 'none' : options.to_human}"
+            "extRCODE:#{ext_rcode} EDNSversion:#{version} flags:#{human_flags} " \
+            "options:#{options.empty? ? 'none' : options.to_human}"
         end
       end
     end

data/lib/packetgen/header/dns/rr.rb

@@ -50,48 +50,29 @@ module PacketGen
           self[:rdata].read data
         end
 
+        # rubocop:disable Metrics/AbcSize
+
         # Get human readable rdata
         # @return [String]
         def human_rdata
-          str = self[:rdata].inspect
-
-          # Need to mask: mDNS uses leftmost bit as a flag (CACHE FLUSH)
-          if self.rrclass & 0x7fff == CLASSES['IN']
-            case type
-            when TYPES['A'], TYPES['AAAA']
-              str = IPAddr.new_ntoh(self[:rdata]).to_s
-            end
-          end
+          str = human_ip_rdata || self[:rdata].inspect
 
-          name = Name.new
-          name.dns = self[:name].dns
           case type
           when TYPES['NS'], TYPES['PTR'], TYPES['CNAME']
+            name = Name.new
+            name.dns = self[:name].dns
             str = name.read(self[:rdata]).to_human
           when TYPES['SOA']
-            mname = name.read(self[:rdata]).dup
-            rname = name.read(self[:rdata][mname.sz..-1])
-            serial = Types::Int32.new.read(self[:rdata][mname.sz + rname.sz, 4])
-            refresh = Types::Int32.new.read(self[:rdata][mname.sz + rname.sz + 4, 4])
-            retryi = Types::Int32.new.read(self[:rdata][mname.sz + rname.sz + 8, 4])
-            expire = Types::Int32.new.read(self[:rdata][mname.sz + rname.sz + 12, 4])
-            minimum = Types::Int32.new.read(self[:rdata][mname.sz + rname.sz + 16, 4])
-            str = "#{mname.to_human} #{rname.to_human} #{serial.to_i} #{refresh.to_i} " \
-                  "#{retryi.to_i} #{expire.to_i} #{minimum.to_i}"
+            str = human_soa_rdata
           when TYPES['MX']
-            pref = Types::Int16.new.read(self[:rdata][0, 2])
-            exchange = name.read(self[:rdata][2..-1]).to_human
-            str = '%u %s' % [pref.to_i, exchange]
+            str = human_mx_data
           when TYPES['SRV']
-            priority = Types::Int16.new.read(self[:rdata][0, 2])
-            weight = Types::Int16.new.read(self[:rdata][2, 2])
-            port = Types::Int16.new.read(self[:rdata][4, 2])
-            target = name.read(self[:rdata][6, self[:rdata].size]).to_human
-            str = "#{priority.to_i} #{weight.to_i} #{port.to_i} #{target}"
+            str = human_srv_data
           end
 
           str
         end
+        # rubocop:enable Metrics/AbcSize
 
         # Get human readable class
         # @return [String]
@@ -109,6 +90,58 @@ module PacketGen
         def to_human
           "#{human_type} #{human_rrclass} #{name} TTL #{ttl} #{human_rdata}"
         end
+
+        private
+
+        def human_ip_rdata
+          # Need to mask: mDNS uses leftmost bit as a flag (CACHE FLUSH)
+          return unless self.rrclass & 0x7fff == CLASSES['IN']
+
+          case type
+          when TYPES['A'], TYPES['AAAA']
+            IPAddr.new_ntoh(self[:rdata]).to_s
+          end
+        end
+
+        def human_mx_data
+          name = Name.new
+          name.dns = self[:name].dns
+
+          pref = Types::Int16.new.read(self[:rdata][0, 2])
+          exchange = name.read(self[:rdata][2..-1]).to_human
+
+          '%u %s' % [pref.to_i, exchange]
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def human_soa_rdata
+          name = Name.new
+          name.dns = self[:name].dns
+          mname = name.read(self[:rdata]).dup
+          rname = name.read(self[:rdata][mname.sz..-1])
+
+          serial = Types::Int32.new.read(self[:rdata][mname.sz + rname.sz, 4])
+          refresh = Types::Int32.new.read(self[:rdata][mname.sz + rname.sz + 4, 4])
+          retryi = Types::Int32.new.read(self[:rdata][mname.sz + rname.sz + 8, 4])
+          expire = Types::Int32.new.read(self[:rdata][mname.sz + rname.sz + 12, 4])
+          minimum = Types::Int32.new.read(self[:rdata][mname.sz + rname.sz + 16, 4])
+
+          "#{mname.to_human} #{rname.to_human} #{serial.to_i} #{refresh.to_i} " \
+            "#{retryi.to_i} #{expire.to_i} #{minimum.to_i}"
+        end
+
+        def human_srv_data
+          name = Name.new
+          name.dns = self[:name].dns
+
+          priority = Types::Int16.new.read(self[:rdata][0, 2])
+          weight = Types::Int16.new.read(self[:rdata][2, 2])
+          port = Types::Int16.new.read(self[:rdata][4, 2])
+          target = name.read(self[:rdata][6, self[:rdata].size]).to_human
+
+          "#{priority.to_i} #{weight.to_i} #{port.to_i} #{target}"
+        end
+        # rubocop:enable Metrics/AbcSize
       end
     end
   end

data/lib/packetgen/header/dns.rb

@@ -241,18 +241,25 @@ module PacketGen
         super do |attr|
           next unless attr == :u16
 
-          flags = %i[qr aa tc rd ra].select! { |flag| send "#{flag}?" }
-                                    .map(&:to_s).join(',')
-          str = Inspect.shift_level
-          str << Inspect::FMT_ATTR % ['Flags', 'flags', flags]
-          opcode = '%-16s (%u)' % [OPCODES.key(self.opcode), self.opcode]
+          str = inspect_flags
+
           str << Inspect.shift_level
+          opcode = '%-16s (%u)' % [OPCODES.key(self.opcode), self.opcode]
           str << Inspect::FMT_ATTR % ['Integer', 'opcode', opcode]
-          rcode = '%-16s (%u)' % [RCODES.key(self.rcode), self.rcode]
+
           str << Inspect.shift_level
+          rcode = '%-16s (%u)' % [RCODES.key(self.rcode), self.rcode]
           str << Inspect::FMT_ATTR % ['Integer', 'rcode', rcode]
         end
       end
+
+      private
+
+      def inspect_flags
+        flags = %i[qr aa tc rd ra].select! { |flag| send "#{flag}?" }.map(&:to_s).join(',')
+        str = Inspect.shift_level
+        str << Inspect::FMT_ATTR % ['Flags', 'flags', flags]
+      end
     end
 
     self.add_class DNS

data/lib/packetgen/header/dot11/data.rb

@@ -67,59 +67,49 @@ module PacketGen
         # Get destination MAC address
         # @return [String]
         def dst
-          ds = frame_ctrl & 3
-          case ds
-          when 0, 2
-            self.mac1
-          when 1, 3
-            self.mac3
-          end
+          _src_mac, dst_mac = src_dst_from_mac
+          self.send(dst_mac)
         end
 
         # Set destination MAC address
         # @param [String] mac MAC address to set
         # @return [String]
         def dst=(mac)
-          ds = frame_ctrl & 3
-          case ds
-          when 0, 2
-            self.mac1 = mac
-          when 1, 3
-            self.mac3 = mac
-          end
+          _src_mac, dst_mac = src_dst_from_mac
+          self.send("#{dst_mac}=", mac)
         end
 
         # Get source MAC address
         # @return [String]
         def src
-          ds = frame_ctrl & 3
-          case ds
-          when 0, 1
-            self.mac2
-          when 2
-            self.mac3
-          when 3
-            self.mac4
-          end
+          src_mac, = src_dst_from_mac
+          self.send(src_mac)
         end
 
         # Set source MAC address
         # @param [String] mac MAC address to set
         # @return [String]
         def src=(mac)
+          src_mac, = src_dst_from_mac
+          self.send("#{src_mac}=", mac)
+        end
+
+        private
+
+        def src_dst_from_mac
           ds = frame_ctrl & 3
           case ds
-          when 0, 1
-            self.mac2 = mac
+          when 0
+            %i[mac2 mac1]
+          when 1
+            %i[mac2 mac3]
           when 2
-            self.mac3 = mac
+            %i[mac3 mac1]
           when 3
-            self.mac4 = mac
+            %i[mac4 mac3]
           end
         end
 
-        private
-
         def define_applicable_fields
           super
           if (subtype >= 8) && !@applicable_fields.include?(:qos_ctrl)

data/lib/packetgen/header/dot11/management.rb

@@ -53,12 +53,9 @@ module PacketGen
         # @return [self]
         # @since 2.1.3
         def add_element(type:, value:)
-          if self[:body].is_a? SubMngt
-            self[:body].elements << { type: type, value: value }
-          else
-            raise FormatError, 'Before adding an Element, you have to add a Dot11::SubMngt subclass instance'
-          end
+          raise FormatError, 'Before adding an Element, you have to add a Dot11::SubMngt subclass instance' unless self[:body].is_a? SubMngt
 
+          self[:body].elements << { type: type, value: value }
           self
         end
 

data/lib/packetgen/header/dot11.rb

@@ -355,7 +355,7 @@ module PacketGen
       def added_to_packet(packet)
         return if packet.respond_to? :dot11
 
-        packet.instance_eval("def dot11(arg=nil); header(#{self.class}, arg); end")
+        packet.instance_eval("def dot11(arg=nil); header(#{self.class}, arg); end") # def dot11(arg=nil); header(Dot11, arg); end
       end
 
       private

data/lib/packetgen/header/eap.rb

@@ -218,7 +218,7 @@ module PacketGen
       def added_to_packet(packet)
         return if packet.respond_to? :eap
 
-        packet.instance_eval("def eap(arg=nil); header(#{self.class}, arg); end")
+        packet.instance_eval("def eap(arg=nil); header(#{self.class}, arg); end") # def eap(arg=nil); header(EAP, arg); end
       end
 
       # Invert between a request and a response packet. Not action for

data/lib/packetgen/header/eth.rb

@@ -60,7 +60,7 @@ module PacketGen
         def from_human(str)
           return self if str.nil?
 
-          bytes = str.split(/:/)
+          bytes = str.split(':')
           raise ArgumentError, 'not a MAC address' unless bytes.size == 6
 
           6.times do |i|

data/lib/packetgen/header/http/request.rb

@@ -81,6 +81,10 @@ module PacketGen
           self
         end
 
+        def parse?
+          VERBS.include?(self.verb) && self.version.start_with?('HTTP/1.')
+        end
+
         # String representation of data.
         # @return [String]
         def to_s
@@ -116,6 +120,6 @@ module PacketGen
     end
 
     self.add_class HTTP::Request
-    TCP.bind HTTP::Request, body: ->(b) { HTTP::REQUEST_REGEX =~ b.chars.select(&:valid_encoding?).join }
+    TCP.bind HTTP::Request, body: ->(b) { b.nil? ? '' : HTTP::REQUEST_REGEX =~ b }
   end
 end

data/lib/packetgen/header/http/response.rb

@@ -67,11 +67,42 @@ module PacketGen
         # Read in the HTTP portion of the packet, and parse it.
         # @return [PacketGen::HTTP::Response]
         def read(str)
-          str = str.bytes.map!(&:chr).join unless str.valid_encoding?
-          arr = str.split("\r\n")
+          headers, data = collect_headers_and_data(str)
+
+          unless headers.empty?
+            extract_info_from_first_line(headers)
+            self[:headers].read(headers.join("\n"))
+          end
+          self[:body].read data.join("\n")
+
+          self
+        end
+
+        def parse?
+          version.start_with?('HTTP/1.')
+        end
+
+        # String representation of data.
+        # @return [String]
+        def to_s
+          raise_on_bad_version_status
+
+          str = +''
+          str << self.version << ' ' << self.status_code << ' ' << self.status_mesg << "\r\n"
+          str << self[:headers].to_s if self[:headers].given?
+          str << self.body
+        end
+
+        private
+
+        def collect_headers_and_data(str)
           headers = [] # header stream
           data = [] # data stream
           switch = false
+
+          str = str.bytes.map!(&:chr).join unless str.valid_encoding?
+          arr = str.split("\r\n")
+
           arr.each do |line|
             if line.empty?
               data << line if switch # already done
@@ -85,33 +116,28 @@ module PacketGen
               headers << line
             end
           end
-          unless headers.empty?
-            first_line = headers.shift.split
-            self[:version].read first_line[0]
-            self[:status_code].read first_line[1]
-            self[:status_mesg].read first_line[2..-1].join(' ')
-            self[:headers].read(headers.join("\n"))
-          end
-          self[:body].read data.join("\n")
-          self
+
+          [headers, data]
         end
 
-        # String representation of data.
-        # @return [String]
-        def to_s
+        def extract_info_from_first_line(headers)
+          first_line = headers.shift.split
+          return if first_line.size < 3
+
+          self[:version].read first_line[0]
+          self[:status_code].read first_line[1]
+          self[:status_mesg].read first_line[2..-1].join(' ')
+        end
+
+        def raise_on_bad_version_status
           raise FormatError, 'Missing #status_code.' if self.status_code.empty?
           raise FormatError, 'Missing #status_mesg.' if self.status_mesg.empty?
           raise FormatError, 'Missing #version.'     if self.version.empty?
-
-          str = +''
-          str << self.version << ' ' << self.status_code << ' ' << self.status_mesg << "\r\n"
-          str << self[:headers].to_s if self[:headers].given?
-          str << self.body
         end
       end
     end
 
     self.add_class HTTP::Response
-    TCP.bind HTTP::Response, body: ->(b) { %r[^HTTP/1\.1\s\d{3,}\s.+] =~ b.chars.select(&:valid_encoding?).join }
+    TCP.bind HTTP::Response, body: ->(b) { b.nil? ? '' : %r[^HTTP/1\.1\s\d{3,}\s.+] =~ b }
   end
 end

data/lib/packetgen/header/http/verbs.rb

@@ -16,7 +16,7 @@ module PacketGen
       VERBS = %w[GET HEAD POST PUT DELETE CONNECT OPTIONS TRACE PATCH].freeze
 
       # Identifiable HTTP request regular expression.
-      REQUEST_REGEX = Regexp.new("(#{VERBS.dup.join('|')})\\s+\\S+\\s+HTTP/1.1")
+      REQUEST_REGEX = Regexp.new("^(#{VERBS.dup.join('|')})\\s+\\S+\\s+HTTP/1.1")
     end
   end
 end

data/lib/packetgen/header/igmp.rb

@@ -77,7 +77,7 @@ module PacketGen
       #       directly called
       def added_to_packet(packet)
         igmp_idx = packet.headers.size
-        packet.instance_eval "def igmpize() @headers[#{igmp_idx}].igmpize; end"
+        packet.instance_eval "def igmpize() @headers[#{igmp_idx}].igmpize; end" # def igmpize() @headers[2].igmpize; end
       end
 
       # Get human readbale type

data/lib/packetgen/header/ip/option.rb

@@ -55,7 +55,7 @@ module PacketGen
         #  option data
         # @return [String]
         define_field :data, Types::String, optional: ->(h) { h.length > 2 },
-                     builder: ->(h, t) { t.new(length_from: -> { h.length - 2 }) }
+                                           builder: ->(h, t) { t.new(length_from: -> { h.length - 2 }) }
 
         # @!attribute copied
         #  1-bit copied flag from {#type} field
@@ -161,6 +161,7 @@ module PacketGen
 
       # Strict Source and Record Route IP option
       class SSRR < LSRR; end
+
       # Record Route IP option
       class RR < LSRR; end
 

data/lib/packetgen/header/ipv6/addr.rb

@@ -49,6 +49,8 @@ module PacketGen
         #  @return [Integer]
         define_field :a8, Types::Int16
 
+        # rubocop:disable Metrics/AbcSize
+
         # Read a colon-delimited address
         # @param [String] str
         # @return [self]
@@ -69,6 +71,7 @@ module PacketGen
           self.a8 = addri & 0xffff
           self
         end
+        # rubocop:enable Metrics/AbcSize
 
         # Addr6 in human readable form (colon-delimited hex string)
         # @return [String]