rasn1 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 66f3cf5edaaabbd17a920296e943f8e46f5de81c
-  data.tar.gz: a83fb189ba31da35c1dc1743a01675fb3ac270d1
+  metadata.gz: 379d5a61021e3b58ffb46317f72905e9e3972044
+  data.tar.gz: 60bb0d280cccd6c999744045fb45f334863d46f4
 SHA512:
-  metadata.gz: fa8459ba40745b387cdde298ff577707c63fd41ee4a2646b639878fcbb695638050910b94ec638ce7f010b8053140e30aa305a0634f3508c6fb8e6c7a8a337c7
-  data.tar.gz: a7bc698f83d23585dfd75b27cc46429c9f2ec84b6c36d77980fbb3d0423b8ead411cd9a700a4700b2164e117d247837d54771e66a5f8aaf03fa198b1336cb9b7
+  metadata.gz: beb7960cfdef060b22f81dea31d7b93ece7781afad2b0a7db92606b860e8ff00ab1ae7991a86d5594b97b18b53c2888d6d83f11e4fe6e84abb33cfdddb491d75
+  data.tar.gz: 2fe8288bb99e4c21ead959855e3b0611c182abc6f2e23a8a60ff0babe7ebe62ef9a7795ec8f0512d50792f2e02278b192e8d62879c6f7815836ebb3c2c3287a0

data/README.md

@@ -1,3 +1,5 @@
+[![Gem Version](https://badge.fury.io/rb/rasn1.svg)](https://badge.fury.io/rb/rasn1)
+
 # Rasn1
 
 Rasn1 will be a ruby ASN.1 library to encode, parse and decode ASN.1 data in DER format.
@@ -47,7 +49,7 @@ class ComplexRecord < RASN1::Model
   sequence :cplx_record,
            content: [boolean(:bool),
 	             octet_string(:data, explicit: 0),
-		     Record]
+		     model(:a_record, Record)]
 end
 ```
 

data/lib/rasn1/model.rb

@@ -40,41 +40,94 @@ module RASN1
   #  class Record2 < RASN1::Model
   #    sequence(:record2,
   #             content: [boolean(:rented, default: false),
-  #                       Record])
+  #                       model(:a_record, Record)])
   #  end
   # Set values like this:
   #  record2 = Record2.new
   #  record2[:rented] = true
-  #  record2[:record][:id] = 65537
-  #  record2[:record][:room] = 43
+  #  record2[:a_record][:id] = 65537
+  #  record2[:a_record][:room] = 43
   # or like this:
-  #  record2 = Record2.new(rented: true, record: { id: 65537, room: 43 })
+  #  record2 = Record2.new(rented: true, a_record: { id: 65537, room: 43 })
   # @author Sylvain Daubert
   class Model
 
     class << self
 
-      # Define a SEQUENCE type. Should be used to define a new subclass of {Model}.
-      # @param [Hash] options
-      # @option options [Array] :content
-      # @see Types::Sequence#initialize
-      # @return [Types::Sequence]
-      def sequence(name, options={})
-        @records ||= {}
-        @records[name] = Proc.new do
-          seq = Types::Sequence.new(name, options)
-          seq.value = options[:content] if options[:content]
-          seq
-        end
+      # Use another model in this model
+      # @param [String,Symbol] name
+      # @param [Class] model_klass
+      def model(name, model_klass)
+        @root = [name, model_klass]
+      end
+
+      # @method sequence(name, options)
+      #  @see Types::Sequence#initialize
+      # @method set(name, options)
+      #  @see Types::Set#initialize
+      # @method choice(name, options)
+      #  @see Types::Choice#initialize
+      %w(sequence set choice).each do |type|
+        class_eval "def #{type}(name, options={})\n" \
+                   "  proc = Proc.new do\n" \
+                   "    Types::#{type.capitalize}.new(name, options)\n" \
+                   "  end\n" \
+                   "  @root = [name, proc]\n" \
+                   "  @root << options[:content] unless options[:content].nil?\n" \
+                   "  @root\n" \
+                   "end"
       end
 
-      # define all class methods to instance a ASN.1 TAG
+      # @method sequence_of(name, type, options)
+      #  @see Types::SequenceOf#initialize
+      # @method set_of(name, type, options)
+      #  @see Types::SetOf#initialize
+      %w(sequence set).each do |type|
+        klass_name = "Types::#{type.capitalize}Of"
+        class_eval "def #{type}_of(name, type, options={})\n" \
+                   "  proc = Proc.new do\n" \
+                   "    #{klass_name}.new(name, type, options)\n" \
+                   "  end\n" \
+                   "  @root = [name, proc]\n" \
+                   "end"
+      end
+
+      # @method boolean(name, options)
+      #  @see Types::Boolean#initialize
+      # @method integer(name, options)
+      #  @see Types::Integer#initialize
+      # @method bit_string(name, options)
+      #  @see Types::BitString#initialize
+      # @method octet_string(name, options)
+      #  @see Types::OctetString#initialize
+      # @method null(name, options)
+      #  @see Types::Null#initialize
+      # @method enumerated(name, options)
+      #  @see Types::Enumerated#initialize
+      # @method utf8_string(name, options)
+      #  @see Types::Utf8String#initialize
       Types.primitives.each do |prim|
+        next if prim == Types::ObjectId
         class_eval "def #{prim.type.downcase.gsub(/\s+/, '_')}(name, options={})\n" \
-                   "  Proc.new { #{prim.to_s}.new(name, options) }\n" \
+                   "  proc = Proc.new { #{prim.to_s}.new(name, options) }\n" \
+                   "  @root = [name, proc]\n" \
                    "end"
       end
 
+      # @note This method is named +objectid+ and not +object_id+ to not override
+      #   +Object#object_id+.
+      # @see Types::ObjectId#initialize
+      def objectid(name, options={})
+        proc = Proc.new { Types::ObjectId.new(name, options) }
+        @root = [name, proc]
+      end
+
+      # @see Types::Any#initialize
+      def any(name, options={})
+        proc = Proc.new { Types::Any.new(name, options) }
+        @root = [name, proc]
+      end
+
       # Parse a DER/BER encoded string
       # @param [String] str
       # @param [Boolean] ber accept BER encoding or not
@@ -89,7 +142,8 @@ module RASN1
     # Create a new instance of a {Model}
     # @param [Hash] args
     def initialize(args={})
-      set_elements
+      root = generate_root
+      set_elements *root
       initialize_elements self, args
     end
 
@@ -106,6 +160,12 @@ module RASN1
       @elements[@root].name
     end
 
+    # Get elements names
+    # @return [Array<Symbol,String>]
+    def keys
+      @elements.keys
+    end
+
     # Return a hash image of model
     # @return [Hash]
     def to_h
@@ -117,46 +177,56 @@ module RASN1
       @elements[@root].to_der
     end
 
+    # Get root element from model
+    # @return [Types::Base,Model]
+    def root
+      @elements[@root]
+    end
+
     # Parse a DER/BER encoded string, and modify object in-place.
     # @param [String] str
     # @param [Boolean] ber accept BER encoding or not
     # @return [Integer] number of parsed bytes
     def parse!(str, ber: false)
-      @elements[@root].parse!(str, ber: ber)
+      @elements[@root].parse!(str.dup.force_encoding('BINARY'), ber: ber)
     end
 
     private
 
-    def set_elements(element=nil)
-      if element.nil?
-        records = self.class.class_eval { @records }
-        @root = records.keys.first
-        @elements = {}
-        @elements[@root] = records[@root].call
-        if @elements[@root].value.is_a? Array
-          @elements[@root].value = @elements[@root].value.map do |subel|
-            se = case subel
-                 when Proc
-                   subel.call
-                 when Class
-                   subel.new
-                 end
-            @elements[se.name] = se
-            set_elements se if se.is_a? Types::Sequence
-            se
+    def is_composed?(el)
+      [Types::Sequence, Types::Set].include? el.class
+    end
+
+    def is_of?(el)
+      [Types::SequenceOf, Types::SetOf].include? el.class
+    end
+
+    def get_type(proc_or_class, name=nil)
+      case proc_or_class
+      when Proc
+        proc_or_class.call
+      when Class
+        proc_or_class.new
+      end
+    end
+
+    def generate_root
+      root = self.class.class_eval { @root }
+      @root = root[0]
+      @elements = {}
+      @elements[@root] = get_type(root[1])
+      root
+    end
+
+    def set_elements(name, el, content=nil)
+      if content.is_a? Array
+        @elements[name].value = content.map do |name2, proc_or_class, content2|
+          subel = get_type(proc_or_class, name2)
+          @elements[name2] = subel
+          if is_composed?(subel) and content2.is_a? Array
+            set_elements(name2, proc_or_class, content2)
           end
-        end
-      else
-        element.value.map! do |subel|
-          se = case subel
-               when Proc
-                 subel.call
-               when Class
-                 subel.new
-               end
-          @elements[se.name] = se
-          set_elements se if se.is_a? Types::Sequence
-          se
+          subel
         end
       end
     end
@@ -168,7 +238,7 @@ module RASN1
             if obj[name].is_a? Model
               initialize_elements obj[name], value
             else
-              raise ArgumentError, "element #{name}: may only pass a Hash for Sequence elements"
+              raise ArgumentError, "element #{name}: may only pass a Hash for Model elements"
             end
           else
             obj[name].value = value
@@ -178,20 +248,27 @@ module RASN1
     end
 
     def private_to_h(element)
-      h = {}
-      element.value.each do |subel|
-        h[subel.name] = case subel
-                        when Types::Sequence
-                          private_to_h(subel)
-                        when Model
-                          subel.to_h[subel.name]
-                        else
-                          next if subel.value.nil? and subel.optional?
-                          subel.value
-                        end
+      if element.value.is_a? Array
+        h = {}
+        element.value.each do |subel|
+          case subel
+          when Types::Sequence, Types::Set
+            h[subel.name] = private_to_h(subel)
+          when Model
+            h[@elements.key(subel)] = subel.to_h[subel.name]
+          when Hash, Array
+            # Array of Hash for SequenceOf and SetOf
+            # Array of Array of... of Hash are nested SequenceOf or SetOf
+            return element.value
+          else
+            next if subel.value.nil? and subel.optional?
+            h[subel.name] = subel.value
+          end
+        end
+        h
+      else
+        element.value
       end
-
-      h
     end
   end
 end

data/lib/rasn1/types.rb

@@ -35,3 +35,4 @@ require_relative 'types/sequence_of'
 require_relative 'types/set'
 require_relative 'types/set_of'
 require_relative 'types/choice'
+require_relative 'types/any'

data/lib/rasn1/types/any.rb

@@ -0,0 +1,29 @@
+module RASN1
+  module Types
+
+    # ASN.1 ANY: accpets any types
+    # @author Sylvain Daubert
+    class Any < Base
+
+      # @return [String] DER-formated string
+      def to_der
+        case @value
+        when Base, Model
+          @value.to_der
+        else
+          @value.to_s
+        end
+      end
+
+      # Parse a DER string. This method updates object: {#value} will a DER string.
+      # @param [String] der DER string
+      # @param [Boolean] ber if +true+, accept BER encoding
+      # @return [Integer] total number of parsed bytes
+      def parse!(der, ber: false)
+        total_length,  = get_data(der, ber)
+        @value = der[0, total_length]
+        total_length
+      end
+    end
+  end
+end

data/lib/rasn1/types/base.rb

@@ -36,6 +36,9 @@ module RASN1
     #  ctype = RASN1::Types::Integer.new(:ctype, explicit: 0)                      # with explicit, default #asn1_class is :context
     #  atype = RASN1::Types::Integer.new(:atype, explicit: 1, class: :application)
     #  ptype = RASN1::Types::Integer.new(:ptype, explicit: 2, class: :private)
+    # Sometimes, an EXPLICIT type should be CONSTRUCTED. To do that, use +:constructed+
+    # option:
+    #  ptype = RASN1::Types::Integer.new(:ptype, explicit: 2, class: :private, constructed: true)
     #
     # Implicit tagged values may also be defined:
     #  ctype_implicit = RASN1::Types::Integer.new(:ctype, implicit: 0)
@@ -56,7 +59,7 @@ module RASN1
       INDEFINITE_LENGTH = 0x80
 
       # @return [Symbol, String]
-      attr_reader :name
+      attr_accessor :name
       # @return [Symbol]
       attr_reader :asn1_class
       # @return [Object,nil] default value, if defined
@@ -74,13 +77,19 @@ module RASN1
 
       # @param [Symbol, String] name name for this tag in grammar
       # @param [Hash] options
-      # @option options [Symbol] :class ASN.1 tag class. Default value is +:universal+
+      # @option options [Symbol] :class ASN.1 tag class. Default value is +:universal+.
+      #  If +:explicit+ or +:implicit:+ is defined, default value is +:context+.
       # @option options [::Boolean] :optional define this tag as optional. Default
       #   is +false+
       # @option options [Object] :default default value for DEFAULT tag
       # @option options [Object] :value value to set
+      # @option options [::Integer] :implicit define an IMPLICIT tagged type
+      # @option options [::Integer] :explicit define an EXPLICIT tagged type
+      # @option options [::Boolean] :constructed if +true+, set type as constructed.
+      #  May only be used when +:explicit+ is defined, else it is discarded.
       def initialize(name, options={})
         @name = name
+        @constructed = nil
 
         set_options options
       end
@@ -137,20 +146,12 @@ module RASN1
 
       # @return [::Boolean] +true+ if this is a primitive type
       def primitive?
-        if self.class < Primitive
-          true
-        else
-          false
-        end
+        (self.class < Primitive) && !@constructed
       end
 
       # @return [::Boolean] +true+ if this is a constructed type
       def constructed?
-        if self.class < Constructed
-          true
-        else
-          false
-        end
+        !!((self.class < Constructed) ||  @constructed)
       end
 
       # Get ASN.1 type
@@ -162,7 +163,12 @@ module RASN1
       # Get tag value
       # @return [Integer]
       def tag
-        (@tag_value || self.class::TAG) | CLASSES[@asn1_class] | self.class::ASN1_PC
+        pc = if  @constructed.nil?
+               self.class::ASN1_PC
+             else
+               Constructed::ASN1_PC
+             end
+        (@tag_value || self.class::TAG) | CLASSES[@asn1_class] | pc
       end
 
       # @abstract This method SHOULD be partly implemented by subclasses to parse
@@ -177,7 +183,8 @@ module RASN1
 
         total_length, data = get_data(der, ber)
         if explicit?
-          type = self.class.new(@name)
+          # Delegate to #explicit type to generate sub-tag
+          type = explicit_type
           type.parse!(data)
           @value = type.value
         else
@@ -225,6 +232,7 @@ module RASN1
         if options[:explicit]
           @tag = :explicit
           @tag_value = options[:explicit]
+          @constructed = options[:constructed]
         elsif options[:implicit]
           @tag = :implicit
           @tag_value = options[:implicit]
@@ -241,7 +249,7 @@ module RASN1
       def build_tag
         if build_tag?
           if explicit?
-            v = self.class.new(nil)
+            v = explicit_type
             v.value = @value
             encoded_value = v.to_der
           else
@@ -325,8 +333,12 @@ module RASN1
         [total_length, data]
       end
 
+      def explicit_type
+        self.class.new(@name)
+      end
+
       def raise_tag_error(expected_tag, tag)
-        msg = "Expected tag #{tag2name(expected_tag)} but get #{tag2name(tag)}"
+        msg = "Expected #{tag2name(expected_tag)} but get #{tag2name(tag)}"
         msg << " for #@name"
         raise ASN1Error, msg
       end

data/lib/rasn1/types/enumerated.rb

@@ -18,6 +18,8 @@ module RASN1
     # A {EnumeratedError} is raised when set value is not in enumeration.
     # @author Sylvain Daubert
     class Enumerated < Integer
+      # @return [Hash]
+      attr_reader :enum
 
       # @param [Symbol, String] name name for this tag in grammar
       # @param [Hash] options
@@ -114,6 +116,10 @@ module RASN1
         @value = @enum.key(v)
         raise EnumeratedError, "TAG #@name: value #{v} not in enumeration" if @value.nil?
       end
+
+      def explicit_type
+        self.class.new(@name, enum: self.enum)
+      end
     end
   end
 end

data/lib/rasn1/types/sequence.rb

@@ -18,6 +18,11 @@ module RASN1
     #               RASN1::Types::Integer(:id, explicit: 0, optional: true),
     #               RASN1::Types::Integer(:id, 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
       TAG = 0x10
@@ -25,14 +30,25 @@ module RASN1
       private
 
       def value_to_der
-        @value.map { |element| element.to_der }.join
+        case @value
+        when Array
+          @value.map { |element| element.to_der }.join
+        else
+          @value.to_s
+        end
       end
 
       def der_to_value(der, ber:false)
-        nb_bytes = 0
-        @value.each do |element|
-          nb_bytes += element.parse!(der[nb_bytes..-1])
-        end
+        case @value
+        when Array
+          nb_bytes = 0
+          @value.each do |element|
+            nb_bytes += element.parse!(der[nb_bytes..-1])
+          end
+        else
+          @value = der
+          der.length
+        end 
       end
     end
   end

data/lib/rasn1/types/sequence_of.rb

@@ -5,6 +5,7 @@ module RASN1
     #
     # 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:
@@ -13,6 +14,7 @@ module RASN1
     #  # Set integer values
     #  seqof.value = [1, 2, 3, 4]
     #
+    # == Use with {Constructed} types
     # SEQUENCE OF may be used to create sequence of composed types. For example:
     #  composed_type = RASN1::Sequence.new(:comp)
     #  commposed_type.value = [RASN1::Types::Integer(:id),
@@ -20,38 +22,54 @@ module RASN1
     #  seqof = RASN1::SequenceOf.new(:comp, composed_type)
     #  seqof.value << [0, 'data0']
     #  seqof.value << [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.value << { bool: true, int: 12 }
+    #  seqof.value << { bool: false, int: 65535 }
+    #  # Generate DER string
+    #  der = seqof.to_der    # => String
+    #  # parse 
+    #  seqof.parse! der
     # @author Sylvain Daubert
     class SequenceOf < Constructed
       TAG = Sequence::TAG
 
       # @return [Class, Base]
-      attr_reader :type
+      attr_reader :of_type
 
       # @param [Symbol, String] name name for this tag in grammar
-      # @param [Class, Base] type base type for sequence of
+      # @param [Class, Base] of_type base type for sequence of
       # @see Base#initialize
-      def initialize(name, type, options={})
+      def initialize(name, of_type, options={})
         super(name, options)
-        @type = type
+        @of_type = of_type
         @value = []
       end
 
       private
 
-      def type_class
-        type.is_a?(Class) ? type : type.class
+      def of_type_class
+        @of_type.is_a?(Class) ? @of_type : @of_type.class
       end
 
-      def composed_type?
-        [Sequence, Set].include? type_class
+      def composed_of_type?
+        [Sequence, Set].include? of_type_class
       end
 
       def value_to_der
-        if composed_type?
+        if composed_of_type?
           @value.map do |ary|
-            s = type_class.new(@type.name)
+            s = of_type_class.new(@of_type.name)
             sval = []
-            @type.value.each_with_index do |type, i|
+            @of_type.value.each_with_index do |type, i|
               type2 = type.dup
               type2.value = ary[i]
               sval << type2
@@ -59,8 +77,21 @@ module RASN1
             s.value = sval
             s.to_der
           end.join
+        elsif of_type_class < Model
+          if of_type_class.new.root.is_a? SequenceOf
+            @value.map do |ary|
+              model = of_type_class.new
+              model.root.value = ary
+              model.to_der
+            end.join
+          else
+            @value.map do |hsh|
+              model = of_type_class.new(hsh)
+              model.to_der
+            end.join
+          end
         else
-          @value.map { |v| t = type_class.new(:t, value: v).to_der }.join
+          @value.map { |v| of_type_class.new(:t, value: v).to_der }.join
         end
       end
 
@@ -69,16 +100,28 @@ module RASN1
         nb_bytes = 0
 
         while nb_bytes < der.length
-          of_type = composed_type? ? type.dup : type_class.new(:t)
-          nb_bytes += of_type.parse!(der[nb_bytes, der.length])
-          value = if composed_type?
-                    of_type.value.map { |obj| obj.value }
+          type = if composed_of_type?
+                   @of_type.dup
+                 elsif of_type_class < Model
+                   of_type_class.new
+                 else
+                   of_type_class.new(:t)
+                 end
+          nb_bytes += type.parse!(der[nb_bytes, der.length])
+          value = if composed_of_type?
+                    type.value.map { |obj| obj.value }
+                  elsif of_type_class < Model
+                    type.to_h[type.to_h.keys.first]
                   else
-                    of_type.value
+                    type.value
                   end
           @value << value
         end
       end
+
+      def explicit_type
+        self.class.new(@name, self.of_type)
+      end
     end
   end
 end

data/lib/rasn1/version.rb

@@ -1,3 +1,3 @@
 module RASN1
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/rasn1.gemspec

@@ -20,6 +20,8 @@ Gem::Specification.new do |spec|
   #spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
+  spec.required_ruby_version = '>= 2.1.0'
+
   spec.add_dependency 'yard', '~>0.9'
 
   spec.add_development_dependency 'bundler', '~> 1.13'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rasn1
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Sylvain Daubert
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-06 00:00:00.000000000 Z
+date: 2017-08-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: yard
@@ -95,6 +95,7 @@ files:
 - lib/rasn1.rb
 - lib/rasn1/model.rb
 - lib/rasn1/types.rb
+- lib/rasn1/types/any.rb
 - lib/rasn1/types/base.rb
 - lib/rasn1/types/bit_string.rb
 - lib/rasn1/types/boolean.rb
@@ -125,7 +126,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="