ruby_smb 3.0.0 → 3.0.1

data/lib/ruby_smb/smb_error.rb

@@ -0,0 +1,110 @@
+require 'windows_error'
+
+module RubySMB
+  # SMB Error codes as defined in
+  # [2.2.2.4 SMB Error Classes and Codes](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-smb/6ab6ca20-b404-41fd-b91a-2ed39e3762ea)
+  module SMBError
+    # Returns all the {WindowsError::ErrorCode} objects that match
+    # the return value supplied.
+    #
+    # @param [Integer] retval the return value you want the error code for
+    # @raise [ArgumentError] if something other than a Integer is supplied
+    # @return [Array<WindowsError::ErrorCode>] all Win32 ErrorCodes that matched
+    def self.find_by_retval(retval)
+      raise ArgumentError, "Invalid Return Code!" unless retval.kind_of? Integer
+      error_codes = []
+      self.constants.each do |constant_name|
+        error_code = self.const_get(constant_name)
+        if error_code == retval
+          error_codes << error_code
+        end
+      end
+      error_codes
+    end
+
+    #
+    # CONSTANTS
+    #
+
+    # (0x00000000) The client request is successful.
+    STATUS_SUCCESS = WindowsError::ErrorCode.new('STATUS_SUCCESS', 0x00000000, 'The client request is successful.')
+
+    # (0x00010002) An invalid SMB client request is received by the server.
+    STATUS_INVALID_SMB = WindowsError::ErrorCode.new('STATUS_INVALID_SMB', 0x00010002, 'An invalid SMB client request is received by the server.')
+
+    # (0x00050002) The client request received by the server contains an invalid TID value.
+    STATUS_SMB_BAD_TID = WindowsError::ErrorCode.new('STATUS_SMB_BAD_TID', 0x00050002, 'The client request received by the server contains an invalid TID value.')
+
+    # (0x00160002) The client request received by the server contains an unknown SMB command code.
+    STATUS_SMB_BAD_COMMAND = WindowsError::ErrorCode.new('STATUS_SMB_BAD_COMMAND', 0x00160002, 'The client request received by the server contains an unknown SMB command code.')
+
+    # (0x005B0002) The client request to the server contains an invalid UID value.
+    STATUS_SMB_BAD_UID = WindowsError::ErrorCode.new('STATUS_SMB_BAD_UID', 0x005B0002, 'The client request to the server contains an invalid UID value.')
+
+    # (0x00FB0002) The client request received by the server is for a non-standard SMB operation (for example, an SMB_COM_READ_MPX request on a non-disk share). The client SHOULD send another request with a different SMB command to perform this operation.
+    STATUS_SMB_USE_STANDARD = WindowsError::ErrorCode.new('STATUS_SMB_USE_STANDARD', 0x00FB0002, 'The client request received by the server is for a non-standard SMB operation (for example, an SMB_COM_READ_MPX request on a non-disk share). The client SHOULD send another request with a different SMB command to perform this operation.')
+
+    # (0x80000005) The data was too large to fit into the specified buffer.
+    STATUS_BUFFER_OVERFLOW = WindowsError::ErrorCode.new('STATUS_BUFFER_OVERFLOW', 0x80000005, 'The data was too large to fit into the specified buffer.')
+
+    # (0x80000006) No more files were found that match the file specification.
+    STATUS_NO_MORE_FILES = WindowsError::ErrorCode.new('STATUS_NO_MORE_FILES', 0x80000006, 'No more files were found that match the file specification.')
+
+    # (0x8000002D) The create operation stopped after reaching a symbolic link.
+    STATUS_STOPPED_ON_SYMLINK = WindowsError::ErrorCode.new('STATUS_STOPPED_ON_SYMLINK', 0x8000002D, 'The create operation stopped after reaching a symbolic link.')
+
+    # (0xC0000002) The requested operation is not implemented.
+    STATUS_NOT_IMPLEMENTED = WindowsError::ErrorCode.new('STATUS_NOT_IMPLEMENTED', 0xC0000002, 'The requested operation is not implemented.')
+
+    # (0xC000000D) The parameter specified in the request is not valid.
+    STATUS_INVALID_PARAMETER = WindowsError::ErrorCode.new('STATUS_INVALID_PARAMETER', 0xC000000D, 'The parameter specified in the request is not valid.')
+
+    # (0xC000000E) A device that does not exist was specified.
+    STATUS_NO_SUCH_DEVICE = WindowsError::ErrorCode.new('STATUS_NO_SUCH_DEVICE', 0xC000000E, 'A device that does not exist was specified.')
+
+    # (0xC0000010) The specified request is not a valid operation for the target device.
+    STATUS_INVALID_DEVICE_REQUEST = WindowsError::ErrorCode.new('STATUS_INVALID_DEVICE_REQUEST', 0xC0000010, 'The specified request is not a valid operation for the target device.')
+
+    # (0xC0000016) If extended security has been negotiated, then this error code can be returned in the SMB_COM_SESSION_SETUP_ANDX response from the server to indicate that additional authentication information is to be exchanged. See section 2.2.4.6 for details.
+    STATUS_MORE_PROCESSING_REQUIRED = WindowsError::ErrorCode.new('STATUS_MORE_PROCESSING_REQUIRED', 0xC0000016, 'If extended security has been negotiated, then this error code can be returned in the SMB_COM_SESSION_SETUP_ANDX response from the server to indicate that additional authentication information is to be exchanged. See section 2.2.4.6 for details.')
+
+    # (0xC0000022) The client did not have the required permission needed for the operation.
+    STATUS_ACCESS_DENIED = WindowsError::ErrorCode.new('STATUS_ACCESS_DENIED', 0xC0000022, 'The client did not have the required permission needed for the operation.')
+
+    # (0xC0000023) The buffer is too small to contain the entry. No information has been written to the buffer.
+    STATUS_BUFFER_TOO_SMALL = WindowsError::ErrorCode.new('STATUS_BUFFER_TOO_SMALL', 0xC0000023, 'The buffer is too small to contain the entry. No information has been written to the buffer.')
+
+    # (0xC0000034) The object name is not found.
+    STATUS_OBJECT_NAME_NOT_FOUND = WindowsError::ErrorCode.new('STATUS_OBJECT_NAME_NOT_FOUND', 0xC0000034, 'The object name is not found.')
+
+    # (0xC0000035) The object name already exists.
+    STATUS_OBJECT_NAME_COLLISION = WindowsError::ErrorCode.new('STATUS_OBJECT_NAME_COLLISION', 0xC0000035, 'The object name already exists.')
+
+    # (0xC000003A) The path to the directory specified was not found. This error is also returned on a create request if the operation requires the creation of more than one new directory level for the path specified.
+    STATUS_OBJECT_PATH_NOT_FOUND = WindowsError::ErrorCode.new('STATUS_OBJECT_PATH_NOT_FOUND', 0xC000003A, 'The path to the directory specified was not found. This error is also returned on a create request if the operation requires the creation of more than one new directory level for the path specified.')
+
+    # (0xC00000A5) A specified impersonation level is invalid. This error is also used to indicate that a required impersonation level was not provided.
+    STATUS_BAD_IMPERSONATION_LEVEL = WindowsError::ErrorCode.new('STATUS_BAD_IMPERSONATION_LEVEL', 0xC00000A5, 'A specified impersonation level is invalid. This error is also used to indicate that a required impersonation level was not provided.')
+
+    # (0xC00000B5) The specified I/O operation was not completed before the time-out period expired.
+    STATUS_IO_TIMEOUT = WindowsError::ErrorCode.new('STATUS_IO_TIMEOUT', 0xC00000B5, 'The specified I/O operation was not completed before the time-out period expired.')
+
+    # (0xC00000BA) The file that was specified as a target is a directory and the caller specified that it could be anything but a directory.
+    STATUS_FILE_IS_A_DIRECTORY = WindowsError::ErrorCode.new('STATUS_FILE_IS_A_DIRECTORY', 0xC00000BA, 'The file that was specified as a target is a directory and the caller specified that it could be anything but a directory.')
+
+    # (0xC00000BB) The client request is not supported.
+    STATUS_NOT_SUPPORTED = WindowsError::ErrorCode.new('STATUS_NOT_SUPPORTED', 0xC00000BB, 'The client request is not supported.')
+
+    # (0xC00000C9) The network name specified by the client has been deleted on the server. This error is returned if the client specifies an incorrect TID or the share on the server represented by the TID was deleted.
+    STATUS_NETWORK_NAME_DELETED = WindowsError::ErrorCode.new('STATUS_NETWORK_NAME_DELETED', 0xC00000C9, 'The network name specified by the client has been deleted on the server. This error is returned if the client specifies an incorrect TID or the share on the server represented by the TID was deleted.')
+
+    # (0xC0000203) The user session specified by the client has been deleted on the server. This error is returned by the server if the client sends an incorrect UID.
+    STATUS_USER_SESSION_DELETED = WindowsError::ErrorCode.new('STATUS_USER_SESSION_DELETED', 0xC0000203, 'The user session specified by the client has been deleted on the server. This error is returned by the server if the client sends an incorrect UID.')
+
+    # (0xC000035C) The client's session has expired; therefore, the client MUST re-authenticate to continue accessing remote resources.
+    STATUS_NETWORK_SESSION_EXPIRED = WindowsError::ErrorCode.new('STATUS_NETWORK_SESSION_EXPIRED', 0xC000035C, 'The client\'s session has expired; therefore, the client MUST re-authenticate to continue accessing remote resources.')
+
+    # (0xC000205A) The client has requested too many UID values from the server or the client already has an SMB session setup with this UID value.
+    STATUS_SMB_TOO_MANY_UIDS = WindowsError::ErrorCode.new('STATUS_SMB_TOO_MANY_UIDS', 0xC000205A, 'The client has requested too many UID values from the server or the client already has an SMB session setup with this UID value.')
+  end
+end

data/lib/ruby_smb/version.rb

@@ -1,3 +1,3 @@
 module RubySMB
-  VERSION = '3.0.0'.freeze
+  VERSION = '3.0.1'.freeze
 end

data/lib/ruby_smb.rb

@@ -12,6 +12,7 @@ require 'windows_error/nt_status'
 # [[MS-SMB2] Server Message Block (SMB) Protocol Versions 2 and 3](https://msdn.microsoft.com/en-us/library/cc246482.aspx)
 module RubySMB
   require 'ruby_smb/error'
+  require 'ruby_smb/create_actions'
   require 'ruby_smb/dispositions'
   require 'ruby_smb/impersonation_levels'
   require 'ruby_smb/gss'
@@ -28,4 +29,5 @@ module RubySMB
   require 'ruby_smb/compression'
   require 'ruby_smb/server'
   require 'ruby_smb/dialect'
+  require 'ruby_smb/smb_error'
 end

data/ruby_smb.gemspec

@@ -34,7 +34,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'yard'
 
   spec.add_runtime_dependency 'rubyntlm'
-  spec.add_runtime_dependency 'windows_error'
+  spec.add_runtime_dependency 'windows_error', '>= 0.1.3'
   spec.add_runtime_dependency 'bindata'
   spec.add_runtime_dependency 'openssl-ccm'
   spec.add_runtime_dependency 'openssl-cmac'

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

@@ -3,8 +3,12 @@ RSpec.describe RubySMB::Field::NtStatus do
 
   it { is_expected.to respond_to :to_nt_status }
 
-  it 'is a Unsigned 32-bit little endian integer' do
-    expect(nt_status).to be_a BinData::Uint32le
+  it 'uses an internal Unsigned 32-bit little endian integer' do
+    expect(nt_status.val).to be_a BinData::Uint32le
+  end
+
+  it 'returns an integer value' do
+    expect(nt_status.value).to be_a Integer
   end
 
   describe '#to_nt_status' do

data/spec/lib/ruby_smb/gss/provider/ntlm/authenticator_spec.rb

@@ -13,6 +13,10 @@ RSpec.describe RubySMB::Gss::Provider::NTLM::Authenticator do
     Net::NTLM::Message::Type2.new.response(user: username, password: '', domain: domain)
   end
 
+  before(:each) do
+    allow(authenticator).to receive(:logger).and_return(Logger.new(IO::NULL))
+  end
+
   describe '#initialize' do
     it 'defaults to a null session key' do
       expect(authenticator.session_key).to be_nil

data/spec/lib/ruby_smb/server/server_client_spec.rb

@@ -5,33 +5,24 @@ RSpec.describe RubySMB::Server::ServerClient do
   subject(:server_client) { described_class.new(server, dispatcher) }
 
   it { is_expected.to respond_to :dialect }
-  it { is_expected.to respond_to :identity }
-  it { is_expected.to respond_to :state }
-  it { is_expected.to respond_to :session_key }
+  it { is_expected.to respond_to :session_table }
 
   describe '#disconnect!' do
     it 'closes the socket' do
+      expect(dispatcher.tcp_socket).to receive(:closed?).with(no_args).and_return(false)
       expect(dispatcher.tcp_socket).to receive(:close).with(no_args).and_return(nil)
       server_client.disconnect!
     end
   end
 
   describe '#initialize' do
-    it 'starts in the negotiate state' do
-      expect(server_client.state).to eq :negotiate
-    end
-
     it 'starts without a dialect' do
       expect(server_client.dialect).to be_nil
       expect(server_client.metadialect).to be_nil
     end
 
-    it 'starts without an identity' do
-      expect(server_client.identity).to be_nil
-    end
-
-    it 'starts without a session_key' do
-      expect(server_client.session_key).to be_nil
+    it 'starts without any sessions' do
+      expect(server_client.session_table).to be_empty
     end
 
     it 'creates a new authenticator instance' do
@@ -66,33 +57,30 @@ RSpec.describe RubySMB::Server::ServerClient do
     before(:each) do
       expect(server_client).to receive(:recv_packet).and_return(packet)
       # this hook should ensure that the dispatcher loop returns after processing a single request
-      expect(dispatcher.tcp_socket).to receive(:closed?).and_return(true)
+      expect(dispatcher.tcp_socket).to receive(:closed?).with(no_args).and_return(true)
+      expect(server_client).to receive(:disconnect!).with(no_args).and_return(nil)
     end
 
-    it 'calls #handle_negotiate when the state is negotiate' do
+    it 'calls #handle_negotiate when the dialect is nil' do
       expect(server_client).to receive(:handle_negotiate).with(packet).and_return(nil)
-      server_client.instance_eval { @state = :negotiate }
-      server_client.run
-    end
-
-    it 'calls #handle_session_setup when the state is session_setup' do
-      expect(server_client).to receive(:handle_session_setup).with(packet).and_return(nil)
-      server_client.instance_eval { @state = :session_setup }
+      server_client.instance_eval { @dialect = nil }
       server_client.run
     end
 
-    it 'calls #authenticated when the state is authenticated' do
-      expect(server_client).to receive(:handle_authenticated).with(packet).and_return(nil)
-      server_client.instance_eval { @state = :authenticated }
+    it 'calls #handle_smb when the dialect is not nil' do
+      expect(server_client).to receive(:handle_smb).with(packet).and_return(nil)
+      server_client.instance_eval { @dialect = true }
       server_client.run
     end
   end
 
   describe '#send_packet' do
-    let(:packet) { RubySMB::GenericPacket.new }
+    let(:session_id) { rand(0xffffffff) }
+    let(:packet) { RubySMB::SMB2::Packet::SessionSetupResponse.new(smb2_header: { session_id: session_id }) }
 
     before(:each) do
       expect(dispatcher).to receive(:send_packet).with(packet).and_return(nil)
+      server_client.session_table[session_id] = RubySMB::Server::Session.new(session_id)
     end
 
     it 'sends a packet to the dispatcher' do
@@ -105,40 +93,35 @@ RSpec.describe RubySMB::Server::ServerClient do
           server_client.instance_eval { @dialect = dialect }
         end
 
-        context 'and the state is authenticated' do
+        context 'and the identity is anonymous' do
           before(:each) do
-            server_client.instance_eval { @state = :authenticated }
+            server_client.session_table[session_id].user_id = RubySMB::Gss::Provider::IDENTITY_ANONYMOUS
           end
 
-          context 'and the identity is anonymous' do
-            before(:each) do
-              server_client.instance_eval { @identity = RubySMB::Gss::Provider::IDENTITY_ANONYMOUS }
-            end
-
-            it 'does not sign packets' do
-              expect(server_client).to_not receive(:smb2_sign)
-              expect(server_client).to_not receive(:smb3_sign)
-              server_client.send_packet(packet)
-            end
+          it 'does not sign packets' do
+            expect(RubySMB::Signing).to_not receive(:smb2_sign)
+            expect(RubySMB::Signing).to_not receive(:smb3_sign)
+            server_client.send_packet(packet)
           end
+        end
 
-          context 'and the identity is not anonymous' do
-            before(:each) do
-              server_client.instance_eval { @identity = 'WORKGROUP\RubySMB'; @session_key = Random.new.bytes(16) }
-            end
+        context 'and the identity is not anonymous' do
+          before(:each) do
+            server_client.session_table[session_id].user_id = 'WORKGROUP\RubySMB'
+            server_client.session_table[session_id].key = Random.new.bytes(16)
+          end
 
-            it 'does sign packets' do
-              packet = RubySMB::GenericPacket.new
-              dialect_family = RubySMB::Dialect[dialect].family
-              if dialect_family == RubySMB::Dialect::FAMILY_SMB2
-                expect(server_client).to receive(:smb2_sign).with(packet).and_return(packet)
-                expect(server_client).to_not receive(:smb3_sign)
-              elsif dialect_family == RubySMB::Dialect::FAMILY_SMB3
-                expect(server_client).to receive(:smb3_sign).with(packet).and_return(packet)
-                expect(server_client).to_not receive(:smb2_sign)
-              end
-              server_client.send_packet(packet)
+          it 'does sign packets' do
+            dialect_family = RubySMB::Dialect[dialect].family
+            session = server_client.session_table[session_id]
+            if dialect_family == RubySMB::Dialect::FAMILY_SMB2
+              expect(RubySMB::Signing).to receive(:smb2_sign).with(packet, session.key).and_return(packet)
+              expect(RubySMB::Signing).to_not receive(:smb3_sign)
+            elsif dialect_family == RubySMB::Dialect::FAMILY_SMB3
+              expect(RubySMB::Signing).to receive(:smb3_sign).with(packet, session.key, dialect, any_args).and_return(packet)
+              expect(RubySMB::Signing).to_not receive(:smb2_sign)
             end
+            server_client.send_packet(packet)
           end
         end
       end

data/spec/lib/ruby_smb/server/session_spec.rb

@@ -0,0 +1,38 @@
+RSpec.describe RubySMB::Server::Session do
+  let(:user_id) { 'WORKGROUP\RubySMB' }
+  subject(:session) { described_class.new(rand(0xffffffff), user_id: user_id) }
+
+  it { is_expected.to respond_to :id }
+  it { is_expected.to respond_to :key }
+  it { is_expected.to respond_to :signing_required }
+  it { is_expected.to respond_to :tree_connect_table }
+  it { is_expected.to respond_to :creation_time }
+
+  describe '#initialize' do
+    it 'starts with no signing required' do
+      expect(session.signing_required).to be_falsey
+    end
+
+    it 'starts with no tree connections' do
+      expect(session.tree_connect_table).to be_empty
+    end
+
+    it 'starts in the in progress state' do
+      expect(session.state).to be :in_progress
+    end
+  end
+
+  describe '#is_anonymous' do
+    it 'is false' do
+      expect(session.is_anonymous).to be_falsey
+    end
+
+    context 'when the identity is set to anonymous' do
+      let(:user_id) { RubySMB::Gss::Provider::IDENTITY_ANONYMOUS }
+
+      it 'is true' do
+        expect(session.is_anonymous).to be_truthy
+      end
+    end
+  end
+end

data/spec/lib/ruby_smb/server/share/provider/disk_spec.rb

@@ -0,0 +1,61 @@
+RSpec.describe RubySMB::Server::Share::Provider::Disk do
+  let(:name) { 'share' }
+  let(:path) { Dir.getwd }
+  subject(:share_provider) { described_class.new(name, path) }
+
+  it { is_expected.to respond_to :name }
+  it { is_expected.to respond_to :path }
+  it { is_expected.to respond_to :type }
+
+  describe '#TYPE' do
+    it 'is TYPE_DISK' do
+      expect(described_class::TYPE).to eq RubySMB::Server::Share::TYPE_DISK
+    end
+  end
+
+  describe '#initialize' do
+    it 'sets the name' do
+      expect(share_provider.name).to eq name
+    end
+
+    it 'sets the path' do
+      expect(share_provider.path).to be_a Pathname
+      expect(share_provider.path).to eq Pathname.new(path)
+    end
+
+    it 'sets the type correctly' do
+      expect(share_provider.type).to eq RubySMB::Server::Share::TYPE_DISK
+    end
+
+    it 'raises an ArgumentError for an invalid path' do
+      # __FILE__ is not a directory so it's invalid
+      expect { described_class.new(name, __FILE__) }.to raise_error(ArgumentError)
+    end
+  end
+end
+
+RSpec.describe RubySMB::Server::Share::Provider::Disk::Processor do
+  let(:session) { RubySMB::Server::Session.new(rand(0xffffffff)) }
+  let(:share_provider) { RubySMB::Server::Share::Provider::Disk.new('share', Dir.getwd) }
+  subject(:share_processor) { described_class.new(share_provider, nil, session) }
+
+  it { is_expected.to respond_to :provider }
+
+  describe '#maximal_access' do
+    # no path specified should be the root of the share
+    context 'with no path specified' do
+      let(:maximal_access) { share_processor.maximal_access }
+      it 'is a FileAccessMask' do
+        expect(maximal_access).to be_a RubySMB::SMB2::BitField::FileAccessMask
+      end
+
+      it 'marks the data as readable' do
+        expect(maximal_access.read_data).to eq 1
+      end
+
+      it 'marks the data attributes as readable' do
+        expect(maximal_access.read_attr).to eq 1
+      end
+    end
+  end
+end

data/spec/lib/ruby_smb/server/share/provider/pipe_spec.rb

@@ -0,0 +1,31 @@
+RSpec.describe RubySMB::Server::Share::Provider::Pipe do
+  let(:name) { 'share' }
+  subject(:share_provider) { described_class.new(name) }
+
+  it { is_expected.to respond_to :name }
+  it { is_expected.to respond_to :type }
+
+  describe '#TYPE' do
+    it 'is TYPE_PIPE' do
+      expect(described_class::TYPE).to eq RubySMB::Server::Share::TYPE_PIPE
+    end
+  end
+
+  describe '#initialize' do
+    it 'sets the name' do
+      expect(share_provider.name).to eq name
+    end
+
+    it 'sets the type correctly' do
+      expect(share_provider.type).to eq RubySMB::Server::Share::TYPE_PIPE
+    end
+  end
+end
+
+RSpec.describe RubySMB::Server::Share::Provider::Pipe::Processor do
+  let(:session) { RubySMB::Server::Session.new(rand(0xffffffff)) }
+  let(:share_provider) { RubySMB::Server::Share::Provider::Pipe.new('share') }
+  subject(:share_processor) { described_class.new(share_provider, nil, session) }
+
+  it { is_expected.to respond_to :provider }
+end

data/spec/lib/ruby_smb/server/share/provider_spec.rb

@@ -0,0 +1,13 @@
+RSpec.describe RubySMB::Server::Share::Provider::Base do
+  let(:name) { 'share' }
+  subject(:share_provider) { described_class.new(name) }
+
+  it { is_expected.to respond_to :name }
+  it { is_expected.to respond_to :type }
+
+  describe '#initialize' do
+    it 'sets the name' do
+      expect(share_provider.name).to eq name
+    end
+  end
+end

data/spec/lib/ruby_smb/smb2/bit_field/header_flags_spec.rb

@@ -44,8 +44,14 @@ RSpec.describe RubySMB::SMB2::BitField::Smb2HeaderFlags do
   end
 
   describe '#reserved3' do
-    it 'should be a 4-bit field per the SMB spec' do
-      expect(flags.reserved3).to be_a BinData::Bit4
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.reserved3).to be_a BinData::Bit1
+    end
+  end
+
+  describe '#priority' do
+    it 'should be a 3-bit field per the SMB spec' do
+      expect(flags.priority).to be_a BinData::Bit3
     end
   end
 

data/spec/lib/ruby_smb/smb2/{create_context_spec.rb → create_context/create_context_request_spec.rb}

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-RSpec.describe RubySMB::SMB2::CreateContext do
+RSpec.describe RubySMB::SMB2::CreateContext::CreateContextRequest do
   subject(:struct) { described_class.new }
 
   it { is_expected.to respond_to :next_offset }

data/spec/lib/ruby_smb/smb2/packet/create_request_spec.rb

@@ -80,22 +80,22 @@ RSpec.describe RubySMB::SMB2::Packet::CreateRequest do
     expect(packet.name_offset).to eq packet.name.abs_offset
   end
 
-  it 'tracks the offset to #context in #context_offset' do
-    expect(packet.context_offset).to eq packet.context.abs_offset
+  it 'tracks the offset to #context in #contexts_offset' do
+    expect(packet.contexts_offset).to eq packet.contexts.abs_offset
   end
 
   it 'tracks the length of #name in #name_length' do
     expect(packet.name_length).to eq packet.name.length
   end
 
-  it 'tracks the length of #context in #context_length' do
-    expect(packet.context_length).to eq packet.context.do_num_bytes
+  it 'tracks the length of #context in #contexts_length' do
+    expect(packet.contexts_length).to eq packet.contexts.do_num_bytes
   end
 
   describe '#name' do
     it 'encodes any input into UTF-16LE' do
       packet.name = 'Hello'
-      expect(packet.name.to_binary_s).to eq "H\x00e\x00l\x00l\x00o\x00"
+      expect(packet.name.to_binary_s { |name| name.abs_offset = 0; name.write_now! }).to eq "H\x00e\x00l\x00l\x00o\x00"
     end
   end
 end

data/spec/lib/ruby_smb/smb2/packet/create_response_spec.rb

@@ -54,11 +54,15 @@ RSpec.describe RubySMB::SMB2::Packet::CreateResponse do
     expect(packet.file_id).to be_a RubySMB::Field::Smb2Fileid
   end
 
-  it 'tracks the offset to #context in #context_offset' do
-    expect(packet.context_offset).to eq packet.context.abs_offset
-  end
+  describe '#contexts' do
+    # with no context, the offset and length should be 0
+    # see: https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-smb2/d166aa9e-0b53-410e-b35e-3933d8131927
+    it 'should have the contexts_offset set to 0' do
+      expect(packet.contexts_offset).to eq 0
+    end
 
-  it 'tracks the length of #context in #context_length' do
-    expect(packet.context_length).to eq packet.context.do_num_bytes
+    it 'should have the contexts_length set to ' do
+      expect(packet.contexts_length).to eq 0
+    end
   end
 end

data/spec/lib/ruby_smb/smb2/packet/query_directory_response_spec.rb

@@ -30,8 +30,9 @@ RSpec.describe RubySMB::SMB2::Packet::QueryDirectoryResponse do
     expect(packet.structure_size).to eq 9
   end
 
-  it 'has an offset pointer to the buffer field' do
-    expect(packet.buffer_offset).to eq packet.buffer.abs_offset
+  it 'has an offset pointer of 0 for an empty buffer field' do
+    expect(packet.buffer).to be_empty
+    expect(packet.buffer_offset).to eq 0
   end
 
   it 'has a length value for the buffer field' do