ruby_smb 1.0.5 → 2.0.3

data/spec/lib/ruby_smb/smb2/bit_field/session_flags_spec.rb

@@ -5,6 +5,7 @@ RSpec.describe RubySMB::SMB2::BitField::SessionFlags do
 
   it { is_expected.to respond_to :guest }
   it { is_expected.to respond_to :null }
+  it { is_expected.to respond_to :encrypt_data }
 
   it 'is little endian' do
     expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
@@ -25,4 +26,12 @@ RSpec.describe RubySMB::SMB2::BitField::SessionFlags do
 
     it_behaves_like 'bit field with one flag set', :null, 'v', 0x00000002
   end
+
+  describe '#encrypt_data' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.encrypt_data).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :encrypt_data, 'v', 0x00000004
+  end
 end

data/spec/lib/ruby_smb/smb2/bit_field/share_flags_spec.rb

@@ -1,6 +1,8 @@
 RSpec.describe RubySMB::SMB2::BitField::ShareFlags do
   subject(:flags) { described_class.new }
 
+  it { is_expected.to respond_to :vdo_caching }
+  it { is_expected.to respond_to :auto_caching }
   it { is_expected.to respond_to :dfs_root }
   it { is_expected.to respond_to :dfs }
   it { is_expected.to respond_to :encrypt }
@@ -11,11 +13,28 @@ RSpec.describe RubySMB::SMB2::BitField::ShareFlags do
   it { is_expected.to respond_to :namespace_caching }
   it { is_expected.to respond_to :shared_delete }
   it { is_expected.to respond_to :restrict_exclusive_opens }
+  it { is_expected.to respond_to :identity_remoting }
 
   it 'is little endian' do
     expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
   end
 
+  describe '#vdo_caching' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.vdo_caching).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :vdo_caching, 'V', 0x00000020
+  end
+
+  describe '#auto_caching' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.auto_caching).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :auto_caching, 'V', 0x00000010
+  end
+
   describe '#dfs' do
     it 'should be a 1-bit field per the SMB spec' do
       expect(flags.dfs).to be_a BinData::Bit1
@@ -96,6 +115,14 @@ RSpec.describe RubySMB::SMB2::BitField::ShareFlags do
     it_behaves_like 'bit field with one flag set', :encrypt, 'V', 0x00008000
   end
 
+  describe '#identity_remoting' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.identity_remoting).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :identity_remoting, 'V', 0x00040000
+  end
+
   describe '#set_manual_caching' do
     it 'turns off the caching bits' do
       flags.set_manual_caching

data/spec/lib/ruby_smb/smb2/file_spec.rb

@@ -43,6 +43,7 @@ RSpec.describe RubySMB::SMB2::File do
   it { is_expected.to respond_to :size }
   it { is_expected.to respond_to :size_on_disk }
   it { is_expected.to respond_to :tree }
+  it { is_expected.to respond_to :tree_connect_encrypt_data }
 
   it 'pulls the attributes from the response packet' do
     expect(file.attributes).to eq create_response.file_attributes
@@ -52,10 +53,18 @@ RSpec.describe RubySMB::SMB2::File do
     expect(file.guid).to eq create_response.file_id
   end
 
-  it 'pulls the timestamps from the response packet' do
+  it 'pulls the last access timestamps from the response packet' do
     expect(file.last_access).to eq create_response.last_access.to_datetime
   end
 
+  it 'pulls the last change timestamps from the response packet' do
+    expect(file.last_change).to eq create_response.last_change.to_datetime
+  end
+
+  it 'pulls the last write timestamps from the response packet' do
+    expect(file.last_write).to eq create_response.last_write.to_datetime
+  end
+
   it 'pulls the size from the response packet' do
     expect(file.size).to eq create_response.end_of_file
   end
@@ -64,6 +73,10 @@ RSpec.describe RubySMB::SMB2::File do
     expect(file.size_on_disk).to eq create_response.allocation_size
   end
 
+  it 'sets the tree_connect_encrypt_data flag to false by default' do
+    expect(file.tree_connect_encrypt_data).to be false
+  end
+
   describe '#set_header_fields' do
     let(:request) { RubySMB::SMB2::Packet::ReadRequest.new }
     it 'calls the set_header_field method from the Tree' do
@@ -94,6 +107,10 @@ RSpec.describe RubySMB::SMB2::File do
     it 'sets the offset of the packet' do
       expect(file.read_packet(offset: 55).offset).to eq 55
     end
+
+    it 'sets the credit_charge of the packet' do
+      expect(file.read_packet(credit_charge: 3).smb2_header.credit_charge).to eq 3
+    end
   end
 
   describe '#read' do
@@ -112,12 +129,18 @@ RSpec.describe RubySMB::SMB2::File do
       end
 
       it 'uses a single packet to read the entire file' do
-        expect(file).to receive(:read_packet).with(read_length: 108, offset: 0).and_return(small_read)
-        expect(client).to receive(:send_recv).with(small_read).and_return 'fake data'
+        expect(file).to receive(:read_packet).with(read_length: 108, offset: 0, credit_charge: 0).and_return(small_read)
+        expect(client).to receive(:send_recv).with(small_read, encrypt: false).and_return 'fake data'
         expect(RubySMB::SMB2::Packet::ReadResponse).to receive(:read).with('fake data').and_return(small_response)
         expect(file.read).to eq 'fake data'
       end
 
+      it 'calls Client #send_recv with encryption set if required' do
+        file.tree_connect_encrypt_data = true
+        expect(client).to receive(:send_recv).with(small_read, encrypt: true)
+        file.read
+      end
+
       context 'when the response is not valid' do
         it 'raise an InvalidPacket exception' do
           small_response.smb2_header.command = RubySMB::SMB2::Commands::LOGOFF
@@ -142,22 +165,31 @@ RSpec.describe RubySMB::SMB2::File do
       }
 
       before :example do
+        client.server_supports_multi_credit = 1
         allow(file).to receive(:read_packet)
         allow(client).to receive(:send_recv)
         allow(RubySMB::SMB2::Packet::ReadResponse).to receive(:read).and_return(big_response)
       end
 
-      it 'uses a multiple packet to read the file in chunks' do
-        expect(file).to receive(:read_packet).once.with(read_length: described_class::MAX_PACKET_SIZE, offset: 0).and_return(big_read)
-        expect(file).to receive(:read_packet).once.with(read_length: described_class::MAX_PACKET_SIZE, offset: described_class::MAX_PACKET_SIZE).and_return(big_read)
+      it 'uses multiple packets to read the file in chunks' do
+        expect(file).to receive(:read_packet).once.with(read_length: described_class::MAX_PACKET_SIZE, offset: 0, credit_charge: 1).and_return(big_read)
+        expect(file).to receive(:read_packet).once.with(read_length: described_class::MAX_PACKET_SIZE, offset: described_class::MAX_PACKET_SIZE, credit_charge: 1).and_return(big_read)
         expect(client).to receive(:send_recv).twice.and_return 'fake data'
         expect(RubySMB::SMB2::Packet::ReadResponse).to receive(:read).twice.with('fake data').and_return(big_response)
         file.read(bytes: (described_class::MAX_PACKET_SIZE * 2))
       end
 
+      it 'calls Client #send_recv with encryption set if required' do
+        read_request = double('Read Request')
+        allow(file).to receive(:read_packet).and_return(read_request)
+        file.tree_connect_encrypt_data = true
+        expect(client).to receive(:send_recv).twice.with(read_request, encrypt: true)
+        file.read(bytes: (described_class::MAX_PACKET_SIZE * 2))
+      end
+
       context 'when the second response is not valid' do
         it 'raise an InvalidPacket exception' do
-          allow(file).to receive(:read_packet).with(read_length: described_class::MAX_PACKET_SIZE, offset: described_class::MAX_PACKET_SIZE) do
+          allow(file).to receive(:read_packet).with(read_length: described_class::MAX_PACKET_SIZE, offset: described_class::MAX_PACKET_SIZE, credit_charge: 1) do
             big_response.smb2_header.command = RubySMB::SMB2::Commands::LOGOFF
           end
           expect { file.read(bytes: (described_class::MAX_PACKET_SIZE * 2)) }.to raise_error(RubySMB::Error::InvalidPacket)
@@ -166,12 +198,31 @@ RSpec.describe RubySMB::SMB2::File do
 
       context 'when the second response status code is not STATUS_SUCCESS' do
         it 'raise an UnexpectedStatusCode exception' do
-          allow(file).to receive(:read_packet).with(read_length: described_class::MAX_PACKET_SIZE, offset: described_class::MAX_PACKET_SIZE) do
+          allow(file).to receive(:read_packet).with(read_length: described_class::MAX_PACKET_SIZE, offset: described_class::MAX_PACKET_SIZE, credit_charge: 1) do
             big_response.smb2_header.nt_status = WindowsError::NTStatus::STATUS_INVALID_HANDLE.value
           end
           expect { file.read(bytes: (described_class::MAX_PACKET_SIZE * 2)) }.to raise_error(RubySMB::Error::UnexpectedStatusCode)
         end
       end
+
+      context 'when the server does not support multi credits' do
+        it 'reads 65536 bytes at a time with no credit charge' do
+          client.server_supports_multi_credit = false
+          expect(file).to receive(:read_packet).once.with(read_length: 65536, offset: 0, credit_charge: 0).and_return(big_read)
+          expect(file).to receive(:read_packet).once.with(read_length: 65536, offset: 65536, credit_charge: 0).and_return(big_read)
+          file.read(bytes: (described_class::MAX_PACKET_SIZE * 4))
+        end
+      end
+
+      context 'when the server supports multi credits' do
+        it 'reads a number of bytes equal to #server_max_read_size, with the expected credit charge' do
+          credit_charge = (90000 - 1) / 65536 + 1
+          client.server_max_read_size = 90000
+          expect(file).to receive(:read_packet).once.with(read_length: 90000, offset: 0, credit_charge: credit_charge).and_return(big_read)
+          expect(file).to receive(:read_packet).once.with(read_length: (described_class::MAX_PACKET_SIZE * 4 - 90000), offset: 90000, credit_charge: credit_charge).and_return(big_read)
+          file.read(bytes: (described_class::MAX_PACKET_SIZE * 4))
+        end
+      end
     end
   end
 
@@ -195,6 +246,10 @@ RSpec.describe RubySMB::SMB2::File do
     it 'sets the buffer on the packet' do
       expect(file.write_packet(data:'hello').buffer).to eq 'hello'
     end
+
+    it 'sets the credit_charge on the packet header' do
+      expect(file.write_packet(credit_charge: 5).smb2_header.credit_charge).to eq 5
+    end
   end
 
   describe '#write' do
@@ -204,13 +259,55 @@ RSpec.describe RubySMB::SMB2::File do
         expect(client).to receive(:send_recv).once.and_return(write_response.to_binary_s)
         file.write(data: 'test')
       end
+
+      it 'calls Client #send_recv with encryption set if required' do
+        write_request = double('Write Request')
+        allow(file).to receive(:write_packet).and_return(write_request)
+        file.tree_connect_encrypt_data = true
+        expect(client).to receive(:send_recv).once.with(write_request, encrypt: true).and_return(write_response.to_binary_s)
+        file.write(data: 'test')
+      end
     end
 
     context 'for a large write' do
+      before :example do
+        allow(client).to receive(:send_recv).and_return(write_response.to_binary_s)
+        client.server_supports_multi_credit = 1
+      end
+
       it 'sends multiple packets' do
         expect(client).to receive(:send_recv).twice.and_return(write_response.to_binary_s)
         file.write(data: SecureRandom.random_bytes(described_class::MAX_PACKET_SIZE + 1))
       end
+
+      it 'calls Client #send_recv with encryption set if required' do
+        write_request = double('Write Request')
+        allow(file).to receive(:write_packet).and_return(write_request)
+        file.tree_connect_encrypt_data = true
+        expect(client).to receive(:send_recv).twice.with(write_request, encrypt: true).and_return(write_response.to_binary_s)
+        file.write(data: SecureRandom.random_bytes(described_class::MAX_PACKET_SIZE + 1))
+      end
+
+      context 'when the server does not support multi credits' do
+        it 'writes 65536 bytes at a time with no credit charge' do
+          client.server_supports_multi_credit = false
+          data = SecureRandom.random_bytes(65536 * 2)
+          expect(file).to receive(:write_packet).once.with(data: data[0, 65536], offset: 0, credit_charge: 0)
+          expect(file).to receive(:write_packet).once.with(data: data[65536, (data.size - 65536)], offset: 65536, credit_charge: 0)
+          file.write(data: data)
+        end
+      end
+
+      context 'when the server supports multi credits' do
+        it 'reads a number of bytes equal to #server_max_write_size, with the expected credit charge' do
+          data = SecureRandom.random_bytes(90000 * 2)
+          credit_charge = (90000 - 1) / 65536 + 1
+          client.server_max_write_size = 90000
+          expect(file).to receive(:write_packet).once.with(data: data[0, 90000], offset: 0, credit_charge: credit_charge)
+          expect(file).to receive(:write_packet).once.with(data: data[90000, (data.size - 90000)], offset: 90000, credit_charge: credit_charge)
+          file.write(data: data)
+        end
+      end
     end
 
     it 'raises an InvalidPacket exception if the response is not valid' do
@@ -248,7 +345,7 @@ RSpec.describe RubySMB::SMB2::File do
 
       it 'uses a single packet to delete the entire file' do
         expect(file).to receive(:delete_packet).and_return(small_delete)
-        expect(client).to receive(:send_recv).with(small_delete).and_return 'raw_response'
+        expect(client).to receive(:send_recv).with(small_delete, encrypt: false).and_return 'raw_response'
         expect(RubySMB::SMB2::Packet::SetInfoResponse).to receive(:read).with('raw_response').and_return(small_response)
         expect(file.delete).to eq WindowsError::NTStatus::STATUS_SUCCESS
       end
@@ -260,6 +357,14 @@ RSpec.describe RubySMB::SMB2::File do
         allow(small_response).to receive(:valid?).and_return(false)
         expect { file.delete }.to raise_error(RubySMB::Error::InvalidPacket)
       end
+
+      it 'calls Client #send_recv with encryption set if required' do
+        allow(file).to receive(:delete_packet)
+        allow(RubySMB::SMB2::Packet::SetInfoResponse).to receive(:read).and_return(small_response)
+        file.tree_connect_encrypt_data = true
+        expect(client).to receive(:send_recv).with(small_delete, encrypt: true)
+        file.delete
+      end
     end
   end
 
@@ -291,11 +396,18 @@ RSpec.describe RubySMB::SMB2::File do
 
       it 'uses a single packet to rename the entire file' do
         expect(file).to receive(:rename_packet).and_return(small_rename)
-        expect(client).to receive(:send_recv).with(small_rename).and_return 'raw_response'
+        expect(client).to receive(:send_recv).with(small_rename, encrypt: false).and_return 'raw_response'
         expect(RubySMB::SMB2::Packet::SetInfoResponse).to receive(:read).with('raw_response').and_return(small_response)
         expect(file.rename('new_file.txt')).to eq WindowsError::NTStatus::STATUS_SUCCESS
       end
 
+      it 'calls Client #send_recv with encryption set if required' do
+        allow(RubySMB::SMB2::Packet::SetInfoResponse).to receive(:read).and_return(small_response)
+        file.tree_connect_encrypt_data = true
+        expect(client).to receive(:send_recv).with(small_rename, encrypt: true)
+        file.rename('new_file.txt')
+      end
+
       it 'raises an InvalidPacket exception if the response is not valid' do
         allow(client).to receive(:send_recv)
         allow(RubySMB::SMB2::Packet::SetInfoResponse).to receive(:read).and_return(small_response)
@@ -330,7 +442,13 @@ RSpec.describe RubySMB::SMB2::File do
     end
 
     it 'calls Client #send_recv with the expected request' do
-      expect(client).to receive(:send_recv).with(request)
+      expect(client).to receive(:send_recv).with(request, encrypt: false)
+      file.close
+    end
+
+    it 'calls Client #send_recv with encryption set if required' do
+      file.tree_connect_encrypt_data = true
+      expect(client).to receive(:send_recv).with(request, encrypt: true)
       file.close
     end
 
@@ -394,7 +512,15 @@ RSpec.describe RubySMB::SMB2::File do
     it 'calls Client #send_recv with the expected request' do
       request = double('Request')
       allow(file).to receive(:read_packet).and_return(request)
-      expect(client).to receive(:send_recv).with(request)
+      expect(client).to receive(:send_recv).with(request, encrypt: false)
+      file.send_recv_read
+    end
+
+    it 'calls Client #send_recv with encryption set if required' do
+      request = double('Request')
+      allow(file).to receive(:read_packet).and_return(request)
+      file.tree_connect_encrypt_data = true
+      expect(client).to receive(:send_recv).with(request, encrypt: true)
       file.send_recv_read
     end
 
@@ -408,33 +534,6 @@ RSpec.describe RubySMB::SMB2::File do
       expect { file.send_recv_read }.to raise_error(RubySMB::Error::InvalidPacket)
     end
 
-    context 'when the response status code is STATUS_PENDING' do
-      before :example do
-        allow(file).to receive(:sleep)
-        allow(read_response).to receive(:status_code).and_return(WindowsError::NTStatus::STATUS_PENDING)
-        allow(dispatcher).to receive(:recv_packet).and_return(raw_response)
-      end
-
-      it 'wait 1 second and calls Client dispatcher #recv_packet method one more time' do
-        expect(file).to receive(:sleep).with(1)
-        expect(dispatcher).to receive(:recv_packet)
-        file.send_recv_read
-      end
-
-      it 'parses the response as a SMB2 ReadResponse packet' do
-        expect(RubySMB::SMB2::Packet::ReadResponse).to receive(:read).twice.with(raw_response)
-        file.send_recv_read
-      end
-
-      it 'raises an InvalidPacket exception if the response is not valid' do
-        allow(dispatcher).to receive(:recv_packet) do
-          allow(read_response).to receive(:valid?).and_return(false)
-          raw_response
-        end
-        expect { file.send_recv_read }.to raise_error(RubySMB::Error::InvalidPacket)
-      end
-    end
-
     it 'raises an UnexpectedStatusCode exception if the response status code is not STATUS_SUCCESS' do
       allow(read_response).to receive(:status_code).and_return(WindowsError::NTStatus::STATUS_OBJECT_NAME_NOT_FOUND)
       expect { file.send_recv_read }.to raise_error(RubySMB::Error::UnexpectedStatusCode)
@@ -457,7 +556,7 @@ RSpec.describe RubySMB::SMB2::File do
 
     before :example do
       allow(file).to receive(:write_packet).and_return(request)
-      allow(client).to receive(:send_recv).and_return(raw_response)
+      allow(client).to receive(:send_recv).and_return(raw_response, encrypt: false)
       allow(RubySMB::SMB2::Packet::WriteResponse).to receive(:read).with(raw_response).and_return(write_response)
     end
 
@@ -478,40 +577,19 @@ RSpec.describe RubySMB::SMB2::File do
     end
 
     it 'calls Client #send_recv with the expected request' do
-      expect(client).to receive(:send_recv).with(request)
+      expect(client).to receive(:send_recv).with(request, encrypt: false)
       file.send_recv_write
     end
 
-    it 'parses the response as a SMB1 WriteResponse packet' do
-      expect(RubySMB::SMB2::Packet::WriteResponse).to receive(:read).with(raw_response)
+    it 'calls Client #send_recv with encryption set if required' do
+      file.tree_connect_encrypt_data = true
+      expect(client).to receive(:send_recv).with(request, encrypt: true)
       file.send_recv_write
     end
 
-    context 'when the response status code is STATUS_PENDING' do
-      before :example do
-        allow(file).to receive(:sleep)
-        allow(write_response).to receive(:status_code).and_return(WindowsError::NTStatus::STATUS_PENDING)
-        allow(dispatcher).to receive(:recv_packet).and_return(raw_response)
-      end
-
-      it 'wait 1 second and calls Client dispatcher #recv_packet method one more time' do
-        expect(file).to receive(:sleep).with(1)
-        expect(dispatcher).to receive(:recv_packet)
-        file.send_recv_write
-      end
-
-      it 'parses the response as a SMB2 WriteResponse packet' do
-        expect(RubySMB::SMB2::Packet::WriteResponse).to receive(:read).twice.with(raw_response)
-        file.send_recv_write
-      end
-
-      it 'raises an InvalidPacket exception if the response is not valid' do
-        allow(dispatcher).to receive(:recv_packet) do
-          allow(write_response).to receive(:valid?).and_return(false)
-          raw_response
-        end
-        expect { file.send_recv_write }.to raise_error(RubySMB::Error::InvalidPacket)
-      end
+    it 'parses the response as a SMB1 WriteResponse packet' do
+      expect(RubySMB::SMB2::Packet::WriteResponse).to receive(:read).with(raw_response)
+      file.send_recv_write
     end
 
     it 'raises an InvalidPacket exception if the response is not valid' do

data/spec/lib/ruby_smb/smb2/negotiate_context_spec.rb

@@ -0,0 +1,332 @@
+RSpec.describe RubySMB::SMB2::PreauthIntegrityCapabilities do
+  subject(:capability) { described_class.new }
+
+  it { is_expected.to respond_to :hash_algorithm_count }
+  it { is_expected.to respond_to :salt_length }
+  it { is_expected.to respond_to :hash_algorithms }
+  it { is_expected.to respond_to :salt }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#hash_algorithm_count' do
+    it 'is a 16-bit unsigned integer' do
+      expect(capability.hash_algorithm_count).to be_a BinData::Uint16le
+    end
+
+    it 'is set to the #hash_algorithms array size' do
+      array = [1, 2, 3]
+      capability.hash_algorithms = array
+      expect(capability.hash_algorithm_count).to eq(array.size)
+    end
+  end
+
+  describe '#salt_length' do
+    it 'is a 16-bit unsigned integer' do
+      expect(capability.salt_length).to be_a BinData::Uint16le
+    end
+
+    it 'is set to the #salt string size' do
+      salt = 'my_random_salt'
+      capability.salt = salt
+      expect(capability.salt_length).to eq(salt.size)
+    end
+  end
+
+  describe '#hash_algorithms' do
+    it 'is a BinData Array' do
+      expect(capability.hash_algorithms).to be_a BinData::Array
+    end
+
+    it 'has #hash_algorithm_count elements' do
+      capability.hash_algorithm_count = 3
+      expect(capability.hash_algorithms.size).to eq 3
+    end
+  end
+
+  describe '#salt' do
+    it 'is a string' do
+      expect(capability.salt).to be_a BinData::String
+    end
+
+    it 'should read #salt_length bytes' do
+      salt = 'my_random_salt'
+      capability.salt_length = 5
+      expect(capability.salt.read(salt)).to eq(salt[0,5])
+    end
+  end
+
+  it 'reads binary data as expected' do
+    data = described_class.new(
+      hash_algorithms: [described_class::SHA_512],
+      salt: 'test salt'
+    )
+    expect(described_class.read(data.to_binary_s)).to eq(data)
+  end
+end
+
+RSpec.describe RubySMB::SMB2::EncryptionCapabilities do
+  subject(:capability) { described_class.new }
+
+  it { is_expected.to respond_to :cipher_count }
+  it { is_expected.to respond_to :ciphers }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#cipher_count' do
+    it 'is a 16-bit unsigned integer' do
+      expect(capability.cipher_count).to be_a BinData::Uint16le
+    end
+
+    it 'is set to the #ciphers array size' do
+      array = [1, 2, 3]
+      capability.ciphers = array
+      expect(capability.cipher_count).to eq(array.size)
+    end
+  end
+
+  describe '#ciphers' do
+    it 'is a BinData Array' do
+      expect(capability.ciphers).to be_a BinData::Array
+    end
+
+    it 'has #cipher_count elements' do
+      capability.cipher_count = 3
+      expect(capability.ciphers.size).to eq 3
+    end
+  end
+
+  it 'reads binary data as expected' do
+    data = described_class.new(
+      ciphers: [described_class::AES_128_CCM, described_class::AES_128_GCM]
+    )
+    expect(described_class.read(data.to_binary_s)).to eq(data)
+  end
+end
+
+RSpec.describe RubySMB::SMB2::CompressionCapabilities do
+  subject(:capability) { described_class.new }
+
+  it { is_expected.to respond_to :compression_algorithm_count }
+  it { is_expected.to respond_to :padding }
+  it { is_expected.to respond_to :flags }
+  it { is_expected.to respond_to :compression_algorithms }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#compression_algorithm_count' do
+    it 'is a 16-bit unsigned integer' do
+      expect(capability.compression_algorithm_count).to be_a BinData::Uint16le
+    end
+
+    it 'is set to the #compression_algorithms array size' do
+      array = [1, 2, 3]
+      capability.compression_algorithms = array
+      expect(capability.compression_algorithm_count).to eq(array.size)
+    end
+  end
+
+  describe '#padding' do
+    it 'is a 16-bit unsigned integer' do
+      expect(capability.padding).to be_a BinData::Uint16le
+    end
+  end
+
+  describe '#flags' do
+    it 'is a 32-bit unsigned integer' do
+      expect(capability.flags).to be_a BinData::Uint32le
+    end
+  end
+
+  describe '#compression_algorithms' do
+    it 'is a BinData Array' do
+      expect(capability.compression_algorithms).to be_a BinData::Array
+    end
+
+    it 'has #compression_algorithm_count elements' do
+      capability.compression_algorithm_count = 3
+      expect(capability.compression_algorithms.size).to eq 3
+    end
+  end
+
+  it 'reads binary data as expected' do
+    data = described_class.new(
+      compression_algorithms: [described_class::LZNT1, described_class::LZ77]
+    )
+    expect(described_class.read(data.to_binary_s)).to eq(data)
+  end
+end
+
+RSpec.describe RubySMB::SMB2::NetnameNegotiateContextId  do
+  subject(:capability) { described_class.new }
+
+  it { is_expected.to respond_to :net_name }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#net_name' do
+    it 'is a unicode string' do
+      expect(capability.net_name).to be_a RubySMB::Field::Stringz16
+    end
+  end
+
+  it 'reads binary data as expected' do
+    data = described_class.new(
+      net_name: 'netname test'
+    )
+    expect(described_class.read(data.to_binary_s)).to eq(data)
+  end
+end
+
+RSpec.describe RubySMB::SMB2::NegotiateContext do
+  class FakePacket < BinData::Record
+    endian  :little
+    string :garbage
+    negotiate_context :nc
+  end
+
+  let(:test_packet) do
+    packet = FakePacket.new
+    packet.nc.context_type = described_class::SMB2_PREAUTH_INTEGRITY_CAPABILITIES
+    packet
+  end
+  subject(:negotiate_context) { described_class.new }
+
+  it { is_expected.to respond_to :pad }
+  it { is_expected.to respond_to :context_type }
+  it { is_expected.to respond_to :data_length }
+  it { is_expected.to respond_to :reserved }
+  it { is_expected.to respond_to :data }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#pad' do
+    it 'is a string' do
+      expect(negotiate_context.pad).to be_a BinData::String
+    end
+
+    it 'should keep the #context_type 8-byte aligned' do
+      test_packet.garbage = 'foo'
+      expect(test_packet.nc.context_type.abs_offset % 8).to eq(0)
+    end
+  end
+
+  describe '#context_type ' do
+    it 'is a 16-bit unsigned integer' do
+      expect(negotiate_context.context_type).to be_a BinData::Uint16le
+    end
+  end
+
+  describe '#data_length' do
+    it 'is a 16-bit unsigned integer' do
+      expect(negotiate_context.data_length).to be_a BinData::Uint16le
+    end
+
+    it 'should give the #data field length in bytes' do
+      expect(described_class.new(context_type: described_class::SMB2_ENCRYPTION_CAPABILITIES).data_length)
+        .to eq(RubySMB::SMB2::EncryptionCapabilities.new.num_bytes)
+    end
+  end
+
+  describe '#data' do
+    it 'is a BinData choice field' do
+      expect(negotiate_context.data).to be_a BinData::Choice
+    end
+
+    context 'with a SMB2_PREAUTH_INTEGRITY_CAPABILITIES context type' do
+      it 'selects the PreauthIntegrityCapabilities structure' do
+        expect(described_class.new(context_type: described_class::SMB2_PREAUTH_INTEGRITY_CAPABILITIES).data)
+          .to eq(RubySMB::SMB2::PreauthIntegrityCapabilities.new)
+      end
+    end
+
+    context 'with a SMB2_ENCRYPTION_CAPABILITIES context type' do
+      it 'selects the PreauthIntegrityCapabilities structure' do
+        expect(described_class.new(context_type: described_class::SMB2_ENCRYPTION_CAPABILITIES).data)
+          .to eq(RubySMB::SMB2::EncryptionCapabilities.new)
+      end
+    end
+
+    context 'with a SMB2_COMPRESSION_CAPABILITIES context type' do
+      it 'selects the PreauthIntegrityCapabilities structure' do
+        expect(described_class.new(context_type: described_class::SMB2_COMPRESSION_CAPABILITIES).data)
+          .to eq(RubySMB::SMB2::CompressionCapabilities.new)
+      end
+    end
+
+    context 'with a SMB2_NETNAME_NEGOTIATE_CONTEXT_ID context type' do
+      it 'selects the PreauthIntegrityCapabilities structure' do
+        expect(described_class.new(context_type: described_class::SMB2_NETNAME_NEGOTIATE_CONTEXT_ID).data)
+          .to eq(RubySMB::SMB2::NetnameNegotiateContextId.new)
+      end
+    end
+  end
+
+  describe '#pad_length' do
+    it 'returns 0 when #context_type is already 8-byte aligned' do
+      expect(test_packet.nc.pad_length).to eq(0)
+    end
+
+    it 'returns 2 when #context_type is only 2-byte aligned' do
+      test_packet.garbage = 'align' + 'A'
+      expect(test_packet.nc.pad_length).to eq(2)
+    end
+  end
+
+  context 'with a SMB2_PREAUTH_INTEGRITY_CAPABILITIES context type' do
+    it 'reads binary data as expected' do
+      data = described_class.new(
+        context_type: described_class::SMB2_PREAUTH_INTEGRITY_CAPABILITIES
+      )
+      data.data.hash_algorithms << RubySMB::SMB2::PreauthIntegrityCapabilities::SHA_512
+      data.data.salt = 'test salt'
+      expect(described_class.read(data.to_binary_s)).to eq(data)
+    end
+  end
+
+  context 'with a SMB2_ENCRYPTION_CAPABILITIES context type' do
+    it 'reads binary data as expected' do
+      data = described_class.new(
+        context_type: described_class::SMB2_ENCRYPTION_CAPABILITIES
+      )
+      data.data.ciphers = [
+        RubySMB::SMB2::EncryptionCapabilities::AES_128_CCM,
+        RubySMB::SMB2::EncryptionCapabilities::AES_128_GCM
+      ]
+      expect(described_class.read(data.to_binary_s)).to eq(data)
+    end
+  end
+
+  context 'with a SMB2_COMPRESSION_CAPABILITIES context type' do
+    it 'reads binary data as expected' do
+      data = described_class.new(
+        context_type: described_class::SMB2_COMPRESSION_CAPABILITIES
+      )
+      data.data.compression_algorithms = [
+        RubySMB::SMB2::CompressionCapabilities::LZNT1,
+        RubySMB::SMB2::CompressionCapabilities::LZ77
+      ]
+      expect(described_class.read(data.to_binary_s)).to eq(data)
+    end
+  end
+
+  context 'with a SMB2_NETNAME_NEGOTIATE_CONTEXT_ID context type' do
+    it 'reads binary data as expected' do
+      data = described_class.new(
+        context_type: described_class::SMB2_NETNAME_NEGOTIATE_CONTEXT_ID
+      )
+      data.data.net_name = 'netname test'
+      expect(described_class.read(data.to_binary_s)).to eq(data)
+    end
+  end
+end
+