rasn1 0.6.8 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1889a0ada74e2d9255ce6af799caa441fd2d2cacfaf0097b5afd1730ed9a9fd9
-  data.tar.gz: e0453969129814385bd272c362373b12ae0e38201145280c360ac3696dd95cb1
+  metadata.gz: b0f5f3f69aaae20cfd16576f565bc52d198bea49921a0db15e3e2a95a4947853
+  data.tar.gz: c3c1f6b2d5019febcbff3812611d624094b7aaefc238bd70109d4c278be3af8c
 SHA512:
-  metadata.gz: 4dc47229a202f0bfa7d56a129cd5e1807009b9147da6e844d5a47589fbf0e8eab9bebbb51f81866a0222eb4a6dbf953d381f266ec332e697b6caf1b894fa6c18
-  data.tar.gz: 4fc5127882d478d111452dff0cac6e226d270f47b4798b6a365f735c0bb1402ec417640b48be9839f7336fcf6d526f2a771d90bdc6ed64b0cefc3258d9e22bff
+  metadata.gz: 51e54a40d6608074e76ba0d18d51462e82fba109a4258b9082875bafe36476060186d2081cabb4e2d17e1140f53a4700906a053fdb05638ceb060560a337d05b
+  data.tar.gz: 434ca0398606fb411351a2d43b6701b70f9512043abea8768e21832a2a1800be8347efef50b17b01239ce953b49cb21b64860e2d252cc64e9c696a514de564ea

data/README.md

@@ -1,5 +1,4 @@
 [![Gem Version](https://badge.fury.io/rb/rasn1.svg)](https://badge.fury.io/rb/rasn1)
-[![Build Status](https://travis-ci.org/sdaubert/rasn1.svg?branch=master)](https://travis-ci.org/sdaubert/rasn1)
 
 # Rasn1
 
@@ -15,13 +14,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/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
@@ -57,7 +58,9 @@ module RASN1
   # All methods defined by root may be delegated by model, unless model also defines
   # this method.
   # @author Sylvain Daubert
-  class Model
+  class Model # rubocop:disable Metrics/ClassLength
+    # @private
+    Elem = Struct.new(:name, :proc_or_class, :content)
 
     class << self
       # @return [Hash]
@@ -66,8 +69,9 @@ module RASN1
       # Use another model in this model
       # @param [String,Symbol] name
       # @param [Class] model_klass
+      # @return [Elem]
       def model(name, model_klass)
-        @root = [name, model_klass]
+        @root = Elem.new(name, model_klass, nil)
       end
 
       # Update options of root element.
@@ -92,135 +96,153 @@ module RASN1
       # @return [void]
       def inherited(klass)
         super
-        root = defined?(@root )? @root : nil
+        root = @root
         klass.class_eval { @root = root }
       end
 
       # @method sequence(name, options)
       #  @param [Symbol,String] name name of object in model
       #  @param [Hash] options
+      #  @return [Elem]
       #  @see Types::Sequence#initialize
       # @method set(name, options)
       #  @param [Symbol,String] name name of object in model
       #  @param [Hash] options
+      #  @return [Elem]
       #  @see Types::Set#initialize
       # @method choice(name, options)
       #  @param [Symbol,String] name name of object in model
       #  @param [Hash] options
+      #  @return [Elem]
       #  @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"
+                   "  @root = Elem.new(name, proc, options[:content])\n" \
+                   'end'
       end
 
       # @method sequence_of(name, type, options)
       #  @param [Symbol,String] name name of object in model
       #  @param [Model, Types::Base] type type for SEQUENCE OF
       #  @param [Hash] options
+      #  @return [Elem]
       #  @see Types::SequenceOf#initialize
       # @method set_of(name, type, options)
       #  @param [Symbol,String] name name of object in model
       #  @param [Model, Types::Base] type type for SET OF
       #  @param [Hash] options
+      #  @return [Elem]
       #  @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"
+                   "  @root = Elem.new(name, proc, nil)\n" \
+                   'end'
       end
 
       # @method boolean(name, options)
       #  @param [Symbol,String] name name of object in model
       #  @param [Hash] options
+      #  @return [Elem]
       #  @see Types::Boolean#initialize
       # @method integer(name, options)
       #  @param [Symbol,String] name name of object in model
       #  @param [Hash] options
+      #  @return [Elem]
       #  @see Types::Integer#initialize
       # @method bit_string(name, options)
       #  @param [Symbol,String] name name of object in model
       #  @param [Hash] options
+      #  @return [Elem]
       #  @see Types::BitString#initialize
       # @method octet_string(name, options)
       #  @param [Symbol,String] name name of object in model
       #  @param [Hash] options
+      #  @return [Elem]
       #  @see Types::OctetString#initialize
       # @method null(name, options)
       #  @param [Symbol,String] name name of object in model
       #  @param [Hash] options
+      #  @return [Elem]
       #  @see Types::Null#initialize
       # @method enumerated(name, options)
       #  @param [Symbol,String] name name of object in model
       #  @param [Hash] options
+      #  @return [Elem]
       #  @see Types::Enumerated#initialize
       # @method utf8_string(name, options)
       #  @param [Symbol,String] name name of object in model
       #  @param [Hash] options
+      #  @return [Elem]
       #  @see Types::Utf8String#initialize
       # @method numeric_string(name, options)
       #  @param [Symbol,String] name name of object in model
       #  @param [Hash] options
+      #  @return [Elem]
       #  @see Types::NumericString#initialize
       # @method printable_string(name, options)
       #  @param [Symbol,String] name name of object in model
       #  @param [Hash] options
+      #  @return [Elem]
       #  @see Types::PrintableString#initialize
       # @method visible_string(name, options)
       #  @param [Symbol,String] name name of object in model
       #  @param [Hash] options
+      #  @return [Elem]
       #  @see Types::VisibleString#initialize
       # @method ia5_string(name, options)
       #  @param [Symbol,String] name name of object in model
       #  @param [Hash] options
+      #  @return [Elem]
       #  @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"
+                   "  @root = Elem.new(name, proc, nil)\n" \
+                   'end'
       end
 
       # @param [Symbol,String] name name of object in model
       # @param [Hash] options
+      # @return [Elem]
       # @note This method is named +objectid+ and not +object_id+ to not override
       #   +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)) }
-        @root = [name, proc]
+        options[:name] = name
+        proc = proc { |opts| Types::ObjectId.new(options.merge(opts)) }
+        @root = Elem.new(name, proc, nil)
       end
 
       # @param [Symbol,String] name name of object in model
       # @param [Hash] options
+      # @return [Elem]
       # @see Types::Any#initialize
       def any(name, options={})
-        options.merge!(name: name)
-        proc = Proc.new { |opts| Types::Any.new(options.merge(opts)) }
-        @root = [name, proc]
+        options[:name] = name
+        proc = proc { |opts| Types::Any.new(options.merge(opts)) }
+        @root = Elem.new(name, proc, nil)
       end
 
       # Give type name (aka class name)
       # @return [String]
       def type
         return @type if defined? @type
+
         @type = self.to_s.gsub(/.*::/, '')
       end
 
@@ -231,7 +253,7 @@ module RASN1
       # @raise [ASN1Error] error on parsing
       def parse(str, ber: false)
         model = new
-        model.parse! str, ber: ber
+        model.parse!(str, ber: ber)
         model
       end
     end
@@ -240,8 +262,8 @@ module RASN1
     # @param [Hash] args
     def initialize(args={})
       root = generate_root
-      set_elements(*root)
-      initialize_elements self, args
+      set_elements(root)
+      initialize_elements(self, args)
     end
 
     # Give access to element +name+ in model
@@ -256,14 +278,15 @@ 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
 
-    # Get name frm root type
+    # Get name from root type
     # @return [String,Symbol]
     def name
-      @root
+      @root_name
     end
 
     # Get elements names
@@ -278,15 +301,15 @@ module RASN1
       private_to_h
     end
 
-    # @return [String]
-    def to_der
-      @elements[@root].to_der
-    end
-
     # Get root element from model
     # @return [Types::Base,Model]
     def root
-      @elements[@root]
+      @elements[@root_name]
+    end
+
+    # @return [String]
+    def to_der
+      root.to_der
     end
 
     # Give type name (aka class name)
@@ -301,19 +324,62 @@ module RASN1
     # @return [Integer] number of parsed bytes
     # @raise [ASN1Error] error on parsing
     def parse!(str, ber: false)
-      @elements[@root].parse!(str.dup.force_encoding('BINARY'), ber: ber)
+      root.parse!(str.dup.force_encoding('BINARY'), ber: ber)
+    end
+
+    # @overload value
+    #  Get value of root element
+    #  @return [Object,nil]
+    # @overload value(name, *args)
+    #  Direct access to the value of +name+ (nested) element of model.
+    #  @param [String,Symbol] name
+    #  @param [Array<Integer,String,Symbol>] args more argument to access element. May be
+    #     used to access content of a SequenceOf or a SetOf
+    #  @return [Object,nil]
+    # @return [Object,nil]
+    # @example
+    #  class MyModel1 < RASN1::Model
+    #    sequence('seq', content: [boolean('boolean'), integer('int')])
+    #  end
+    #  class MyModel2 < RASN1::Model
+    #    sequence('root', content: [sequence_of('list', MyModel1)])
+    #  end
+    #  model = MyModel2.new
+    #  model.parse!(der)
+    #  # access to 2nd MyModel1.int in list
+    #  model.value('list', 1, 'int')
+    def value(name=nil, *args)
+      if name.nil?
+        root.value
+      else
+        elt = by_name(name)
+
+        unless args.empty?
+          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)
-      if @elements[@root].respond_to? meth
-        @elements[@root].send meth, *args
+      if root.respond_to? meth
+        root.send meth, *args
       else
         super
       end
     end
 
+    # @return [Boolean]
+    def respond_to_missing?(meth, *)
+      root.respond_to?(meth) || super
+    end
+
     # @return [String]
     def inspect(level=0)
       '  ' * level + "(#{type}) #{root.inspect(-level)}"
@@ -326,16 +392,34 @@ 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?
 
-    def is_composed?(el)
-      [Types::Sequence, Types::Set].include? el.class
+      @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
+
+      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
 
+    # proc_or_class:
+    # * proc: a Types::Base subclass
+    # * class: a model
     def get_type(proc_or_class, options={})
       case proc_or_class
       when Proc
@@ -346,84 +430,87 @@ module RASN1
     end
 
     def generate_root
-      root = self.class.class_eval { @root }
-      @root = root[0]
+      class_element = self.class.class_eval { @root }
+      @root_name = class_element.name
       @elements = {}
-      @elements[@root] = get_type(root[1], self.class.options || {})
-      root
+      @elements[@root_name] = get_type(class_element.proc_or_class, self.class.options || {})
+      class_element
     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(element) # rubocop:disable Naming/AccessorMethodName
+      return unless element.content.is_a? Array
+
+      @elements[name].value = element.content.map do |another_element|
+        subel = get_type(another_element.proc_or_class)
+        @elements[another_element.name] = subel
+        set_elements(another_element) if composed?(subel) && another_element.content.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
-            end
-          else
-            obj[name].value = value
-          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
+          initialize_element_from_array(obj[name], value)
+        else
+          obj[name].value = value
         end
       end
     end
 
+    def initialize_element_from_array(obj, value)
+      composed = obj.is_a?(Model) ? obj.root : obj
+      if composed.of_type.is_a?(Model)
+        value.each do |el|
+          composed << initialize_elements(composed.of_type.class.new, el)
+        end
+      else
+        value.each { |el| composed << el }
+      end
+    end
+
     def private_to_h(element=nil)
-      my_element = element
-      my_element = root if my_element.nil?
+      my_element = element || root
       my_element = my_element.root if my_element.is_a?(Model)
       value = case my_element
               when Types::SequenceOf
-                if my_element.of_type < Model
-                  my_element.value.map { |el| el.to_h.values.first }
-                else
-                  my_element.value.map { |el| private_to_h(el) }
-                end
+                sequence_of_to_h(my_element)
               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
-                seq.compact!
-                Hash[seq]
+                sequence_to_h(my_element)
               else
                 my_element.value
               end
       if element.nil?
-        { @root => value }
+        { @root_name => value }
       else
         value
       end
     end
+
+    def sequence_of_to_h(elt)
+      if elt.of_type < Model
+        elt.value.map { |el| el.to_h.values.first }
+      else
+        elt.value.map { |el| private_to_h(el) }
+      end
+    end
+
+    def sequence_to_h(seq)
+      ary = seq.value.map do |el|
+        next if el.optional? && el.value.nil?
+
+        name = el.is_a?(Model) ? @elements.key(el) : el.name
+        [name, private_to_h(el)]
+      end
+      ary.compact!
+      ary.to_h
+    end
   end
 end

data/lib/rasn1/types/any.rb

@@ -1,21 +1,23 @@
+# frozen_string_literal: true
+
 module RASN1
   module Types
-
     # ASN.1 ANY: accepts any types
     #
     # If `any#value` is `nil` and Any object is not {#optional?}, `any` will be encoded as a {Null} object.
     # @author Sylvain Daubert
     class Any < Base
-
       # @return [String] DER-formated string
       def to_der
-        case @value
-        when Base, Model
-          @value.to_der
-        when nil
-          optional? ? '' : Null.new.to_der
+        if value?
+          case @value
+          when Base, Model
+            @value.to_der
+          else
+            @value.to_s
+          end
         else
-          @value.to_s
+          optional? ? '' : Null.new.to_der
         end
       end
 
@@ -25,30 +27,43 @@ module RASN1
       # @param [Boolean] ber if +true+, accept BER encoding
       # @return [Integer] total number of parsed bytes
       def parse!(der, ber: false)
-        if der.nil? or der.empty?
+        if der.empty?
           return 0 if optional?
 
-          raise ASN1Error, "Expected ANY but get nothing"
+          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
+
+        @no_value = false
         @value = der[0, total_length]
+
         total_length
       end
 
       def inspect(level=0)
-        str = ''
-        str << '  ' * level if 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
+
+      def common_inspect(level)
+        lvl = level >= 0 ? level : 0
+        str = '  ' * lvl
         str << "#{@name} " unless @name.nil?
-        if @value.nil?
-          str << "(ANY) NULL"
-        elsif @value.is_a?(OctetString) or @value.is_a?(BitString)
-          str << "(ANY) #{@value.type}: #{value.value.inspect}"
-        elsif @value.class < Base
-          str << "(ANY) #{@value.type}: #{value.value}"
-        else
-          str << "ANY: #{value.to_s.inspect}"
-        end
+        str << asn1_class.to_s.upcase << ' ' unless asn1_class == :universal
+        str << "[#{id}] EXPLICIT " if explicit?
+        str << "[#{id}] IMPLICIT " if implicit?
+        str << '(ANY) '
       end
     end
   end