rasn2 0.16.0

data/lib/rasn1/types/sequence_of.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+module RASN1
+  module Types
+    # ASN.1 SEQUENCE OF
+    #
+    # A SEQUENCE OF is an array of one ASN.1 type.
+    #
+    # == Use with {Primitive} types
+    # To encode this ASN.1 example:
+    #  Integers ::= SEQUENCE OF INTEGER
+    # do:
+    #  # Create a SEQUENCE OF INTEGER
+    #  seqof = RASN1::Types::SequenceOf.new(RASN1::Types::Integer)
+    #  # Set integer values
+    #  seqof.value = [1, 2, 3, 4].map { |i| RASN1::Types::Integer.new(value: i) }
+    #  seqof << 5   # infer a RASN1::Types::Integer with given value
+    #
+    # == Use with {Constructed} types
+    # SEQUENCE OF may be used to create sequence of composed types. For example:
+    #  composed_type = RASN1::Types::Sequence.new
+    #  commposed_type.value = [RASN1::Types::Integer,
+    #                          RASN1::Types::OctetString]
+    #  seqof = RASN1::Types::SequenceOf.new(composed_type)
+    #  seqof << [0, 'data0']
+    #  seqof << [1, 'data1']
+    #
+    # == Use with {Model}
+    # SEQUENCE OF may also be used with a Model type:
+    #  class MyModel < RASN1::Model
+    #    sequence :seq,
+    #             content: [boolean(:bool), integer(:int)]
+    #  end
+    #
+    #  seqof = RASN1::Types::SequenceOf.new(:record, MyModel)
+    #  # set values
+    #  seqof << { bool: true, int: 12 }
+    #  seqof << { bool: false, int: 65535 }
+    #  # Generate DER string
+    #  der = seqof.to_der    # => String
+    #  # parse
+    #  seqof.parse! der
+    #
+    # After parsing, a SEQUENCE OF may be accessed as an Array:
+    #  seqof[0]                # => MyModel
+    #  seqof[0][:bool].value   # => true
+    #  seqof[0][:int].value    # => 12
+    # @author Sylvain Daubert
+    class SequenceOf < Constructed
+      # SequenceOf id value
+      ID = Sequence::ID
+
+      # @return [Class, Base]
+      attr_reader :of_type
+
+      # A SEQUENCE OF is encoded as a SEQUENCE.
+      # @return ['SEQUENCE']
+      def self.encoded_type
+        Sequence.encoded_type
+      end
+
+      # @param [Class, Base] of_type base type for sequence of
+      # @see Base#initialize
+      def initialize(of_type, options={})
+        super(options)
+        @of_type = of_type
+        @no_value = false
+      end
+
+      # Clone @#of_type and values
+      def initialize_copy(*)
+        super
+        @of_type = @of_type.dup
+        @value = @value.map(&:dup)
+      end
+
+      # @return [Array]
+      def void_value
+        []
+      end
+
+      # Add an item to SEQUENCE OF
+      # @param [Object] obj
+      # @note
+      #   * if a SEQUENCE OF primitive type, +obj+ is an instance of primitive type or equivalent Ruby type
+      #   * if a SEQUENCE OF composed type, +obj+ is an array of ruby type instances
+      #   * if a SEQUENCE OF model, +obj+ is either a Model or a Hash
+      def <<(obj)
+        return push_primitive(obj) if of_type_class < Primitive
+        return push_composed_array(obj) if composed_of_type?
+
+        push_model(obj)
+      end
+
+      # Get element of index +idx+
+      # @param [Integer] idx
+      # @return [Base]
+      def [](idx)
+        @value[idx]
+      end
+
+      # Get length of SEQUENCE OF (ie number of elements)
+      # @return [Integer]
+      def length
+        @value.length
+      end
+
+      # @param [::Integer] level
+      # @return [String]
+      def inspect(level=0)
+        str = common_inspect(level)
+        str << "\n"
+        level = level.abs + 1
+        @value.each do |item|
+          case item
+          when Base, Model
+            next if item.optional? && item.value.nil?
+
+            str << item.inspect(level)
+            str << "\n" unless str.end_with?("\n")
+          else
+            str << ('  ' * level) << "#{item.inspect}\n"
+          end
+        end
+        str
+      end
+
+      # Make sequence of value from +der+ string
+      # @param [String] der
+      # @param [::Boolean] ber
+      # @return [void]
+      def der_to_value(der, ber: false) # rubocop:disable Lint/UnusedMethodArgument
+        @value = []
+        nb_bytes = 0
+
+        while nb_bytes < der.length
+          type = of_type_class.new
+          nb_bytes += type.parse!(der[nb_bytes, der.length])
+          @value << type
+        end
+      end
+
+      private
+
+      def of_type_class
+        @of_type.is_a?(Class) ? @of_type : @of_type.class
+      end
+
+      def composed_of_type?
+        !@of_type.is_a?(Class) && [Sequence, Set].include?(of_type_class)
+      end
+
+      def value_to_der
+        @value.map(&:to_der).join
+      end
+
+      def explicit_type
+        self.class.new(self.of_type, name: name)
+      end
+
+      def push_primitive(obj)
+        @value <<
+          case obj
+          when Primitive
+            obj
+          else
+            of_type_class.new(value: obj)
+          end
+      end
+
+      def push_composed_array(obj)
+        raise ASN1Error, 'object to add should be an Array' unless obj.is_a?(Array)
+
+        new_value = of_type_class.new
+        @of_type.value.each_with_index do |type, i|
+          type2 = type.dup
+          type2.value = obj[i]
+          new_value.value << type2
+        end
+        @value << new_value
+      end
+
+      def push_model(obj)
+        case obj
+        when Hash
+          @value << of_type_class.new(obj)
+        when of_type_class
+          @value << obj
+        else
+          raise ASN1Error, "object to add should be a #{of_type_class} or a Hash"
+        end
+      end
+
+      def trace_data
+        ''
+      end
+    end
+  end
+end

data/lib/rasn1/types/set.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RASN1
+  module Types
+    # ASN.1 set
+    #
+    # A set is a collection of another ASN.1 types.
+    #
+    # To encode this ASN.1 example:
+    #  Record ::= SET {
+    #    id        INTEGER,
+    #    room  [0] INTEGER OPTIONAL,
+    #    house [1] IMPLICIT INTEGER DEFAULT 0
+    #  }
+    # do:
+    #  set = RASN1::Types::Set.new
+    #  set.value = [
+    #               RASN1::Types::Integer
+    #               RASN1::Types::Integer(explicit: 0, optional: true),
+    #               RASN1::Types::Integer(implicit: 1, default: 0)
+    #              ]
+    # @author Sylvain Daubert
+    class Set < Sequence
+      # Set id value
+      ID = 0x11
+    end
+  end
+end

data/lib/rasn1/types/set_of.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RASN1
+  module Types
+    # ASN.1 SET OF
+    # @author Sylvain Daubert
+    class SetOf < SequenceOf
+      # SetOf id value
+      ID = Set::ID
+
+      # A SET OF is encoded as a SET.
+      # @return ['SET']
+      def self.encoded_type
+        Set.encoded_type
+      end
+    end
+  end
+end

data/lib/rasn1/types/tag.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+module RASN1
+  module Types
+    # ASN.1 Tag constructed type.
+    #
+    # A Tag type is a constructed element with schematized content
+    # (child elements, like a {Sequence}) that can be bound to flexible tag
+    # criteria instead of a fixed universal tag:
+    # * a single tag number,
+    # * a list of possible tag numbers,
+    # * any private-class tag.
+    #
+    # == Binding to a single tag
+    #   # Context-class tag 5 (default class is :context)
+    #   generic = Tag.new(tag: 5, value: [Integer.new, OctetString.new])
+    #   # Application-class tag 10
+    #   generic = Tag.new(tag: 10, class: :application, value: [Integer.new])
+    #
+    # == Binding to a list of tags
+    #   generic = Tag.new(tag: [5, 6, 7], value: [Integer.new, OctetString.new])
+    #
+    # == Binding to any private tag
+    #   generic = Tag.new(tag: :private, value: [Integer.new, OctetString.new])
+    #   # or equivalently
+    #   generic = Tag.new(any_private: true, value: [Integer.new])
+    class Tag < Constructed
+      # Placeholder ID — not used directly; tag is always dynamic.
+      ID = 0
+
+      # @return [Integer, nil] the tag number that was matched during parsing
+      attr_reader :matched_tag
+
+      # @param [Hash] options
+      # @option options [Integer, Array<Integer>, :private] :tag tag number(s) to
+      #   bind to, or +:private+ to accept any private-class tag
+      # @option options [Boolean] :any_private if +true+, accept any private-class tag
+      # @see Base#initialize
+      def initialize(options={})
+        extract_tag_binding(options)
+        super
+        @no_value = false
+        @value ||= []
+      end
+
+      # Deep copy
+      def initialize_copy(*)
+        super
+        @value = case @value
+                 when Array then @value.map(&:dup)
+                 else @value.dup
+                 end
+        @accepted_tags = @accepted_tags.dup
+      end
+
+      # @return [Array]
+      def void_value
+        []
+      end
+
+      # Get element by index or name
+      # @param [Integer, String, Symbol] idx_or_name
+      # @return [Object, nil]
+      def [](idx_or_name)
+        return unless @value.is_a?(Array)
+
+        case idx_or_name
+        when ::Integer
+          @value[idx_or_name.to_i]
+        when String, Symbol
+          @value.find { |elt| elt.name == idx_or_name }
+        end
+      end
+
+      # Parse constructed content from DER
+      # @param [String] der
+      # @param [Boolean] ber
+      # @return [void]
+      def der_to_value(der, ber: false) # rubocop:disable Lint/UnusedMethodArgument
+        if @value.is_a?(Array) && !@value.empty?
+          nb_bytes = 0
+          @value.each do |element|
+            nb_bytes += element.parse!(der[nb_bytes..])
+          end
+        else
+          @value = der
+          der.length
+        end
+      end
+
+      private
+
+      def extract_tag_binding(options)
+        tag = options.delete(:tag)
+        @any_private = !options.delete(:any_private).nil?
+
+        @accepted_tags = case tag
+                         when Array then tag
+                         when ::Integer then [tag]
+                         when :private
+                           @any_private = true
+                           []
+                         else
+                           []
+                         end
+
+        if @any_private
+          options[:class] ||= :private
+          options[:implicit] = @accepted_tags.first if @accepted_tags.any?
+        elsif @accepted_tags.any?
+          options[:class] ||= :context
+          options[:implicit] = @accepted_tags.first
+        end
+      end
+
+      def check_id(der)
+        return check_any_private_id(der) if @any_private && @accepted_tags.empty?
+        return check_multi_tag_id(der) if @accepted_tags.length > 1
+
+        super
+      end
+
+      def check_any_private_id(der)
+        return no_match(der) if der.nil? || der.empty?
+
+        first_octet = der.unpack1('C').to_i
+        asn1_class_bits = first_octet & CLASS_MASK
+        if asn1_class_bits == CLASSES[:private]
+          _, _, tag_id, = Types.decode_identifier_octets(der)
+          @id_value = tag_id
+          @matched_tag = tag_id
+          true
+        else
+          no_match(der)
+        end
+      end
+
+      def check_multi_tag_id(der)
+        original_id = @id_value
+        @accepted_tags.each do |tag|
+          @id_value = tag
+          expected_id = encode_identifier_octets
+          real_id = der[0, expected_id.size]
+          if real_id == expected_id
+            @matched_tag = tag
+            return true
+          end
+        end
+        @id_value = original_id
+        no_match(der)
+      end
+
+      def no_match(der)
+        if optional?
+          @no_value = true
+          @value = void_value
+        elsif !@default.nil?
+          @value = @default
+        else
+          raise_id_error(der)
+        end
+        false
+      end
+
+      def value_to_der
+        case @value
+        when Array then @value.map(&:to_der).join
+        else @value.to_s
+        end
+      end
+
+      def trace_data
+        ''
+      end
+
+      def explicit_type
+        opts = { name: name, value: @value }
+        if @accepted_tags.length == 1
+          opts[:tag] = @accepted_tags.first
+        elsif @accepted_tags.length > 1
+          opts[:tag] = @accepted_tags
+        end
+        opts[:any_private] = true if @any_private
+        opts[:class] = @asn1_class unless @asn1_class == :universal
+        self.class.new(opts)
+      end
+    end
+  end
+end

data/lib/rasn1/types/universal_string.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RASN1
+  module Types
+    # ASN.1 UniversalString
+    # @since 0.13.0
+    # @author zeroSteiner
+    class UniversalString < OctetString
+      # UniversalString id value
+      ID = 28
+      # UniversalString encoding
+      # @since 0.15.0
+      ENCODING = Encoding::UTF_32BE
+
+      # Get ASN.1 type
+      # @return [String]
+      def self.type
+        'UniversalString'
+      end
+    end
+  end
+end

data/lib/rasn1/types/utc_time.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module RASN1
+  module Types
+    # ASN.1 UTCTime
+    #
+    # +{#value} of a +UtcTime+ should be a ruby Time.
+    #
+    # ===Notes
+    # When encoding, resulting string is always a UTC time, appended with +Z+.
+    # Seconds are always generated.
+    #
+    # On parsing, UTC times (ending with +Z+) and local times (ending with
+    # +sHHMM+, where +s+ is +++ or +-+, and +HHMM+ is the time differential
+    # betwen UTC and local time) are both supported. Seconds may be present or
+    # not.
+    # @author Sylvain Daubert
+    class UtcTime < Primitive
+      # UtcTime id value
+      ID = 23
+
+      # Get ASN.1 type
+      # @return [String]
+      def self.type
+        'UTCTime'
+      end
+
+      # Make time value from +der+ string
+      # @param [String] der
+      # @param [::Boolean] ber
+      # @return [void]
+      # @raise [ASN1Error] unrecognized  time format
+      def der_to_value(der, ber: false) # rubocop:disable Lint/UnusedMethodArgument
+        format = case der.size
+                 when 11, 15
+                   '%Y%m%d%H%M%z'
+                 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
+        begin
+          @value = Strptime.new(format).exec(century + der)
+        rescue ArgumentError
+          prefix = @name.nil? ? type : "tag #{@name}"
+          raise ASN1Error, "#{prefix}: unrecognized format: #{der}"
+        end
+      end
+
+      private
+
+      def value_to_der
+        @value.getutc.strftime('%y%m%d%H%M%SZ')
+      end
+
+      def trace_data
+        return super if explicit?
+
+        +'    ' << raw_data
+      end
+    end
+  end
+end

data/lib/rasn1/types/utf8_string.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RASN1
+  module Types
+    # ASN.1 UTF8 String
+    # @author Sylvain Daubert
+    class Utf8String < OctetString
+      # Utf8String id value
+      ID = 12
+      # Utf8String encoding
+      # @since 0.15.0
+      ENCODING = Encoding::UTF_8
+
+      # Get ASN.1 type
+      # @return [String]
+      def self.type
+        'UTF8String'
+      end
+    end
+  end
+end

data/lib/rasn1/types/visible_string.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RASN1
+  module Types
+    # Create VisibleString as a Constrained subclass of IA5String
+    Types.define_type(:VisibleString, from: IA5String) do |value|
+      value.nil? || value.chars.all? { |c| c.ord.between?(32, 126) }
+    end
+
+    # ASN.1 Visible String
+    #
+    # VisibleString may only contain ASCII characters from range 32 to 126.
+    # @author LemonTree55
+    # @since 0.3.0
+    # @since 0.15.0 VisibleString is defined as a constrained {IA5String}. It will now raise if value contains a non-visible character.
+    class VisibleString
+      # VisibleString id value
+      # @since 0.3.0
+      ID = 26
+
+      # Get ASN.1 type
+      # @return [String]
+      # @author Sylvain Daubert
+      # @since 0.3.0
+      def self.type
+        'VisibleString'
+      end
+    end
+  end
+end