Merge pull request #49 from lemontree55/fix048

RASN1.parse may now parse multiple elements from a DER string

Author: lemontree55

lib/rasn1.rb

@@ -25,22 +25,24 @@ module RASN1
   #       generate {Types::Base} objects.
   # @param [String] der binary string to parse
   # @param [Boolean] ber if +true+, decode a BER string, else a DER one
-  # @return [Types::Base]
+  # @return [Types::Base, Array[Types::Base]]
   def self.parse(der, ber: false) # rubocop:disable Metrics/AbcSize
-    type = Types.id2type(der)
-    type.parse!(der, ber: ber)
+    result = []
+    until der.nil? || der.empty?
+      type = Types.id2type(der)
+      size = type.parse!(der, ber: ber)
 
-    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..]
+      if CONTAINER_CLASSES.include?(type.class)
+        RASN1.tracer.tracing_level += 1 unless RASN1.tracer.nil?
+        content = self.parse(type.value)
+        type.value = content.is_a?(Array) ? content : [content]
+        RASN1.tracer.tracing_level -= 1 unless RASN1.tracer.nil?
       end
-      RASN1.tracer.tracing_level -= 1 unless RASN1.tracer.nil?
-      type.value = ary
+
+      result << type
+      der = der[size..]
     end
-    type
+
+    result.size == 1 ? result[0] : result
   end
 end

lib/rasn1/types/base.rb

@@ -95,6 +95,7 @@ def self.encoded_type
       # Parse a DER or BER string
       # @param [String] der_or_ber string to parse
       # @param [Hash] options
+      # @return [Base]
       # @option options [Boolean] :ber if +true+, parse a BER string, else a DER one
       # @note More options are supported. See {Base#initialize}.
       def self.parse(der_or_ber, options={})

spec/rasn1_spec.rb

@@ -150,7 +150,7 @@
         expect(obj.value).to eq(RASN1::Types::Sequence.new(value: [@bool, @int]).to_der)
       end
 
-      context '(complex example)' do
+      context '(complex examples)' do
         it 'decodes a complex example' do
           der = File.read(File.join(__dir__, 'cert_example.der')).b
           cert = RASN1.parse(der)
@@ -194,6 +194,41 @@
           expect(cert.value[0].value[7].constructed?).to eq(true)
           expect(cert.value[0].value[7].id).to eq(3)
         end
+
+        it 'decodes a 2-pass example' do
+          der = ["303d040c800007db0300259e5d7f12860400a22b02046d192dad020100020100301d301b06132b060104018f5b067301010101288fc080c0000204ffffffff"].pack("H*")
+
+          # 1st pass
+          pdu = RASN1.parse(der)
+          expect(pdu).to be_a(RASN1::Types::Sequence)
+          expect(pdu.value.size).to eq(3)
+          expect(pdu.value[0]).to be_a(RASN1::Types::OctetString)
+          expect(pdu.value[0].value.length).to eq(12)
+          expect(pdu.value[1]).to be_a(RASN1::Types::OctetString)
+          expect(pdu.value[1].value.length).to eq(0)
+          expect(pdu.value[2]).to be_a(RASN1::Types::Base)
+          expect(pdu.value[2].asn1_class).to eq(:context)
+          expect(pdu.value[2].value.length).to eq(43)
+
+          # 2nd pass
+          subpdus = RASN1.parse(pdu.value[2].value)
+          expect(subpdus).to be_a(Array)
+          expect(subpdus.size).to eq(4)
+          expect(subpdus[0]).to be_a(RASN1::Types::Integer)
+          expect(subpdus[0].to_i).to eq(1830366637)
+          expect(subpdus[1]).to be_a(RASN1::Types::Integer)
+          expect(subpdus[1].to_i).to eq(0)
+          expect(subpdus[2]).to be_a(RASN1::Types::Integer)
+          expect(subpdus[2].to_i).to eq(0)
+          expect(subpdus[3]).to be_a(RASN1::Types::Sequence)
+          expect(subpdus[3].value.size).to eq(1)
+          expect(subpdus[3].value[0]).to be_a(RASN1::Types::Sequence)
+          expect(subpdus[3].value[0].value.size).to eq(2)
+          expect(subpdus[3].value[0].value[0]).to be_a(RASN1::Types::ObjectId)
+          expect(subpdus[3].value[0].value[0].value).to eq("1.3.6.1.4.1.2011.6.115.1.1.1.1.40.4160757760")
+          expect(subpdus[3].value[0].value[1]).to be_a(RASN1::Types::Integer)
+          expect(subpdus[3].value[0].value[1].value).to eq(-1)
+        end
       end
     end
   end