rasn2 0.16.0

data/lib/rasn1/types/bit_string.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module RASN1
+  module Types
+    # ASN.1 Bit String
+    # @author Sylvain Daubert
+    class BitString < Primitive
+      # BitString id value
+      ID = 3
+
+      # @return [Integer]
+      attr_writer :bit_length
+
+      # @param [Hash] options
+      # @option options [Object] :bit_length default bit_length value. Should be
+      #   present if +:default+ is set
+      # @see Base#initialize common options to all ASN.1 types
+      def initialize(options={})
+        super
+        if @default
+          raise ASN1Error, "#{@name}: default bit length is not defined" if @options[:bit_length].nil?
+
+          @default_bit_length = @options[:bit_length]
+        end
+        @bit_length = @options[:bit_length]
+      end
+
+      # Get bit length
+      def bit_length
+        if value?
+          @bit_length
+        else
+          @default_bit_length
+        end
+      end
+
+      # @param [Integer] level
+      # @return [String]
+      def inspect(level=0)
+        str = common_inspect(level)
+        str << " #{value.inspect} (bit length: #{bit_length})"
+      end
+
+      # Same as {Base#can_build?} but also check bit_length
+      # @see Base#can_build?
+      # @return [Boolean]
+      def can_build?
+        super || (!@default.nil? && (@bit_length != @default_bit_length))
+      end
+
+      # Make value from DER/BER string. Also set {#bit_length}.
+      # @param [String] der
+      # @param [::Boolean] ber
+      # @return [void]
+      # @see Types::Base#der_to_value
+      def der_to_value(der, ber: false) # rubocop:disable Lint/UnusedMethodArgument
+        unused = der.unpack1('C').to_i
+        value = der[1..].to_s
+        @bit_length = value.length * 8 - unused
+        @value = value
+      end
+
+      private
+
+      # @author Sylvain Daubert
+      # @author adfoster-r7
+      def value_to_der
+        raise ASN1Error, "#{@name}: bit length is not set" if bit_length.nil?
+
+        value = generate_value_with_correct_length
+
+        unused = value.length * 8 - @bit_length.to_i
+        der = [unused, value].pack('CA*')
+
+        if unused.positive?
+          last_byte = value[-1].to_s.unpack1('C').to_i
+          last_byte &= (0xff >> unused) << unused
+          der[-1] = [last_byte].pack('C')
+        end
+
+        @value = value
+
+        der
+      end
+
+      def generate_value_with_correct_length
+        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)
+        value[0, max_len].to_s
+      end
+
+      def explicit_type
+        self.class.new(name: name, value: @value, bit_length: @bit_length)
+      end
+    end
+  end
+end

data/lib/rasn1/types/bmp_string.rb

@@ -0,0 +1,22 @@
+# 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
+      # UniversalString encoding
+      # @since 0.15.0
+      ENCODING = Encoding::UTF_16BE
+
+      # Get ASN.1 type
+      # @return [String]
+      def self.type
+        'BmpString'
+      end
+    end
+  end
+end

data/lib/rasn1/types/boolean.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RASN1
+  module Types
+    # ASN.1 Boolean
+    # @author Sylvain Daubert
+    class Boolean < Primitive
+      # Boolean id value
+      ID = 0x01
+
+      # DER true value
+      DER_TRUE = 0xff
+      # DER false value
+      DER_FALSE = 0
+
+      # @return [false]
+      def void_value # rubocop:disable Naming/PredicateMethod
+        false
+      end
+
+      # Make boolean value from DER/BER string.
+      # @param [String] der
+      # @param [::Boolean] ber
+      # @return [void]
+      # @see Types::Base#der_to_value
+      # @raise [ASN1Error] +der+ is not 1-byte long
+      # @raise [ASN1Error] +der+ is not {DER_TRUE} nor {DER_FALSE} and +ber+ is +false+
+      def der_to_value(der, ber: false)
+        raise ASN1Error, "tag #{@name}: BOOLEAN should have a length of 1" unless der.size == 1
+
+        bool = der.unpack1('C')
+        case bool
+        when DER_FALSE
+          @value = false
+        when DER_TRUE
+          @value = true
+        else
+          raise ASN1Error, "tag #{@name}: bad value 0x%02x for BOOLEAN" % bool unless ber
+
+          @value = true
+        end
+      end
+
+      private
+
+      def value_to_der
+        [@value ? DER_TRUE : DER_FALSE].pack('C')
+      end
+
+      def trace_data
+        return super if explicit?
+
+        '    ' + colorize_bool(raw_data != "\x00".b, raw_data.unpack1('H*'))
+      end
+    end
+  end
+end

data/lib/rasn1/types/choice.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module RASN1
+  module Types
+    # A ASN.1 CHOICE is a choice between different types.
+    #
+    # == Create a CHOICE
+    # A CHOICE is defined this way:
+    #   choice = Choice.new
+    #   choice.value = [Integer.new(implicit: 0, class: :context),
+    #                   Integer.new(implicit: 1, class: :context),
+    #                   OctetString.new(implicit: 2, class: :context)]
+    # The chosen type may be set this way:
+    #   choice.chosen = 0   # choose :int1
+    # The chosen value may be set these ways:
+    #   choise.value[choice.chosen].value = 1
+    #   choise.set_chosen_value 1
+    # The chosen value may be got these ways:
+    #   choise.value[choice.chosen].value # => 1
+    #   choice.chosen_value               # => 1
+    #
+    # == Encode a CHOICE
+    # {#to_der} only encodes the chosen value:
+    #   choise.to_der   # => "\x80\x01\x01"
+    #
+    # == Parse a CHOICE
+    # Parsing a CHOICE set {#chosen} and set value to chosen type. If parsed string does
+    # not contain a type from CHOICE, a {RASN1::ASN1Error} is raised.
+    #   str = "\x04\x03abc"
+    #   choice.parse! str
+    #   choice.chosen        # => 2
+    #   choice.chosen_value  # => "abc"
+    # @author Sylvain Daubert
+    class Choice < Base
+      # Chosen type
+      # @return [Integer] index of type in choice value
+      attr_accessor :chosen
+
+      # Set chosen value.
+      # @note {#chosen} MUST be set before calling this method
+      # @param [Object] value
+      # @return [Object] value
+      # @raise [ChoiceError] {#chosen} not set
+      def set_chosen_value(value) # rubocop:disable Naming/AccessorMethodName
+        check_chosen
+        @value[@chosen].value = value
+      end
+
+      # Get chosen value
+      # @note {#chosen} MUST be set before calling this method
+      # @return [Object] value
+      # @raise [ChoiceError] {#chosen} not set
+      def chosen_value
+        check_chosen
+        case @value[@chosen]
+        when Base
+          @value[@chosen].value
+        when Model
+          @value[@chosen]
+        when Wrapper
+          @value[@chosen].element
+        end
+      end
+
+      # @note {#chosen} MUST be set before calling this method
+      # @return [String] DER-formated string
+      # @raise [ChoiceError] {#chosen} not set
+      def to_der
+        check_chosen
+        @value[@chosen].to_der
+      end
+
+      # Parse a DER string. This method updates object by setting {#chosen} and
+      # chosen value.
+      # @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)
+        len, data = do_parse(der, ber: ber)
+        return 0 if len.zero?
+
+        element = @value[@chosen]
+        if element.explicit?
+          element.do_parse_explicit(data)
+        else
+          element.der_to_value(data, ber: ber)
+        end
+        len
+      end
+
+      # @private
+      # @see Types::Base#do_parse
+      # @since 0.15.0 Specific +#do_parse+ to handle recursivity
+      def do_parse(der, ber: false)
+        @value.each_with_index do |element, i|
+          @chosen = i
+          return element.do_parse(der, ber: ber)
+        rescue ASN1Error
+          @chosen = nil
+          next
+        end
+
+        @no_value = true
+        @value = void_value
+        raise ASN1Error, "CHOICE #{@name}: no type matching #{der.inspect}" unless optional?
+
+        [0, ''.b]
+      end
+
+      # Make choice value from DER/BER string.
+      # @param [String] der
+      # @param [::Boolean] ber
+      # @return [void]
+      # @since 0.15.0 Specific +#der_to_value+ to handle recursivity
+      def der_to_value(der, ber: false)
+        @value.each_with_index do |element, i|
+          @chosen = i
+          element.parse!(der, ber: ber)
+          break
+        rescue ASN1Error
+          @chosen = nil
+          next
+        end
+      end
+
+      # @param [::Integer] level
+      # @return [String]
+      def inspect(level=0)
+        str = common_inspect(level)
+        str << if defined?(@chosen) && value?
+                 "\n#{@value[@chosen].inspect(level + 1)}"
+               else
+                 ' not chosen!'
+               end
+      end
+
+      # @private Tracer private API
+      # @return [String]
+      def trace
+        msg_type(no_id: true)
+      end
+
+      # Return empty array
+      # @return [Array()]
+      # @since 0.15.0
+      def void_value
+        []
+      end
+
+      private
+
+      def check_chosen
+        raise ChoiceError.new(self) if !defined?(@chosen) || @chosen.nil?
+      end
+    end
+  end
+end

data/lib/rasn1/types/constrained.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RASN1
+  module Types
+    # Mixin to add constraints on a RASN1 type.
+    # Should not be used directly but through {Types.define_type}.
+    # @version 0.11.0
+    # @author Sylvain Daubert
+    module Constrained
+      # Define class/module methods for {Constrained} module
+      module ClassMethods
+        # @return [Proc] proc to check constraints
+        attr_accessor :constraint
+
+        # Check if a constraint is really defined
+        # @return [Boolean]
+        def constrained?
+          @constraint.is_a?(Proc)
+        end
+
+        # Check constraint, if defined
+        # @param [Object] value the value of the type to check
+        # @raise [ConstraintError] constraint is not verified
+        def check_constraint(value)
+          return unless constrained?
+          raise ConstraintError.new(self) unless @constraint.call(value)
+        end
+      end
+
+      extend ClassMethods
+
+      # Redefined +#value=+ to check constraint before assigning +val+
+      # @see Types::Base#value=
+      # @raise [ConstraintError] constraint is not verified
+      def value=(val)
+        self.class.check_constraint(val)
+        super
+      end
+
+      # Make value from +der+ string and check constraints
+      # @param [String] der
+      # @param [::Boolean] ber
+      # @return [void]
+      # @raise [ConstraintError] constraint is not verified
+      def der_to_value(der, ber: false)
+        super
+        self.class.check_constraint(@value)
+      end
+    end
+  end
+end

data/lib/rasn1/types/constructed.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RASN1
+  module Types
+    # @abstract This class SHOULD be used as base class for all ASN.1 primitive
+    #  types.
+    # Base class for all ASN.1 constructed types
+    # @author Sylvain Daubert
+    class Constructed < Base
+      # 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
+          str = common_inspect(level)
+          str << "\n"
+          level = level.abs + 1
+          @value.each do |item|
+            case item
+            when Base, Model, Wrapper
+              str << "#{item.inspect(level)}\n"
+            else
+              str << '  ' * level
+              str << "#{item.inspect}\n"
+            end
+          end
+          str
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/rasn1/types/enumerated.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RASN1
+  module Types
+    # ASN.1 Enumerated
+    #
+    # An enumerated type permits to assign names to integer values. It may be defined
+    # different ways:
+    #  enum = RASN1::Types::Enumerated.new(enum: { 'a' => 0, 'b' => 1, 'c' => 2 })
+    #  enum = RASN1::Types::Enumerated.new(enum: { a: 0, b: 1, c: 2 })
+    # Its value should be setting as an Integer or a String/symbol:
+    #  enum.value = :b
+    #  enum.value = 1   # equivalent to :b
+    # But its value is always stored as named integer:
+    #  enum.value = :b
+    #  enum.value      # => :b
+    #  enum.value = 0
+    #  enum.value      # => :a
+    # A {EnumeratedError} is raised when set value is not in enumeration.
+    # @author Sylvain Daubert
+    class Enumerated < Integer
+      # @!attribute enum
+      # @return [Hash]
+
+      # Enumerated id value
+      ID = 0x0a
+
+      # @option options [Hash] :enum enumeration hash. Keys are names, and values
+      #   are integers. This key is mandatory.
+      # @raise [EnumeratedError] +:enum+ key is not present
+      # @raise [EnumeratedError] +:default+ value is unknown
+      # @see Base#initialize common options to all ASN.1 types
+      def initialize(options={})
+        super
+        raise EnumeratedError, 'no enumeration given' if @enum.empty?
+      end
+
+      # @return [Hash]
+      def to_h
+        @enum
+      end
+    end
+  end
+end

data/lib/rasn1/types/generalized_time.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require 'strptime'
+
+module RASN1
+  module Types
+    # ASN.1 GeneralizedTime
+    #
+    # +{#value} of a {GeneralizedTime} should be a ruby Time.
+    #
+    # ===Notes
+    # When encoding, resulting string is always a UTC time, appended with +Z+.
+    # Minutes and seconds are always generated. Fractions of second are generated
+    # if value Time object have them.
+    #
+    # On parsing, are supported:
+    # * UTC times (ending with +Z+),
+    # * local times (no suffix),
+    # * local times with difference between UTC and this local time (ending with
+    #   +sHHMM+, where +s+ is +++ or +-+, and +HHMM+ is the time differential
+    #   betwen UTC and local time).
+    # These times may include minutes and seconds. Fractions of hour, minute and
+    # second are supported.
+    # @author Sylvain Daubert
+    class GeneralizedTime < Primitive
+      # 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 [Time]
+      def void_value
+        Time.now
+      end
+
+      # Make time value from +der+ string
+      # @param [String] der
+      # @param [::Boolean] ber
+      # @return [void]
+      def der_to_value(der, ber: false) # rubocop:disable Lint/UnusedMethodArgument
+        date_hour, fraction = der.split('.')
+        date_hour = date_hour.to_s
+        fraction = fraction.to_s
+
+        if fraction.empty?
+          value_when_fraction_empty(date_hour)
+        elsif fraction[-1] == 'Z'
+          value_when_fraction_ends_with_z(date_hour, fraction)
+        else
+          value_on_others_cases(date_hour, fraction)
+        end
+      end
+
+      private
+
+      def value_to_der
+        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
+          utc_value.strftime('%Y%m%d%H%M%SZ')
+        end
+      end
+
+      def value_when_fraction_empty(date_hour)
+        tz = compute_tz(date_hour)
+        year = date_hour.slice!(0, 4).to_i
+        month = date_hour.slice!(0, 2).to_i
+        day = date_hour.slice!(0, 2).to_i
+        hour = date_hour.slice!(0, 2).to_i
+        minute = date_hour.slice!(0, 2).to_i
+        second = date_hour.slice!(0, 2).to_i
+        @value = Time.new(year, month, day, hour, minute, second, tz)
+      end
+
+      # Ruby 3.0: special handle for timezone
+      #   From 3.1: "Z" and "-0100" are supported
+      #   Below 3.1: should be "-01:00" or "+00:00"
+      def compute_tz(date_hour)
+        if date_hour.end_with?('Z')
+          date_hour.slice!(-1, 1)
+          '+00:00' # Ruby 3.0: to remove after end-of support of ruby 3.0
+        elsif date_hour.match?(/[+-]\d+$/)
+          # Ruby 3.0
+          # date_hour.slice!(-5, 5)
+          zone = date_hour.slice!(-5, 5).to_s
+          "#{zone[0, 3]}:#{zone[3, 2]}"
+        end
+      end
+
+      def value_when_fraction_ends_with_z(date_hour, fraction)
+        fraction = fraction[0...-1]
+        date_hour << 'Z'
+        frac_base = compute_frac_base(date_hour)
+        value_when_fraction_empty(date_hour)
+        fix_value(fraction, frac_base)
+      end
+
+      def value_on_others_cases(date_hour, fraction)
+        match = fraction.match(/(\d+)([+-]\d+)/)
+        if match
+          # fraction contains fraction and timezone info. Split them
+          fraction = match[1]
+          date_hour << match[2]
+        end
+
+        frac_base = compute_frac_base(date_hour)
+        value_when_fraction_empty(date_hour)
+        fix_value(fraction, frac_base)
+      end
+
+      def fix_value(fraction, frac_base)
+        frac = ".#{fraction}".to_r * frac_base
+        @value = (@value + frac) unless fraction.nil?
+      end
+
+      def compute_frac_base(date_hour)
+        case date_hour.size
+        when 10, 11
+          HOUR_TO_SEC
+        when 12, 13, 17
+          MINUTE_TO_SEC
+        when 15
+          if date_hour[-1] == 'Z'
+            SECOND_TO_SEC
+          else
+            HOUR_TO_SEC
+          end
+        when 14, 19
+          SECOND_TO_SEC
+        else
+          prefix = @name.nil? ? type : "tag #{@name}"
+          raise ASN1Error, "#{prefix}: unrecognized format: #{date_hour}"
+        end
+      end
+
+      def trace_data
+        return super if explicit?
+
+        +'    ' << colorize(Time.parse(raw_data)).dark.green
+      end
+    end
+  end
+end

data/lib/rasn1/types/ia5_string.rb

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