ruby_smb 1.0.0 → 1.1.0

data/spec/lib/ruby_smb/dcerpc_spec.rb

@@ -0,0 +1,81 @@
+RSpec.describe RubySMB::Dcerpc do
+  let(:tree) { double('Tree') }
+  let(:pipe) do
+    RubySMB::SMB1::Pipe.new(
+      tree: tree,
+      response: RubySMB::SMB1::Packet::NtCreateAndxResponse.new,
+      name: 'winreg'
+    )
+  end
+
+  describe '#bind' do
+    let(:options)         { { endpoint: RubySMB::Dcerpc::Winreg } }
+    let(:bind_packet)     { RubySMB::Dcerpc::Bind.new(options) }
+    let(:bind_ack_packet) { RubySMB::Dcerpc::BindAck.new }
+    let(:client)          { double('Client') }
+
+    before :example do
+      allow(RubySMB::Dcerpc::Bind).to receive(:new).and_return(bind_packet)
+      allow(pipe).to receive(:write)
+      allow(pipe).to receive(:read)
+      bind_ack_packet.p_result_list.n_results = 1
+      bind_ack_packet.p_result_list.p_results[0].result = RubySMB::Dcerpc::BindAck::ACCEPTANCE
+      allow(RubySMB::Dcerpc::BindAck).to receive(:read).and_return(bind_ack_packet)
+      allow(tree).to receive(:client).and_return(client)
+      allow(client).to receive(:max_buffer_size=)
+    end
+
+    it 'creates a Bind packet' do
+      pipe.bind(options)
+      expect(RubySMB::Dcerpc::Bind).to have_received(:new).with(options)
+    end
+
+    it 'writes to the named pipe' do
+      pipe.bind(options)
+      expect(pipe).to have_received(:write).with(data: bind_packet.to_binary_s)
+    end
+
+    it 'reads the socket' do
+      pipe.bind(options)
+      expect(pipe).to have_received(:read)
+    end
+
+    it 'creates a BindAck packet from the response' do
+      raw_response = RubySMB::Dcerpc::BindAck.new.to_binary_s
+      allow(pipe).to receive(:read).and_return(raw_response)
+      pipe.bind(options)
+      expect(RubySMB::Dcerpc::BindAck).to have_received(:read).with(raw_response)
+    end
+
+    it 'raises the expected exception when an invalid packet is received' do
+      allow(RubySMB::Dcerpc::BindAck).to receive(:read).and_raise(IOError)
+      expect { pipe.bind(options) }.to raise_error(RubySMB::Dcerpc::Error::InvalidPacket)
+    end
+
+    it 'raises the expected exception when it is not a BindAck packet' do
+      response = RubySMB::Dcerpc::Bind.new
+      allow(RubySMB::Dcerpc::BindAck).to receive(:read).and_return(response)
+      expect { pipe.bind(options) }.to raise_error(RubySMB::Dcerpc::Error::BindError)
+    end
+
+    it 'raises an exception when no result is returned' do
+      bind_ack_packet.p_result_list.n_results = 0
+      expect { pipe.bind(options) }.to raise_error(RubySMB::Dcerpc::Error::BindError)
+    end
+
+    it 'raises an exception when result is not ACCEPTANCE' do
+      bind_ack_packet.p_result_list.p_results[0].result = RubySMB::Dcerpc::BindAck::USER_REJECTION
+      expect { pipe.bind(options) }.to raise_error(RubySMB::Dcerpc::Error::BindError)
+    end
+
+    it 'sets the Tree #client.max_buffer_size property to the DCERPC response #max_xmit_frag property value' do
+      bind_ack_packet.max_xmit_frag = 64
+      pipe.bind(options)
+      expect(client).to have_received(:max_buffer_size=).with(64)
+    end
+
+    it 'returns the expected BindAck packet' do
+      expect(pipe.bind(options)).to eq(bind_ack_packet)
+    end
+  end
+end

data/spec/lib/ruby_smb/dispatcher/socket_spec.rb

@@ -85,7 +85,7 @@ RSpec.describe RubySMB::Dispatcher::Socket do
       end
 
       it 'reads the nbss header using Nbss::SessionHeader structure' do
-        expect(RubySMB::Nbss::SessionHeader).to receive(:read).with(response_socket).and_return(session_header)
+        expect(RubySMB::Nbss::SessionHeader).to receive(:read).with(nbss).and_return(session_header)
         smb_socket.recv_packet
       end
 
@@ -105,6 +105,7 @@ RSpec.describe RubySMB::Dispatcher::Socket do
         packet_length = 10
         session_header.packet_length = packet_length
         allow(RubySMB::Nbss::SessionHeader).to receive(:read).and_return(session_header)
+        expect(response_socket).to receive(:read).with(4).and_return(session_header)
         expect(response_socket).to receive(:read).with(packet_length).and_return('A' * packet_length)
         smb_socket.recv_packet
       end
@@ -116,6 +117,7 @@ RSpec.describe RubySMB::Dispatcher::Socket do
           session_header.packet_length = packet_length
           allow(RubySMB::Nbss::SessionHeader).to receive(:read).and_return(session_header)
 
+          expect(response_socket).to receive(:read).with(4).and_return(session_header)
           loop do
             expect(response_socket).to receive(:read).with(packet_length).and_return('A' * returned_length).once
             packet_length -= returned_length

data/spec/lib/ruby_smb/generic_packet_spec.rb

@@ -63,8 +63,13 @@ RSpec.describe RubySMB::GenericPacket do
         expect(RubySMB::SMB1::Packet::NegotiateResponse.read(smb1_error_packet.to_binary_s)).to be_a RubySMB::SMB1::Packet::EmptyPacket
       end
 
-      it 'reraises the exception if it is not a valid error packet either' do
-        expect{RubySMB::SMB1::Packet::NegotiateResponse.read('a')}.to raise_error(EOFError)
+      it 'raises an InvaliPacket exception if it is not a valid error packet either' do
+        expect{RubySMB::SMB1::Packet::NegotiateResponse.read('a')}.to raise_error(RubySMB::Error::InvalidPacket)
+      end
+
+      it 'sets the EmptyPacket#original_command attribute to the original COMMAND' do
+        packet = RubySMB::SMB1::Packet::NegotiateResponse.read(smb1_error_packet.to_binary_s)
+        expect(packet.original_command).to eq RubySMB::SMB1::Packet::NegotiateResponse::COMMAND
       end
     end
 
@@ -75,8 +80,51 @@ RSpec.describe RubySMB::GenericPacket do
         expect(RubySMB::SMB2::Packet::NegotiateResponse.read(smb2_error_packet.to_binary_s)).to be_a RubySMB::SMB2::Packet::ErrorPacket
       end
 
-      it 'reraises the exception if it is not a valid error packet either' do
-        expect{RubySMB::SMB2::Packet::NegotiateResponse.read('a')}.to raise_error(EOFError)
+      it 'raises an InvaliPacket exception if it is not a valid error packet either' do
+        expect{RubySMB::SMB2::Packet::NegotiateResponse.read('a')}.to raise_error(RubySMB::Error::InvalidPacket)
+      end
+
+      it 'sets the ErrorPacket#original_command attribute to the original COMMAND' do
+        packet = RubySMB::SMB2::Packet::NegotiateResponse.read(smb2_error_packet.to_binary_s)
+        expect(packet.original_command).to eq RubySMB::SMB2::Packet::NegotiateResponse::COMMAND
+      end
+    end
+  end
+
+  describe '#valid?' do
+    context 'when reading an SMB1 packet' do
+      let(:packet) { RubySMB::SMB1::Packet::NegotiateResponse.new }
+
+      it 'returns true if the packet protocol ID and header command are valid' do
+        expect(packet).to be_valid
+      end
+
+      it 'returns false if the packet protocol ID is wrong' do
+        packet.smb_header.protocol = RubySMB::SMB2::SMB2_PROTOCOL_ID
+        expect(packet).to_not be_valid
+      end
+
+      it 'returns false if the packet header command is wrong' do
+        packet.smb_header.command = RubySMB::SMB1::Commands::SMB_COM_TREE_CONNECT
+        expect(packet).to_not be_valid
+      end
+    end
+
+    context 'when reading an SMB2 packet' do
+      let(:packet) { RubySMB::SMB2::Packet::NegotiateResponse.new }
+
+      it 'returns true if the packet protocol ID and header command are valid' do
+        expect(packet).to be_valid
+      end
+
+      it 'returns false if the packet protocol ID is wrong' do
+        packet.smb2_header.protocol = RubySMB::SMB1::SMB_PROTOCOL_ID
+        expect(packet).to_not be_valid
+      end
+
+      it 'returns false if the packet header command is wrong' do
+        packet.smb2_header.command = RubySMB::SMB2::Commands::TREE_CONNECT
+        expect(packet).to_not be_valid
       end
     end
   end

data/spec/lib/ruby_smb/smb1/file_spec.rb

@@ -110,10 +110,18 @@ RSpec.describe RubySMB::SMB1::File do
       file.read_packet
     end
 
-    it 'sets the read_length of the packet' do
+    it 'sets the #max_count_of_bytes_to_return of the packet' do
       expect(file.read_packet(read_length: 55).parameter_block.max_count_of_bytes_to_return).to eq 55
     end
 
+    it 'sets the #min_count_of_bytes_to_return of the packet' do
+      expect(file.read_packet(read_length: 55).parameter_block.min_count_of_bytes_to_return).to eq 55
+    end
+    
+    it 'sets the #remaining of the packet' do
+      expect(file.read_packet(read_length: 55).parameter_block.remaining).to eq 55
+    end
+
     it 'sets the offset of the packet' do
       expect(file.read_packet(offset: 55).parameter_block.offset).to eq 55
     end
@@ -163,7 +171,7 @@ RSpec.describe RubySMB::SMB1::File do
     end
 
     context 'when sending the request packet and gets a response back' do
-      context 'when the response is not a ReadAndxResponse packet' do
+      context 'when the response is not valid' do
         it 'raise an InvalidPacket exception' do
           read_andx_response.smb_header.command = RubySMB::SMB1::Commands::SMB_COM_ECHO
           expect { file.read }.to raise_error(RubySMB::Error::InvalidPacket)
@@ -181,6 +189,7 @@ RSpec.describe RubySMB::SMB1::File do
         let(:empty_packet) do
           empty_packet = RubySMB::SMB1::Packet::EmptyPacket.new
           empty_packet.smb_header.command = RubySMB::SMB1::Commands::SMB_COM_READ_ANDX
+          empty_packet.original_command = RubySMB::SMB1::Commands::SMB_COM_READ_ANDX
           empty_packet
         end
 
@@ -345,6 +354,11 @@ RSpec.describe RubySMB::SMB1::File do
       set_info_res.smb_header.nt_status = status.value
       expect(file.delete).to eq status
     end
+
+    it 'raises an InvalidPacket exception if the response is not valid' do
+      allow(set_info_res).to receive(:valid?).and_return(false)
+      expect { file.delete }.to raise_error(RubySMB::Error::InvalidPacket)
+    end
   end
 
   describe '#delete_packet' do
@@ -415,6 +429,11 @@ RSpec.describe RubySMB::SMB1::File do
       set_info_res.smb_header.nt_status = status.value
       expect(file.rename(filename)).to eq status
     end
+
+    it 'raises an InvalidPacket exception if the response is not valid' do
+      allow(set_info_res).to receive(:valid?).and_return(false)
+      expect { file.rename(filename) }.to raise_error(RubySMB::Error::InvalidPacket)
+    end
   end
 
   describe '#rename_packet' do
@@ -465,5 +484,175 @@ RSpec.describe RubySMB::SMB1::File do
       expect(parameter_block.max_data_count).to eq 16_384
     end
   end
+
+  describe '#close' do
+    let(:request)  { double('CloseRequest') }
+    let(:response) { double('CloseResponse') }
+    let(:raw_response) { double('Raw response') }
+
+    before :example do
+      allow(RubySMB::SMB1::Packet::CloseRequest).to receive(:new).and_return(request)
+      allow(file).to receive(:set_header_fields).and_return(request)
+      allow(client).to receive(:send_recv).and_return(raw_response)
+      allow(RubySMB::SMB1::Packet::CloseResponse).to receive(:read).and_return(response)
+      allow(response).to receive(:valid?).and_return(true)
+      allow(response).to receive(:status_code).and_return(WindowsError::NTStatus::STATUS_SUCCESS)
+    end
+
+    it 'creates a new SMB1 CloseRequest packet' do
+      expect(RubySMB::SMB1::Packet::CloseRequest).to receive(:new)
+      file.close
+    end
+
+    it 'calls Tree #set_header_fields to set SetFileInformationRequest headers' do
+      expect(file).to receive(:set_header_fields).with(request)
+      file.close
+    end
+
+    it 'calls Client #send_recv with the expected request' do
+      expect(client).to receive(:send_recv).with(request)
+      file.close
+    end
+
+    it 'parses the response as a SMB1 CloseResponse packet' do
+      expect(RubySMB::SMB1::Packet::CloseResponse).to receive(:read).with(raw_response)
+      file.close
+    end
+
+    it 'raises an InvalidPacket exception if the response is not valid' do
+      allow(response).to receive(:valid?).and_return(false)
+      smb_header = double('SMB Header')
+      allow(response).to receive(:smb_header).and_return(smb_header)
+      allow(smb_header).to receive_messages(:protocol => nil, :command => nil)
+      expect { file.close }.to raise_error(RubySMB::Error::InvalidPacket)
+    end
+
+    it 'raises an UnexpectedStatusCode exception if the response status code is not STATUS_SUCCESS' do
+      allow(response).to receive(:status_code).and_return(WindowsError::NTStatus::STATUS_OBJECT_NAME_NOT_FOUND)
+      expect { file.close }.to raise_error(RubySMB::Error::UnexpectedStatusCode)
+    end
+
+    it 'returns the response status code' do
+      expect(file.close).to eq WindowsError::NTStatus::STATUS_SUCCESS
+    end
+  end
+
+  describe '#send_recv_read' do
+    let(:read_data) { 'read data' }
+    let(:raw_response) { double('fake raw response data') }
+    let(:read_andx_response) {
+      res = RubySMB::SMB1::Packet::ReadAndxResponse.new
+      res.data_block.data = read_data
+      res
+    }
+
+    before :example do
+      allow(client).to receive(:send_recv).and_return(raw_response)
+      allow(RubySMB::SMB1::Packet::ReadAndxResponse).to receive(:read).with(raw_response).and_return(read_andx_response)
+    end
+
+    context 'when the number of bytes to read is not provided' do
+      it 'reads 0 bytes by default' do
+        expect(file).to receive(:read_packet).with(read_length: 0, offset: 0).once.and_call_original
+        file.send_recv_read
+      end
+    end
+
+    it 'only reads the number of bytes provided as argument' do
+      bytes = 5
+      expect(file).to receive(:read_packet).with(read_length: bytes, offset: 0).once.and_call_original
+      file.send_recv_read(read_length: bytes)
+    end
+
+    it 'reads from the offset provided as argument' do
+      offset = 3
+      expect(file).to receive(:read_packet).with(read_length: 0, offset: offset).once.and_call_original
+      file.send_recv_read(offset: offset)
+    end
+
+    it 'calls Client #send_recv with the expected request' do
+      request = double('Request')
+      allow(file).to receive(:read_packet).and_return(request)
+      expect(client).to receive(:send_recv).with(request)
+      file.send_recv_read
+    end
+
+    it 'parses the response as a SMB1 ReadAndxResponse packet' do
+      expect(RubySMB::SMB1::Packet::ReadAndxResponse).to receive(:read).with(raw_response)
+      file.send_recv_read
+    end
+
+    it 'raises an InvalidPacket exception if the response is not valid' do
+      allow(read_andx_response).to receive(:valid?).and_return(false)
+      expect { file.send_recv_read }.to raise_error(RubySMB::Error::InvalidPacket)
+    end
+
+    it 'raises an UnexpectedStatusCode exception if the response status code is not STATUS_SUCCESS' do
+      allow(read_andx_response).to receive(:status_code).and_return(WindowsError::NTStatus::STATUS_OBJECT_NAME_NOT_FOUND)
+      expect { file.send_recv_read }.to raise_error(RubySMB::Error::UnexpectedStatusCode)
+    end
+
+    it 'returns the expected string' do
+      expect(file.send_recv_read).to eq(read_data)
+    end
+  end
+
+  describe '#send_recv_write' do
+    let(:write_data) { 'write data' }
+    let(:request) { double('Request') }
+    let(:raw_response) { double('fake raw response data') }
+    let(:write_andx_response) {
+      res = RubySMB::SMB1::Packet::WriteAndxResponse.new
+      res.parameter_block.count_low = write_data.size
+      res
+    }
+
+    before :example do
+      allow(file).to receive(:write_packet).and_return(request)
+      allow(request).to receive(:set_64_bit_offset)
+      allow(client).to receive(:send_recv).and_return(raw_response)
+      allow(RubySMB::SMB1::Packet::WriteAndxResponse).to receive(:read).with(raw_response).and_return(write_andx_response)
+    end
+
+    it 'reads 0 bytes from offset 0 by default' do
+      expect(file).to receive(:write_packet).with(data: '', offset: 0).once.and_call_original
+      file.send_recv_write
+    end
+
+    it 'writes the data provided as argument' do
+      expect(file).to receive(:write_packet).with(data: write_data, offset: 0).once.and_call_original
+      file.send_recv_write(data: write_data)
+    end
+
+    it 'reads from the offset provided as argument' do
+      offset = 3
+      expect(file).to receive(:write_packet).with(data: '', offset: offset).once.and_call_original
+      file.send_recv_write(offset: offset)
+    end
+
+    it 'sets the 64 bit offset to true' do
+      expect(request).to receive(:set_64_bit_offset).with(true)
+      file.send_recv_write
+    end
+
+    it 'calls Client #send_recv with the expected request' do
+      expect(client).to receive(:send_recv).with(request)
+      file.send_recv_write
+    end
+
+    it 'parses the response as a SMB1 WriteAndxResponse packet' do
+      expect(RubySMB::SMB1::Packet::WriteAndxResponse).to receive(:read).with(raw_response)
+      file.send_recv_write
+    end
+
+    it 'raises an InvalidPacket exception if the response is not valid' do
+      allow(write_andx_response).to receive(:valid?).and_return(false)
+      expect { file.send_recv_write }.to raise_error(RubySMB::Error::InvalidPacket)
+    end
+
+    it 'returns the expected response #count_low value' do
+      expect(file.send_recv_write).to eq(write_data.size)
+    end
+  end
 end
 

data/spec/lib/ruby_smb/smb1/packet/empty_packet_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+RSpec.describe RubySMB::SMB1::Packet::EmptyPacket do
+  subject(:packet) { described_class.new }
+
+  describe '#smb_header' do
+    subject(:header) { packet.smb_header }
+
+    it 'is a standard SMB Header' do
+      expect(header).to be_a RubySMB::SMB1::SMBHeader
+    end
+  end
+
+  describe '#parameter_block' do
+    subject(:parameter_block) { packet.parameter_block }
+
+    it 'is a standard ParameterBlock' do
+      expect(parameter_block).to be_a RubySMB::SMB1::ParameterBlock
+    end
+
+    it 'should be empty' do
+      expect(parameter_block.to_binary_s).to eq "\x00"
+    end
+  end
+
+  describe '#data_block' do
+    subject(:data_block) { packet.data_block }
+
+    it 'is a standard DataBlock' do
+      expect(data_block).to be_a RubySMB::SMB1::DataBlock
+    end
+
+    it 'should be empty' do
+      expect(data_block.to_binary_s).to eq "\x00\x00"
+    end
+  end
+
+  describe '#valid?' do
+    before :example do
+      packet.original_command = RubySMB::SMB1::Commands::SMB_COM_TREE_CONNECT
+      packet.smb_header.command = RubySMB::SMB1::Commands::SMB_COM_TREE_CONNECT
+    end
+
+    it 'returns true if the packet protocol ID and header command are valid' do
+      expect(packet).to be_valid
+    end
+
+    it 'returns false if the packet protocol ID is wrong' do
+      packet.smb_header.protocol = RubySMB::SMB2::SMB2_PROTOCOL_ID
+      expect(packet).to_not be_valid
+    end
+
+    it 'returns false if the packet header command is wrong' do
+      packet.smb_header.command = RubySMB::SMB1::Commands::SMB_COM_NEGOTIATE
+      expect(packet).to_not be_valid
+    end
+
+    it 'returns false if the packet parameter block size is not 0' do
+      packet.parameter_block.word_count = 10
+      expect(packet).to_not be_valid
+    end
+
+    it 'returns false if the packet data block size is not 0' do
+      packet.data_block.byte_count = 10
+      expect(packet).to_not be_valid
+    end
+  end
+end

data/spec/lib/ruby_smb/smb1/packet/trans2/find_first2_response_spec.rb

@@ -80,6 +80,8 @@ RSpec.describe RubySMB::SMB1::Packet::Trans2::FindFirst2Response do
 
     let(:names_blob) { names_array.collect(&:to_binary_s).join('') }
 
+    let(:find_info) { FindFileFullDirectoryInfo.new }
+
     it 'returns an array of parsed FindFileFullDirectoryInfo structs' do
       packet.data_block.trans2_data.buffer = names_blob
       expect(packet.results(FindFileFullDirectoryInfo, unicode: false)).to eq names_array
@@ -87,7 +89,6 @@ RSpec.describe RubySMB::SMB1::Packet::Trans2::FindFirst2Response do
 
     it 'sets the FindFileFullDirectoryInfo unicode attribute when unicode argument is true' do
       packet.data_block.trans2_data.buffer = names1.to_binary_s
-      find_info = FindFileFullDirectoryInfo.new
       allow(FindFileFullDirectoryInfo).to receive(:new).and_return find_info
       expect(find_info).to receive(:unicode=).with(true).once
       packet.results(FindFileFullDirectoryInfo, unicode: true)
@@ -95,10 +96,18 @@ RSpec.describe RubySMB::SMB1::Packet::Trans2::FindFirst2Response do
 
     it 'does not set the FindFileFullDirectoryInfo unicode attribute when unicode argument is false' do
       packet.data_block.trans2_data.buffer = names1.to_binary_s
-      find_info = FindFileFullDirectoryInfo.new
       allow(FindFileFullDirectoryInfo).to receive(:new).and_return find_info
       expect(find_info).to receive(:unicode=).with(false).once
       packet.results(FindFileFullDirectoryInfo, unicode: false)
     end
+
+    context 'when the File Information is not a valid' do
+      it 'raises an InvalidPacket exception' do
+        packet.data_block.trans2_data.buffer = names1.to_binary_s
+        allow(FindFileFullDirectoryInfo).to receive(:new).and_return(find_info)
+        allow(find_info).to receive(:read).and_raise(IOError)
+        expect { packet.results(FindFileFullDirectoryInfo, unicode: false) }.to raise_error(RubySMB::Error::InvalidPacket)
+      end
+    end
   end
 end

data/spec/lib/ruby_smb/smb1/packet/trans2/find_next2_response_spec.rb

@@ -78,6 +78,8 @@ RSpec.describe RubySMB::SMB1::Packet::Trans2::FindNext2Response do
 
     let(:names_blob) { names_array.collect(&:to_binary_s).join('') }
 
+    let(:find_info) { FindFileFullDirectoryInfo.new }
+
     it 'returns an array of parsed FindFileFullDirectoryInfo structs' do
       packet.data_block.trans2_data.buffer = names_blob
       expect(packet.results(FindFileFullDirectoryInfo, unicode: false)).to eq names_array
@@ -85,7 +87,6 @@ RSpec.describe RubySMB::SMB1::Packet::Trans2::FindNext2Response do
 
     it 'sets the FindFileFullDirectoryInfo unicode attribute when unicode argument is true' do
       packet.data_block.trans2_data.buffer = names1.to_binary_s
-      find_info = FindFileFullDirectoryInfo.new
       allow(FindFileFullDirectoryInfo).to receive(:new).and_return find_info
       expect(find_info).to receive(:unicode=).with(true).once
       packet.results(FindFileFullDirectoryInfo, unicode: true)
@@ -93,10 +94,18 @@ RSpec.describe RubySMB::SMB1::Packet::Trans2::FindNext2Response do
 
     it 'does not set the FindFileFullDirectoryInfo unicode attribute when unicode argument is false' do
       packet.data_block.trans2_data.buffer = names1.to_binary_s
-      find_info = FindFileFullDirectoryInfo.new
       allow(FindFileFullDirectoryInfo).to receive(:new).and_return find_info
       expect(find_info).to receive(:unicode=).with(false).once
       packet.results(FindFileFullDirectoryInfo, unicode: false)
     end
+
+    context 'when the File Information is not a valid' do
+      it 'raises an InvalidPacket exception' do
+        packet.data_block.trans2_data.buffer = names1.to_binary_s
+        allow(FindFileFullDirectoryInfo).to receive(:new).and_return(find_info)
+        allow(find_info).to receive(:read).and_raise(IOError)
+        expect { packet.results(FindFileFullDirectoryInfo, unicode: false) }.to raise_error(RubySMB::Error::InvalidPacket)
+      end
+    end
   end
 end

data/spec/lib/ruby_smb/smb1/packet/tree_connect_response_spec.rb

@@ -104,4 +104,44 @@ RSpec.describe RubySMB::SMB1::Packet::TreeConnectResponse do
       expect(file_response.guest_access_rights).to be_a RubySMB::SMB1::BitField::FileAccessMask
     end
   end
+
+  describe '#access_rights' do
+    it 'is a DirectoryAccessMask if the Tree is a directory' do
+      allow(packet).to receive(:is_directory?).and_return(true)
+      expect(packet.access_rights).to be_a RubySMB::SMB1::BitField::DirectoryAccessMask
+    end
+
+    it 'is a FileAccessMask if the Tree is not a directory' do
+      allow(packet).to receive(:is_directory?).and_return(false)
+      expect(packet.access_rights).to be_a RubySMB::SMB1::BitField::FileAccessMask
+    end
+
+    context 'when it is not a valid FileAccessMask' do
+      it 'raises an InvalidBitField exception' do
+        allow(packet).to receive(:is_directory?).and_return(false)
+        allow(RubySMB::SMB1::BitField::FileAccessMask).to receive(:read).and_raise(IOError)
+        expect { packet.access_rights }.to raise_error(RubySMB::Error::InvalidBitField)
+      end
+    end
+  end
+
+  describe '#guest_access_rights' do
+    it 'is a DirectoryAccessMask if the Tree is a directory' do
+      allow(packet).to receive(:is_directory?).and_return(true)
+      expect(packet.guest_access_rights).to be_a RubySMB::SMB1::BitField::DirectoryAccessMask
+    end
+
+    it 'is a FileAccessMask if the Tree is not a directory' do
+      allow(packet).to receive(:is_directory?).and_return(false)
+      expect(packet.guest_access_rights).to be_a RubySMB::SMB1::BitField::FileAccessMask
+    end
+
+    context 'when it is not a valid FileAccessMask' do
+      it 'raises an InvalidBitField exception' do
+        allow(packet).to receive(:is_directory?).and_return(false)
+        allow(RubySMB::SMB1::BitField::FileAccessMask).to receive(:read).and_raise(IOError)
+        expect { packet.guest_access_rights }.to raise_error(RubySMB::Error::InvalidBitField)
+      end
+    end
+  end
 end