rasn1 0.6.6 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4acb42db867027d85bfd208aaaee5906af7fe4fdcd92327055f66187415e959f
-  data.tar.gz: 52cbb1f7306006fb0c03e3e00911d52a474a78c994e2a8e5618046356de43117
+  metadata.gz: f4eb9957878c25e54a394fee02aab5a42aa1201ad6250f7f6a2a3992128c87d6
+  data.tar.gz: 3b3d3c85d619ee7f78923d7f7c839874f329087b0b1a4094839b059daf94c2ec
 SHA512:
-  metadata.gz: ce57ddfbbed465bce5fefb9c7c8b91593e09e4a9cc3797e467e5eb0f482964f1f2bbed3a9053da1f590fddb18e846a1a608351594d667459f59a0f5218294480
-  data.tar.gz: 93943756f8b526d6467d834976eda477bacd777565d4d46723c050aab5e909b78c5e3f74539999d0cf3ab3c60f316582fc8060814003936df02c09e78b4d7308
+  metadata.gz: 9eb501aacf629355e56a4103dfc3e354bfa035c031a23f2dcc61f8add191a13960cd64ea68db36340694f3b20aba316c0088ebe91943d795405b11489be9342e
+  data.tar.gz: 115cef9248e5251a24ec0bb6d6e977084cfb4ff78118a7f5be31ee8fea05a0c831b935fa72c18bdc08e71bb729a85cff2b394f4a84aafd56245f70908f0a4dc6

data/README.md

@@ -15,13 +15,22 @@ gem 'rasn1'
 
 And then execute:
 
-    $ bundle
+    $ bundle install
 
 Or install it yourself as:
 
     $ gem install rasn1
 
-## Usage
+## Simple usage
+
+To decode a DER/BER string without checking a model, do:
+
+```ruby
+decoded_der = RASN1.parse(der_string)
+decoded_ber = RASN1.parse(ber_string, ber: true)
+```
+
+## Advanced usage
 All examples below will be based on:
 
 ```

data/lib/rasn1.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rasn1/version'
 require 'rasn1/types'
 require 'rasn1/model'
@@ -5,7 +7,6 @@ require 'rasn1/model'
 # Rasn1 is a pure ruby library to parse, decode and encode ASN.1 data.
 # @author Sylvain Daubert
 module RASN1
-
   # Base error class
   class Error < StandardError; end
 
@@ -26,10 +27,10 @@ module RASN1
   # CHOICE error: #chosen not set
   class ChoiceError < RASN1::Error
     def message
-      "CHOICE #@name: #chosen not set"
+      "CHOICE #{@name}: #chosen not set"
     end
   end
-  
+
   # 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}.
@@ -42,15 +43,15 @@ module RASN1
   # @return [Types::Base]
   def self.parse(der, ber: false)
     root = nil
-    while der.size > 0
-      type = Types.tag2type(der[0].ord)
+    until der.empty?
+      type = Types.id2type(der)
       type.parse!(der, ber: ber)
       root = type if root.nil?
 
       if [Types::Sequence, Types::Set].include? type.class
         subder = type.value
         ary = []
-        while subder.size > 0
+        until subder.empty?
           ary << self.parse(subder)
           subder = subder[ary.last.to_der.size..-1]
         end

data/lib/rasn1/model.rb

@@ -1,5 +1,6 @@
-module RASN1
+# frozen_string_literal: true
 
+module RASN1
   # @abstract
   # {Model} class is a base class to define ASN.1 models.
   # == Create a simple ASN.1 model
@@ -58,8 +59,9 @@ module RASN1
   # this method.
   # @author Sylvain Daubert
   class Model
-
     class << self
+      # @return [Hash]
+      attr_reader :options
 
       # Use another model in this model
       # @param [String,Symbol] name
@@ -106,16 +108,16 @@ module RASN1
       #  @param [Symbol,String] name name of object in model
       #  @param [Hash] options
       #  @see Types::Choice#initialize
-      %w(sequence set choice).each do |type|
+      %w[sequence set choice].each do |type|
         class_eval "def #{type}(name, options={})\n" \
                    "  options.merge!(name: name)\n" \
-                   "  proc = Proc.new do |opts|\n" \
+                   "  proc = proc do |opts|\n" \
                    "    Types::#{type.capitalize}.new(options.merge(opts))\n" \
                    "  end\n" \
                    "  @root = [name, proc]\n" \
                    "  @root << options[:content] unless options[:content].nil?\n" \
                    "  @root\n" \
-                   "end"
+                   'end'
       end
 
       # @method sequence_of(name, type, options)
@@ -128,15 +130,15 @@ module RASN1
       #  @param [Model, Types::Base] type type for SET OF
       #  @param [Hash] options
       #  @see Types::SetOf#initialize
-      %w(sequence set).each do |type|
+      %w[sequence set].each do |type|
         klass_name = "Types::#{type.capitalize}Of"
         class_eval "def #{type}_of(name, type, options={})\n" \
                    "  options.merge!(name: name)\n" \
-                   "  proc = Proc.new do |opts|\n" \
+                   "  proc = proc do |opts|\n" \
                    "    #{klass_name}.new(type, options.merge(opts))\n" \
                    "  end\n" \
                    "  @root = [name, proc]\n" \
-                   "end"
+                   'end'
       end
 
       # @method boolean(name, options)
@@ -185,14 +187,15 @@ module RASN1
       #  @see Types::IA5String#initialize
       Types.primitives.each do |prim|
         next if prim == Types::ObjectId
+
         method_name = prim.type.gsub(/([a-z0-9])([A-Z])/, '\1_\2').downcase.gsub(/\s+/, '_')
         class_eval "def #{method_name}(name, options={})\n" \
                    "  options.merge!(name: name)\n" \
-                   "  proc = Proc.new do |opts|\n" \
-                   "    #{prim.to_s}.new(options.merge(opts))\n" \
+                   "  proc = proc do |opts|\n" \
+                   "    #{prim}.new(options.merge(opts))\n" \
                    "  end\n" \
                    "  @root = [name, proc]\n" \
-                   "end"
+                   'end'
       end
 
       # @param [Symbol,String] name name of object in model
@@ -201,8 +204,8 @@ module RASN1
       #   +Object#object_id+.
       # @see Types::ObjectId#initialize
       def objectid(name, options={})
-        options.merge!(name: name)
-        proc = Proc.new { |opts| Types::ObjectId.new(options.merge(opts)) }
+        options[:name] = name
+        proc = proc { |opts| Types::ObjectId.new(options.merge(opts)) }
         @root = [name, proc]
       end
 
@@ -210,15 +213,16 @@ module RASN1
       # @param [Hash] options
       # @see Types::Any#initialize
       def any(name, options={})
-        options.merge!(name: name)
-        proc = Proc.new { |opts| Types::Any.new(options.merge(opts)) }
+        options[:name] = name
+        proc = proc { |opts| Types::Any.new(options.merge(opts)) }
         @root = [name, proc]
       end
 
       # Give type name (aka class name)
       # @return [String]
       def type
-        return @type if @type
+        return @type if defined? @type
+
         @type = self.to_s.gsub(/.*::/, '')
       end
 
@@ -254,7 +258,8 @@ module RASN1
     # @param [Object] value
     # @return [Object] value
     def []=(name, value)
-      raise Error, "cannot set value for a Model" if @elements[name].is_a? Model
+      raise Error, 'cannot set value for a Model' if @elements[name].is_a? Model
+
       @elements[name].value = value
     end
 
@@ -302,6 +307,32 @@ module RASN1
       @elements[@root].parse!(str.dup.force_encoding('BINARY'), ber: ber)
     end
 
+    # @overload value
+    #  Get value of root element
+    #  @return [Object,nil]
+    # @overload value(name)
+    #  Direct access to the value of +name+ (nested) element of model.
+    #  @param [String,Symbol] name
+    #  @return [Object,nil]
+    # @return [Object,nil]
+    def value(name=nil, *args)
+      if name.nil?
+        @elements[@root].value
+      else
+        elt = by_name(name)
+
+        unless args.empty?
+          elt = elt.root if elt.is_a?(Model)
+          args.each do |arg|
+            elt = elt.root if elt.is_a?(Model)
+            elt = elt[arg]
+          end
+        end
+
+        elt.value
+      end
+    end
+
     # Delegate some methods to root element
     # @param [Symbol] meth
     def method_missing(meth, *args)
@@ -312,6 +343,11 @@ module RASN1
       end
     end
 
+    # @return [Boolean]
+    def respond_to_missing?(meth, *)
+      @elements[@root].respond_to?(meth) || super
+    end
+
     # @return [String]
     def inspect(level=0)
       '  ' * level + "(#{type}) #{root.inspect(-level)}"
@@ -324,14 +360,29 @@ module RASN1
       (other.class == self.class) && (other.to_der == self.to_der)
     end
 
-    private
+    protected
+
+    # Give a (nested) element from its name
+    # @param [String, Symbol] name
+    # @return [Model, Types::Base]
+    def by_name(name)
+      elt = self[name]
+      return elt unless elt.nil?
+
+      @elements.each_key do |subelt_name|
+        if self[subelt_name].is_a?(Model)
+          elt = self[subelt_name][name]
+          return elt unless elt.nil?
+        end
+      end
 
-    def is_composed?(el)
-      [Types::Sequence, Types::Set].include? el.class
+      nil
     end
 
-    def is_of?(el)
-      [Types::SequenceOf, Types::SetOf].include? el.class
+    private
+
+    def composed?(elt)
+      [Types::Sequence, Types::Set].include? elt.class
     end
 
     def get_type(proc_or_class, options={})
@@ -347,50 +398,47 @@ module RASN1
       root = self.class.class_eval { @root }
       @root = root[0]
       @elements = {}
-      @elements[@root] = get_type(root[1], self.class.class_eval { @options } || {})
+      @elements[@root] = get_type(root[1], self.class.options || {})
       root
     end
 
-    def set_elements(name, el, content=nil)
-      if content.is_a? Array
-        @elements[name].value = content.map do |name2, proc_or_class, content2|
-          subel = get_type(proc_or_class)
-          @elements[name2] = subel
-          if is_composed?(subel) and content2.is_a? Array
-            set_elements(name2, proc_or_class, content2)
-          end
-          subel
-        end
+    def set_elements(name, _elt, content=nil)
+      return unless content.is_a? Array
+
+      @elements[name].value = content.map do |name2, proc_or_class, content2|
+        subel = get_type(proc_or_class)
+        @elements[name2] = subel
+        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
@@ -408,10 +456,11 @@ module RASN1
                 end
               when Types::Sequence
                 seq = my_element.value.map do |el|
-                        next if el.optional? and el.value.nil?
-                        name = el.is_a?(Model) ? @elements.key(el) : el.name
-                        [name, private_to_h(el)]
-                      end
+                  next if el.optional? && el.value.nil?
+
+                  name = el.is_a?(Model) ? @elements.key(el) : el.name
+                  [name, private_to_h(el)]
+                end
                 seq.compact!
                 Hash[seq]
               else

data/lib/rasn1/types.rb

@@ -1,46 +1,75 @@
+# frozen_string_literal: true
+
 module RASN1
   # This modules is a namesapce for all ASN.1 type classes.
   # @author Sylvain Daubert
   module Types
-
     # Give all primitive types
     # @return [Array<Types::Primitive>]
     def self.primitives
-      @primitives ||= self.constants.map { |c| Types.const_get(c) }.
-                           select { |klass| klass < Primitive }
+      @primitives ||= self.constants.map { |c| Types.const_get(c) }
+                          .select { |klass| klass < Primitive }
     end
 
     # Give all constructed types
     # @return [Array<Types::Constructed>]
     def self.constructed
-      @constructed ||= self.constants.map { |c| Types.const_get(c) }.
-                            select { |klass| klass < Constructed }
+      @constructed ||= self.constants.map { |c| Types.const_get(c) }
+                           .select { |klass| klass < Constructed }
+    end
+
+    # @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 an integer. If +tag+ is unknown, return a {Types::Base}
+    # 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
-
-      if !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].flatten.map do |type|
-          next unless type.const_defined? :TAG
-          [type::TAG, type]
+        ary = (primitives + constructed).map do |type|
+          next unless type.const_defined? :ID
+
+          [type::ID, type]
         end
-        @tag2types = Hash[ary]
-        @tag2types.default = Types::Base
+        @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