ruby_smb 1.0.0 → 1.1.0

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

@@ -1,15 +1,12 @@
 RSpec.describe RubySMB::SMB1::Pipe do
 
+  it { expect(described_class).to be < RubySMB::SMB1::File }
+
   let(:peek_nmpipe_response) {
     packet = RubySMB::SMB1::Packet::Trans::PeekNmpipeResponse.new
     packet.data_block.trans_parameters.read("\x10\x20\x00\x00\x03\x00")
     packet
   }
-
-  describe RubySMB::SMB1::Pipe do
-    it { expect(described_class).to be < RubySMB::SMB1::File }
-  end
-
   let(:dispatcher) { RubySMB::Dispatcher::Socket.new(double('socket')) }
   let(:client) { RubySMB::Client.new(dispatcher, username: 'msfadmin', password: 'msfadmin') }
   let(:connect_response) {
@@ -37,6 +34,68 @@ RSpec.describe RubySMB::SMB1::Pipe do
     described_class.new(tree: tree, response: nt_create_andx_response, name: filename)
   }
 
+  describe '#peek' do
+    let(:request) { RubySMB::SMB1::Packet::Trans::PeekNmpipeRequest.new }
+    let(:raw_response) { double('Raw response') }
+    let(:response) { double('Response') }
+
+    before :example do
+      allow(RubySMB::SMB1::Packet::Trans::PeekNmpipeRequest).to receive(:new).and_return(request)
+      allow(client).to receive(:send_recv).and_return(raw_response)
+      allow(RubySMB::SMB1::Packet::Trans::PeekNmpipeResponse).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 PeekNmpipeRequest'do
+      expect(RubySMB::SMB1::Packet::Trans::PeekNmpipeRequest).to receive(:new)
+      pipe.peek
+    end
+
+    it 'sets the request #fid field' do
+      expect(request).to receive(:fid=).with(pipe.fid)
+      pipe.peek
+    end
+
+    it 'sets the request #max_data_count fieldto the peek_size argument' do
+      peek_size = 5
+      pipe.peek(peek_size: peek_size)
+      expect(request.parameter_block.max_data_count).to eq(peek_size)
+    end
+
+    it 'calls Tree #set_header_fields' do
+      expect(tree).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 SMB1 PeekNmpipeResponse packet' do
+      expect(RubySMB::SMB1::Packet::Trans::PeekNmpipeResponse).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)
+      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 { 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) { peek_nmpipe_response }
@@ -62,202 +121,266 @@ RSpec.describe RubySMB::SMB1::Pipe do
     end
   end
 
-  context 'with DCERPC' do
-    describe '#net_share_enum_all' do
-      let(:host) { '1.2.3.4' }
-      let(:dcerpc_response) { RubySMB::Dcerpc::Response.new }
-
-      before :example do
-        allow(pipe).to receive(:bind)
-        allow(pipe).to receive(:request).and_return(dcerpc_response)
-        allow(RubySMB::Dcerpc::Srvsvc::NetShareEnumAll).to receive(:parse_response).and_return([])
+  describe '#initialize' do
+    context 'when name is not provided' do
+      it 'raises an ArgumentError' do
+        expect {
+          described_class.new(tree: tree, response: nt_create_andx_response, name: nil)
+        }.to raise_error(ArgumentError)
       end
+    end
 
-      it 'calls #bind with the expected arguments' do
-        expect(pipe).to receive(:bind).with(endpoint: RubySMB::Dcerpc::Srvsvc)
-        pipe.net_share_enum_all(host)
-      end
+    it 'calls the superclass with the expected arguments' do
+      expect(pipe.tree).to eq(tree)
+      expect(pipe.name).to eq(filename)
+      expect(pipe.attributes).to eq(nt_create_andx_response.parameter_block.ext_file_attributes)
+      expect(pipe.fid).to eq(nt_create_andx_response.parameter_block.fid)
+      expect(pipe.last_access).to eq(nt_create_andx_response.parameter_block.last_access_time.to_datetime)
+      expect(pipe.last_change).to eq(nt_create_andx_response.parameter_block.last_change_time.to_datetime)
+      expect(pipe.last_write).to eq(nt_create_andx_response.parameter_block.last_write_time.to_datetime)
+      expect(pipe.size).to eq(nt_create_andx_response.parameter_block.end_of_file)
+      expect(pipe.size_on_disk).to eq(nt_create_andx_response.parameter_block.allocation_size)
+    end
 
-      it 'calls #request with the expected arguments' do
-        expect(pipe).to receive(:request).with(RubySMB::Dcerpc::Srvsvc::NET_SHARE_ENUM_ALL, host: host)
-        pipe.net_share_enum_all(host)
+    context 'with \'srvsvc\' filename' do
+      it 'extends Srvsvc class' do
+        pipe = described_class.new(tree: tree, response: nt_create_andx_response, name: 'srvsvc')
+        expect(pipe.respond_to?(:net_share_enum_all)).to be true
       end
+    end
 
-      it 'parse the response with NetShareEnumAll #parse_response method' do
-        stub = 'ABCD'
-        dcerpc_response.alloc_hint = stub.size
-        dcerpc_response.stub = stub
-        expect(RubySMB::Dcerpc::Srvsvc::NetShareEnumAll).to receive(:parse_response).with(stub)
-        pipe.net_share_enum_all(host)
+    context 'with \'winreg\' filename' do
+      it 'extends Winreg class' do
+        pipe = described_class.new(tree: tree, response: nt_create_andx_response, name: 'winreg')
+        expect(pipe.respond_to?(:has_registry_key?)).to be true
       end
+    end
+  end
 
-      it 'returns the remote shares' do
-        shares = [
-          ["C$", "DISK", "Default share"],
-          ["Shared", "DISK", ""],
-          ["IPC$", "IPC", "Remote IPC"],
-          ["ADMIN$", "DISK", "Remote Admin"]
-        ]
-        output = [
-          {:name=>"C$", :type=>"DISK", :comment=>"Default share"},
-          {:name=>"Shared", :type=>"DISK", :comment=>""},
-          {:name=>"IPC$", :type=>"IPC", :comment=>"Remote IPC"},
-          {:name=>"ADMIN$", :type=>"DISK", :comment=>"Remote Admin"},
-        ]
-        allow(RubySMB::Dcerpc::Srvsvc::NetShareEnumAll).to receive(:parse_response).and_return(shares)
-        expect(pipe.net_share_enum_all(host)).to eq(output)
-      end
+  describe '#dcerpc_request' do
+    let(:options)                   { { host: '1.2.3.4' } }
+    let(:stub_packet )              { RubySMB::Dcerpc::Winreg::OpenKeyRequest.new }
+    let(:dcerpc_request)            { double('DCERPC Request') }
+    let(:request_stub)              { double('Request stub') }
+    let(:binary_dcerpc_request)     { double('Binary DCERPC Request') }
+    let(:trans_nmpipe_request)      { double('TransactNmpipeRequest') }
+    let(:trans_data)                { double('Trans data') }
+    let(:trans_nmpipe_raw_response) { double('Trans nmpipe raw response') }
+    let(:trans_nmpipe_response)     { double('TransactNmpipeResponse') }
+    let(:raw_data)                  { double('Raw data') }
+    let(:dcerpc_response)           { double('DCERPC Response') }
+    let(:result)                    { 'Result' }
+
+    before :example do
+      allow(RubySMB::Dcerpc::Request).to receive(:new).and_return(dcerpc_request)
+      allow(dcerpc_request).to receive_messages(
+        :stub        => request_stub,
+        :to_binary_s => binary_dcerpc_request
+      )
+      allow(request_stub).to receive(:read)
+      allow(RubySMB::SMB1::Packet::Trans::TransactNmpipeRequest).to receive(:new).and_return(trans_nmpipe_request)
+      allow(tree).to receive(:set_header_fields)
+      allow(trans_nmpipe_request).to receive_message_chain(:data_block, :trans_data => trans_data)
+      allow(trans_nmpipe_request).to receive(:set_fid)
+      allow(trans_data).to receive(:write_data=)
+      allow(client).to receive(:send_recv).and_return(trans_nmpipe_raw_response)
+      allow(RubySMB::SMB1::Packet::Trans::TransactNmpipeResponse).to receive(:read).and_return(trans_nmpipe_response)
+      allow(trans_nmpipe_response).to receive_messages(
+        :valid?      => true,
+        :status_code => WindowsError::NTStatus::STATUS_SUCCESS
+      )
+      allow(trans_nmpipe_response).to receive_message_chain(:data_block, :trans_data, :read_data, :to_binary_s => raw_data)
+      allow(RubySMB::Dcerpc::Response).to receive(:read).and_return(dcerpc_response)
+      allow(dcerpc_response).to receive_message_chain(:pdu_header, :ptype => RubySMB::Dcerpc::PTypes::RESPONSE)
+      allow(dcerpc_response).to receive(:stub).and_return(result)
     end
 
-    describe '#bind' do
-      let(:options) { { endpoint: RubySMB::Dcerpc::Srvsvc } }
-      let(:bind_packet) { RubySMB::Dcerpc::Bind.new(options) }
-      let(:bind_ack_packet) { RubySMB::Dcerpc::BindAck.new }
+    it 'creates a Request packet with the expected arguments' do
+      pipe.dcerpc_request(stub_packet, options)
+      expect(options).to eq( { host: '1.2.3.4', endpoint: 'Winreg' })
+      expect(RubySMB::Dcerpc::Request).to have_received(:new).with({ opnum: stub_packet.opnum }, options)
+    end
 
-      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)
-      end
+    it 'sets DCERPC request stub to the stub packet passed as argument' do
+      pipe.dcerpc_request(stub_packet, options)
+      expect(request_stub).to have_received(:read).with(stub_packet.to_binary_s)
+    end
 
-      it 'creates a Bind packet' do
-        expect(RubySMB::Dcerpc::Bind).to receive(:new).with(options).and_return(bind_packet)
-        pipe.bind(options)
-      end
+    it 'creates a Trans TransactNmpipeRequest packet' do
+      pipe.dcerpc_request(stub_packet, options)
+      expect(RubySMB::SMB1::Packet::Trans::TransactNmpipeRequest).to have_received(:new).with(options)
+    end
 
-      it 'writes to the named pipe' do
-        expect(pipe).to receive(:write).with(data: bind_packet.to_binary_s)
-        pipe.bind(options)
-      end
+    it 'calls Tree #set_header_fields' do
+      pipe.dcerpc_request(stub_packet, options)
+      expect(tree).to have_received(:set_header_fields).with(trans_nmpipe_request)
+    end
 
-      it 'reads the socket' do
-        expect(pipe).to receive(:read)
-        pipe.bind(options)
+    it 'calls TransactNmpipeRequest #set_fid' do
+      pipe.dcerpc_request(stub_packet, options)
+      expect(trans_nmpipe_request).to have_received(:set_fid).with(pipe.fid)
+    end
+
+    it 'sets the expected #write_data request property' do
+      pipe.dcerpc_request(stub_packet, options)
+      expect(trans_data).to have_received(:write_data=).with(binary_dcerpc_request)
+    end
+
+    it 'sends the expected request' do
+      pipe.dcerpc_request(stub_packet, options)
+      expect(client).to have_received(:send_recv).with(trans_nmpipe_request)
+    end
+
+    it 'creates a Trans TransactNmpipeResponse packet from the response' do
+      pipe.dcerpc_request(stub_packet, options)
+      expect(RubySMB::SMB1::Packet::Trans::TransactNmpipeResponse).to have_received(:read).with(trans_nmpipe_raw_response)
+    end
+
+    context 'when the response is not a Trans packet' do
+      it 'raises an InvalidPacket exception' do
+        allow(trans_nmpipe_response).to receive_message_chain(:smb_header, :protocol)
+        allow(trans_nmpipe_response).to receive_message_chain(:smb_header, :command)
+        allow(trans_nmpipe_response).to receive(:valid?).and_return(false)
+        expect { pipe.dcerpc_request(stub_packet, options) }.to raise_error(RubySMB::Error::InvalidPacket)
       end
+    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)
-        expect(RubySMB::Dcerpc::BindAck).to receive(:read).with(raw_response).and_return(bind_ack_packet)
-        pipe.bind(options)
+    context 'when the response status code is not STATUS_SUCCESS or STATUS_BUFFER_OVERFLOW' do
+      it 'raises an UnexpectedStatusCode exception' do
+        allow(trans_nmpipe_response).to receive(:status_code).and_return(WindowsError::NTStatus::STATUS_INVALID_HANDLE)
+        expect { pipe.dcerpc_request(stub_packet, options) }.to raise_error(RubySMB::Error::UnexpectedStatusCode)
       end
+    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)
+    context 'when the response status code is STATUS_SUCCESS' do
+      it 'does not raise any exception' do
+        expect { pipe.dcerpc_request(stub_packet, options) }.not_to raise_error
       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)
+      it 'creates a DCERPC Response packet from the response' do
+        pipe.dcerpc_request(stub_packet, options)
+        expect(RubySMB::Dcerpc::Response).to have_received(:read).with(raw_data)
       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)
+      context 'when an IOError occurs while parsing the DCERPC response' do
+        it 'raises an InvalidPacket exception' do
+          allow(RubySMB::Dcerpc::Response).to receive(:read).and_raise(IOError)
+          expect { pipe.dcerpc_request(stub_packet, options) }.to raise_error(RubySMB::Dcerpc::Error::InvalidPacket)
+        end
       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)
+      context 'when the response is not a DCERPC Response packet' do
+        it 'raises an InvalidPacket exception' do
+          allow(dcerpc_response).to receive_message_chain(:pdu_header, :ptype => RubySMB::Dcerpc::PTypes::FAULT)
+          expect { pipe.dcerpc_request(stub_packet, options) }.to raise_error(RubySMB::Dcerpc::Error::InvalidPacket)
+        end
       end
 
-      it 'returns the expected BindAck packet' do
-        expect(pipe.bind(options)).to eq(bind_ack_packet)
+      it 'returns the expected stub data' do
+        expect(pipe.dcerpc_request(stub_packet, options)).to eq(result)
       end
     end
 
-    describe '#request' do
-      let(:options) { { host: '1.2.3.4' } }
-      let(:opnum) { RubySMB::Dcerpc::Srvsvc::NET_SHARE_ENUM_ALL }
-      let(:req_packet) { RubySMB::Dcerpc::Request.new({ :opnum => opnum }, options) }
-      let(:nmpipe_packet) { RubySMB::SMB1::Packet::Trans::TransactNmpipeRequest.new(options) }
-      let(:nmpipe_response) { RubySMB::SMB1::Packet::Trans::TransactNmpipeResponse.new }
-      let(:res_packet) { RubySMB::Dcerpc::Response.new }
-
+    context 'when the response status code is STATUS_BUFFER_OVERFLOW' do
+      let(:data_count)     { 100 }
+      let(:added_raw_data) { double('Added raw data') }
       before :example do
-        allow(RubySMB::Dcerpc::Request).to receive(:new).and_return(req_packet)
-        allow(RubySMB::SMB1::Packet::Trans::TransactNmpipeRequest).to receive(:new).and_return(nmpipe_packet)
-        allow(client).to receive(:send_recv)
-        allow(RubySMB::SMB1::Packet::Trans::TransactNmpipeResponse).to receive(:read).and_return(nmpipe_response)
-        allow(RubySMB::Dcerpc::Response).to receive(:read).and_return(res_packet)
+        allow(trans_nmpipe_response).to receive(:status_code).and_return(WindowsError::NTStatus::STATUS_BUFFER_OVERFLOW)
+        allow(trans_nmpipe_response).to receive_message_chain(:parameter_block, :data_count => data_count)
+        allow(pipe).to receive(:read).and_return(added_raw_data)
+        allow(raw_data).to receive(:<<)
+        allow(dcerpc_response).to receive_message_chain(:pdu_header, :pfc_flags, :first_frag => 1)
+        allow(dcerpc_response).to receive_message_chain(:pdu_header, :pfc_flags, :last_frag => 1)
       end
 
-      it 'creates a Request packet' do
-        expect(RubySMB::Dcerpc::Request).to receive(:new).and_return(req_packet)
-        pipe.request(opnum, options)
+      it 'does not raise any exception' do
+        expect { pipe.dcerpc_request(stub_packet, options) }.not_to raise_error
       end
 
-      it 'creates a Trans TransactNmpipeRequest packet' do
-        expect(RubySMB::SMB1::Packet::Trans::TransactNmpipeRequest).to receive(:new).and_return(nmpipe_packet)
-        pipe.request(opnum, options)
+      it 'reads the expected number of bytes and concatenate it the first response raw data' do
+        pipe.dcerpc_request(stub_packet, options)
+        expect(pipe).to have_received(:read).with(bytes: tree.client.max_buffer_size - data_count)
+        expect(raw_data).to have_received(:<<).with(added_raw_data)
       end
 
-      it 'calls Tree #set_header_fields' do
-        expect(tree).to receive(:set_header_fields).with(nmpipe_packet)
-        pipe.request(opnum, options)
+      it 'creates a DCERPC Response packet from the updated raw data' do
+        pipe.dcerpc_request(stub_packet, options)
+        expect(RubySMB::Dcerpc::Response).to have_received(:read).with(raw_data)
       end
 
-      it 'calls TransactNmpipeRequest #set_fid' do
-        expect(nmpipe_packet).to receive(:set_fid).with(pipe.fid)
-        pipe.request(opnum, options)
+      context 'when an IOError occurs while parsing the DCERPC response' do
+        it 'raises an InvalidPacket exception' do
+          allow(RubySMB::Dcerpc::Response).to receive(:read).and_raise(IOError)
+          expect { pipe.dcerpc_request(stub_packet, options) }.to raise_error(RubySMB::Dcerpc::Error::InvalidPacket)
+        end
       end
 
-      it 'sets the expected data on the request' do
-        expect(client).to receive(:send_recv) do
-          expect(nmpipe_packet.data_block.trans_data.write_data).to eq(req_packet.to_binary_s)
+      context 'when the response is not a DCERPC Response packet' do
+        it 'raises an InvalidPacket exception' do
+          allow(dcerpc_response).to receive_message_chain(:pdu_header, :ptype => RubySMB::Dcerpc::PTypes::FAULT)
+          expect { pipe.dcerpc_request(stub_packet, options) }.to raise_error(RubySMB::Dcerpc::Error::InvalidPacket)
         end
-        pipe.request(opnum, options)
       end
 
-      it 'sends the expected request' do
-        expect(client).to receive(:send_recv).with(nmpipe_packet)
-        pipe.request(opnum, options)
+      context 'when the response is not the first fragment' do
+        it 'raises an InvalidPacket exception' do
+          allow(dcerpc_response).to receive_message_chain(:pdu_header, :pfc_flags, :first_frag => 0)
+          expect { pipe.dcerpc_request(stub_packet, options) }.to raise_error(RubySMB::Dcerpc::Error::InvalidPacket)
+        end
       end
 
-      it 'creates a Trans TransactNmpipeResponse packet from the response' do
-        raw_response = double('Raw response')
-        allow(client).to receive(:send_recv).and_return(raw_response)
-        expect(RubySMB::SMB1::Packet::Trans::TransactNmpipeResponse).to receive(:read).with(raw_response).and_return(nmpipe_response)
-        pipe.request(opnum, options)
-      end
+      context 'when the response is the last fragment' do
+        it 'only reads the pipe once' do
+          pipe.dcerpc_request(stub_packet, options)
+          expect(RubySMB::Dcerpc::Response).to have_received(:read).once
+        end
 
-      it 'raises the expected exception when it is not a Trans packet' do
-        response = RubySMB::SMB1::Packet::Trans2::Response.new
-        allow(RubySMB::SMB1::Packet::Trans::TransactNmpipeResponse).to receive(:read).and_return(response)
-        expect { pipe.request(opnum, options) }.to raise_error(RubySMB::Error::InvalidPacket)
+        it 'returns the expected stub data' do
+          expect(pipe.dcerpc_request(stub_packet, options)).to eq(result)
+        end
       end
 
-      it 'raises the expected exception when the status code is not STATUS_SUCCESS' do
-        nmpipe_response.smb_header.nt_status = WindowsError::NTStatus::STATUS_INVALID_HANDLE.value
-        expect { pipe.request(opnum, options) }.to raise_error(RubySMB::Error::UnexpectedStatusCode)
-      end
+      context 'when the response is not the last fragment' do
+        let(:raw_data2)        { double('Raw data #2') }
+        let(:dcerpc_response2) { double('DCERPC Response #2') }
+        let(:result2)          { 'Result #2' }
+        before :example do
+          allow(dcerpc_response).to receive_message_chain(:pdu_header, :pfc_flags, :last_frag => 0)
+          allow(pipe).to receive(:read).with(bytes: tree.client.max_buffer_size).and_return(raw_data2)
+          allow(RubySMB::Dcerpc::Response).to receive(:read).with(raw_data2).and_return(dcerpc_response2)
+          allow(dcerpc_response2).to receive_message_chain(:pdu_header, :ptype => RubySMB::Dcerpc::PTypes::RESPONSE)
+          allow(dcerpc_response2).to receive_message_chain(:pdu_header, :pfc_flags, :last_frag => 1)
+          allow(dcerpc_response2).to receive(:stub).and_return(result2)
+        end
 
-      it 'creates a DCERPC Response packet from the response' do
-        nmpipe_response.data_block.trans_data.read_data = "test"
-        expect(RubySMB::Dcerpc::Response).to receive(:read).with(nmpipe_response.data_block.trans_data.read_data)
-        pipe.request(opnum, options)
-      end
+        it 'reads the expected number of bytes' do
+          pipe.dcerpc_request(stub_packet, options)
+          expect(pipe).to have_received(:read).with(bytes: tree.client.max_buffer_size)
+        end
 
-      it 'raises the expected exception when an invalid packet is received' do
-        allow(RubySMB::Dcerpc::Response).to receive(:read).and_raise(IOError)
-        expect { pipe.request(opnum, options) }.to raise_error(RubySMB::Dcerpc::Error::InvalidPacket)
-      end
+        it 'creates a DCERPC Response packet from the new raw data' do
+          pipe.dcerpc_request(stub_packet, options)
+          expect(RubySMB::Dcerpc::Response).to have_received(:read).with(raw_data2)
+        end
 
-      it 'raises the expected exception when it is not a Response packet' do
-        response = RubySMB::Dcerpc::Request.new
-        allow(RubySMB::Dcerpc::Response).to receive(:read).and_return(response)
-        expect { pipe.request(opnum, options) }.to raise_error(RubySMB::Dcerpc::Error::InvalidPacket)
-      end
+        context 'when an IOError occurs while parsing the new DCERPC response' do
+          it 'raises an InvalidPacket exception' do
+            allow(RubySMB::Dcerpc::Response).to receive(:read).with(raw_data2).and_raise(IOError)
+            expect { pipe.dcerpc_request(stub_packet, options) }.to raise_error(RubySMB::Dcerpc::Error::InvalidPacket)
+          end
+        end
 
-      it 'returns the expected DCERPC Response' do
-        expect(pipe.request(opnum, options)).to eq(res_packet)
+        context 'when the new response is not a DCERPC Response packet' do
+          it 'raises an InvalidPacket exception' do
+            allow(dcerpc_response2).to receive_message_chain(:pdu_header, :ptype => RubySMB::Dcerpc::PTypes::FAULT)
+            expect { pipe.dcerpc_request(stub_packet, options) }.to raise_error(RubySMB::Dcerpc::Error::InvalidPacket)
+          end
+        end
+
+        it 'returns the expected stub data' do
+          expect(pipe.dcerpc_request(stub_packet, options)).to eq(result)
+        end
       end
     end
   end
-
 end

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

@@ -46,25 +46,34 @@ RSpec.describe RubySMB::SMB1::Tree do
   end
 
   describe '#disconnect!' do
-    it 'calls #set_header_fields' do
+    let(:disco_response) { double('Response') }
+
+    before :example do
       allow(RubySMB::SMB1::Packet::TreeDisconnectRequest).to receive(:new).and_return(disco_req)
-      allow(client).to receive(:send_recv).and_return(disco_resp.to_binary_s)
+      allow(RubySMB::SMB1::Packet::TreeDisconnectResponse).to receive(:read).and_return(disco_resp)
+      allow(client).to receive(:send_recv)
+    end
+
+    it 'calls #set_header_fields' do
       expect(tree).to receive(:set_header_fields).with(disco_req)
       tree.disconnect!
     end
 
     it 'sends a TreeDisconnectRequest with the Tree ID in the header' do
-      allow(RubySMB::SMB1::Packet::TreeDisconnectRequest).to receive(:new).and_return(disco_req)
       modified_req = disco_req
       modified_req.smb_header.tid = tree.id
-      expect(client).to receive(:send_recv).with(modified_req).and_return(disco_resp.to_binary_s)
+      expect(client).to receive(:send_recv).with(modified_req)
       tree.disconnect!
     end
 
     it 'returns the NTStatus code from the response' do
-      allow(client).to receive(:send_recv).and_return(disco_resp.to_binary_s)
       expect(tree.disconnect!).to eq disco_resp.status_code
     end
+
+    it 'raises an InvalidPacket exception if the response is not valid' do
+      allow(disco_resp).to receive(:valid?).and_return(false)
+      expect { tree.disconnect! }.to raise_error(RubySMB::Error::InvalidPacket)
+    end
   end
 
   describe '#open_file' do
@@ -239,14 +248,14 @@ RSpec.describe RubySMB::SMB1::Tree do
       end
 
       context 'when the response is not a NtCreateAndxResponse packet' do
-        it 'raise an InvalidPacket exception' do
+        it 'raises an InvalidPacket exception' do
           nt_create_andx_response.smb_header.command = RubySMB::SMB1::Commands::SMB_COM_ECHO
           expect { tree.open_file(filename: filename) }.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
+        it 'raises an UnexpectedStatusCode exception' do
           nt_create_andx_response.smb_header.nt_status = WindowsError::NTStatus::STATUS_INVALID_HANDLE.value
           expect { tree.open_file(filename: filename) }.to raise_error(RubySMB::Error::UnexpectedStatusCode)
         end
@@ -342,6 +351,20 @@ RSpec.describe RubySMB::SMB1::Tree do
       expect(tree.list).to eq([file_info1, file_info2])
     end
 
+    context 'when the response is not a valid Trans2 FindFirst2Response' do
+      it 'raises an InvalidPacket exception' do
+        find_first2_res.smb_header.command = RubySMB::SMB1::Commands::SMB_COM_ECHO
+        expect { tree.list }.to raise_error(RubySMB::Error::InvalidPacket)
+      end
+    end
+
+    context 'when the response status code is not STATUS_SUCCESS' do
+      it 'raises an UnexpectedStatusCode exception' do
+        find_first2_res.smb_header.nt_status = WindowsError::NTStatus::STATUS_INVALID_HANDLE.value
+        expect { tree.list }.to raise_error(RubySMB::Error::UnexpectedStatusCode)
+      end
+    end
+
     context 'when more requests are needed to get all the information' do
       let(:find_next2_req) { RubySMB::SMB1::Packet::Trans2::FindNext2Request.new }
       let(:file_info2) do
@@ -414,6 +437,20 @@ RSpec.describe RubySMB::SMB1::Tree do
       it 'returns the expected FindFileFullDirectoryInfo structures' do
         expect(tree.list).to eq([file_info1, file_info2])
       end
+
+      context 'when the response is not a valid Trans2 FindNext2Response' do
+        it 'raises an InvalidPacket exception' do
+          find_next2_res.smb_header.command = RubySMB::SMB1::Commands::SMB_COM_ECHO
+          expect { tree.list }.to raise_error(RubySMB::Error::InvalidPacket)
+        end
+      end
+
+      context 'when the response status code is not STATUS_SUCCESS' do
+        it 'raises an UnexpectedStatusCode exception' do
+          find_next2_res.smb_header.nt_status = WindowsError::NTStatus::STATUS_INVALID_HANDLE.value
+          expect { tree.list }.to raise_error(RubySMB::Error::UnexpectedStatusCode)
+        end
+      end
     end
   end