mongo 2.11.6 → 2.12.0.rc0

data/spec/mongo/crypt/auto_encryption_context_spec.rb

@@ -0,0 +1,107 @@
+require 'mongo'
+require 'lite_spec_helper'
+
+describe Mongo::Crypt::AutoEncryptionContext do
+  require_libmongocrypt
+  include_context 'define shared FLE helpers'
+
+  let(:mongocrypt) { Mongo::Crypt::Handle.new(kms_providers, logger: logger) }
+  let(:context) { described_class.new(mongocrypt, io, db_name, command) }
+
+  let(:logger) { nil }
+
+  let(:io) { double("Mongo::ClientEncryption::IO") }
+  let(:db_name) { 'admin' }
+  let(:command) do
+    {
+      "find": "test",
+      "filter": {
+          "ssn": "457-55-5462"
+      }
+    }
+  end
+
+  describe '#initialize' do
+    shared_examples 'a functioning AutoEncryptionContext' do
+      context 'with valid command' do
+        it 'initializes context' do
+          expect do
+            context
+          end.not_to raise_error
+        end
+      end
+
+      context 'with invalid command' do
+        let(:command) do
+          {
+            incorrect_key: 'value'
+          }
+        end
+
+        it 'raises an exception' do
+          expect do
+            context
+          end.to raise_error(/command not supported for auto encryption: incorrect_key/)
+        end
+      end
+
+      context 'with nil command' do
+        let(:command) { nil }
+
+        it 'raises an exception' do
+          expect do
+            context
+          end.to raise_error(Mongo::Error::CryptError, /Attempted to pass nil data to libmongocrypt/)
+        end
+      end
+
+      context 'with non-document command' do
+      let(:command) { 'command-to-encrypt' }
+
+        it 'raises an exception' do
+          expect do
+            context
+          end.to raise_error(Mongo::Error::CryptError, /Attempted to pass invalid data to libmongocrypt/)
+        end
+      end
+    end
+
+    context 'with local KMS providers' do
+      include_context 'with local kms_providers'
+      it_behaves_like 'a functioning AutoEncryptionContext'
+    end
+
+    context 'with AWS KMS providers' do
+      include_context 'with AWS kms_providers'
+      it_behaves_like 'a functioning AutoEncryptionContext'
+    end
+
+    context 'with verbose logging' do
+      include_context 'with local kms_providers'
+
+      before(:all) do
+        # Logging from libmongocrypt requires the C library to be built with the -DENABLE_TRACE=ON
+        # option; none of the pre-built packages on Evergreen have been built with logging enabled.
+        #
+        # It is still useful to be able to run these tests locally to confirm that logging is working
+        # while debugging any problems.
+        #
+        # For now, skip this test by default and revisit once we have determined how we want to
+        # package libmongocrypt with the Ruby driver (see: https://jira.mongodb.org/browse/RUBY-1966)
+        skip "These tests require libmongocrypt to be built with the '-DENABLE_TRACE=ON' cmake option." +
+          " They also require the MONGOCRYPT_TRACE environment variable to be set to 'ON'."
+      end
+
+      let(:logger) do
+        ::Logger.new($stdout).tap do |logger|
+          logger.level = ::Logger::DEBUG
+        end
+      end
+
+      it 'receives log messages from libmongocrypt' do
+        expect(logger).to receive(:debug).with(/mongocrypt_ctx_encrypt_init/)
+        context
+      end
+    end
+  end
+end

data/spec/mongo/crypt/binary_spec.rb

@@ -0,0 +1,115 @@
+require 'mongo'
+require 'support/lite_constraints'
+
+RSpec.configure do |config|
+  config.extend(LiteConstraints)
+end
+
+describe Mongo::Crypt::Binary do
+  require_libmongocrypt
+
+  let(:data) { 'I love Ruby' }
+  let(:binary) { described_class.from_data(data) }
+
+  describe '#initialize' do
+    context 'with nil data' do
+      let(:binary) { described_class.new }
+
+      it 'creates a new Mongo::Crypt::Binary object' do
+        expect do
+          binary
+        end.not_to raise_error
+      end
+    end
+
+    context 'with valid data' do
+      let(:binary) { described_class.new(data: data) }
+
+      it 'creates a new Mongo::Crypt::Binary object' do
+        expect do
+          binary
+        end.not_to raise_error
+      end
+    end
+
+    context 'with pointer' do
+      let(:pointer) { Mongo::Crypt::Binding.mongocrypt_binary_new }
+      let(:binary) { described_class.new(pointer: pointer) }
+
+      after do
+        Mongo::Crypt::Binding.mongocrypt_binary_destroy(pointer)
+      end
+
+      it 'creates a new Mongo::Crypt::Binary object from pointer' do
+        expect do
+          binary
+        end.not_to raise_error
+
+        expect(binary.ref).to eq(pointer)
+      end
+    end
+  end
+
+  describe '#self.from_data' do
+    let(:binary) { described_class.from_data(data) }
+
+    it 'creates a new Mongo::Crypt::Binary object' do
+      expect do
+        binary
+      end.not_to raise_error
+    end
+  end
+
+  describe '#self.from_pointer' do
+    let(:pointer) { Mongo::Crypt::Binding.mongocrypt_binary_new }
+    let(:binary) { described_class.from_pointer(pointer) }
+
+    after do
+      Mongo::Crypt::Binding.mongocrypt_binary_destroy(pointer)
+    end
+
+    it 'creates a new Mongo::Crypt::Binary object from pointer' do
+      expect do
+        binary
+      end.not_to raise_error
+
+      expect(binary.ref).to eq(pointer)
+    end
+  end
+
+  describe '#to_s' do
+    it 'returns the original string' do
+      expect(binary.to_s).to eq(data)
+    end
+  end
+
+  describe '#write' do
+    # Binary must have enough space pre-allocated
+    let(:binary) { described_class.from_data("\00" * data.length) }
+
+    it 'writes data to the binary object' do
+      expect(binary.write(data)).to be true
+      expect(binary.to_s).to eq(data)
+    end
+
+    context 'with no space allocated' do
+      let(:binary) { described_class.new }
+
+      it 'returns false' do
+        expect do
+          binary.write(data)
+        end.to raise_error(ArgumentError, /Cannot write #{data.length} bytes of data to a Binary object that was initialized with 0 bytes/)
+      end
+    end
+
+    context 'without enough space allocated' do
+      let(:binary) { described_class.from_data("\00" * (data.length - 1)) }
+
+      it 'returns false' do
+        expect do
+          binary.write(data)
+        end.to raise_error(ArgumentError, /Cannot write #{data.length} bytes of data to a Binary object that was initialized with #{data.length - 1} bytes/)
+      end
+    end
+  end
+end

data/spec/mongo/crypt/binding/binary_spec.rb

@@ -0,0 +1,56 @@
+require 'mongo'
+require 'support/lite_constraints'
+
+RSpec.configure do |config|
+  config.extend(LiteConstraints)
+end
+
+describe 'Mongo::Crypt::Binding' do
+  describe 'binary_t bindings' do
+    require_libmongocrypt
+
+    let(:bytes) { [104, 101, 108, 108, 111] }
+
+    let(:bytes_pointer) do
+      # FFI::MemoryPointer automatically frees memory when it goes out of scope
+      p = FFI::MemoryPointer.new(bytes.size)
+      p.write_array_of_type(FFI::TYPE_UINT8, :put_uint8, bytes)
+    end
+
+    after do
+      Mongo::Crypt::Binding.mongocrypt_binary_destroy(binary)
+    end
+
+    describe '#mongocrypt_binary_new' do
+      let(:binary) { Mongo::Crypt::Binding.mongocrypt_binary_new }
+
+      it 'returns a pointer' do
+        expect(binary).to be_a_kind_of(FFI::Pointer)
+      end
+    end
+
+    describe '#mongocrypt_binary_new_from_data' do
+      let(:binary) { Mongo::Crypt::Binding.mongocrypt_binary_new_from_data(bytes_pointer, bytes.length) }
+
+      it 'returns a pointer' do
+        expect(binary).to be_a_kind_of(FFI::Pointer)
+      end
+    end
+
+    describe '#mongocrypt_binary_data' do
+      let(:binary) { Mongo::Crypt::Binding.mongocrypt_binary_new_from_data(bytes_pointer, bytes.length) }
+
+      it 'returns the pointer to the data' do
+        expect(Mongo::Crypt::Binding.mongocrypt_binary_data(binary)).to eq(bytes_pointer)
+      end
+    end
+
+    describe '#mongocrypt_binary_len' do
+      let(:binary) { Mongo::Crypt::Binding.mongocrypt_binary_new_from_data(bytes_pointer, bytes.length) }
+
+      it 'returns the length of the data' do
+        expect(Mongo::Crypt::Binding.mongocrypt_binary_len(binary)).to eq(bytes.length)
+      end
+    end
+  end
+end

data/spec/mongo/crypt/binding/context_spec.rb

@@ -0,0 +1,257 @@
+require 'mongo'
+require 'support/lite_constraints'
+require 'mongo/crypt/helpers/mongo_crypt_spec_helper'
+
+RSpec.configure do |config|
+  config.extend(LiteConstraints)
+end
+
+shared_context 'initialized for data key creation' do
+  let(:master_key) { "ru\xfe\x00" * 24 }
+  let(:binary) { MongoCryptSpecHelper.mongocrypt_binary_t_from(master_key)}
+
+  before do
+    Mongo::Crypt::Binding.mongocrypt_setopt_kms_provider_local(mongocrypt, binary)
+    MongoCryptSpecHelper.bind_crypto_hooks(mongocrypt)
+    Mongo::Crypt::Binding.mongocrypt_init(mongocrypt)
+
+    Mongo::Crypt::Binding.mongocrypt_ctx_setopt_masterkey_local(context)
+  end
+
+  after do
+    Mongo::Crypt::Binding.mongocrypt_binary_destroy(binary)
+  end
+end
+
+shared_context 'initialized for explicit encryption' do
+  # TODO: replace with code showing how to generate this value
+  let(:key_id) { "\xDEd\x00\xDC\x0E\xF8J\x99\x97\xFA\xCC\x04\xBF\xAA\x00\xF5" }
+  let(:key_id_binary) { MongoCryptSpecHelper.mongocrypt_binary_t_from(key_id) }
+
+  let(:value) do
+    { 'v': 'Hello, world!' }.to_bson.to_s
+  end
+
+  let(:value_binary) { MongoCryptSpecHelper.mongocrypt_binary_t_from(value) }
+
+  before do
+    MongoCryptSpecHelper.bind_crypto_hooks(mongocrypt)
+    Mongo::Crypt::Binding.mongocrypt_init(mongocrypt)
+
+    Mongo::Crypt::Binding.mongocrypt_ctx_setopt_key_id(context, key_id_binary)
+    Mongo::Crypt::Binding.mongocrypt_ctx_setopt_algorithm(
+      context,
+      'AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic',
+      -1
+    )
+  end
+
+  after do
+    Mongo::Crypt::Binding.mongocrypt_binary_destroy(key_id_binary)
+    Mongo::Crypt::Binding.mongocrypt_binary_destroy(value_binary)
+  end
+end
+
+describe 'Mongo::Crypt::Binding' do
+  describe 'mongocrypt_ctx_t bindings' do
+    require_libmongocrypt
+    fails_on_jruby
+
+    let(:mongocrypt) { Mongo::Crypt::Binding.mongocrypt_new }
+    let(:context) { Mongo::Crypt::Binding.mongocrypt_ctx_new(mongocrypt) }
+
+    after do
+      Mongo::Crypt::Binding.mongocrypt_destroy(mongocrypt)
+      Mongo::Crypt::Binding.mongocrypt_ctx_destroy(context)
+    end
+
+    describe '#mongocrypt_ctx_new' do
+      it 'returns a pointer' do
+        expect(context).to be_a_kind_of(FFI::Pointer)
+      end
+    end
+
+    describe '#mongocrypt_ctx_status' do
+      let(:status) { Mongo::Crypt::Binding.mongocrypt_status_new }
+
+      after do
+        Mongo::Crypt::Binding.mongocrypt_status_destroy(status)
+      end
+
+      context 'for a new mongocrypt_ctx_t object' do
+        it 'returns an ok status' do
+          Mongo::Crypt::Binding.mongocrypt_ctx_status(context, status)
+          expect(Mongo::Crypt::Binding.mongocrypt_status_type(status)).to eq(:ok)
+        end
+      end
+    end
+
+    describe '#mongocrypt_ctx_setopt_masterkey_local' do
+      let(:result) do
+        Mongo::Crypt::Binding.mongocrypt_ctx_setopt_masterkey_local(context)
+      end
+
+      before do
+        Mongo::Crypt::Binding.mongocrypt_init(mongocrypt)
+      end
+
+      it 'returns true' do
+        expect(result).to be true
+      end
+    end
+
+    describe '#mongocrypt_ctx_datakey_init' do
+      let(:result) do
+        Mongo::Crypt::Binding.mongocrypt_ctx_datakey_init(context)
+      end
+
+      context 'a master key option and KMS provider have been set' do
+        include_context 'initialized for data key creation'
+
+        it 'returns true' do
+          expect(result).to be true
+        end
+      end
+    end
+
+    describe '#mongocrypt_ctx_setopt_key_id' do
+      let(:binary) { MongoCryptSpecHelper.mongocrypt_binary_t_from(uuid) }
+
+      let(:result) do
+        Mongo::Crypt::Binding.mongocrypt_ctx_setopt_key_id(context, binary)
+      end
+
+      before do
+        Mongo::Crypt::Binding.mongocrypt_init(mongocrypt)
+      end
+
+      after do
+        Mongo::Crypt::Binding.mongocrypt_binary_destroy(binary)
+      end
+
+      context 'with valid key id' do
+        # 16-byte binary uuid string
+        # TODO: replace with code showing how to generate this value
+        let(:uuid) { "\xDEd\x00\xDC\x0E\xF8J\x99\x97\xFA\xCC\x04\xBF\xAA\x00\xF5" }
+
+        it 'returns true' do
+          expect(result).to be true
+        end
+      end
+
+      context 'with invalid key id' do
+        # invalid uuid string -- a truncated string of bytes
+        let(:uuid) { "\xDEd\x00\xDC\x0E\xF8J\x99\x97\xFA\xCC\x04\xBF" }
+
+        it 'returns false' do
+          expect(result).to be false
+        end
+      end
+    end
+
+    describe '#mongocrypt_ctx_setopt_algorithm' do
+      let(:result) do
+        Mongo::Crypt::Binding.mongocrypt_ctx_setopt_algorithm(
+          context,
+          algo,
+          -1
+        )
+      end
+
+      before do
+        Mongo::Crypt::Binding.mongocrypt_init(mongocrypt)
+      end
+
+      context 'with deterministic algorithm' do
+        let(:algo) { 'AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic' }
+
+        it 'returns true' do
+          expect(result).to be true
+        end
+      end
+
+      context 'with random algorithm' do
+        let(:algo) { 'AEAD_AES_256_CBC_HMAC_SHA_512-Random' }
+
+        it 'returns true' do
+          expect(result).to be true
+        end
+      end
+
+      context 'with invalid algorithm' do
+        let(:algo) { 'fake-algorithm' }
+
+        it 'returns false' do
+          expect(result).to be false
+        end
+      end
+
+      context 'with nil algorithm' do
+        let(:algo) { nil }
+
+        it 'returns false' do
+          expect(result).to be false
+        end
+      end
+    end
+
+    describe '#mongocrypt_ctx_explicit_encrypt_init' do
+      let(:result) do
+        Mongo::Crypt::Binding.mongocrypt_ctx_explicit_encrypt_init(context, value_binary)
+      end
+
+      context 'a key_id and algorithm have been set' do
+        include_context 'initialized for explicit encryption'
+
+        it 'returns true' do
+          expect(result).to be true
+        end
+      end
+    end
+
+    describe '#mongocrypt_ctx_mongo_op' do
+      context 'ctx is initialized for explicit encryption' do
+        include_context 'initialized for explicit encryption'
+
+        before do
+          Mongo::Crypt::Binding.mongocrypt_ctx_explicit_encrypt_init(context, value_binary)
+        end
+
+        let(:out_binary) { Mongo::Crypt::Binding.mongocrypt_binary_new }
+        let(:result) { Mongo::Crypt::Binding.mongocrypt_ctx_mongo_op(context, out_binary) }
+
+        after do
+          Mongo::Crypt::Binding.mongocrypt_binary_destroy(out_binary)
+        end
+
+        it 'returns a BSON document' do
+          expect(result).to be true
+
+          data = Mongo::Crypt::Binding.mongocrypt_binary_data(out_binary)
+          len = Mongo::Crypt::Binding.mongocrypt_binary_len(out_binary)
+
+          response = data.get_array_of_uint8(0, len).pack('C*')
+          expect(response).to be_a_kind_of(String)
+        end
+      end
+    end
+
+    describe '#mongocrypt_ctx_state' do
+      let(:result) do
+        Mongo::Crypt::Binding.mongocrypt_ctx_state(context)
+      end
+
+      context 'the mongocrypt_ctx has been properly initialized' do
+        include_context 'initialized for data key creation'
+
+        before do
+          Mongo::Crypt::Binding.mongocrypt_ctx_datakey_init(context)
+        end
+
+        it 'returns ready state' do
+          expect(result).to eq(:ready)
+        end
+      end
+    end
+  end
+end