ruby_smb 0.0.18 → 0.0.19

data/lib/ruby_smb/smb2/packet/set_info_response.rb

@@ -0,0 +1,20 @@
+module RubySMB
+  module SMB2
+    module Packet
+      # An SMB2 Read Response Packet as defined in
+      # [2.2.40 SMB2 SET_INFO Response](https://msdn.microsoft.com/en-us/library/cc246562.aspx)
+      class SetInfoResponse < RubySMB::GenericPacket
+        endian :little
+
+        smb2_header   :smb2_header
+        uint16        :structure_size, label: 'Structure Size', initial_value: 2
+
+        def initialize_instance
+          super
+          smb2_header.command     = RubySMB::SMB2::Commands::SET_INFO
+          smb2_header.flags.reply = 1
+        end
+      end
+    end
+  end
+end

data/lib/ruby_smb/smb2/packet/tree_connect_request.rb

@@ -1,7 +1,6 @@
 module RubySMB
   module SMB2
     module Packet
-
       # An SMB2 TreeConnectRequest Packet as defined in
       # [2.2.9 SMB2 TREE_CONNECT Request](https://msdn.microsoft.com/en-us/library/cc246567.aspx)
       class TreeConnectRequest < RubySMB::GenericPacket
@@ -10,7 +9,7 @@ module RubySMB
         uint16       :structure_size, label: 'Structure Size', initial_value: 9
         uint16       :flags,          label: 'Flags',          initial_value: 0x00
         uint16       :path_offset,    label: 'Path Offset',    initial_value: 0x48
-        uint16       :path_length,    label: 'Path Length',    initial_value: lambda { self.path.length }
+        uint16       :path_length,    label: 'Path Length',    initial_value: -> { path.length }
         string       :path,           label: 'Path Buffer'
 
         def initialize_instance
@@ -19,9 +18,9 @@ module RubySMB
         end
 
         def encode_path(path)
-          self.path = path.encode("utf-16le")
+          self.path = path.encode('utf-16le')
         end
       end
     end
   end
-end
+end

data/lib/ruby_smb/smb2/packet/tree_connect_response.rb

@@ -1,11 +1,10 @@
 module RubySMB
   module SMB2
     module Packet
-
       # An SMB2 TreeConnectResponse Packet as defined in
       # [2.2.10 SMB2 TREE_CONNECT Response](https://msdn.microsoft.com/en-us/library/cc246499.aspx)
       class TreeConnectResponse < RubySMB::GenericPacket
-        endian  :little
+        endian :little
         smb2_header           :smb2_header
         uint16                :structure_size, label: 'Structure Size', initial_value: 16
         uint8                 :share_type,     label: 'Share Type',     initial_value: 0x01
@@ -28,9 +27,9 @@ module RubySMB
         # @return [RubySMB::SMB2::BitField::FileAccessMask] if anything else was connected to
         def access_rights
           if is_directory?
-            self.maximal_access
+            maximal_access
           else
-            mask = self.maximal_access.to_binary_s
+            mask = maximal_access.to_binary_s
             RubySMB::SMB2::BitField::FileAccessMask.read(mask)
           end
         end
@@ -39,12 +38,9 @@ module RubySMB
         #
         # @return [Boolean]
         def is_directory?
-          self.share_type == 0x01
+          share_type == 0x01
         end
-
-
-
       end
     end
   end
-end
+end

data/lib/ruby_smb/smb2/packet/tree_disconnect_request.rb

@@ -1,7 +1,6 @@
 module RubySMB
   module SMB2
     module Packet
-
       # An SMB2 TreeDisconnectRequest Packet as defined in
       # [2.2.11 SMB2 TREE_DISCONNECT Request](https://msdn.microsoft.com/en-us/library/cc246500.aspx)
       class TreeDisconnectRequest < RubySMB::GenericPacket
@@ -9,13 +8,11 @@ module RubySMB
         smb2_header  :smb2_header
         uint16       :structure_size, label: 'Structure Size', initial_value: 4
 
-
         def initialize_instance
           super
           smb2_header.command = RubySMB::SMB2::Commands::TREE_DISCONNECT
         end
-
       end
     end
   end
-end
+end

data/lib/ruby_smb/smb2/packet/tree_disconnect_response.rb

@@ -1,7 +1,6 @@
 module RubySMB
   module SMB2
     module Packet
-
       # An SMB2 TreeDisconnectResponse Packet as defined in
       # [2.2.12 SMB2 TREE_DISCONNECT Response](https://msdn.microsoft.com/en-us/library/cc246501.aspx)
       class TreeDisconnectResponse < RubySMB::GenericPacket
@@ -9,14 +8,12 @@ module RubySMB
         smb2_header  :smb2_header
         uint16       :structure_size, label: 'Structure Size', initial_value: 4
 
-
         def initialize_instance
           super
           smb2_header.command = RubySMB::SMB2::Commands::TREE_DISCONNECT
           smb2_header.flags.reply = 1
         end
-
       end
     end
   end
-end
+end

data/lib/ruby_smb/smb2/packet/write_request.rb

@@ -0,0 +1,29 @@
+module RubySMB
+  module SMB2
+    module Packet
+      # An SMB2 Write Request Packet as defined in
+      # [2.2.21 SMB2 WRITE Request](https://msdn.microsoft.com/en-us/library/cc246532.aspx)
+      class WriteRequest < RubySMB::GenericPacket
+        endian :little
+
+        smb2_header           :smb2_header
+        uint16                :structure_size,        label: 'Structure Size',  initial_value: 49
+        uint16                :data_offset,           label: 'Data Offset' ,    initial_value: lambda { self.buffer.abs_offset }
+        uint32                :write_length,          label: 'Write Length',    initial_value: lambda { self.buffer.do_num_bytes }
+        uint64                :write_offset,          label: 'File Write Offset'
+        smb2_fileid           :file_id,               label: 'File ID'
+        uint32                :channel,               label: 'Channel'
+        uint32                :remaining_bytes,       label: 'Remaining Bytes'
+        uint16                :channel_offset,        label: 'Write Channel Info Offset'
+        uint16                :channel_length,        label: 'Write Channel Info Length'
+        uint32                :flags,                 label: 'Flags'
+        string                :buffer,                label: 'Write Data Buffer'
+
+        def initialize_instance
+          super
+          smb2_header.command = RubySMB::SMB2::Commands::WRITE
+        end
+      end
+    end
+  end
+end

data/lib/ruby_smb/smb2/packet/write_response.rb

@@ -0,0 +1,26 @@
+module RubySMB
+  module SMB2
+    module Packet
+      # An SMB2 Write Response Packet as defined in
+      # [2.2.22 SMB2 WRITE Response](https://msdn.microsoft.com/en-us/library/cc246533.aspx)
+      class WriteResponse < RubySMB::GenericPacket
+        endian :little
+
+        smb2_header           :smb2_header
+        uint16                :structure_size,        label: 'Structure Size',  initial_value: 17
+        uint16                :reserved,              label: 'Reserved Space'
+        uint32                :write_count,           label: 'Bytes Written'
+        uint32                :remaining_bytes,       label: 'Remaining Bytes'
+        uint16                :channel_offset,        label: 'Write Channel Info Offset'
+        uint16                :channel_length,        label: 'Write Channel Info Length'
+
+
+        def initialize_instance
+          super
+          smb2_header.command = RubySMB::SMB2::Commands::WRITE
+          smb2_header.flags.reply = 1
+        end
+      end
+    end
+  end
+end

data/lib/ruby_smb/smb2/tree.rb

@@ -1,10 +1,8 @@
 module RubySMB
   module SMB2
-
     # An SMB2 connected remote Tree, as returned by a
     # [RubySMB::SMB2::Packet::TreeConnectRequest]
     class Tree
-
       # The client this Tree is connected through
       # @!attribute [rw] client
       #   @return [RubySMB::Client]
@@ -37,15 +35,173 @@ module RubySMB
       # @return [WindowsError::ErrorCode] the NTStatus sent back by the server.
       def disconnect!
         request = RubySMB::SMB2::Packet::TreeDisconnectRequest.new
-        request.smb2_header.tree_id = self.id
-        request.smb2_header.credit_charge = 1
-        request.smb2_header.credits = 256
-        raw_response = self.client.send_recv(request)
+        request = set_header_fields(request)
+        raw_response = client.send_recv(request)
         response = RubySMB::SMB2::Packet::TreeDisconnectResponse.read(raw_response)
         response.status_code
       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)
+
+        create_request = RubySMB::SMB2::Packet::CreateRequest.new
+        create_request = set_header_fields(create_request)
+
+        # If the user supplied file attributes, use those, otherwise set some
+        # sane defaults.
+        if attributes
+          create_request.file_attributes = attributes
+        else
+          create_request.file_attributes.directory  = 0
+          create_request.file_attributes.normal     = 1
+        end
+
+        # If the user supplied Create Options, use those, otherwise set some
+        # sane defaults.
+        if options
+          create_request.create_options = options
+        else
+          create_request.create_options.directory_file      = 0
+          create_request.create_options.non_directory_file  = 1
+        end
+
+        if read
+          create_request.share_access.read_access = 1
+          create_request.desired_access.read_data = 1
+        end
+
+        if write
+          create_request.share_access.write_access   = 1
+          create_request.desired_access.write_data   = 1
+          create_request.desired_access.append_data  = 1
+        end
+
+        if delete
+          create_request.share_access.delete_access   = 1
+          create_request.desired_access.delete_access = 1
+        end
+
+        create_request.requested_oplock     = 0xff
+        create_request.impersonation_level  = impersonation
+        create_request.create_disposition   = disposition
+        create_request.name                 = filename
+
+        raw_response  = client.send_recv(create_request)
+        response      = RubySMB::SMB2::Packet::CreateResponse.read(raw_response)
+
+        RubySMB::SMB2::File.new(name: filename, tree: self, response: response)
+      end
+
+      # List `directory` on the remote share.
+      #
+      # @example
+      #   tree = client.tree_connect("\\\\192.168.99.134\\Share")
+      #   tree.list(directory: "path\\to\\directory")
+      #
+      # @param directory [String] path to the directory to be listed
+      # @param pattern [String] search pattern
+      # @param type [Class] file information class
+      # @return [Array] array of directory structures
+      def list(directory: nil, pattern: '*', type: RubySMB::Fscc::FileInformation::FileIdFullDirectoryInformation)
+        create_response = open_directory(directory: directory)
+        file_id         = create_response.file_id
+
+        directory_request                         = RubySMB::SMB2::Packet::QueryDirectoryRequest.new
+        directory_request.file_information_class  = type::CLASS_LEVEL
+        directory_request.file_id                 = file_id
+        directory_request.name                    = pattern
+        directory_request.output_length           = 65_535
+
+        directory_request = set_header_fields(directory_request)
+
+        files = []
+
+        loop do
+          response            = client.send_recv(directory_request)
+          directory_response  = RubySMB::SMB2::Packet::QueryDirectoryResponse.read(response)
 
+          status_code         = directory_response.smb2_header.nt_status.to_nt_status
+
+          break if status_code == WindowsError::NTStatus::STATUS_NO_MORE_FILES
+
+          unless status_code == WindowsError::NTStatus::STATUS_SUCCESS
+
+            raise RubySMB::Error::UnexpectedStatusCode, status_code.to_s
+          end
+
+          files += directory_response.results(type)
+          # Reset the message id so the client can update appropriately.
+          directory_request.smb2_header.message_id = 0
+        end
+
+        files
+      end
+
+      # 'Opens' a directory file on the remote end, using a CreateRequest. This
+      # can be used to open an existing directory, or create a new one, depending
+      # on the disposition set.
+      #
+      # @param directory [String] the name of the directory file
+      # @param disposition [Integer] the create disposition to use, should be one of {RubySMB::Dispositions}
+      # @param impersonation [Integer] the impersonation level to use, should be one of {RubySMB::ImpersonationLevels}
+      # @param read [Boolean] whether to request read access
+      # @param write [Boolean] whether to request write access
+      # @param delete [Boolean] whether to request delete access
+      # @return [RubySMB::SMB2::Packet::CreateResponse] the response packet returned from the server
+      def open_directory(directory: nil, disposition: RubySMB::Dispositions::FILE_OPEN,
+                         impersonation: RubySMB::ImpersonationLevels::SEC_IMPERSONATE,
+                         read: true, write: false, delete: false)
+
+        create_request  = open_directory_packet(directory: directory, disposition: disposition,
+                                                impersonation: impersonation, read: read, write: write, delete: delete)
+        raw_response    = client.send_recv(create_request)
+        RubySMB::SMB2::Packet::CreateResponse.read(raw_response)
+      end
+
+      # Creates the Packet for the #open_directory method.
+      #
+      # @param directory [String] the name of the directory file
+      # @param disposition [Integer] the create disposition to use, should be one of {RubySMB::Dispositions}
+      # @param impersonation [Integer] the impersonation level to use, should be one of {RubySMB::ImpersonationLevels}
+      # @param read [Boolean] whether to request read access
+      # @param write [Boolean] whether to request write access
+      # @param delete [Boolean] whether to request delete access
+      # @return [RubySMB::SMB2::Packet::CreateRequest] the request packet to send to the server
+      def open_directory_packet(directory: nil, disposition: RubySMB::Dispositions::FILE_OPEN,
+                                impersonation: RubySMB::ImpersonationLevels::SEC_IMPERSONATE,
+                                read: true, write: false, delete: false)
+        create_request = RubySMB::SMB2::Packet::CreateRequest.new
+        create_request = set_header_fields(create_request)
+
+        create_request.impersonation_level            = impersonation
+        create_request.create_options.directory_file  = 1
+        create_request.file_attributes.directory      = 1
+        create_request.desired_access.list            = 1
+        create_request.share_access.read_access       = 1 if read
+        create_request.share_access.write_access      = 1 if write
+        create_request.share_access.delete_access     = 1 if delete
+        create_request.create_disposition             = disposition
+
+        if directory.nil? || directory.empty?
+          create_request.name = "\x00"
+          create_request.name_length = 0
+        else
+          create_request.name = directory
+        end
+        create_request
+      end
+
+      # Sets a few preset header fields that will always be set the same
+      # way for Tree operations. This is, the TreeID, Credits, and Credit Charge.
+      #
+      # @param [RubySMB::SMB2::Packet] the request packet to modify
+      # @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
     end
   end
-end
+end

data/lib/ruby_smb/version.rb

@@ -1,3 +1,3 @@
 module RubySMB
-  VERSION = '0.0.18'
+  VERSION = '0.0.19'.freeze
 end

data/spec/lib/ruby_smb/client_spec.rb

@@ -1,19 +1,18 @@
 require 'spec_helper'
 
 RSpec.describe RubySMB::Client do
-
-  let(:sock)  { double("Socket", peeraddr: '192.168.1.5' ) }
+  let(:sock) { double('Socket', peeraddr: '192.168.1.5') }
   let(:dispatcher) { RubySMB::Dispatcher::Socket.new(sock) }
   let(:username) { 'msfadmin' }
-  let(:password) { 'msfadmin' }
+  let(:password) { 'msfpasswd' }
   subject(:client) { described_class.new(dispatcher, username: username, password: password) }
-  let(:smb1_client) { described_class.new(dispatcher, smb2:false, username: username, password: password) }
-  let(:smb2_client) { described_class.new(dispatcher, smb1:false, username: username, password: password) }
+  let(:smb1_client) { described_class.new(dispatcher, smb2: false, username: username, password: password) }
+  let(:smb2_client) { described_class.new(dispatcher, smb1: false, username: username, password: password) }
   let(:empty_packet) { RubySMB::SMB1::Packet::EmptyPacket.new }
 
   describe '#initialize' do
     it 'should raise an ArgumentError without a valid dispatcher' do
-      expect{ described_class.new(nil) }.to raise_error(ArgumentError)
+      expect { described_class.new(nil) }.to raise_error(ArgumentError)
     end
 
     it 'defaults to true for SMB1 support' do
@@ -25,8 +24,7 @@ RSpec.describe RubySMB::Client do
     end
 
     it 'accepts an argument to disable smb1 support' do
-      smb_client = described_class.new(dispatcher, smb1:false, username: username, password: password)
-      expect(smb_client.smb1).to be false
+      expect(smb2_client.smb1).to be false
     end
 
     it 'accepts an argument to disable smb2 support' do
@@ -34,10 +32,10 @@ RSpec.describe RubySMB::Client do
     end
 
     it 'raises an exception if both SMB1 and SMB2 are disabled' do
-      expect{described_class.new(dispatcher, smb1:false, smb2:false, username: username, password: password)}.to raise_error(ArgumentError, 'You must enable at least one Protocol')
+      expect { described_class.new(dispatcher, smb1: false, smb2: false, username: username, password: password) }.to raise_error(ArgumentError, 'You must enable at least one Protocol')
     end
 
-    it 'sets the username attribute'  do
+    it 'sets the username attribute' do
       expect(client.username).to eq username
     end
 
@@ -45,9 +43,36 @@ RSpec.describe RubySMB::Client do
       expect(client.password).to eq password
     end
 
-    it 'crates an NTLM client' do
+    it 'creates an NTLM client' do
       expect(client.ntlm_client).to be_a Net::NTLM::Client
     end
+
+    it 'passes the expected arguments when creating the NTLM client' do
+      domain = 'SPEC_DOMAIN'
+      local_workstation = 'SPEC_WORKSTATION'
+
+      allow(Net::NTLM::Client).to receive(:new) do |username, passwd, opt|
+        expect(username).to eq(username)
+        expect(password).to eq(password)
+        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
+        expect(opt[:flags]).to eq(flags)
+      end
+
+      described_class.new(
+        dispatcher,
+        username: username,
+        password: password,
+        domain: domain,
+        local_workstation: local_workstation
+      )
+    end
+
+    it 'sets the max_buffer_size to MAX_BUFFER_SIZE' do
+      expect(client.max_buffer_size).to eq RubySMB::Client::MAX_BUFFER_SIZE
+    end
   end
 
   describe '#send_recv' do
@@ -56,7 +81,7 @@ RSpec.describe RubySMB::Client do
 
     before(:each) do
       expect(dispatcher).to receive(:send_packet).and_return(nil)
-      expect(dispatcher).to receive(:recv_packet).and_return("A")
+      expect(dispatcher).to receive(:recv_packet).and_return('A')
     end
 
     it 'checks the packet version' do
@@ -64,7 +89,7 @@ RSpec.describe RubySMB::Client do
       client.send_recv(smb1_request)
     end
 
-    it 'calls #smb1_sign if it is an SMB1 packet'  do
+    it 'calls #smb1_sign if it is an SMB1 packet' do
       expect(client).to receive(:smb1_sign).with(smb1_request).and_call_original
       client.send_recv(smb1_request)
     end
@@ -73,7 +98,6 @@ RSpec.describe RubySMB::Client do
       expect(client).to receive(:smb2_sign).with(smb2_request).and_call_original
       client.send_recv(smb2_request)
     end
-
   end
 
   describe '#login' do
@@ -83,39 +107,39 @@ RSpec.describe RubySMB::Client do
     end
 
     it 'defaults username to what was in the initializer' do
-      expect{ client.login }.to_not change(client, :username)
+      expect { client.login }.to_not change(client, :username)
     end
 
     it 'overrides username if it is passed as a parameter' do
-      expect{ client.login(username:'test') }.to change(client, :username).to('test')
+      expect { client.login(username: 'test') }.to change(client, :username).to('test')
     end
 
     it 'defaults password to what was in the initializer' do
-      expect{ client.login }.to_not change(client, :password)
+      expect { client.login }.to_not change(client, :password)
     end
 
     it 'overrides password if it is passed as a parameter' do
-      expect{ client.login(password:'test') }.to change(client, :password).to('test')
+      expect { client.login(password: 'test') }.to change(client, :password).to('test')
     end
 
     it 'defaults domain to what was in the initializer' do
-      expect{ client.login }.to_not change(client, :domain)
+      expect { client.login }.to_not change(client, :domain)
     end
 
     it 'overrides domain if it is passed as a parameter' do
-      expect{ client.login(domain:'test') }.to change(client, :domain).to('test')
+      expect { client.login(domain: 'test') }.to change(client, :domain).to('test')
     end
 
     it 'defaults local_workstation to what was in the initializer' do
-      expect{ client.login }.to_not change(client, :local_workstation)
+      expect { client.login }.to_not change(client, :local_workstation)
     end
 
     it 'overrides local_workstation if it is passed as a parameter' do
-      expect{ client.login(local_workstation:'test') }.to change(client, :local_workstation).to('test')
+      expect { client.login(local_workstation: 'test') }.to change(client, :local_workstation).to('test')
     end
 
     it 'initialises a new NTLM Client' do
-      expect{ client.login }.to change(client, :ntlm_client)
+      expect { client.login }.to change(client, :ntlm_client)
     end
 
     it 'calls negotiate after the setup' do
@@ -127,37 +151,129 @@ RSpec.describe RubySMB::Client do
       expect(client).to receive(:authenticate)
       client.login
     end
+  end
+
+  context 'NetBIOS Session Service' do
+    describe '#session_request' do
+      let(:called_name)     { '*SMBSERVER      ' }
+      let(:calling_name)    { "               \x00" }
+      let(:session_header)  { RubySMB::Nbss::SessionHeader.new }
+      let(:session_request) { RubySMB::Nbss::SessionRequest.new }
+
+      before :example do
+        allow(RubySMB::Nbss::SessionRequest).to receive(:new).and_return(session_request)
+        allow(dispatcher).to receive(:send_packet)
+        allow(dispatcher).to receive(:recv_packet).and_return(session_header.to_binary_s)
+      end
+
+      it 'requests a session for *SMBSERVER by default' do
+        expect(client).to receive(:nb_name_encode).with(called_name).once
+        expect(client).to receive(:nb_name_encode).with(calling_name).once
+        client.session_request
+      end
+
+      it 'requests a session for the provided name and the expected calling name' do
+        name = 'NBNAME'
+        called_name  = "#{name}          "
+
+        expect(client).to receive(:nb_name_encode).with(called_name).once
+        expect(client).to receive(:nb_name_encode).with(calling_name).once
+        client.session_request(name)
+      end
+
+      it 'makes NetBIOS name uppercase' do
+        name = 'nbNamE'
+        called_name = "#{name.upcase}          "
+
+        expect(client).to receive(:nb_name_encode).with(called_name).once
+        expect(client).to receive(:nb_name_encode).with(calling_name).once
+        client.session_request(name)
+      end
+
+      it 'creates a SessionRequest packet' do
+        expect(RubySMB::Nbss::SessionRequest).to receive(:new).and_return(session_request)
+        client.session_request
+      end
+
+      it 'sets the expected fields of the SessionRequest packet' do
+        encoded_called_name = "\x20#{client.nb_name_encode(called_name)}\x00"
+        encoded_calling_name = "\x20#{client.nb_name_encode(calling_name)}\x00"
+        allow(dispatcher).to receive(:send_packet) do |packet, _opts|
+          expect(packet).to be_a(RubySMB::Nbss::SessionRequest)
+          expect(packet.session_header.session_packet_type).to eq RubySMB::Nbss::SESSION_REQUEST
+          expect(packet.called_name).to eq encoded_called_name 
+          expect(packet.calling_name).to eq encoded_calling_name 
+          expect(packet.session_header.packet_length).to eq (encoded_called_name.size + encoded_calling_name.size)
+        end
+        client.session_request
+      end
+
+      it 'sends the SessionRequest packet without adding additional NetBIOS Session Header' do
+        expect(dispatcher).to receive(:send_packet).with(session_request, nbss_header: false)
+        client.session_request
+      end
+
+      it 'reads the full response packet, including the NetBIOS Session Header' do
+        expect(dispatcher).to receive(:recv_packet).with(full_response: true).and_return(session_header.to_binary_s)
+        client.session_request
+      end
+
+      it 'parses the response with SessionHeader packet structure' do
+        expect(RubySMB::Nbss::SessionHeader).to receive(:read).with(session_header.to_binary_s).and_return(session_header)
+        client.session_request
+      end
+
+      it 'returns true when it is a POSITIVE_SESSION_RESPONSE' do
+        session_header.session_packet_type = RubySMB::Nbss::POSITIVE_SESSION_RESPONSE
+        expect(client.session_request).to be true
+      end
+
+      it 'raises an exception when it is a NEGATIVE_SESSION_RESPONSE' do
+        negative_session_response = RubySMB::Nbss::NegativeSessionResponse.new
+        negative_session_response.session_header.session_packet_type = RubySMB::Nbss::NEGATIVE_SESSION_RESPONSE
+        negative_session_response.error_code = 0x80
+        allow(dispatcher).to receive(:recv_packet).and_return(negative_session_response.to_binary_s)
+        expect { client.session_request }.to raise_error(RubySMB::Error::NetBiosSessionService)
+      end
+    end
 
+    describe '#nb_name_encode' do
+      it 'encodes as expected' do
+        input = 'TESTNB          '
+        output = 'FEEFFDFEEOECCACACACACACACACACACA'
+        expect(client.nb_name_encode(input)).to eq output
+      end
+    end
   end
 
   context 'Protocol Negotiation' do
-    let(:random_junk) { "fgrgrwgawrtw4t4tg4gahgn" }
+    let(:random_junk) { 'fgrgrwgawrtw4t4tg4gahgn' }
     let(:smb1_capabilities) {
-      {:level_2_oplocks=>1,
-       :nt_status=>1,
-       :rpc_remote_apis=>1,
-       :nt_smbs=>1,
-       :large_files=>1,
-       :unicode=>1,
-       :mpx_mode=>0,
-       :raw_mode=>0,
-       :large_writex=>1,
-       :large_readx=>1,
-       :info_level_passthru=>1,
-       :dfs=>0,
-       :reserved1=>0,
-       :bulk_transfer=>0,
-       :nt_find=>1,
-       :lock_and_read=>1,
-       :unix=>0,
-       :reserved2=>0,
-       :lwio=>1,
-       :extended_security=>1,
-       :reserved3=>0,
-       :dynamic_reauth=>0,
-       :reserved4=>0,
-       :compressed_data=>0,
-       :reserved5=>0}
+      { level_2_oplocks: 1,
+        nt_status: 1,
+        rpc_remote_apis: 1,
+        nt_smbs: 1,
+        large_files: 1,
+        unicode: 1,
+        mpx_mode: 0,
+        raw_mode: 0,
+        large_writex: 1,
+        large_readx: 1,
+        info_level_passthru: 1,
+        dfs: 0,
+        reserved1: 0,
+        bulk_transfer: 0,
+        nt_find: 1,
+        lock_and_read: 1,
+        unix: 0,
+        reserved2: 0,
+        lwio: 1,
+        extended_security: 1,
+        reserved3: 0,
+        dynamic_reauth: 0,
+        reserved4: 0,
+        compressed_data: 0,
+        reserved5: 0 }
     }
     let(:smb1_extended_response) {
       packet = RubySMB::SMB1::Packet::NegotiateResponseExtended.new
@@ -176,19 +292,19 @@ RSpec.describe RubySMB::Client do
       end
 
       it 'sets the default SMB1 Dialect' do
-        expect(client.smb1_negotiate_request.dialects).to include({:buffer_format=>2, :dialect_string=> RubySMB::Client::SMB1_DIALECT_SMB1_DEFAULT})
+        expect(client.smb1_negotiate_request.dialects).to include(buffer_format: 2, dialect_string: RubySMB::Client::SMB1_DIALECT_SMB1_DEFAULT)
       end
 
       it 'sets the SMB2.02 dialect if SMB2 support is enabled' do
-        expect(client.smb1_negotiate_request.dialects).to include({:buffer_format=>2, :dialect_string=> RubySMB::Client::SMB1_DIALECT_SMB2_DEFAULT})
+        expect(client.smb1_negotiate_request.dialects).to include(buffer_format: 2, dialect_string: RubySMB::Client::SMB1_DIALECT_SMB2_DEFAULT)
       end
 
       it 'excludes the SMB2.02 Dialect if SMB2 support is disabled' do
-        expect(smb1_client.smb1_negotiate_request.dialects).to_not include({:buffer_format=>2, :dialect_string=> RubySMB::Client::SMB1_DIALECT_SMB2_DEFAULT})
+        expect(smb1_client.smb1_negotiate_request.dialects).to_not include(buffer_format: 2, dialect_string: RubySMB::Client::SMB1_DIALECT_SMB2_DEFAULT)
       end
 
       it 'excludes the default SMB1 Dialect if SMB1 support is disabled' do
-        expect(smb2_client.smb1_negotiate_request.dialects).to_not include({:buffer_format=>2, :dialect_string=> RubySMB::Client::SMB1_DIALECT_SMB1_DEFAULT})
+        expect(smb2_client.smb1_negotiate_request.dialects).to_not include(buffer_format: 2, dialect_string: RubySMB::Client::SMB1_DIALECT_SMB1_DEFAULT)
       end
     end
 
@@ -209,26 +325,18 @@ RSpec.describe RubySMB::Client do
     describe '#negotiate_request' do
       it 'calls #smb1_negotiate_request if SMB1 is enabled' do
         expect(smb1_client).to receive(:smb1_negotiate_request)
-        expect(smb1_client).to receive(:send_recv)
         smb1_client.negotiate_request
       end
 
       it 'calls #smb1_negotiate_request if both protocols are enabled' do
         expect(client).to receive(:smb1_negotiate_request)
-        expect(client).to receive(:send_recv)
         client.negotiate_request
       end
 
       it 'calls #smb2_negotiate_request if SMB2 is enabled' do
         expect(smb2_client).to receive(:smb2_negotiate_request)
-        expect(smb2_client).to receive(:send_recv)
         smb2_client.negotiate_request
       end
-
-      it 'returns the raw response string from the server' do
-        expect(client).to receive(:send_recv).and_return('A')
-        expect(client.negotiate_request).to eq "A"
-      end
     end
 
     describe '#negotiate_response' do
@@ -238,39 +346,39 @@ RSpec.describe RubySMB::Client do
         end
 
         it 'raises an exception if the Response is invalid' do
-          expect{ smb1_client.negotiate_response(random_junk) }.to raise_error(RubySMB::Error::InvalidPacket)
+          expect { smb1_client.negotiate_response(random_junk) }.to raise_error(RubySMB::Error::InvalidPacket)
         end
 
         it 'considers the response invalid if it is not an actual Negotiate Response' do
           bogus_response = smb1_extended_response
           bogus_response.smb_header.command = 0xff
-          expect{ smb1_client.negotiate_response(bogus_response.to_binary_s) }.to raise_error(RubySMB::Error::InvalidPacket)
+          expect { smb1_client.negotiate_response(bogus_response.to_binary_s) }.to raise_error(RubySMB::Error::InvalidPacket)
         end
 
         it 'considers the response invalid if Extended Security is not enabled' do
           bogus_response = smb1_extended_response
           bogus_response.parameter_block.capabilities.extended_security = 0
-          expect{ smb1_client.negotiate_response(bogus_response.to_binary_s) }.to raise_error(RubySMB::Error::InvalidPacket)
+          expect { smb1_client.negotiate_response(bogus_response.to_binary_s) }.to raise_error(RubySMB::Error::InvalidPacket)
         end
       end
 
       context 'with only SMB2' do
         it 'returns a properly formed packet' do
-          expect( smb2_client.negotiate_response(smb2_response.to_binary_s) ).to eq smb2_response
+          expect(smb2_client.negotiate_response(smb2_response.to_binary_s)).to eq smb2_response
         end
 
         it 'raises an exception if the Response is invalid' do
-          expect{ smb2_client.negotiate_response(random_junk) }.to raise_error(RubySMB::Error::InvalidPacket)
+          expect { smb2_client.negotiate_response(random_junk) }.to raise_error(RubySMB::Error::InvalidPacket)
         end
       end
 
       context 'with SMB1 and SMB2 enabled' do
         it 'returns an SMB1 NegotiateResponse if it looks like SMB1' do
-          expect( client.negotiate_response(smb1_extended_response_raw) ).to eq smb1_extended_response
+          expect(client.negotiate_response(smb1_extended_response_raw)).to eq smb1_extended_response
         end
 
         it 'returns an SMB2 NegotiateResponse if it looks like SMB2' do
-          expect( client.negotiate_response(smb2_response.to_binary_s) ).to eq smb2_response
+          expect(client.negotiate_response(smb2_response.to_binary_s)).to eq smb2_response
         end
       end
     end
@@ -279,7 +387,7 @@ RSpec.describe RubySMB::Client do
       context 'when SMB1 was Negotiated' do
         it 'turns off SMB2 support' do
           client.parse_negotiate_response(smb1_extended_response)
-          expect( client.smb2 ).to be false
+          expect(client.smb2).to be false
         end
 
         it 'sets whether or not signing is required' do
@@ -287,12 +395,27 @@ RSpec.describe RubySMB::Client do
           client.parse_negotiate_response(smb1_extended_response)
           expect(client.signing_required).to be true
         end
+
+        it 'sets #dialect to the negotiated dialect' do
+          smb1_extended_response.dialects = [
+            RubySMB::SMB1::Dialect.new(dialect_string: 'A'),
+            RubySMB::SMB1::Dialect.new(dialect_string: 'B'),
+            RubySMB::SMB1::Dialect.new(dialect_string: 'C'),
+          ]
+          smb1_extended_response.parameter_block.dialect_index = 1
+          client.parse_negotiate_response(smb1_extended_response)
+          expect(client.dialect).to eq 'B'
+        end
+
+        it 'returns the string \'SMB1\'' do
+          expect(client.parse_negotiate_response(smb1_extended_response)).to eq ('SMB1')
+        end
       end
 
       context 'when SMB2 was negotiated' do
         it 'turns off SMB1 support' do
           client.parse_negotiate_response(smb2_response)
-          expect( client.smb1 ).to be false
+          expect(client.smb1).to be false
         end
 
         it 'sets whether or not signing is required' do
@@ -300,25 +423,50 @@ RSpec.describe RubySMB::Client do
           client.parse_negotiate_response(smb2_response)
           expect(client.signing_required).to be true
         end
+
+        it 'sets #dialect to the negotiated dialect' do
+          smb2_response.dialect_revision = 2
+          client.parse_negotiate_response(smb2_response)
+          expect(client.dialect).to eq '0x0002'
+        end
+
+        it 'returns the string \'SMB2\'' do
+          expect(client.parse_negotiate_response(smb2_response)).to eq ('SMB2')
+        end
       end
     end
 
     describe '#negotiate' do
       it 'calls the backing methods' do
         expect(client).to receive(:negotiate_request)
+        expect(client).to receive(:send_recv)
         expect(client).to receive(:negotiate_response)
         expect(client).to receive(:parse_negotiate_response)
         client.negotiate
       end
+
+      it 'sets the response-packet #dialects array with the dialects sent in the request' do
+        request_packet = client.smb1_negotiate_request
+        allow(client).to receive(:negotiate_request).and_return(request_packet)
+        allow(client).to receive(:send_recv)
+        allow(client).to receive(:negotiate_response).and_return(smb1_extended_response)
+        expect(smb1_extended_response).to receive(:dialects=).with(request_packet.dialects)
+        client.negotiate
+      end
+
+      it 'raise the expected exception if an error occurs' do
+        allow(client).to receive(:send_recv).and_raise(RubySMB::Error::InvalidPacket)
+        expect { client.negotiate }.to raise_error(RubySMB::Error::NegotiationFailure)
+      end
     end
   end
 
   context 'Authentication' do
     let(:type2_string) {
-      "TlRMTVNTUAACAAAAHgAeADgAAAA1goriwmZ8HEHtFHAAAAAAAAAAAJgAmABW\nAAAABgGxHQAAAA" +
-        "9XAEkATgAtAFMATgBKAEQARwAwAFUAQQA5ADAARgACAB4A\nVwBJAE4ALQBTAE4ASgBEAEcAMABV" +
-        "AEEAOQAwAEYAAQAeAFcASQBOAC0AUwBO\nAEoARABHADAAVQBBADkAMABGAAQAHgBXAEkATgAtAF" +
-        "MATgBKAEQARwAwAFUA\nQQA5ADAARgADAB4AVwBJAE4ALQBTAE4ASgBEAEcAMABVAEEAOQAwAEYABw" +
+      "TlRMTVNTUAACAAAAHgAeADgAAAA1goriwmZ8HEHtFHAAAAAAAAAAAJgAmABW\nAAAABgGxHQAAAA" \
+        "9XAEkATgAtAFMATgBKAEQARwAwAFUAQQA5ADAARgACAB4A\nVwBJAE4ALQBTAE4ASgBEAEcAMABV" \
+        "AEEAOQAwAEYAAQAeAFcASQBOAC0AUwBO\nAEoARABHADAAVQBBADkAMABGAAQAHgBXAEkATgAtAF" \
+        "MATgBKAEQARwAwAFUA\nQQA5ADAARgADAB4AVwBJAE4ALQBTAE4ASgBEAEcAMABVAEEAOQAwAEYABw" \
         "AI\nADxThZ4nnNIBAAAAAA==\n"
     }
 
@@ -342,28 +490,89 @@ RSpec.describe RubySMB::Client do
     end
 
     context 'for SMB1' do
-      let(:ntlm_client)  { smb1_client.ntlm_client }
-      let(:type1_message)  { ntlm_client.init_context }
+      let(:ntlm_client) { smb1_client.ntlm_client }
+      let(:type1_message) { ntlm_client.init_context }
       let(:negotiate_packet) { RubySMB::SMB1::Packet::SessionSetupRequest.new }
+      let(:response_packet) { RubySMB::SMB1::Packet::SessionSetupResponse.new }
+      let(:final_response_packet) { RubySMB::SMB1::Packet::SessionSetupResponse.new }
       let(:type3_message) { ntlm_client.init_context(type2_string) }
       let(:user_id) { 2041 }
 
+      describe '#smb1_authenticate' do
+        before :example do
+          allow(smb1_client).to receive(:smb1_ntlmssp_negotiate)
+          allow(smb1_client).to receive(:smb1_ntlmssp_challenge_packet).and_return(response_packet)
+          allow(smb1_client).to receive(:smb1_type2_message).and_return(type2_string)
+          allow(smb1_client).to receive(:smb1_ntlmssp_authenticate)
+          allow(smb1_client).to receive(:smb1_ntlmssp_final_packet).and_return(final_response_packet)
+        end
+
+        it 'calls the backing methods' do
+          response_packet.smb_header.uid = user_id
+          expect(smb1_client).to receive(:smb1_ntlmssp_negotiate).and_return(negotiate_packet)
+          expect(smb1_client).to receive(:smb1_ntlmssp_challenge_packet).with(negotiate_packet).and_return(response_packet)
+          expect(smb1_client).to receive(:smb1_type2_message).with(response_packet).and_return(type2_string)
+          expect(smb1_client).to receive(:store_target_info).with(String)
+          expect(smb1_client).to receive(:extract_os_version).with(String)
+          expect(smb1_client).to receive(:smb1_ntlmssp_authenticate).with(Net::NTLM::Message::Type3, user_id)
+          expect(smb1_client).to receive(:smb1_ntlmssp_final_packet).and_return(final_response_packet)
+          smb1_client.smb1_authenticate
+        end
+
+        it 'stores the OS information from the challenge packet' do
+          native_os = 'Windows 7 Professional 7601 Service Pack 1'
+          native_lm = 'Windows 7 Professional 6.1'
+          response_packet.data_block.native_os = native_os
+          response_packet.data_block.native_lan_man = native_lm
+          smb1_client.smb1_authenticate
+
+          expect(smb1_client.peer_native_os).to eq native_os
+          expect(smb1_client.peer_native_lm).to eq native_lm
+        end
+
+        it 'stores the session key from the NTLM client' do
+          smb1_client.smb1_authenticate
+          expect(smb1_client.session_key).to eq ntlm_client.session_key
+        end
+
+        it 'stores the OS version number from the challenge message' do
+          smb1_client.smb1_authenticate
+          expect(smb1_client.os_version).to eq '6.1.7601'
+        end
+
+        it 'stores the user ID if the status code is \'STATUS_SUCCESS\'' do
+          response_packet.smb_header.uid = user_id
+          final_response_packet.smb_header.nt_status = WindowsError::NTStatus::STATUS_SUCCESS.value
+          smb1_client.smb1_authenticate
+          expect(smb1_client.user_id).to eq user_id
+        end
+
+        it 'does not store the user ID if the status code is not \'STATUS_SUCCESS\'' do
+          response_packet.smb_header.uid = user_id
+          final_response_packet.smb_header.nt_status = WindowsError::NTStatus::STATUS_PENDING.value
+          smb1_client.smb1_authenticate
+          expect(smb1_client.user_id).to eq nil
+        end
+      end
 
       describe '#smb1_ntlmssp_auth_packet' do
         it 'creates a new SessionSetupRequest packet' do
           expect(RubySMB::SMB1::Packet::SessionSetupRequest).to receive(:new).and_return(negotiate_packet)
-          smb1_client.smb1_ntlmssp_auth_packet(type2_string, user_id)
+          smb1_client.smb1_ntlmssp_auth_packet(type3_message, user_id)
         end
 
-        it 'builds the security blob with an NTLM Type 3 Message' do
+        it 'sets the security blob with an NTLM Type 3 Message' do
           expect(RubySMB::SMB1::Packet::SessionSetupRequest).to receive(:new).and_return(negotiate_packet)
-          expect(ntlm_client).to receive(:init_context).with(type2_string).and_return(type3_message)
           expect(negotiate_packet).to receive(:set_type3_blob).with(type3_message.serialize)
-          smb1_client.smb1_ntlmssp_auth_packet(type2_string, user_id)
+          smb1_client.smb1_ntlmssp_auth_packet(type3_message, user_id)
         end
 
         it 'enables extended security on the packet' do
-          expect(smb1_client.smb1_ntlmssp_auth_packet(type2_string, user_id).smb_header.flags2.extended_security).to eq 1
+          expect(smb1_client.smb1_ntlmssp_auth_packet(type3_message, user_id).smb_header.flags2.extended_security).to eq 1
+        end
+
+        it 'sets the max_buffer_size to the client\'s max_buffer_size' do
+          expect(smb1_client.smb1_ntlmssp_auth_packet(type3_message, user_id).parameter_block.max_buffer_size).to eq smb1_client.max_buffer_size
         end
       end
 
@@ -383,6 +592,10 @@ RSpec.describe RubySMB::Client do
         it 'enables extended security on the packet' do
           expect(smb1_client.smb1_ntlmssp_negotiate_packet.smb_header.flags2.extended_security).to eq 1
         end
+
+        it 'sets the max_buffer_size to the client\'s max_buffer_size' do
+          expect(smb1_client.smb1_ntlmssp_negotiate_packet.parameter_block.max_buffer_size).to eq smb1_client.max_buffer_size
+        end
       end
 
       describe '#smb1_ntlmssp_authenticate' do
@@ -390,7 +603,7 @@ RSpec.describe RubySMB::Client do
           expect(smb1_client).to receive(:smb1_ntlmssp_auth_packet).and_return(negotiate_packet)
           expect(dispatcher).to receive(:send_packet).with(negotiate_packet)
           expect(dispatcher).to receive(:recv_packet)
-          smb1_client.smb1_ntlmssp_authenticate(type2_string, user_id)
+          smb1_client.smb1_ntlmssp_authenticate(type3_message, user_id)
         end
       end
 
@@ -421,11 +634,11 @@ RSpec.describe RubySMB::Client do
 
         it 'raises an UnexpectedStatusCode if the status code is not correct' do
           response.smb_header.nt_status = 0xc0000015
-          expect{ smb1_client.smb1_ntlmssp_challenge_packet(response.to_binary_s) }.to raise_error( RubySMB::Error::UnexpectedStatusCode)
+          expect { smb1_client.smb1_ntlmssp_challenge_packet(response.to_binary_s) }.to raise_error(RubySMB::Error::UnexpectedStatusCode)
         end
 
         it 'raises an InvalidPacket if the Command field is wrong' do
-          expect{ smb1_client.smb1_ntlmssp_challenge_packet(wrong_command.to_binary_s) }.to raise_error(RubySMB::Error::InvalidPacket)
+          expect { smb1_client.smb1_ntlmssp_challenge_packet(wrong_command.to_binary_s) }.to raise_error(RubySMB::Error::InvalidPacket)
         end
       end
 
@@ -446,12 +659,12 @@ RSpec.describe RubySMB::Client do
         end
 
         it 'raises an InvalidPacket if the Command field is wrong' do
-          expect{ smb1_client.smb1_ntlmssp_final_packet(wrong_command.to_binary_s) }.to raise_error(RubySMB::Error::InvalidPacket)
+          expect { smb1_client.smb1_ntlmssp_final_packet(wrong_command.to_binary_s) }.to raise_error(RubySMB::Error::InvalidPacket)
         end
       end
 
       describe '#smb1_type2_message' do
-        let(:fake_type2) { "NTLMSSP FOO" }
+        let(:fake_type2) { 'NTLMSSP FOO' }
         let(:response_packet) {
           packet = RubySMB::SMB1::Packet::SessionSetupResponse.new
           packet.set_type2_blob(fake_type2)
@@ -466,10 +679,50 @@ RSpec.describe RubySMB::Client do
         let(:anonymous_request) { RubySMB::SMB1::Packet::SessionSetupLegacyRequest.new }
         let(:anonymous_response) { RubySMB::SMB1::Packet::SessionSetupLegacyResponse.new }
 
+        describe '#smb1_anonymous_auth' do
+          it 'calls the backing methods' do
+            expect(client).to receive(:smb1_anonymous_auth_request).and_return(anonymous_request)
+            expect(client).to receive(:send_recv).with(anonymous_request)
+            expect(client).to receive(:smb1_anonymous_auth_response).and_return(anonymous_response)
+            client.smb1_anonymous_auth
+          end
+
+          it 'returns the status code' do
+            allow(client).to receive(:send_recv)
+            allow(client).to receive(:smb1_anonymous_auth_response).and_return(anonymous_response)
+            anonymous_response.smb_header.nt_status = WindowsError::NTStatus::STATUS_PENDING.value
+            expect(client.smb1_anonymous_auth).to eq WindowsError::NTStatus::STATUS_PENDING
+          end
+
+          it 'sets the expected Client\'s attribute from the response when the status code is STATUS_SUCCESS' do
+            native_os = 'Windows 7 Professional 7601 Service Pack 1'
+            native_lm = 'Windows 7 Professional 6.1'
+            primary_domain = 'SPEC_DOMAIN'
+            anonymous_response.smb_header.uid = user_id
+            anonymous_response.data_block.native_os = native_os
+            anonymous_response.data_block.native_lan_man = native_lm
+            anonymous_response.data_block.primary_domain = primary_domain
+            anonymous_response.smb_header.nt_status = WindowsError::NTStatus::STATUS_SUCCESS.value
+
+            allow(client).to receive(:send_recv)
+            allow(client).to receive(:smb1_anonymous_auth_response).and_return(anonymous_response)
+
+            client.smb1_anonymous_auth
+            expect(client.user_id).to eq user_id
+            expect(client.peer_native_os).to eq native_os
+            expect(client.peer_native_lm).to eq native_lm
+            expect(client.primary_domain).to eq primary_domain
+          end
+        end
+
         describe '#smb1_anonymous_auth_request' do
           it 'creates a SessionSetupLegacyRequest packet with a null byte for the oem password' do
             expect(smb1_client.smb1_anonymous_auth_request.data_block.oem_password).to eq "\x00"
           end
+
+          it 'creates a SessionSetupLegacyRequest packet with the max_buffer_size set to the client\'s max_buffer_size' do
+            expect(smb1_client.smb1_anonymous_auth_request.parameter_block.max_buffer_size).to eq smb1_client.max_buffer_size
+          end
         end
 
         describe '#smb1_anonymous_auth_response' do
@@ -484,20 +737,59 @@ RSpec.describe RubySMB::Client do
 
           it 'raises an InvalidPacket error if the command is wrong' do
             anonymous_response.smb_header.command = RubySMB::SMB1::Commands::SMB_COM_NEGOTIATE
-            expect{ smb1_client.smb1_anonymous_auth_response(anonymous_response.to_binary_s) }.to raise_error(RubySMB::Error::InvalidPacket)
+            expect { smb1_client.smb1_anonymous_auth_response(anonymous_response.to_binary_s) }.to raise_error(RubySMB::Error::InvalidPacket)
           end
         end
-
       end
     end
 
     context 'for SMB2' do
       let(:ntlm_client) { smb2_client.ntlm_client }
-      let(:type1_message)  { ntlm_client.init_context }
+      let(:type1_message) { ntlm_client.init_context }
       let(:negotiate_packet) { RubySMB::SMB2::Packet::SessionSetupRequest.new }
+      let(:response_packet) { RubySMB::SMB2::Packet::SessionSetupResponse.new }
+      let(:final_response_packet) { RubySMB::SMB2::Packet::SessionSetupResponse.new }
       let(:type3_message) { ntlm_client.init_context(type2_string) }
       let(:session_id) { 0x0000040000000005 }
 
+      describe '#smb2_authenticate' do
+        before :example do
+          allow(smb2_client).to receive(:smb2_ntlmssp_negotiate)
+          allow(smb2_client).to receive(:smb2_ntlmssp_challenge_packet).and_return(response_packet)
+          allow(smb2_client).to receive(:smb2_type2_message).and_return(type2_string)
+          allow(smb2_client).to receive(:smb2_ntlmssp_authenticate)
+          allow(smb2_client).to receive(:smb2_ntlmssp_final_packet).and_return(final_response_packet)
+        end
+
+        it 'calls the backing methods' do
+          response_packet.smb2_header.session_id = session_id
+          expect(smb2_client).to receive(:smb2_ntlmssp_negotiate).and_return(negotiate_packet)
+          expect(smb2_client).to receive(:smb2_ntlmssp_challenge_packet).with(negotiate_packet).and_return(response_packet)
+          expect(smb2_client).to receive(:smb2_type2_message).with(response_packet).and_return(type2_string)
+          expect(smb2_client).to receive(:store_target_info).with(String)
+          expect(smb2_client).to receive(:extract_os_version).with(String)
+          expect(smb2_client).to receive(:smb2_ntlmssp_authenticate).with(Net::NTLM::Message::Type3, session_id)
+          expect(smb2_client).to receive(:smb2_ntlmssp_final_packet).and_return(final_response_packet)
+          smb2_client.smb2_authenticate
+        end
+
+        it 'stores the session ID from the challenge message' do
+          response_packet.smb2_header.session_id = session_id
+          smb2_client.smb2_authenticate
+          expect(smb2_client.session_id).to eq session_id
+        end
+
+        it 'stores the session key from the NTLM client' do
+          smb2_client.smb2_authenticate
+          expect(smb2_client.session_key).to eq ntlm_client.session_key
+        end
+
+        it 'stores the OS version number from the challenge message' do
+          smb2_client.smb2_authenticate
+          expect(smb2_client.os_version).to eq '6.1.7601'
+        end
+      end
+
       describe '#smb2_ntlmssp_negotiate_packet' do
         it 'creates a new SessionSetupRequest packet' do
           expect(RubySMB::SMB2::Packet::SessionSetupRequest).to receive(:new).and_return(negotiate_packet)
@@ -516,7 +808,7 @@ RSpec.describe RubySMB::Client do
         end
 
         it 'increments client#smb2_message_id' do
-          expect{ smb2_client.smb2_ntlmssp_negotiate_packet }.to change(smb2_client, :smb2_message_id).to(2)
+          expect { smb2_client.smb2_ntlmssp_negotiate_packet }.to change(smb2_client, :smb2_message_id).to(2)
         end
       end
 
@@ -547,16 +839,16 @@ RSpec.describe RubySMB::Client do
 
         it 'raises an UnexpectedStatusCode if the status code is not correct' do
           response.smb2_header.nt_status = 0xc0000015
-          expect{ smb2_client.smb2_ntlmssp_challenge_packet(response.to_binary_s) }.to raise_error( RubySMB::Error::UnexpectedStatusCode)
+          expect { smb2_client.smb2_ntlmssp_challenge_packet(response.to_binary_s) }.to raise_error(RubySMB::Error::UnexpectedStatusCode)
         end
 
         it 'raises an InvalidPacket if the Command field is wrong' do
-          expect{ smb2_client.smb2_ntlmssp_challenge_packet(wrong_command.to_binary_s) }.to raise_error(RubySMB::Error::InvalidPacket)
+          expect { smb2_client.smb2_ntlmssp_challenge_packet(wrong_command.to_binary_s) }.to raise_error(RubySMB::Error::InvalidPacket)
         end
       end
 
       describe '#smb2_type2_message' do
-        let(:fake_type2) { "NTLMSSP FOO" }
+        let(:fake_type2) { 'NTLMSSP FOO' }
         let(:response_packet) {
           packet = RubySMB::SMB2::Packet::SessionSetupResponse.new
           packet.set_type2_blob(fake_type2)
@@ -567,23 +859,21 @@ RSpec.describe RubySMB::Client do
         end
       end
 
-      describe '#smb1_ntlmssp_auth_packet' do
+      describe '#smb2_ntlmssp_auth_packet' do
         it 'creates a new SessionSetupRequest packet' do
           expect(RubySMB::SMB2::Packet::SessionSetupRequest).to receive(:new).and_return(negotiate_packet)
-          smb2_client.smb2_ntlmssp_auth_packet(type2_string, session_id)
+          smb2_client.smb2_ntlmssp_auth_packet(type3_message, session_id)
         end
 
-        it 'builds the security blob with an NTLM Type 3 Message' do
+        it 'sets the security blob with an NTLM Type 3 Message' do
           expect(RubySMB::SMB2::Packet::SessionSetupRequest).to receive(:new).and_return(negotiate_packet)
-          expect(ntlm_client).to receive(:init_context).with(type2_string).and_return(type3_message)
           expect(negotiate_packet).to receive(:set_type3_blob).with(type3_message.serialize)
-          smb2_client.smb2_ntlmssp_auth_packet(type2_string, session_id)
+          smb2_client.smb2_ntlmssp_auth_packet(type3_message, session_id)
         end
 
         it 'sets the session ID on the request packet' do
-          expect(smb2_client.smb2_ntlmssp_auth_packet(type2_string, session_id).smb2_header.session_id).to eq session_id
+          expect(smb2_client.smb2_ntlmssp_auth_packet(type3_message, session_id).smb2_header.session_id).to eq session_id
         end
-
       end
 
       describe '#smb2_ntlmssp_authenticate' do
@@ -591,7 +881,7 @@ RSpec.describe RubySMB::Client do
           expect(smb2_client).to receive(:smb2_ntlmssp_auth_packet).and_return(negotiate_packet)
           expect(dispatcher).to receive(:send_packet).with(negotiate_packet)
           expect(dispatcher).to receive(:recv_packet)
-          smb2_client.smb2_ntlmssp_authenticate(type2_string, session_id)
+          smb2_client.smb2_ntlmssp_authenticate(type3_message, session_id)
         end
       end
 
@@ -612,10 +902,50 @@ RSpec.describe RubySMB::Client do
         end
 
         it 'raises an InvalidPacket if the Command field is wrong' do
-          expect{ smb2_client.smb2_ntlmssp_final_packet(wrong_command.to_binary_s) }.to raise_error(RubySMB::Error::InvalidPacket)
+          expect { smb2_client.smb2_ntlmssp_final_packet(wrong_command.to_binary_s) }.to raise_error(RubySMB::Error::InvalidPacket)
         end
       end
     end
+
+    describe '#store_target_info' do
+      let(:target_info_str) { "\x02\x00\x14\x00T\x00E\x00S\x00T\x00D\x00O\x00M"\
+        "\x00A\x00I\x00N\x00\x01\x00\x10\x00T\x00E\x00S\x00T\x00N\x00A\x00M"\
+        "\x00E\x00\x04\x00 \x00t\x00e\x00s\x00t\x00d\x00o\x00m\x00a\x00i\x00"\
+        "n\x00.\x00l\x00o\x00c\x00a\x00l\x00\x03\x002\x00t\x00e\x00s\x00t\x00"\
+        "n\x00a\x00m\x00e\x00.\x00t\x00e\x00s\x00t\x00d\x00o\x00m\x00a\x00i"\
+        "\x00n\x00.\x00l\x00o\x00c\x00a\x00l\x00\x05\x00 \x00t\x00e\x00s\x00t"\
+        "\x00f\x00o\x00r\x00e\x00s\x00t\x00.\x00l\x00o\x00c\x00a\x00l\x00\a"\
+        "\x00\b\x00Q7w\x01Fh\xD3\x01\x00\x00\x00\x00" }
+
+      it 'creates a Net::NTLM::TargetInfo object from the target_info string' do
+        expect(Net::NTLM::TargetInfo).to receive(:new).with(target_info_str).and_call_original
+        client.store_target_info(target_info_str)
+      end
+
+      it 'sets the expected Client\'s attribute' do
+        client.store_target_info(target_info_str)
+        expect(client.default_name).to eq 'TESTNAME'
+        expect(client.default_domain).to eq 'TESTDOMAIN'
+        expect(client.dns_host_name).to eq 'testname.testdomain.local'
+        expect(client.dns_domain_name).to eq 'testdomain.local'
+        expect(client.dns_tree_name).to eq 'testforest.local'
+      end
+
+      it 'stores the strings with UTF-8 encoding' do
+        client.store_target_info(target_info_str)
+        expect(client.default_name.encoding.name).to eq 'UTF-8'
+        expect(client.default_domain.encoding.name).to eq 'UTF-8'
+        expect(client.dns_host_name.encoding.name).to eq 'UTF-8'
+        expect(client.dns_domain_name.encoding.name).to eq 'UTF-8'
+        expect(client.dns_tree_name.encoding.name).to eq 'UTF-8'
+      end
+    end
+
+    describe '#extract_os_version' do
+      it 'returns the expected version number' do
+        expect(client.extract_os_version("\x06\x00q\x17\x00\x00\x00\x0F")).to eq '6.0.6001'
+      end
+    end
   end
 
   context 'Signing' do
@@ -626,13 +956,13 @@ RSpec.describe RubySMB::Client do
         packet.smb2_header.signature = "\x00" * 16
         packet
       }
-      let(:fake_hmac) { "\x31\x07\x78\x3e\x35\xd7\x0e\x89\x08\x43\x8a\x18\xcd\x78\x52\x39".force_encoding("ASCII-8BIT") }
+      let(:fake_hmac) { "\x31\x07\x78\x3e\x35\xd7\x0e\x89\x08\x43\x8a\x18\xcd\x78\x52\x39".force_encoding('ASCII-8BIT') }
 
       context 'if signing is required and we have a session key' do
         it 'generates the HMAC based on the packet and the NTLM session key and signs the packet with it' do
           smb2_client.session_key = 'foo'
           smb2_client.signing_required = true
-          expect(OpenSSL::HMAC).to receive(:digest).with(instance_of(OpenSSL::Digest::SHA256),smb2_client.session_key,request1.to_binary_s).and_return(fake_hmac)
+          expect(OpenSSL::HMAC).to receive(:digest).with(instance_of(OpenSSL::Digest::SHA256), smb2_client.session_key, request1.to_binary_s).and_return(fake_hmac)
           expect(smb2_client.smb2_sign(request1).smb2_header.signature).to eq fake_hmac
         end
       end
@@ -652,12 +982,11 @@ RSpec.describe RubySMB::Client do
           expect(smb2_client.smb2_sign(request1)).to eq request1
         end
       end
-
     end
 
     describe '#smb1_sign' do
       let(:request1) { RubySMB::SMB1::Packet::SessionSetupRequest.new }
-      let(:fake_sig) { "\x9f\x62\xcf\x08\xd9\xc2\x83\x21".force_encoding("ASCII-8BIT") }
+      let(:fake_sig) { "\x9f\x62\xcf\x08\xd9\xc2\x83\x21".force_encoding('ASCII-8BIT') }
 
       context 'if signing is required and we have a session key' do
         it 'generates the signature based on the packet, the sequence counter and the NTLM session key and signs the packet with it' do
@@ -685,7 +1014,7 @@ RSpec.describe RubySMB::Client do
           smb1_client.signing_required = true
           expect(smb1_client.smb1_sign(request1)).to eq request1
         end
-       end
+      end
     end
   end
 
@@ -699,7 +1028,7 @@ RSpec.describe RubySMB::Client do
 
     it 'increments the client message id' do
       client.smb2_message_id = 1
-      expect{ client.increment_smb_message_id(request_packet) }.to change{ client.smb2_message_id}.by(1)
+      expect { client.increment_smb_message_id(request_packet) }.to change { client.smb2_message_id }.by(1)
     end
   end
 
@@ -735,23 +1064,23 @@ RSpec.describe RubySMB::Client do
       describe '#smb1_tree_from_response' do
         it 'raises an InvalidPacket exception if the command is not TREE_CONNECT' do
           response.smb_header.command = RubySMB::SMB1::Commands::SMB_COM_NEGOTIATE
-          expect{ smb1_client.smb1_tree_from_response(path,response) }.to raise_error(RubySMB::Error::InvalidPacket)
+          expect { smb1_client.smb1_tree_from_response(path, response) }.to raise_error(RubySMB::Error::InvalidPacket)
         end
 
         it 'raises an UnexpectedStatusCode exception if we do not get STATUS_SUCCESS' do
           response.smb_header.nt_status = 0xc0000015
-          expect{ smb1_client.smb1_tree_from_response(path,response) }.to raise_error(RubySMB::Error::UnexpectedStatusCode, 'STATUS_NONEXISTENT_SECTOR')
+          expect { smb1_client.smb1_tree_from_response(path, response) }.to raise_error(RubySMB::Error::UnexpectedStatusCode, 'STATUS_NONEXISTENT_SECTOR')
         end
 
         it 'creates a new Tree from itself, the share path, and the response packet' do
-          expect(RubySMB::SMB1::Tree).to receive(:new).with(client:smb1_client, share:path, response:response)
-          smb1_client.smb1_tree_from_response(path,response)
+          expect(RubySMB::SMB1::Tree).to receive(:new).with(client: smb1_client, share: path, response: response)
+          smb1_client.smb1_tree_from_response(path, response)
         end
       end
     end
 
     context 'with SMB2' do
-      let(:request) { RubySMB::SMB2::Packet::TreeConnectRequest.new  }
+      let(:request) { RubySMB::SMB2::Packet::TreeConnectRequest.new }
       let(:response) {
         packet = RubySMB::SMB2::Packet::TreeConnectResponse.new
         packet.smb2_header.tree_id = tree_id
@@ -779,20 +1108,28 @@ RSpec.describe RubySMB::Client do
       describe '#smb2_tree_from_response' do
         it 'raises an InvalidPacket exception if the command is not TREE_CONNECT' do
           response.smb2_header.command = RubySMB::SMB2::Commands::NEGOTIATE
-          expect{ smb2_client.smb2_tree_from_response(path,response) }.to raise_error(RubySMB::Error::InvalidPacket)
+          expect { smb2_client.smb2_tree_from_response(path, response) }.to raise_error(RubySMB::Error::InvalidPacket)
         end
 
         it 'raises an UnexpectedStatusCode exception if we do not get STATUS_SUCCESS' do
           response.smb2_header.nt_status = 0xc0000015
-          expect{ smb2_client.smb2_tree_from_response(path,response) }.to raise_error(RubySMB::Error::UnexpectedStatusCode, 'STATUS_NONEXISTENT_SECTOR')
+          expect { smb2_client.smb2_tree_from_response(path, response) }.to raise_error(RubySMB::Error::UnexpectedStatusCode, 'STATUS_NONEXISTENT_SECTOR')
         end
 
         it 'creates a new Tree from itself, the share path, and the response packet' do
-          expect(RubySMB::SMB2::Tree).to receive(:new).with(client:smb2_client, share:path, response:response)
-          smb2_client.smb2_tree_from_response(path,response)
+          expect(RubySMB::SMB2::Tree).to receive(:new).with(client: smb2_client, share: path, response: response)
+          smb2_client.smb2_tree_from_response(path, response)
         end
       end
 
+      describe '#net_share_enum_all' do
+        let(:shares){{}}
+
+        it 'it calls the smb2 method' do
+          expect(smb2_client).to receive(:smb2_net_share_enum_all).with(sock.peeraddr).and_return(shares)
+          smb2_client.net_share_enum_all(sock.peeraddr)
+        end
+      end
     end
   end
 
@@ -819,9 +1156,9 @@ RSpec.describe RubySMB::Client do
 
       it 'sets the data on the request packet' do
         modified_request = echo_request
-        modified_request.data_block.data = "DEADBEEF"
+        modified_request.data_block.data = 'DEADBEEF'
         expect(smb1_client).to receive(:send_recv).with(modified_request).and_return(echo_response.to_binary_s)
-        smb1_client.smb1_echo(data: "DEADBEEF")
+        smb1_client.smb1_echo(data: 'DEADBEEF')
       end
 
       it 'returns the NT status code' do
@@ -841,4 +1178,6 @@ RSpec.describe RubySMB::Client do
       end
     end
   end
-end
+
+end
+