packetgen 1.4.3 → 2.0.0

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

@@ -0,0 +1,34 @@
+# coding: utf-8
+module PacketGen
+  module Header
+    class IKE
+
+      # This class handles Vendor ID payloads, as defined in RFC 7296 §3.12.
+      #
+      # A Vendor ID payload contains a generic payload header (see {Payload})
+      # and data field (type {Types::String}):
+      #                        1                   2                   3
+      #    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+      #   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+      #   | Next Payload  |C|  RESERVED   |         Payload Length        |
+      #   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+      #   |                                                               |
+      #   ~                            VendorID Data                         ~
+      #   |                                                               |
+      #   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+      #
+      # == Create a Vendor ID payload
+      #   # Create a IKE packet with a Vendor ID payload
+      #   pkt = PacketGen.gen('IP').add('UDP').add('IKE')
+      #   pkt.add('IKE::VendorID', data: "abcdefgh")
+      # @author Sylvain Daubert
+      class VendorID < Payload
+
+        # Payload type number
+        PAYLOAD_TYPE = 43
+      end
+    end
+
+    self.add_class IKE::VendorID
+  end
+end

data/lib/packetgen/header/ip.rb

@@ -211,16 +211,16 @@ module PacketGen
           next if attr == :body
           str << Inspect.inspect_attribute(attr, value, 2)
           if attr == :u8
-            str << shift + Inspect::INSPECT_FMT_ATTR % ['', 'version', version]
-            str << shift + Inspect::INSPECT_FMT_ATTR % ['', 'ihl', ihl]
+            str << shift + Inspect::FMT_ATTR % ['', 'version', version]
+            str << shift + Inspect::FMT_ATTR % ['', 'ihl', ihl]
           elsif attr == :frag
             flags = flag_rsv? ? %w(RSV) : []
             flags << 'DF' if flag_df?
             flags << 'MF' if flag_mf?
             flags_str = flags.empty? ? 'none' : flags.join(',')
-            str << shift + Inspect::INSPECT_FMT_ATTR % ['', 'flags', flags_str]
+            str << shift + Inspect::FMT_ATTR % ['', 'flags', flags_str]
             foff = Inspect.int_dec_hex(fragment_offset, 4)
-            str << shift + Inspect::INSPECT_FMT_ATTR % ['', 'frag_offset', foff]
+            str << shift + Inspect::FMT_ATTR % ['', 'frag_offset', foff]
           end
         end
         str

data/lib/packetgen/header/ipv6.rb

@@ -206,11 +206,11 @@ module PacketGen
           str << Inspect.inspect_attribute(attr, value, 2)
           if attr == :u32
             shift = Inspect.shift_level(2)
-            str << shift + Inspect::INSPECT_FMT_ATTR % ['', 'version', version]
+            str << shift + Inspect::FMT_ATTR % ['', 'version', version]
             tclass = Inspect.int_dec_hex(traffic_class, 2)
-            str << shift + Inspect::INSPECT_FMT_ATTR % ['', 'tclass', tclass]
+            str << shift + Inspect::FMT_ATTR % ['', 'tclass', tclass]
             fl_value = Inspect.int_dec_hex(flow_label, 5)
-            str << shift + Inspect::INSPECT_FMT_ATTR % ['', 'flow_label', fl_value]
+            str << shift + Inspect::FMT_ATTR % ['', 'flow_label', fl_value]
           end
         end
         str

data/lib/packetgen/header/snmp.rb

@@ -0,0 +1,283 @@
+# coding: utf-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.
+
+module PacketGen
+  module Header
+
+    # Dissect error
+    class DissectError < ParseError; end
+
+    # Simple Network Management Protocol (SNMP)
+    # @author Sylvain Daubert
+    # @since 2.0.0
+    class SNMP < ASN1Base
+
+      # Agents listen to this port
+      UDP_PORT1 = 161
+      # Configuration sinks listen to this port
+      UDP_PORT2 = 162
+
+      PDU_GET      = 0
+      PDU_NEXT     = 1
+      PDU_RESPONSE = 2
+      PDU_SET      = 3
+      PDU_TRAPv1   = 4
+      PDU_BULK     = 5
+      PDU_INFORM   = 6
+      PDU_TRAPv2   = 7
+      PDU_REPORT   = 8
+
+      ERRORS = { 'no_error'              => 0,
+                 'too_big'               => 1,
+                 'no_such_name'          => 2,
+                 'bad_value'             => 3,
+                 'read_only'             => 4,
+                 'generic_error'         => 5,
+                 'no_access'             => 6,
+                 'wrong_type'            => 7,
+                 'wrong_length'          => 8,
+                 'wrong_encoding'        => 9,
+                 'wrong_value'           => 10,
+                 'no_creation'           => 11,
+                 'inconsistent_value'    => 12,
+                 'ressource_unavailable' => 13,
+                 'commit_failed'         => 14,
+                 'undo_failed'           => 15,
+                 'authorization_error'   => 16,
+                 'not_writable'          => 17,
+                 'inconsistent_name'     => 18
+               }
+
+      # Class to handle SNMP VarBind
+      #  VarBind ::= SEQUENCE {
+      #                name  OBJECT IDENTIFIER,
+      #                value ANY     -- depends on name
+      #              }
+      # @author Sylvain Daubert
+      class VarBind < RASN1::Model
+        sequence :varbind,
+                 content: [objectid(:name),
+                           any(:value)]
+      end
+
+      # Class to handle SNMP VariableBindingsList
+      #  VarBindList ::= SEQUENCE (SIZE (0..max-bindings)) OF VarBind
+      # @author Sylvain Daubert
+      class VariableBindings < RASN1::Model
+        sequence_of :bindings, VarBind
+      end
+
+      # Class to handle GetRequest PDU
+      #  GetRequest-PDU ::= [0] IMPLICIT PDU
+      #  
+      #  PDU ::= SEQUENCE {
+      #              request-id INTEGER (-214783648..214783647),
+      #  
+      #              error-status                -- sometimes ignored
+      #                  INTEGER {
+      #                      noError(0),
+      #                      tooBig(1),
+      #                      noSuchName(2),      -- for proxy compatibility
+      #                      badValue(3),        -- for proxy compatibility
+      #                      readOnly(4),        -- for proxy compatibility
+      #                      genErr(5),
+      #                      noAccess(6),
+      #                      wrongType(7),
+      #                      wrongLength(8),
+      #                      wrongEncoding(9),
+      #                      wrongValue(10),
+      #                      noCreation(11),
+      #                      inconsistentValue(12),
+      #                      resourceUnavailable(13),
+      #                      commitFailed(14),
+      #                      undoFailed(15),
+      #                      authorizationError(16),
+      #                      notWritable(17),
+      #                      inconsistentName(18)
+      #                  },
+      #          
+      #              error-index                 -- sometimes ignored
+      #                  INTEGER (0..max-bindings),
+      #          
+      #              variable-bindings           -- values are sometimes ignored
+      #                  VarBindList
+      #          }
+      # @author Sylvain Daubert
+      class GetRequest < RASN1::Model
+        sequence :pdu,
+                 implicit: SNMP::PDU_GET, constructed: true,
+                 content: [integer(:id, value: 0),
+                           enumerated(:error, enum: ERRORS),
+                           integer(:error_index),
+                           model(:varbindlist, VariableBindings)]
+
+        # @return [String]
+        def inspect
+          Inspect.inspect_body(to_der, self.class)
+        end
+      end
+
+      # Class to handle GetNextRequest PDU
+      #  GetNextRequest-PDU ::= [1] IMPLICIT PDU   -- PDU definition: see GetRequest
+      # @author Sylvain Daubert
+      class GetNextRequest < GetRequest
+        root_options implicit: SNMP::PDU_NEXT
+      end
+
+      # Class to handle GetResponse PDU
+      #  GetResponse-PDU ::= [2] IMPLICIT PDU   -- PDU definition: see GetRequest
+      # @author Sylvain Daubert
+      class GetResponse < GetRequest
+        root_options implicit: SNMP::PDU_RESPONSE
+      end
+
+      # Class to handle SetRequest PDU
+      #  SetRequest-PDU ::= [3] IMPLICIT PDU   -- PDU definition: see GetRequest
+      # @author Sylvain Daubert
+      class SetRequest < GetRequest
+        root_options implicit: SNMP::PDU_GET
+      end
+
+      # Class to handle Trap from SNMPv1
+      #  Trap-PDU ::= [4] IMPLICIT SEQUENCE {
+      #                          enterprise OBJECT IDENTIFIER,
+      #                          agent-addr NetworkAddress,
+      #                          generic-trap      -- generic trap type
+      #                              INTEGER {
+      #                                  coldStart(0),
+      #                                  warmStart(1),
+      #                                  linkDown(2),
+      #                                  linkUp(3),
+      #                                  authenticationFailure(4),
+      #                                  egpNeighborLoss(5),
+      #                                  enterpriseSpecific(6)
+      #                              },
+      #                          specific-trap INTEGER,
+      #                          time-stamp TimeTicks,
+      #                          variable-bindings VarBindList
+      #                   }
+      class Trapv1 < RASN1::Model
+        sequence :trap,
+                 implicit: SNMP::PDU_TRAPv1, constructed: true,
+                 content: [objectid(:enterprise),
+                           octet_string(:agent_addr),
+                           enumerated(:generic_trap, enum: { 'cold_start'        => 0,
+                                                             'warm_start'        => 1,
+                                                             'link_down'         => 2,
+                                                             'link_up'           => 3,
+                                                             'auth_failure'      => 4,
+                                                             'egp_neighbor_loss' => 5,
+                                                             'specific'          => 6 }),
+                           integer(:specific_trap),
+                           integer(:timestamp),
+                           model(:varbindlist, VariableBindings)]
+      end
+
+      # Class to handle Bulk PDU
+      #  GetBulkRequest-PDU ::= [5] IMPLICIT BulkPDU
+      #  
+      #  BulkPDU ::=                         -- must be identical in
+      #        SEQUENCE {                    -- structure to PDU
+      #            request-id      INTEGER (-214783648..214783647),
+      #            non-repeaters   INTEGER (0..max-bindings),
+      #            max-repetitions INTEGER (0..max-bindings),
+      #            variable-bindings           -- values are ignored
+      #                VarBindList
+      #        }
+      # @author Sylvain Daubert
+      class Bulk < RASN1::Model
+        sequence :bulkpdu,
+                 implicit: SNMP::PDU_BULK, constructed: true,
+                 content: [integer(:id, value: 0),
+                           integer(:non_repeaters),
+                           integer(:max_repetitions),
+                           model(:varbindlist, VariableBindings)]
+
+        # @return [String]
+        def inspect
+          Inspect.inspect_body(to_der, self.class)
+        end
+      end
+
+      # Class to handle InformRequest PDU
+      #  InformRequest-PDU ::= [6] IMPLICIT PDU   -- PDU definition: see GetRequest
+      # @author Sylvain Daubert
+      class InformRequest < GetRequest
+        root_options implicit: SNMP::PDU_INFORM
+      end
+
+      # Class to handle Trapv2 PDU
+      #  SNMPv2-Trap-PDU ::= [7] IMPLICIT PDU   -- PDU definition: see GetRequest
+      # @author Sylvain Daubert
+      class Trapv2 < GetRequest
+        root_options implicit: SNMP::PDU_TRAPv2
+      end
+
+      # Class to handle Report PDU
+      #  Report-PDU ::= [8] IMPLICIT PDU   -- PDU definition: see GetRequest
+      # @author Sylvain Daubert
+      class Report < GetRequest
+        root_options implicit: SNMP::PDU_REPORT
+      end
+
+      # Class to handle PDUs from SNMP packet
+      #  PDUs ::= CHOICE {
+      #             get-request      [0] IMPLICIT PDU,
+      #             get-next-request [1] IMPLICIT PDU,
+      #             get-response     [2] IMPLICIT PDU,
+      #             set-request      [3] IMPLICIT PDU,
+      #             snmpV1-trap      [4] IMPLICIT PDU,
+      #             get-bulk-request [5] IMPLICIT PDU,
+      #             inform-request   [6] IMPLICIT PDU,
+      #             snmpV2-trap      [7] IMPLICIT PDU,
+      #             report           [8] IMPLICIT PDU
+      #           }
+      # @author Sylvain Daubert
+      class PDUs < RASN1::Model
+        choice :pdus,
+               content: [model(:get_request, GetRequest),
+                         model(:get_next_request, GetNextRequest),
+                         model(:get_response, GetResponse),
+                         model(:set_request, SetRequest),
+                         #model(:trapv1, Trapv1),
+                         model(:bulk, Bulk),
+                         model(:inform, InformRequest),
+                         model(:trapv2, Trapv2),
+                         model(:report, Report)]
+      end
+
+      sequence :message,
+               content: [enumerated(:version, value: 'v2c',
+                                    enum: { 'v1' => 0, 'v2c' => 1, 'v2' => 2, 'v3' => 3 }),
+                         octet_string(:community, value: 'public'),
+                         model(:data, PDUs)]
+
+      define_attributes :version, :community
+
+      # accessor to data payload
+      # @return [GetRequest]
+      def data
+        @elements[:data]
+      end
+
+      def inspect
+        str = super
+        str << Inspect.shift_level(2)
+        if self[:data].chosen.nil?
+          str << Inspect::FMT_ATTR % [self[:data].type, :data, '']
+        else
+          data = self[:data]
+          str << Inspect::FMT_ATTR % [data.type, :data, data.chosen_value.type]
+          str << data.chosen_value.inspect
+        end
+      end
+    end
+
+    self.add_class SNMP
+    UDP.bind_header SNMP, dport: SNMP::UDP_PORT1, sport: SNMP::UDP_PORT1
+    UDP.bind_header SNMP, dport: SNMP::UDP_PORT2, sport: SNMP::UDP_PORT2
+  end
+end

data/lib/packetgen/header/tcp.rb

@@ -217,13 +217,13 @@ module PacketGen
           str << Inspect.inspect_attribute(attr, value, 2)
           if attr == :u16
             doff = Inspect.int_dec_hex(data_offset, 1)
-            str << shift + Inspect::INSPECT_FMT_ATTR % ['', 'data_offset', doff]
-            str << shift + Inspect::INSPECT_FMT_ATTR % ['', 'reserved', reserved]
+            str << shift + Inspect::FMT_ATTR % ['', 'data_offset', doff]
+            str << shift + Inspect::FMT_ATTR % ['', 'reserved', reserved]
             flags = ''
             %w(ns cwr ece urg ack psh rst syn fin).each do |fl|
               flags << (send("flag_#{fl}?") ? fl[0].upcase : '.')
             end
-            str << shift + Inspect::INSPECT_FMT_ATTR % ['', 'flags', flags]
+            str << shift + Inspect::FMT_ATTR % ['', 'flags', flags]
           end
         end
         str

data/lib/packetgen/inspect.rb

@@ -6,10 +6,10 @@ module PacketGen
   module Inspect
 
     # Maximum number of characters on a line for INSPECT
-    INSPECT_MAX_WIDTH = 70
+    MAX_WIDTH = 70
 
     # Format to inspect attribute
-    INSPECT_FMT_ATTR = "%10s %12s: %s\n"
+    FMT_ATTR = "%12s %12s: %s\n"
 
     # Create a dashed line with +obj+ class writing in it
     # @param [String] name
@@ -17,7 +17,7 @@ module PacketGen
     # @return [String]
     def self.dashed_line(name, level=1)
       str = '--' * level << " #{name} "
-      str << '-' * (INSPECT_MAX_WIDTH - str.length) << "\n"
+      str << '-' * (MAX_WIDTH - str.length) << "\n"
     end
 
     # @return [String]
@@ -44,23 +44,49 @@ module PacketGen
     # @return [String]
     def self.inspect_attribute(attr, value, level=1)
       str = shift_level(level)
-      val = if value.is_a? Types::Int
+      val = if value.is_a?(Types::Int) or value.is_a?(Integer)
               int_dec_hex(value, value.to_s.size * 2)
             elsif value.respond_to? :to_human
               value.to_human
             else
               value.to_s.inspect
             end
-      str << INSPECT_FMT_ATTR % [value.class.to_s.sub(/.*::/, ''), attr, val]
+      str << FMT_ATTR % [value.class.to_s.sub(/.*::/, ''), attr, val]
+    end
+
+    # Format a ASN.1 attribute for +#inspect+.
+    # 3 cases are handled:
+    # * attribute value is a {Types::Int}: show value as integer and in
+    #   hexdecimal format,
+    # * attribute value responds to +#to_human+: call it,
+    # * else, +#to_s+ is used to format attribute value.
+    # @param [Symbol] name attribute name
+    # @param [RASN1::Types::Base,RASN1::Model] attr attribute
+    # @param [Integer] level
+    # @return [String]
+    def self.inspect_asn1_attribute(name, attr, level=1)
+      str = shift_level(level)
+      val = case attr
+            when RASN1::Types::Enumerated
+              hexsize = attr.value_size * 2
+              "%-10s (0x%0#{hexsize}x)" % [attr.value, attr.to_i]
+            when RASN1::Types::Integer
+              int_dec_hex(attr.value, attr.value_size * 2)
+            when RASN1::Model
+              attr.root.type
+            else
+              attr.value.to_s.inspect
+            end
+      str << FMT_ATTR % [attr.type, name, val]
     end
 
     # @param [#to_s] body
     # @return [String]
-    def self.inspect_body(body)
+    def self.inspect_body(body, name='Body')
       return '' if body.nil? or body.empty?
-      str = dashed_line('Body', 2)
+      str = dashed_line(name, 2)
       str << (0..15).to_a.map { |v| " %02d" % v}.join << "\n"
-      str << '-' * INSPECT_MAX_WIDTH << "\n"
+      str << '-' * MAX_WIDTH << "\n"
       if body.size > 0
         (body.size / 16 + 1).times do |i|
           octets = body.to_s[i*16, 16].unpack('C*')
@@ -71,7 +97,7 @@ module PacketGen
           str << "\n"
         end
       end
-      str << '-' * INSPECT_MAX_WIDTH << "\n"
+      str << '-' * MAX_WIDTH << "\n"
     end
   end
 end