rasn1 0.7.1 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f51c0d098d5fde894990bb1637582548b5a35ae47c39e9d006971321501bbc49
-  data.tar.gz: f14a8c3fabfedd6eeeb02b80c6d4dd4a69f67b34efb283d592d92492143560f5
+  metadata.gz: f4eb9957878c25e54a394fee02aab5a42aa1201ad6250f7f6a2a3992128c87d6
+  data.tar.gz: 3b3d3c85d619ee7f78923d7f7c839874f329087b0b1a4094839b059daf94c2ec
 SHA512:
-  metadata.gz: 99e94933fdf79ac6cc413e2f2ca85d9f73ecb493444a20b61394bde44418ebe6dfd691eb59e65166c00247c8fb870686ded69ff77cd00662549835fa1aab4578
-  data.tar.gz: 2ac5e04d46e2fe7056a94489f99f1903ae1a1c645344306d548c1cc38dae0951f73f2936357ea27695f640c6f39593086c8927d38edcffa9d9ec6cb31ed30b3f
+  metadata.gz: 9eb501aacf629355e56a4103dfc3e354bfa035c031a23f2dcc61f8add191a13960cd64ea68db36340694f3b20aba316c0088ebe91943d795405b11489be9342e
+  data.tar.gz: 115cef9248e5251a24ec0bb6d6e977084cfb4ff78118a7f5be31ee8fea05a0c831b935fa72c18bdc08e71bb729a85cff2b394f4a84aafd56245f70908f0a4dc6

data/lib/rasn1.rb

@@ -44,7 +44,7 @@ module RASN1
   def self.parse(der, ber: false)
     root = nil
     until der.empty?
-      type = Types.tag2type(der[0].ord)
+      type = Types.id2type(der)
       type.parse!(der, ber: ber)
       root = type if root.nil?
 

data/lib/rasn1/model.rb

@@ -204,7 +204,7 @@ module RASN1
       #   +Object#object_id+.
       # @see Types::ObjectId#initialize
       def objectid(name, options={})
-        options.merge!(name: name)
+        options[:name] = name
         proc = proc { |opts| Types::ObjectId.new(options.merge(opts)) }
         @root = [name, proc]
       end
@@ -213,7 +213,7 @@ module RASN1
       # @param [Hash] options
       # @see Types::Any#initialize
       def any(name, options={})
-        options.merge!(name: name)
+        options[:name] = name
         proc = proc { |opts| Types::Any.new(options.merge(opts)) }
         @root = [name, proc]
       end
@@ -369,7 +369,7 @@ module RASN1
       elt = self[name]
       return elt unless elt.nil?
 
-      keys.each do |subelt_name|
+      @elements.each_key do |subelt_name|
         if self[subelt_name].is_a?(Model)
           elt = self[subelt_name][name]
           return elt unless elt.nil?
@@ -408,40 +408,37 @@ module RASN1
       @elements[name].value = content.map do |name2, proc_or_class, content2|
         subel = get_type(proc_or_class)
         @elements[name2] = subel
-        if composed?(subel) && content2.is_a?(Array)
-          set_elements(name2, proc_or_class, content2)
-        end
+        set_elements(name2, proc_or_class, content2) if composed?(subel) && content2.is_a?(Array)
         subel
       end
     end
 
     def initialize_elements(obj, args)
       args.each do |name, value|
-        if obj[name]
-          if value.is_a? Hash
-            if obj[name].is_a? Model
-              initialize_elements obj[name], value
-            else
-              raise ArgumentError, "element #{name}: may only pass a Hash for Model elements"
-            end
-          elsif value.is_a? Array
-            composed = if obj[name].is_a? Model
-                         obj[name].root
-                       else
-                         obj[name]
-                       end
-            if composed.of_type.is_a? Model
-              value.each do |el|
-                composed << initialize_elements(composed.of_type.class.new, el)
-              end
-            else
-              value.each do |el|
-                obj[name] << el
-              end
+        next unless obj[name]
+
+        case value
+        when Hash
+          raise ArgumentError, "element #{name}: may only pass a Hash for Model elements" unless obj[name].is_a? Model
+
+          initialize_elements obj[name], value
+        when Array
+          composed = if obj[name].is_a? Model
+                       obj[name].root
+                     else
+                       obj[name]
+                     end
+          if composed.of_type.is_a? Model
+            value.each do |el|
+              composed << initialize_elements(composed.of_type.class.new, el)
             end
           else
-            obj[name].value = value
+            value.each do |el|
+              obj[name] << el
+            end
           end
+        else
+          obj[name].value = value
         end
       end
     end

data/lib/rasn1/types.rb

@@ -18,32 +18,58 @@ module RASN1
                            .select { |klass| klass < Constructed }
     end
 
-    # Give ASN.1 type from an integer. If +tag+ is unknown, return a {Types::Base}
+    # @private
+    # Decode a DER string to extract identifier octets.
+    # @param [String] der
+    # @return [Array] Return ASN.1 class as Symbol, contructed/primitive as Symbol,
+    #                 ID and size of identifier octets
+    def self.decode_identifier_octets(der)
+      first_octet = der[0].unpack1('C')
+      asn1_class = Types::Base::CLASSES.key(first_octet & Types::Base::CLASS_MASK)
+      pc = (first_octet & Types::Constructed::ASN1_PC).positive? ? :constructed : :primitive
+      id = first_octet & Types::Base::MULTI_OCTETS_ID
+
+      size = if id == Types::Base::MULTI_OCTETS_ID
+               id = 0
+               1.upto(der.size - 1) do |i|
+                 octet = der[i].unpack1('C')
+                 id = (id << 7) | (octet & 0x7f)
+                 break i + 1 if (octet & 0x80).zero?
+               end
+             else
+               1
+             end
+
+      [asn1_class, pc, id, size]
+    end
+
+    # Give ASN.1 type from a DER string. If ID is unknown, return a {Types::Base}
     # object.
-    # @param [Integer] tag
+    # @param [String] der
     # @return [Types::Base]
     # @raise [ASN1Error] +tag+ is out of range
-    def self.tag2type(tag)
-      raise ASN1Error, 'tag is out of range' if tag > 0xff
-
-      unless defined? @tag2types
+    def self.id2type(der)
+      # Define a cache for well-known ASN.1 types
+      unless defined? @id2types
         constructed = self.constructed - [Types::SequenceOf, Types::SetOf]
         primitives = self.primitives - [Types::Enumerated]
         ary = (primitives + constructed).map do |type|
-          next unless type.const_defined? :TAG
+          next unless type.const_defined? :ID
 
-          [type::TAG, type]
+          [type::ID, type]
         end
-        @tag2types = Hash[ary]
-        @tag2types.default = Types::Base
-        @tag2types.freeze
+        @id2types = Hash[ary]
+        @id2types.default = Types::Base
+        @id2types.freeze
       end
 
-      klass = @tag2types[tag & 0xdf] # Remove CONSTRUCTED bit
-      is_constructed = (tag & 0x20) == 0x20
-      asn1class = Types::Base::CLASSES.key(tag & 0xc0)
+      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
+      is_constructed = (pc == :constructed)
       options = { class: asn1class, constructed: is_constructed }
-      options[:tag_value] = (tag & 0x1f) if klass == Types::Base
+      options[:tag_value] = id if klass == Types::Base
       klass.new(options)
     end
   end

data/lib/rasn1/types/any.rb

@@ -31,8 +31,12 @@ module RASN1
           raise ASN1Error, 'Expected ANY but get nothing'
         end
 
-        total_length, = get_data(der, ber)
+        id_size = Types.decode_identifier_octets(der).last
+        total_length, = get_data(der[id_size..-1], ber)
+        total_length += id_size
+
         @value = der[0, total_length]
+
         total_length
       end
 

data/lib/rasn1/types/base.rb

@@ -5,7 +5,7 @@ module RASN1
     # @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}.
     #
@@ -13,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
@@ -45,30 +45,20 @@ module RASN1
     #  ctype_implicit = RASN1::Types::Integer.new(implicit: 0)
     # @author Sylvain Daubert
     class Base
-      # Allowed ASN.1 tag classes
+      # Allowed ASN.1 classes
       CLASSES = {
-        universal:   0x00,
+        universal: 0x00,
         application: 0x40,
-        context:     0x80,
-        private:     0xc0
+        context: 0x80,
+        private: 0xc0
       }.freeze
 
-      # @private Types that cannot be dupped (Ruby <= 2.3)
-      UNDUPPABLE_TYPES = [[NilClass, nil], [TrueClass, true], [FalseClass, false], [Integer, 0]].map do |klass, obj|
-        begin
-          obj.dup
-          nil
-        rescue => TypeError
-          klass
-        end
-      end.compact.freeze
-
       # Binary mask to get class
       # @private
       CLASS_MASK = 0xc0
 
-      # Maximum ASN.1 tag number
-      MAX_TAG = 0x1e
+      # @private first octet identifier for multi-octets identifier
+      MULTI_OCTETS_ID = 0x1f
 
       # Length value for indefinite length
       INDEFINITE_LENGTH = 0x80
@@ -92,7 +82,7 @@ module RASN1
 
       # Get ASN.1 type used to encode this one
       # @return [String]
-      def self.encode_type
+      def self.encoded_type
         type
       end
 
@@ -109,11 +99,11 @@ module RASN1
 
       # @overload initialize(options={})
       #   @param [Hash] options
-      #   @option options [Symbol] :class ASN.1 tag class. Default value is +:universal+.
+      #   @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 for DEFAULT tag
+      #   @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
@@ -123,11 +113,11 @@ module RASN1
       # @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+.
+      #   @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
+      #   @option options [::Boolean] :optional define this value as optional. Default
       #     is +false+
-      #   @option options [Object] :default default value for DEFAULT tag
+      #   @option options [Object] :default default value (ASN.1 DEFAULT)
       #   @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.
@@ -145,8 +135,8 @@ module RASN1
 
       # Used by +#dup+ and +#clone+. Deep copy @value and @default.
       def initialize_copy(_other)
-        @value = @value.dup unless UNDUPPABLE_TYPES.include?(@value.class)
-        @default = @default.dup unless UNDUPPABLE_TYPES.include?(@default.class)
+        @value = @value.dup
+        @default = @default.dup
       end
 
       # Get value or default value
@@ -187,7 +177,7 @@ module RASN1
       #   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
@@ -206,17 +196,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
@@ -227,11 +210,13 @@ 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
         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)
@@ -268,6 +253,16 @@ 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
@@ -295,6 +290,7 @@ module RASN1
         set_tag options
         @value = options[:value]
         @name = options[:name]
+        @options = options
       end
 
       def set_class(asn1_class)
@@ -302,7 +298,7 @@ module RASN1
         when nil
           @asn1_class = :universal
         when Symbol
-          raise ClassError unless CLASSES.keys.include? asn1_class
+          raise ClassError unless CLASSES.key? asn1_class
 
           @asn1_class = asn1_class
         else
@@ -323,27 +319,27 @@ module RASN1
       def set_tag(options)
         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?
+      def can_build?
         !(!@default.nil? && (@value.nil? || (@value == @default))) &&
           !(optional? && @value.nil?)
       end
 
-      def build_tag
-        if build_tag?
+      def build
+        if can_build?
           if explicit?
             v = explicit_type
             v.value = @value
@@ -351,22 +347,42 @@ 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::ID
+      end
 
-        self.class::TAG
+      def encode_identifier_octets
+        id2octets.pack('C*')
       end
 
-      def encode_tag
-        raise ASN1Error, 'multi-byte tag value are not supported' unless tag_value <= MAX_TAG
+      def id2octets
+        first_octet = CLASSES[asn1_class] | pc_bit
+        if id < MULTI_OCTETS_ID
+          [first_octet | id]
+        else
+          [first_octet | MULTI_OCTETS_ID] + unsigned_to_chained_octets(id)
+        end
+      end
 
-        [tag].pack('C')
+      # 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)
@@ -384,15 +400,16 @@ module RASN1
         end
       end
 
-      def check_tag(der)
-        tag = der[0, 1]
-        if tag != encode_tag
+      def check_id(der)
+        expected_id = encode_identifier_octets
+        real_id = der[0, expected_id.size]
+        if real_id != expected_id
           if optional?
             @value = nil
           elsif !@default.nil?
             @value = @default
           else
-            raise_tag_error(tag)
+            raise_id_error(der)
           end
           false
         else
@@ -401,30 +418,28 @@ module RASN1
       end
 
       def get_data(der, ber)
-        length = der[1, 1].unpack('C').first
+        length = der[0, 1].unpack1('C')
         length_length = 0
 
         if length == INDEFINITE_LENGTH
           if primitive?
-            raise ASN1Error, "malformed #{type} TAG: indefinite length " \
+            raise ASN1Error, "malformed #{type}: indefinite length " \
               'forbidden for primitive types'
           elsif ber
-            raise NotImplementedError, 'TAG: indefinite length not ' \
-              'supported yet'
+            raise NotImplementedError, 'indefinite length not supported'
           else
-            raise ASN1Error, 'TAG: indefinite length forbidden in DER ' \
-              'encoding'
+            raise ASN1Error, 'indefinite length forbidden in DER encoding'
           end
         elsif length < INDEFINITE_LENGTH
-          data = der[2, length]
+          data = der[1, length]
         else
           length_length = length & 0x7f
-          length = der[2, length_length].unpack('C*')
+          length = der[1, length_length].unpack('C*')
                                         .reduce(0) { |len, b| (len << 8) | b }
-          data = der[2 + length_length, length]
+          data = der[1 + length_length, length]
         end
 
-        total_length = 2 + length
+        total_length = 1 + length
         total_length += length_length if length_length.positive?
 
         [total_length, data]
@@ -434,36 +449,38 @@ module RASN1
         self.class.new
       end
 
-      def raise_tag_error(tag)
+      def raise_id_error(der)
         msg = name.nil? ? +'' : +"#{name}: "
-        msg << "Expected #{self2name} but get #{tag2name(tag)}"
+        msg << "Expected #{self2name} but get #{der2name(der)}"
         raise ASN1Error, msg
       end
 
-      def class_from_numeric_tag(tag)
-        CLASSES.key(tag & CLASS_MASK)
+      def class_from_numeric_id(id)
+        CLASSES.key(id & CLASS_MASK)
       end
 
       def self2name
-        name = class_from_numeric_tag(tag).to_s.upcase
-        name << " #{(tag & Constructed::ASN1_PC).positive? ? '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? || tag.empty?
+      def der2name(der)
+        return 'no ID' if der.nil? || der.empty?
 
-        itag = tag.unpack('C').first
-        name = class_from_numeric_tag(itag).to_s.upcase
-        name << " #{(itag & Constructed::ASN1_PC).positive? ? 'CONSTRUCTED' : 'PRIMITIVE'}"
+        asn1_class, pc, id, id_size = Types.decode_identifier_octets(der)
+        name = +"#{asn1_class.to_s.upcase} #{pc.to_s.upcase}"
         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}"
+                     .find { |klass| klass::ID == id }
+        name << " #{type.nil? ? '0x%X (0x%s)' % [id, bin2hex(der[0...id_size])] : type.encoded_type}"
+      end
+
+      def bin2hex(str)
+        str.unpack1('H*')
       end
     end
   end