ruby_smb 1.0.3 → 2.0.1

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

@@ -51,9 +51,9 @@ RSpec.describe RubySMB::Dispatcher::Socket do
     let(:session_header)  { RubySMB::Nbss::SessionHeader.new }
 
     context 'when reading from the socket results in a nil value' do
-      it 'should raise Error::NetBiosSessionService' do
+      it 'should raise Error::CommunicationError' do
         smb_socket.tcp_socket = blank_socket
-        expect { smb_socket.recv_packet }.to raise_error(::RubySMB::Error::NetBiosSessionService)
+        expect { smb_socket.recv_packet }.to raise_error(::RubySMB::Error::CommunicationError)
       end
     end
 

data/spec/lib/ruby_smb/error_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+RSpec.describe RubySMB::Error::InvalidPacket do
+  context 'with a String' do
+    it 'outputs the expected error message' do
+      ex = described_class.new('My exception')
+      expect(ex.to_s).to eq('My exception')
+    end
+  end
+
+  context 'with a Hash' do
+    it 'outputs the expected error message' do
+      ex = described_class.new(
+        expected_proto:  RubySMB::SMB1::SMB_PROTOCOL_ID,
+        expected_cmd:    RubySMB::SMB1::Packet::NegotiateResponseExtended::COMMAND,
+        expected_custom: "extended_security=1",
+        received_proto:  RubySMB::SMB2::SMB2_PROTOCOL_ID,
+        received_cmd:    RubySMB::SMB2::Packet::NegotiateResponse::COMMAND,
+        received_custom: "extended_security=0"
+      )
+      expect(ex.to_s).to eq('Expecting SMB1 protocol with command=114 (extended_security=1), got SMB2 protocol with command=0 (extended_security=0)')
+    end
+  end
+
+  context 'with an unsupported type' do
+    it 'raises the expected exception' do
+      expect { described_class.new(['wrong']) }.to raise_error(
+        ArgumentError,
+        'InvalidPacket expects a String or a Hash, got a Array'
+      )
+    end
+  end
+end
+
+
+RSpec.describe RubySMB::Error::UnexpectedStatusCode do
+  context 'with a WindowsError::ErrorCode' do
+    it 'outputs the expected error message' do
+      ex = described_class.new(WindowsError::NTStatus::STATUS_BUFFER_OVERFLOW)
+      expect(ex.to_s).to eq('The server responded with an unexpected status code: STATUS_BUFFER_OVERFLOW')
+    end
+  end
+
+  context 'with an Integer' do
+    it 'outputs the expected error message' do
+      ex = described_class.new(0x80000005)
+      expect(ex.to_s).to eq('The server responded with an unexpected status code: STATUS_BUFFER_OVERFLOW')
+    end
+  end
+
+  context 'with an unsupported type' do
+    it 'raises the expected exception' do
+      expect { described_class.new(['wrong']) }.to raise_error(
+        ArgumentError,
+        'Status code must be a WindowsError::ErrorCode or an Integer, got Array'
+      )
+    end
+  end
+end

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