ruby_smb 2.0.0 → 2.0.5

data/lib/ruby_smb/smb2/file.rb

@@ -52,10 +52,10 @@ module RubySMB
       #   @return [RubySMB::SMB2::Tree]
       attr_accessor :tree
 
-      # Whether or not encryption is required (SMB 3.x)
-      # @!attribute [rw] encryption_required
+      # Whether or not the share associated with this tree connect needs to be encrypted (SMB 3.x)
+      # @!attribute [rw] tree_connect_encrypt_data
       #   @return [Boolean]
-      attr_accessor :encryption_required
+      attr_accessor :tree_connect_encrypt_data
 
       def initialize(tree:, response:, name:, encrypt: false)
         raise ArgumentError, 'No Tree Provided' if tree.nil?
@@ -71,7 +71,7 @@ module RubySMB
         @last_write   = response.last_write.to_datetime
         @size         = response.end_of_file
         @size_on_disk = response.allocation_size
-        @encryption_required = encrypt
+        @tree_connect_encrypt_data = encrypt
       end
 
       # Appends the supplied data to the end of the file.
@@ -89,14 +89,13 @@ module RubySMB
       # @raise [RubySMB::Error::UnexpectedStatusCode] if the response NTStatus is not STATUS_SUCCESS
       def close
         close_request = set_header_fields(RubySMB::SMB2::Packet::CloseRequest.new)
-        raw_response  = tree.client.send_recv(close_request, encrypt: @encryption_required)
+        raw_response  = tree.client.send_recv(close_request, encrypt: @tree_connect_encrypt_data)
         response = RubySMB::SMB2::Packet::CloseResponse.read(raw_response)
         unless response.valid?
           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
-
-        read_request = read_packet(read_length: atomic_read_size, offset: offset)
-        raw_response = tree.client.send_recv(read_request, encrypt: @encryption_required)
+        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, 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)
-          raw_response = tree.client.send_recv(read_request, encrypt: @encryption_required)
+          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,24 +168,25 @@ 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
 
       def send_recv_read(read_length: 0, offset: 0)
         read_request = read_packet(read_length: read_length, offset: offset)
-        raw_response = tree.client.send_recv(read_request, encrypt: @encryption_required)
+        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
@@ -200,14 +200,13 @@ module RubySMB
       # @return [WindowsError::ErrorCode] the NTStatus Response code
       # @raise [RubySMB::Error::InvalidPacket] if the response is not a SetInfoResponse packet
       def delete
-        raw_response = tree.client.send_recv(delete_packet, encrypt: @encryption_required)
+        raw_response = tree.client.send_recv(delete_packet, encrypt: @tree_connect_encrypt_data)
         response = RubySMB::SMB2::Packet::SetInfoResponse.read(raw_response)
         unless response.valid?
           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)
-          raw_response  = tree.client.send_recv(write_request, encrypt: @encryption_required)
+          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,24 +273,25 @@ 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
 
       def send_recv_write(data:'', offset: 0)
         pkt = write_packet(data: data, offset: offset)
-        raw_response = tree.client.send_recv(pkt, encrypt: @encryption_required)
+        raw_response = tree.client.send_recv(pkt, 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
         unless response.status_code == WindowsError::NTStatus::STATUS_SUCCESS
@@ -305,14 +306,13 @@ module RubySMB
       # @return [WindowsError::ErrorCode] the NTStatus Response code
       # @raise [RubySMB::Error::InvalidPacket] if the response is not a SetInfoResponse packet
       def rename(new_file_name)
-        raw_response = tree.client.send_recv(rename_packet(new_file_name), encrypt: @encryption_required)
+        raw_response = tree.client.send_recv(rename_packet(new_file_name), encrypt: @tree_connect_encrypt_data)
         response = RubySMB::SMB2::Packet::SetInfoResponse.read(raw_response)
         unless response.valid?
           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/packet/negotiate_response.rb

@@ -15,7 +15,7 @@ module RubySMB
         uint16              :dialect_revision,          label: 'Dialect Revision'
         uint16              :negotiate_context_count,   label: 'Negotiate Context Count', initial_value: -> { negotiate_context_list.size }, onlyif: -> { has_negotiate_context? }
         uint16              :reserved1,                 label: 'Reserved', initial_value: 0, onlyif: -> { !has_negotiate_context? }
-        string              :server_guid,               label: 'Server GUID',                  length: 16
+        string              :server_guid,               label: 'Server GUID', length: 16
         smb2_capabilities   :capabilities
         uint32              :max_transact_size,         label: 'Max Transaction Size'
         uint32              :max_read_size,             label: 'Max Read Size'

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

@@ -23,10 +23,10 @@ module RubySMB
       #   @return [Integer]
       attr_accessor :id
 
-      # Whether or not encryption is required (SMB 3.x)
-      # @!attribute [rw] encryption_required
+      # Whether or not the share associated with this tree connect needs to be encrypted (SMB 3.x)
+      # @!attribute [rw] tree_connect_encrypt_data
       #   @return [Boolean]
-      attr_accessor :encryption_required
+      attr_accessor :tree_connect_encrypt_data
 
       def initialize(client:, share:, response:, encrypt: false)
         @client              = client
@@ -34,7 +34,7 @@ module RubySMB
         @id                  = response.smb2_header.tree_id
         @permissions         = response.maximal_access
         @share_type          = response.share_type
-        @encryption_required = encrypt
+        @tree_connect_encrypt_data = encrypt
       end
 
       # Disconnects this Tree from the current session
@@ -44,19 +44,26 @@ module RubySMB
       def disconnect!
         request = RubySMB::SMB2::Packet::TreeDisconnectRequest.new
         request = set_header_fields(request)
-        raw_response = client.send_recv(request, encrypt: @encryption_required)
+        raw_response = client.send_recv(request, encrypt: @tree_connect_encrypt_data)
         response = RubySMB::SMB2::Packet::TreeDisconnectResponse.read(raw_response)
         unless response.valid?
           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)
 
@@ -102,14 +109,13 @@ module RubySMB
         create_request.create_disposition   = disposition
         create_request.name                 = filename
 
-        raw_response  = client.send_recv(create_request, encrypt: @encryption_required)
+        raw_response  = client.send_recv(create_request, encrypt: @tree_connect_encrypt_data)
         response      = RubySMB::SMB2::Packet::CreateResponse.read(raw_response)
         unless response.valid?
           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
@@ -118,7 +124,7 @@ module RubySMB
 
         case @share_type
         when RubySMB::SMB2::Packet::TreeConnectResponse::SMB2_SHARE_TYPE_DISK
-          RubySMB::SMB2::File.new(name: filename, tree: self, response: response, encrypt: @encryption_required)
+          RubySMB::SMB2::File.new(name: filename, tree: self, response: response, encrypt: @tree_connect_encrypt_data)
         when RubySMB::SMB2::Packet::TreeConnectResponse::SMB2_SHARE_TYPE_PIPE
           RubySMB::SMB2::Pipe.new(name: filename, tree: self, response: response)
         # when RubySMB::SMB2::TreeConnectResponse::SMB2_SHARE_TYPE_PRINT
@@ -147,21 +153,27 @@ 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: @encryption_required)
+          response            = client.send_recv(directory_request, encrypt: @tree_connect_encrypt_data)
           directory_response  = RubySMB::SMB2::Packet::QueryDirectoryResponse.read(response)
           unless directory_response.valid?
             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
 
@@ -199,14 +211,13 @@ module RubySMB
 
         create_request  = open_directory_packet(directory: directory, disposition: disposition,
                                                 impersonation: impersonation, read: read, write: write, delete: delete)
-        raw_response    = client.send_recv(create_request, encrypt: @encryption_required)
+        raw_response    = client.send_recv(create_request, encrypt: @tree_connect_encrypt_data)
         response = RubySMB::SMB2::Packet::CreateResponse.read(raw_response)
         unless response.valid?
           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.0'.freeze
+  VERSION = '2.0.5'.freeze
 end

data/spec/lib/ruby_smb/client_spec.rb

@@ -46,7 +46,7 @@ RSpec.describe RubySMB::Client do
   it { is_expected.to respond_to :encryption_algorithm }
   it { is_expected.to respond_to :client_encryption_key }
   it { is_expected.to respond_to :server_encryption_key }
-  it { is_expected.to respond_to :encryption_required }
+  it { is_expected.to respond_to :session_encrypt_data }
   it { is_expected.to respond_to :server_encryption_algorithms }
   it { is_expected.to respond_to :server_compression_algorithms }
   it { is_expected.to respond_to :negotiated_smb_version }
@@ -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
@@ -106,9 +108,9 @@ RSpec.describe RubySMB::Client do
       expect(client.password).to eq password
     end
 
-    it 'sets the encryption_required attribute' do
+    it 'sets the session_encrypt_data attribute' do
       client =  described_class.new(dispatcher, username: username, password: password, always_encrypt: true)
-      expect(client.encryption_required).to eq true
+      expect(client.session_encrypt_data).to eq true
     end
 
     it 'creates an NTLM client' do
@@ -125,7 +127,7 @@ RSpec.describe RubySMB::Client do
         expect(opt[:workstation]).to eq(local_workstation)
         expect(opt[:domain]).to eq(domain)
         flags = Net::NTLM::Client::DEFAULT_FLAGS |
-          Net::NTLM::FLAGS[:TARGET_INFO] | 0x02000000
+          Net::NTLM::FLAGS[:TARGET_INFO] | 0x02000000 ^ Net::NTLM::FLAGS[:OEM]
         expect(opt[:flags]).to eq(flags)
       end
 
@@ -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,16 +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')
-    end
-
-    it 'checks the packet version' do
-      expect(smb1_request).to receive(:packet_smb_version).and_call_original
-      client.send_recv(smb1_request)
+      allow(RubySMB::SMB2::SMB2Header).to receive(:read).and_return(smb2_header)
     end
 
     context 'when signing' do
@@ -204,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
@@ -234,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
@@ -256,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
@@ -267,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
 
@@ -285,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
@@ -302,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
 
@@ -322,6 +385,11 @@ RSpec.describe RubySMB::Client do
       expect(client.can_be_encrypted?(packet)).to be true
     end
 
+    it 'returns false if it is an SMB1 packet' do
+      packet = RubySMB::SMB1::Packet::LogoffRequest.new
+      expect(client.can_be_encrypted?(packet)).to be false
+    end
+
     [RubySMB::SMB2::Packet::SessionSetupRequest, RubySMB::SMB2::Packet::NegotiateRequest].each do |klass|
       it "returns false if the packet is a #{klass}" do
         packet = klass.new
@@ -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,33 +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 '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
+    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_packet }.to raise_error(RubySMB::Error::CommunicationError)
     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
+    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 '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 '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 '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 '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 '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
 
@@ -658,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
@@ -1027,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
@@ -1050,6 +1159,53 @@ RSpec.describe RubySMB::Client do
         it 'returns the string \'SMB2\'' 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)
+            expect(client.session_encrypt_data).to be true
+          end
+
+          it 'keeps session encryption disabled if it was already' do
+            client.session_encrypt_data = false
+            client.parse_negotiate_response(smb3_response)
+            expect(client.session_encrypt_data).to be false
+          end
+        end
+
+        context 'when the server does not support encryption' do
+          before :example do
+            smb3_response.capabilities.encryption = 0
+          end
+
+          it 'disables session encryption if it was already enabled' do
+            client.session_encrypt_data = true
+            client.parse_negotiate_response(smb3_response)
+            expect(client.session_encrypt_data).to be false
+          end
+
+          it 'keeps session encryption disabled if it was already' do
+            client.session_encrypt_data = false
+            client.parse_negotiate_response(smb3_response)
+            expect(client.session_encrypt_data).to be false
+          end
+        end
       end
 
       context 'when the response contains the SMB2 wildcard revision number dialect' do
@@ -1121,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
@@ -1213,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
@@ -1240,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
@@ -1251,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
@@ -1260,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'
               )
@@ -1276,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'
               )
@@ -1287,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
@@ -1298,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
 
@@ -1307,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
 
@@ -1316,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
@@ -1325,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'
               )
@@ -1341,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'
               )
@@ -1359,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
@@ -1710,22 +1849,22 @@ RSpec.describe RubySMB::Client do
           smb2_client.smb2_authenticate
         end
 
-        context 'when setting the encryption_required parameter' do
+        context 'when setting the session_encrypt_data parameter' do
           before :example do
             smb2_client.smb3 = true
-            smb2_client.encryption_required = false
+            smb2_client.session_encrypt_data = false
           end
 
-          it 'sets the encryption_required parameter to true if the server requires encryption' do
+          it 'sets the session_encrypt_data parameter to true if the server requires encryption' do
             final_response_packet.session_flags.encrypt_data = 1
             smb2_client.smb2_authenticate
-            expect(smb2_client.encryption_required).to be true
+            expect(smb2_client.session_encrypt_data).to be true
           end
 
-          it 'does not set the encryption_required parameter if the server does not require encryption' do
+          it 'does not set the session_encrypt_data parameter if the server does not require encryption' do
             final_response_packet.session_flags.encrypt_data = 0
             smb2_client.smb2_authenticate
-            expect(smb2_client.encryption_required).to be false
+            expect(smb2_client.session_encrypt_data).to be false
           end
         end
       end
@@ -2220,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
 
@@ -2235,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
 
@@ -2258,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
 
@@ -2340,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
@@ -2362,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