rasn2 1.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9744f6f89db9eccc56949cfaa1be37d919f1c12cbea2178d8ffd05d6a526e72
-  data.tar.gz: ea3fc33186e718dd636948ba6eeeb915beac90617c1736a265770daeb2a45a15
+  metadata.gz: 0bc40f5198815e03f0bfa923321ac614e68d4587f31b3cb18d999f40e7b49004
+  data.tar.gz: '09ec989aa9f0674cf2f4ed956518bd717a85de33357b7c09cd2fe6a2d2caa9b8'
 SHA512:
-  metadata.gz: 58299aa777a6c80d63c6f8faed939ac638804a7a28a25e83e431a78391564a9138902252b0ebe1ebd7c46a168311f008c5540a23590f905d1c78598ad05bfe31
-  data.tar.gz: 78c1496c6792b9542ab1d76c6134d12cc9cd6e8c4e55c18a62fcb5574ed6d40c7c9179cf5bf66b1f277dc9f27ee507c885fc4d5b3dbd52894d42c409d08b1206
+  metadata.gz: 7739ea22723954d0ee78787697e8dde59bb0b41f6fb3c23c8e34f0cab1bd23720b35e05abffb8ac389141115f598d61cf28ce32ccd7d078169cf16bf0043616c
+  data.tar.gz: e5ef77bb7b20f1bb6819c4935e04a302c58930bc183371b132522c0b245da9e306de8fbcb29653c535c8d6646f991ff990726466937f487a5c7ea0470034a342

data/lib/rasn2/helpers/colorize.rb

@@ -1,44 +1,80 @@
+# frozen_string_literal: true
+
 module RASN2
   module Helpers
     module Colorize
+      def colorizer
+        @colorizer&.first || Rainbow.new
+      end
+
+      def colorizer=(colorizer)
+        @colorizer ||= []
+        @colorizer << colorizer
+      end
+
+      def begin_colorizer(color)
+        @colorizer ||= []
+        @colorizer << Rainbow.new
+        @colorizer.last.enabled = color
+      end
+
+      def colorize(msg)
+        colorizer.wrap(msg)
+      end
+
+      def end_colorizer
+        @colorizer&.pop
+      end
+
       def parens_hex(input, padding=2)
-        input = input.is_a?(Integer) ? ("0x%0#{padding}x")% input : "0x#{input}"
-        "#{colorize('(').webgray}#{colorize(input).blue}#{colorize(')').webgray}"
+        value = if input.is_a?(Integer)
+                  if input >= 0
+                    value = "%0#{padding}X" % input
+                    value = value.rjust((value.length + 1) / 2 * 2, '0')
+                    "0x#{value}"
+                  else
+                    '0xFF'
+                  end
+                else
+                  input
+                end
+        "#{colorize('(').webgray}#{colorize(value).blue}#{colorize(')').webgray}"
       end
 
       def int_with_hex(input, raw_value=nil)
-        if raw_value
-          "#{colorize(input).blue} #{parens_hex(raw_value)}"
-        else
+        if raw_value.nil?
           "#{colorize(input).blue} #{parens_hex(input)}"
+        else
+          "#{colorize(input).blue} #{parens_hex(raw_value)}"
         end
-
       end
 
       def brace_surround(input)
         "#{colorize('[').webgray} #{input} #{colorize(']').webgray}"
       end
 
-      def colorize_class(name, tag_id=nil)
-        if tag_id
-          "#{colorize(name).bold.yellow} #{parens_hex(tag_id)}"
-          else
-        colorize(name).bold.yellow
-        end
+      def colorize_class(name, tag_id=nil, *attributes)
+        parts = [colorize(name).bold.yellow]
+        parts += attributes.map { |attr| colorize_attribute(attr) } if attributes.any?
+        parts << parens_hex(tag_id) if tag_id
+        parts.join(' ')
       end
 
       def colorize_id(id, tag_class=nil)
         id = id.strip if id.is_a? String
         tag_class = tag_class.strip if tag_class.is_a? String
+        tag_class = '' if tag_class == 'UNIVERSAL'
+
+        return '' if id.to_s == '' && tag_class.to_s == ''
+
         if tag_class && tag_class != ''
           brace_surround("#{colorize_class(tag_class)} #{colorize(id).bold.green}")
         else
           brace_surround(colorize(id).bold.green)
         end
-
       end
 
-      def length_specifier(data_length, encoded_length = nil)
+      def length_specifier(data_length, encoded_length=nil)
         encoded_length = data_length if encoded_length.nil?
         "#{colorize('len:').gray} #{colorize(data_length).blue} #{parens_hex(encoded_length)}"
       end
@@ -52,25 +88,32 @@ module RASN2
       end
 
       def colorize_default(value)
-        colorize(value).green.bold
+        " #{colorize_attribute('DEFAULT VALUE')} #{colorize(value).green.bold}"
       end
 
-      def colorize_nil(name = 'NONE')
+      def colorize_nil(name='NONE')
         colorize(name).red.bold
       end
 
       def colorize_enum(name, raw_value)
-        raw_value = raw_value.unpack1('H*') if raw_value.is_a?(String)
+        raw_value = "0x#{raw_value.unpack1('H*').upcase}" if raw_value.is_a?(String)
         "#{colorize_class(name)} #{parens_hex(raw_value)}"
       end
 
+      def colorize_value(value)
+        colorize(value).blue
+      end
+
       def colorize_bool(value, raw_value)
-        if value
-          "#{colorize('TRUE').bold.green} #{parens_hex(raw_value)}"
-        else
-          "#{colorize('FALSE').bold.red} #{parens_hex(raw_value)}"
-        end
+        hex_raw_value = raw_value.is_a?(String) ? "0x#{raw_value.unpack1('H*').upcase}" : raw_value
+        value = if value
+                  colorize('TRUE').bold.green
+                else
+                  colorize('FALSE').bold.red
+                end
+
+        "#{value} #{parens_hex(hex_raw_value)}"
       end
     end
   end
-end
+end

data/lib/rasn2/model.rb

@@ -129,6 +129,8 @@ module RASN2
     # @private Sequence types
     SEQUENCE_TYPES = [Types::Sequence, Types::SequenceOf, Types::Set, Types::SetOf].freeze
 
+    include Helpers::Colorize
+
     # Define helper methods to define models
     module Accel # rubocop:disable Metrics/ModuleLength
       # @return [Hash]
@@ -567,7 +569,9 @@ module RASN2
     # @return [Integer] number of parsed bytes
     # @raise [ASN1Error] error on parsing
     def parse!(der, ber: false)
-      root.parse!(der, ber: ber)
+      result = root.parse!(der, ber: ber)
+      result.model = self if result.respond_to? :model=
+      result
     end
 
     # @private
@@ -634,7 +638,7 @@ module RASN2
 
     # @return [String]
     def inspect(level=0, color: true)
-      "#{'  ' * level}(#{type}) #{root.inspect(-level)}"
+      root.inspect(level, color: color, kind: type)
     end
 
     # Objects are equal if they have same class AND same DER

data/lib/rasn2/schema_parser.rb

@@ -45,7 +45,7 @@ module RASN2
     }.freeze
 
     # Constructed type names
-    CONSTRUCTED_TYPES = %w[SEQUENCE SET].freeze
+    CONSTRUCTED_TYPES = %w[SEQUENCE SET TAG].freeze
 
     # Error raised when parsing an ASN.1 schema fails
     class ParseError < RASN2::Error; end

data/lib/rasn2/tracer.rb

@@ -37,7 +37,8 @@ module RASN2
     # @param [String] msg
     # @return [void]
     def trace(msg)
-      @io.puts(indent << msg)
+      indented = msg.split("\n").map { |line| indent + line }.join("\n")
+      @io.puts(indented)
     end
 
     # Return identation for given +level+. If +nil+, use {#tracing_level}.
@@ -45,7 +46,7 @@ module RASN2
     # @return [String]
     def indent(level=nil)
       level ||= @tracing_level
-      '  ' * level
+      "  " * level
     end
   end
 

data/lib/rasn2/types/any.rb

@@ -31,67 +31,51 @@ module RASN2
       # @param [Boolean] ber if +true+, accept BER encoding
       # @return [Integer] total number of parsed bytes
       def parse!(der, ber: false)
-        total_length, _data = do_parse(der, ber: ber)
+        total_length, data = do_parse(der, ber: ber)
+        @value = data
         total_length
       end
 
-      # @param [::Integer] level
-      # @return [String]
-      def inspect(level=0)
-        str = common_inspect(level)
-        str << if !value?
-                 'NULL'
-               elsif @value.is_a?(OctetString) || @value.is_a?(BitString)
-                 "#{@value.type}: #{value.value.inspect}"
-               elsif @value.class < Base
-                 "#{@value.type}: #{value.value}"
-               else
-                 value.to_s.inspect
-               end
-      end
-
       # @private Tracer private API
       # @return [String]
       def trace
         return trace_any if value?
 
-        msg_type(no_id: true) << " #{colorize_nil}"
-      end
-
-      private
-
-      def common_inspect(level)
-        lvl = [0, level].max
-        str = '  ' * lvl
-        str << "#{@name} " unless @name.nil?
-        str << asn1_class.to_s.upcase << ' ' unless asn1_class == :universal
-        str << "[#{id}] EXPLICIT " if explicit?
-        str << "[#{id}] IMPLICIT " if implicit?
-        str << '(ANY) '
+        parts = []
+        parts << msg_type(no_id: true)
+        parts << colorize_nil
+        parts.reject(&:empty?).join(' ')
       end
 
       # @private
       # @see Types::Base#do_parse
       def do_parse(der, ber: false)
+        asn1_class, _pc, id, id_size = Types.decode_identifier_octets(der)
+        @id = id
+        @asn1_class = asn1_class
+
         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..], ber)
         total_length += id_size
 
         @no_value = false
         real_value = der[0, total_length].to_s
-        @value = real_value
+        @value = if constructed?
+                   RASN2.parse(real_value, ber: ber)
+                 else
+                   real_value
+                 end
 
-        [total_length, real_value]
+        [total_length, @value]
       end
 
       def trace_any
-        msg_type(no_id: true) << trace_data(value)
+        "#{msg_type(no_id: false)}#{trace_data(value)}"
       end
     end
   end

data/lib/rasn2/types/base.rb

@@ -45,6 +45,10 @@ module RASN2
     #  ctype_implicit = RASN2::Types::Integer.new(implicit: 0)
     # @author Sylvain Daubert
     class Base # rubocop:disable Metrics/ClassLength
+      ID = nil
+
+      attr_accessor :model
+
       # Allowed ASN.1 classes
       CLASSES = {
         universal: 0x00,
@@ -54,7 +58,7 @@ module RASN2
       }.freeze
 
       def colorize(msg)
-        tracer ? tracer.colorize(msg) : Rainbow.new.wrap(msg)
+        tracer ? tracer.colorize(msg) : self.colorizer.wrap(msg)
       end
 
       include RASN2::Helpers::Colorize
@@ -199,6 +203,10 @@ module RASN2
         defined?(@tag) ? @tag == :implicit : nil # rubocop:disable Style/ReturnNilInPredicateMethodDefinition
       end
 
+      def private?
+        self.instance_of?(Types::Tag)
+      end
+
       # @abstract This method SHOULD be partly implemented by subclasses, which
       #   SHOULD respond to +#value_to_der+.
       # @return [String] DER-formated string
@@ -254,14 +262,43 @@ module RASN2
         value_to_der.size
       end
 
+      def attributes
+        attributes = []
+        attributes << 'OPTIONAL' if optional?
+        attributes << 'CONSTRUCTED' if constructed? && !(self.class < Constructed)
+        attributes << 'EXPLICIT' if explicit?
+        attributes << 'IMPLICIT' if implicit?
+        attributes
+      end
+
       # @param [Integer] level
       # @return [String]
-      def inspect(level=0, color: true)
-        str = common_inspect(level)
-        str << ' ' << inspect_value
-        str << ' OPTIONAL' if optional?
-        str << " DEFAULT #{@default}" unless @default.nil?
-        str
+      def inspect(level=0, color: false)
+        parts = []
+        new_level = level.abs + 1
+
+        begin_colorizer(color)
+        parts << common_inspect(level, color: color)
+
+        if constructed?
+          if @value.is_a?(Array)
+            @value.each do |value|
+              parts << "\n"
+              parts << value.inspect(new_level, color: color).to_s
+            end
+          else
+            parts << "\n"
+            if @value.is_a?(Base)
+              parts << @value.inspect(new_level, color: color).to_s
+            else
+              @value.inspect.to_s
+            end
+          end
+        else
+          parts << inspect_value unless inspect_value.empty?
+        end
+        end_colorizer
+        parts.reject(&:empty?).join(' ')
       end
 
       # Objects are equal if they have same class AND same DER
@@ -303,12 +340,14 @@ module RASN2
       def trace
         return trace_real if value?
 
-        msg = msg_type
-        if default.nil? # rubocop:disable Style/ConditionalAssignment
-          msg << " #{colorize_nil}"
-        else
-          msg << " #{colorize_attribute('DEFAULT VALUE')} #{colorize_default(value)}"
-        end
+        parts = [msg_type]
+        parts << if default.nil?
+                   colorize_nil
+                 else
+                   colorize_default(value)
+                 end
+
+        parts.reject(&:empty?).join(' ')
       end
 
       # @private Parse tage and length from binary string. Return data length and binary data.
@@ -346,42 +385,28 @@ module RASN2
         @value = der
       end
 
-      private
-
       def trace_real
-        encoded_id = unpack(encode_identifier_octets)
+        raw_id = encode_identifier_octets
+        encoded_id = raw_id.unpack1('w*')
         data_length = raw_data.length
-        encoded_length = unpack(raw_length)
-        msg = "#{msg_type} #{parens_hex(encoded_id)}, #{length_specifier(data_length, encoded_length)}"
+        encoded_length = raw_length.unpack1('w*')
+        parts = [msg_type(raw_id.unpack1('H*').to_i(16), encoded_id)]
+        msg = parts.reject(&:empty?).join(' ')
+        msg << ", #{length_specifier(data_length, 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.between?(32, 126) ? byte.chr : '.'
-          byte_count += 1
+        format_string = data.size > 65_535 ? '%08X' : '%04X'
+        lines = data.bytes.each_slice(16).map.with_index do |chunk, index|
+          offset = format_string % (index * 16)
+          hex = chunk.map { |b| '%02x' % b }.join(' ')
+          hex_padded = hex.ljust(47) # 16*2 hex digits + 15 spaces
+          ascii = chunk.map { |b| (32..126).cover?(b) ? b.chr : '.' }.join
+          "  #{offset}  #{hex_padded}  |#{ascii}|"
         end
-        lines.map(&:rstrip).join << "\n"
-      end
-
-      def trace_format_new_data_line(count)
-        head_line = RASN2.tracer.indent(RASN2.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 + RASN2.tracer.indent(RASN2.tracer.tracing_level + 1).length
-        base_idx + offset + (byte_count % 16) * byte_count_mul
+        "\n#{lines.join("\n")}"
       end
 
       def unpack(binstr)
@@ -389,22 +414,16 @@ module RASN2
       end
 
       def asn1_class_to_s
-        asn1_class == :universal ? '' : asn1_class.to_s.upcase << ' '
+        asn1_class.to_s.upcase
       end
 
-      def msg_type(no_id: false)
-        msg = name.nil? ? +'' : "#{colorize_name(name)} "
-        msg << "#{colorize_id(id, asn1_class_to_s)} " unless no_id
-        msg << if explicit?
-                 + "#{colorize_attribute('EXPLICIT')} "
-               elsif implicit?
-                 +  "#{colorize_attribute('IMPLICIT')} "
-               else
-                 +''
-               end
-        msg << colorize_class(type)
-        msg << " #{colorize_attribute('OPTIONAL')}" if optional?
-        msg
+      def msg_type(raw_id=nil, _encoded_id=nil, no_id: false)
+        parts = []
+        parts << colorize_name(name) unless name.nil?
+        real_id = no_id ? nil : raw_id || id
+        parts << colorize_id(id, asn1_class_to_s) if real_id
+        parts << colorize_class(type, real_id, *self.attributes)
+        parts.reject(&:empty?).join(' ')
       end
 
       def pc_bit
@@ -417,22 +436,32 @@ module RASN2
         end
       end
 
-      def common_inspect(level)
-        lvl = [level, 0].max
-        str = '  ' * lvl
-        str << "#{@name} " unless @name.nil?
-        str << asn1_class_to_s
-        str << "[#{id}] EXPLICIT " if explicit?
-        str << "[#{id}] IMPLICIT " if implicit?
-        str << "#{type}:"
+      def universal?
+        @asn1_class == :universal
+      end
+
+      def common_inspect(level=0, color: false)
+        begin_colorizer(color)
+        parts = []
+        parts << "(#{model})" if model
+        parts << colorize_name(name) if name
+        parts << colorize_id(id, asn1_class_to_s) if id && !universal?
+        class_name = colorize_class(type, nil, *self.attributes)
+        class_name += ':' if constructed?
+        parts << class_name
+        end_colorizer
+        "#{"  " * level}" + parts.reject(&:empty?).join(' ').to_s
       end
 
       def inspect_value
-        if value?
-          value.inspect
-        else
-          '(NO VALUE)'
-        end
+        str = if value?
+                colorize_value(value.inspect)
+              else
+                colorize_nil('(NO VALUE)')
+              end
+
+        str += colorize_default(@default) if @default
+        str
       end
 
       def value_to_der
@@ -586,6 +615,8 @@ module RASN2
         elsif !@default.nil?
           @value = @default
         else
+          return true if self.instance_of?(Tag)
+
           raise_id_error(der)
         end
         false
@@ -638,18 +669,24 @@ module RASN2
 
       def raise_id_error(der)
         msg = name.nil? ? +'' : "#{name}: "
-        msg << "Expected #{self2name} but get #{der2name(der)}"
+        msg << "Expected #{self2name} but got #{der2name(der)}"
 
         raise ASN1Error, msg
       end
 
       def self2name
-        name = "#{colorize_class(asn1_class.to_s.upcase)} #{colorize_attribute(constructed? ? 'CONSTRUCTED' : 'PRIMITIVE')}"
+        parts = [asn1_class.to_s.upcase]
+        parts << (constructed? ? 'CONSTRUCTED' : 'PRIMITIVE').to_s
         if implicit? || explicit?
-          name << ' 0x%X (0x%s)' % [id, bin2hex(encode_identifier_octets)]
+          parts << '0x%X (0x%s)' % [id, bin2hex(encode_identifier_octets)]
         else
-          name << ' ' << colorize_class(self.class.type)
+          parts << self.class.type.to_s
         end
+        parts.reject(&:empty?).join(' ')
+      end
+
+      def indent(input, by=2)
+        input.split("\n").map { |line| ("  " * by) + line }.join("\n")
       end
 
       def der2name(der)
@@ -658,11 +695,12 @@ module RASN2
         asn1_class, pc, id, id_size = Types.decode_identifier_octets(der)
         name = "#{asn1_class.to_s.upcase} #{pc.to_s.upcase}"
         type =  find_type(id)
-        name << " #{type.nil? ? "#{colorize(bin2hex(der[0...id_size])).magenta}" : colorize(type.encoded_type).green}"
+        name << " #{type.nil? ? bin2hex(der[0...id_size]).to_s : type.encoded_type}"
       end
 
       def find_type(id)
         Types.constants.map { |c| Types.const_get(c) }
+             .grep(Class)
              .select { |klass| klass < Primitive || klass < Constructed }
              .find { |klass| id == klass::ID }
       end

data/lib/rasn2/types/bit_string.rb

@@ -34,11 +34,8 @@ module RASN2
         end
       end
 
-      # @param [Integer] level
-      # @return [String]
-      def inspect(level=0)
-        str = common_inspect(level)
-        str << " #{value.inspect} (bit length: #{bit_length})"
+      def inspect_value
+        "(bit length: #{bit_length}): #{value.inspect}"
       end
 
       # Same as {Base#can_build?} but also check bit_length

data/lib/rasn2/types/boolean.rb

@@ -50,7 +50,7 @@ module RASN2
       def trace_data
         return super if explicit?
 
-        '    ' + colorize_bool(raw_data != "\x00".b, raw_data.unpack1('H*'))
+        "    #{colorize_bool(raw_data != "\x00".b, raw_data)}"
       end
     end
   end

data/lib/rasn2/types/choice.rb

@@ -126,12 +126,12 @@ module RASN2
 
       # @param [::Integer] level
       # @return [String]
-      def inspect(level=0)
+      def inspect(level=0, color: true)
         str = common_inspect(level)
         str << if defined?(@chosen) && value?
-                 "\n#{@value[@chosen].inspect(level + 1)}"
+                 @value[@chosen].inspect(level + 1)
                else
-                 ' not chosen!'
+                 'not chosen!'
                end
       end
 

data/lib/rasn2/types/constructed.rb

@@ -23,29 +23,6 @@ module RASN2
               (el.value.respond_to?(:empty?) ? !el.value.empty? : !el.value.nil?))
         end
       end
-
-      # @param [::Integer] level (default: 0)
-      # @return [String]
-      def inspect(level=0)
-        case @value
-        when Array
-          str = common_inspect(level)
-          str << "\n"
-          level = level.abs + 1
-          @value.each do |item|
-            case item
-            when Base, Model, Wrapper
-              str << "#{item.inspect(level)}\n"
-            else
-              str << '  ' * level
-              str << "#{item.inspect}\n"
-            end
-          end
-          str
-        else
-          super
-        end
-      end
     end
   end
 end

data/lib/rasn2/types/ia5_string.rb

@@ -16,6 +16,10 @@ module RASN2
       def self.type
         'IA5String'
       end
+
+      def inspect_value
+        colorize_value(@value.inspect)
+      end
     end
   end
 end

data/lib/rasn2/types/integer.rb

@@ -155,8 +155,9 @@ module RASN2
 
       def trace_data
         return super if explicit?
+
         i = der_to_int_value(raw_data)
-        return "    #{int_with_hex(i, raw_data.unpack1('H*'))}" if @enum.empty?
+        return "    #{int_with_hex(i, raw_data.unpack1('w*'))}" if @enum.empty?
 
         v = int_to_enum(i, check_enum: false)
         "    #{colorize_enum(v, raw_data)}"

data/lib/rasn2/types/null.rb

@@ -9,10 +9,11 @@ module RASN2
       ID = 0x05
 
       # @return [String]
-      def inspect(level=0)
-        str = common_inspect(level)[0..-2] # remove terminal ':'
-        str << ' OPTIONAL' if optional?
-        str
+      def inspect(level=0, color: true)
+        begin_colorizer(color)
+        result = common_inspect(level)
+        end_colorizer
+        result
       end
 
       # @return [Boolean]

data/lib/rasn2/types/octet_string.rb

@@ -15,11 +15,8 @@ module RASN2
       # OctetString id value
       ID = 4
 
-      # @param [::Integer] level
-      # @return [String]
-      def inspect(level=0)
-        str = common_inspect(level)
-        str << " #{value.inspect}"
+      def inspect_value
+        value.inspect
       end
 
       # Make string value from +der+ string. Force encoding to UTF-8

data/lib/rasn2/types/sequence_of.rb

@@ -107,22 +107,17 @@ module RASN2
 
       # @param [::Integer] level
       # @return [String]
-      def inspect(level=0)
-        str = common_inspect(level)
-        str << "\n"
-        level = level.abs + 1
-        @value.each do |item|
-          case item
-          when Base, Model
-            next if item.optional? && item.value.nil?
-
-            str << item.inspect(level)
-            str << "\n" unless str.end_with?("\n")
-          else
-            str << ('  ' * level) << "#{item.inspect}\n"
-          end
+      def inspect(level=0, color: false)
+        new_level = level.abs + 1
+        begin_colorizer(color)
+        name = @name ? "#{colorize_name(@name)} " : ''
+        lines = []
+        lines << "#{"  " * level}#{name}SEQUENCE OF:"
+        lines += @value.map do |item|
+          item.inspect(new_level, color: color)
         end
-        str
+        end_colorizer
+        lines.join("\n")
       end
 
       # Make sequence of value from +der+ string

data/lib/rasn2/types/tag.rb

@@ -24,7 +24,7 @@ module RASN2
     #   generic = Tag.new(tag: :private, value: [Integer.new, OctetString.new])
     #   # or equivalently
     #   generic = Tag.new(any_private: true, value: [Integer.new])
-    class Tag < Constructed
+    class Tag < Base
       # Placeholder ID — not used directly; tag is always dynamic.
       ID = 0
 
@@ -72,22 +72,6 @@ module RASN2
         end
       end
 
-      # Parse constructed content from DER
-      # @param [String] der
-      # @param [Boolean] ber
-      # @return [void]
-      def der_to_value(der, ber: false) # rubocop:disable Lint/UnusedMethodArgument
-        if @value.is_a?(Array) && !@value.empty?
-          nb_bytes = 0
-          @value.each do |element|
-            nb_bytes += element.parse!(der[nb_bytes..])
-          end
-        else
-          @value = der
-          der.length
-        end
-      end
-
       private
 
       def extract_tag_binding(options)
@@ -114,6 +98,12 @@ module RASN2
       end
 
       def check_id(der)
+        asn1_class, pc, tag_id, size = Types.decode_identifier_octets(der)
+        @asn1_class = asn1_class
+        @constructed = pc
+        @tag = tag_id
+        @tag_size = size
+
         return check_any_private_id(der) if @any_private && @accepted_tags.empty?
         return check_multi_tag_id(der) if @accepted_tags.length > 1
 
@@ -123,10 +113,7 @@ module RASN2
       def check_any_private_id(der)
         return no_match(der) if der.nil? || der.empty?
 
-        first_octet = der.unpack1('C').to_i
-        asn1_class_bits = first_octet & CLASS_MASK
-        if asn1_class_bits == CLASSES[:private]
-          _, _, tag_id, = Types.decode_identifier_octets(der)
+        if asn1_class == :private
           @id_value = tag_id
           @matched_tag = tag_id
           true
@@ -164,15 +151,13 @@ module RASN2
 
       def value_to_der
         case @value
-        when Array then @value.map(&:to_der).join
-        else @value.to_s
+        when Array
+          @value.map(&:to_der).join
+        else
+          @value.to_s
         end
       end
 
-      def trace_data
-        ''
-      end
-
       def explicit_type
         opts = { name: name, value: @value }
         if @accepted_tags.length == 1

data/lib/rasn2/types.rb

@@ -15,6 +15,7 @@ module RASN2
       return @primitives unless @primitives.empty?
 
       @primitives = self.constants.map { |c| Types.const_get(c) }
+                        .grep(Class)
                         .select { |klass| klass < Primitive }
     end
 
@@ -24,6 +25,7 @@ module RASN2
       return @constructed unless @constructed.empty?
 
       @constructed = self.constants.map { |c| Types.const_get(c) }
+                         .grep(Class)
                          .select { |klass| klass < Constructed }
     end
 
@@ -67,10 +69,10 @@ module RASN2
       asn1class, pc, id, = self.decode_identifier_octets(der)
       # cache_id: check versus class and 5 LSB bits
       cache_id = der.unpack1('C') & 0xdf
-      klass = cache_id < Types::Base::MULTI_OCTETS_ID ? @id2types[id] : Types::Base
+      klass = cache_id < Types::Base::MULTI_OCTETS_ID ? @id2types[id] : Types::Tag
       is_constructed = (pc == :constructed)
       options = { class: asn1class, constructed: is_constructed }
-      options[:tag_value] = id if klass == Types::Base
+      options[:tag_value] = id if klass == Types::Tag
       klass.new(options)
     end
 

data/lib/rasn2/version.rb

@@ -2,5 +2,5 @@
 
 module RASN2
   # RASN2 version number
-  VERSION = '1.0'
+  VERSION = '1.0.1'
 end

data/lib/rasn2/wrapper.rb

@@ -201,13 +201,6 @@ module RASN2
       !constructed?
     end
 
-    # @param [::Integer] level
-    # @return [String]
-    def inspect(level=0)
-      return super() unless explicit?
-
-      @explicit_wrapper.inspect(level) << ' ' << super()
-    end
 
     private
 

data/lib/rasn2.rb

@@ -35,7 +35,7 @@ module RASN2
       type = Types.id2type(der)
       size = type.parse!(der, ber: ber)
 
-      if CONTAINER_CLASSES.include?(type.class)
+      if CONTAINER_CLASSES.include?(type.class) || type.constructed?
         RASN2.tracer.tracing_level += 1 unless RASN2.tracer.nil?
         content = self.parse(type.value)
         type.value = content.is_a?(Array) ? content : [content]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rasn2
 version: !ruby/object:Gem::Version
-  version: '1.0'
+  version: 1.0.1
 platform: ruby
 authors:
 - LemonTree55