rasn1 0.11.0 → 0.12.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cc6eb3e3649f88dae027153d6136d5e5969135c74a527d4abbc42a42e03e2e73
-  data.tar.gz: a674238e2461230d7076ffb29250b3a222c229b7af484b586da25642ba87863a
+  metadata.gz: 884fa6f74d0b3074ef074d061301092d55df580b663714c4a962a7b8503d777d
+  data.tar.gz: 77cc3c5d7bf926463464ca4d37237f0cddc358e0d7b9aa3e85c15982ab3f3fc1
 SHA512:
-  metadata.gz: dba48f620835a6ce4c9b6764d1538a2f96a94f21a7c8aa39b587783ba08b5c745c918eb885276372b3ae215f904596dfb3b5eab818c1a7416131e898c9c220eb
-  data.tar.gz: e397c4b1b78320a3b69e24aa9bbf46d29b04653b03aed76f9c906e5e47a03b027957d2d8d6a8f60793f13255b2492f5eb43e9f05a73d3e8dd9bde676cbbcdfe9
+  metadata.gz: fee544874a10b10618cd596b1c30edd4ad70185a783eeadbe23a86fa2439339d7d025784be5adc76904e05856ac8791817a768c0603ece0141e38d2975e588ad
+  data.tar.gz: 39428eb166401712d44eb60c4413bcd919d4fca380213acbe1dc29c32425c03a8852e1f0afa8934f5a04c604b376ac3c47424754b358cae96cc685029c467da7

data/lib/rasn1/errors.rb

@@ -18,10 +18,17 @@ module RASN1
   # Enumerated error
   class EnumeratedError < Error; end
 
-  # CHOICE error: #chosen not set
+  # CHOICE error: {Types::Choice#chosen} not set
   class ChoiceError < RASN1::Error
+    # @param [Types::Base] object
+    def initialize(object)
+      @object = object
+      super()
+    end
+
+    # @return [String]
     def message
-      "CHOICE #{@name}: #chosen not set"
+      "CHOICE #{@object.name}: #chosen not set"
     end
   end
 
@@ -37,7 +44,12 @@ module RASN1
 
     # @return [String]
     def message
-      "Constraint not verified on #{object.inspect}"
+      "Constraint not verified on #{@object.inspect}"
     end
   end
+
+  # Exception raised when model validation fails
+  # @since 0.12.0
+  class ModelValidationError < Error
+  end
 end

data/lib/rasn1/model.rb

@@ -57,16 +57,47 @@ module RASN1
   #
   # == Delegation
   # {Model} may delegate some methods to its root element. Thus, if root element
-  # is, for example, a {TypeInts::Choice}, model may delegate +#chosen+ and +#chosen_value+.
+  # is, for example, a {Types::Choice}, model may delegate +#chosen+ and +#chosen_value+.
   #
   # All methods defined by root may be delegated by model, unless model also defines
   # this method.
   # @author Sylvain Daubert
-  class Model
+  # @author adfoster-r7 ModelValidationError, track source location for dynamic class methods
+  class Model # rubocop:disable Metrics/ClassLength
     # @private
-    Elem = Struct.new(:name, :proc_or_class, :content)
+    Elem = Struct.new(:name, :proc_or_class, :content) do
+      # @param [String,Symbol] name
+      # @param [Proc,Class] proc_or_class
+      # @param [Hash,nil] content
+      def initialize(name, proc_or_class, content)
+        if content.is_a?(Array)
+          duplicate_names = find_all_duplicate_names(content.map(&:name) + [name])
+          raise ModelValidationError, "Duplicate name #{duplicate_names.first} found" if duplicate_names.any?
+        end
+
+        super
+      end
+
+      private
+
+      # @param [Array<String>] names
+      # @return [Array<String>] The duplicate names found in the array
+      def find_all_duplicate_names(names)
+        names.group_by { |name| name }
+             .select { |_name, values| values.length > 1 }
+             .keys
+      end
+    end
 
     # @private
+    WrapElem = Struct.new(:element, :options) do
+      # @return [String]
+      def name
+        "#{element.name}_wrapper"
+      end
+    end
+
+    # Define helper methods to define models
     module Accel
       # @return [Hash]
       attr_reader :options
@@ -79,6 +110,15 @@ module RASN1
         @root = Elem.new(name, model_klass, nil)
       end
 
+      # Use a {Wrapper} around a {Types::Base} or a {Model} object
+      # @param [Types::Base,Model] element
+      # @param [Hash] options
+      # @return [WrapElem]
+      # @since 0.12
+      def wrapper(element, options={})
+        @root = WrapElem.new(element, options)
+      end
+
       # Update options of root element.
       # May be used when subclassing.
       #  class Model1 < RASN1::Model
@@ -92,8 +132,13 @@ module RASN1
       #  end
       # @param [Hash] options
       # @return [void]
+      # @since 0.12.0 may change name through +:name+
       def root_options(options)
         @options = options
+        return unless options.key?(:name)
+
+        @root = @root.dup
+        @root.name = options[:name]
       end
 
       # On inheritance, create +@root+ class variable
@@ -105,33 +150,45 @@ module RASN1
         klass.class_eval { @root = root }
       end
 
+      # @private
+      # @param [String,Symbol] accel_name
+      # @param [Class] klass
+      # @since 0.11.0
+      # @since 0.12.0 track source location on error (adfoster-r7)
       def define_type_accel_base(accel_name, klass)
-        singleton_class.class_eval(
-          "def #{accel_name}(name, options={})\n" \
-          "  options[:name] = name\n" \
-          "  proc = proc do |opts|\n" \
-          "    #{klass}.new(options.merge(opts))\n" \
-          "  end\n" \
-          "  @root = Elem.new(name, proc, options[:content])\n" \
-          'end'
-        )
+        singleton_class.class_eval <<-EVAL, __FILE__, __LINE__ + 1
+          def #{accel_name}(name, options={}) # def sequence(name, type, options)
+            options[:name] = name
+            proc = proc do |opts|
+              #{klass}.new(options.merge(opts)) # Sequence.new(options.merge(opts))
+            end
+            @root = Elem.new(name, proc, options[:content])
+          end
+        EVAL
       end
 
+      # @private
+      # @param [String,Symbol] accel_name
+      # @param [Class] klass
+      # @since 0.11.0
+      # @since 0.12.0 track source location on error (adfoster-r7)
       def define_type_accel_of(accel_name, klass)
-        singleton_class.class_eval(
-          "def #{accel_name}_of(name, type, options={})\n" \
-          "  options[:name] = name\n" \
-          "  proc = proc do |opts|\n" \
-          "    #{klass}.new(type, options.merge(opts))\n" \
-          "  end\n" \
-          "  @root = Elem.new(name, proc, nil)\n" \
-          'end'
-        )
+        singleton_class.class_eval <<-EVAL, __FILE__, __LINE__ + 1
+          def #{accel_name}_of(name, type, options={}) # def sequence_of(name, type, options)
+            options[:name] = name
+            proc = proc do |opts|
+              #{klass}.new(type, options.merge(opts)) # SequenceOf.new(type, options.merge(opts))
+            end
+            @root = Elem.new(name, proc, nil)
+          end
+        EVAL
       end
 
       # Define an accelarator to access a type in a model definition
       # @param [String] accel_name
-      # @param [Class] klass
+      # @param [Class] klass class to instanciate
+      # @since 0.11.0
+      # @since 0.12.0 track source location on error (adfoster-r7)
       def define_type_accel(accel_name, klass)
         if klass < Types::SequenceOf
           define_type_accel_of(accel_name, klass)
@@ -184,17 +241,20 @@ module RASN1
 
     extend Accel
 
-    # @method sequence(name, options)
+    # @!method sequence(name, options)
+    #  @!scope class
     #  @param [Symbol,String] name name of object in model
     #  @param [Hash] options
     #  @return [Elem]
     #  @see Types::Sequence#initialize
-    # @method set(name, options)
+    # @!method set(name, options)
+    #  @!scope class
     #  @param [Symbol,String] name name of object in model
     #  @param [Hash] options
     #  @return [Elem]
     #  @see Types::Set#initialize
-    # @method choice(name, options)
+    # @!method choice(name, options)
+    #  @!scope class
     #  @param [Symbol,String] name name of object in model
     #  @param [Hash] options
     #  @return [Elem]
@@ -203,13 +263,15 @@ module RASN1
       self.define_type_accel_base(type, Types.const_get(type.capitalize))
     end
 
-    # @method sequence_of(name, type, options)
+    # @!method sequence_of(name, type, options)
+    #  @!scope class
     #  @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)
+    # @!method set_of(name, type, options)
+    #  @!scope class
     #  @param [Symbol,String] name name of object in model
     #  @param [Model, Types::Base] type type for SET OF
     #  @param [Hash] options
@@ -219,57 +281,68 @@ module RASN1
       define_type_accel_of(type, Types.const_get("#{type.capitalize}Of"))
     end
 
-    # @method boolean(name, options)
+    # @!method boolean(name, options)
+    #  @!scope class
     #  @param [Symbol,String] name name of object in model
     #  @param [Hash] options
     #  @return [Elem]
     #  @see Types::Boolean#initialize
-    # @method integer(name, options)
+    # @!method integer(name, options)
+    #  @!scope class
     #  @param [Symbol,String] name name of object in model
     #  @param [Hash] options
     #  @return [Elem]
     #  @see Types::Integer#initialize
-    # @method bit_string(name, options)
+    # @!method bit_string(name, options)
+    #  @!scope class
     #  @param [Symbol,String] name name of object in model
     #  @param [Hash] options
     #  @return [Elem]
     #  @see Types::BitString#initialize
-    # @method octet_string(name, options)
+    # @!method octet_string(name, options)
+    #  @!scope class
     #  @param [Symbol,String] name name of object in model
     #  @param [Hash] options
     #  @return [Elem]
     #  @see Types::OctetString#initialize
-    # @method null(name, options)
+    # @!method null(name, options)
+    #  @!scope class
     #  @param [Symbol,String] name name of object in model
     #  @param [Hash] options
     #  @return [Elem]
     #  @see Types::Null#initialize
-    # @method enumerated(name, options)
+    # @!method enumerated(name, options)
+    #  @!scope class
     #  @param [Symbol,String] name name of object in model
     #  @param [Hash] options
     #  @return [Elem]
     #  @see Types::Enumerated#initialize
-    # @method utf8_string(name, options)
+    # @!method utf8_string(name, options)
+    #  @!scope class
     #  @param [Symbol,String] name name of object in model
     #  @param [Hash] options
     #  @return [Elem]
     #  @see Types::Utf8String#initialize
-    # @method numeric_string(name, options)
+    # @!method numeric_string(name, options)
+    #  @!scope class
     #  @param [Symbol,String] name name of object in model
     #  @param [Hash] options
     #  @return [Elem]
     #  @see Types::NumericString#initialize
-    # @method printable_string(name, options)
+    # @!method printable_string(name, options)
+    #  @!scope class
     #  @param [Symbol,String] name name of object in model
     #  @param [Hash] options
     #  @return [Elem]
     #  @see Types::PrintableString#initialize
-    # @method visible_string(name, options)
+    # @!method visible_string(name, options)
+    #  @!scope class
     #  @param [Symbol,String] name name of object in model
     #  @param [Hash] options
     #  @return [Elem]
     #  @see Types::VisibleString#initialize
-    # @method ia5_string(name, options)
+    # @!method ia5_string(name, options)
+    #  @!scope class
     #  @param [Symbol,String] name name of object in model
     #  @param [Hash] options
     #  @return [Elem]
@@ -285,7 +358,7 @@ module RASN1
     # @param [Hash] args
     def initialize(args={})
       root = generate_root
-      set_elements(root)
+      generate_elements(root)
       initialize_elements(self, args)
     end
 
@@ -296,7 +369,7 @@ module RASN1
       @elements[name]
     end
 
-    # Set value of element +name+. Element should be a {Base}.
+    # Set value of element +name+. Element should be a {Types::Base}.
     # @param [String,Symbol] name
     # @param [Object] value
     # @return [Object] value
@@ -460,14 +533,33 @@ module RASN1
       class_element
     end
 
-    def set_elements(element) # rubocop:disable Naming/AccessorMethodName
+    def generate_elements(element)
+      if element.is_a?(WrapElem)
+        generate_wrapper(element)
+        return
+      end
       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)
+        add_subelement(another_element)
+      end
+    end
+
+    def generate_wrapper(wrap_elem)
+      inner_elem = wrap_elem.element
+      subel = add_subelement(inner_elem)
+      Wrapper.new(subel, wrap_elem.options)
+    end
+
+    def add_subelement(subelement)
+      case subelement
+      when Elem
+        subel = get_type(subelement.proc_or_class)
+        @elements[subelement.name] = subel
+        generate_elements(subelement) if composed?(subel) && subelement.content.is_a?(Array)
         subel
+      when WrapElem
+        generate_wrapper(subelement)
       end
     end
 
@@ -477,7 +569,7 @@ module RASN1
 
         case value
         when Hash
-          raise ArgumentError, "element #{name}: may only pass a Hash for Model elements" unless obj[name].is_a? Model
+          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
@@ -499,7 +591,7 @@ module RASN1
       end
     end
 
-    def private_to_h(element=nil)
+    def private_to_h(element=nil) # rubocop:disable Metrics/CyclomaticComplexity
       my_element = element || root
       my_element = my_element.root if my_element.is_a?(Model)
       value = case my_element
@@ -507,6 +599,13 @@ module RASN1
                 sequence_of_to_h(my_element)
               when Types::Sequence
                 sequence_to_h(my_element)
+              # @author adfoster-r7
+              when Types::Choice
+                raise ChoiceError.new(my_element) if my_element.chosen.nil?
+
+                private_to_h(my_element.value[my_element.chosen])
+              when Wrapper
+                wrapper_to_h(my_element)
               else
                 my_element.value
               end
@@ -529,11 +628,29 @@ module RASN1
       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)]
+        case el
+        when Model
+          hsh = el.to_h
+          hsh = hsh[hsh.keys.first]
+          [@elements.key(el), hsh]
+        when Wrapper
+          [@elements.key(el.element), wrapper_to_h(el)]
+        else
+          [el.name, private_to_h(el)]
+        end
       end
       ary.compact!
       ary.to_h
     end
+
+    def wrapper_to_h(wrap)
+      case wrap.element
+      when Model
+        hsh = wrap.element.to_h
+        hsh[hsh.keys.first]
+      else
+        private_to_h(wrap.element)
+      end
+    end
   end
 end

data/lib/rasn1/tracer.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module RASN1
+  # @private
+  class Tracer
+    # @return [IO]
+    attr_reader :io
+    # @return [Integer]
+    attr_accessor :tracing_level
+
+    TRACED_CLASSES = [Types::Any, Types::Choice, Types::Sequence, Types::SequenceOf, Types::Base].freeze
+
+    # @param [IO] io
+    def initialize(io)
+      @io = io
+      @tracing_level = 0
+    end
+
+    # Puts +msg+ onto {#io}.
+    # @param [String] msg
+    # @return [void]
+    def trace(msg)
+      @io.puts(indent << msg)
+    end
+
+    # Return identation for given +level+. If +nil+, use {#tracing_level}.
+    # @param [Integer,nil] level
+    # @return [String]
+    def indent(level=nil)
+      level ||= @tracing_level
+      '  ' * level
+    end
+  end
+
+  # Trace RASN1 parsing to +io+.
+  # All parsing methods called in block are traced to +io+. Each ASN.1 element is
+  # traced in a line showing element's id, its length and its data.
+  # @param [IO] io
+  # @example
+  #   RASN1.trace do
+  #     RASN1.parse("\x02\x01\x01")  # puts "INTEGER id: 2 (0x02), len: 1 (0x01), data: 0x01"
+  #   end
+  #   RASN1.parse("\x01\x01\xff")    # puts nothing onto STDOUT
+  # @return [void]
+  def self.trace(io=$stdout)
+    @tracer = Tracer.new(io)
+    Tracer::TRACED_CLASSES.each(&:start_tracing)
+
+    begin
+      yield @tracer
+    ensure
+      Tracer::TRACED_CLASSES.reverse.each(&:stop_tracing)
+      @tracer.io.flush
+      @tracer = nil
+    end
+  end
+
+  # @private
+  def self.tracer
+    @tracer
+  end
+
+  module Types
+    class Base
+      class << self
+        # @private
+        # Patch {#do_parse} to add tracing ability
+        def start_tracing
+          alias_method :do_parse_without_tracing, :do_parse
+          alias_method :do_parse, :do_parse_with_tracing
+          alias_method :do_parse_explicit_without_tracing, :do_parse_explicit
+          alias_method :do_parse_explicit, :do_parse_explicit_with_tracing
+        end
+
+        # @private
+        # Unpatch {#do_parse} to remove tracing ability
+        def stop_tracing
+          alias_method :do_parse, :do_parse_without_tracing # rubocop:disable Lint/DuplicateMethods
+          alias_method :do_parse_explicit, :do_parse_explicit_without_tracing # rubocop:disable Lint/DuplicateMethods
+        end
+      end
+
+      # @private
+      # Parse +der+ with tracing abillity
+      # @see #parse!
+      def do_parse_with_tracing(der, ber)
+        ret = do_parse_without_tracing(der, ber)
+        RASN1.tracer.trace(self.trace)
+        ret
+      end
+
+      def do_parse_explicit_with_tracing(data)
+        RASN1.tracer.tracing_level += 1
+        do_parse_explicit_without_tracing(data)
+        RASN1.tracer.tracing_level -= 1
+      end
+    end
+
+    class Choice
+      class << self
+        # @private
+        # Patch {#parse!} to add tracing ability
+        def start_tracing
+          alias_method :parse_without_tracing, :parse!
+          alias_method :parse!, :parse_with_tracing
+        end
+
+        # @private
+        # Unpatch {#parse!} to remove tracing ability
+        def stop_tracing
+          alias_method :parse!, :parse_without_tracing # rubocop:disable Lint/DuplicateMethods
+        end
+      end
+
+      # @private
+      # Parse +der+ with tracing abillity
+      # @see #parse!
+      def parse_with_tracing(der, ber: false)
+        RASN1.tracer.trace(self.trace)
+        parse_without_tracing(der, ber: ber)
+      end
+    end
+
+    class Sequence
+      class << self
+        # @private
+        # Patch {#der_to_value} to add tracing ability
+        def start_tracing
+          alias_method :der_to_value_without_tracing, :der_to_value
+          alias_method :der_to_value, :der_to_value_with_tracing
+        end
+
+        # @private
+        # Unpatch {#der_to_value!} to remove tracing ability
+        def stop_tracing
+          alias_method :der_to_value, :der_to_value_without_tracing # rubocop:disable Lint/DuplicateMethods
+        end
+      end
+
+      # @private
+      # der_to_value +der+ with tracing abillity
+      def der_to_value_with_tracing(der, ber: false)
+        RASN1.tracer.tracing_level += 1
+        der_to_value_without_tracing(der, ber: ber)
+        RASN1.tracer.tracing_level -= 1
+      end
+    end
+
+    class SequenceOf
+      class << self
+        # @private
+        # Patch {#der_to_value} to add tracing ability
+        def start_tracing
+          alias_method :der_to_value_without_tracing, :der_to_value
+          alias_method :der_to_value, :der_to_value_with_tracing
+        end
+
+        # @private
+        # Unpatch {#der_to_value!} to remove tracing ability
+        def stop_tracing
+          alias_method :der_to_value, :der_to_value_without_tracing # rubocop:disable Lint/DuplicateMethods
+        end
+      end
+
+      # @private
+      # der_to_value +der+ with tracing abillity
+      def der_to_value_with_tracing(der, ber: false)
+        RASN1.tracer.tracing_level += 1
+        der_to_value_without_tracing(der, ber: ber)
+        RASN1.tracer.tracing_level -= 1
+      end
+    end
+  end
+end

data/lib/rasn1/types/any.rb

@@ -21,28 +21,22 @@ module RASN1
         end
       end
 
+      def can_build?
+        value? || !optional?
+      end
+
       # Parse a DER string. This method updates object: {#value} will be a DER
       # string.
       # @param [String] der DER string
       # @param [Boolean] ber if +true+, accept BER encoding
       # @return [Integer] total number of parsed bytes
       def parse!(der, ber: false)
-        if der.empty?
-          return 0 if optional?
-
-          raise ASN1Error, 'Expected ANY but get nothing'
-        end
-
-        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, _data = do_parse(der, ber)
         total_length
       end
 
+      # @param [::Integer] level
+      # @return [String]
       def inspect(level=0)
         str = common_inspect(level)
         str << if !value?
@@ -56,6 +50,16 @@ module RASN1
                end
       end
 
+      # @private Tracer private API
+      # @return [String]
+      def trace
+        return trace_any if value?
+
+        msg_type(no_id: true) << ' NONE'
+      end
+
+      private
+
       def common_inspect(level)
         lvl = level >= 0 ? level : 0
         str = '  ' * lvl
@@ -65,6 +69,27 @@ module RASN1
         str << "[#{id}] IMPLICIT " if implicit?
         str << '(ANY) '
       end
+
+      def do_parse(der, ber)
+        if der.empty?
+          return [0, ''] if optional?
+
+          raise ASN1Error, 'Expected ANY but get nothing'
+        end
+
+        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, @value]
+      end
+
+      def trace_any
+        msg_type(no_id: true) << trace_data(value)
+      end
     end
   end
 end