ldap-ber 0.1.0

data/lib/ber/function.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'ber/identified'
+
+module BER
+  # @see BER.function
+  #
+  # Used within refinements to identify...
+  #
+  class Function
+    def parse_ber_object(syntax, id, data)
+      object_type = (syntax && syntax[id]) || IDENTIFIED[id]
+
+      case object_type
+      when :string
+        s = BerIdentifiedString.new(data || EMPTY_STRING)
+        s.ber_identifier = id
+        s
+
+      when :integer
+        neg = !(data.unpack1('C') & 0x80).zero?
+        int = 0
+
+        data.each_byte do |b|
+          int = (int << 8) + (neg ? 255 - b : b)
+        end
+
+        if neg
+          (int + 1) * -1
+        else
+          int
+        end
+
+      when :oid
+        oid = data.unpack('w*')
+        f   = oid.shift
+        g   = if f < 40
+                [0, f]
+              elsif f < 80
+                [1, f - 40]
+              else
+                [2, f - 80]
+              end
+        oid.unshift g.last
+        oid.unshift g.first
+        BerIdentifiedOid.new(oid)
+
+      when :array
+        seq = BerIdentifiedArray.new
+        seq.ber_identifier = id
+        sio = StringIO.new(data || EMPTY_STRING)
+
+        until (e = read_ber(sio, syntax)).nil?
+          seq << e
+        end
+        seq
+
+      when :boolean
+        data != "\000"
+
+      when :null
+        n = BerIdentifiedNull.new
+        n.ber_identifier = id
+        n
+
+      else
+        raise Error, "Unsupported object type: id=#{id}"
+      end
+    end
+
+    def read_ber_length(object)
+      n = object.getbyte
+
+      if n <= 0x7f
+        n
+      elsif n == 0x80
+        -1
+      elsif n == 0xff
+        raise Error, 'Invalid BER length 0xFF detected.'
+      else
+        v = 0
+        object.read(n & 0x7f).each_byte do |b|
+          v = (v << 8) + b
+        end
+
+        v
+      end
+    end
+
+    def read_ber(object, syntax)
+      return unless (id = object.getbyte)
+
+      content_length = read_ber_length(object)
+
+      yield id, content_length if block_given?
+
+      raise Error, 'Indeterminite BER content length not implemented.' if content_length == -1
+
+      data = object.read(content_length)
+
+      parse_ber_object(syntax, id, data)
+    end
+  end
+end

data/lib/ber/identified.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'ber/identified/null'
+require 'ber/identified/oid'
+require 'ber/identified/string'
+require 'ber/identified/array'

data/lib/ber/identified/array.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module BER
+  # Wrapper around an Array
+  #
+  # @see BER::Function.parse_ber_object
+  class BerIdentifiedArray < Array
+    attr_accessor :ber_identifier
+
+    def initialize(*args)
+      super
+    end
+  end
+end

data/lib/ber/identified/null.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module BER
+  class BerIdentifiedNull
+    attr_accessor :ber_identifier
+
+    def to_ber
+      "\005\000"
+    end
+  end
+
+  Null = BerIdentifiedNull.new
+end

data/lib/ber/identified/oid.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module BER
+  class BerIdentifiedOid
+    attr_accessor :ber_identifier
+
+    def initialize(oid)
+      @value = oid.split(/\./).map(&:to_i) if oid.is_a?(String)
+    end
+
+    def to_ber
+      to_ber_oid
+    end
+
+    def to_ber_oid
+      @value.to_ber_oid
+    end
+
+    def to_s
+      @value.join('.')
+    end
+
+    def to_arr
+      @value.dup
+    end
+  end
+end

data/lib/ber/identified/string.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module BER
+  # Wrapper around a String
+  #
+  # @see BER::Function.parse_ber_object
+  class BerIdentifiedString < String
+    attr_accessor :ber_identifier
+
+    def initialize(args)
+      super
+
+      return unless encoding == Encoding::BINARY
+
+      current_encoding = encoding
+      force_encoding('UTF-8')
+      force_encoding(current_encoding) unless valid_encoding?
+    end
+  end
+end

data/lib/ber/refinements.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'ber/refinements/array'
+require 'ber/refinements/false_class'
+require 'ber/refinements/integer'
+require 'ber/refinements/io'
+require 'ber/refinements/ssl_socket'
+require 'ber/refinements/string'
+require 'ber/refinements/string_io'
+require 'ber/refinements/true_class'

data/lib/ber/refinements/array.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+# Refine Array
+#
+module BER
+  refine ::Array do
+    # 48
+    #
+    def to_ber(id = 0)
+      to_ber_seq_internal(0x30 + id)
+    end
+
+    alias_method :to_ber_sequence, :to_ber
+
+    # 49
+    #
+    def to_ber_set(id = 0)
+      to_ber_seq_internal(0x31 + id)
+    end
+
+    # 96
+    #
+    def to_ber_appsequence(id = 0)
+      to_ber_seq_internal(0x60 + id)
+    end
+
+    # 160
+    #
+    def to_ber_contextspecific(id = 0)
+      to_ber_seq_internal(0xa0 + id)
+    end
+
+    def to_ber_oid
+      ary   = dup
+      first = ary.shift
+      raise BER::Error, 'Invalid OID' unless [0, 1, 2].include?(first)
+
+      first = first * 40 + ary.shift
+      ary.unshift first
+      oid = ary.pack('w*')
+      [6, oid.length].pack('CC') + oid
+    end
+
+    def to_ber_control
+      ary = self[0].is_a?(Array) ? self : [self]
+      ary = ary.collect do |control_sequence|
+        control_sequence.collect(&:to_ber).to_ber_sequence.reject_empty_ber_arrays
+      end
+      ary.to_ber_sequence.reject_empty_ber_arrays
+    end
+
+    private
+
+    def to_ber_seq_internal(code)
+      s = join
+      [code].pack('C') + s.length.to_ber_length_encoding + s
+    end
+  end
+end

data/lib/ber/refinements/false_class.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# Refine FalseClass
+#
+module BER
+  refine ::FalseClass do
+    def to_ber
+      "\001\001\000"
+    end
+  end
+end

data/lib/ber/refinements/integer.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+# Refine Integer
+#
+module BER
+  refine ::Integer do
+    # @return [String]
+    #
+    # @api public
+    def to_ber
+      "\002#{to_ber_internal}"
+    end
+
+    # @return [String]
+    #
+    # @api public
+    def to_ber_enumerated
+      "\012#{to_ber_internal}"
+    end
+
+    def to_ber_length_encoding
+      if self <= 127
+        [self].pack('C')
+      else
+        i = [self].pack('N').sub(/^[\0]+/, ::BER::EMPTY_STRING)
+        [0x80 + i.length].pack('C') + i
+      end
+    end
+
+    # @param tag [Integer]
+    #
+    # @return [String]
+    #
+    # @api private
+    def to_ber_application(tag)
+      [0x40 + tag].pack('C') + to_ber_internal
+    end
+
+    private
+
+    def to_ber_internal
+      size  = 1
+      size += 1 until ((negative? ? ~self : self) >> (size * 8)).zero?
+
+      size += 1 if positive? && (self & (0x80 << (size - 1) * 8)).positive?
+
+      size += 1 if negative? && (self & (0x80 << (size - 1) * 8)).zero?
+
+      result = [size]
+
+      while size.positive?
+        result << ((self >> ((size - 1) * 8)) & 0xff)
+        size -= 1
+      end
+
+      result.pack('C*')
+    end
+  end
+end

data/lib/ber/refinements/io.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# Refine IO
+#
+module BER
+  refine ::IO do
+    def read_ber(syntax = ::BER::ASN_SYNTAX)
+      ::BER.function.read_ber(self, syntax)
+    end
+
+    def read_ber_length
+      ::BER.function.read_ber_length(self)
+    end
+
+    def parse_ber_object(syntax, id, data)
+      ::BER.function.parse_ber_object(self, syntax, id, data)
+    end
+  end
+end

data/lib/ber/refinements/ssl_socket.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# Refine ::OpenSSL::SSL::SSLSocket
+#
+module BER
+  if defined? ::OpenSSL
+    refine ::OpenSSL::SSL::SSLSocket do
+      def read_ber(syntax = ::BER::ASN_SYNTAX)
+        ::BER.function.read_ber(self, syntax)
+      end
+
+      def read_ber_length
+        ::BER.function.read_ber_length(self)
+      end
+
+      def parse_ber_object(syntax, id, data)
+        ::BER.function.parse_ber_object(self, syntax, id, data)
+      end
+    end
+  end
+end

data/lib/ber/refinements/string.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'stringio'
+
+# Refine String
+#
+module BER
+  refine ::String do
+    def read_ber(syntax = ::BER::ASN_SYNTAX)
+      ::StringIO.new(self).read_ber(syntax)
+    end
+
+    def read_ber!(syntax = ::BER::ASN_SYNTAX)
+      io     = ::StringIO.new(self)
+      result = io.read_ber(syntax)
+      slice!(0...io.pos)
+      result
+    end
+
+    def read_ber_length
+      ::BER.function.read_ber_length(self)
+    end
+
+    def parse_ber_object(syntax, id, data)
+      ::BER.function.parse_ber_object(self, syntax, id, data)
+    end
+
+    # @param code [String] (0x04)
+    #
+    # @return [String]
+    #
+    # @api public
+    def to_ber(code = 0x04)
+      raw_string = ascii_encoded
+      [code].pack('C') + raw_string.length.to_ber_length_encoding + raw_string
+    end
+
+    # @param code [String] (0x04)
+    #
+    # @return [String]
+    #
+    # @api public
+    def to_ber_bin(code = 0x04)
+      [code].pack('C') + length.to_ber_length_encoding + self
+    end
+
+    # @param code [String]
+    #
+    # @return [String]
+    #
+    # @api public
+    def to_ber_application_string(code)
+      to_ber(0x40 + code)
+    end
+
+    def to_ber_contextspecific(code)
+      to_ber(0x80 + code)
+    end
+
+    def reject_empty_ber_arrays
+      gsub(/0\000/n, ::BER::EMPTY_STRING)
+    end
+
+    private
+
+    def ascii_encoded
+      encode('UTF-8').force_encoding('ASCII-8BIT')
+    rescue Encoding::UndefinedConversionError,
+           Encoding::ConverterNotFoundError,
+           Encoding::InvalidByteSequenceError
+      self
+    end
+  end
+end