rasn1 0.11.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cc6eb3e3649f88dae027153d6136d5e5969135c74a527d4abbc42a42e03e2e73
-  data.tar.gz: a674238e2461230d7076ffb29250b3a222c229b7af484b586da25642ba87863a
+  metadata.gz: 552859c3f49caec5374c8db4459ad23e1f9c43e930b0d6511cab8f997c798d20
+  data.tar.gz: 29eaf2fc529b470c9bc6283efbaf82e580d5b4b86d5c46920ee4a882a18b0d72
 SHA512:
-  metadata.gz: dba48f620835a6ce4c9b6764d1538a2f96a94f21a7c8aa39b587783ba08b5c745c918eb885276372b3ae215f904596dfb3b5eab818c1a7416131e898c9c220eb
-  data.tar.gz: e397c4b1b78320a3b69e24aa9bbf46d29b04653b03aed76f9c906e5e47a03b027957d2d8d6a8f60793f13255b2492f5eb43e9f05a73d3e8dd9bde676cbbcdfe9
+  metadata.gz: 9e5df0e417db7e1f02accae9cc4f17b4a49975d1dc17b716dbf587bb3f5e8ca68ed842d22358d7de037041255c164df5a92c6ada52adba944f0ac635793a64b1
+  data.tar.gz: e193284ea13ca5f80a460b8b390839a0283a8424ca8201f24cbd6113919399fcd5b83a2fc39dd5b26925187e19930a1aceccb1485255de8301435e20a2c82761

data/lib/rasn1/errors.rb

@@ -20,8 +20,14 @@ module RASN1
 
   # CHOICE error: #chosen not set
   class ChoiceError < RASN1::Error
+    # @param [Types::Base] object
+    def initialize(object)
+      @object = object
+      super()
+    end
+
     def message
-      "CHOICE #{@name}: #chosen not set"
+      "CHOICE #{@object.name}: #chosen not set"
     end
   end
 
@@ -37,7 +43,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,42 @@ 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
+      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
+      def name
+        "#{element.name}_wrapper"
+      end
+    end
+
     module Accel
       # @return [Hash]
       attr_reader :options
@@ -79,6 +105,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 +127,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 +145,38 @@ module RASN1
         klass.class_eval { @root = root }
       end
 
+      # @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
 
+      # @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
+      # @since 0.11.0
       def define_type_accel(accel_name, klass)
         if klass < Types::SequenceOf
           define_type_accel_of(accel_name, klass)
@@ -184,17 +229,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 +251,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 +269,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 +346,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 +357,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 +521,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 +557,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 +579,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 +587,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 +616,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/types/any.rb

@@ -21,6 +21,10 @@ 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

data/lib/rasn1/types/base.rb

@@ -69,6 +69,8 @@ module RASN1
       attr_reader :asn1_class
       # @return [Object,nil] default value, if defined
       attr_reader :default
+      # @return [Hash[Symbol, Object]]
+      attr_reader :options
 
       # Get ASN.1 type
       # @return [String]
@@ -116,7 +118,8 @@ module RASN1
       # @option options [::String] :name name for this node
       def initialize(options={})
         @constructed = nil
-        set_options options
+        set_value(options.delete(:value))
+        self.options = options
         specific_initializer
       end
 
@@ -253,11 +256,38 @@ module RASN1
         (other.class == self.class) && (other.to_der == self.to_der)
       end
 
+      # Set options to this object
+      # @param [Hash] options
+      # @return [void]
+      # @since 0.12
+      def options=(options)
+        set_class options[:class]
+        set_optional options[:optional]
+        set_default options[:default]
+        set_tag options
+        @name = options[:name]
+        @options = options
+      end
+
+      # Say if a value is set
+      # @return [Boolean]
+      # @since 0.12.0
+      def value?
+        !@no_value
+      end
+
+      # Say if DER can be built (not default value, not optional without value, has a value)
+      # @return [Boolean]
+      # @since 0.12.0
+      def can_build?
+        value? && (@default.nil? || (@value != @default))
+      end
+
       private
 
       def pc_bit
         if @constructed.nil?
-          self.class::ASN1_PC
+          self.class.const_get(:ASN1_PC)
         elsif @constructed # true
           Constructed::ASN1_PC
         else # false
@@ -296,16 +326,6 @@ module RASN1
         @value = der
       end
 
-      def set_options(options) # rubocop:disable Naming/AccessorMethodName
-        set_class options[:class]
-        set_optional options[:optional]
-        set_default options[:default]
-        set_tag options
-        set_value options[:value]
-        @name = options[:name]
-        @options = options
-      end
-
       def set_class(asn1_class) # rubocop:disable Naming/AccessorMethodName
         case asn1_class
         when nil
@@ -330,17 +350,15 @@ module RASN1
       # handle undocumented option +:tag_value+, used internally by
       # {RASN1.parse} to parse non-universal class tags.
       def set_tag(options) # rubocop:disable Naming/AccessorMethodName
+        @constructed = options[:constructed]
         if options[:explicit]
           @tag = :explicit
           @id_value = options[:explicit]
-          @constructed = options[:constructed]
         elsif options[:implicit]
           @tag = :implicit
           @id_value = options[:implicit]
-          @constructed = options[:constructed]
         elsif options[:tag_value]
           @id_value = options[:tag_value]
-          @constructed = options[:constructed]
         end
 
         @asn1_class = :context if defined?(@tag) && (@asn1_class == :universal)
@@ -357,15 +375,6 @@ module RASN1
         value
       end
 
-      def value?
-        !@no_value
-      end
-
-      def can_build?
-        (@default.nil? || (value? && (@value != @default))) &&
-          (!optional? || value?)
-      end
-
       def build
         if can_build?
           if explicit?
@@ -382,9 +391,9 @@ module RASN1
       end
 
       def id_value
-        return @id_value if defined? @id_value
+        return @id_value if defined?(@id_value) && !@id_value.nil?
 
-        self.class::ID
+        self.class.const_get(:ID)
       end
 
       def encode_identifier_octets

data/lib/rasn1/types/bit_string.rb

@@ -42,14 +42,14 @@ module RASN1
         str << " #{value.inspect} (bit length: #{bit_length})"
       end
 
-      private
-
       def can_build?
-        !(!@default.nil? && (!value? || (@value == @default) &&
-                              (@bit_length == @default_bit_length))) &&
-          !(optional? && !value?)
+        super || (!@default.nil? && (@bit_length != @default_bit_length))
       end
 
+      private
+
+      # @author Sylvain Daubert
+      # @author adfoster-r7
       def value_to_der
         raise ASN1Error, "#{@name}: bit length is not set" if bit_length.nil?
 
@@ -70,9 +70,8 @@ module RASN1
       end
 
       def generate_value_with_correct_length
-        value = @value || ''
-        value << "\x00" while value.length * 8 < @bit_length.to_i
-        value.force_encoding('BINARY')
+        value = (@value || '').dup.force_encoding('BINARY')
+        value << "\x00".b while value.length * 8 < @bit_length.to_i
         return value unless value.length * 8 > @bit_length.to_i
 
         max_len = @bit_length.to_i / 8 + ((@bit_length.to_i % 8).positive? ? 1 : 0)
@@ -85,6 +84,10 @@ module RASN1
         @bit_length = value.length * 8 - unused
         @value = value
       end
+
+      def explicit_type
+        self.class.new(value: @value, bit_length: @bit_length)
+      end
     end
   end
 end

data/lib/rasn1/types/bmp_string.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RASN1
+  module Types
+    # ASN.1 BmpString
+    # @since 0.12.0
+    # @author adfoster-r7
+    class BmpString < OctetString
+      # BmpString id value
+      ID = 30
+
+      # Get ASN.1 type
+      # @return [String]
+      def self.type
+        'BmpString'
+      end
+
+      private
+
+      def value_to_der
+        @value.to_s.dup.encode('UTF-16BE').b
+      end
+
+      def der_to_value(der, ber: false)
+        super
+        @value = der.to_s.dup.force_encoding('UTF-16BE')
+      end
+    end
+  end
+end

data/lib/rasn1/types/choice.rb

@@ -100,7 +100,7 @@ module RASN1
       private
 
       def check_chosen
-        raise ChoiceError if !defined?(@chosen) || @chosen.nil?
+        raise ChoiceError.new(self) if !defined?(@chosen) || @chosen.nil?
       end
     end
   end

data/lib/rasn1/types/constrained.rb

@@ -3,7 +3,7 @@
 module RASN1
   module Types
     # Mixin to had constraints on a RASN1 type.
-    # Should not be used directly but through {Model.define_type}.
+    # Should not be used directly but through {Types.define_type}.
     # @version 0.11.0
     # @author Sylvain Daubert
     module Constrained

data/lib/rasn1/types/constructed.rb

@@ -10,6 +10,22 @@ module RASN1
       # Constructed value
       ASN1_PC = 0x20
 
+      # @return [Boolean]
+      # @since 0.12.0
+      # @see Base#can_build?
+      def can_build? # rubocop:disable Metrics/CyclomaticComplexity
+        return super unless @value.is_a?(Array) && optional?
+        return false unless super
+
+        @value.any? do |el|
+          el.can_build? && (
+            el.primitive? ||
+              (el.value.respond_to?(:empty?) ? !el.value.empty? : !el.value.nil?))
+        end
+      end
+
+      # @param [::Integer] level (default: 0)
+      # @return [String]
       def inspect(level=0)
         case @value
         when Array
@@ -18,7 +34,7 @@ module RASN1
           level = level.abs + 1
           @value.each do |item|
             case item
-            when Base, Model
+            when Base, Model, Wrapper
               str << "#{item.inspect(level)}\n"
             else
               str << '  ' * level

data/lib/rasn1/types/generalized_time.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'strptime'
+
 module RASN1
   module Types
     # ASN.1 GeneralizedTime
@@ -24,25 +26,33 @@ module RASN1
       # GeneralizedTime id value
       ID = 24
 
+      # @private
+      HOUR_TO_SEC = 3600
+      # @private
+      MINUTE_TO_SEC = 60
+      # @private
+      SECOND_TO_SEC = 1
+
       # Get ASN.1 type
       # @return [String]
       def self.type
         'GeneralizedTime'
       end
 
-      # @return [DateTime]
+      # @return [Time]
       def void_value
-        DateTime.now
+        Time.now
       end
 
       private
 
       def value_to_der
-        if @value.nsec.positive?
-          der = @value.getutc.strftime('%Y%m%d%H%M%S.%9NZ')
+        utc_value = @value.getutc
+        if utc_value.nsec.positive?
+          der = utc_value.strftime('%Y%m%d%H%M%S.%9NZ')
           der.sub(/0+Z/, 'Z')
         else
-          @value.getutc.strftime('%Y%m%d%H%M%SZ')
+          utc_value.strftime('%Y%m%d%H%M%SZ')
         end
       end
 
@@ -61,18 +71,13 @@ module RASN1
       end
 
       def value_when_fraction_empty(date_hour)
-        utc_offset_forced = false
-
         if (date_hour[-1] != 'Z') && (date_hour !~ /[+-]\d+$/)
           # If not UTC, have to add offset with UTC to force
-          # DateTime#strptime to generate a local time. But this difference
-          # may be errored because of DST.
+          # Strptime to generate a local time.
           date_hour << Time.now.strftime('%z')
-          utc_offset_forced = true
         end
 
         value_from(date_hour)
-        fix_dst if utc_offset_forced
       end
 
       def value_when_fraction_ends_with_z(date_hour, fraction)
@@ -90,62 +95,44 @@ module RASN1
           date_hour << match[2]
         else
           # fraction only contains fraction.
-          # Have to add offset with UTC to force DateTime#strptime to
-          # generate a local time. But this difference may be errored
-          # because of DST.
+          # Have to add offset with UTC to force Strptime to
+          # generate a local time.
           date_hour << Time.now.strftime('%z')
-          utc_offset_forced = true
         end
 
         frac_base = value_from(date_hour)
-        fix_dst if utc_offset_forced
         fix_value(fraction, frac_base)
       end
 
       def value_from(date_hour)
         format, frac_base = strformat(date_hour)
-        @value = DateTime.strptime(date_hour, format).to_time
+        @value = Strptime.new(format).exec(date_hour)
         frac_base
       end
 
-      # Check DST. There may be a shift of one hour...
-      def fix_dst
-        compare_time = Time.new(*@value.to_a[0..5].reverse)
-        @value = compare_time if compare_time.utc_offset != @value.utc_offset
-      end
-
       def fix_value(fraction, frac_base)
-        @value += ".#{fraction}".to_r * frac_base unless fraction.nil?
+        frac = ".#{fraction}".to_r * frac_base
+        @value = (@value + frac) unless fraction.nil?
       end
 
-      def strformat(date_hour) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
+      def strformat(date_hour)
         case date_hour.size
         when 11
-          frac_base = 60 * 60
-          format = '%Y%m%d%HZ'
-        when 13
-          frac_base = 60
-          format = '%Y%m%d%H%MZ'
+          ['%Y%m%d%H%z', HOUR_TO_SEC]
+        when 13, 17
+          ['%Y%m%d%H%M%z', MINUTE_TO_SEC]
         when 15
           if date_hour[-1] == 'Z'
-            frac_base = 1
-            format = '%Y%m%d%H%M%SZ'
+            ['%Y%m%d%H%M%S%z', SECOND_TO_SEC]
           else
-            frac_base = 60 * 60
-            format = '%Y%m%d%H%z'
+            ['%Y%m%d%H%z', HOUR_TO_SEC]
           end
-        when 17
-          frac_base = 60
-          format = '%Y%m%d%H%M%z'
         when 19
-          frac_base = 1
-          format = '%Y%m%d%H%M%S%z'
+          ['%Y%m%d%H%M%S%z', SECOND_TO_SEC]
         else
           prefix = @name.nil? ? type : "tag #{@name}"
-          raise ASN1Error, "#{prefix}: unrecognized format: #{der}"
+          raise ASN1Error, "#{prefix}: unrecognized format: #{date_hour}"
         end
-
-        [format, frac_base]
       end
     end
   end

data/lib/rasn1/types/ia5string.rb

@@ -17,12 +17,12 @@ module RASN1
       private
 
       def value_to_der
-        @value.to_s.force_encoding('US-ASCII').force_encoding('BINARY')
+        @value.to_s.dup.force_encoding('US-ASCII').b
       end
 
       def der_to_value(der, ber: false)
         super
-        @value.to_s.force_encoding('US-ASCII')
+        @value.to_s.dup.force_encoding('US-ASCII')
       end
     end
   end

data/lib/rasn1/types/integer.rb

@@ -133,8 +133,9 @@ module RASN1
         return if @enum.empty?
 
         int_value = @value
+        raise EnumeratedError, "#{@name}: value #{int_value} not in enumeration" unless @enum.value?(@value)
+
         @value = @enum.key(@value)
-        raise EnumeratedError, "#{@name}: value #{int_value} not in enumeration" unless value?
       end
 
       def explicit_type

data/lib/rasn1/types/null.rb

@@ -15,6 +15,10 @@ module RASN1
         str
       end
 
+      def can_build?
+        !optional?
+      end
+
       private
 
       def value_to_der

data/lib/rasn1/types/numeric_string.rb

@@ -18,7 +18,7 @@ module RASN1
 
       def value_to_der
         check_characters
-        @value.to_s.force_encoding('BINARY')
+        @value.to_s.b
       end
 
       def der_to_value(der, ber: false)

data/lib/rasn1/types/printable_string.rb

@@ -18,7 +18,7 @@ module RASN1
 
       def value_to_der
         check_characters
-        @value.to_s.force_encoding('BINARY')
+        @value.to_s.b
       end
 
       def der_to_value(der, ber: false)

data/lib/rasn1/types/sequence_of.rb

@@ -59,7 +59,6 @@ module RASN1
         Sequence.encoded_type
       end
 
-      # @param [Symbol, String] name name for this tag in grammar
       # @param [Class, Base] of_type base type for sequence of
       # @see Base#initialize
       def initialize(of_type, options={})
@@ -105,6 +104,7 @@ module RASN1
         @value.length
       end
 
+      # @return [String]
       def inspect(level=0)
         str = common_inspect(level)
         str << "\n"

data/lib/rasn1/types/utc_time.rb

@@ -35,20 +35,16 @@ module RASN1
 
       def der_to_value(der, ber: false) # rubocop:disable Lint/UnusedMethodArgument
         format = case der.size
-                 when 11
-                   '%Y%m%d%H%MZ'
-                 when 13
-                   '%Y%m%d%H%M%SZ'
-                 when 15
+                 when 11, 15
                    '%Y%m%d%H%M%z'
-                 when 17
+                 when 13, 17
                    '%Y%m%d%H%M%S%z'
                  else
                    prefix = @name.nil? ? type : "tag #{@name}"
                    raise ASN1Error, "#{prefix}: unrecognized format: #{der}"
                  end
         century = (Time.now.year / 100).to_s
-        @value = DateTime.strptime(century + der, format).to_time
+        @value = Strptime.new(format).exec(century + der)
       end
     end
   end

data/lib/rasn1/types/utf8_string.rb

@@ -17,12 +17,12 @@ module RASN1
       private
 
       def value_to_der
-        @value.to_s.force_encoding('UTF-8').force_encoding('BINARY')
+        @value.to_s.dup.force_encoding('UTF-8').b
       end
 
       def der_to_value(der, ber: false)
         super
-        @value = der.force_encoding('UTF-8')
+        @value = der.dup.force_encoding('UTF-8')
       end
     end
   end

data/lib/rasn1/types.rb

@@ -4,18 +4,25 @@ module RASN1
   # This modules is a namesapce for all ASN.1 type classes.
   # @author Sylvain Daubert
   module Types
+    @primitives = []
+    @constructed = []
+
     # Give all primitive types
     # @return [Array<Types::Primitive>]
     def self.primitives
-      @primitives ||= self.constants.map { |c| Types.const_get(c) }
-                          .select { |klass| klass < Primitive }
+      return @primitives unless @primitives.empty?
+
+      @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 }
+      return @constructed unless @constructed.empty?
+
+      @constructed = self.constants.map { |c| Types.const_get(c) }
+                         .select { |klass| klass < Constructed }
     end
 
     # @private
@@ -67,8 +74,8 @@ module RASN1
     def self.generate_id2type_cache
       constructed = self.constructed - [Types::SequenceOf, Types::SetOf]
       primitives = self.primitives - [Types::Enumerated]
-      ary = (primitives + constructed).select { |type| type.const_defined? :ID }
-                                      .map { |type| [type::ID, type] }
+      ary = (primitives + constructed).select { |type| type.const_defined?(:ID) }
+                                      .map { |type| [type.const_get(:ID), type] }
       @id2types = ary.to_h
       @id2types.default = Types::Base
       @id2types.freeze
@@ -77,9 +84,12 @@ module RASN1
     # Define a new ASN.1 type from a base one.
     # This new type may have a constraint defines on it.
     # @param [Symbol,String] name New type name. Must start with a capital letter.
-    # @param [Types::Base] from
+    # @param [Types::Base] from class from which inherits
+    # @param [Module] in_module module in which creates new type (default to {RASN1::Types})
     # @return [Class] newly created class
-    def self.define_type(name, from:, &block)
+    # @since 0.11.0
+    # @since 0.12.0 in_module parameter
+    def self.define_type(name, from:, in_module: self, &block)
       constraint = block.nil? ? nil : block.to_proc
 
       new_klass = Class.new(from) do
@@ -87,12 +97,13 @@ module RASN1
       end
       new_klass.constraint = constraint
 
-      self.const_set(name, new_klass)
-      Model.define_type_accel(name.downcase, new_klass)
+      in_module.const_set(name, new_klass)
+      accel_name = name.to_s.gsub(/([a-z])([A-Z])/, '\1_\2').downcase
+      Model.define_type_accel(accel_name, new_klass)
 
       # Empty type caches
-      @primitives = nil
-      @constructed = nil
+      @primitives = []
+      @constructed = []
 
       new_klass
     end
@@ -108,6 +119,7 @@ require_relative 'types/octet_string'
 require_relative 'types/null'
 require_relative 'types/object_id'
 require_relative 'types/enumerated'
+require_relative 'types/bmp_string'
 require_relative 'types/utf8_string'
 require_relative 'types/numeric_string'
 require_relative 'types/printable_string'

data/lib/rasn1/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RASN1
-  VERSION = '0.11.0'
+  VERSION = '0.12.0'
 end

data/lib/rasn1/wrapper.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require 'delegate'
+
+module RASN1
+  # This class is used to wrap a {Types::Base} or {Model} instance to force its options.
+  #
+  # == Usage
+  # This class may be used to wrap another RASN1 object by 3 ways:
+  # * wrap an object to modify its options,
+  # * implicitly wrap an object (i.e. change its tag),
+  # * explicitly wrap an object (i.e wrap the object in another explicit ASN.1 tag)
+  #
+  # @example
+  #   # object to wrap
+  #   int = RASN1::Types::Integer.new(implicit: 1)    # its tag is 0x81
+  #   # simple wraper, change an option
+  #   wrapper = RASN1::Wrapper.new(int, optional: true, default: 1)
+  #   # implicit wrapper
+  #   wrapper = RASN1::Wrapper.new(int, implicit: 3)  # wrapped int tag is now 0x83
+  #   # explicit wrapper
+  #   wrapper = RASN1::Wrapper.new(int, explicit: 4)  # int tag is always 0x81, but it is wrapped in a 0x84 tag
+  # @since 0.12.0
+  class Wrapper < SimpleDelegator
+    # @private Private class used to build/parse explicit wrappers
+    class ExplicitWrapper < Types::Base
+      ID = 0 # not used
+      ASN1_PC = 0 # not constructed
+
+      def self.type
+        ''
+      end
+
+      # @return [Boolean]
+      # @see Types::Base#can_build?
+      def can_build?
+        ok = super
+        return ok unless optional?
+
+        ok && @value.can_build?
+      end
+
+      private
+
+      def value_to_der
+        @value.is_a?(String) ? @value : @value.to_der
+      end
+
+      def inspect_value
+        ''
+      end
+    end
+
+    # @param [Types::Base,Model] element element to wrap
+    # @param [Hash] options
+    def initialize(element, options={})
+      opts = explicit_implicit(options)
+
+      if explicit?
+        generate_explicit_wrapper(opts)
+        element.options = element.options.merge(generate_explicit_wrapper_options(opts))
+        @options = opts
+      else
+        opts[:value] = element.value
+        element.options = element.options.merge(opts)
+        @options = {}
+      end
+      raise RASN1::Error, 'Cannot be implicit and explicit' if explicit? && implicit?
+
+      super(element)
+    end
+
+    def explicit_implicit(options)
+      opts = options.dup
+      @explicit = opts.delete(:explicit)
+      @implicit = opts.delete(:implicit)
+      opts
+    end
+
+    def generate_explicit_wrapper(options)
+      # ExplicitWrapper is a hand-made explicit tag, but we have to use its implicit option
+      # to force its tag value.
+      @explicit_wrapper = ExplicitWrapper.new(options.merge(implicit: @explicit))
+    end
+
+    def generate_explicit_wrapper_options(options)
+      new_opts = {}
+      new_opts[:default] = options[:default] if options.key?(:default)
+      new_opts[:optional] = options[:optional] if options.key?(:optional)
+      new_opts
+    end
+
+    # Say if wrapper is an explicit one (i.e. add tag and length to its element)
+    # @return [Boolean]
+    def explicit?
+      !!@explicit
+    end
+
+    # Say if wrapper is an implicit one (i.e. change tag of its element)
+    # @return [Boolean]
+    def implicit?
+      !!@implicit
+    end
+
+    # Convert wrapper and its element to a DER string
+    # @return [String]
+    def to_der
+      if implicit?
+        el = generate_implicit_element
+        el.to_der
+      elsif explicit?
+        @explicit_wrapper.value = element
+        @explicit_wrapper.to_der
+      else
+        element.to_der
+      end
+    end
+
+    # Parse a DER string. This method updates object.
+    # @param [String] der DER string
+    # @param [Boolean] ber if +true+, accept BER encoding
+    # @return [Integer] total number of parsed bytes
+    # @raise [ASN1Error] error on parsing
+    def parse!(der, ber: false)
+      if implicit?
+        el = generate_implicit_element
+        parsed = el.parse!(der, ber: ber)
+        element.value = el.value
+        parsed
+      elsif explicit?
+        parsed = @explicit_wrapper.parse!(der, ber: ber)
+        element.parse!(@explicit_wrapper.value, ber: ber) if parsed.positive?
+        parsed
+      else
+        element.parse!(der, ber: ber)
+      end
+    end
+
+    def value?
+      if explicit?
+        @explicit_wrapper.value?
+      else
+        __getobj__.value?
+      end
+    end
+
+    # Return Wrapped element
+    # @return [Types::Base,Model]
+    def element
+      __getobj__
+    end
+
+    # @return [::Integer]
+    def id
+      if implicit?
+        @implicit
+      elsif explicit?
+        @explicit
+      else
+        element.id
+      end
+    end
+
+    # @return [Symbol]
+    def asn1_class
+      return element.asn1_class unless @options.key?(:class)
+
+      @options[:class]
+    end
+
+    # @return [Boolean]
+    def constructed?
+      return element.constructed? unless @options.key?(:constructed)
+
+      @options[:constructed]
+    end
+
+    # @return [Boolean]
+    def primitive?
+      !constructed?
+    end
+
+    def inspect(level=0)
+      return super(level) unless explicit?
+
+      @explicit_wrapper.inspect(level) << ' ' << super(level)
+    end
+
+    private
+
+    def generate_implicit_element
+      el = element.dup
+      if el.explicit?
+        el.options = el.options.merge(explicit: @implicit)
+      elsif el.implicit?
+        el.options = el.options.merge(implicit: @implicit)
+      end
+      el
+    end
+  end
+end

data/lib/rasn1.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
-require 'rasn1/version'
-require 'rasn1/errors'
-require 'rasn1/types'
-require 'rasn1/model'
+require_relative 'rasn1/version'
+require_relative 'rasn1/errors'
+require_relative 'rasn1/types'
+require_relative 'rasn1/model'
+require_relative 'rasn1/wrapper'
 
 # Rasn1 is a pure ruby library to parse, decode and encode ASN.1 data.
 # @author Sylvain Daubert

metadata

@@ -1,57 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: rasn1
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.12.0
 platform: ruby
 authors:
 - Sylvain Daubert
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-10-13 00:00:00.000000000 Z
+date: 2022-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: strptime
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '12.3'
-  type: :development
+        version: 0.2.5
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '12.3'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-- !ruby/object:Gem::Dependency
-  name: yard
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.9'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.9'
+        version: 0.2.5
 description: |
   RASN1 is a pure ruby ASN.1 library. It may encode and decode DER and BER
   encodings.
@@ -72,6 +44,7 @@ files:
 - lib/rasn1/types/any.rb
 - lib/rasn1/types/base.rb
 - lib/rasn1/types/bit_string.rb
+- lib/rasn1/types/bmp_string.rb
 - lib/rasn1/types/boolean.rb
 - lib/rasn1/types/choice.rb
 - lib/rasn1/types/constrained.rb
@@ -94,6 +67,7 @@ files:
 - lib/rasn1/types/utf8_string.rb
 - lib/rasn1/types/visible_string.rb
 - lib/rasn1/version.rb
+- lib/rasn1/wrapper.rb
 homepage: https://github.com/sdaubert/rasn1
 licenses:
 - MIT