ruby_smb 2.0.2 → 2.0.3

data/lib/ruby_smb/dcerpc/winreg/query_value_request.rb

@@ -13,9 +13,10 @@ module RubySMB
 
         rpc_hkey           :hkey
         rrp_unicode_string :lp_value_name
-        string             :pad, length: -> { pad_length }
+        string             :pad1, length: -> { pad_length(self.lp_value_name) }
         ndr_lp_dword       :lp_type
-        ndr_lp_byte        :lp_data
+        ndr_lp_byte_array  :lp_data
+        string             :pad2, length: -> { pad_length(self.lp_data) }
         ndr_lp_dword       :lpcb_data
         ndr_lp_dword       :lpcb_len
 
@@ -24,10 +25,10 @@ module RubySMB
           @opnum = REG_QUERY_VALUE
         end
 
-        # Determines the correct length for the padding in front of
-        # #lp_type. It should always force a 4-byte alignment.
-        def pad_length
-          offset = (lp_value_name.abs_offset + lp_value_name.to_binary_s.length) % 4
+        # Determines the correct length for the padding, so that the next
+        # field is 4-byte aligned.
+        def pad_length(prev_element)
+          offset = (prev_element.abs_offset + prev_element.to_binary_s.length) % 4
           (4 - offset) % 4
         end
       end

data/lib/ruby_smb/dcerpc/winreg/query_value_response.rb

@@ -9,22 +9,22 @@ module RubySMB
 
         endian :little
 
-        ndr_lp_dword :lp_type
-        ndr_lp_byte  :lp_data
-        string       :pad, length: -> { pad_length }
-        ndr_lp_dword :lpcb_data
-        ndr_lp_dword :lpcb_len
-        uint32       :error_status
+        ndr_lp_dword      :lp_type
+        ndr_lp_byte_array :lp_data
+        string            :pad, length: -> { pad_length(self.lp_data) }
+        ndr_lp_dword      :lpcb_data
+        ndr_lp_dword      :lpcb_len
+        uint32            :error_status
 
         def initialize_instance
           super
           @opnum = REG_QUERY_VALUE
         end
 
-        # Determines the correct length for the padding in front of
-        # #lpcb_data. It should always force a 4-byte alignment.
-        def pad_length
-          offset = (lp_data.abs_offset + lp_data.to_binary_s.length) % 4
+        # Determines the correct length for the padding, so that the next
+        # field is 4-byte aligned.
+        def pad_length(prev_element)
+          offset = (prev_element.abs_offset + prev_element.to_binary_s.length) % 4
           (4 - offset) % 4
         end
 

data/lib/ruby_smb/dcerpc/winreg/save_key_request.rb

@@ -0,0 +1,37 @@
+module RubySMB
+  module Dcerpc
+    module Winreg
+
+      class RpcHkey < Ndr::NdrContextHandle; end
+
+      # This class represents a BaseRegSaveKey Request Packet as defined in
+      # [3.1.5.20 BaseRegSaveKey (Opnum 20)](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-rrp/f022247d-6ef1-4f46-b195-7f60654f4a0d)
+      class SaveKeyRequest < BinData::Record
+        attr_reader :opnum
+
+        endian :little
+
+        rpc_hkey                 :hkey
+        rrp_unicode_string       :lp_file
+        string                   :pad, length: -> { pad_length(self.lp_file) }
+        prpc_security_attributes :lp_security_attributes
+
+        def initialize_instance
+          super
+          @opnum = REG_SAVE_KEY
+        end
+
+        # Determines the correct length for the padding, so that the next
+        # field is 4-byte aligned.
+        def pad_length(prev_element)
+          offset = (prev_element.abs_offset + prev_element.to_binary_s.length) % 4
+          (4 - offset) % 4
+        end
+      end
+
+    end
+  end
+end
+
+
+

data/lib/ruby_smb/dcerpc/winreg/save_key_response.rb

@@ -0,0 +1,23 @@
+module RubySMB
+  module Dcerpc
+    module Winreg
+
+      # This class represents a BaseRegSaveKey Response Packet as defined in
+      # [3.1.5.20 BaseRegSaveKey (Opnum 20)](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-rrp/f022247d-6ef1-4f46-b195-7f60654f4a0d)
+      class SaveKeyResponse < BinData::Record
+        attr_reader :opnum
+
+        endian :little
+
+        uint32       :error_status
+
+        def initialize_instance
+          super
+          @opnum = REG_CREATE_KEY
+        end
+      end
+
+    end
+  end
+end
+

data/lib/ruby_smb/dispatcher/base.rb

@@ -9,7 +9,7 @@ module RubySMB
       def nbss(packet)
         nbss = RubySMB::Nbss::SessionHeader.new
         nbss.session_packet_type = RubySMB::Nbss::SESSION_MESSAGE
-        nbss.packet_length       = packet.do_num_bytes
+        nbss.stream_protocol_length = packet.do_num_bytes
         nbss.to_binary_s
       end
 

data/lib/ruby_smb/dispatcher/socket.rb

@@ -74,7 +74,7 @@ module RubySMB
           raise ::RubySMB::Error::NetBiosSessionService, 'NBSS Header is missing'
         end
 
-        length = nbss_header.packet_length
+        length = nbss_header.stream_protocol_length
         data = full_response ? nbss_header.to_binary_s : ''
         if length > 0
           if IO.select([@tcp_socket], nil, nil, @read_timeout).nil?

data/lib/ruby_smb/field/stringz16.rb

@@ -25,12 +25,17 @@ module RubySMB
       # @see BinData::Stringz
       def read_and_return_value(io)
         max_length = eval_parameter(:max_length)
+        if max_length && max_length % 2 != 0
+          raise ArgumentError, "[Stringz16] #max_length should be a multiple of "\
+            "two, since it is Unicode (got #{max_length})"
+        end
         str = ''
         i = 0
         ch = nil
 
         # read until double NULL-byte or we have read in the max number of bytes
-        while (ch != "\0\0") && (i != max_length)
+        loop do
+          break if ch == "\0\0" || (max_length && i == max_length)
           ch = io.readbytes(2)
           str << ch
           i += 2
@@ -46,6 +51,17 @@ module RubySMB
       def truncate_after_first_zero_byte!(str)
         str.sub!(/([^\0]*\0\0\0).*/, '\1')
       end
+
+      def trim_to!(str, max_length = nil)
+        if max_length
+          max_length = 2 if max_length < 2
+          str.slice!(max_length..-1)
+          if str.length == max_length && str[-2, 2] != "\0\0"
+            str[-2, 2] = "\0\0"
+          end
+        end
+      end
+
     end
   end
 end

data/lib/ruby_smb/nbss/session_header.rb

@@ -1,13 +1,13 @@
 module RubySMB
   module Nbss
     # Representation of the NetBIOS Session Service Header as defined in
-    # [4.3.1 GENERAL FORMAT OF SESSION PACKETS](https://tools.ietf.org/html/rfc1002)
+    # SMB: [2.1 Transport](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-smb/f906c680-330c-43ae-9a71-f854e24aeee6)
+    # SMB2: [2.1 Transport](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-smb2/1dfacde4-b5c7-4494-8a14-a09d3ab4cc83)
     class SessionHeader < BinData::Record
       endian :big
 
-      uint8 :session_packet_type,  label: 'Session Packet Type'
-      bit7  :flags,                label: 'Flags',              initial_value: 0
-      bit17 :packet_length,        label: 'Packet Length'
+      uint8  :session_packet_type,    label: 'Session Packet Type', initial_value: 0
+      uint24 :stream_protocol_length, label: 'Stream Protocol Length'
     end
   end
 end

data/lib/ruby_smb/smb1/file.rb

@@ -106,11 +106,7 @@ module RubySMB
       # @raise [RubySMB::Error::InvalidPacket] if the response packet is not valid
       # @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.max_buffer_size
-                             @tree.client.max_buffer_size
-                           else
-                             bytes
-                           end
+        atomic_read_size = [bytes, @tree.client.max_buffer_size].min
         remaining_bytes = bytes
         data = ''
 
@@ -227,11 +223,7 @@ module RubySMB
         total_bytes_written = 0
 
         loop do
-          atomic_write_size = if bytes > @tree.client.max_buffer_size
-                               @tree.client.max_buffer_size
-                              else
-                                bytes
-                              end
+          atomic_write_size = [bytes, @tree.client.max_buffer_size].min
           write_request = write_packet(data: buffer.slice!(0, atomic_write_size), offset: offset)
           raw_response = @tree.client.send_recv(write_request)
           response = RubySMB::SMB1::Packet::WriteAndxResponse.read(raw_response)

data/lib/ruby_smb/smb1/pipe.rb

@@ -20,6 +20,8 @@ module RubySMB
           extend RubySMB::Dcerpc::Srvsvc
         when 'winreg'
           extend RubySMB::Dcerpc::Winreg
+        when 'svcctl'
+          extend RubySMB::Dcerpc::Svcctl
         end
         super(tree: tree, response: response, name: name)
       end

data/lib/ruby_smb/smb2/file.rb

@@ -115,13 +115,15 @@ 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?
@@ -142,9 +144,9 @@ 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?
@@ -169,11 +171,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
 
@@ -240,16 +244,18 @@ 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?
@@ -262,7 +268,7 @@ module RubySMB
           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 +279,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
 

data/lib/ruby_smb/smb2/pipe.rb

@@ -17,6 +17,8 @@ module RubySMB
           extend RubySMB::Dcerpc::Srvsvc
         when 'winreg'
           extend RubySMB::Dcerpc::Winreg
+        when 'svcctl'
+          extend RubySMB::Dcerpc::Svcctl
         end
         super(tree: tree, response: response, name: name)
       end
@@ -89,6 +91,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)

data/lib/ruby_smb/smb2/tree.rb

@@ -147,12 +147,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)
@@ -256,7 +263,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.2'.freeze
+  VERSION = '2.0.3'.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,39 @@ 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 #msb2_message_id with SMB2 header #credit_charge if the dialect is not 0x0202' do
+      allow(smb2_client).to receive(:is_status_pending?).and_return(false)
+      smb2_client.smb2_message_id = 0
+      smb2_client.dialect = '0x0210'
+      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 dialect is 0x0202' do
+      allow(smb2_client).to receive(:is_status_pending?).and_return(false)
+      smb2_client.smb2_message_id = 0
+      smb2_client.dialect = '0x0202'
+      smb2_header.credit_charge = 5
+      smb2_client.send_recv(smb2_request)
+      expect(smb2_client.smb2_message_id).to eq(1)
+    end
   end
 
   describe '#is_status_pending?' do
@@ -297,17 +360,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 +407,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 +456,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 +749,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 +1118,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,6 +1155,12 @@ 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