rasn1 0.12.0 → 0.12.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 552859c3f49caec5374c8db4459ad23e1f9c43e930b0d6511cab8f997c798d20
-  data.tar.gz: 29eaf2fc529b470c9bc6283efbaf82e580d5b4b86d5c46920ee4a882a18b0d72
+  metadata.gz: 884fa6f74d0b3074ef074d061301092d55df580b663714c4a962a7b8503d777d
+  data.tar.gz: 77cc3c5d7bf926463464ca4d37237f0cddc358e0d7b9aa3e85c15982ab3f3fc1
 SHA512:
-  metadata.gz: 9e5df0e417db7e1f02accae9cc4f17b4a49975d1dc17b716dbf587bb3f5e8ca68ed842d22358d7de037041255c164df5a92c6ada52adba944f0ac635793a64b1
-  data.tar.gz: e193284ea13ca5f80a460b8b390839a0283a8424ca8201f24cbd6113919399fcd5b83a2fc39dd5b26925187e19930a1aceccb1485255de8301435e20a2c82761
+  metadata.gz: fee544874a10b10618cd596b1c30edd4ad70185a783eeadbe23a86fa2439339d7d025784be5adc76904e05856ac8791817a768c0603ece0141e38d2975e588ad
+  data.tar.gz: 39428eb166401712d44eb60c4413bcd919d4fca380213acbe1dc29c32425c03a8852e1f0afa8934f5a04c604b376ac3c47424754b358cae96cc685029c467da7

data/lib/rasn1/errors.rb

@@ -18,7 +18,7 @@ module RASN1
   # Enumerated error
   class EnumeratedError < Error; end
 
-  # CHOICE error: #chosen not set
+  # CHOICE error: {Types::Choice#chosen} not set
   class ChoiceError < RASN1::Error
     # @param [Types::Base] object
     def initialize(object)
@@ -26,6 +26,7 @@ module RASN1
       super()
     end
 
+    # @return [String]
     def message
       "CHOICE #{@object.name}: #chosen not set"
     end

data/lib/rasn1/model.rb

@@ -66,6 +66,9 @@ module RASN1
   class Model # rubocop:disable Metrics/ClassLength
     # @private
     Elem = Struct.new(:name, :proc_or_class, :content) do
+      # @param [String,Symbol] name
+      # @param [Proc,Class] proc_or_class
+      # @param [Hash,nil] content
       def initialize(name, proc_or_class, content)
         if content.is_a?(Array)
           duplicate_names = find_all_duplicate_names(content.map(&:name) + [name])
@@ -88,11 +91,13 @@ module RASN1
 
     # @private
     WrapElem = Struct.new(:element, :options) do
+      # @return [String]
       def name
         "#{element.name}_wrapper"
       end
     end
 
+    # Define helper methods to define models
     module Accel
       # @return [Hash]
       attr_reader :options
@@ -145,6 +150,9 @@ module RASN1
         klass.class_eval { @root = root }
       end
 
+      # @private
+      # @param [String,Symbol] accel_name
+      # @param [Class] klass
       # @since 0.11.0
       # @since 0.12.0 track source location on error (adfoster-r7)
       def define_type_accel_base(accel_name, klass)
@@ -159,6 +167,9 @@ module RASN1
         EVAL
       end
 
+      # @private
+      # @param [String,Symbol] accel_name
+      # @param [Class] klass
       # @since 0.11.0
       # @since 0.12.0 track source location on error (adfoster-r7)
       def define_type_accel_of(accel_name, klass)
@@ -175,8 +186,9 @@ module RASN1
 
       # Define an accelarator to access a type in a model definition
       # @param [String] accel_name
-      # @param [Class] klass
+      # @param [Class] klass class to instanciate
       # @since 0.11.0
+      # @since 0.12.0 track source location on error (adfoster-r7)
       def define_type_accel(accel_name, klass)
         if klass < Types::SequenceOf
           define_type_accel_of(accel_name, klass)

data/lib/rasn1/tracer.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module RASN1
+  # @private
+  class Tracer
+    # @return [IO]
+    attr_reader :io
+    # @return [Integer]
+    attr_accessor :tracing_level
+
+    TRACED_CLASSES = [Types::Any, Types::Choice, Types::Sequence, Types::SequenceOf, Types::Base].freeze
+
+    # @param [IO] io
+    def initialize(io)
+      @io = io
+      @tracing_level = 0
+    end
+
+    # Puts +msg+ onto {#io}.
+    # @param [String] msg
+    # @return [void]
+    def trace(msg)
+      @io.puts(indent << msg)
+    end
+
+    # Return identation for given +level+. If +nil+, use {#tracing_level}.
+    # @param [Integer,nil] level
+    # @return [String]
+    def indent(level=nil)
+      level ||= @tracing_level
+      '  ' * level
+    end
+  end
+
+  # Trace RASN1 parsing to +io+.
+  # All parsing methods called in block are traced to +io+. Each ASN.1 element is
+  # traced in a line showing element's id, its length and its data.
+  # @param [IO] io
+  # @example
+  #   RASN1.trace do
+  #     RASN1.parse("\x02\x01\x01")  # puts "INTEGER id: 2 (0x02), len: 1 (0x01), data: 0x01"
+  #   end
+  #   RASN1.parse("\x01\x01\xff")    # puts nothing onto STDOUT
+  # @return [void]
+  def self.trace(io=$stdout)
+    @tracer = Tracer.new(io)
+    Tracer::TRACED_CLASSES.each(&:start_tracing)
+
+    begin
+      yield @tracer
+    ensure
+      Tracer::TRACED_CLASSES.reverse.each(&:stop_tracing)
+      @tracer.io.flush
+      @tracer = nil
+    end
+  end
+
+  # @private
+  def self.tracer
+    @tracer
+  end
+
+  module Types
+    class Base
+      class << self
+        # @private
+        # Patch {#do_parse} to add tracing ability
+        def start_tracing
+          alias_method :do_parse_without_tracing, :do_parse
+          alias_method :do_parse, :do_parse_with_tracing
+          alias_method :do_parse_explicit_without_tracing, :do_parse_explicit
+          alias_method :do_parse_explicit, :do_parse_explicit_with_tracing
+        end
+
+        # @private
+        # Unpatch {#do_parse} to remove tracing ability
+        def stop_tracing
+          alias_method :do_parse, :do_parse_without_tracing # rubocop:disable Lint/DuplicateMethods
+          alias_method :do_parse_explicit, :do_parse_explicit_without_tracing # rubocop:disable Lint/DuplicateMethods
+        end
+      end
+
+      # @private
+      # Parse +der+ with tracing abillity
+      # @see #parse!
+      def do_parse_with_tracing(der, ber)
+        ret = do_parse_without_tracing(der, ber)
+        RASN1.tracer.trace(self.trace)
+        ret
+      end
+
+      def do_parse_explicit_with_tracing(data)
+        RASN1.tracer.tracing_level += 1
+        do_parse_explicit_without_tracing(data)
+        RASN1.tracer.tracing_level -= 1
+      end
+    end
+
+    class Choice
+      class << self
+        # @private
+        # Patch {#parse!} to add tracing ability
+        def start_tracing
+          alias_method :parse_without_tracing, :parse!
+          alias_method :parse!, :parse_with_tracing
+        end
+
+        # @private
+        # Unpatch {#parse!} to remove tracing ability
+        def stop_tracing
+          alias_method :parse!, :parse_without_tracing # rubocop:disable Lint/DuplicateMethods
+        end
+      end
+
+      # @private
+      # Parse +der+ with tracing abillity
+      # @see #parse!
+      def parse_with_tracing(der, ber: false)
+        RASN1.tracer.trace(self.trace)
+        parse_without_tracing(der, ber: ber)
+      end
+    end
+
+    class Sequence
+      class << self
+        # @private
+        # Patch {#der_to_value} to add tracing ability
+        def start_tracing
+          alias_method :der_to_value_without_tracing, :der_to_value
+          alias_method :der_to_value, :der_to_value_with_tracing
+        end
+
+        # @private
+        # Unpatch {#der_to_value!} to remove tracing ability
+        def stop_tracing
+          alias_method :der_to_value, :der_to_value_without_tracing # rubocop:disable Lint/DuplicateMethods
+        end
+      end
+
+      # @private
+      # der_to_value +der+ with tracing abillity
+      def der_to_value_with_tracing(der, ber: false)
+        RASN1.tracer.tracing_level += 1
+        der_to_value_without_tracing(der, ber: ber)
+        RASN1.tracer.tracing_level -= 1
+      end
+    end
+
+    class SequenceOf
+      class << self
+        # @private
+        # Patch {#der_to_value} to add tracing ability
+        def start_tracing
+          alias_method :der_to_value_without_tracing, :der_to_value
+          alias_method :der_to_value, :der_to_value_with_tracing
+        end
+
+        # @private
+        # Unpatch {#der_to_value!} to remove tracing ability
+        def stop_tracing
+          alias_method :der_to_value, :der_to_value_without_tracing # rubocop:disable Lint/DuplicateMethods
+        end
+      end
+
+      # @private
+      # der_to_value +der+ with tracing abillity
+      def der_to_value_with_tracing(der, ber: false)
+        RASN1.tracer.tracing_level += 1
+        der_to_value_without_tracing(der, ber: ber)
+        RASN1.tracer.tracing_level -= 1
+      end
+    end
+  end
+end

data/lib/rasn1/types/any.rb

@@ -31,22 +31,12 @@ module RASN1
       # @param [Boolean] ber if +true+, accept BER encoding
       # @return [Integer] total number of parsed bytes
       def parse!(der, ber: false)
-        if der.empty?
-          return 0 if optional?
-
-          raise ASN1Error, 'Expected ANY but get nothing'
-        end
-
-        id_size = Types.decode_identifier_octets(der).last
-        total_length, = get_data(der[id_size..-1], ber)
-        total_length += id_size
-
-        @no_value = false
-        @value = der[0, total_length]
-
+        total_length, _data = do_parse(der, ber)
         total_length
       end
 
+      # @param [::Integer] level
+      # @return [String]
       def inspect(level=0)
         str = common_inspect(level)
         str << if !value?
@@ -60,6 +50,16 @@ module RASN1
                end
       end
 
+      # @private Tracer private API
+      # @return [String]
+      def trace
+        return trace_any if value?
+
+        msg_type(no_id: true) << ' NONE'
+      end
+
+      private
+
       def common_inspect(level)
         lvl = level >= 0 ? level : 0
         str = '  ' * lvl
@@ -69,6 +69,27 @@ module RASN1
         str << "[#{id}] IMPLICIT " if implicit?
         str << '(ANY) '
       end
+
+      def do_parse(der, ber)
+        if der.empty?
+          return [0, ''] if optional?
+
+          raise ASN1Error, 'Expected ANY but get nothing'
+        end
+
+        id_size = Types.decode_identifier_octets(der).last
+        total_length, = get_data(der[id_size..-1], ber)
+        total_length += id_size
+
+        @no_value = false
+        @value = der[0, total_length]
+
+        [total_length, @value]
+      end
+
+      def trace_any
+        msg_type(no_id: true) << trace_data(value)
+      end
     end
   end
 end

data/lib/rasn1/types/base.rb

@@ -71,6 +71,12 @@ module RASN1
       attr_reader :default
       # @return [Hash[Symbol, Object]]
       attr_reader :options
+      # @return [String] raw parsed data
+      attr_reader :raw_data
+      # @return [String] raw parsed length
+      attr_reader :raw_length
+
+      private :raw_data, :raw_length
 
       # Get ASN.1 type
       # @return [String]
@@ -121,13 +127,16 @@ module RASN1
         set_value(options.delete(:value))
         self.options = options
         specific_initializer
+        @raw_data = ''.b
+        @raw_length = ''.b
       end
 
       # @abstract To help subclass initialize itself. Default implementation do nothing.
       def specific_initializer; end
 
-      # Used by +#dup+ and +#clone+. Deep copy @value and @default.
-      def initialize_copy(_other)
+      # Deep copy @value and @default.
+      def initialize_copy(*)
+        super
         @value = @value.dup
         @no_value = @no_value.dup
         @default = @default.dup
@@ -153,6 +162,7 @@ module RASN1
         ''
       end
 
+      # Say if this type is optional
       # @return [::Boolean]
       def optional?
         @optional
@@ -215,17 +225,11 @@ module RASN1
       # @return [Integer] total number of parsed bytes
       # @raise [ASN1Error] error on parsing
       def parse!(der, ber: false)
-        return 0 unless check_id(der)
+        total_length, data = do_parse(der, ber)
+        return 0 if total_length.zero?
 
-        id_size = Types.decode_identifier_octets(der).last
-        total_length, data = get_data(der[id_size..-1], ber)
-        total_length += id_size
-        @no_value = false
         if explicit?
-          # Delegate to #explicit type to generate sub-value
-          type = explicit_type
-          type.parse!(data)
-          @value = type.value
+          do_parse_explicit(data)
         else
           der_to_value(data, ber: ber)
         end
@@ -283,8 +287,82 @@ module RASN1
         value? && (@default.nil? || (@value != @default))
       end
 
+      # @private Tracer private API
+      # @return [String]
+      def trace
+        return trace_real if value?
+
+        msg = msg_type
+        if default.nil? # rubocop:disable Style/ConditionalAssignment
+          msg << ' NONE'
+        else
+          msg << " DEFAULT VALUE #{default}"
+        end
+      end
+
       private
 
+      def trace_real
+        encoded_id = unpack(encode_identifier_octets)
+        data_length = raw_data.length
+        encoded_length = unpack(raw_length)
+        msg = msg_type
+        msg << " (0x#{encoded_id}),"
+        msg << " len: #{data_length} (0x#{encoded_length})"
+        msg << trace_data
+      end
+
+      def trace_data(data=nil)
+        byte_count = 0
+        data ||= raw_data
+
+        lines = []
+        str = ''
+        data.each_byte do |byte|
+          if (byte_count % 16).zero?
+            str = trace_format_new_data_line(byte_count)
+            lines << str
+          end
+          str[compute_trace_index(byte_count, 3), 2] = '%02x' % byte
+          str[compute_trace_index(byte_count, 1, 49)] = byte >= 32 && byte <= 126 ? byte.chr : '.'
+          byte_count += 1
+        end
+        lines.map(&:rstrip).join << "\n"
+      end
+
+      def trace_format_new_data_line(count)
+        head_line = RASN1.tracer.indent(RASN1.tracer.tracing_level + 1)
+        ("\n#{head_line}%04x " % count) << ' ' * 68
+      end
+
+      def compute_trace_index(byte_count, byte_count_mul=1, offset=0)
+        base_idx = 7 + RASN1.tracer.indent(RASN1.tracer.tracing_level + 1).length
+        base_idx + offset + (byte_count % 16) * byte_count_mul
+      end
+
+      def unpack(binstr)
+        binstr.unpack1('H*')
+      end
+
+      def asn1_class_to_s
+        asn1_class == :universal ? '' : asn1_class.to_s.upcase << ' '
+      end
+
+      def msg_type(no_id: false)
+        msg = name.nil? ? +'' : +"#{name} "
+        msg << "[ #{asn1_class_to_s}#{id} ] " unless no_id
+        msg << if explicit?
+                 +'EXPLICIT '
+               elsif implicit?
+                 +'IMPLICIT '
+               else
+                 +''
+               end
+        msg << type
+        msg << ' OPTIONAL' if optional?
+        msg
+      end
+
       def pc_bit
         if @constructed.nil?
           self.class.const_get(:ASN1_PC)
@@ -299,7 +377,7 @@ module RASN1
         lvl = level >= 0 ? level : 0
         str = '  ' * lvl
         str << "#{@name} " unless @name.nil?
-        str << asn1_class.to_s.upcase << ' ' unless asn1_class == :universal
+        str << asn1_class_to_s
         str << "[#{id}] EXPLICIT " if explicit?
         str << "[#{id}] IMPLICIT " if implicit?
         str << "#{type}:"
@@ -313,6 +391,24 @@ module RASN1
         end
       end
 
+      def do_parse(der, ber)
+        return [0, ''] unless check_id(der)
+
+        id_size = Types.decode_identifier_octets(der).last
+        total_length, data = get_data(der[id_size..-1], ber)
+        total_length += id_size
+        @no_value = false
+
+        [total_length, data]
+      end
+
+      def do_parse_explicit(data)
+        # Delegate to #explicit type to generate sub-value
+        type = explicit_type
+        type.parse!(data)
+        @value = type.value
+      end
+
       def value_to_der
         case @value
         when Base
@@ -454,6 +550,21 @@ module RASN1
       end
 
       def get_data(der, ber)
+        return [0, ''] if der.nil? || der.empty?
+
+        length, length_length = get_length(der, ber)
+
+        data = der[1 + length_length, length]
+        @raw_length = der[0, length_length + 1]
+        @raw_data = data
+
+        total_length = 1 + length
+        total_length += length_length if length_length.positive?
+
+        [total_length, data]
+      end
+
+      def get_length(der, ber)
         length = der.unpack1('C').to_i
         length_length = 0
 
@@ -464,12 +575,8 @@ module RASN1
           length = der[1, length_length].unpack('C*')
                                         .reduce(0) { |len, b| (len << 8) | b }
         end
-        data = der[1 + length_length, length]
 
-        total_length = 1 + length
-        total_length += length_length if length_length.positive?
-
-        [total_length, data]
+        [length, length_length]
       end
 
       def raise_on_indefinite_length(ber)
@@ -484,7 +591,7 @@ module RASN1
       end
 
       def explicit_type
-        self.class.new
+        self.class.new(name: name)
       end
 
       def raise_id_error(der)
@@ -493,10 +600,6 @@ module RASN1
         raise ASN1Error, msg
       end
 
-      def class_from_numeric_id(id)
-        CLASSES.key(id & CLASS_MASK)
-      end
-
       def self2name
         name = +"#{asn1_class.to_s.upcase} #{constructed? ? 'CONSTRUCTED' : 'PRIMITIVE'}"
         if implicit? || explicit?

data/lib/rasn1/types/bit_string.rb

@@ -8,7 +8,6 @@ module RASN1
       # BitString id value
       ID = 3
 
-      # @param [Integer] bit_length
       # @return [Integer]
       attr_writer :bit_length
 
@@ -42,6 +41,9 @@ module RASN1
         str << " #{value.inspect} (bit length: #{bit_length})"
       end
 
+      # Same as {Base#can_build?} but also check bit_length
+      # @see Base#can_build?
+      # @return [Boolean]
       def can_build?
         super || (!@default.nil? && (@bit_length != @default_bit_length))
       end
@@ -86,7 +88,7 @@ module RASN1
       end
 
       def explicit_type
-        self.class.new(value: @value, bit_length: @bit_length)
+        self.class.new(name: name, value: @value, bit_length: @bit_length)
       end
     end
   end

data/lib/rasn1/types/boolean.rb

@@ -39,6 +39,12 @@ module RASN1
           @value = true
         end
       end
+
+      def trace_data
+        return super if explicit?
+
+        "    #{raw_data == "\x00".b ? 'FALSE' : 'TRUE'} (0x#{raw_data.unpack1('H*')})"
+      end
     end
   end
 end

data/lib/rasn1/types/choice.rb

@@ -88,6 +88,8 @@ module RASN1
         raise ASN1Error, "CHOICE #{@name}: no type matching #{der.inspect}" unless parsed
       end
 
+      # @param [::Integer] level
+      # @return [String]
       def inspect(level=0)
         str = common_inspect(level)
         str << if defined? @chosen
@@ -97,6 +99,12 @@ module RASN1
                end
       end
 
+      # @private Tracer private API
+      # @return [String]
+      def trace
+        msg_type(no_id: true)
+      end
+
       private
 
       def check_chosen

data/lib/rasn1/types/constrained.rb

@@ -2,11 +2,12 @@
 
 module RASN1
   module Types
-    # Mixin to had constraints on a RASN1 type.
+    # Mixin to add constraints on a RASN1 type.
     # Should not be used directly but through {Types.define_type}.
     # @version 0.11.0
     # @author Sylvain Daubert
     module Constrained
+      # Define class/module methods for {Constrained} module
       module ClassMethods
         # Setter for constraint
         # @param [Proc,nil] constraint
@@ -31,8 +32,10 @@ module RASN1
       end
 
       class << self
+        # @return [Proc] proc to check constraints
         attr_reader :constraint
 
+        # Extend +base+ with {ClassMethods}
         def included(base)
           base.extend ClassMethods
         end
@@ -46,6 +49,8 @@ module RASN1
         super
       end
 
+      private
+
       def der_to_value(der, ber: false)
         super
         self.class.check_constraint(@value)

data/lib/rasn1/types/generalized_time.rb

@@ -134,6 +134,12 @@ module RASN1
           raise ASN1Error, "#{prefix}: unrecognized format: #{date_hour}"
         end
       end
+
+      def trace_data
+        return super if explicit?
+
+        +'    ' << raw_data
+      end
     end
   end
 end

data/lib/rasn1/types/integer.rb

@@ -20,7 +20,7 @@ module RASN1
         initialize_enum(@options[:enum])
       end
 
-      # @param [Integer,String,Symbol,nil] v
+      # @param [Integer,String,Symbol,nil] val
       # @return [void]
       def value=(val)
         @no_value = false
@@ -128,18 +128,29 @@ module RASN1
         v
       end
 
+      def int_to_enum(int, check_enum: true)
+        raise EnumeratedError, "#{@name}: value #{int} not in enumeration" if check_enum && !@enum.value?(int)
+
+        @enum.key(int) || int
+      end
+
       def der_to_value(der, ber: false)
         @value = der_to_int_value(der, ber: ber)
         return if @enum.empty?
 
-        int_value = @value
-        raise EnumeratedError, "#{@name}: value #{int_value} not in enumeration" unless @enum.value?(@value)
-
-        @value = @enum.key(@value)
+        @value = int_to_enum(@value)
       end
 
       def explicit_type
-        self.class.new(name: @name, enum: @enum)
+        self.class.new(name: name, enum: enum)
+      end
+
+      def trace_data
+        return super if explicit?
+        return "    #{der_to_int_value(raw_data)} (0x#{raw_data.unpack1('H*')})" if @enum.empty?
+
+        v = int_to_enum(der_to_int_value(raw_data), check_enum: false)
+        "    #{v} (0x#{raw_data.unpack1('H*')})"
       end
     end
   end

data/lib/rasn1/types/null.rb

@@ -15,6 +15,8 @@ module RASN1
         str
       end
 
+      # @return [Boolean]
+      # Build only if not optional
       def can_build?
         !optional?
       end

data/lib/rasn1/types/octet_string.rb

@@ -15,6 +15,8 @@ module RASN1
       # OctetString id value
       ID = 4
 
+      # @param [::Integer] level
+      # @return [String]
       def inspect(level=0)
         str = common_inspect(level)
         str << " #{value.inspect}"

data/lib/rasn1/types/sequence.rb

@@ -36,7 +36,8 @@ module RASN1
         @value ||= []
       end
 
-      def initialize_copy(other)
+      # Deep copy @value
+      def initialize_copy(*)
         super
         @value = case @value
                  when Array
@@ -88,8 +89,12 @@ module RASN1
         end
       end
 
+      def trace_data
+        ''
+      end
+
       def explicit_type
-        self.class.new(value: @value)
+        self.class.new(name: name, value: @value)
       end
     end
   end

data/lib/rasn1/types/sequence_of.rb

@@ -67,7 +67,8 @@ module RASN1
         @no_value = false
       end
 
-      def initialize_copy(other)
+      # Clone @#of_type and values
+      def initialize_copy(*)
         super
         @of_type = @of_type.dup
         @value = @value.map(&:dup)
@@ -104,6 +105,7 @@ module RASN1
         @value.length
       end
 
+      # @param [::Integer] level
       # @return [String]
       def inspect(level=0)
         str = common_inspect(level)
@@ -153,7 +155,7 @@ module RASN1
       end
 
       def explicit_type
-        self.class.new(self.of_type)
+        self.class.new(self.of_type, name: name)
       end
 
       def push_primitive(obj)
@@ -188,6 +190,10 @@ module RASN1
           raise ASN1Error, "object to add should be a #{of_type_class} or a Hash"
         end
       end
+
+      def trace_data
+        ''
+      end
     end
   end
 end

data/lib/rasn1/types/utc_time.rb

@@ -46,6 +46,12 @@ module RASN1
         century = (Time.now.year / 100).to_s
         @value = Strptime.new(format).exec(century + der)
       end
+
+      def trace_data
+        return super if explicit?
+
+        +'    ' << raw_data
+      end
     end
   end
 end

data/lib/rasn1/types.rb

@@ -87,8 +87,16 @@ module RASN1
     # @param [Types::Base] from class from which inherits
     # @param [Module] in_module module in which creates new type (default to {RASN1::Types})
     # @return [Class] newly created class
+    # @yieldparam [Object] value value to set to type, or infered at parsing
+    # @yieldreturn [Boolean]
     # @since 0.11.0
     # @since 0.12.0 in_module parameter
+    # @example
+    #   # Define a new UInt32 type
+    #   # UInt32 ::= INTEGER (0 .. 4294967295)
+    #   RASN1::Types.define_type('UInt32', from: RASN1::Types::Integer) do |value|
+    #     (value >= 0) && (value < 2**32)
+    #   end
     def self.define_type(name, from:, in_module: self, &block)
       constraint = block.nil? ? nil : block.to_proc
 

data/lib/rasn1/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RASN1
-  VERSION = '0.12.0'
+  VERSION = '0.12.1'
 end

data/lib/rasn1/wrapper.rb

@@ -14,8 +14,8 @@ module RASN1
   # @example
   #   # object to wrap
   #   int = RASN1::Types::Integer.new(implicit: 1)    # its tag is 0x81
-  #   # simple wraper, change an option
-  #   wrapper = RASN1::Wrapper.new(int, optional: true, default: 1)
+  #   # simple wrapper, change an option
+  #   wrapper = RASN1::Wrapper.new(int, default: 1)
   #   # implicit wrapper
   #   wrapper = RASN1::Wrapper.new(int, implicit: 3)  # wrapped int tag is now 0x83
   #   # explicit wrapper
@@ -70,26 +70,6 @@ module RASN1
       super(element)
     end
 
-    def explicit_implicit(options)
-      opts = options.dup
-      @explicit = opts.delete(:explicit)
-      @implicit = opts.delete(:implicit)
-      opts
-    end
-
-    def generate_explicit_wrapper(options)
-      # ExplicitWrapper is a hand-made explicit tag, but we have to use its implicit option
-      # to force its tag value.
-      @explicit_wrapper = ExplicitWrapper.new(options.merge(implicit: @explicit))
-    end
-
-    def generate_explicit_wrapper_options(options)
-      new_opts = {}
-      new_opts[:default] = options[:default] if options.key?(:default)
-      new_opts[:optional] = options[:optional] if options.key?(:optional)
-      new_opts
-    end
-
     # Say if wrapper is an explicit one (i.e. add tag and length to its element)
     # @return [Boolean]
     def explicit?
@@ -136,6 +116,8 @@ module RASN1
       end
     end
 
+    # @return [Boolean]
+    # @see Types::Base#value?
     def value?
       if explicit?
         @explicit_wrapper.value?
@@ -151,6 +133,7 @@ module RASN1
     end
 
     # @return [::Integer]
+    # @see Types::Base#id
     def id
       if implicit?
         @implicit
@@ -162,6 +145,7 @@ module RASN1
     end
 
     # @return [Symbol]
+    # @see Types::Base#asn1_class
     def asn1_class
       return element.asn1_class unless @options.key?(:class)
 
@@ -169,6 +153,7 @@ module RASN1
     end
 
     # @return [Boolean]
+    # @see Types::Base#constructed
     def constructed?
       return element.constructed? unless @options.key?(:constructed)
 
@@ -176,10 +161,13 @@ module RASN1
     end
 
     # @return [Boolean]
+    # @see Types::Base#primitive
     def primitive?
       !constructed?
     end
 
+    # @param [::Integer] level
+    # @return [String]
     def inspect(level=0)
       return super(level) unless explicit?
 
@@ -188,6 +176,26 @@ module RASN1
 
     private
 
+    def explicit_implicit(options)
+      opts = options.dup
+      @explicit = opts.delete(:explicit)
+      @implicit = opts.delete(:implicit)
+      opts
+    end
+
+    def generate_explicit_wrapper(options)
+      # ExplicitWrapper is a hand-made explicit tag, but we have to use its implicit option
+      # to force its tag value.
+      @explicit_wrapper = ExplicitWrapper.new(options.merge(implicit: @explicit))
+    end
+
+    def generate_explicit_wrapper_options(options)
+      new_opts = {}
+      new_opts[:default] = options[:default] if options.key?(:default)
+      new_opts[:optional] = options[:optional] if options.key?(:optional)
+      new_opts
+    end
+
     def generate_implicit_element
       el = element.dup
       if el.explicit?

data/lib/rasn1.rb

@@ -5,10 +5,14 @@ require_relative 'rasn1/errors'
 require_relative 'rasn1/types'
 require_relative 'rasn1/model'
 require_relative 'rasn1/wrapper'
+require_relative 'rasn1/tracer'
 
 # Rasn1 is a pure ruby library to parse, decode and encode ASN.1 data.
 # @author Sylvain Daubert
 module RASN1
+  # @private
+  CONTAINER_CLASSES = [Types::Sequence, Types::Set].freeze
+
   # Parse a DER/BER string without checking a model
   # @note If you want to check ASN.1 grammary, you should define a {Model}
   #       and use {Model#parse}.
@@ -19,24 +23,21 @@ module RASN1
   # @param [String] der binary string to parse
   # @param [Boolean] ber if +true+, decode a BER string, else a DER one
   # @return [Types::Base]
-  def self.parse(der, ber: false)
-    root = nil
-    until der.empty?
-      type = Types.id2type(der)
-      type.parse!(der, ber: ber)
-      root ||= type
+  def self.parse(der, ber: false) # rubocop:disable Metrics:AbcSize
+    type = Types.id2type(der)
+    type.parse!(der, ber: ber)
 
-      if [Types::Sequence, Types::Set].include? type.class
-        subder = type.value
-        ary = []
-        until subder.empty?
-          ary << self.parse(subder)
-          subder = subder[ary.last.to_der.size..-1]
-        end
-        type.value = ary
+    if CONTAINER_CLASSES.include?(type.class)
+      subder = type.value
+      ary = []
+      RASN1.tracer.tracing_level += 1 unless RASN1.tracer.nil?
+      until subder.empty?
+        ary << self.parse(subder)
+        subder = subder[ary.last.to_der.size..-1]
       end
-      der = der[type.to_der.size..-1]
+      RASN1.tracer.tracing_level -= 1 unless RASN1.tracer.nil?
+      type.value = ary
     end
-    root
+    type
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rasn1
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 0.12.1
 platform: ruby
 authors:
 - Sylvain Daubert
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-11-12 00:00:00.000000000 Z
+date: 2022-12-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: strptime
@@ -40,6 +40,7 @@ files:
 - lib/rasn1.rb
 - lib/rasn1/errors.rb
 - lib/rasn1/model.rb
+- lib/rasn1/tracer.rb
 - lib/rasn1/types.rb
 - lib/rasn1/types/any.rb
 - lib/rasn1/types/base.rb