ruby_smb 1.0.5 → 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/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

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) {
@@ -124,201 +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 '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 'reads the socket' do
-        expect(pipe).to receive(:read)
-        pipe.bind(options)
+    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
-        nmpipe_response.smb_header.command = RubySMB::SMB1::Commands::SMB_COM_TRANSACTION2
-        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