ruby_smb 2.0.1 → 2.0.6

data/lib/ruby_smb/smb1/tree.rb

@@ -49,13 +49,20 @@ module RubySMB
           raise RubySMB::Error::InvalidPacket.new(
             expected_proto: RubySMB::SMB1::SMB_PROTOCOL_ID,
             expected_cmd:   RubySMB::SMB1::Packet::TreeDisconnectResponse::COMMAND,
-            received_proto: response.smb_header.protocol,
-            received_cmd:   response.smb_header.command
+            packet:         response
           )
         end
         response.status_code
       end
 
+      def open_pipe(opts)
+        # Make sure we don't modify the caller's hash options
+        opts = opts.dup
+        opts[:filename] = opts[:filename].dup
+        opts[:filename].prepend('\\') unless opts[:filename].start_with?('\\')
+        open_file(opts)
+      end
+
       # Open a file on the remote share.
       #
       # @example
@@ -135,15 +142,14 @@ module RubySMB
           raise RubySMB::Error::InvalidPacket.new(
             expected_proto: RubySMB::SMB1::SMB_PROTOCOL_ID,
             expected_cmd:   RubySMB::SMB1::Packet::NtCreateAndxResponse::COMMAND,
-            received_proto: response.smb_header.protocol,
-            received_cmd:   response.smb_header.command
+            packet:         response
           )
         end
         unless response.status_code == WindowsError::NTStatus::STATUS_SUCCESS
           raise RubySMB::Error::UnexpectedStatusCode, response.status_code
         end
 
-        case response.parameter_block.resource_type 
+        case response.parameter_block.resource_type
         when RubySMB::SMB1::ResourceType::BYTE_MODE_PIPE, RubySMB::SMB1::ResourceType::MESSAGE_MODE_PIPE
           RubySMB::SMB1::Pipe.new(name: filename, tree: self, response: response)
         when RubySMB::SMB1::ResourceType::DISK
@@ -195,8 +201,7 @@ module RubySMB
           raise RubySMB::Error::InvalidPacket.new(
             expected_proto: RubySMB::SMB1::SMB_PROTOCOL_ID,
             expected_cmd:   RubySMB::SMB1::Packet::Trans2::FindFirst2Response::COMMAND,
-            received_proto: response.smb_header.protocol,
-            received_cmd:   response.smb_header.command
+            packet:         response
           )
         end
         unless response.status_code == WindowsError::NTStatus::STATUS_SUCCESS
@@ -230,8 +235,7 @@ module RubySMB
             raise RubySMB::Error::InvalidPacket.new(
               expected_proto: RubySMB::SMB1::SMB_PROTOCOL_ID,
               expected_cmd:   RubySMB::SMB1::Packet::Trans2::FindNext2Response::COMMAND,
-              received_proto: response.smb_header.protocol,
-              received_cmd:   response.smb_header.command
+              packet:         response
             )
           end
           unless response.status_code == WindowsError::NTStatus::STATUS_SUCCESS

data/lib/ruby_smb/smb2/file.rb

@@ -95,8 +95,7 @@ module RubySMB
           raise RubySMB::Error::InvalidPacket.new(
             expected_proto: RubySMB::SMB2::SMB2_PROTOCOL_ID,
             expected_cmd:   RubySMB::SMB2::Packet::CloseResponse::COMMAND,
-            received_proto: response.smb2_header.protocol,
-            received_cmd:   response.smb2_header.command
+            packet:         response
           )
         end
         unless response.status_code == WindowsError::NTStatus::STATUS_SUCCESS
@@ -115,21 +114,22 @@ module RubySMB
       # @raise [RubySMB::Error::InvalidPacket] if the response is not a ReadResponse packet
       # @raise [RubySMB::Error::UnexpectedStatusCode] if the response NTStatus is not STATUS_SUCCESS
       def read(bytes: size, offset: 0)
-        atomic_read_size = if bytes > tree.client.server_max_read_size
-                             tree.client.server_max_read_size
-                           else
-                             bytes
-                           end
+        max_read = tree.client.server_max_read_size
+        max_read = 65536 unless tree.client.server_supports_multi_credit
+        atomic_read_size = [bytes, max_read].min
+        credit_charge = 0
+        if tree.client.server_supports_multi_credit
+          credit_charge = (atomic_read_size - 1) / 65536 + 1
+        end
 
-        read_request = read_packet(read_length: atomic_read_size, offset: offset)
+        read_request = read_packet(read_length: atomic_read_size, offset: offset, credit_charge: credit_charge)
         raw_response = tree.client.send_recv(read_request, encrypt: @tree_connect_encrypt_data)
         response     = RubySMB::SMB2::Packet::ReadResponse.read(raw_response)
         unless response.valid?
           raise RubySMB::Error::InvalidPacket.new(
             expected_proto: RubySMB::SMB2::SMB2_PROTOCOL_ID,
             expected_cmd:   RubySMB::SMB2::Packet::ReadResponse::COMMAND,
-            received_proto: response.smb2_header.protocol,
-            received_cmd:   response.smb2_header.command
+            packet:         response
           )
         end
         unless response.status_code == WindowsError::NTStatus::STATUS_SUCCESS
@@ -142,17 +142,16 @@ module RubySMB
 
         while remaining_bytes > 0
           offset += atomic_read_size
-          atomic_read_size = remaining_bytes if remaining_bytes < tree.client.server_max_read_size
+          atomic_read_size = remaining_bytes if remaining_bytes < max_read
 
-          read_request = read_packet(read_length: atomic_read_size, offset: offset)
+          read_request = read_packet(read_length: atomic_read_size, offset: offset, credit_charge: credit_charge)
           raw_response = tree.client.send_recv(read_request, encrypt: @tree_connect_encrypt_data)
           response     = RubySMB::SMB2::Packet::ReadResponse.read(raw_response)
           unless response.valid?
             raise RubySMB::Error::InvalidPacket.new(
               expected_proto: RubySMB::SMB2::SMB2_PROTOCOL_ID,
               expected_cmd:   RubySMB::SMB2::Packet::ReadResponse::COMMAND,
-              received_proto: response.smb2_header.protocol,
-              received_cmd:   response.smb2_header.command
+              packet:         response
             )
           end
           unless response.status_code == WindowsError::NTStatus::STATUS_SUCCESS
@@ -169,11 +168,13 @@ module RubySMB
       #
       # @param bytes [Integer] the number of bytes to read
       # @param offset [Integer] the byte offset in the file to start reading from
+      # @param credit_charge [Integer] the number of credits that this request consumes
       # @return [RubySMB::SMB2::Packet::ReadRequest] the data read from the file
-      def read_packet(read_length: 0, offset: 0)
+      def read_packet(read_length: 0, offset: 0, credit_charge: 1)
         read_request = set_header_fields(RubySMB::SMB2::Packet::ReadRequest.new)
         read_request.read_length  = read_length
         read_request.offset       = offset
+        read_request.smb2_header.credit_charge = credit_charge
         read_request
       end
 
@@ -185,8 +186,7 @@ module RubySMB
           raise RubySMB::Error::InvalidPacket.new(
             expected_proto: RubySMB::SMB2::SMB2_PROTOCOL_ID,
             expected_cmd:   RubySMB::SMB2::Packet::ReadResponse::COMMAND,
-            received_proto: response.smb2_header.protocol,
-            received_cmd:   response.smb2_header.command
+            packet:         response
           )
         end
         unless response.status_code == WindowsError::NTStatus::STATUS_SUCCESS
@@ -206,8 +206,7 @@ module RubySMB
           raise RubySMB::Error::InvalidPacket.new(
             expected_proto: RubySMB::SMB2::SMB2_PROTOCOL_ID,
             expected_cmd:   RubySMB::SMB2::Packet::SetInfoResponse::COMMAND,
-            received_proto: response.smb2_header.protocol,
-            received_cmd:   response.smb2_header.command
+            packet:         response
           )
         end
         response.smb2_header.nt_status.to_nt_status
@@ -240,29 +239,30 @@ module RubySMB
       # @return [WindowsError::ErrorCode] the NTStatus code returned from the operation
       # @raise [RubySMB::Error::InvalidPacket] if the response is not a WriteResponse packet
       def write(data:'', offset: 0)
+        max_write = tree.client.server_max_write_size
+        max_write = 65536 unless tree.client.server_supports_multi_credit
         buffer            = data.dup
         bytes             = data.length
-        atomic_write_size = if bytes > tree.client.server_max_write_size
-                              tree.client.server_max_write_size
-                            else
-                             bytes
-                            end
+        atomic_write_size = [bytes, max_write].min
+        credit_charge = 0
+        if tree.client.server_supports_multi_credit
+          credit_charge = (atomic_write_size - 1) / 65536 + 1
+        end
 
         while buffer.length > 0 do
-          write_request = write_packet(data: buffer.slice!(0,atomic_write_size), offset: offset)
+          write_request = write_packet(data: buffer.slice!(0, atomic_write_size), offset: offset, credit_charge: credit_charge)
           raw_response  = tree.client.send_recv(write_request, encrypt: @tree_connect_encrypt_data)
           response      = RubySMB::SMB2::Packet::WriteResponse.read(raw_response)
           unless response.valid?
             raise RubySMB::Error::InvalidPacket.new(
               expected_proto: RubySMB::SMB2::SMB2_PROTOCOL_ID,
               expected_cmd:   RubySMB::SMB2::Packet::WriteResponse::COMMAND,
-              received_proto: response.smb2_header.protocol,
-              received_cmd:   response.smb2_header.command
+              packet:         response
             )
           end
           status        = response.smb2_header.nt_status.to_nt_status
 
-          offset+= atomic_write_size
+          offset += atomic_write_size
           return status unless status == WindowsError::NTStatus::STATUS_SUCCESS
         end
 
@@ -273,11 +273,13 @@ module RubySMB
       #
       # @param data [String] the data to write to the file
       # @param offset [Integer] the offset in the file to start writing from
+      # @param credit_charge [Integer] the number of credits that this request consumes
       # @return []RubySMB::SMB2::Packet::WriteRequest] the request packet
-      def write_packet(data:'', offset: 0)
+      def write_packet(data:'', offset: 0, credit_charge: 1)
         write_request               = set_header_fields(RubySMB::SMB2::Packet::WriteRequest.new)
         write_request.write_offset  = offset
         write_request.buffer        = data
+        write_request.smb2_header.credit_charge = credit_charge
         write_request
       end
 
@@ -289,8 +291,7 @@ module RubySMB
           raise RubySMB::Error::InvalidPacket.new(
             expected_proto: RubySMB::SMB2::SMB2_PROTOCOL_ID,
             expected_cmd:   RubySMB::SMB2::Packet::WriteResponse::COMMAND,
-            received_proto: response.smb2_header.protocol,
-            received_cmd:   response.smb2_header.command
+            packet:         response
           )
         end
         unless response.status_code == WindowsError::NTStatus::STATUS_SUCCESS
@@ -311,8 +312,7 @@ module RubySMB
           raise RubySMB::Error::InvalidPacket.new(
             expected_proto: RubySMB::SMB2::SMB2_PROTOCOL_ID,
             expected_cmd:   RubySMB::SMB2::Packet::SetInfoResponse::COMMAND,
-            received_proto: response.smb2_header.protocol,
-            received_cmd:   response.smb2_header.command
+            packet:         response
           )
         end
         response.smb2_header.nt_status.to_nt_status

data/lib/ruby_smb/smb2/pipe.rb

@@ -13,9 +13,13 @@ module RubySMB
       def initialize(tree:, response:, name:)
         raise ArgumentError, 'No Name Provided' if name.nil?
         case name
-        when 'srvsvc'
+        when 'netlogon', '\\netlogon'
+          extend RubySMB::Dcerpc::Netlogon
+        when 'srvsvc', '\\srvsvc'
           extend RubySMB::Dcerpc::Srvsvc
-        when 'winreg'
+        when 'svcctl', '\\svcctl'
+          extend RubySMB::Dcerpc::Svcctl
+        when 'winreg', '\\winreg'
           extend RubySMB::Dcerpc::Winreg
         end
         super(tree: tree, response: response, name: name)
@@ -40,8 +44,7 @@ module RubySMB
           raise RubySMB::Error::InvalidPacket.new(
             expected_proto: RubySMB::SMB2::SMB2_PROTOCOL_ID,
             expected_cmd:   RubySMB::SMB2::Packet::IoctlResponse::COMMAND,
-            received_proto: response.smb2_header.protocol,
-            received_cmd:   response.smb2_header.command
+            packet:         response
           )
         end
 
@@ -89,6 +92,7 @@ module RubySMB
         request = set_header_fields(RubySMB::SMB2::Packet::IoctlRequest.new(options))
         request.ctl_code = 0x0011C017
         request.flags.is_fsctl = 0x00000001
+        # TODO: handle fragmentation when the request size > MAX_XMIT_FRAG
         request.buffer = action.to_binary_s
 
         ioctl_raw_response = @tree.client.send_recv(request)
@@ -97,8 +101,7 @@ module RubySMB
           raise RubySMB::Error::InvalidPacket.new(
             expected_proto: RubySMB::SMB2::SMB2_PROTOCOL_ID,
             expected_cmd:   RubySMB::SMB2::Packet::IoctlRequest::COMMAND,
-            received_proto: ioctl_response.smb2_header.protocol,
-            received_cmd:   ioctl_response.smb2_header.command
+            packet:         ioctl_response
           )
         end
         unless [WindowsError::NTStatus::STATUS_SUCCESS,

data/lib/ruby_smb/smb2/tree.rb

@@ -50,13 +50,20 @@ module RubySMB
           raise RubySMB::Error::InvalidPacket.new(
             expected_proto: RubySMB::SMB2::SMB2_PROTOCOL_ID,
             expected_cmd:   RubySMB::SMB2::Packet::TreeDisconnectResponse::COMMAND,
-            received_proto: response.smb2_header.protocol,
-            received_cmd:   response.smb2_header.command
+            packet:         response
           )
         end
         response.status_code
       end
 
+      def open_pipe(opts)
+        # Make sure we don't modify the caller's hash options
+        opts = opts.dup
+        opts[:filename] = opts[:filename].dup
+        opts[:filename] = opts[:filename][1..-1] if opts[:filename].start_with? '\\'
+        open_file(opts)
+      end
+
       def open_file(filename:, attributes: nil, options: nil, disposition: RubySMB::Dispositions::FILE_OPEN,
                     impersonation: RubySMB::ImpersonationLevels::SEC_IMPERSONATE, read: true, write: false, delete: false)
 
@@ -108,8 +115,7 @@ module RubySMB
           raise RubySMB::Error::InvalidPacket.new(
             expected_proto: RubySMB::SMB2::SMB2_PROTOCOL_ID,
             expected_cmd:   RubySMB::SMB2::Packet::CreateResponse::COMMAND,
-            received_proto: response.smb2_header.protocol,
-            received_cmd:   response.smb2_header.command
+            packet:         response
           )
         end
         unless response.status_code == WindowsError::NTStatus::STATUS_SUCCESS
@@ -147,12 +153,19 @@ module RubySMB
         directory_request.file_information_class  = type::CLASS_LEVEL
         directory_request.file_id                 = file_id
         directory_request.name                    = pattern
-        directory_request.output_length           = 65_535
+
+        max_read = client.server_max_read_size
+        max_read = 65536 unless client.server_supports_multi_credit
+        credit_charge = 0
+        if client.server_supports_multi_credit
+          credit_charge = (max_read - 1) / 65536 + 1
+        end
+        directory_request.output_length = max_read
+        directory_request.smb2_header.credit_charge = credit_charge
 
         directory_request = set_header_fields(directory_request)
 
         files = []
-
         loop do
           response            = client.send_recv(directory_request, encrypt: @tree_connect_encrypt_data)
           directory_response  = RubySMB::SMB2::Packet::QueryDirectoryResponse.read(response)
@@ -160,8 +173,7 @@ module RubySMB
             raise RubySMB::Error::InvalidPacket.new(
               expected_proto: RubySMB::SMB2::SMB2_PROTOCOL_ID,
               expected_cmd:   RubySMB::SMB2::Packet::QueryDirectoryResponse::COMMAND,
-              received_proto: directory_response.smb2_header.protocol,
-              received_cmd:   directory_response.smb2_header.command
+              packet:         directory_response
             )
           end
 
@@ -205,8 +217,7 @@ module RubySMB
           raise RubySMB::Error::InvalidPacket.new(
             expected_proto: RubySMB::SMB2::SMB2_PROTOCOL_ID,
             expected_cmd:   RubySMB::SMB2::Packet::CreateResponse::COMMAND,
-            received_proto: response.smb2_header.protocol,
-            received_cmd:   response.smb2_header.command
+            packet:         response
           )
         end
         unless response.status_code == WindowsError::NTStatus::STATUS_SUCCESS
@@ -256,7 +267,6 @@ module RubySMB
       # @return [RubySMB::SMB2::Packet] the modified packet.
       def set_header_fields(request)
         request.smb2_header.tree_id = id
-        request.smb2_header.credit_charge = 1
         request.smb2_header.credits = 256
         request
       end

data/lib/ruby_smb/version.rb

@@ -1,3 +1,3 @@
 module RubySMB
-  VERSION = '2.0.1'.freeze
+  VERSION = '2.0.6'.freeze
 end

data/spec/lib/ruby_smb/client_spec.rb

@@ -65,6 +65,8 @@ RSpec.describe RubySMB::Client do
   it { is_expected.to respond_to :verify_signature }
   it { is_expected.to respond_to :auth_user }
   it { is_expected.to respond_to :last_file_id }
+  it { is_expected.to respond_to :pid }
+  it { is_expected.to respond_to :server_supports_multi_credit }
 
   describe '#initialize' do
     it 'should raise an ArgumentError without a valid dispatcher' do
@@ -141,6 +143,18 @@ RSpec.describe RubySMB::Client do
     it 'sets the max_buffer_size to MAX_BUFFER_SIZE' do
       expect(client.max_buffer_size).to eq RubySMB::Client::MAX_BUFFER_SIZE
     end
+
+    it 'sets the server_supports_multi_credit to false' do
+      expect(client.server_supports_multi_credit).to be false
+    end
+
+    it 'sets the pid to a random value' do
+      100.times do
+        previous_pid = client.pid
+        client = described_class.new(dispatcher, username: username, password: password)
+        expect(client.pid).to_not eq(previous_pid)
+      end
+    end
   end
 
   describe '#echo' do
@@ -184,11 +198,13 @@ RSpec.describe RubySMB::Client do
   describe '#send_recv' do
     let(:smb1_request) { RubySMB::SMB1::Packet::TreeConnectRequest.new }
     let(:smb2_request) { RubySMB::SMB2::Packet::TreeConnectRequest.new }
+    let(:smb2_header)  { RubySMB::SMB2::SMB2Header.new }
 
     before(:each) do
       allow(client).to receive(:is_status_pending?).and_return(false)
       allow(dispatcher).to receive(:send_packet).and_return(nil)
       allow(dispatcher).to receive(:recv_packet).and_return('A')
+      allow(RubySMB::SMB2::SMB2Header).to receive(:read).and_return(smb2_header)
     end
 
     context 'when signing' do
@@ -199,9 +215,10 @@ RSpec.describe RubySMB::Client do
 
       context 'with an SMB2 packet' do
         it 'does not sign a SessionSetupRequest packet' do
+          allow(smb2_client).to receive(:is_status_pending?).and_return(false)
           expect(smb2_client).to_not receive(:smb2_sign)
           expect(smb2_client).to_not receive(:smb3_sign)
-          client.send_recv(RubySMB::SMB2::Packet::SessionSetupRequest.new)
+          smb2_client.send_recv(RubySMB::SMB2::Packet::SessionSetupRequest.new)
         end
 
         it 'calls #smb2_sign if it is an SMB2 client' do
@@ -229,6 +246,29 @@ RSpec.describe RubySMB::Client do
         expect(smb1_client).to_not receive(:is_status_pending?)
         smb1_client.send_recv(smb1_request)
       end
+
+      it 'set the #uid SMB header when #user_id is defined' do
+        smb1_client.user_id = 333
+        smb1_client.send_recv(smb1_request)
+        expect(smb1_request.smb_header.uid).to eq(333)
+      end
+
+      it 'does not set the #uid SMB header when #user_id is not defined' do
+        smb1_client.send_recv(smb1_request)
+        expect(smb1_request.smb_header.uid).to eq(0)
+      end
+
+      it 'set the #pid SMB header when #pid is defined' do
+        smb1_client.pid = 333
+        smb1_client.send_recv(smb1_request)
+        expect(smb1_request.smb_header.pid_low).to eq(333)
+      end
+
+      it 'does not set the #pid SMB header when #pid is not defined' do
+        smb1_client.pid = nil
+        smb1_client.send_recv(smb1_request)
+        expect(smb1_request.smb_header.pid_low).to eq(0)
+      end
     end
 
     context 'with SMB2' do
@@ -251,10 +291,8 @@ RSpec.describe RubySMB::Client do
       context 'with a SessionSetupRequest' do
         it 'does not encrypt/decrypt' do
           request = RubySMB::SMB2::Packet::SessionSetupRequest.new
-          expect(smb3_client).to_not receive(:send_encrypt).with(request)
-          expect(smb3_client).to_not receive(:recv_encrypt)
-          expect(dispatcher).to receive(:send_packet).with(request)
-          expect(dispatcher).to receive(:recv_packet)
+          expect(smb3_client).to receive(:send_packet).with(request, encrypt: false)
+          expect(smb3_client).to receive(:recv_packet).with(encrypt: false)
           smb3_client.send_recv(request)
         end
       end
@@ -262,17 +300,15 @@ RSpec.describe RubySMB::Client do
       context 'with a NegotiateRequest' do
         it 'does not encrypt/decrypt' do
           request = RubySMB::SMB2::Packet::NegotiateRequest.new
-          expect(smb3_client).to_not receive(:send_encrypt).with(request)
-          expect(smb3_client).to_not receive(:recv_encrypt)
-          expect(dispatcher).to receive(:send_packet).with(request)
-          expect(dispatcher).to receive(:recv_packet)
+          expect(smb3_client).to receive(:send_packet).with(request, encrypt: false)
+          expect(smb3_client).to receive(:recv_packet).with(encrypt: false)
           smb3_client.send_recv(request)
         end
       end
 
       it 'encrypts and decrypts' do
-        expect(smb3_client).to receive(:send_encrypt).with(smb2_request)
-        expect(smb3_client).to receive(:recv_encrypt)
+        expect(smb3_client).to receive(:send_packet).with(smb2_request, encrypt: true)
+        expect(smb3_client).to receive(:recv_packet).with(encrypt: true)
         smb3_client.send_recv(smb2_request)
       end
 
@@ -280,12 +316,44 @@ RSpec.describe RubySMB::Client do
         it 'waits 1 second and reads/decrypts again' do
           allow(smb3_client).to receive(:is_status_pending?).and_return(true, false)
           expect(smb3_client).to receive(:sleep).with(1)
-          expect(smb3_client).to receive(:send_encrypt).with(smb2_request)
-          expect(smb3_client).to receive(:recv_encrypt).twice
+          expect(smb3_client).to receive(:send_packet).with(smb2_request, encrypt: true)
+          expect(smb3_client).to receive(:recv_packet).with(encrypt: true).twice
           smb3_client.send_recv(smb2_request)
         end
       end
     end
+
+    it 'increments the sequence counter if signing is required and the session key exist' do
+      allow(smb2_client).to receive(:is_status_pending?).and_return(false)
+      smb2_client.signing_required = true
+      smb2_client.session_key = 'key'
+      smb2_client.sequence_counter = 0
+      smb2_client.send_recv(smb2_request)
+      expect(smb2_client.sequence_counter).to eq(1)
+    end
+
+    it 'updates #smb2_message_id with SMB2 header #credit_charge if the server supports multi credits' do
+      allow(smb2_client).to receive(:is_status_pending?).and_return(false)
+      smb2_client.smb2_message_id = 0
+      smb2_client.server_supports_multi_credit = true
+      smb2_header.credit_charge = 5
+      smb2_client.send_recv(smb2_request)
+      expect(smb2_client.smb2_message_id).to eq(5)
+    end
+
+    it 'does not update #msb2_message_id with SMB2 header #credit_charge if the server does not support multi credits' do
+      allow(smb2_client).to receive(:is_status_pending?).and_return(false)
+      smb2_client.smb2_message_id = 0
+      smb2_client.server_supports_multi_credit = false
+      smb2_header.credit_charge = 5
+      smb2_client.send_recv(smb2_request)
+      expect(smb2_client.smb2_message_id).to eq(1)
+    end
+
+    it 'ignores errors thrown when parsing the SMB2 header' do
+      allow(RubySMB::SMB2::SMB2Header).to receive(:read).and_raise(IOError)
+      expect { smb2_client.send_recv(smb2_request) }.to_not raise_error
+    end
   end
 
   describe '#is_status_pending?' do
@@ -297,17 +365,17 @@ RSpec.describe RubySMB::Client do
     }
 
     it 'returns true when the response has a STATUS_PENDING status code and the async_command flag set' do
-      expect(client.is_status_pending?(response.to_binary_s)).to be true
+      expect(client.is_status_pending?(response.smb2_header)).to be true
     end
 
     it 'returns false when the response has a STATUS_PENDING status code and the async_command flag not set' do
       response.smb2_header.flags.async_command = 0
-      expect(client.is_status_pending?(response.to_binary_s)).to be false
+      expect(client.is_status_pending?(response.smb2_header)).to be false
     end
 
     it 'returns false when the response has no STATUS_PENDING status code but the async_command flag set' do
       response.smb2_header.nt_status= WindowsError::NTStatus::STATUS_SUCCESS.value
-      expect(client.is_status_pending?(response.to_binary_s)).to be false
+      expect(client.is_status_pending?(response.smb2_header)).to be false
     end
   end
 
@@ -344,35 +412,47 @@ RSpec.describe RubySMB::Client do
     end
   end
 
-  describe '#send_encrypt' do
+  describe '#send_packet' do
     let(:packet) { RubySMB::SMB2::Packet::SessionSetupRequest.new }
     before :example do
       allow(dispatcher).to receive(:send_packet)
       client.dialect = '0x0300'
     end
 
-    it 'creates a Transform request' do
-      expect(client).to receive(:smb3_encrypt).with(packet.to_binary_s)
-      client.send_encrypt(packet)
+    it 'does not encrypt the packet' do
+      expect(client).to_not receive(:smb3_encrypt)
+      client.send_packet(packet)
     end
 
-    it 'raises an EncryptionError exception if an error occurs while encrypting' do
-      allow(client).to receive(:smb3_encrypt).and_raise(RubySMB::Error::RubySMBError.new('Error'))
-      expect { client.send_encrypt(packet) }.to raise_error(
-        RubySMB::Error::EncryptionError,
-        "Error while encrypting #{packet.class.name} packet (SMB 0x0300): Error"
-      )
+    it 'sends the packet through the dispatcher' do
+      client.send_packet(packet)
+      expect(dispatcher).to have_received(:send_packet).with(packet)
     end
 
-    it 'sends the encrypted packet' do
-      encrypted_packet = double('Encrypted packet')
-      allow(client).to receive(:smb3_encrypt).and_return(encrypted_packet)
-      client.send_encrypt(packet)
-      expect(dispatcher).to have_received(:send_packet).with(encrypted_packet)
+    context 'with encryption' do
+      it 'creates a Transform request' do
+        expect(client).to receive(:smb3_encrypt).with(packet.to_binary_s)
+        client.send_packet(packet, encrypt: true)
+      end
+
+      it 'raises an EncryptionError exception if an error occurs while encrypting' do
+        allow(client).to receive(:smb3_encrypt).and_raise(RubySMB::Error::RubySMBError.new('Error'))
+        expect { client.send_packet(packet, encrypt: true) }.to raise_error(
+          RubySMB::Error::EncryptionError,
+          "Error while encrypting #{packet.class.name} packet (SMB 0x0300): Error"
+        )
+      end
+
+      it 'sends the encrypted packet' do
+        encrypted_packet = double('Encrypted packet')
+        allow(client).to receive(:smb3_encrypt).and_return(encrypted_packet)
+        client.send_packet(packet, encrypt: true)
+        expect(dispatcher).to have_received(:send_packet).with(encrypted_packet)
+      end
     end
   end
 
-  describe '#recv_encrypt' do
+  describe '#recv_packet' do
     let(:packet) { RubySMB::SMB2::Packet::SessionSetupRequest.new }
     before :example do
       allow(dispatcher).to receive(:recv_packet).and_return(packet.to_binary_s)
@@ -381,42 +461,49 @@ RSpec.describe RubySMB::Client do
     end
 
     it 'reads the response packet' do
-      client.recv_encrypt
+      client.recv_packet
       expect(dispatcher).to have_received(:recv_packet)
     end
 
-    it 'raises an EncryptionError exception if an error occurs while receiving the response' do
+    it 'raises an CommunicationError exception if an error occurs while receiving the response' do
       allow(dispatcher).to receive(:recv_packet).and_raise(RubySMB::Error::CommunicationError)
-      expect { client.recv_encrypt }.to raise_error(
-        RubySMB::Error::EncryptionError,
-        'Communication error with the remote host: RubySMB::Error::CommunicationError. '\
-        'The server supports encryption but was not able to handle the encrypted request.'
-      )
+      expect { client.recv_packet }.to raise_error(RubySMB::Error::CommunicationError)
     end
 
-    it 'parses the response as a Transform response packet' do
-      expect(RubySMB::SMB2::Packet::TransformHeader).to receive(:read).with(packet.to_binary_s)
-      client.recv_encrypt
-    end
+    context 'with encryption' do
+      it 'raises an EncryptionError exception if an error occurs while receiving the response' do
+        allow(dispatcher).to receive(:recv_packet).and_raise(RubySMB::Error::CommunicationError)
+        expect { client.recv_packet(encrypt: true) }.to raise_error(
+          RubySMB::Error::EncryptionError,
+          'Communication error with the remote host: RubySMB::Error::CommunicationError. '\
+          'The server supports encryption but was not able to handle the encrypted request.'
+        )
+      end
 
-    it 'raises an InvalidPacket exception if an error occurs while parsing the response' do
-      allow(RubySMB::SMB2::Packet::TransformHeader).to receive(:read).and_raise(IOError)
-      expect { client.recv_encrypt }.to raise_error(RubySMB::Error::InvalidPacket, 'Not a SMB2 TransformHeader packet')
-    end
+      it 'parses the response as a Transform response packet' do
+        expect(RubySMB::SMB2::Packet::TransformHeader).to receive(:read).with(packet.to_binary_s)
+        client.recv_packet(encrypt: true)
+      end
 
-    it 'decrypts the Transform response packet' do
-      transform = double('Transform header packet')
-      allow(RubySMB::SMB2::Packet::TransformHeader).to receive(:read).and_return(transform)
-      client.recv_encrypt
-      expect(client).to have_received(:smb3_decrypt).with(transform)
-    end
+      it 'raises an InvalidPacket exception if an error occurs while parsing the response' do
+        allow(RubySMB::SMB2::Packet::TransformHeader).to receive(:read).and_raise(IOError)
+        expect { client.recv_packet(encrypt: true) }.to raise_error(RubySMB::Error::InvalidPacket, 'Not a SMB2 TransformHeader packet')
+      end
 
-    it 'raises an EncryptionError exception if an error occurs while decrypting' do
-      allow(client).to receive(:smb3_decrypt).and_raise(RubySMB::Error::RubySMBError)
-      expect { client.recv_encrypt }.to raise_error(
-        RubySMB::Error::EncryptionError,
-        'Error while decrypting RubySMB::SMB2::Packet::TransformHeader packet (SMB 0x0300}): RubySMB::Error::RubySMBError'
-      )
+      it 'decrypts the Transform response packet' do
+        transform = double('Transform header packet')
+        allow(RubySMB::SMB2::Packet::TransformHeader).to receive(:read).and_return(transform)
+        client.recv_packet(encrypt: true)
+        expect(client).to have_received(:smb3_decrypt).with(transform)
+      end
+
+      it 'raises an EncryptionError exception if an error occurs while decrypting' do
+        allow(client).to receive(:smb3_decrypt).and_raise(RubySMB::Error::RubySMBError)
+        expect { client.recv_packet(encrypt: true) }.to raise_error(
+          RubySMB::Error::EncryptionError,
+          'Error while decrypting RubySMB::SMB2::Packet::TransformHeader packet (SMB 0x0300}): RubySMB::Error::RubySMBError'
+        )
+      end
     end
   end
 
@@ -667,7 +754,7 @@ RSpec.describe RubySMB::Client do
         expect(session_packet.session_header.session_packet_type).to eq RubySMB::Nbss::SESSION_REQUEST
         expect(session_packet.called_name).to eq called_name
         expect(session_packet.calling_name).to eq calling_name
-        expect(session_packet.session_header.packet_length).to eq(
+        expect(session_packet.session_header.stream_protocol_length).to eq(
           session_packet.called_name.to_binary_s.size + session_packet.calling_name.to_binary_s.size
         )
       end
@@ -1036,6 +1123,19 @@ RSpec.describe RubySMB::Client do
         it 'returns the string \'SMB2\'' do
           expect(client.parse_negotiate_response(smb2_response)).to eq ('SMB2')
         end
+
+        it 'sets #server_supports_multi_credit to true when the response has #large_mtu capability set' do
+          smb2_response.capabilities.large_mtu = 1
+          client.parse_negotiate_response(smb2_response)
+          expect(client.server_supports_multi_credit).to be true
+        end
+
+        it 'sets #server_supports_multi_credit to false when the dialect is 0x0202' do
+          smb2_response.dialect_revision = 0x0202
+          smb2_response.capabilities.large_mtu = 1 # just to make sure it won't affect the result
+          client.parse_negotiate_response(smb2_response)
+          expect(client.server_supports_multi_credit).to be false
+        end
       end
 
       context 'when SMB3 was negotiated' do
@@ -1060,11 +1160,22 @@ RSpec.describe RubySMB::Client do
           expect(client.parse_negotiate_response(smb3_response)).to eq ('SMB3')
         end
 
+        it 'sets #server_supports_multi_credit to true when the response has #large_mtu capability set' do
+          smb3_response.capabilities.large_mtu = 1
+          client.parse_negotiate_response(smb3_response)
+          expect(client.server_supports_multi_credit).to be true
+        end
+
         context 'when the server supports encryption' do
           before :example do
             smb3_response.capabilities.encryption = 1
           end
 
+          it 'sets the expected encryption algorithm' do
+            client.parse_negotiate_response(smb3_response)
+            expect(client.encryption_algorithm).to eq(RubySMB::SMB2::EncryptionCapabilities::ENCRYPTION_ALGORITHM_MAP[RubySMB::SMB2::EncryptionCapabilities::AES_128_CCM])
+          end
+
           it 'keeps session encryption enabled if it was already' do
             client.session_encrypt_data = true
             client.parse_negotiate_response(smb3_response)
@@ -1166,26 +1277,15 @@ RSpec.describe RubySMB::Client do
         end
       end
 
-      ['0x0300', '0x0302'].each do |dialect|
-        context "with #{dialect} dialect" do
-          before :example do
-            client.dialect = dialect
-          end
-
-          it 'sets the expected encryption algorithm' do
-            client.negotiate
-            expect(client.encryption_algorithm).to eq(RubySMB::SMB2::EncryptionCapabilities::ENCRYPTION_ALGORITHM_MAP[RubySMB::SMB2::EncryptionCapabilities::AES_128_CCM])
-          end
-        end
-      end
-
       context "with 0x0311 dialect" do
-        it 'calls #parse_smb3_encryption_data' do
+        it 'calls #parse_negotiate_response and updates the preauth hash' do
           client.dialect = '0x0311'
           request_packet = client.smb2_3_negotiate_request
           allow(client).to receive(:negotiate_request).and_return(request_packet)
           allow(client).to receive(:negotiate_response).and_return(smb3_response)
-          expect(client).to receive(:parse_smb3_encryption_data).with(request_packet, smb3_response)
+          expect(client).to receive(:parse_negotiate_response).with(smb3_response)
+          expect(client).to receive(:update_preauth_hash).with(request_packet)
+          expect(client).to receive(:update_preauth_hash).with(smb3_response)
           client.negotiate
         end
       end
@@ -1258,7 +1358,7 @@ RSpec.describe RubySMB::Client do
         end
       end
 
-      describe '#parse_smb3_encryption_data' do
+      describe '#parse_smb3_capabilities' do
         let(:request_packet) { client.smb2_3_negotiate_request }
         let(:smb3_response) { RubySMB::SMB2::Packet::NegotiateResponse.new(dialect_revision: 0x311) }
         let(:nc_encryption) do
@@ -1285,7 +1385,7 @@ RSpec.describe RubySMB::Client do
         context 'when selecting the integrity hash algorithm' do
           context 'with one algorithm' do
             it 'selects the expected algorithm' do
-              smb3_client.parse_smb3_encryption_data(request_packet, smb3_response)
+              smb3_client.parse_smb3_capabilities(smb3_response)
               expect(smb3_client.preauth_integrity_hash_algorithm).to eq('SHA512')
             end
           end
@@ -1296,7 +1396,7 @@ RSpec.describe RubySMB::Client do
                 RubySMB::SMB2::NegotiateContext::SMB2_PREAUTH_INTEGRITY_CAPABILITIES
               )
               nc.data.hash_algorithms << 3
-              smb3_client.parse_smb3_encryption_data(request_packet, smb3_response)
+              smb3_client.parse_smb3_capabilities(smb3_response)
               expect(smb3_client.preauth_integrity_hash_algorithm).to eq('SHA512')
             end
           end
@@ -1305,7 +1405,7 @@ RSpec.describe RubySMB::Client do
             it 'raises the expected exception' do
               smb3_response = RubySMB::SMB2::Packet::NegotiateResponse.new(dialect_revision: 0x311)
               smb3_response.add_negotiate_context(nc_encryption)
-              expect { smb3_client.parse_smb3_encryption_data(request_packet, smb3_response) }.to raise_error(
+              expect { smb3_client.parse_smb3_capabilities(smb3_response) }.to raise_error(
                 RubySMB::Error::EncryptionError,
                 'Unable to retrieve the Preauth Integrity Hash Algorithm from the Negotiate response'
               )
@@ -1321,7 +1421,7 @@ RSpec.describe RubySMB::Client do
               )
               nc.data.hash_algorithms << 5
               smb3_response.add_negotiate_context(nc)
-              expect { smb3_client.parse_smb3_encryption_data(request_packet, smb3_response) }.to raise_error(
+              expect { smb3_client.parse_smb3_capabilities(smb3_response) }.to raise_error(
                 RubySMB::Error::EncryptionError,
                 'Unable to retrieve the Preauth Integrity Hash Algorithm from the Negotiate response'
               )
@@ -1332,7 +1432,7 @@ RSpec.describe RubySMB::Client do
         context 'when selecting the encryption algorithm' do
           context 'with one algorithm' do
             it 'selects the expected algorithm' do
-              smb3_client.parse_smb3_encryption_data(request_packet, smb3_response)
+              smb3_client.parse_smb3_capabilities(smb3_response)
               expect(smb3_client.encryption_algorithm).to eq('AES-128-CCM')
             end
           end
@@ -1343,7 +1443,7 @@ RSpec.describe RubySMB::Client do
                 RubySMB::SMB2::NegotiateContext::SMB2_ENCRYPTION_CAPABILITIES
               )
               nc.data.ciphers << RubySMB::SMB2::EncryptionCapabilities::AES_128_GCM
-              smb3_client.parse_smb3_encryption_data(request_packet, smb3_response)
+              smb3_client.parse_smb3_capabilities(smb3_response)
               expect(smb3_client.encryption_algorithm).to eq('AES-128-GCM')
             end
 
@@ -1352,7 +1452,7 @@ RSpec.describe RubySMB::Client do
                 RubySMB::SMB2::NegotiateContext::SMB2_ENCRYPTION_CAPABILITIES
               )
               nc.data.ciphers << 3
-              smb3_client.parse_smb3_encryption_data(request_packet, smb3_response)
+              smb3_client.parse_smb3_capabilities(smb3_response)
               expect(smb3_client.encryption_algorithm).to eq('AES-128-CCM')
             end
 
@@ -1361,7 +1461,7 @@ RSpec.describe RubySMB::Client do
                 RubySMB::SMB2::NegotiateContext::SMB2_ENCRYPTION_CAPABILITIES
               )
               nc.data.ciphers << RubySMB::SMB2::EncryptionCapabilities::AES_128_GCM
-              smb3_client.parse_smb3_encryption_data(request_packet, smb3_response)
+              smb3_client.parse_smb3_capabilities(smb3_response)
               expect(smb3_client.server_encryption_algorithms).to eq([1, 2])
             end
           end
@@ -1370,7 +1470,7 @@ RSpec.describe RubySMB::Client do
             it 'raises the expected exception' do
               smb3_response = RubySMB::SMB2::Packet::NegotiateResponse.new(dialect_revision: 0x311)
               smb3_response.add_negotiate_context(nc_integrity)
-              expect { smb3_client.parse_smb3_encryption_data(request_packet, smb3_response) }.to raise_error(
+              expect { smb3_client.parse_smb3_capabilities(smb3_response) }.to raise_error(
                 RubySMB::Error::EncryptionError,
                 'Unable to retrieve the encryption cipher list supported by the server from the Negotiate response'
               )
@@ -1386,7 +1486,7 @@ RSpec.describe RubySMB::Client do
               )
               nc.data.ciphers << 14
               smb3_response.add_negotiate_context(nc)
-              expect { smb3_client.parse_smb3_encryption_data(request_packet, smb3_response) }.to raise_error(
+              expect { smb3_client.parse_smb3_capabilities(smb3_response) }.to raise_error(
                 RubySMB::Error::EncryptionError,
                 'Unable to retrieve the encryption cipher list supported by the server from the Negotiate response'
               )
@@ -1404,16 +1504,10 @@ RSpec.describe RubySMB::Client do
             nc.data.compression_algorithms << RubySMB::SMB2::CompressionCapabilities::LZ77_Huffman
             nc.data.compression_algorithms << RubySMB::SMB2::CompressionCapabilities::Pattern_V1
             smb3_response.add_negotiate_context(nc)
-            smb3_client.parse_smb3_encryption_data(request_packet, smb3_response)
+            smb3_client.parse_smb3_capabilities(smb3_response)
             expect(smb3_client.server_compression_algorithms).to eq([1, 2, 3, 4])
           end
         end
-
-        it 'updates the preauth hash' do
-          expect(smb3_client).to receive(:update_preauth_hash).with(request_packet)
-          expect(smb3_client).to receive(:update_preauth_hash).with(smb3_response)
-          smb3_client.parse_smb3_encryption_data(request_packet, smb3_response)
-        end
       end
     end
   end
@@ -2265,7 +2359,7 @@ RSpec.describe RubySMB::Client do
         let(:named_pipe){ double("Named Pipe") }
 
         before :example do
-          allow(tree).to receive(:open_file).and_return(named_pipe)
+          allow(tree).to receive(:open_pipe).and_return(named_pipe)
           allow(named_pipe).to receive(:net_share_enum_all)
         end
 
@@ -2280,8 +2374,8 @@ RSpec.describe RubySMB::Client do
             smb1_client.net_share_enum_all(sock.peeraddr)
           end
 
-          it 'it calls the Tree #open_file method to open "srvsvc" named pipe' do
-            expect(tree).to receive(:open_file).with(filename: "srvsvc", write: true, read: true).and_return(named_pipe)
+          it 'it calls the Tree #open_pipe method to open "srvsvc" named pipe' do
+            expect(tree).to receive(:open_pipe).with(filename: "srvsvc", write: true, read: true).and_return(named_pipe)
             smb1_client.net_share_enum_all(sock.peeraddr)
           end
 
@@ -2303,8 +2397,8 @@ RSpec.describe RubySMB::Client do
             smb2_client.net_share_enum_all(sock.peeraddr)
           end
 
-          it 'it calls the Tree #open_file method to open "srvsvc" named pipe' do
-            expect(tree).to receive(:open_file).with(filename: "srvsvc", write: true, read: true).and_return(named_pipe)
+          it 'it calls the Tree #open_pipe method to open "srvsvc" named pipe' do
+            expect(tree).to receive(:open_pipe).with(filename: "srvsvc", write: true, read: true).and_return(named_pipe)
             smb2_client.net_share_enum_all(sock.peeraddr)
           end
 
@@ -2385,7 +2479,7 @@ RSpec.describe RubySMB::Client do
       before :example do
         allow(ipc_tree).to receive_messages(
           :share     => share,
-          :open_file => named_pipe
+          :open_pipe => named_pipe
         )
         allow(client).to receive(:tree_connect).and_return(ipc_tree)
       end
@@ -2407,9 +2501,9 @@ RSpec.describe RubySMB::Client do
         expect(client).to have_received(:tree_connect).with(share)
       end
 
-      it 'open \'winreg\' file on the IPC$ Tree' do
+      it 'open \'winreg\' pipe on the IPC$ Tree' do
         client.connect_to_winreg(host)
-        expect(ipc_tree).to have_received(:open_file).with(filename: "winreg", write: true, read: true)
+        expect(ipc_tree).to have_received(:open_pipe).with(filename: "winreg", write: true, read: true)
       end
 
       it 'returns the expected opened named pipe' do