rasn2 0.16.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1b52ab2b6b1a8019f3ae996d875ef09869cf715c2a58cce73c58bd8ba6a50b95
-  data.tar.gz: ebd0936fdb3a8921c97c33d18b2938bd461fd525a6991dd52a45b65be552bb2c
+  metadata.gz: 0bc40f5198815e03f0bfa923321ac614e68d4587f31b3cb18d999f40e7b49004
+  data.tar.gz: '09ec989aa9f0674cf2f4ed956518bd717a85de33357b7c09cd2fe6a2d2caa9b8'
 SHA512:
-  metadata.gz: 3e57fb8bf6ebd8e2d9df9558613cac061f8f73344ee6fcf73ae72abb0946313503a6f4df24d5487a2859fd51c4dc9d4d74391570adaddd7b33ec2ce1d93ac3ca
-  data.tar.gz: e5d1dc4e78a2e7d4bd1830ae1f0bc7d4eae17aaccdbf6708f42ef7cacc3ff6719ff83cb6d9f732971534199b18b533343f1ba16135229870673c308ce18f6267
+  metadata.gz: 7739ea22723954d0ee78787697e8dde59bb0b41f6fb3c23c8e34f0cab1bd23720b35e05abffb8ac389141115f598d61cf28ce32ccd7d078169cf16bf0043616c
+  data.tar.gz: e5ef77bb7b20f1bb6819c4935e04a302c58930bc183371b132522c0b245da9e306de8fbcb29653c535c8d6646f991ff990726466937f487a5c7ea0470034a342

data/lib/{rasn1 → rasn2}/errors.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module RASN1
+module RASN2
   # Base error class
   class Error < StandardError; end
 
@@ -19,7 +19,7 @@ module RASN1
   class EnumeratedError < Error; end
 
   # CHOICE error: {Types::Choice#chosen} not set
-  class ChoiceError < RASN1::Error
+  class ChoiceError < RASN2::Error
     # @param [Types::Base] object
     def initialize(object)
       @object = object

data/lib/rasn2/helpers/colorize.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module RASN2
+  module Helpers
+    module Colorize
+      def colorizer
+        @colorizer&.first || Rainbow.new
+      end
+
+      def colorizer=(colorizer)
+        @colorizer ||= []
+        @colorizer << colorizer
+      end
+
+      def begin_colorizer(color)
+        @colorizer ||= []
+        @colorizer << Rainbow.new
+        @colorizer.last.enabled = color
+      end
+
+      def colorize(msg)
+        colorizer.wrap(msg)
+      end
+
+      def end_colorizer
+        @colorizer&.pop
+      end
+
+      def parens_hex(input, padding=2)
+        value = if input.is_a?(Integer)
+                  if input >= 0
+                    value = "%0#{padding}X" % input
+                    value = value.rjust((value.length + 1) / 2 * 2, '0')
+                    "0x#{value}"
+                  else
+                    '0xFF'
+                  end
+                else
+                  input
+                end
+        "#{colorize('(').webgray}#{colorize(value).blue}#{colorize(')').webgray}"
+      end
+
+      def int_with_hex(input, raw_value=nil)
+        if raw_value.nil?
+          "#{colorize(input).blue} #{parens_hex(input)}"
+        else
+          "#{colorize(input).blue} #{parens_hex(raw_value)}"
+        end
+      end
+
+      def brace_surround(input)
+        "#{colorize('[').webgray} #{input} #{colorize(']').webgray}"
+      end
+
+      def colorize_class(name, tag_id=nil, *attributes)
+        parts = [colorize(name).bold.yellow]
+        parts += attributes.map { |attr| colorize_attribute(attr) } if attributes.any?
+        parts << parens_hex(tag_id) if tag_id
+        parts.join(' ')
+      end
+
+      def colorize_id(id, tag_class=nil)
+        id = id.strip if id.is_a? String
+        tag_class = tag_class.strip if tag_class.is_a? String
+        tag_class = '' if tag_class == 'UNIVERSAL'
+
+        return '' if id.to_s == '' && tag_class.to_s == ''
+
+        if tag_class && tag_class != ''
+          brace_surround("#{colorize_class(tag_class)} #{colorize(id).bold.green}")
+        else
+          brace_surround(colorize(id).bold.green)
+        end
+      end
+
+      def length_specifier(data_length, encoded_length=nil)
+        encoded_length = data_length if encoded_length.nil?
+        "#{colorize('len:').gray} #{colorize(data_length).blue} #{parens_hex(encoded_length)}"
+      end
+
+      def colorize_name(name)
+        colorize(name).bold.white
+      end
+
+      def colorize_attribute(attribute)
+        colorize(attribute).bold.magenta
+      end
+
+      def colorize_default(value)
+        " #{colorize_attribute('DEFAULT VALUE')} #{colorize(value).green.bold}"
+      end
+
+      def colorize_nil(name='NONE')
+        colorize(name).red.bold
+      end
+
+      def colorize_enum(name, raw_value)
+        raw_value = "0x#{raw_value.unpack1('H*').upcase}" if raw_value.is_a?(String)
+        "#{colorize_class(name)} #{parens_hex(raw_value)}"
+      end
+
+      def colorize_value(value)
+        colorize(value).blue
+      end
+
+      def colorize_bool(value, raw_value)
+        hex_raw_value = raw_value.is_a?(String) ? "0x#{raw_value.unpack1('H*').upcase}" : raw_value
+        value = if value
+                  colorize('TRUE').bold.green
+                else
+                  colorize('FALSE').bold.red
+                end
+
+        "#{value} #{parens_hex(hex_raw_value)}"
+      end
+    end
+  end
+end

data/lib/{rasn1 → rasn2}/model.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module RASN1
+module RASN2
   # @abstract
   # {Model} class is a base class to define ASN.1 models.
   # == Create a simple ASN.1 model
@@ -11,7 +11,7 @@ module RASN1
   #    house [1] EXPLICIT INTEGER DEFAULT 0
   #  }
   # you may create your model like this:
-  #  class Record < RASN1::Model
+  #  class Record < RASN2::Model
   #    sequence(:record,
   #             content: [integer(:id),
   #                       integer(:room, implicit: 0, optional: true),
@@ -20,7 +20,7 @@ module RASN1
   #
   # Since 0.17.0, content may also be defined through a block. This is strictly
   # equivalent to the +:content+ option:
-  #  class Record < RASN1::Model
+  #  class Record < RASN2::Model
   #    sequence :record do
   #      integer :id
   #      integer :room, implicit: 0, optional: true
@@ -28,7 +28,7 @@ module RASN1
   #    end
   #  end
   # Blocks may be nested, and may use all model helpers (+#model+, +#wrapper+, +#sequence_of+, ...):
-  #  class PersonnelRecord < RASN1::Model
+  #  class PersonnelRecord < RASN2::Model
   #    sequence :personnelRecord do
   #      utf8_string :name
   #      utf8_string :title
@@ -43,7 +43,7 @@ module RASN1
   #
   # === Parse a DER-encoded string
   #  record = Record.parse(der_string)
-  #  record[:id]             # => RASN1::Types::Integer
+  #  record[:id]             # => RASN2::Types::Integer
   #  record[:id].value       # => Integer
   #  record[:id].to_i        # => Integer
   #  record[:id].asn1_class  # => Symbol
@@ -61,7 +61,7 @@ module RASN1
   #
   # == Create a more complex model
   # Models may be nested. For example:
-  #  class Record2 < RASN1::Model
+  #  class Record2 < RASN2::Model
   #    sequence(:record2,
   #             content: [boolean(:rented, default: false),
   #                       model(:a_record, Record)])
@@ -74,7 +74,7 @@ module RASN1
   # or like this:
   #  record2 = Record2.new(rented: true, a_record: { id: 65537, room: 43 })
   # Same model, using a block:
-  #  class Record2 < RASN1::Model
+  #  class Record2 < RASN2::Model
   #    sequence :record2 do
   #      boolean :rented, default: false
   #      model :a_record, Record
@@ -129,6 +129,8 @@ module RASN1
     # @private Sequence types
     SEQUENCE_TYPES = [Types::Sequence, Types::SequenceOf, Types::Set, Types::SetOf].freeze
 
+    include Helpers::Colorize
+
     # Define helper methods to define models
     module Accel # rubocop:disable Metrics/ModuleLength
       # @return [Hash]
@@ -193,7 +195,7 @@ module RASN1
 
       # Update options of root element.
       # May be used when subclassing.
-      #  class Model1 < RASN1::Model
+      #  class Model1 < RASN2::Model
       #    sequence :seq, implicit: 0,
       #             content: [bool(:bool), integer(:int)]
       #  end
@@ -567,7 +569,9 @@ module RASN1
     # @return [Integer] number of parsed bytes
     # @raise [ASN1Error] error on parsing
     def parse!(der, ber: false)
-      root.parse!(der, ber: ber)
+      result = root.parse!(der, ber: ber)
+      result.model = self if result.respond_to? :model=
+      result
     end
 
     # @private
@@ -587,10 +591,10 @@ module RASN1
     #  @return [Object,nil]
     # @return [Object,nil]
     # @example
-    #  class MyModel1 < RASN1::Model
+    #  class MyModel1 < RASN2::Model
     #    sequence('seq', content: [boolean('boolean'), integer('int')])
     #  end
-    #  class MyModel2 < RASN1::Model
+    #  class MyModel2 < RASN2::Model
     #    sequence('root', content: [sequence_of('list', MyModel1)])
     #  end
     #  model = MyModel2.new
@@ -634,7 +638,7 @@ module RASN1
 
     # @return [String]
     def inspect(level=0, color: true)
-      "#{'  ' * level}(#{type}) #{root.inspect(-level)}"
+      root.inspect(level, color: color, kind: type)
     end
 
     # Objects are equal if they have same class AND same DER

data/lib/{rasn1 → rasn2}/schema_parser.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-module RASN1
+module RASN2
   # Parser for ASN.1 text schema definitions.
   #
   # Parses ASN.1 module definitions and generates {Model} subclasses from them.
   #
   # @example Parse a schema file
-  #   models = RASN1::SchemaParser.parse_file('path/to/schema.asn')
-  #   # => { 'PersonnelRecord' => PersonnelRecord (class < RASN1::Model) }
+  #   models = RASN2::SchemaParser.parse_file('path/to/schema.asn')
+  #   # => { 'PersonnelRecord' => PersonnelRecord (class < RASN2::Model) }
   #
   # @example Parse a schema string
   #   schema = <<~ASN1
@@ -19,12 +19,12 @@ module RASN1
   #       }
   #     END
   #   ASN1
-  #   models = RASN1::SchemaParser.parse(schema)
+  #   models = RASN2::SchemaParser.parse(schema)
   #
   # @author rickmark
   # @since 0.16.0
   module SchemaParser
-    # ASN.1 type name to RASN1 type DSL method mapping
+    # ASN.1 type name to RASN2 type DSL method mapping
     TYPE_MAP = {
       'BOOLEAN' => :boolean,
       'INTEGER' => :integer,
@@ -45,10 +45,10 @@ module RASN1
     }.freeze
 
     # Constructed type names
-    CONSTRUCTED_TYPES = %w[SEQUENCE SET].freeze
+    CONSTRUCTED_TYPES = %w[SEQUENCE SET TAG].freeze
 
     # Error raised when parsing an ASN.1 schema fails
-    class ParseError < RASN1::Error; end
+    class ParseError < RASN2::Error; end
 
     class << self
       # Parse an ASN.1 schema from a file and generate Model classes.
@@ -348,7 +348,7 @@ module RASN1
       # Build a single Model subclass
       # @return [Class]
       def build_model_class(type_name, type_def, mod, existing_models, namespace)
-        klass = Class.new(RASN1::Model)
+        klass = Class.new(RASN2::Model)
 
         root_name = type_name.gsub(/([a-z])([A-Z])/, '\1_\2').gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').downcase.to_sym
 
@@ -445,14 +445,14 @@ module RASN1
       # (end of private section)
     end
 
-    # Convert an ASN.1 type name to the corresponding RASN1 Model DSL method symbol
+    # Convert an ASN.1 type name to the corresponding RASN2 Model DSL method symbol
     # @param [String] type_name
     # @return [Symbol, nil]
     def self.type_to_method(type_name)
       TYPE_MAP[type_name]
     end
 
-    # Convert an ASN.1 type name to the corresponding RASN1::Types class
+    # Convert an ASN.1 type name to the corresponding RASN2::Types class
     # @param [String] type_name
     # @return [Class, nil]
     def self.type_to_class(type_name)

data/lib/{rasn1 → rasn2}/tracer.rb

@@ -2,7 +2,7 @@
 
 require 'rainbow'
 
-module RASN1
+module RASN2
   # @private
   class Tracer
     # @return [IO]
@@ -37,7 +37,8 @@ module RASN1
     # @param [String] msg
     # @return [void]
     def trace(msg)
-      @io.puts(indent << msg)
+      indented = msg.split("\n").map { |line| indent + line }.join("\n")
+      @io.puts(indented)
     end
 
     # Return identation for given +level+. If +nil+, use {#tracing_level}.
@@ -45,23 +46,23 @@ module RASN1
     # @return [String]
     def indent(level=nil)
       level ||= @tracing_level
-      '  ' * level
+      "  " * level
     end
   end
 
-  # Trace RASN1 parsing to +io+.
+  # Trace RASN2 parsing to +io+.
   # All parsing methods called in block are traced to +io+. Each ASN.1 element is
   # traced in a line showing element's id, its length and its data.
   # @param [IO] io
   # @param [Boolean] color enable colorized output using pastel gem (requires pastel to be installed)
   # @example
-  #   RASN1.trace do
-  #     RASN1.parse("\x02\x01\x01")  # puts "INTEGER id: 2 (0x02), len: 1 (0x01), data: 0x01"
+  #   RASN2.trace do
+  #     RASN2.parse("\x02\x01\x01")  # puts "INTEGER id: 2 (0x02), len: 1 (0x01), data: 0x01"
   #   end
-  #   RASN1.parse("\x01\x01\xff")    # puts nothing onto STDOUT
+  #   RASN2.parse("\x01\x01\xff")    # puts nothing onto STDOUT
   # @example with color
-  #   RASN1.trace(color: true) do
-  #     RASN1.parse("\x02\x01\x01")  # same output but with ANSI colors
+  #   RASN2.trace(color: true) do
+  #     RASN2.parse("\x02\x01\x01")  # same output but with ANSI colors
   #   end
   # @return [void]
   def self.trace(io=$stdout, color: false)
@@ -142,7 +143,7 @@ module RASN1
       # Parse +der+ with tracing abillity
       # @see #parse!
       def parse_with_tracing(der, ber: false)
-        RASN1.tracer.trace(self.trace)
+        RASN2.tracer.trace(self.trace)
         parse_without_tracing(der, ber: ber)
       end
     end
@@ -166,9 +167,9 @@ module RASN1
       # @private
       # der_to_value +der+ with tracing abillity
       def der_to_value_with_tracing(der, ber: false)
-        RASN1.tracer.tracing_level += 1
+        RASN2.tracer.tracing_level += 1
         der_to_value_without_tracing(der, ber: ber)
-        RASN1.tracer.tracing_level -= 1
+        RASN2.tracer.tracing_level -= 1
       end
     end
 
@@ -191,9 +192,9 @@ module RASN1
       # @private
       # der_to_value +der+ with tracing abillity
       def der_to_value_with_tracing(der, ber: false)
-        RASN1.tracer.tracing_level += 1
+        RASN2.tracer.tracing_level += 1
         der_to_value_without_tracing(der, ber: ber)
-        RASN1.tracer.tracing_level -= 1
+        RASN2.tracer.tracing_level -= 1
       end
     end
   end

data/lib/{rasn1 → rasn2}/types/any.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module RASN1
+module RASN2
   module Types
     # ASN.1 ANY: accepts any types
     #
@@ -31,67 +31,51 @@ module RASN1
       # @param [Boolean] ber if +true+, accept BER encoding
       # @return [Integer] total number of parsed bytes
       def parse!(der, ber: false)
-        total_length, _data = do_parse(der, ber: ber)
+        total_length, data = do_parse(der, ber: ber)
+        @value = data
         total_length
       end
 
-      # @param [::Integer] level
-      # @return [String]
-      def inspect(level=0)
-        str = common_inspect(level)
-        str << if !value?
-                 'NULL'
-               elsif @value.is_a?(OctetString) || @value.is_a?(BitString)
-                 "#{@value.type}: #{value.value.inspect}"
-               elsif @value.class < Base
-                 "#{@value.type}: #{value.value}"
-               else
-                 value.to_s.inspect
-               end
-      end
-
       # @private Tracer private API
       # @return [String]
       def trace
         return trace_any if value?
 
-        msg_type(no_id: true) << " #{colorize_nil}"
-      end
-
-      private
-
-      def common_inspect(level)
-        lvl = [0, level].max
-        str = '  ' * lvl
-        str << "#{@name} " unless @name.nil?
-        str << asn1_class.to_s.upcase << ' ' unless asn1_class == :universal
-        str << "[#{id}] EXPLICIT " if explicit?
-        str << "[#{id}] IMPLICIT " if implicit?
-        str << '(ANY) '
+        parts = []
+        parts << msg_type(no_id: true)
+        parts << colorize_nil
+        parts.reject(&:empty?).join(' ')
       end
 
       # @private
       # @see Types::Base#do_parse
       def do_parse(der, ber: false)
+        asn1_class, _pc, id, id_size = Types.decode_identifier_octets(der)
+        @id = id
+        @asn1_class = asn1_class
+
         if der.empty?
           return [0, ''] if optional?
 
           raise ASN1Error, 'Expected ANY but get nothing'
         end
 
-        id_size = Types.decode_identifier_octets(der).last
         total_length, = get_data(der[id_size..], ber)
         total_length += id_size
 
         @no_value = false
         real_value = der[0, total_length].to_s
-        @value = real_value
+        @value = if constructed?
+                   RASN2.parse(real_value, ber: ber)
+                 else
+                   real_value
+                 end
 
-        [total_length, real_value]
+        [total_length, @value]
       end
 
       def trace_any
-        msg_type(no_id: true) << trace_data(value)
+        "#{msg_type(no_id: false)}#{trace_data(value)}"
       end
     end
   end