packetgen 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dfd9d08f263a51dd186442e4b8f8395be3a964a2
-  data.tar.gz: f68b293509bf734b7aa1760ba976b437ce3fba4c
+  metadata.gz: f98c7d5b928554e3d6da92e42f96bf3ee0a397a8
+  data.tar.gz: 994ede3f4bc303f98df8bd29e6bcb0b34932bf75
 SHA512:
-  metadata.gz: 024c502d411c3ae81f7272bb5476964421738e3357d6a5e8b6308600408a499805f0015497d31ca792278857dc23609f2352c26a23011ef17c6edc40fe44e726
-  data.tar.gz: 968a82ca1231067f5bc68fefae05c80842ff4b058fb17ff9c269320662e7eb6acb5db4c54435be479294857cadc41fee0d7fcb7d795437b982a30ae2fba17bed
+  metadata.gz: d3a0d0198fda11d157d42ca626b6e59d0af792748b194d60dff4d0bd6a928e6b664eeb4d95d5ad70c94e3f38e690e8b616377eb95fffd9fe338158766235148c
+  data.tar.gz: '09ba37f246d17b612f0ae247dab1408a799a9782d652e29ac3e798d8b46543225b506c983546b2e5acc7effdc52aca65f17f1fec1e3d32434f68edd535439b18'

data/README.md

@@ -166,5 +166,5 @@ Copyright © 2016 Sylvain Daubert
 ### Other sources
 All original code maintains its copyright from its original authors and licensing.
 
-This is mainly for StrucFu (copied from [PacketFu](https://github.com/packetfu/packetfu))
-and PcapNG module (also copied from PacketFu, but I am the author).
+This is mainly for PcapNG (copied from [PacketFu](https://github.com/packetfu/packetfu),
+but i am the original author).

data/lib/packetgen/header/arp.rb

@@ -7,9 +7,9 @@ module PacketGen
   module Header
 
     # An ARP header consists of:
-    # * a hardware type ({#hrd} or {#htype}) field ({Int16}),
+    # * a hardware type ({#hrd} or {#htype}) field ({Types::Int16}),
     # * a protocol type ({#pro} or {#ptype}) field (+Int16+),
-    # * a hardware address length ({#hln} or {#hlen}) field ({Int8}),
+    # * a hardware address length ({#hln} or {#hlen}) field ({Types::Int8}),
     # * a protocol address length ({#pln} or {#plen}) field (+Int8+),
     # * a {#opcode} (or {#op}) field (+Int16+),
     # * a source hardware address ({#sha} or {#src_mac}) field ({Eth::MacAddr}),
@@ -27,11 +27,47 @@ module PacketGen
     #  pkt.arp   # => PacketGen::Header::ARP
     #
     # @author Sylvain Daubert
-    class ARP < Struct.new(:hrd, :pro, :hln, :pln, :op,
-                           :sha, :spa, :tha, :tpa, :body)
-      include StructFu
-      include HeaderMethods
-      extend HeaderClassMethods
+    class ARP < Base
+
+      # @!attribute hrd
+      #  16-bit hardware protocol type
+      #  # @return [Integer]
+      define_field :hrd, Types::Int16, default: 1
+      # @!attribute pro
+      #  16-bit internet protocol type
+      #  # @return [Integer]
+      define_field :pro, Types::Int16, default: 0x800
+      # @!attribute hln
+      #  8-bit hardware address length
+      #  # @return [Integer]
+      define_field :hln, Types::Int8, default: 6
+      # @!attribute pln
+      #  8-bit internet address length
+      #  # @return [Integer]
+      define_field :pln, Types::Int8, default: 4
+      # @!attribute op
+      #  16-bit operation code
+      #  # @return [Integer]
+      define_field :op, Types::Int16, default: 1
+      # @!attribute sha
+      #  source hardware address
+      #  @return [Eth::MacAddr]
+      define_field :sha, Eth::MacAddr
+      # @!attribute spa
+      #  source protocol address
+      #  @return [IP::Addr]
+      define_field :spa, IP::Addr
+      # @!attribute tha
+      #  target hardware address
+      #  @return [Eth::MacAddr]
+      define_field :tha, Eth::MacAddr
+      # @!attribute tpa
+      #  target protocol address
+      #  @return [IP::Addr]
+      define_field :tpa, IP::Addr
+      # @!attribute body
+      #  @return [Types::String,Header::Base]
+      define_field :body, Types::String
 
       # @param [Hash] options
       # @option options [Integer] :hrd network protocol type (default: 1)
@@ -44,143 +80,36 @@ module PacketGen
       # @option options [String] :spa sender internet address
       # @option options [String] :tha target hardware address
       # @option options [String] :tpa targetr internet address
-       def initialize(options={})
-        super Int16.new(options[:hrd] || options[:htype] || 1),
-              Int16.new(options[:pro] || options[:ptype] || 0x800),
-              Int8.new(options[:hln] || options[:hlen] || 6),
-              Int8.new(options[:pln] || options[:plen] || 4),
-              Int16.new(options[:op] || options[:opcode] || 1),
-              Eth::MacAddr.new.from_human(options[:sha] || options[:src_mac]),
-              IP::Addr.new.from_human(options[:spa] || options[:src_ip]),
-              Eth::MacAddr.new.from_human(options[:tha] || options[:dst_mac]),
-              IP::Addr.new.from_human(options[:tpa] || options[:dst_ip]),
-              StructFu::String.new.read(options[:body])
+      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]
+        super 
       end
 
-      # Read a ARP header from a string
-      # @param [String] str binary string
-      # @return [self]
-      def read(str)
-        force_binary str
-        raise ParseError, 'string too short for ARP' if str.size < self.sz
-        self[:hrd].read str[0, 2]
-        self[:pro].read str[2, 2]
-        self[:hln].read str[4, 1]
-        self[:pln].read str[5, 1]
-        self[:op].read str[6, 2]
-        self[:sha].read str[8, 6]
-        self[:spa].read str[14, 4]
-        self[:tha].read str[18, 6]
-        self[:tpa].read str[24, 4]
-        self[:body].read str[28..-1]
-      end
-
-      # @!attribute [rw] hrd
-      # @return [Integer]
-      def hrd
-        self[:hrd].to_i
-      end
       alias :htype :hrd
-      
-      def hrd=(i)
-        self[:hrd].read i
-      end
       alias :htype= :hrd=
-
-      # @!attribute [rw] pro
-      # @return [Integer]
-      def pro
-        self[:pro].to_i
-      end
       alias :ptype :pro
-      
-      def pro=(i)
-        self[:pro].read i
-      end
       alias :ptype= :pro=
-
-      # @!attribute [rw] hln
-      # @return [Integer]
-      def hln
-        self[:hln].to_i
-      end
       alias :hlen :hln
-      
-      def hln=(i)
-        self[:hln].read i
-      end
       alias :hlen= :hln=
-
-      # @!attribute [rw] pln
-      # @return [Integer]
-      def pln
-        self[:pln].to_i
-      end
       alias :plen :pln
-      
-      def pln=(i)
-        self[:pln].read i
-      end
       alias :plen= :pln=
-
-      # @!attribute [rw] op
-      # @return [Integer]
-      def op
-        self[:op].to_i
-      end
       alias :opcode :op
-      
-      def op=(i)
-        self[:op].read i
-      end
       alias :opcode= :op=
-
-      # @!attribute [rw] sha
-      # @return [String]
-      def sha
-        self[:sha].to_human
-      end
       alias :src_mac :sha
-      
-      def sha=(addr)
-        self[:sha].from_human addr
-      end
       alias :src_mac= :sha=
-
-      # @!attribute [rw] spa
-      # @return [String]
-      def spa
-        self[:spa].to_human
-      end
       alias :src_ip :spa
-      
-      def spa=(addr)
-        self[:spa].from_human addr
-      end
       alias :src_ip= :spa=
-
-      # @!attribute [rw] tha
-      # @return [String]
-      def tha
-        self[:tha].to_human
-      end
       alias :dst_mac :tha
-      
-      def tha=(addr)
-        self[:tha].from_human addr
-      end
       alias :dst_mac= :tha=
-
-      # @!attribute [rw] tpa
-      # @return [String]
-      def tpa
-        self[:tpa].to_human
-      end
       alias :dst_ip :tpa
-      
-      def tpa=(addr)
-        self[:tpa].from_human addr
-      end
       alias :dst_ip= :tpa=
     end
 

data/lib/packetgen/header/base.rb

@@ -0,0 +1,175 @@
+# 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
+
+    # @abstract
+    # Base class for all header types
+    # @author Sylvain Daubert
+    class Base < Types::Fields
+
+      # @api private
+      # Simple class to handle a header association
+      class Binding < Struct.new(:key, :value)
+        # Check +fields+ responds to binding
+        # @param [Types::Fields] fields
+        # @return [Boolean]
+        def check?(fields)
+          case self[:value]
+          when Proc
+            self[:value].call fields.send(self[:key])
+          else
+            fields.send(self[:key]) == self[:value]
+          end
+        end
+
+        # Set +fields+ field to binding value
+        # @param [Types::Fields] fields
+        # @return [void]
+        def set(fields)
+          case self[:value]
+          when Proc
+            fields.send "#{self[:key]}=", self[:value].call(nil)
+          else
+            fields.send "#{self[:key]}=", self[:value]
+          end
+        end
+      end
+
+      # @api private
+      # Class to handle header associations
+      class Bindings
+        include Enumerable
+
+        # op type
+        # @return [:or,:and]
+        attr_accessor :op
+        # @return [Array<Binding>]
+        attr_accessor :bindings
+
+        # @param [:or, :and] op
+        def initialize(op)
+          @op = op
+          @bindings = []
+        end
+
+        # @param [Object] arg
+        # @return [Bindings] self
+        def <<(arg)
+          @bindings << arg
+        end
+
+        # each iterator
+        # @return [void]
+        def each
+          @bindings.each { |b| yield b }
+        end
+
+        # @return [Boolean]
+        def empty?
+          @bindings.empty?
+        end
+
+        # @return [Hash]
+        def to_h
+          hsh = {}
+          each { |b| hsh[b.key] = b.value }
+          hsh
+        end
+
+        # Check +fields+ responds to set of bindings
+        # @param [Types::Fields] fields
+        # @return [Boolean]
+        def check?(fields)
+          case @op
+          when :or
+            @bindings.any? { |binding| binding.check?(fields) }
+          when :and
+            @bindings.all? { |binding| binding.check?(fields) }
+          end
+        end
+
+        # Set +fields+ to bindings value
+        # @param [Types::Fields] fields
+        # @return [void]
+        def set(fields)
+          @bindings.each { |b| b.set fields }
+        end
+      end
+
+      # @api private
+      # Reference on packet which owns this header
+      attr_accessor :packet
+
+      # On inheritage, create +@known_headers+ class variable
+      # @param [Class] klass
+      # @return [void]
+      def self.inherited(klass)
+        super
+        klass.class_eval { @known_headers = {} }
+      end
+
+      # Bind a upper header to current class
+      #   Header1.bind_header Header2, field1: 43
+      #   Header1.bind_header Header2, field1: 43, field2: 43
+      #   Header1.bind_header Header2, op: :and, field1: 43, field2: 43
+      #   Header1.bind_header Header2, field1: ->(v) { v.nil? ? 128 : v > 127 }
+      # @param [Class] header_klass header class to bind to current class
+      # @param [Hash] args current class fields and their value when +header_klass+
+      #  is embedded in current class. Given value may be a lambda, whose alone argument
+      #  is the value extracted from header field (or +nil+ when lambda is used to set
+      #  field while adding a header).
+      #
+      #  If multiple fields are given, a special key +:op+ may be given to set parse
+      #  operation on this binding. By default, +:op+ is +:or+ (at least one binding
+      #  must match to parse it). It also may be set to +:and+ (all bindings must match
+      #  to parse it).
+      # @return [void]
+      def self.bind_header(header_klass, args={})
+        op = args.delete(:op) || :or
+        bindings = Bindings.new(op)
+        @known_headers[header_klass] = bindings
+        args.each do |key, value|
+          bindings << Binding.new(key, value)
+        end
+      end
+
+      # @api private
+      # Get knwon headers
+      # @return [Hash] keys: header classes, values: hashes
+      def self.known_headers
+        @known_headers
+      end
+
+      # @api private
+      # Get +header+ id in packet headers array
+      # @param [Header] header
+      # @return [Integer]
+      # @raise FormatError +header+ not in a packet
+      def header_id(header)
+        raise FormatError, "header of type #{header.class} not in a packet" if packet.nil?
+        id = packet.headers.index(header)
+        if id.nil?
+          raise FormatError, "header of type #{header.class} not in packet #{packet}"
+        end
+        id
+      end
+
+      # @api private
+      # Get IP or IPv6 previous header from +header+
+      # @param [Header] header
+      # @return [Header]
+      # @raise FormatError no IP or IPv6 header previous +header+ in packet
+      # @raise FormatError +header+ not in a packet
+      def ip_header(header)
+        hid = header_id(header)
+        iph = packet.headers[0...hid].reverse.find { |h| h.is_a? IP or h.is_a? IPv6 }
+        raise FormatError, 'no IP or IPv6 header in packet' if iph.nil?
+        iph
+      end
+    end
+  end
+end

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

@@ -0,0 +1,110 @@
+module PacketGen
+  module Header
+    class DNS
+
+      # DNS Name, defined as a suite of labels. A label is of type {Types::IntString}.
+      # @author Sylvain Daubert
+      class Name < Types::Array
+
+        # Mask to decode a pointer on another label
+        POINTER_MASK = 0xc000
+
+        # @return [DNS]
+        attr_accessor :dns
+
+        def initialize
+          super
+          @pointer = nil
+          @pointer_name = nil
+        end
+
+        # @!method push(label)
+        #  @param [Types::IntString] label
+        #  @return [Name] self
+        # @!method <<(label)
+        #  @param [Types::IntString] label
+        #  @return [Name] self
+
+        # Read a set of labels form a dotted string
+        # @param [String] str
+        # @return [Name] self
+        def from_human(str)
+          clear
+          return self if str.nil?
+
+          str.split('.').each do |label|
+            self << Types::IntString.new(label)
+          end
+          self << Types::IntString.new('')
+        end
+
+        # Read a sequence of label from a string
+        # @param [String] str binary string
+        # @return [Name] self
+        def read(str)
+          @pointer = nil
+          @pointer_name = nil
+          clear
+          return self if str.nil?
+
+          force_binary str
+          start = 0
+          while true
+            index = str[start, 2].unpack('n').first
+            if pointer? index
+              # Pointer on another label
+              @pointer = str[start, 2]
+              break
+            else
+              label = Types::IntString.new
+              label.read(str[start..-1])
+              start += label.sz
+              self << label
+              break if label.length == 0 or str[start..-1].length == 0
+            end
+          end
+          self
+        end
+
+        # Get options binary string
+        # @return [String]
+        def to_s
+          super << @pointer.to_s
+        end
+
+        # Get a human readable string
+        # @return [String]
+        def to_human
+          ary = map(&:string)
+          np = name_from_pointer
+          ary << np if np
+          str = ary.join('.')
+          str.empty? ? '.' : str
+        end
+
+        private
+
+        def pointer?(index)
+          return false if index.nil?
+          index & POINTER_MASK == POINTER_MASK
+        end
+
+        def name_from_pointer
+          return nil unless @pointer
+          return @pointer_name if @pointer_name
+          
+          index = @pointer.unpack('n').first
+          mask = ~POINTER_MASK & 0xffff
+          ptr = index & mask
+          name = Name.new
+          name.dns = @dns
+          @pointer_name = name.read(self.dns.to_s[ptr..-1]).to_human
+        end
+
+        def record_from_hash(hsh)
+          raise NotImplementedError, "not supported by #{self.class}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,137 @@
+require_relative 'option'
+
+module PacketGen
+  module Header
+    class DNS
+
+      # OPT pseudo-RR. Used by Extended DNS (EDNS(0), cf. RFC 6891).
+      #
+      # a OPT record may contain zero or more {Option options} in its {#rdata}.
+      # @author Sylvain Daubert
+      class OPT < RR
+        # @return [Array<Option>]
+        attr_reader :options
+
+        # @param [DNS] dns
+        # @param [Hash] options
+        # @option options [String] :name domain as a dotted string. Default to +"."+
+        # @option options [Integer,String] :type see {TYPES}. Default to +'OPT'+
+        # @option options [Integer] :udp_size UDP maximum size. Also +:rrclass+.
+        #  Default to 512.
+        # @option options [Integer] :ext_rcode
+        # @option options [Integer] :version
+        # @option options [Boolean] :do DO bit
+        # @option options [Integer] :ttl set +ext_rcode+, +version+, +do+ and
+        #   +z+ at once
+        # @option options [Integer] :rdlength if not provided, automatically set
+        #   from +:rdata+ length
+        # @option options [String] :rdata
+        def initialize(dns, options={})
+          opts = { name: '.', rrclass: 512, type: 41 }.merge!(options)
+          super dns, opts
+          @options = []
+
+          self.udp_size = options[:udp_size] if options[:udp_size]
+          self.ext_rcode = options[:ext_rcode] if options[:ext_rcode]
+          self.version = options[:version] if options[:version]
+          self.do = options[:do] unless options[:do].nil?
+        end
+
+        # @overload ext_rcode=(v)
+        #  Setter for upper 8 bits of extended 12-bit RCODE
+        #  @param [Integer] v
+        #  @return [Integer]
+        # @overload ext_rcode
+        #  Getter for upper 8 bits of extended 12-bit RCODE
+        #  @return [Integer]
+        # @return [Integer]
+        def ext_rcode=(v=nil)
+          if v
+            self[:ttl].value = self[:ttl].to_i & (0xffffffff & ~(0xff << 24))
+            self[:ttl].value |= (v & 0xff) << 24
+          end
+          (self[:ttl].to_i >> 24) & 0xff
+        end
+        alias ext_rcode ext_rcode=
+
+        # @overload version=(v)
+        #  Setter EDNS version
+        #  @param [Integer] v
+        #  @return [Integer]
+        # @overload version
+        #  Getter for EDNS version
+        #  @return [Integer]
+        # @return [Integer]
+        def version=(v=nil)
+          if v
+            self[:ttl].value = self[:ttl].to_i & (0xffffffff & ~(0xff << 16))
+            self[:ttl].value |= (v & 0xff) << 16
+          end
+          (self[:ttl].to_i >> 16) & 0xff
+        end
+        alias version version=
+
+        # @overload do=(v)
+        #  Setter EDNS do
+        #  @param [Boolean] v
+        #  @return [Boolean]
+        # @overload do?
+        #  Getter for EDNS do
+        #  @return [Boolean]
+        # @return [Boolean]
+        def do=(v=nil)
+          b = v ? 1 : 0
+          unless v.nil?
+            self[:ttl].value = self[:ttl].to_i & (0xffffffff & ~(1 << 15))
+            self[:ttl].value |= (b & 1) << 15
+          end
+          ((self[:ttl].to_i >> 15) & 1) == 1 ? true : false
+        end
+        alias :do? :do=
+
+        # @overload z=(v)
+        #  @param [Integer] v
+        #  @return [Integer]
+        # @overload z
+        #  @return [Integer]
+        # @return [Integer]
+        def z=(v=nil)
+          if v
+            self[:ttl].value = self[:ttl].to_i & (0xffffffff & ~0x7fff)
+            self[:ttl].value |= v & 0x7fff
+          end
+          self[:ttl].to_i & 0x7fff
+        end
+        alias z z=
+
+        # @!attribute udp_size
+        #  @return [Integer] UDP payload size
+        alias udp_size rrclass
+        alias udp_size= rrclass=
+
+        # @return [String]
+        def human_flags
+          do? ? 'do' : 'none'
+        end
+
+        # @return [String]
+        def human_options
+          str = @options.map(&:to_human).join(';')
+          str.empty? ? 'none' : str
+        end
+
+        # @return [String]
+        def to_human
+          "#{name} #{human_type} UDPsize:#{udp_size} " \
+          "extRCODE:#{ext_rcode} EDNSversion:#{version} flags:#{human_flags} " \
+          "options:#{human_options}"
+        end
+
+        # @return [String]
+        def to_s
+          super + @options.map(&:to_s).join
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module PacketGen
+  module Header
+    class DNS
+
+      # DNS option
+      # @author Sylvain Daubert
+      class Option < Types::TLV
+
+        # Force {#type} and {#length} fields to be {Types::Int16}
+        # @see TLV#initialize
+        def initialize(options={})
+          super options.merge!(t: Types::Int16, l: Types::Int16)
+        end
+      end
+    end
+  end
+end