ruby_smb 1.1.0 → 2.0.4

data/spec/lib/ruby_smb/error_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+RSpec.describe RubySMB::Error::InvalidPacket do
+  context 'with a String' do
+    it 'outputs the expected error message' do
+      ex = described_class.new('My exception')
+      expect(ex.to_s).to eq('My exception')
+    end
+  end
+
+  context 'with a Hash' do
+    let(:ex) do
+      described_class.new(
+        expected_proto:  RubySMB::SMB1::SMB_PROTOCOL_ID,
+        expected_cmd:    RubySMB::SMB1::Packet::NegotiateResponseExtended::COMMAND,
+        expected_custom: "extended_security=1",
+        packet:          packet,
+        received_custom: "extended_security=0"
+      )
+    end
+
+    context 'with an SMB2 packet' do
+      let(:packet) { RubySMB::SMB2::Packet::NegotiateResponse.new }
+
+      it 'outputs the expected error message' do
+        expect(ex.to_s).to eq('Expecting SMB1 protocol with command=114 (extended_security=1), got SMB2 protocol with command=0 (extended_security=0), Status: (0x00000000) STATUS_SUCCESS: The operation completed successfully.')
+      end
+    end
+
+    context 'with an SMB1 packet' do
+      let(:packet) { RubySMB::SMB1::Packet::ReadAndxRequest.new }
+
+      it 'outputs the expected error message' do
+        expect(ex.to_s).to eq('Expecting SMB1 protocol with command=114 (extended_security=1), got SMB1 protocol with command=46 (extended_security=0), Status: (0x00000000) STATUS_SUCCESS: The operation completed successfully.')
+      end
+    end
+
+    context 'without packet' do
+      let(:ex) do
+        described_class.new(
+          expected_proto:  RubySMB::SMB1::SMB_PROTOCOL_ID,
+          expected_cmd:    RubySMB::SMB1::Packet::NegotiateResponseExtended::COMMAND,
+          expected_custom: "extended_security=1",
+          received_custom: "extended_security=0"
+        )
+      end
+
+      it 'outputs the expected error message' do
+        expect(ex.to_s).to eq('Expecting SMB1 protocol with command=114 (extended_security=1), got ??? protocol with command=??? (extended_security=0)')
+      end
+    end
+  end
+
+  context 'with an unsupported type' do
+    it 'raises the expected exception' do
+      expect { described_class.new(['wrong']) }.to raise_error(
+        ArgumentError,
+        'InvalidPacket expects a String or a Hash, got a Array'
+      )
+    end
+  end
+end
+
+
+RSpec.describe RubySMB::Error::UnexpectedStatusCode do
+  context 'with a WindowsError::ErrorCode' do
+    it 'outputs the expected error message' do
+      ex = described_class.new(WindowsError::NTStatus::STATUS_BUFFER_OVERFLOW)
+      expect(ex.to_s).to eq('The server responded with an unexpected status code: STATUS_BUFFER_OVERFLOW')
+    end
+  end
+
+  context 'with an Integer' do
+    it 'outputs the expected error message' do
+      ex = described_class.new(0x80000005)
+      expect(ex.to_s).to eq('The server responded with an unexpected status code: STATUS_BUFFER_OVERFLOW')
+    end
+  end
+
+  context 'with an unsupported type' do
+    it 'raises the expected exception' do
+      expect { described_class.new(['wrong']) }.to raise_error(
+        ArgumentError,
+        'Status code must be a WindowsError::ErrorCode or an Integer, got Array'
+      )
+    end
+  end
+end

data/spec/lib/ruby_smb/field/stringz16_spec.rb

@@ -44,5 +44,17 @@ RSpec.describe RubySMB::Field::Stringz16 do
       io = StringIO.new("A\x00B\x00C\x00D\x00")
       expect { stringz16.read(io) }.to raise_error(EOFError)
     end
+
+    it 'trims the string to #max_length and makes sure it ends with a null terminator' do
+      io = StringIO.new("A\x00B\x00C\x00D\x00")
+      str = described_class.new(max_length: 6)
+      expect(str.read(io).to_binary_s).to eq("A\x00B\x00\x00\x00".b)
+    end
+
+    it 'raises an exception when #max_length is not a multiple of two' do
+      io = StringIO.new("A\x00B\x00C\x00D\x00")
+      str = described_class.new(max_length: 5)
+      expect { str.read(io) }.to raise_error(ArgumentError)
+    end
   end
 end

data/spec/lib/ruby_smb/generic_packet_spec.rb

@@ -88,6 +88,13 @@ RSpec.describe RubySMB::GenericPacket do
         packet = RubySMB::SMB2::Packet::NegotiateResponse.read(smb2_error_packet.to_binary_s)
         expect(packet.original_command).to eq RubySMB::SMB2::Packet::NegotiateResponse::COMMAND
       end
+
+      context 'when the server returns an SMB1 error packet' do
+        let(:smb1_error_packet) { RubySMB::SMB1::Packet::EmptyPacket.new }
+        it 'returns the empty packet instead of the asked for class' do
+          expect(RubySMB::SMB2::Packet::NegotiateResponse.read(smb1_error_packet.to_binary_s)).to be_a RubySMB::SMB1::Packet::EmptyPacket
+        end
+      end
     end
   end
 

data/spec/lib/ruby_smb/nbss/session_header_spec.rb

@@ -2,8 +2,7 @@ RSpec.describe RubySMB::Nbss::SessionHeader do
   subject(:session_header) { described_class.new }
 
   it { is_expected.to respond_to :session_packet_type }
-  it { is_expected.to respond_to :flags }
-  it { is_expected.to respond_to :packet_length }
+  it { is_expected.to respond_to :stream_protocol_length }
 
   it 'is big endian' do
     expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :big
@@ -15,15 +14,9 @@ RSpec.describe RubySMB::Nbss::SessionHeader do
     end
   end
 
-  describe '#flags' do
-    it 'is a 7-bit Unsigned Integer' do
-      expect(session_header.flags).to be_a BinData::Bit7
-    end
-  end
-
-  describe '#packet_length' do
-    it 'is a 17-bit Unsigned Integer' do
-      expect(session_header.packet_length).to be_a BinData::Bit17
+  describe '#stream_protocol_length' do
+    it 'is a 24-bit Unsigned Integer' do
+      expect(session_header.stream_protocol_length).to be_a BinData::Uint24be
     end
   end
 end

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

@@ -521,9 +521,7 @@ RSpec.describe RubySMB::SMB1::File do
 
     it 'raises an InvalidPacket exception if the response is not valid' do
       allow(response).to receive(:valid?).and_return(false)
-      smb_header = double('SMB Header')
-      allow(response).to receive(:smb_header).and_return(smb_header)
-      allow(smb_header).to receive_messages(:protocol => nil, :command => nil)
+      allow(response).to receive(:packet_smb_version)
       expect { file.close }.to raise_error(RubySMB::Error::InvalidPacket)
     end
 

data/spec/lib/ruby_smb/smb1/packet/session_setup_legacy_request_spec.rb

@@ -10,8 +10,8 @@ RSpec.describe RubySMB::SMB1::Packet::SessionSetupLegacyRequest do
       expect(header).to be_a RubySMB::SMB1::SMBHeader
     end
 
-    it 'should have the command set to SMB_COM_NEGOTIATE' do
-      expect(header.command).to eq RubySMB::SMB1::Commands::SMB_COM_SESSION_SETUP
+    it 'should have the command set to SMB_COM_SESSION_SETUP_ANDX' do
+      expect(header.command).to eq RubySMB::SMB1::Commands::SMB_COM_SESSION_SETUP_ANDX
     end
 
     it 'should not have the response flag set' do

data/spec/lib/ruby_smb/smb1/packet/session_setup_legacy_response_spec.rb

@@ -10,8 +10,8 @@ RSpec.describe RubySMB::SMB1::Packet::SessionSetupLegacyResponse do
       expect(header).to be_a RubySMB::SMB1::SMBHeader
     end
 
-    it 'should have the command set to SMB_COM_NEGOTIATE' do
-      expect(header.command).to eq RubySMB::SMB1::Commands::SMB_COM_SESSION_SETUP
+    it 'should have the command set to SMB_COM_SESSION_SETUP_ANDX' do
+      expect(header.command).to eq RubySMB::SMB1::Commands::SMB_COM_SESSION_SETUP_ANDX
     end
 
     it 'should have the response flag set' do

data/spec/lib/ruby_smb/smb1/packet/session_setup_request_spec.rb

@@ -10,8 +10,8 @@ RSpec.describe RubySMB::SMB1::Packet::SessionSetupRequest do
       expect(header).to be_a RubySMB::SMB1::SMBHeader
     end
 
-    it 'should have the command set to SMB_COM_NEGOTIATE' do
-      expect(header.command).to eq RubySMB::SMB1::Commands::SMB_COM_SESSION_SETUP
+    it 'should have the command set to SMB_COM_SESSION_SETUP_ANDX' do
+      expect(header.command).to eq RubySMB::SMB1::Commands::SMB_COM_SESSION_SETUP_ANDX
     end
 
     it 'should not have the response flag set' do

data/spec/lib/ruby_smb/smb1/packet/session_setup_response_spec.rb

@@ -11,7 +11,7 @@ RSpec.describe RubySMB::SMB1::Packet::SessionSetupResponse do
     end
 
     it 'should have the command set to SMB_COM_NEGOTIATE' do
-      expect(header.command).to eq RubySMB::SMB1::Commands::SMB_COM_SESSION_SETUP
+      expect(header.command).to eq RubySMB::SMB1::Commands::SMB_COM_SESSION_SETUP_ANDX
     end
 
     it 'should have the response flag set' do

data/spec/lib/ruby_smb/smb1/pipe_spec.rb

@@ -80,9 +80,7 @@ RSpec.describe RubySMB::SMB1::Pipe do
 
     it 'raises an InvalidPacket exception if the response is not valid' do
       allow(response).to receive(:valid?).and_return(false)
-      smb_header = double('SMB Header')
-      allow(response).to receive(:smb_header).and_return(smb_header)
-      allow(smb_header).to receive_messages(:protocol => nil, :command => nil)
+      allow(response).to receive(:packet_smb_version)
       expect { pipe.peek }.to raise_error(RubySMB::Error::InvalidPacket)
     end
 
@@ -149,12 +147,40 @@ RSpec.describe RubySMB::SMB1::Pipe do
       end
     end
 
+    context 'with \'\\srvsvc\' filename' do
+      it 'extends Srvsvc class' do
+        pipe = described_class.new(tree: tree, response: nt_create_andx_response, name: '\\srvsvc')
+        expect(pipe.respond_to?(:net_share_enum_all)).to be true
+      end
+    end
+
     context 'with \'winreg\' filename' do
       it 'extends Winreg class' do
         pipe = described_class.new(tree: tree, response: nt_create_andx_response, name: 'winreg')
         expect(pipe.respond_to?(:has_registry_key?)).to be true
       end
     end
+
+    context 'with \'\\winreg\' filename' do
+      it 'extends Winreg class' do
+        pipe = described_class.new(tree: tree, response: nt_create_andx_response, name: '\\winreg')
+        expect(pipe.respond_to?(:has_registry_key?)).to be true
+      end
+    end
+
+    context 'with \'svcctl\' filename' do
+      it 'extends svcctl class' do
+        pipe = described_class.new(tree: tree, response: nt_create_andx_response, name: 'svcctl')
+        expect(pipe.respond_to?(:query_service_config)).to be true
+      end
+    end
+
+    context 'with \'\\svcctl\' filename' do
+      it 'extends svcctl class' do
+        pipe = described_class.new(tree: tree, response: nt_create_andx_response, name: '\\svcctl')
+        expect(pipe.respond_to?(:query_service_config)).to be true
+      end
+    end
   end
 
   describe '#dcerpc_request' do
@@ -238,8 +264,7 @@ RSpec.describe RubySMB::SMB1::Pipe do
 
     context 'when the response is not a Trans packet' do
       it 'raises an InvalidPacket exception' do
-        allow(trans_nmpipe_response).to receive_message_chain(:smb_header, :protocol)
-        allow(trans_nmpipe_response).to receive_message_chain(:smb_header, :command)
+        allow(trans_nmpipe_response).to receive(:packet_smb_version)
         allow(trans_nmpipe_response).to receive(:valid?).and_return(false)
         expect { pipe.dcerpc_request(stub_packet, options) }.to raise_error(RubySMB::Error::InvalidPacket)
       end

data/spec/lib/ruby_smb/smb1/tree_spec.rb

@@ -492,4 +492,26 @@ RSpec.describe RubySMB::SMB1::Tree do
     end
   end
 
+  describe '#open_pipe' do
+    let(:opts) { { filename: 'test', write: true } }
+    before :example do
+      allow(tree).to receive(:open_file)
+    end
+
+    it 'calls #open_file with the provided options' do
+      opts[:filename] ='\\test'
+      expect(tree).to receive(:open_file).with(opts)
+      tree.open_pipe(opts)
+    end
+
+    it 'prepends the filename with \\ if needed' do
+      expect(tree).to receive(:open_file).with( { filename: '\\test', write: true } )
+      tree.open_pipe(opts)
+    end
+
+    it 'does not modify the original option hash' do
+      tree.open_pipe(opts)
+      expect(opts).to eq( { filename: 'test', write: true } )
+    end
+  end
 end

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
 
@@ -341,9 +459,7 @@ RSpec.describe RubySMB::SMB2::File do
 
     it 'raises an InvalidPacket exception if the response is not valid' do
       allow(response).to receive(:valid?).and_return(false)
-      smb2_header = double('SMB2 Header')
-      allow(response).to receive(:smb2_header).and_return(smb2_header)
-      allow(smb2_header).to receive_messages(:protocol => nil, :command => nil)
+      allow(response).to receive(:packet_smb_version)
       expect { file.close }.to raise_error(RubySMB::Error::InvalidPacket)
     end
 
@@ -394,7 +510,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 +532,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 +554,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 +575,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