ruby_smb 1.0.3 → 1.0.4

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

@@ -99,7 +99,17 @@ RSpec.describe RubySMB::SMB2::File do
   describe '#read' do
     context 'for a small file' do
       let(:small_read) { file.read_packet(read_length: 108) }
-      let(:small_response) { RubySMB::SMB2::Packet::ReadResponse.new(data_length: 9, buffer: 'fake data') }
+      let(:small_response) {
+        response = RubySMB::SMB2::Packet::ReadResponse.new(data_length: 9, buffer: 'fake data')
+        response.smb2_header.command = RubySMB::SMB2::Commands::READ
+        response
+      }
+
+      before :example do
+        allow(file).to receive(:read_packet)
+        allow(client).to receive(:send_recv)
+        allow(RubySMB::SMB2::Packet::ReadResponse).to receive(:read).and_return(small_response)
+      end
 
       it 'uses a single packet to read the entire file' do
         expect(file).to receive(:read_packet).with(read_length: 108, offset: 0).and_return(small_read)
@@ -107,11 +117,35 @@ RSpec.describe RubySMB::SMB2::File do
         expect(RubySMB::SMB2::Packet::ReadResponse).to receive(:read).with('fake data').and_return(small_response)
         expect(file.read).to eq 'fake data'
       end
+
+      context 'when the response is not valid' do
+        it 'raise an InvalidPacket exception' do
+          small_response.smb2_header.command = RubySMB::SMB2::Commands::LOGOFF
+          expect { file.read }.to raise_error(RubySMB::Error::InvalidPacket)
+        end
+      end
+
+      context 'when the response status code is not STATUS_SUCCESS' do
+        it 'raise an UnexpectedStatusCode exception' do
+          small_response.smb2_header.nt_status = WindowsError::NTStatus::STATUS_INVALID_HANDLE.value
+          expect { file.read }.to raise_error(RubySMB::Error::UnexpectedStatusCode)
+        end
+      end
     end
 
     context 'for a larger file' do
       let(:big_read) { file.read_packet(read_length: 108) }
-      let(:big_response) { RubySMB::SMB2::Packet::ReadResponse.new(data_length: 9, buffer: 'fake data') }
+      let(:big_response) {
+        response = RubySMB::SMB2::Packet::ReadResponse.new(data_length: 9, buffer: 'fake data')
+        response.smb2_header.command = RubySMB::SMB2::Commands::READ
+        response
+      }
+
+      before :example do
+        allow(file).to receive(:read_packet)
+        allow(client).to receive(:send_recv)
+        allow(RubySMB::SMB2::Packet::ReadResponse).to receive(:read).and_return(big_response)
+      end
 
       it 'uses a multiple packet to read the file in chunks' do
         expect(file).to receive(:read_packet).once.with(read_length: described_class::MAX_PACKET_SIZE, offset: 0).and_return(big_read)
@@ -120,6 +154,24 @@ RSpec.describe RubySMB::SMB2::File do
         expect(RubySMB::SMB2::Packet::ReadResponse).to receive(:read).twice.with('fake data').and_return(big_response)
         file.read(bytes: (described_class::MAX_PACKET_SIZE * 2))
       end
+
+      context 'when the second response is not valid' do
+        it 'raise an InvalidPacket exception' do
+          allow(file).to receive(:read_packet).with(read_length: described_class::MAX_PACKET_SIZE, offset: described_class::MAX_PACKET_SIZE) do
+            big_response.smb2_header.command = RubySMB::SMB2::Commands::LOGOFF
+          end
+          expect { file.read(bytes: (described_class::MAX_PACKET_SIZE * 2)) }.to raise_error(RubySMB::Error::InvalidPacket)
+        end
+      end
+
+      context 'when the second response status code is not STATUS_SUCCESS' do
+        it 'raise an UnexpectedStatusCode exception' do
+          allow(file).to receive(:read_packet).with(read_length: described_class::MAX_PACKET_SIZE, offset: described_class::MAX_PACKET_SIZE) do
+            big_response.smb2_header.nt_status = WindowsError::NTStatus::STATUS_INVALID_HANDLE.value
+          end
+          expect { file.read(bytes: (described_class::MAX_PACKET_SIZE * 2)) }.to raise_error(RubySMB::Error::UnexpectedStatusCode)
+        end
+      end
     end
   end
 
@@ -160,6 +212,13 @@ RSpec.describe RubySMB::SMB2::File do
         file.write(data: SecureRandom.random_bytes(described_class::MAX_PACKET_SIZE + 1))
       end
     end
+
+    it 'raises an InvalidPacket exception if the response is not valid' do
+      allow(client).to receive(:send_recv)
+      allow(RubySMB::SMB2::Packet::WriteResponse).to receive(:read).and_return(write_response)
+      allow(write_response).to receive(:valid?).and_return(false)
+      expect { file.write(data: 'test') }.to raise_error(RubySMB::Error::InvalidPacket)
+    end
   end
 
   describe '#delete_packet' do
@@ -193,6 +252,14 @@ RSpec.describe RubySMB::SMB2::File do
         expect(RubySMB::SMB2::Packet::SetInfoResponse).to receive(:read).with('raw_response').and_return(small_response)
         expect(file.delete).to eq WindowsError::NTStatus::STATUS_SUCCESS
       end
+
+      it 'raises an InvalidPacket exception if the response is not valid' do
+        allow(file).to receive(:delete_packet)
+        allow(client).to receive(:send_recv)
+        allow(RubySMB::SMB2::Packet::SetInfoResponse).to receive(:read).and_return(small_response)
+        allow(small_response).to receive(:valid?).and_return(false)
+        expect { file.delete }.to raise_error(RubySMB::Error::InvalidPacket)
+      end
     end
   end
 
@@ -228,6 +295,232 @@ RSpec.describe RubySMB::SMB2::File do
         expect(RubySMB::SMB2::Packet::SetInfoResponse).to receive(:read).with('raw_response').and_return(small_response)
         expect(file.rename('new_file.txt')).to eq WindowsError::NTStatus::STATUS_SUCCESS
       end
+
+      it 'raises an InvalidPacket exception if the response is not valid' do
+        allow(client).to receive(:send_recv)
+        allow(RubySMB::SMB2::Packet::SetInfoResponse).to receive(:read).and_return(small_response)
+        allow(small_response).to receive(:valid?).and_return(false)
+        expect { file.rename('new_file.txt') }.to raise_error(RubySMB::Error::InvalidPacket)
+      end
+    end
+  end
+
+  describe '#close' do
+    let(:request)  { double('CloseRequest') }
+    let(:response) { double('CloseResponse') }
+    let(:raw_response) { double('Raw response') }
+
+    before :example do
+      allow(RubySMB::SMB2::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::SMB2::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 SMB2 CloseRequest packet' do
+      expect(RubySMB::SMB2::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 SMB2 CloseResponse packet' do
+      expect(RubySMB::SMB2::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)
+      smb2_header = double('SMB2 Header')
+      allow(response).to receive(:smb2_header).and_return(smb2_header)
+      allow(smb2_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_response) {
+      res = RubySMB::SMB2::Packet::ReadResponse.new
+      res.data_length = read_data.size
+      res.buffer = read_data
+      res
+    }
+
+    before :example do
+      allow(client).to receive(:send_recv).and_return(raw_response)
+      allow(RubySMB::SMB2::Packet::ReadResponse).to receive(:read).with(raw_response).and_return(read_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 SMB2 ReadResponse packet' do
+      expect(RubySMB::SMB2::Packet::ReadResponse).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_response).to receive(:valid?).and_return(false)
+      expect { file.send_recv_read }.to raise_error(RubySMB::Error::InvalidPacket)
+    end
+
+    context 'when the response status code is STATUS_PENDING' do
+      before :example do
+        allow(file).to receive(:sleep)
+        allow(read_response).to receive(:status_code).and_return(WindowsError::NTStatus::STATUS_PENDING)
+        allow(dispatcher).to receive(:recv_packet).and_return(raw_response)
+      end
+
+      it 'wait 1 second and calls Client dispatcher #recv_packet method one more time' do
+        expect(file).to receive(:sleep).with(1)
+        expect(dispatcher).to receive(:recv_packet)
+        file.send_recv_read
+      end
+
+      it 'parses the response as a SMB2 ReadResponse packet' do
+        expect(RubySMB::SMB2::Packet::ReadResponse).to receive(:read).twice.with(raw_response)
+        file.send_recv_read
+      end
+
+      it 'raises an InvalidPacket exception if the response is not valid' do
+        allow(dispatcher).to receive(:recv_packet) do
+          allow(read_response).to receive(:valid?).and_return(false)
+          raw_response
+        end
+        expect { file.send_recv_read }.to raise_error(RubySMB::Error::InvalidPacket)
+      end
+    end
+
+    it 'raises an UnexpectedStatusCode exception if the response status code is not STATUS_SUCCESS' do
+      allow(read_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_response) {
+      res = RubySMB::SMB2::Packet::WriteResponse.new
+      res.write_count = write_data.size
+      res
+    }
+
+    before :example do
+      allow(file).to receive(:write_packet).and_return(request)
+      allow(client).to receive(:send_recv).and_return(raw_response)
+      allow(RubySMB::SMB2::Packet::WriteResponse).to receive(:read).with(raw_response).and_return(write_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 '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 WriteResponse packet' do
+      expect(RubySMB::SMB2::Packet::WriteResponse).to receive(:read).with(raw_response)
+      file.send_recv_write
+    end
+
+    context 'when the response status code is STATUS_PENDING' do
+      before :example do
+        allow(file).to receive(:sleep)
+        allow(write_response).to receive(:status_code).and_return(WindowsError::NTStatus::STATUS_PENDING)
+        allow(dispatcher).to receive(:recv_packet).and_return(raw_response)
+      end
+
+      it 'wait 1 second and calls Client dispatcher #recv_packet method one more time' do
+        expect(file).to receive(:sleep).with(1)
+        expect(dispatcher).to receive(:recv_packet)
+        file.send_recv_write
+      end
+
+      it 'parses the response as a SMB2 WriteResponse packet' do
+        expect(RubySMB::SMB2::Packet::WriteResponse).to receive(:read).twice.with(raw_response)
+        file.send_recv_write
+      end
+
+      it 'raises an InvalidPacket exception if the response is not valid' do
+        allow(dispatcher).to receive(:recv_packet) do
+          allow(write_response).to receive(:valid?).and_return(false)
+          raw_response
+        end
+        expect { file.send_recv_write }.to raise_error(RubySMB::Error::InvalidPacket)
+      end
+    end
+
+    it 'raises an InvalidPacket exception if the response is not valid' do
+      allow(write_response).to receive(:valid?).and_return(false)
+      expect { file.send_recv_write }.to raise_error(RubySMB::Error::InvalidPacket)
+    end
+
+    it 'returns the expected response #write_count value' do
+      expect(file.send_recv_write).to eq(write_data.size)
     end
   end
 end

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

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+RSpec.describe RubySMB::SMB2::Packet::ErrorPacket do
+  subject(:packet) { described_class.new }
+
+  it { is_expected.to respond_to :smb2_header }
+  it { is_expected.to respond_to :structure_size }
+  it { is_expected.to respond_to :error_data }
+
+  describe '#smb2_header' do
+    subject(:header) { packet.smb2_header }
+
+    it 'is a standard SMB2 Header' do
+      expect(header).to be_a RubySMB::SMB2::SMB2Header
+    end
+  end
+
+  describe '#structure_size' do
+    it 'should be a 16-bit unsigned integer' do
+      expect(packet.structure_size).to be_a BinData::Uint16le
+    end
+  end
+
+  describe '#error_data' do
+    it 'should be a 8-bit unsigned integer' do
+      expect(packet.error_data).to be_a BinData::Uint8
+    end
+  end
+
+  describe '#valid?' do
+    before :example do
+      packet.original_command = RubySMB::SMB2::Commands::LOGOFF
+      packet.smb2_header.command = RubySMB::SMB2::Commands::LOGOFF
+    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.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::NEGOTIATE
+      expect(packet).to_not be_valid
+    end
+  end
+end
+

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

@@ -60,5 +60,13 @@ RSpec.describe RubySMB::SMB2::Packet::QueryDirectoryResponse do
       packet.buffer = names_blob
       expect(packet.results(RubySMB::Fscc::FileInformation::FileNamesInformation)).to eq names_array
     end
+
+    context 'when the File Information is not a valid' do
+      it 'raises an InvalidPacket exception' do
+        packet.buffer = names_blob
+        allow(RubySMB::Fscc::FileInformation::FileNamesInformation).to receive(:read).and_raise(IOError)
+        expect { packet.results(RubySMB::Fscc::FileInformation::FileNamesInformation) }.to raise_error(RubySMB::Error::InvalidPacket)
+      end
+    end
   end
 end

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

@@ -52,5 +52,13 @@ RSpec.describe RubySMB::SMB2::Packet::TreeConnectResponse do
       allow(packet).to receive(:is_directory?).and_return(false)
       expect(packet.access_rights).to be_a RubySMB::SMB2::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::SMB2::BitField::FileAccessMask).to receive(:read).and_raise(IOError)
+        expect { packet.access_rights }.to raise_error(RubySMB::Error::InvalidBitField)
+      end
+    end
   end
 end

data/spec/lib/ruby_smb/smb2/pipe_spec.rb

@@ -36,6 +36,72 @@ RSpec.describe RubySMB::SMB2::Pipe do
 
   subject(:pipe) { described_class.new(name: 'msf-pipe', response: create_response, tree: tree) }
 
+  describe '#peek' do
+    let(:request) { RubySMB::SMB2::Packet::IoctlRequest.new }
+    let(:raw_response) { double('Raw response') }
+    let(:response) { double('Response') }
+
+    before :example do
+      allow(RubySMB::SMB2::Packet::IoctlRequest).to receive(:new).and_return(request)
+      allow(client).to receive(:send_recv).and_return(raw_response)
+      allow(RubySMB::SMB2::Packet::IoctlResponse).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 IoctlRequest'do
+      expect(RubySMB::SMB2::Packet::IoctlRequest).to receive(:new)
+      pipe.peek
+    end
+
+    it 'sets the request #ctl_code field' do
+      expect(request).to receive(:ctl_code=).with(RubySMB::Fscc::ControlCodes::FSCTL_PIPE_PEEK)
+      pipe.peek
+    end
+
+    it 'sets the request #is_fsctl flag to true' do
+      pipe.peek
+      expect(request.flags.is_fsctl).to eq 1
+    end
+
+    it 'sets the request #max_output_response field to the expected value' do
+      pipe.peek(peek_size: 10)
+      expect(request.max_output_response).to eq(16 + 10)
+    end
+
+    it 'calls #set_header_fields' do
+      expect(pipe).to receive(:set_header_fields).with(request)
+      pipe.peek
+    end
+
+    it 'calls Client #send_recv' do
+      expect(client).to receive(:send_recv).with(request)
+      pipe.peek
+    end
+
+    it 'parses the response as a SMB2 IoctlResponse packet' do
+      expect(RubySMB::SMB2::Packet::IoctlResponse).to receive(:read).with(raw_response)
+      pipe.peek
+    end
+
+    it 'raises an InvalidPacket exception if the response is not valid' do
+      allow(response).to receive(:valid?).and_return(false)
+      smb2_header = double('SMB2 Header')
+      allow(response).to receive(:smb2_header).and_return(smb2_header)
+      allow(smb2_header).to receive_messages(:protocol => nil, :command => nil)
+      expect { pipe.peek }.to raise_error(RubySMB::Error::InvalidPacket)
+    end
+
+    it 'raises an UnexpectedStatusCode exception if the response status code is not STATUS_SUCCESS or STATUS_BUFFER_OVERFLOW' do
+      allow(response).to receive(:status_code).and_return(WindowsError::NTStatus::STATUS_OBJECT_NAME_NOT_FOUND)
+      expect { pipe.peek }.to raise_error(RubySMB::Error::UnexpectedStatusCode)
+    end
+
+    it 'returns the expected response' do
+      expect(pipe.peek).to eq(response)
+    end
+  end
+
   describe '#peek_available' do
     it 'reads the correct number of bytes available' do
       allow(pipe).to receive(:peek) { ioctl_response }
@@ -244,9 +310,9 @@ RSpec.describe RubySMB::SMB2::Pipe do
         pipe.ioctl_send_recv(action, options)
       end
 
-      it 'raises the expected exception when it is not a IoctlResponse packet' do
-        response = RubySMB::SMB2::Packet::LogoffResponse.new
-        allow(RubySMB::SMB2::Packet::IoctlResponse).to receive(:read).and_return(response)
+      it 'raises the expected exception when it is not a valid packet' do
+        ioctl_response.smb2_header.command = RubySMB::SMB2::Commands::LOGOFF
+        allow(RubySMB::SMB2::Packet::IoctlResponse).to receive(:read).and_return(ioctl_response)
         expect { pipe.ioctl_send_recv(action, options) }.to raise_error(RubySMB::Error::InvalidPacket)
       end