packetgen 2.1.4 → 2.2.0

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

@@ -33,9 +33,9 @@ module PacketGen
           return self if str.nil?
 
           str.split('.').each do |label|
-            self << Types::IntString.new(label)
+            self << Types::IntString.new(string: label)
           end
-          self << Types::IntString.new('')
+          self << Types::IntString.new
         end
 
         # Read a sequence of label from a string

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

@@ -17,7 +17,7 @@ module PacketGen
         # @!attribute rdata
         #  @return [Types::String]
         define_field :rdata, Types::String,
-                     builder: ->(rr) { Types::String.new('', length_from: rr[:rdlength]) }
+                     builder: ->(rr, t) { t.new(length_from: rr[:rdlength]) }
 
         # @param [DNS] dns
         # @param [Hash] options

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

@@ -19,7 +19,7 @@ module PacketGen
         # @!attribute value
         #  @return [::String]
         define_field :value, Types::String,
-                     builder: ->(h) { Types::String.new('', length_from: h[:value_size]) }
+                     builder: ->(h, t) { t.new(length_from: h[:value_size]) }
         # @!attribute optional_name
         #  @return [::String]
         define_field :optional_name, Types::String

data/lib/packetgen/header/esp.rb

@@ -218,7 +218,7 @@ module PacketGen
         # as padding is used to pad for CBC mode, this is unused
         cipher.final
 
-        self[:body] = Types::String.new(iv) << enc_msg[0..-3]
+        self[:body] = Types::String.new.read(iv) << enc_msg[0..-3]
         self[:pad_length].read enc_msg[-2]
         self[:next].read enc_msg[-1]
 

data/lib/packetgen/header/eth.rb

@@ -32,7 +32,7 @@ module PacketGen
 
       # Ethernet MAC address, as a group of 6 bytes
       # @author Sylvain Daubert
-      class MacAddr < Base
+      class MacAddr < Types::Fields
         # @!attribute a0
         #  @return [Integer] first byte from MacAddr
         define_field :a0, Types::Int8

data/lib/packetgen/header/http.rb

@@ -0,0 +1,8 @@
+# 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.
+
+require_relative 'http/headers'
+require_relative 'http/response'
+require_relative 'http/request'

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

@@ -0,0 +1,76 @@
+# 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
+
+    # @since 2.2.0
+    module HTTP 
+      # @abstract Base class for HTTP headers.
+      # @author Kent 'picat' Gruber
+      class Headers
+        def initialize
+          @data = nil
+        end
+
+        # Populate object from a string or directly from a hash.
+        # @param [String, Hash]
+        # @return [self]
+        def read(s_or_h)
+          case s_or_h
+          when String
+            @data = s_or_h.split("\n").map do |h| 
+              k, v = h.split(":", 2)
+              [k, v.strip] 
+            end.to_h
+          when Hash
+            @data = s_or_h
+          end
+          self
+        end
+
+        # Get binary string.
+        # @return [String]
+        def to_s
+          return "\r\n" if @data.nil? || @data.empty?
+          d = []
+          @data.map do |k, v|
+            str = ""
+            str << k << ": " << v
+            d << str
+          end
+          d.join("\r\n") << "\r\n\r\n"
+        end
+
+        # Get a human readable string.
+        # @return [Hash]
+        def to_human
+          @data
+        end
+
+        # Read human-readable data to populate header data.
+        # @param [String, Hash]
+        # @return [self]
+        def from_human(data)
+          read(data)
+        end
+
+        # Check if any headers were given.
+        # @return [Boolean]
+        def given?
+          return true unless @data.nil? || @data.empty?
+          false
+        end
+
+        # Shorcut to the underlying Headers data or nil.
+        # @return [Hash, nil]
+        def data
+          @data
+        end
+        alias to_h data
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+# 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
+    module HTTP
+      # An HTTP/1.1 Request packet consits of:
+      # * the http method ({Types::String}).
+      # * the path ({Types::String}).
+      # * the version ({Types::String}).
+      # * associated http headers ({HTTP::Headers}).
+      #
+      # == Create a HTTP Request header
+      #   # standalone
+      #   http_rqst = PacketGen::Header::HTTP::Request.new
+      #   # in a packet
+      #   pkt = PacketGen.gen("IP").add("TCP").add("HTTP::Request")
+      #   # access to HTTP Request header
+      #   pkt.http_request # => PacketGen::Header::HTTP::Request
+      #
+      # Note: When creating a HTTP Request packet, +sport+ and +dport+
+      # attributes of TCP header are not set.
+      #
+      # == HTTP Request attributes
+      #	  http_rqst.version = "HTTP/1.1"
+      #	  http_rqst.method  = "GET"
+      #	  http_rqst.path    = "/meow.html"
+      #   http_rqst.headers = "Host: tcpdump.org"     # string or
+      #	  http_rqst.headers = { "Host": "tcpdump.org" } # even a hash
+      #
+      # @author Kent 'picat' Gruber
+      class Request < Base
+        # @!attribute method
+        #   @return [Types::String]
+        define_field :method,  Types::String
+        # @!attribute path 
+        #   @return [Types::String]
+        define_field :path,    Types::String
+        # @!attribute version 
+        #   @return [Types::String]
+        define_field :version, Types::String, default: "HTTP/1.1"
+        # @!attribute headers
+        #   associated http/1.1 headers
+        #   @return [HTTP::Headers]
+        define_field :headers, HTTP::Headers 
+
+        # @param [Hash] options
+        # @option options [String] :method
+        # @option options [String] :path
+        # @option options [String] :version
+        # @option options [Hash]   :headers
+        def initialize(options={})
+          super(options)
+          self.headers ||= options[:headers]
+        end
+
+        # Read in the HTTP portion of the packet, and parse it. 
+        # @return [PacketGen::HTTP::Request]
+        def read(str)
+          # prepare data to parse
+          str = str.split("\n").map(&:strip).reject(&:empty?)
+          first_line = str.shift.split
+          self[:method]  = first_line[0]
+          self[:path]    = first_line[1]
+          self[:version] = first_line[2]
+          headers = str.join("\n")
+          self[:headers].read(headers)
+          self
+        end
+
+        # String representation of data.
+        # @return [String]
+        def to_s
+          raise FormatError, "Missing #method."  if self.method.empty?
+          raise FormatError, "Missing #path."    if self.path.empty?
+          raise FormatError, "Missing #version." if self.version.empty?
+          str = "" # build 'dat string
+          str << self[:method] << " " << self[:path] << " " << self[:version] << "\r\n" << self[:headers].to_s
+        end
+      end
+    end
+
+    self.add_class HTTP::Request 
+    TCP.bind_header HTTP::Request, body: ->(b) { /^(CONNECT|DELETE|GET|HEAD|OPTIONS|PATCH|POST|PUT)/ =~ b }
+  end
+end

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

@@ -0,0 +1,116 @@
+# 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
+    module HTTP
+      # An HTTP/1.1 Response packet consits of:
+      # * the version ({Types::String}).
+      # * the status code ({Types::String}).
+      # * the status message ({Types::String}).
+      # * associated http headers ({HTTP::Headers}).
+      # * the actual http payload body ({Types::String}).
+      #
+      # == Create a HTTP Response header
+      #   # standalone
+      #   http_resp = PacketGen::Header::HTTP::Response.new
+      #   # in a packet
+      #   pkt = PacketGen.gen("IP").add("TCP").add("HTTP::Response")
+      #   # access to HTTP Response header
+      #   pkt.http_response # => PacketGen::Header::HTTP::Response
+      #
+      # Note: When creating a HTTP Response packet, +sport+ and +dport+
+      # attributes of TCP header are not set.
+      #
+      # == HTTP Response attributes
+      #   http_resp.version     = "HTTP/1.1"
+      #   http_resp.status_code = "200"
+      #   http_resp.status_mesg = "OK"
+      #   http_resp.body        = "this is a body"
+      #   http_resp.headers     = "Host: tcpdump.org"     # string or
+      #   http_resp.headers     = { "Host": "tcpdump.org" } # even a hash
+      #
+      # @author Kent 'picat' Gruber
+      class Response < Base
+        # @!attribute version 
+        #   @return [Types::String]
+        define_field :version,     Types::String, default: "HTTP/1.1"
+        # @!attribute status_code 
+        #   @return [Types::String]
+        define_field :status_code, Types::String
+        # @!attribute status_mesg 
+        #   @return [Types::String]
+        define_field :status_mesg, Types::String  
+        # @!attribute headers
+        #   associated http/1.1 headers
+        #   @return [Types::String]
+        define_field :headers, HTTP::Headers
+        # @!attribute body 
+        #   @return [HTTP::PHeaders]
+        define_field :body, Types::String
+
+        # @param [Hash] options
+        # @option options [String] :version
+        # @option options [String] :status_code
+        # @option options [String] :status_mesg
+        # @option options [String] :body
+        # @option options [Hash]   :headers
+        def initialize(options={})
+          super(options)
+          self.headers ||= options[:headers]
+        end
+
+        # Read in the HTTP portion of the packet, and parse it. 
+        # @return [PacketGen::HTTP::Response]
+        def read(str)
+          # prepare data to parse
+          arr     = str.split("\r\n")
+          headers = [] # header stream
+          data    = [] # data stream
+          switch  = false
+          arr.each do |line|
+            if line.empty?
+              data << line if switch # already done
+              switch = true
+              next
+            end
+            case switch
+            when true
+              data << line
+            else
+              headers << line
+            end
+          end
+          unless headers.empty?
+            first_line = headers.shift.split
+            self[:version]     = first_line[0]
+            self[:status_code] = first_line[1]
+            self[:status_mesg] = first_line[2..-1].join(" ")
+            self[:headers].read(headers.join("\n")) 
+          end
+          self[:body] = data.join("\n")
+          self
+        end
+
+        # String representation of data.
+        # @return [String]
+        def to_s
+          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 = "" # build 'dat string
+          str << self[:version] << " " << self[:status_code] << " " << self[:status_mesg] << "\r\n" 
+          if self[:headers].given?
+            str << self[:headers].to_s 
+          end
+          str << self.body
+        end
+      end
+    end
+
+    self.add_class HTTP::Response
+    TCP.bind_header HTTP::Response, body: ->(b) { /^HTTP\/1\.1\s\d{3,}\s.+/ =~ b }
+  end
+end

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

@@ -107,7 +107,7 @@ module PacketGen
         #   this field is not present in the proposal.
         #   @return [String]
         define_field_before :content, :spi, Types::String,
-                            builder: ->(t) { Types::String.new('', length_from: t[:spi_size]) }
+                            builder: ->(h, t) { t.new(length_from: h[:spi_size]) }
 
         alias type message_type
 

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

@@ -398,11 +398,11 @@ module PacketGen
         #   the sending entity's SPI. When the {#spi_size} field is zero,
         #   this field is not present in the proposal.
         #   @return [String]
-        define_field :spi, Types::String, builder: ->(t) { Types::String.new('', length_from: t[:spi_size]) }
+        define_field :spi, Types::String, builder: ->(h, t) { t.new(length_from: h[:spi_size]) }
         # @!attribute transforms
         #  8-bit set of tranforms for this proposal
         #  @return [Transforms]
-        define_field :transforms, Transforms, builder: ->(t) { Transforms.new(counter: t[:num_trans]) }
+        define_field :transforms, Transforms, builder: ->(h, t) { t.new(counter: h[:num_trans]) }
 
         def initialize(options={})
           if options[:spi] and options[:spi_size].nil?

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

@@ -234,7 +234,7 @@ module PacketGen
         #  Set of {TrafficSelector}
         #  @return {TrafficSelectors}
         define_field_before :body, :traffic_selectors, TrafficSelectors,
-                            builder: ->(ts) { TrafficSelectors.new(counter: ts[:num_ts]) }
+                            builder: ->(h, t) { t.new(counter: h[:num_ts]) }
         alias :selectors :traffic_selectors
 
         # Populate object from a string

data/lib/packetgen/header/ip.rb

@@ -11,6 +11,7 @@ module PacketGen
     # * a first byte ({#u8} of {Types::Int8} type) composed of:
     #   * a 4-bit {#version} field,
     #   * a 4-bit IP header length ({#ihl}) field,
+    # * a Type of Service field ({#tos}, {Types::Int8} type),
     # * a total length ({#length}, {Types::Int16} type),
     # * a ID ({#id}, +Int16+ type),
     # * a {#frag} worg (+Int16+) composed of:
@@ -20,7 +21,8 @@ module PacketGen
     # * a {#protocol} field (+Int8+),
     # * a {#checksum} field (+Int16+),
     # * a source IP address ({#src}, {Addr} type),
-    # * a destination IP ddress ({#dst}, +Addr+ type),
+    # * a destination IP address ({#dst}, +Addr+ type),
+    # * an optional {#options} field ({Types::String} type),
     # * and a {#body} ({Types::String} type).
     #
     # == Create a IP header
@@ -62,7 +64,7 @@ module PacketGen
 
       # IP address, as a group of 4 bytes
       # @author Sylvain Daubert
-      class Addr < Base
+      class Addr < Types::Fields
         # @!attribute a1
         #  @return [Integer] IP address first byte 
         define_field :a1, Types::Int8
@@ -141,6 +143,11 @@ module PacketGen
       # @!attribute dst
       #   @return [Addr] destination IP address
       define_field :dst, Addr, default: '127.0.0.1'
+      # @!attribute options
+      #  @since 2.2.0
+      #  @return [Types::String]
+      define_field :options, Types::String, optional: ->(h) { h.ihl > 5 },
+                   builder: ->(h,t) { t.new(length_from: ->() { (h.ihl - 5) * 4 }) }
       # @!attribute body
       #  @return [Types::String,Header::Base]
       define_field :body, Types::String
@@ -161,6 +168,29 @@ module PacketGen
       #   @return [Integer] 13-bit fragment offset
       define_bit_fields_on :frag, :flag_rsv, :flag_df, :flag_mf, :fragment_offset, 13
 
+      # Populate object from a binary string
+      # @param [String] str
+      # @return [Fields] self
+      #def read(str)
+      #  return self if str.nil?
+      #  force_binary str
+      #  self[:u8].read str[0, 1]
+      #  self[:tos].read str[1, 1]
+      #  self[:length].read str[2, 2]
+      #  self[:id].read str[4, 2]
+      #  self[:frag].read str[6, 2]
+      #  self[:ttl].read str[8, 1]
+      #  self[:protocol].read str[9, 1]
+      #  self[:checksum].read str[10, 2]
+      #  self[:src].read str[12, 4]
+      #  self[:dst].read str[16, 4]
+      #  if self.ihl > 5
+      #    opt_size = (self.ihl - 5) * 4
+      #    self[:options].read str[20, opt_size]
+      #  end
+      #  self
+      #end
+
       # Compute checksum and set +checksum+ field
       # @return [Integer]
       def calc_checksum