ldap-ber 0.1.0

data/lib/ber/refinements/string_io.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# Refine StringIO
+#
+module BER
+  refine ::StringIO do
+    def read_ber(syntax = ::BER::ASN_SYNTAX)
+      ::BER.function.read_ber(self, syntax)
+    end
+
+    # alias read read_ber # overwrite default Socket method for compatibility with Connection
+    # # alias read_nonblock read_ber # overwrite default Socket method for compatibility with Connection
+
+    # def read_nonblock(*args)
+    #   binding.pry
+    #   read(*args)
+    # 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/true_class.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# Refine TrueClass
+#
+module BER
+  refine ::TrueClass do
+    # @return [String]
+    #
+    # @api public
+    def to_ber
+      (+"\001\001\xFF").force_encoding('ASCII-8BIT').freeze
+    end
+  end
+end

data/lib/ber/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module BER
+  VERSION = '0.1.0'
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'bundler'
+Bundler.setup
+
+require 'simplecov'
+SimpleCov.start do
+  add_filter '/spec/'
+end
+
+begin
+  require 'pry-byebug'
+rescue LoadError
+end
+
+require 'ber'
+
+require 'pathname'
+SPEC_ROOT = Pathname(__FILE__).dirname

data/spec/unit/ber_spec.rb

@@ -0,0 +1,50 @@
+RSpec.describe BER do
+  describe 'hash mapping' do
+    it '#config' do
+      expect(BER.config).to be_kind_of(Hash)
+      expect(BER.config[:response]).to have_key(25)
+      expect(BER.config[:result]).to have_key(0)
+      expect(BER.config[:result]).to_not have_key(22)
+    end
+
+    it '#lookup' do
+      expect(BER.fetch(:response, 25)).to eql(:intermediate_response)
+      expect(BER.fetch(:result, 0)).to eql(:success)
+    end
+
+    it '#reverse_lookup' do
+      expect(BER.fetch(:response, :intermediate_response)).to eql(25)
+      expect(BER.fetch(:result, :success)).to eql(0)
+    end
+  end
+
+  describe 'syntax compilation' do
+    let(:syntax) do
+      {
+        application: {
+          constructed: {
+            0 => :array,        # LDAP BindRequest
+            3 => :array         # LDAP SearchRequest
+          },
+          primitive: {
+            2 => :string,       # ldapsearch sends this to unbind
+          }
+        },
+        context_specific: {
+          primitive: {
+            0 => :string,       # simple auth (password)
+            7 => :string        # present filter
+          },
+          constructed: {
+            3 => :array         # equality filter
+          }
+        }
+      }
+    end
+
+    it '#compile_syntax' do
+      expect(BER.compile_syntax({}).size).to eql(256)
+      expect(BER.compile_syntax(syntax).compact).to eql(%i[string array array string string array])
+    end
+  end
+end

data/spec/unit/identified/identified_string_spec.rb

@@ -0,0 +1,46 @@
+RSpec.describe 'BerIdentifiedString' do
+  using ::BER
+
+  context 'UTF8' do
+    let(:bis) { BER::BerIdentifiedString.new(data) }
+
+    describe 'with ascii data' do
+      let(:data) { 'some text'.force_encoding('UTF-8') }
+
+      it do
+        expect(bis.valid_encoding?).to be(true)
+        expect(bis.encoding.name).to eql('UTF-8')
+      end
+    end
+
+    describe 'with umlaut data' do
+      let(:data) { 'Müller'.force_encoding('UTF-8') }
+
+      it do
+        expect(bis.valid_encoding?).to be(true)
+        expect(bis.encoding.name).to eql('UTF-8')
+      end
+    end
+
+    describe 'with utf8 data' do
+      let(:data) { ['e4b8ad'].pack('H*').force_encoding('UTF-8') }
+
+      it do
+        expect(bis.valid_encoding?).to be(true)
+        expect(bis.encoding.name).to eql('UTF-8')
+      end
+    end
+  end
+
+  context 'BINARY' do
+    it do
+      data = ['6a31b4a12aa27a41aca9603f27dd5116'].pack('H*').force_encoding('ASCII-8BIT')
+      bis  = BER::BerIdentifiedString.new(data)
+
+      expect(data.encoding.name).to eql('ASCII-8BIT')
+
+      expect(bis.valid_encoding?).to be(true)
+      expect(bis.encoding.name).to eql('ASCII-8BIT')
+    end
+  end
+end

data/spec/unit/refinements/array_spec.rb

@@ -0,0 +1,32 @@
+RSpec.describe Array, 'refined using ::BER' do
+  using ::BER
+
+  describe 'read_ber' do
+    it 'empty array' do
+      expect([].to_ber.read_ber).to eql([])
+    end
+
+    it 'array' do
+      expect([1, 2, 3].map { |i| i.to_ber }.to_ber.read_ber).to eql([1, 2, 3])
+    end
+  end
+
+  describe 'to_ber_control' do
+    it 'control code array' do
+      control_codes = []
+      control_codes << ['1.2.3'.to_ber, true.to_ber].to_ber_sequence
+      control_codes << ['1.7.9'.to_ber, false.to_ber].to_ber_sequence
+      control_codes = control_codes.to_ber_sequence
+
+      expect(control_codes).to eql([['1.2.3', true], ['1.7.9', false]].to_ber_control)
+    end
+
+    it 'wrap array if not nested' do
+      expect(['1.2.3', true].to_ber_control).to eql([['1.2.3', true]].to_ber_control)
+    end
+
+    it 'empty string if empty array' do
+      expect([].to_ber_control).to eql('')
+    end
+  end
+end

data/spec/unit/refinements/boolean_spec.rb

@@ -0,0 +1,16 @@
+#
+# http://tools.ietf.org/html/rfc4511#section-5.1
+#
+RSpec.describe 'Boolean', 'refined using ::BER' do
+  using ::BER
+
+  it 'true' do
+    expect(true.to_ber).to eql("\x01\x01\xFF".b)
+    expect("\x01\x01\xFF".read_ber).to be(true)
+  end
+
+  it 'false' do
+    expect(false.to_ber).to eql("\x01\x01\x00".b)
+    expect("\x01\x01\x00".read_ber).to be(false)
+  end
+end

data/spec/unit/refinements/integer_spec.rb

@@ -0,0 +1,73 @@
+RSpec.describe Integer, 'refined using ::BER' do
+  using ::BER
+
+  let(:sample) do
+    {
+      0             => "\x02\x01\x00",
+      1             => "\x02\x01\x01",
+      127           => "\x02\x01\x7F",
+      128           => "\x02\x02\x00\x80",
+      255           => "\x02\x02\x00\xFF",
+      256           => "\x02\x02\x01\x00",
+      65_535        => "\x02\x03\x00\xFF\xFF",
+      65_536        => "\x02\x03\x01\x00\x00",
+      8_388_607     => "\x02\x03\x7F\xFF\xFF",
+      8_388_608     => "\x02\x04\x00\x80\x00\x00",
+      16_777_215    => "\x02\x04\x00\xFF\xFF\xFF",
+      0x01000000    => "\x02\x04\x01\x00\x00\x00",
+      0x3FFFFFFF    => "\x02\x04\x3F\xFF\xFF\xFF",
+      0x4FFFFFFF    => "\x02\x04\x4F\xFF\xFF\xFF",
+
+      5             => "\x02\x01\x05",
+      500           => "\x02\x02\x01\xf4",
+      50_000        => "\x02\x03\x00\xC3\x50",
+      5_000_000_000 => "\x02\x05\x01\x2a\x05\xF2\x00",
+
+      -1            => "\x02\x01\xFF",
+      -127          => "\x02\x01\x81",
+      -128          => "\x02\x01\x80",
+      -255          => "\x02\x02\xFF\x01",
+      -256          => "\x02\x02\xFF\x00",
+      -65_535       => "\x02\x03\xFF\x00\x01",
+      -65_536       => "\x02\x03\xFF\x00\x00",
+      -65_537       => "\x02\x03\xFE\xFF\xFF",
+      -8_388_607    => "\x02\x03\x80\x00\x01",
+      -8_388_608    => "\x02\x03\x80\x00\x00",
+      -16_777_215   => "\x02\x04\xFF\x00\x00\x01"
+    }
+  end
+
+
+  it 'ASN_SYNTAX' do
+    expect("\002\001\006".read_ber(BER::ASN_SYNTAX)).to eql(6)
+    expect("\002\001\006".read_ber).to eql(6)
+  end
+
+  it '#to_ber' do
+    sample.each do |int, encoded_int|
+      expect(int.to_ber).to eql(encoded_int.b)
+    end
+  end
+
+  it '#read_ber' do
+    sample.each do |int, encoded_int|
+      expect(encoded_int.b.read_ber).to eql(int)
+    end
+  end
+
+  describe 'round trip' do
+    it 'powers of two' do
+      100.times do |i|
+        n = 2 << i
+        expect(n.to_ber.read_ber).to eql(n)
+      end
+    end
+
+    it 'powers of ten' do
+      100.times do |i|
+        n = 5 * 10**i
+        expect(n.to_ber.read_ber).to eql(n)
+      end
+    end
+  end
+end

data/spec/unit/refinements/string_spec.rb

@@ -0,0 +1,33 @@
+RSpec.describe String, 'refined using ::BER' do
+  using ::BER
+
+  describe 'ASN_SYNTAX' do
+    it 'decode string' do
+      expect("\004\007testing".read_ber).to eql('testing')
+      # expect("\004\007testing".read_ber(BER::ASN_SYNTAX)).to eql('testing')
+    end
+  end
+
+  describe 'utf8' do
+    it 'encode utf8 strings' do
+      expect("\u00e5".force_encoding('UTF-8').to_ber).to eql("\x04\x02\xC3\xA5".b)
+    end
+
+    it 'utf8 encodable strings' do
+      expect('teststring'.encode('US-ASCII').to_ber).to eql("\x04\nteststring")
+    end
+
+    it 'non utf8 encodable strings' do
+      expect("\x81".to_ber).to eql("\x04\x01\x81".b)
+    end
+  end
+
+  # This is used for searching for GUIDs in Active Directory
+  describe 'binary' do
+    it 'encode data' do
+      expect(['6a31b4a12aa27a41aca9603f27dd5116'].pack('H*').to_ber_bin).to eql(
+        "\x04\x10" + "j1\xB4\xA1*\xA2zA\xAC\xA9`?'\xDDQ\x16".b
+      )
+    end
+  end
+end

data/spec/unit/request_spec.rb

@@ -0,0 +1,38 @@
+RSpec.describe 'LDAP Requests' do
+  using ::BER
+
+  describe 'consumed' do
+    let(:bind_request) do
+      "0$\002\001\001`\037\002\001\003\004\rAdministrator\200\vad_is_bogus"
+    end
+
+    it 'decode bind request' do
+      expect(bind_request.read_ber(BER::ASN_SYNTAX)).to eql([1, [3, 'Administrator', 'ad_is_bogus']])
+    end
+
+    xit 'exception does not modify string' do
+      duplicate = bind_request.dup
+
+      expect_any_instance_of(StringIO).to receive(:read_ber).and_raise(BER::Error)
+
+      expect { duplicate.read_ber!(BER::ASN_SYNTAX) }.to raise_error(BER::Error)
+
+      expect(bind_request).to eql(duplicate)
+    end
+  end
+
+  describe 'ASN_SYNTAX' do
+    let(:bind_request) do
+      "0$\002\001\001`\037\002\001\003\004\rAdministrator\200\vad_is_bogus UNCONSUMED".b
+    end
+
+    it 'parse ber' do
+      expect(bind_request.read_ber!(BER::ASN_SYNTAX)).to eql([1, [3, 'Administrator', 'ad_is_bogus']])
+    end
+
+    it 'unconsumed message' do
+      bind_request.read_ber!(BER::ASN_SYNTAX)
+      expect(bind_request).to eql(' UNCONSUMED')
+    end
+  end
+end

metadata

@@ -0,0 +1,159 @@
+--- !ruby/object:Gem::Specification
+name: ldap-ber
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Peter Hamilton
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-02-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dry-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: dry-initializer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+description: Refactored from Net:LDAP gem.
+email:
+- pete@peterdavidhamilton.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".rubocop_todo.yml"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- ldap-ber.gemspec
+- lib/ber.rb
+- lib/ber.yaml
+- lib/ber/function.rb
+- lib/ber/identified.rb
+- lib/ber/identified/array.rb
+- lib/ber/identified/null.rb
+- lib/ber/identified/oid.rb
+- lib/ber/identified/string.rb
+- lib/ber/refinements.rb
+- lib/ber/refinements/array.rb
+- lib/ber/refinements/false_class.rb
+- lib/ber/refinements/integer.rb
+- lib/ber/refinements/io.rb
+- lib/ber/refinements/ssl_socket.rb
+- lib/ber/refinements/string.rb
+- lib/ber/refinements/string_io.rb
+- lib/ber/refinements/true_class.rb
+- lib/ber/version.rb
+- spec/spec_helper.rb
+- spec/unit/ber_spec.rb
+- spec/unit/identified/identified_string_spec.rb
+- spec/unit/refinements/array_spec.rb
+- spec/unit/refinements/boolean_spec.rb
+- spec/unit/refinements/integer_spec.rb
+- spec/unit/refinements/string_spec.rb
+- spec/unit/request_spec.rb
+homepage: https://gitlab.com/peterdavidhamilton/ldap-ber
+licenses:
+- MIT
+metadata:
+  yard.run: yri
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key: 
+specification_version: 4
+summary: 'LDAP Basic Encoding Rules: used by rom-ldap'
+test_files:
+- spec/spec_helper.rb
+- spec/unit/ber_spec.rb
+- spec/unit/identified/identified_string_spec.rb
+- spec/unit/refinements/array_spec.rb
+- spec/unit/refinements/boolean_spec.rb
+- spec/unit/refinements/integer_spec.rb
+- spec/unit/refinements/string_spec.rb
+- spec/unit/request_spec.rb