rasn2 0.16.0

data/lib/rasn1/types.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require_relative 'types/constrained'
+
+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
+      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
+      return @constructed unless @constructed.empty?
+
+      @constructed = self.constants.map { |c| Types.const_get(c) }
+                         .select { |klass| klass < Constructed }
+    end
+
+    # @private
+    # Decode a DER string to extract identifier octets.
+    # @param [String] der
+    # @return [Array] Return ASN.1 class as Symbol, contructed/primitive as Symbol,
+    #                 ID and size of identifier octets
+    def self.decode_identifier_octets(der)
+      first_octet = der.unpack1('C').to_i
+      asn1_class = Types::Base::CLASSES.key(first_octet & Types::Base::CLASS_MASK) || :universal
+      pc = first_octet.anybits?(Types::Constructed::ASN1_PC) ? :constructed : :primitive
+      id = first_octet & Types::Base::MULTI_OCTETS_ID
+
+      size = if id == Types::Base::MULTI_OCTETS_ID
+               id = 0
+               count = 1
+               der[1..].to_s.bytes.each do |octet|
+                 count += 1
+
+                 id = (id << 7) | (octet & 0x7f)
+                 break if octet.nobits?(0x80)
+               end
+               count
+             else
+               1
+             end
+
+      [asn1_class, pc, id, size]
+    end
+
+    # Give ASN.1 type from a DER string. If ID is unknown, return a {Types::Base}
+    # object.
+    # @param [String] der
+    # @return [Types::Base]
+    # @raise [ASN1Error] +tag+ is out of range
+    def self.id2type(der)
+      # Define a cache for well-known ASN.1 types
+      self.generate_id2type_cache unless defined? @id2types
+
+      asn1class, pc, id, = self.decode_identifier_octets(der)
+      # cache_id: check versus class and 5 LSB bits
+      cache_id = der.unpack1('C') & 0xdf
+      klass = cache_id < Types::Base::MULTI_OCTETS_ID ? @id2types[id] : Types::Base
+      is_constructed = (pc == :constructed)
+      options = { class: asn1class, constructed: is_constructed }
+      options[:tag_value] = id if klass == Types::Base
+      klass.new(options)
+    end
+
+    # @private Generate cache for {.id2type}
+    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.const_get(:ID), type] }
+      @id2types = ary.to_h
+      @id2types.default = Types::Base
+      @id2types.freeze
+    end
+
+    # 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 class from which inherits
+    # @param [Module] in_module module in which creates new type (default to {RASN1::Types})
+    # @return [Class] newly created class
+    # @yieldparam [Object] value value to set to type, or infered at parsing
+    # @yieldreturn [Boolean]
+    # @since 0.11.0
+    # @since 0.12.0 in_module parameter
+    # @example
+    #   # Define a new UInt32 type
+    #   # UInt32 ::= INTEGER (0 .. 4294967295)
+    #   RASN1::Types.define_type('UInt32', from: RASN1::Types::Integer) do |value|
+    #     (value >= 0) && (value < 2**32)
+    #   end
+    def self.define_type(name, from:, in_module: self, &block)
+      constraint = block&.to_proc
+
+      new_klass = Class.new(from)
+      new_klass.include(Constrained)
+      new_klass.extend(Constrained::ClassMethods)
+      new_klass.constraint = constraint
+
+      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 = []
+      @constructed = []
+
+      new_klass
+    end
+  end
+end
+
+require_relative 'types/base'
+require_relative 'types/primitive'
+require_relative 'types/boolean'
+require_relative 'types/integer'
+require_relative 'types/bit_string'
+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/universal_string'
+require_relative 'types/utf8_string'
+require_relative 'types/numeric_string'
+require_relative 'types/printable_string'
+require_relative 'types/ia5_string'
+require_relative 'types/constructed'
+require_relative 'types/sequence'
+require_relative 'types/sequence_of'
+require_relative 'types/set'
+require_relative 'types/set_of'
+require_relative 'types/choice'
+require_relative 'types/any'
+require_relative 'types/tag'
+require_relative 'types/utc_time'
+require_relative 'types/generalized_time'

data/lib/rasn1/value_notation.rb

@@ -0,0 +1,256 @@
+# frozen_string_literal: true
+
+module RASN1
+  # Support for ASN.1 value notation (text representation of ASN.1 data instances).
+  #
+  # ASN.1 value notation allows defining values for ASN.1 types in a human-readable
+  # text format. For example:
+  #   myPerson PersonnelRecord ::= {
+  #       name    "John Doe",
+  #       title   "Engineer",
+  #       age     30,
+  #       employed TRUE
+  #   }
+  #
+  # This module provides methods to parse such text into {Model} instances and
+  # to generate such text from {Model} instances.
+  #
+  # @example Parse a value notation string
+  #   models = RASN1::SchemaParser.parse_file('schema.asn')
+  #   record = RASN1::ValueNotation.parse(
+  #     File.read('instance.asn'),
+  #     models: models
+  #   )
+  #   record[:name].value  # => "John Doe"
+  #
+  # @example Generate value notation from a model
+  #   record = PersonnelRecord.new(name: 'John Doe', title: 'Engineer', age: 30, employed: true)
+  #   text = RASN1::ValueNotation.emit(record, name: 'myPerson', type_name: 'PersonnelRecord')
+  #
+  # @author rickmark
+  # @since 0.17.0
+  module ValueNotation
+    # Error raised when parsing or emitting value notation fails
+    class Error < RASN1::Error; end
+
+    class << self
+      # Parse an ASN.1 value notation string and populate a model instance.
+      # @param [String] text the value notation text
+      # @param [Hash{String => Class}] models hash mapping type names to Model subclasses
+      # @return [Model] populated model instance
+      # @raise [Error] if the text cannot be parsed
+      def parse(text, models:)
+        text = text.strip
+        match = text.match(/\A(\w+)\s+(\w+)\s*::=\s*(.*)\z/m)
+        raise Error, 'Invalid value notation format' unless match
+
+        value_name = match[1]
+        type_name = match[2]
+        body = match[3].strip
+
+        model_class = models[type_name]
+        raise Error, "Unknown type: #{type_name}" unless model_class
+
+        values = parse_constructed_value(body)
+        instance = model_class.new(values)
+        instance.define_singleton_method(:value_name) { value_name }
+        instance.define_singleton_method(:type_name) { type_name }
+        instance
+      end
+
+      # Parse an ASN.1 value notation file.
+      # @param [String] filename path to the value notation file
+      # @param [Hash{String => Class}] models hash mapping type names to Model subclasses
+      # @return [Model] populated model instance
+      # @raise [Error] if the file cannot be parsed
+      def parse_file(filename, models:)
+        parse(File.read(filename), models: models)
+      end
+
+      # Emit ASN.1 value notation text from a model instance.
+      # @param [Model] model the model instance to emit
+      # @param [String] name the value name (e.g. 'myPerson')
+      # @param [String] type_name the type name (e.g. 'PersonnelRecord')
+      # @param [Integer] indent indentation level (number of spaces per level)
+      # @return [String] value notation text
+      def emit(model, name: nil, type_name: nil)
+        name ||= model.respond_to?(:value_name) ? model.value_name : 'value'
+        type_name ||= model.respond_to?(:type_name) ? model.type_name : model.class.type
+        body = emit_constructed(model, indent_level: 1)
+        "#{name} #{type_name} ::= {\n#{body}\n}\n"
+      end
+
+      private
+
+      # Parse a constructed value body: { field1 value1, field2 value2, ... }
+      # @param [String] text
+      # @return [Hash{Symbol => Object}]
+      def parse_constructed_value(text)
+        text = text.strip
+        raise Error, "Expected '{' at start of constructed value" unless text.start_with?('{')
+        raise Error, "Expected '}' at end of constructed value" unless text.end_with?('}')
+
+        inner = text[1..-2].strip
+        result = {}
+        remaining = inner
+
+        until remaining.nil? || remaining.strip.empty?
+          remaining = remaining.strip
+          field_name, value, remaining = parse_field(remaining)
+          result[field_name.to_sym] = value
+          # consume optional comma
+          remaining = remaining&.strip
+          remaining = remaining.sub(/\A,\s*/, '') if remaining&.start_with?(',')
+        end
+
+        result
+      end
+
+      # Parse a single field: name value
+      # @param [String] text
+      # @return [Array(String, Object, String)] field name, parsed value, remaining text
+      def parse_field(text)
+        # Match field name
+        match = text.match(/\A(\w+)\s+/)
+        raise Error, "Expected field name in: #{text[0..40]}" unless match
+
+        field_name = match[1]
+        rest = match.post_match
+
+        value, rest = parse_value(rest)
+        [field_name, value, rest]
+      end
+
+      # Parse a single value (string, integer, boolean, null, or nested constructed)
+      # @param [String] text
+      # @return [Array(Object, String)] parsed value and remaining text
+      def parse_value(text)
+        text = text.strip
+        case text
+        when /\A"/ then parse_string_value(text)
+        when /\ATRUE\b/i then [true, text.sub(/\ATRUE/i, '')]
+        when /\AFALSE\b/i then [false, text.sub(/\AFALSE/i, '')]
+        when /\ANULL\b/i then [nil, text.sub(/\ANULL/i, '')]
+        when /\A\{/ then parse_nested_constructed(text)
+        when /\A-?\d/ then parse_integer_value(text)
+        else
+          raise Error, "Unexpected value at: #{text[0..40]}"
+        end
+      end
+
+      # Parse a quoted string value
+      # @param [String] text
+      # @return [Array(String, String)]
+      def parse_string_value(text)
+        # Handle escaped quotes within the string
+        pos = 1
+        result = +''
+        while pos < text.length
+          ch = text[pos]
+          if ch == '"'
+            # Check for escaped quote (doubled)
+            return [result, text[(pos + 1)..]] unless pos + 1 < text.length && text[pos + 1] == '"'
+
+            result << '"'
+            pos += 2
+
+          else
+            result << ch
+            pos += 1
+          end
+        end
+        raise Error, 'Unterminated string value'
+      end
+
+      # Parse an integer value
+      # @param [String] text
+      # @return [Array(Integer, String)]
+      def parse_integer_value(text)
+        match = text.match(/\A(-?\d+)/)
+        raise Error, "Expected integer at: #{text[0..20]}" unless match
+
+        [match[1].to_i, match.post_match]
+      end
+
+      # Parse a nested constructed value { ... }
+      # @param [String] text
+      # @return [Array(Hash, String)]
+      def parse_nested_constructed(text)
+        # Find matching closing brace
+        depth = 0
+        pos = 0
+        text.each_char.with_index do |ch, idx|
+          depth += 1 if ch == '{'
+          depth -= 1 if ch == '}'
+          if depth.zero?
+            pos = idx
+            break
+          end
+        end
+        raise Error, 'Unmatched braces in constructed value' if depth != 0
+
+        inner_text = text[0..pos]
+        rest = text[(pos + 1)..]
+        values = parse_constructed_value(inner_text)
+        [values, rest]
+      end
+
+      # Emit the fields of a constructed model value
+      # @param [Model] model
+      # @param [Integer] indent_level
+      # @return [String]
+      def emit_constructed(model, indent_level: 1)
+        indent = '    ' * indent_level
+        fields = collect_fields(model)
+
+        lines = fields.map do |field_name, value|
+          formatted = format_value(value, indent_level: indent_level)
+          "#{indent}#{field_name} #{formatted}"
+        end
+
+        lines.join(",\n")
+      end
+
+      # Collect the named fields from a model's root sequence
+      # @param [Model] model
+      # @return [Array<Array(Symbol, Object)>]
+      def collect_fields(model)
+        root = model.root
+        return [] unless root.is_a?(Types::Sequence) || root.is_a?(Types::Set)
+        return [] unless root.value.is_a?(Array)
+
+        fields = []
+        root.value.each do |element|
+          case element
+          when Model
+            fields << [element.name, element]
+          when Types::Base
+            next if element.optional? && !element.value?
+
+            fields << [element.name, element.value]
+          end
+        end
+        fields
+      end
+
+      # Format a value for value notation output
+      # @param [Object] value
+      # @param [Integer] indent_level
+      # @return [String]
+      def format_value(value, indent_level: 0)
+        case value
+        when Model
+          body = emit_constructed(value, indent_level: indent_level + 1)
+          "{\n#{body}\n#{'    ' * indent_level}}"
+        when true then 'TRUE'
+        when false then 'FALSE'
+        when ::Integer then value.to_s
+        when String then "\"#{value.gsub('"', '""')}\""
+        when nil then 'NULL'
+        else
+          value.to_s
+        end
+      end
+    end
+  end
+end

data/lib/rasn1/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module RASN1
+  # RASN1 version number
+  VERSION = '0.16.0'
+end

data/lib/rasn1/wrapper.rb

@@ -0,0 +1,279 @@
+# 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 4 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),
+  # * wrap a choice model to reuse it in its own definition.
+  #
+  # @example Wrapping object
+  #   # object to wrap
+  #   int = RASN1::Types::Integer.new(implicit: 1)    # its tag is 0x81
+  #   # simple wrapper, change an option
+  #   wrapper = RASN1::Wrapper.new(int, 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
+  # @example Wrapping a choice to make it recursive
+  #  class RecursiveChoice < RASN1::Model
+  #    choice :choice,
+  #           content: [
+  #             integer(:value, implicit: 1),
+  #             wrapper(model(:recursive, RecursiveChoice), implicit:2)
+  #           ]
+  #  end
+  # @since 0.12.0
+  # @since 0.15.0 Wrappers are lazy. They allocate their inner element only when needed (i.e. when calling {#to_der}, {#parse!} or {#element})
+  # @author Sylvain Daubert
+  # @author LemonTree55
+  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={})
+      @lazy = true
+      opts = explicit_implicit(options)
+
+      if explicit?
+        generate_explicit_wrapper(opts)
+        @element_options_to_merge = generate_explicit_wrapper_options(opts)
+        @options = opts
+      else
+        opts[:value] = element.value if element.respond_to?(:value)
+        @element_options_to_merge = opts
+        @options = {}
+      end
+      raise RASN1::Error, 'Cannot be implicit and explicit' if explicit? && implicit?
+
+      super(element)
+    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]
+    # @since 0.12.0
+    # @since 0.15.0 Allocate element (lazy wrapper)
+    def to_der
+      lazy_generation
+      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
+    # @since 0.12.0
+    # @since 0.15.0 Allocate element (lazy wrapper)
+    def parse!(der, ber: false)
+      lazy_generation
+      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
+
+    # @private
+    # @see Types::Base#do_parse
+    def do_parse(der, ber: false)
+      if implicit?
+        generate_implicit_element(Types::Base.new(constructed: element.constructed?)).do_parse(der, ber: ber)
+      elsif explicit?
+        @explicit_wrapper.do_parse(der, ber: ber)
+      else
+        element.do_parse(der, ber: ber)
+      end
+    end
+
+    # @return [Boolean]
+    # @see Types::Base#value?
+    def value?
+      if explicit?
+        @explicit_wrapper.value?
+      elsif __getobj__.is_a?(Class)
+        false
+      else
+        __getobj__.value?
+      end
+    end
+
+    # Return Wrapped element
+    # @return [Types::Base,Model]
+    # @since 0.12.0
+    # @since 0.15.0 Allocate element (lazy wrapper)
+    def element
+      lazy_generation
+    end
+
+    # @return [::Integer]
+    # @see Types::Base#id
+    def id
+      if implicit?
+        @implicit
+      elsif explicit?
+        @explicit
+      else
+        lazy_generation(register: false).id
+      end
+    end
+
+    # @return [Symbol]
+    # @see Types::Base#asn1_class
+    def asn1_class
+      return lazy_generation(register: false).asn1_class unless @options.key?(:class)
+
+      @options[:class]
+    end
+
+    # @return [Boolean]
+    # @see Types::Base#constructed
+    def constructed?
+      return lazy_generation(register: false).constructed? unless @options.key?(:constructed)
+
+      @options[:constructed]
+    end
+
+    # @return [Boolean]
+    # @see Types::Base#primitive
+    def primitive?
+      !constructed?
+    end
+
+    # @param [::Integer] level
+    # @return [String]
+    def inspect(level=0)
+      return super() unless explicit?
+
+      @explicit_wrapper.inspect(level) << ' ' << super()
+    end
+
+    private
+
+    def explicit_implicit(options)
+      opts = options.dup
+      @explicit = tag_id_to_integer(opts.delete(:explicit))
+      @implicit = tag_id_to_integer(opts.delete(:implicit))
+      opts
+    end
+
+    # Convert a tag id to an integer.
+    # If given a String or Symbol, interprets the characters as big-endian octets
+    # (like Apple 4-character codes / 4CCs). Integers and +nil+ are returned as-is.
+    # @param [::Integer, String, Symbol, nil] value tag value
+    # @return [::Integer, nil]
+    def tag_id_to_integer(value)
+      case value
+      when ::Integer, NilClass
+        value
+      when ::String, ::Symbol
+        value.to_s.bytes.reduce(0) { |acc, b| (acc << 8) | b }
+      else
+        value
+      end
+    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
+
+    def generate_implicit_element(from=nil)
+      el = (from || element).dup
+      el.options = if element.explicit?
+                     el.options.merge(explicit: @implicit)
+                   else
+                     el.options.merge(implicit: @implicit)
+                   end
+      el
+    end
+
+    def lazy_generation(register: true)
+      return __getobj__ unless @lazy
+
+      real_element = __getobj__
+      case real_element
+      when Types::Base, Model
+        real_element.options = real_element.options.merge(@element_options_to_merge)
+        @lazy = false
+        real_element
+      else
+        el = real_element.new(@element_options_to_merge)
+        if register
+          @lazy = false
+          __setobj__(el)
+        end
+        el
+      end
+    end
+  end
+end