rasn2 0.16.0

data/lib/rasn1/types/integer.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module RASN1
+  module Types
+    # ASN.1 Integer
+    # @author Sylvain Daubert
+    class Integer < Primitive
+      # @return [Hash,nil]
+      attr_reader :enum
+
+      # Integer id value
+      ID = 2
+
+      # @option options [Hash] :enum enumeration hash. Keys are names, and values
+      #   are integers.
+      # @raise [EnumeratedError] +:default+ value is unknown when +:enum+ key is present
+      # @see Base#initialize common options to all ASN.1 types
+      def initialize(options={})
+        super
+        initialize_enum(@options[:enum])
+      end
+
+      # @param [Integer,String,Symbol,nil] val
+      # @return [void]
+      def value=(val)
+        @no_value = false
+        case val
+        when String, Symbol
+          value_from_string_or_symbol(val)
+        when ::Integer
+          value_from_integer(val)
+        when nil
+          @no_value = true
+          @value = void_value
+        else
+          raise EnumeratedError, "#{@name}: not in enumeration"
+        end
+      end
+
+      # @return [Integer]
+      def void_value
+        0
+      end
+
+      # Integer value
+      # @return [Integer]
+      def to_i
+        val = value? ? @value : @default
+        case val
+        when String, Symbol
+          @enum[val]
+        else
+          val || 0
+        end
+      end
+
+      # Make integer value from +der+ string.
+      # @param [String] der
+      # @param [::Boolean] ber
+      # @return [void]
+      def der_to_value(der, ber: false)
+        int_value = der_to_int_value(der, ber: ber)
+        @value = if @enum.empty?
+                   int_value
+                 else
+                   int_to_enum(int_value)
+                 end
+      end
+
+      private
+
+      def initialize_enum(enum)
+        @enum = enum || {}
+        return if @enum.empty?
+
+        # To ensure @value has the correct type
+        self.value = @value if value?
+
+        check_enum_default
+      end
+
+      def check_enum_default
+        case @default
+        when String, Symbol
+          raise EnumeratedError, "#{@name}: unknwon enumerated default value #@{default}" unless @enum.key?(@default)
+        when ::Integer
+          raise EnumeratedError, "#{@name}: default value #@{default} not in enumeration" unless @enum.value?(@default)
+
+          @default = @enum.key(@default)
+        when nil
+        else
+          raise TypeError, "#{@name}: #{@default.class} not handled as default value"
+        end
+      end
+
+      def value_from_string_or_symbol(val)
+        raise EnumeratedError, "#{@name} has no :enum" if @enum.empty?
+        raise EnumeratedError, "#{@name}: unknwon enumerated value #{val}" unless @enum.key? val
+
+        @value = val
+      end
+
+      def value_from_integer(val)
+        if @enum.empty?
+          @value = val
+        elsif @enum.value? val
+          @value = @enum.key(val)
+        else
+          raise EnumeratedError, "#{@name}: #{val} not in enumeration"
+        end
+      end
+
+      def int_value_to_der(value)
+        size = compute_size(value)
+        comp_value = value >= 0 ? value : (~(-value) + 1) & ((1 << (size * 8)) - 1)
+        ary = comp_value.digits(256)
+        # v is > 0 and its MSBit is 1. Add a 0 byte to mark it as positive
+        ary << 0 if value.positive? && (value >> (size * 8 - 1) == 1)
+        ary.reverse.pack('C*')
+      end
+
+      def compute_size(value)
+        size = value.bit_length / 8 + ((value.bit_length % 8).positive? ? 1 : 0)
+        size = 1 if size.zero?
+        size
+      end
+
+      def value_to_der
+        case @value
+        when String, Symbol
+          int_value_to_der(@enum[@value])
+        when ::Integer
+          int_value_to_der(@value)
+        else
+          raise TypeError, "#{@name}: #{@value.class} not handled"
+        end
+      end
+
+      def der_to_int_value(der, ber: false) # rubocop:disable Lint/UnusedMethodArgument
+        ary = der.unpack('C*')
+        v = ary.reduce(0) { |len, b| (len << 8) | b }
+        v = -((~v & ((1 << v.bit_length) - 1)) + 1) if ary[0] & 0x80 == 0x80
+        v
+      end
+
+      def int_to_enum(int, check_enum: true)
+        raise EnumeratedError, "#{@name}: value #{int} not in enumeration" if check_enum && !@enum.value?(int)
+
+        @enum.key(int) || int
+      end
+
+      def explicit_type
+        self.class.new(name: name, enum: enum)
+      end
+
+      def trace_data
+        return super if explicit?
+        i = der_to_int_value(raw_data)
+        return "    #{int_with_hex(i, raw_data.unpack1('H*'))}" if @enum.empty?
+
+        v = int_to_enum(i, check_enum: false)
+        "    #{colorize_enum(v, raw_data)}"
+      end
+    end
+  end
+end

data/lib/rasn1/types/null.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RASN1
+  module Types
+    # ASN.1 Null
+    # @author Sylvain Daubert
+    class Null < Primitive
+      # Null id value
+      ID = 0x05
+
+      # @return [String]
+      def inspect(level=0)
+        str = common_inspect(level)[0..-2] # remove terminal ':'
+        str << ' OPTIONAL' if optional?
+        str
+      end
+
+      # @return [Boolean]
+      # Build only if not optional
+      def can_build?
+        !optional?
+      end
+
+      # Check +der+ string
+      # @param [String] der
+      # @param [::Boolean] ber
+      # @return [void]
+      # @raise [ASN1Error] +der+ is not empty
+      def der_to_value(der, ber: false) # rubocop:disable Lint/UnusedMethodArgument
+        raise ASN1Error, 'NULL should not have content!' if der.length.positive?
+
+        @no_value = true
+        @value = void_value
+      end
+
+      private
+
+      def value_to_der
+        ''
+      end
+    end
+  end
+end

data/lib/rasn1/types/numeric_string.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RASN1
+  module Types
+    # ASN.1 Numeric String
+    # @author Sylvain Daubert
+    class NumericString < OctetString
+      # NumericString id value
+      ID = 18
+      # Invalid characters in NumericString
+      INVALID_CHARS = /([^0-9 ])/
+
+      # Get ASN.1 type
+      # @return [String]
+      def self.type
+        'NumericString'
+      end
+
+      # Make string value from +der+ string
+      # @param [String] der
+      # @param [::Boolean] ber
+      # @return [void]
+      # @raise [ASN1Error] invalid characters detected
+      def der_to_value(der, ber: false)
+        super
+        check_characters
+      end
+
+      private
+
+      def value_to_der
+        check_characters
+        @value.to_s.b
+      end
+
+      def check_characters
+        raise ASN1Error, "NUMERIC STRING #{@name}: invalid character: '#{$1}'" if @value.to_s =~ INVALID_CHARS
+      end
+    end
+  end
+end

data/lib/rasn1/types/object_id.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RASN1
+  module Types
+    # ASN.1 Object ID
+    # @author Sylvain Daubert
+    # @author LemonTree55
+    class ObjectId < Primitive
+      # ObjectId id value
+      ID = 6
+
+      # Make object id value from +der+ string
+      # @param [String] der
+      # @param [::Boolean] ber
+      # @return [void]
+      def der_to_value(der, ber: false) # rubocop:disable Lint/UnusedMethodArgument
+        bytes = der.unpack('C*')
+
+        ids = []
+        current_id = 0
+        bytes.each do |byte|
+          current_id = (current_id << 7) | (byte & 0x7f)
+          if byte.nobits?(0x80)
+            ids << current_id
+            current_id = 0
+          end
+        end
+
+        first_id = [2, ids.first / 40].min
+        second_id = ids.first - first_id * 40
+        ids[0..0] = [first_id, second_id]
+
+        @value = ids.join('.')
+      end
+
+      private
+
+      # @raise [ASN1Error]
+      def value_to_der
+        ids = @value.to_s.split('.').map(&:to_i)
+
+        check_first_ids(ids)
+
+        ids[0, 2] = ids[0] * 40 + ids[1]
+        octets = []
+        ids.each do |v|
+          if v < 128
+            octets << v
+          else
+            octets.concat(unsigned_to_chained_octets(v))
+          end
+        end
+        octets.pack('C*')
+      end
+
+      # @param [Array[::Integer]] ids
+      # @raise [ASN1Error]
+      def check_first_ids(ids)
+        raise ASN1Error, "OBJECT ID #{@name}: first subidentifier should be less than 3" if ids[0] > 2
+        raise ASN1Error, "OBJECT ID #{@name}: second subidentifier should be less than 40" if (ids[0] < 2) && (ids[1] > 39)
+      end
+    end
+  end
+end

data/lib/rasn1/types/octet_string.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RASN1
+  module Types
+    # ASN.1 Octet String
+    #
+    # An OCTET STRINT may contain another primtive object:
+    #  os = OctetString.new
+    #  int = Integer.new
+    #  int.value = 12
+    #  os.value = int
+    #  os.to_der   # => DER string with INTEGER in OCTET STRING
+    # @author Sylvain Daubert
+    class OctetString < Primitive
+      # OctetString id value
+      ID = 4
+
+      # @param [::Integer] level
+      # @return [String]
+      def inspect(level=0)
+        str = common_inspect(level)
+        str << " #{value.inspect}"
+      end
+
+      # Make string value from +der+ string. Force encoding to UTF-8
+      # @param [String] der
+      # @param [::Boolean] ber
+      # @return [void]
+      # @since 0.15.0 Handle ENCODING constant, if defined by subclass
+      def der_to_value(der, ber: false)
+        klass = self.class
+        if klass.const_defined?(:ENCODING)
+          @value = der.to_s.dup.force_encoding(klass.const_get(:ENCODING))
+        else
+          super
+        end
+      end
+
+      private
+
+      # @since 0.15.0 Handle ENCODING constant, if defined by subclass
+      def value_to_der
+        klass = self.class
+        if klass.const_defined?(:ENCODING)
+          @value.to_s.encode(klass.const_get(:ENCODING)).b
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/rasn1/types/primitive.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RASN1
+  module Types
+    # @abstract This class SHOULD be used as base class for all ASN.1 primitive
+    #  types.
+    # @author Sylvain Daubert
+    class Primitive < Base
+      # Primitive value
+      ASN1_PC = 0x00
+    end
+  end
+end

data/lib/rasn1/types/printable_string.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RASN1
+  module Types
+    # ASN.1 Printable String
+    # @author Sylvain Daubert
+    class PrintableString < OctetString
+      # PrintableString id value
+      ID = 19
+      # Invalid characters in PrintableString
+      INVALID_CHARS = %r{([^a-zA-Z0-9 '=()+,\-./:?])}
+
+      # Get ASN.1 type
+      # @return [String]
+      def self.type
+        'PrintableString'
+      end
+
+      # Make string value from +der+ string
+      # @param [String] der
+      # @param [::Boolean] ber
+      # @return [void]
+      # @raise [ASN1Error] invalid characters detected
+      def der_to_value(der, ber: false)
+        super
+        check_characters
+      end
+
+      private
+
+      def value_to_der
+        check_characters
+        @value.to_s.b
+      end
+
+      def check_characters
+        m = @value.to_s.match(INVALID_CHARS)
+        raise ASN1Error, "PRINTABLE STRING #{@name}: invalid character: '#{m[1]}'" if m
+      end
+    end
+  end
+end

data/lib/rasn1/types/sequence.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module RASN1
+  module Types
+    # ASN.1 sequence
+    #
+    # A sequence is a collection of another ASN.1 types.
+    #
+    # To encode this ASN.1 example:
+    #  Record ::= SEQUENCE {
+    #    id        INTEGER,
+    #    room  [0] INTEGER OPTIONAL,
+    #    house [1] IMPLICIT INTEGER DEFAULT 0
+    #  }
+    # do:
+    #  seq = RASN1::Types::Sequence.new
+    #  seq.value = [
+    #               RASN1::Types::Integer.new
+    #               RASN1::Types::Integer.new(explicit: 0, optional: true),
+    #               RASN1::Types::Integer.new(implicit: 1, default: 0)
+    #              ]
+    #
+    # A sequence may also be used without value to not parse sequence content:
+    #  seq = RASN1::Types::Sequence.new(:seq)
+    #  seq.parse!(der_string)
+    #  seq.value    # => String
+    # @author Sylvain Daubert
+    class Sequence < Constructed
+      # Sequence id value
+      ID = 0x10
+
+      # @see Base#initialize
+      def initialize(options={})
+        super
+        @no_value = false
+        @value ||= []
+      end
+
+      # Deep copy @value
+      def initialize_copy(*)
+        super
+        @value = case @value
+                 when Array
+                   @value.map(&:dup)
+                 else
+                   @value.dup
+                 end
+      end
+
+      # @return [Array]
+      def void_value
+        []
+      end
+
+      # Get element at index +idx+, or element of name +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
+
+      # Make sequence value from +der+ string
+      # @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 value_to_der
+        case @value
+        when Array
+          @value.map(&:to_der).join
+        else
+          @value.to_s
+        end
+      end
+
+      def trace_data
+        ''
+      end
+
+      def explicit_type
+        self.class.new(name: name, value: @value)
+      end
+    end
+  end
+end