rasn1 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 66f3cf5edaaabbd17a920296e943f8e46f5de81c
+  data.tar.gz: a83fb189ba31da35c1dc1743a01675fb3ac270d1
+SHA512:
+  metadata.gz: fa8459ba40745b387cdde298ff577707c63fd41ee4a2646b639878fcbb695638050910b94ec638ce7f010b8053140e30aa305a0634f3508c6fb8e6c7a8a337c7
+  data.tar.gz: a7bc698f83d23585dfd75b27cc46429c9f2ec84b6c36d77980fbb3d0423b8ead411cd9a700a4700b2164e117d247837d54771e66a5f8aaf03fa198b1336cb9b7

data/.gitignore

@@ -0,0 +1,10 @@
+*~
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rasn1.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Sylvain Daubert
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,89 @@
+# Rasn1
+
+Rasn1 will be a ruby ASN.1 library to encode, parse and decode ASN.1 data in DER format.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rasn1'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rasn1
+
+## Usage
+All examples below will be based on:
+
+```
+Record ::= SEQUENCE {
+  id        INTEGER,
+  room  [0] INTEGER OPTIONAL,
+  house [1] INTEGER DEFAULT 0
+}
+```
+
+## Create a ASN.1 model
+
+```ruby
+class Record < RASN1::Model
+  sequence :record,
+           content: [integer(:id),
+                     integer(:room, implicit: 0, optional: true),
+                     integer(:house, implicit: 1, default: 0)]
+end
+```
+
+More comple classes may be designed by nesting simple classes. For example:
+
+```ruby
+class ComplexRecord < RASN1::Model
+  sequence :cplx_record,
+           content: [boolean(:bool),
+	             octet_string(:data, explicit: 0),
+		     Record]
+end
+```
+
+## Parse a DER-encoded string
+```ruby
+record = Record.parse(der_string)
+record[:id]             # => RASN1::Types::Integer
+record[:id].value       # => Integer
+record[:id].to_i        # => Integer
+record[:id].asn1_class  # => Symbol
+record[:id].optional?   # => false
+record[:id].default     # => nil
+record[:room].optional  # => true
+record[:house].default  # => 0
+
+record[:id].to_der      # => String
+```
+
+## Generate a DER-encoded string
+```ruby
+record = Record.new(id: 12)
+record[:id].to_i      # => 12
+record[:room]         # => nil
+record[:house]        # => 0
+
+# Set one value
+record[:room] = 43
+record[:room]         # => 43
+
+# Set mulitple values
+record.set id: 124, house: 155
+
+record.to_der         # => String
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/sdaubert/rasn1.
+

data/Rakefile

@@ -0,0 +1,12 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'yard'
+
+RSpec::Core::RakeTask.new
+YARD::Rake::YardocTask.new do |t|
+  t.files = ['lib/**/*.rb', '-', 'README.md', 'LICENSE']
+  t.options = %w(--no-private)
+end
+
+task :default => :spec
+

data/lib/rasn1.rb

@@ -0,0 +1,32 @@
+require 'rasn1/version'
+require 'rasn1/types'
+require 'rasn1/model'
+
+# Rasn1 is a pure ruby library to parse, decode and encode ASN.1 data.
+# @author Sylvain Daubert
+module RASN1
+
+  # Base error class
+  class Error < StandardError; end
+
+  # ASN.1 encoding/decoding error
+  class ASN1Error < Error; end
+
+  # ASN.1 class error
+  class ClassError < Error
+    # @return [String]
+    def message
+      "Tag class should be a symbol: #{Types::Base::CLASSES.keys.join(', ')}"
+    end
+  end
+
+  # Enumerated error
+  class EnumeratedError < Error; end
+
+  # CHOICE error: #chosen not set
+  class ChoiceError < RASN1::Error
+    def message
+      "CHOICE #@name: #chosen not set"
+    end
+  end
+end

data/lib/rasn1/model.rb

@@ -0,0 +1,197 @@
+module RASN1
+
+  # @abstract
+  # {Model} class is a base class to define ASN.1 models.
+  # == Create a simple ASN.1 model
+  # Given this ASN.1 example:
+  #  Record ::= SEQUENCE {
+  #    id        INTEGER,
+  #    room  [0] IMPLICIT INTEGER OPTIONAL,
+  #    house [1] EXPLICIT INTEGER DEFAULT 0
+  #  }
+  # you may create your model like this:
+  #  class Record < RASN1::Model
+  #    sequence(:record,
+  #             content: [integer(:id),
+  #                       integer(:room, implicit: 0, optional: true),
+  #                       integer(:house, explicit: 1, default: 0)])
+  #  end
+  #
+  # === Parse a DER-encoded string
+  #  record = Record.parse(der_string)
+  #  record[:id]             # => RASN1::Types::Integer
+  #  record[:id].value       # => Integer
+  #  record[:id].to_i        # => Integer
+  #  record[:id].asn1_class  # => Symbol
+  #  record[:id].optional?   # => false
+  #  record[:id].default     # => nil
+  #  record[:room].optional  # => true
+  #  record[:house].default  # => 0
+  #
+  # You may also parse a BER-encoded string this way:
+  #  record = Record.parse(der_string, ber: true)
+  #
+  # === Generate a DER-encoded string
+  #  record = Record.new(id: 12, room: 24)
+  #  record.to_der
+  #
+  # == Create a more complex model
+  # Models may be nested. For example:
+  #  class Record2 < RASN1::Model
+  #    sequence(:record2,
+  #             content: [boolean(:rented, default: false),
+  #                       Record])
+  #  end
+  # Set values like this:
+  #  record2 = Record2.new
+  #  record2[:rented] = true
+  #  record2[:record][:id] = 65537
+  #  record2[:record][:room] = 43
+  # or like this:
+  #  record2 = Record2.new(rented: true, 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
+      end
+
+      # define all class methods to instance a ASN.1 TAG
+      Types.primitives.each do |prim|
+        class_eval "def #{prim.type.downcase.gsub(/\s+/, '_')}(name, options={})\n" \
+                   "  Proc.new { #{prim.to_s}.new(name, options) }\n" \
+                   "end"
+      end
+
+      # Parse a DER/BER encoded string
+      # @param [String] str
+      # @param [Boolean] ber accept BER encoding or not
+      # @return [Model]
+      def parse(str, ber: false)
+        model = new
+        model.parse! str, ber: ber
+        model
+      end
+    end
+
+    # Create a new instance of a {Model}
+    # @param [Hash] args
+    def initialize(args={})
+      set_elements
+      initialize_elements self, args
+    end
+
+    # Give access to element +name+ in model
+    # @param [String,Symbol] name
+    # @return [Types::Base]
+    def [](name)
+      @elements[name]
+    end
+
+    # Get name frm root type
+    # @return [String,Symbol]
+    def name
+      @elements[@root].name
+    end
+
+    # Return a hash image of model
+    # @return [Hash]
+    def to_h
+      { @root => private_to_h(@elements[@root]) }
+    end
+
+    # @return [String]
+    def to_der
+      @elements[@root].to_der
+    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)
+    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
+          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
+        end
+      end
+    end
+
+    def initialize_elements(obj, args)
+      args.each do |name, value|
+        if obj[name]
+          if value.is_a? Hash
+            if obj[name].is_a? Model
+              initialize_elements obj[name], value
+            else
+              raise ArgumentError, "element #{name}: may only pass a Hash for Sequence elements"
+            end
+          else
+            obj[name].value = value
+          end
+        end
+      end
+    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
+      end
+
+      h
+    end
+  end
+end

data/lib/rasn1/types.rb

@@ -0,0 +1,37 @@
+module RASN1
+  # This modules is a namesapce for all ASN.1 type classes.
+  # @author Sylvain Daubert
+  module Types
+
+    # Give all primitive types
+    # @return [Array<Types::Primitive>]
+    def self.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
+      self.constants.map { |c| Types.const_get(c) }.
+          select { |klass| klass < Constructed }
+    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/utf8_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'

data/lib/rasn1/types/base.rb

@@ -0,0 +1,347 @@
+module RASN1
+  module Types
+
+    # @abstract This is base class for all ASN.1 types.
+    #   
+    #   Subclasses SHOULD define:
+    #   * a TAG constant defining ASN.1 tag number,
+    #   * a private method {#value_to_der} converting its {#value} to DER,
+    #   * a private method {#der_to_value} converting DER into {#value}.
+    #
+    # ==Define an optional value
+    # An optional value may be defined using +:optional+ key from {#initialize}:
+    #   Integer.new(:int, optional: true)
+    # An optional value implies:
+    # * while parsing, if decoded tag is not optional expected tag, no {ASN1Error}
+    #   is raised, and parser tries net tag,
+    # * while encoding, if {#value} is +nil+, this value is not encoded.
+    # ==Define a default value
+    # A default value may be defined using +:default+ key from {#initialize}:
+    #  Integer.new(:int, default: 0)
+    # A default value implies:
+    # * while parsing, if decoded tag is not expected tag, no {ASN1Error} is raised
+    #   and parser sets default value to this tag. Then parser tries nex tag,
+    # * while encoding, if {#value} is equal to default value, this value is not
+    #   encoded.
+    # ==Define a tagged value
+    # ASN.1 permits to define tagged values.
+    # By example:
+    #  -- context specific tag
+    #  CType ::= [0] EXPLICIT INTEGER
+    #  -- application specific tag
+    #  AType ::= [APPLICATION 1] EXPLICIT INTEGER
+    #  -- private tag
+    #  PType ::= [PRIVATE 2] EXPLICIT INTEGER
+    # These types may be defined as:
+    #  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)
+    #
+    # Implicit tagged values may also be defined:
+    #  ctype_implicit = RASN1::Types::Integer.new(:ctype, implicit: 0)
+    # @author Sylvain Daubert
+    class Base
+      # Allowed ASN.1 tag classes
+      CLASSES = {
+                 universal:   0x00,
+                 application: 0x40,
+                 context:     0x80,
+                 private:     0xc0
+                }
+
+      # Maximum ASN.1 tag number
+      MAX_TAG = 0x1e
+
+      # Length value for indefinite length
+      INDEFINITE_LENGTH = 0x80
+
+      # @return [Symbol, String]
+      attr_reader :name
+      # @return [Symbol]
+      attr_reader :asn1_class
+      # @return [Object,nil] default value, if defined
+      attr_reader :default
+      # @return [Object]
+      attr_writer :value
+
+      # Get ASN.1 type
+      # @return [String]
+      def self.type
+        return @type if @type
+        @type = self.to_s.gsub(/.*::/, '').gsub(/([a-z0-9])([A-Z])/, '\1 \2').upcase
+      end
+
+
+      # @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 [::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
+      def initialize(name, options={})
+        @name = name
+
+        set_options options
+      end
+
+      # Used by +#dup+ and +#clone+. Deep copy @value.
+      def initialize_copy(other)
+        @value = @value.nil? ? nil : @value.dup
+      end
+
+      # Get value or default value
+      def value
+        if @value.nil?
+          @default
+        else
+          @value
+        end
+      end
+
+      # @return [::Boolean]
+      def optional?
+        @optional
+      end
+
+      # Say if this type is tagged or not
+      # @return [::Boolean]
+      def tagged?
+        !@tag.nil?
+      end
+
+      # Say if a tagged type is explicit
+      # @return [::Boolean,nil] return +nil+ if not tagged, return +true+
+      #   if explicit, else +false+
+      def explicit?
+        @tag.nil? ? @tag : @tag == :explicit
+      end
+
+      # Say if a tagged type is implicit
+      # @return [::Boolean,nil] return +nil+ if not tagged, return +true+
+      #   if implicit, else +false+
+      def implicit?
+        @tag.nil? ? @tag : @tag == :implicit
+      end
+
+      # @abstract This method SHOULD be partly implemented by subclasses, which
+      #   SHOULD respond to +#value_to_der+.
+      # @return [String] DER-formated string
+      def to_der
+        if self.class.const_defined?('TAG')
+          build_tag
+        else
+          raise NotImplementedError, 'should be implemented by subclasses'
+        end
+      end
+
+      # @return [::Boolean] +true+ if this is a primitive type
+      def primitive?
+        if self.class < Primitive
+          true
+        else
+          false
+        end
+      end
+
+      # @return [::Boolean] +true+ if this is a constructed type
+      def constructed?
+        if self.class < Constructed
+          true
+        else
+          false
+        end
+      end
+
+      # Get ASN.1 type
+      # @return [String]
+      def type
+        self.class.type
+      end
+
+      # Get tag value
+      # @return [Integer]
+      def tag
+        (@tag_value || self.class::TAG) | CLASSES[@asn1_class] | self.class::ASN1_PC
+      end
+
+      # @abstract This method SHOULD be partly implemented by subclasses to parse
+      #  data. Subclasses SHOULD respond to +#der_to_value+.
+      # 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
+      def parse!(der, ber: false)
+        return 0 unless check_tag(der)
+
+        total_length, data = get_data(der, ber)
+        if explicit?
+          type = self.class.new(@name)
+          type.parse!(data)
+          @value = type.value
+        else
+          der_to_value(data, ber: ber)
+        end
+
+        total_length
+      end
+
+
+      private
+
+      def set_options(options)
+        set_class options[:class]
+        set_optional options[:optional]
+        set_default options[:default]
+        set_tag options
+        @value = options[:value]
+      end
+
+      def set_class(asn1_class)
+        case asn1_class
+        when nil
+          @asn1_class = :universal
+        when Symbol
+          if CLASSES.keys.include? asn1_class
+            @asn1_class = asn1_class
+          else
+            raise ClassError
+          end
+        else
+          raise ClassError
+        end
+      end
+
+      def set_optional(optional)
+        @optional = !!optional
+      end
+
+      def set_default(default)
+        @default = default
+      end
+
+      def set_tag(options)
+        if options[:explicit]
+          @tag = :explicit
+          @tag_value = options[:explicit]
+        elsif options[:implicit]
+          @tag = :implicit
+          @tag_value = options[:implicit]
+        end
+
+        @asn1_class = :context if @tag and @asn1_class == :universal
+      end
+
+      def build_tag?
+        !(!@default.nil? and (@value.nil? or @value == @default)) and
+          !(optional? and @value.nil?)
+      end
+
+      def build_tag
+        if build_tag?
+          if explicit?
+            v = self.class.new(nil)
+            v.value = @value
+            encoded_value = v.to_der
+          else
+            encoded_value = value_to_der
+          end
+          encode_tag << encode_size(encoded_value.size) << encoded_value
+        else
+          ''
+        end
+      end
+
+      def encode_tag
+        if (@tag_value || self.class::TAG) <= MAX_TAG
+          [tag].pack('C')
+        else
+          raise ASN1Error, 'multi-byte tag value are not supported'
+        end
+      end
+
+      def encode_size(size)
+        if size >= INDEFINITE_LENGTH
+          bytes = []
+          while size > 255
+            bytes << (size & 0xff)
+            size >>= 8
+          end
+          bytes << size
+          bytes.reverse!
+          bytes.unshift(INDEFINITE_LENGTH | bytes.size)
+          bytes.pack('C*')
+        else
+          [size].pack('C')
+        end
+      end
+
+      def check_tag(der)
+        tag = der[0, 1]
+        if tag != encode_tag
+          if optional?
+            @value = nil
+          elsif !@default.nil?
+            @value = @default
+          else
+            raise_tag_error(encode_tag, tag)
+          end
+          false
+        else
+          true
+        end
+      end
+
+      def get_data(der, ber)
+        length = der[1, 1].unpack('C').first
+        length_length = 0
+
+        if length == INDEFINITE_LENGTH
+          if primitive?
+            raise ASN1Error, "malformed #{type} TAG (#@name): indefinite length " \
+              "forbidden for primitive types"
+          else
+            if ber
+              raise NotImplementedError, "TAG #@name: indefinite length not " \
+                "supported yet"
+            else
+              raise ASN1Error, "TAG #@name: indefinite length forbidden in DER " \
+                "encoding"
+            end
+          end
+        elsif length < INDEFINITE_LENGTH
+          data = der[2, length]
+        else
+          length_length = length & 0x7f
+          length = der[2, length_length].unpack('C*').
+            reduce(0) { |len, b| (len << 8) | b }
+          data = der[2 + length_length, length]
+        end
+
+        total_length = 2 + length
+        total_length += length_length if length_length > 0
+
+        [total_length, data]
+      end
+
+      def raise_tag_error(expected_tag, tag)
+        msg = "Expected tag #{tag2name(expected_tag)} but get #{tag2name(tag)}"
+        msg << " for #@name"
+        raise ASN1Error, msg
+      end
+
+      def tag2name(tag)
+        return 'no tag' if tag.nil? or tag.empty?
+
+        itag = tag.unpack('C').first
+        name = CLASSES.key(itag & 0xc0).to_s.upcase
+        name << " #{itag & Constructed::ASN1_PC > 0 ? 'CONSTRUCTED' : 'PRIMITIVE'}"
+        type =  Types.constants.map { |c| Types.const_get(c) }.
+                  select { |klass| klass < Primitive || klass < Constructed }.
+                  find { |klass| klass::TAG == itag & 0x1f }
+        name << " #{type.nil? ? "0x%02X" % (itag & 0x1f) : type.type }"
+      end
+    end
+  end
+end