ruby_smb 1.0.3 → 2.0.1

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

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

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

@@ -10,8 +10,8 @@ RSpec.describe RubySMB::SMB1::Packet::SessionSetupLegacyRequest do
       expect(header).to be_a RubySMB::SMB1::SMBHeader
     end
 
-    it 'should have the command set to SMB_COM_NEGOTIATE' do
-      expect(header.command).to eq RubySMB::SMB1::Commands::SMB_COM_SESSION_SETUP
+    it 'should have the command set to SMB_COM_SESSION_SETUP_ANDX' do
+      expect(header.command).to eq RubySMB::SMB1::Commands::SMB_COM_SESSION_SETUP_ANDX
     end
 
     it 'should not have the response flag set' do

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

@@ -10,8 +10,8 @@ RSpec.describe RubySMB::SMB1::Packet::SessionSetupLegacyResponse do
       expect(header).to be_a RubySMB::SMB1::SMBHeader
     end
 
-    it 'should have the command set to SMB_COM_NEGOTIATE' do
-      expect(header.command).to eq RubySMB::SMB1::Commands::SMB_COM_SESSION_SETUP
+    it 'should have the command set to SMB_COM_SESSION_SETUP_ANDX' do
+      expect(header.command).to eq RubySMB::SMB1::Commands::SMB_COM_SESSION_SETUP_ANDX
     end
 
     it 'should have the response flag set' do

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

@@ -10,8 +10,8 @@ RSpec.describe RubySMB::SMB1::Packet::SessionSetupRequest do
       expect(header).to be_a RubySMB::SMB1::SMBHeader
     end
 
-    it 'should have the command set to SMB_COM_NEGOTIATE' do
-      expect(header.command).to eq RubySMB::SMB1::Commands::SMB_COM_SESSION_SETUP
+    it 'should have the command set to SMB_COM_SESSION_SETUP_ANDX' do
+      expect(header.command).to eq RubySMB::SMB1::Commands::SMB_COM_SESSION_SETUP_ANDX
     end
 
     it 'should not have the response flag set' do

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

@@ -11,7 +11,7 @@ RSpec.describe RubySMB::SMB1::Packet::SessionSetupResponse do
     end
 
     it 'should have the command set to SMB_COM_NEGOTIATE' do
-      expect(header.command).to eq RubySMB::SMB1::Commands::SMB_COM_SESSION_SETUP
+      expect(header.command).to eq RubySMB::SMB1::Commands::SMB_COM_SESSION_SETUP_ANDX
     end
 
     it 'should have the response flag set' do

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

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

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

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

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

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

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