rasn1 0.6.8 → 0.9.0

data/lib/rasn1/types/base.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
+
 module RASN1
   module Types
-
     # @abstract This is base class for all ASN.1 types.
     #
     #   Subclasses SHOULD define:
-    #   * a TAG constant defining ASN.1 tag number,
+    #   * an ID constant defining ASN.1 BER/DER identification number,
     #   * a private method {#value_to_der} converting its {#value} to DER,
     #   * a private method {#der_to_value} converting DER into {#value}.
     #
@@ -12,15 +13,15 @@ module RASN1
     # An optional value may be defined using +:optional+ key from {#initialize}:
     #   Integer.new(:int, optional: true)
     # An optional value implies:
-    # * while parsing, if decoded tag is not optional expected tag, no {ASN1Error}
-    #   is raised, and parser tries net tag,
+    # * while parsing, if decoded ID is not optional expected ID, no {ASN1Error}
+    #   is raised, and parser tries next field,
     # * while encoding, if {#value} is +nil+, this value is not encoded.
     # ==Define a default value
     # A default value may be defined using +:default+ key from {#initialize}:
     #  Integer.new(:int, default: 0)
     # A default value implies:
-    # * while parsing, if decoded tag is not expected tag, no {ASN1Error} is raised
-    #   and parser sets default value to this tag. Then parser tries nex tag,
+    # * while parsing, if decoded ID is not expected one, no {ASN1Error} is raised
+    #   and parser sets default value to this ID. Then parser tries next field,
     # * while encoding, if {#value} is equal to default value, this value is not
     #   encoded.
     # ==Define a tagged value
@@ -43,17 +44,21 @@ module RASN1
     # Implicit tagged values may also be defined:
     #  ctype_implicit = RASN1::Types::Integer.new(implicit: 0)
     # @author Sylvain Daubert
-    class Base
-      # Allowed ASN.1 tag classes
+    class Base # rubocop:disable Metrics/ClassLength
+      # Allowed ASN.1 classes
       CLASSES = {
-                 universal:   0x00,
-                 application: 0x40,
-                 context:     0x80,
-                 private:     0xc0
-                }
+        universal: 0x00,
+        application: 0x40,
+        context: 0x80,
+        private: 0xc0
+      }.freeze
 
-      # Maximum ASN.1 tag number
-      MAX_TAG = 0x1e
+      # Binary mask to get class
+      # @private
+      CLASS_MASK = 0xc0
+
+      # @private first octet identifier for multi-octets identifier
+      MULTI_OCTETS_ID = 0x1f
 
       # Length value for indefinite length
       INDEFINITE_LENGTH = 0x80
@@ -64,19 +69,18 @@ module RASN1
       attr_reader :asn1_class
       # @return [Object,nil] default value, if defined
       attr_reader :default
-      # @return [Object]
-      attr_writer :value
 
       # Get ASN.1 type
       # @return [String]
       def self.type
         return @type if defined? @type
+
         @type = self.to_s.gsub(/.*::/, '').gsub(/([a-z0-9])([A-Z])/, '\1 \2').upcase
       end
 
       # Get ASN.1 type used to encode this one
       # @return [String]
-      def self.encode_type
+      def self.encoded_type
         type
       end
 
@@ -91,68 +95,50 @@ module RASN1
         obj
       end
 
-
-      # @overload initialize(options={})
-      #   @param [Hash] options
-      #   @option options [Symbol] :class ASN.1 tag class. Default value is +:universal+.
-      #    If +:explicit+ or +:implicit:+ is defined, default value is +:context+.
-      #   @option options [::Boolean] :optional define this tag as optional. Default
-      #     is +false+
-      #   @option options [Object] :default default value for DEFAULT tag
-      #   @option options [Object] :value value to set
-      #   @option options [::Integer] :implicit define an IMPLICIT tagged type
-      #   @option options [::Integer] :explicit define an EXPLICIT tagged type
-      #   @option options [::Boolean] :constructed if +true+, set type as constructed.
-      #    May only be used when +:explicit+ is defined, else it is discarded.
-      #   @option options [::String] :name name for this node
-      # @overload initialize(value, options={})
-      #   @param [Object] value value to set for this ASN.1 object
-      #   @param [Hash] options
-      #   @option options [Symbol] :class ASN.1 tag class. Default value is +:universal+.
-      #    If +:explicit+ or +:implicit:+ is defined, default value is +:context+.
-      #   @option options [::Boolean] :optional define this tag as optional. Default
-      #     is +false+
-      #   @option options [Object] :default default value for DEFAULT tag
-      #   @option options [::Integer] :implicit define an IMPLICIT tagged type
-      #   @option options [::Integer] :explicit define an EXPLICIT tagged type
-      #   @option options [::Boolean] :constructed if +true+, set type as constructed.
-      #    May only be used when +:explicit+ is defined, else it is discarded.
-      #   @option options [::String] :name name for this node
-      def initialize(value_or_options={}, options={})
+      # @param [Hash] options
+      # @option options [Symbol] :class ASN.1 class. Default value is +:universal+.
+      #  If +:explicit+ or +:implicit:+ is defined, default value is +:context+.
+      # @option options [::Boolean] :optional define this tag as optional. Default
+      #   is +false+
+      # @option options [Object] :default default value (ASN.1 DEFAULT)
+      # @option options [Object] :value value to set
+      # @option options [::Integer] :implicit define an IMPLICIT tagged type
+      # @option options [::Integer] :explicit define an EXPLICIT tagged type
+      # @option options [::Boolean] :constructed if +true+, set type as constructed.
+      #  May only be used when +:explicit+ is defined, else it is discarded.
+      # @option options [::String] :name name for this node
+      def initialize(options={})
         @constructed = nil
-        if value_or_options.is_a? Hash
-          set_options value_or_options
-        else
-          set_options options
-          @value = value_or_options
-        end
+        set_options options
       end
 
-      # Used by +#dup+ and +#clone+. Deep copy @value.
-      def initialize_copy(other)
-        @value = case
-                 when NilClass, TrueClass, FalseClass, Integer
-                   @value
-                 else
-                   @value.dup
-                 end
-        @default = case
-                 when NilClass, TrueClass, FalseClass, Integer
-                   @default
-                 else
-                   @default.dup
-                 end
+      # Used by +#dup+ and +#clone+. Deep copy @value and @default.
+      def initialize_copy(_other)
+        @value = @value.dup
+        @no_value = @no_value.dup
+        @default = @default.dup
       end
 
       # Get value or default value
       def value
-        if @value.nil?
-          @default
-        else
+        if value?
           @value
+        else
+          @default
         end
       end
 
+      # Set value. If +val+ is +nil+, unset value
+      # @param [Object,nil] val
+      def value=(val)
+        set_value(val)
+      end
+
+      # @abstract Define 'void' value (i.e. 'value' when no value was set)
+      def void_value
+        ''
+      end
+
       # @return [::Boolean]
       def optional?
         @optional
@@ -168,21 +154,21 @@ module RASN1
       # @return [::Boolean,nil] return +nil+ if not tagged, return +true+
       #   if explicit, else +false+
       def explicit?
-        !defined?(@tag) ? nil : @tag == :explicit
+        defined?(@tag) ? @tag == :explicit : nil
       end
 
       # Say if a tagged type is implicit
       # @return [::Boolean,nil] return +nil+ if not tagged, return +true+
       #   if implicit, else +false+
       def implicit?
-        !defined?(@tag) ? nil : @tag == :implicit
+        defined?(@tag) ? @tag == :implicit : nil
       end
 
       # @abstract This method SHOULD be partly implemented by subclasses, which
       #   SHOULD respond to +#value_to_der+.
       # @return [String] DER-formated string
       def to_der
-        build_tag
+        build
       end
 
       # @return [::Boolean] +true+ if this is a primitive type
@@ -192,7 +178,7 @@ module RASN1
 
       # @return [::Boolean] +true+ if this is a constructed type
       def constructed?
-        !!((self.class < Constructed) ||  @constructed)
+        (self.class < Constructed) || !!@constructed
       end
 
       # Get ASN.1 type
@@ -201,17 +187,10 @@ module RASN1
         self.class.type
       end
 
-      # Get tag value
+      # Get identifier value
       # @return [Integer]
-      def tag
-        pc = if @constructed.nil?
-               self.class::ASN1_PC
-             elsif @constructed   # true
-               Constructed::ASN1_PC
-             else    # false
-               0
-             end
-        tag_value | CLASSES[@asn1_class] | pc
+      def id
+        id_value
       end
 
       # @abstract This method SHOULD be partly implemented by subclasses to parse
@@ -222,13 +201,15 @@ module RASN1
       # @return [Integer] total number of parsed bytes
       # @raise [ASN1Error] error on parsing
       def parse!(der, ber: false)
-        return 0 unless check_tag(der)
+        return 0 unless check_id(der)
 
-        total_length, data = get_data(der, ber)
+        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-tag
+          # Delegate to #explicit type to generate sub-value
           type = explicit_type
-          type.value = @value
           type.parse!(data)
           @value = type.value
         else
@@ -247,11 +228,9 @@ module RASN1
       # @param [Integer] level
       # @return [String]
       def inspect(level=0)
-        str = ''
-        str << '  ' * level if level > 0
-        str << "#{@name} " unless @name.nil?
-        str << "#{type}: #{value.inspect}"
-        str << " OPTIONAL" if optional?
+        str = common_inspect(level)
+        str << ' ' << inspect_value
+        str << ' OPTIONAL' if optional?
         str << " DEFAULT #{@default}" unless @default.nil?
         str
       end
@@ -265,6 +244,34 @@ module RASN1
 
       private
 
+      def pc_bit
+        if @constructed.nil?
+          self.class::ASN1_PC
+        elsif @constructed # true
+          Constructed::ASN1_PC
+        else # false
+          Primitive::ASN1_PC
+        end
+      end
+
+      def common_inspect(level)
+        lvl = level >= 0 ? level : 0
+        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 << "#{type}:"
+      end
+
+      def inspect_value
+        if value?
+          value.inspect
+        else
+          '(NO VALUE)'
+        end
+      end
+
       def value_to_der
         case @value
         when Base
@@ -274,68 +281,82 @@ module RASN1
         end
       end
 
-      def der_to_value(der, ber:false)
+      def der_to_value(der, ber: false) # rubocop:disable Lint/UnusedMethodArgument
         @value = der
       end
 
-      def set_options(options)
+      def set_options(options) # rubocop:disable Naming/AccessorMethodName
         set_class options[:class]
         set_optional options[:optional]
         set_default options[:default]
         set_tag options
-        @value = options[:value]
+        set_value options[:value]
         @name = options[:name]
+        @options = options
       end
 
-      def set_class(asn1_class)
+      def set_class(asn1_class) # rubocop:disable Naming/AccessorMethodName
         case asn1_class
         when nil
           @asn1_class = :universal
         when Symbol
-          if CLASSES.keys.include? asn1_class
-            @asn1_class = asn1_class
-          else
-            raise ClassError
-          end
+          raise ClassError unless CLASSES.key? asn1_class
+
+          @asn1_class = asn1_class
         else
           raise ClassError
         end
       end
 
-      def set_optional(optional)
+      def set_optional(optional) # rubocop:disable Naming/AccessorMethodName
         @optional = !!optional
       end
 
-      def set_default(default)
+      def set_default(default) # rubocop:disable Naming/AccessorMethodName
         @default = default
       end
 
       # handle undocumented option +:tag_value+, used internally by
       # {RASN1.parse} to parse non-universal class tags.
-      def set_tag(options)
+      def set_tag(options) # rubocop:disable Naming/AccessorMethodName
         if options[:explicit]
           @tag = :explicit
-          @tag_value = options[:explicit]
+          @id_value = options[:explicit]
           @constructed = options[:constructed]
         elsif options[:implicit]
           @tag = :implicit
-          @tag_value = options[:implicit]
+          @id_value = options[:implicit]
           @constructed = options[:constructed]
         elsif options[:tag_value]
-          @tag_value = options[:tag_value]
+          @id_value = options[:tag_value]
           @constructed = options[:constructed]
         end
 
         @asn1_class = :context if defined?(@tag) && (@asn1_class == :universal)
       end
 
-      def build_tag?
-        !(!@default.nil? and (@value.nil? or @value == @default)) and
-          !(optional? and @value.nil?)
+      def set_value(value) # rubocop:disable Naming/AccessorMethodName
+        if value.nil?
+          @no_value = true
+          @value = void_value
+        else
+          @no_value = false
+          @value = value
+        end
+        value
+      end
+
+      def value?
+        !@no_value
+      end
+
+      def can_build?
+        (@default.nil? || (value? && (@value != @default))) &&
+          (!optional? || value?)
       end
 
-      def build_tag
-        if build_tag?
+      def build
+        if can_build?
           if explicit?
             v = explicit_type
             v.value = @value
@@ -343,35 +364,52 @@ module RASN1
           else
             encoded_value = value_to_der
           end
-          encode_tag << encode_size(encoded_value.size) << encoded_value
+          encode_identifier_octets << encode_size(encoded_value.size) << encoded_value
         else
           ''
         end
       end
 
-      def tag_value
-        return @tag_value if defined? @tag_value
+      def id_value
+        return @id_value if defined? @id_value
 
-        self.class::TAG
+        self.class::ID
       end
 
-      def encode_tag
-        if tag_value <= MAX_TAG
-          [tag].pack('C')
+      def encode_identifier_octets
+        id2octets.pack('C*')
+      end
+
+      def id2octets
+        first_octet = CLASSES[asn1_class] | pc_bit
+        if id < MULTI_OCTETS_ID
+          [first_octet | id]
         else
-          raise ASN1Error, 'multi-byte tag value are not supported'
+          [first_octet | MULTI_OCTETS_ID] + unsigned_to_chained_octets(id)
         end
       end
 
+      # Encode an unsigned integer on multiple octets.
+      # Value is encoded on bit 6-0 of each octet, bit 7(MSB) indicates wether
+      # further octets follow.
+      def unsigned_to_chained_octets(value)
+        ary = []
+        while value.positive?
+          ary.unshift(value & 0x7f | 0x80)
+          value >>= 7
+        end
+        ary[-1] &= 0x7f
+        ary
+      end
+
       def encode_size(size)
         if size >= INDEFINITE_LENGTH
           bytes = []
           while size > 255
-            bytes << (size & 0xff)
+            bytes.unshift(size & 0xff)
             size >>= 8
           end
-          bytes << size
-          bytes.reverse!
+          bytes.unshift(size)
           bytes.unshift(INDEFINITE_LENGTH | bytes.size)
           bytes.pack('C*')
         else
@@ -379,84 +417,92 @@ module RASN1
         end
       end
 
-      def check_tag(der)
-        tag = der[0, 1]
-        if tag != encode_tag
-          if optional?
-            @value = nil
-          elsif !@default.nil?
-            @value = @default
-          else
-            raise_tag_error(tag)
-          end
-          false
+      def check_id(der)
+        expected_id = encode_identifier_octets
+        real_id = der[0, expected_id.size]
+        return true if real_id == expected_id
+
+        if optional?
+          @no_value = true
+          @value = void_value
+        elsif !@default.nil?
+          @value = @default
         else
-          true
+          raise_id_error(der)
         end
+        false
       end
 
       def get_data(der, ber)
-        length = der[1, 1].unpack('C').first
+        length = der.unpack1('C').to_i
         length_length = 0
 
         if length == INDEFINITE_LENGTH
-          if primitive?
-            raise ASN1Error, "malformed #{type} TAG: indefinite length " \
-              "forbidden for primitive types"
-          else
-            if ber
-              raise NotImplementedError, "TAG: indefinite length not " \
-                "supported yet"
-            else
-              raise ASN1Error, "TAG: indefinite length forbidden in DER " \
-                "encoding"
-            end
-          end
-        elsif length < INDEFINITE_LENGTH
-          data = der[2, length]
-        else
+          raise_on_indefinite_length(ber)
+        elsif length > INDEFINITE_LENGTH
           length_length = length & 0x7f
-          length = der[2, length_length].unpack('C*').
-            reduce(0) { |len, b| (len << 8) | b }
-          data = der[2 + length_length, length]
+          length = der[1, length_length].unpack('C*')
+                                        .reduce(0) { |len, b| (len << 8) | b }
         end
+        data = der[1 + length_length, length]
 
-        total_length = 2 + length
-        total_length += length_length if length_length > 0
+        total_length = 1 + length
+        total_length += length_length if length_length.positive?
 
         [total_length, data]
       end
 
+      def raise_on_indefinite_length(ber)
+        if primitive?
+          raise ASN1Error, "malformed #{type}: indefinite length " \
+            'forbidden for primitive types'
+        elsif ber
+          raise NotImplementedError, 'indefinite length not supported'
+        else
+          raise ASN1Error, 'indefinite length forbidden in DER encoding'
+        end
+      end
+
       def explicit_type
         self.class.new
       end
 
-      def raise_tag_error(tag)
-        msg = name.nil? ? '' : "#{name}: "
-        msg << "Expected #{self2name} but get #{tag2name(tag)}"
+      def raise_id_error(der)
+        msg = name.nil? ? +'' : +"#{name}: "
+        msg << "Expected #{self2name} but get #{der2name(der)}"
         raise ASN1Error, msg
       end
 
+      def class_from_numeric_id(id)
+        CLASSES.key(id & CLASS_MASK)
+      end
+
       def self2name
-        name = CLASSES.key(tag & 0xc0).to_s.upcase
-        name << " #{tag & Constructed::ASN1_PC > 0 ? 'CONSTRUCTED' : 'PRIMITIVE'}"
+        name = +"#{asn1_class.to_s.upcase} #{constructed? ? 'CONSTRUCTED' : 'PRIMITIVE'}"
         if implicit? || explicit?
-          name << ' 0x%02X (0x%02X)' % [tag & 0x1f, tag]
+          name << ' 0x%X (0x%s)' % [id, bin2hex(encode_identifier_octets)]
         else
           name << ' ' << self.class.type
         end
       end
 
-      def tag2name(tag)
-        return 'no tag' if tag.nil? or tag.empty?
+      def der2name(der)
+        return 'no ID' if der.nil? || der.empty?
+
+        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? ? '0x%X (0x%s)' % [id, bin2hex(der[0...id_size])] : type.encoded_type}"
+      end
+
+      def find_type(id)
+        Types.constants.map { |c| Types.const_get(c) }
+             .select { |klass| klass < Primitive || klass < Constructed }
+             .find { |klass| klass::ID == id }
+      end
 
-        itag = tag.unpack('C').first
-        name = CLASSES.key(itag & 0xc0).to_s.upcase
-        name << " #{itag & Constructed::ASN1_PC > 0 ? 'CONSTRUCTED' : 'PRIMITIVE'}"
-        type =  Types.constants.map { |c| Types.const_get(c) }.
-                  select { |klass| klass < Primitive || klass < Constructed }.
-                  find { |klass| klass::TAG == itag & 0x1f }
-        name << " #{type.nil? ? "0x%02X (0x%02X)" % [itag & 0x1f, itag] : type.encode_type }"
+      def bin2hex(str)
+        str.unpack1('H*')
       end
     end
   end