ruby_smb 0.0.18 → 0.0.19

data/spec/lib/ruby_smb/dcerpc/bind_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+RSpec.describe RubySMB::Dcerpc::Bind do
+
+  describe '#initialize' do
+
+    let(:bind){described_class.new(endpoint: RubySMB::Dcerpc::Srvsvc)}
+    let(:abstract_syntax){bind.p_context_elem.p_cont_elem[0].abstract_syntax}
+
+    it 'should set the abstract syntax to SrvsvcSyntax' do
+      expect(abstract_syntax).to eq RubySMB::Dcerpc::Srvsvc::SrvSvcSyntax.new
+    end
+  end
+end

data/spec/lib/ruby_smb/dcerpc/handle_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+RSpec.describe RubySMB::Dcerpc::Handle do
+
+  describe 'A dce/rpc handle' do
+    let(:output){double('Output')}
+    let(:tree){double('Tree')}
+    let(:response){double('Response')}
+    let(:file){double('File')}
+    let(:handle){described_class.new(file)}
+    let(:endpoint){ RubySMB::Dcerpc::Srvsvc }
+    let(:ioctl_response){ double('IoctlResponse') }
+
+    it 'should #bind' do
+      expect(handle).to receive(:ioctl_request)#.with([response_socket], nil, nil, timeout)
+      handle.bind(endpoint: endpoint)
+    end
+
+    it 'should #request' do
+      expect(handle).to receive(:ioctl_request)#.with([response_socket], nil, nil, timeout)
+      handle.request(opnum: 15, stub: RubySMB::Dcerpc::Srvsvc::NetShareEnumAll, options: {host: '127.0.0.1'})
+    end
+
+    it 'should #handle_msg' do
+      expect(ioctl_response).to receive(:buffer).and_return RubySMB::Dcerpc::Response.new.stub
+      expect(RubySMB::Dcerpc::PduHeader).to receive(:read).and_return(RubySMB::Dcerpc::PduHeader.new(ptype: 1))
+      expect(handle.handle_msg(ioctl_response)).to eq(RubySMB::Dcerpc::Response.new.stub.to_binary_s)
+    end
+  end
+  
+end

data/spec/lib/ruby_smb/dcerpc/request_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+RSpec.describe RubySMB::Dcerpc::Request do
+
+  describe 'when making a NetShareEnumAll dcerpc request' do
+    let(:request){
+      described_class.new(
+          opnum: RubySMB::Dcerpc::Srvsvc::NetShareEnumAll::Opnum,
+          stub: RubySMB::Dcerpc::Srvsvc::NetShareEnumAll.new(host: '192.161.204.122').to_binary_s
+      )
+    }
+
+    it 'should create a Request struct with NetShareEnumAll as stub with size of 106' do
+      expect(request.do_num_bytes).to eq 104
+    end
+
+    it 'should set the correct opnum' do
+      expect(request.opnum).to eq 0xF
+    end
+  end
+end

data/spec/lib/ruby_smb/dcerpc/response_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+RSpec.describe RubySMB::Dcerpc::Response do
+
+  let(:raw_response){'0500020310000000b801000000000000a00100000000000001000000010000000000020006000000040002000600000008000200000000800c00020010000200000000001400020018000200000000801c00020020000200000000002400020028000200030000802c000200300002000000000034000200070000000000000007000000410044004d0049004e002400000000000d000000000000000d000000520065006d006f00740065002000410064006d0069006e0000000000020000000000000002000000430000000100000000000000010000000000000003000000000000000300000043002400000000000e000000000000000e000000440065006600610075006c007400200073006800610072006500000007000000000000000700000064006f00670065003600340000000000010000000000000001000000000000000500000000000000050000004900500043002400000000000b000000000000000b000000520065006d006f00740065002000490050004300000000000600000000000000060000005500730065007200730000000100000000000000010000000000000006000000380002000000000000000000'.strip.gsub(/([A-Fa-f0-9]{1,2})\s*?/) { $1.hex.chr }}
+
+  describe '#read' do
+
+    let(:response){described_class.read(raw_response)}
+
+    it 'should use the alloc_hint to determine stub length' do
+      expect(response.stub.do_num_bytes).to eq response.alloc_hint
+    end
+  end
+end

data/spec/lib/ruby_smb/dcerpc/srvsvc_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+RSpec.describe RubySMB::Dcerpc::Srvsvc do
+
+  describe 'when making a NetShareEnumAll struct' do
+    let(:stub){ RubySMB::Dcerpc::Srvsvc::NetShareEnumAll.new(host: '192.161.204.122') }
+
+    it 'crafts an 8 octet aligned stub' do
+      expect(stub.do_num_bytes).to eq 80
+    end
+  end
+
+end

data/spec/lib/ruby_smb/dcerpc/uuid_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+RSpec.describe RubySMB::Dcerpc::Uuid do
+  let(:uuid_string){'8a885d04-1ceb-11c9-9fe8-08002b104860'}
+  let(:uuid){RubySMB::Dcerpc::Uuid.new(initial_value: uuid_string)}
+
+  describe '#initialize' do
+    it 'should create a 16 byte struct' do
+      expect(uuid.do_num_bytes).to be 16
+    end
+  end
+end

data/spec/lib/ruby_smb/dispatcher/base_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+RSpec.describe RubySMB::Dispatcher::Base do
+  subject(:dispatcher) { described_class.new }
+  let(:session_header) { RubySMB::Nbss::SessionHeader.new }
+  let(:packet) { RubySMB::SMB1::Packet::NegotiateRequest.new }
+
+  describe '#nbss' do
+    it 'creates a SessionHeader packet' do
+      expect(RubySMB::Nbss::SessionHeader).to receive(:new).and_return(session_header)
+      dispatcher.nbss(packet)
+    end
+
+    it 'returns the size of the packet to the packet in 4 bytes' do
+      expect(dispatcher.nbss(packet)).to eq "\x00\x00\x00\x23"
+    end
+  end
+
+  it 'raises NotImplementedError on #send_packet' do
+    expect { dispatcher.send_packet('foo') }.to raise_error(NotImplementedError)
+  end
+
+  it 'raises NotImplementedError on #recv_packet' do
+    expect { dispatcher.recv_packet }.to raise_error(NotImplementedError)
+  end
+end

data/spec/lib/ruby_smb/dispatcher/socket_spec.rb

@@ -1,8 +1,6 @@
 RSpec.describe RubySMB::Dispatcher::Socket do
   class FakeSocket < StringIO
-    def setsockopt(*args)
-
-    end
+    def setsockopt(*args); end
   end
 
   let(:fake_tcp_socket) {
@@ -16,7 +14,7 @@ RSpec.describe RubySMB::Dispatcher::Socket do
 
   # Don't try to actually select on our StringIO fake socket
   before(:each) do
-    allow(IO).to receive(:select).and_return(nil)
+    allow(IO).to receive(:select).and_return([])
   end
 
   it 'should attempt to set KEEPALIVE on the socket' do
@@ -24,6 +22,15 @@ RSpec.describe RubySMB::Dispatcher::Socket do
     described_class.new(fake_tcp_socket)
   end
 
+  it 'sets the default read_timeout value to READ_TIMEOUT' do
+    expect(described_class.new(fake_tcp_socket).read_timeout).to eq(described_class::READ_TIMEOUT)
+  end
+
+  it 'accepts a read_timeout value as arguments' do
+    read_timeout = 10
+    expect(described_class.new(fake_tcp_socket, read_timeout: read_timeout).read_timeout).to eq(read_timeout)
+  end
+
   describe '#connect' do
     it 'should support setting a custom socket object' do
       socket = described_class.connect('172.16.22.165', socket: fake_tcp_socket)
@@ -39,35 +46,128 @@ RSpec.describe RubySMB::Dispatcher::Socket do
   end
 
   describe '#recv_packet' do
-    let(:blank_socket) { StringIO.new('') }
+    let(:blank_socket)    { StringIO.new('') }
     let(:response_socket) { StringIO.new(response_packet) }
+    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
+        smb_socket.tcp_socket = blank_socket
+        expect { smb_socket.recv_packet }.to raise_error(::RubySMB::Error::NetBiosSessionService)
+      end
+    end
 
-    describe 'when reading from the socket results in a nil value' do
+    context 'when reading from the socket results in an empty value' do
       it 'should raise Error::NetBiosSessionService' do
         smb_socket.tcp_socket = blank_socket
+        allow(blank_socket).to receive(:read).and_return('')
         expect { smb_socket.recv_packet }.to raise_error(::RubySMB::Error::NetBiosSessionService)
       end
     end
 
-    describe 'when reading an SMB Response packet' do
-      it 'reads a number of bytes defined in the nbss header' do
+    context 'when a socket error occurs' do
+      it 'raises a CommunicationError exception' do
+        expect(fake_tcp_socket).to receive(:read).and_raise(Errno::ECONNRESET)
+        expect { smb_socket.recv_packet }.to raise_error(RubySMB::Error::CommunicationError)
+      end
+    end
+
+    context 'when the read_timeout expires' do
+      it 'raises a CommunicationError exception' do
+        allow(IO).to receive(:select).and_return(nil)
+        expect { smb_socket.recv_packet }.to raise_error(RubySMB::Error::CommunicationError)
+      end
+    end
+
+    context 'when reading an SMB Response packet' do
+      before :example do
         smb_socket.tcp_socket = response_socket
-        expect(response_socket).to receive(:read).with(4).and_call_original
-        expect(response_socket).to receive(:read).with(negotiate_response.do_num_bytes).and_call_original
+      end
+
+      it 'reads the nbss header using Nbss::SessionHeader structure' do
+        expect(RubySMB::Nbss::SessionHeader).to receive(:read).with(response_socket).and_return(session_header)
         smb_socket.recv_packet
       end
-    end
 
-    it 'raises a CommunicationError if it encounters a socket error' do
-      expect(fake_tcp_socket).to receive(:read).and_raise(Errno::ECONNRESET)
-      expect{ smb_socket.recv_packet }.to raise_error(RubySMB::Error::CommunicationError)
+      it 'uses the default read_timeout with IO#select when it has not been specifically defined' do
+        expect(IO).to receive(:select).with([response_socket], nil, nil, described_class::READ_TIMEOUT).and_return([]).twice
+        smb_socket.recv_packet
+      end
+
+      it 'uses the defined read_timeout with IO#select' do
+        timeout = 10
+        smb_socket.read_timeout = timeout
+        expect(IO).to receive(:select).with([response_socket], nil, nil, timeout).and_return([]).twice
+        smb_socket.recv_packet
+      end
+
+      it 'reads the number of bytes specified in the nbss header' do
+        packet_length = 10
+        session_header.packet_length = packet_length
+        allow(RubySMB::Nbss::SessionHeader).to receive(:read).and_return(session_header)
+        expect(response_socket).to receive(:read).with(packet_length).and_return('A' * packet_length)
+        smb_socket.recv_packet
+      end
+
+      context 'when the socket does not return everything the first time' do
+        it 'calls #read several times until everything is returned' do
+          packet_length = 67
+          returned_length = 10
+          session_header.packet_length = packet_length
+          allow(RubySMB::Nbss::SessionHeader).to receive(:read).and_return(session_header)
+
+          loop do
+            expect(response_socket).to receive(:read).with(packet_length).and_return('A' * returned_length).once
+            packet_length -= returned_length
+            break if packet_length <= 0
+          end
+          smb_socket.recv_packet
+        end
+      end
+
+      context 'when the full_response argument is true' do
+        it 'returns the full packet including the nbss header' do
+          expect(smb_socket.recv_packet(full_response: true)).to eq(response_packet)
+        end
+
+        context 'when the SMB packet is empty' do
+          it 'returns the nbss header only' do
+            session_header.packet_length = 0
+            allow(RubySMB::Nbss::SessionHeader).to receive(:read).and_return(session_header)
+            expect(smb_socket.recv_packet(full_response: true)).to eq(session_header.to_binary_s)
+          end
+        end
+      end
+
+      context 'when the full_response argument is false' do
+        it 'returns the SMB packet without the nbss header' do
+          expect(smb_socket.recv_packet(full_response: false)).to eq(negotiate_response.to_binary_s)
+        end
+
+        context 'when the SMB packet is empty' do
+          it 'returns an empty string' do
+            session_header.packet_length = 0
+            allow(RubySMB::Nbss::SessionHeader).to receive(:read).and_return(session_header)
+            expect(smb_socket.recv_packet(full_response: false)).to eq('')
+          end
+        end
+      end
     end
   end
 
   describe '#send_packet' do
-    it 'calls nbss to create the nbss header for the packet' do
-      expect(smb_socket).to receive(:nbss).with(negotiate_response).and_return(nbss)
-      smb_socket.send_packet(negotiate_response)
+    context 'when nbss_header argument is true' do
+      it 'calls #nbss to create the nbss header for the packet' do
+        expect(smb_socket).to receive(:nbss).with(negotiate_response).and_return(nbss)
+        smb_socket.send_packet(negotiate_response, nbss_header: true)
+      end
+    end
+
+    context 'when nbss_header argument is false' do
+      it 'does not call #nbss' do
+        expect(smb_socket).to_not receive(:nbss)
+        smb_socket.send_packet(negotiate_response, nbss_header: false)
+      end
     end
 
     it 'writes the packet to the socket' do
@@ -77,7 +177,7 @@ RSpec.describe RubySMB::Dispatcher::Socket do
 
     it 'raises a CommunicationError if it encounters a socket error' do
       expect(fake_tcp_socket).to receive(:write).and_raise(Errno::ECONNRESET)
-      expect{ smb_socket.send_packet(negotiate_response) }.to raise_error(RubySMB::Error::CommunicationError)
+      expect { smb_socket.send_packet(negotiate_response) }.to raise_error(RubySMB::Error::CommunicationError)
     end
   end
 end

data/spec/lib/ruby_smb/field/extended_attribute_flag_spec.rb

@@ -3,14 +3,11 @@ RSpec.describe RubySMB::Field::ExtendedAttributeFlag do
 
   it { is_expected.to respond_to :file_need_ea }
 
-
   describe 'file_need_ea' do
     it 'should be a 1-bit field per the SMB spec' do
       expect(flag.file_need_ea).to be_a BinData::Bit1
     end
 
-
     it_behaves_like 'bit field with one flag set', :file_need_ea, 'C', 0x80
   end
-
 end

data/spec/lib/ruby_smb/field/file_time_spec.rb

@@ -1,3 +1,5 @@
+require 'date'
+
 RSpec.describe RubySMB::Field::FileTime do
   subject(:file_time) { described_class.read(binary_filetime) }
 
@@ -42,13 +44,13 @@ RSpec.describe RubySMB::Field::FileTime do
     it 'will take a Time object correctly but lose Nanoseconds' do
       empty_filetime.set time_filetime
       val = empty_filetime.get
-      expect(val / 10_000_000).to eq (int_filetime / 10_000_000)
+      expect(val / 10_000_000).to eq(int_filetime / 10_000_000)
     end
 
     it 'will take a DateTime object correctly but lose Nanoseconds' do
       empty_filetime.set datetime_filetime
       val = empty_filetime.get
-      expect(val / 10_000_000).to eq (int_filetime / 10_000_000)
+      expect(val / 10_000_000).to eq(int_filetime / 10_000_000)
     end
 
     it 'will accept a raw integer value and set it' do

data/spec/lib/ruby_smb/field/security_descriptor.rb

@@ -191,4 +191,3 @@ RSpec.describe RubySMB::Field::SecurityDescriptor do
     end
   end
 end
-

data/spec/lib/ruby_smb/field/smb2_fileid_spec.rb

@@ -0,0 +1,10 @@
+RSpec.describe RubySMB::Field::Smb2Fileid do
+  subject(:fea) { described_class.new }
+
+  it { is_expected.to respond_to :persistent }
+  it { is_expected.to respond_to :volatile }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+end

data/spec/lib/ruby_smb/field/smb_fea_list_spec.rb

@@ -1,23 +1,21 @@
 RSpec.describe RubySMB::Field::SmbFeaList do
   subject(:list) { described_class.new }
-  let(:fea1)  {
+  let(:fea1) {
     fea = RubySMB::Field::SmbFea.new
     fea.attribute_name  = 'foo'
     fea.attribute_value = 'bar'
     fea
   }
-  let(:fea2)  {
+  let(:fea2) {
     fea = RubySMB::Field::SmbFea.new
     fea.attribute_name  = 'hello world'
     fea.attribute_value = 'this is a test'
     fea
   }
 
-
   it { is_expected.to respond_to :size_of_list }
   it { is_expected.to respond_to :fea_list }
 
-
   it 'is little endian' do
     expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
   end
@@ -32,7 +30,7 @@ RSpec.describe RubySMB::Field::SmbFeaList do
       list.fea_list << fea1
       expect(list.size_of_list).to eq fea1.do_num_bytes
       list.fea_list << fea2
-      expect(list.size_of_list).to eq (fea1.do_num_bytes + fea2.do_num_bytes )
+      expect(list.size_of_list).to eq(fea1.do_num_bytes + fea2.do_num_bytes)
     end
   end
 end

data/spec/lib/ruby_smb/field/smb_gea_list_spec.rb

@@ -0,0 +1,37 @@
+RSpec.describe RubySMB::Field::SmbGeaList do
+  subject(:list) { described_class.new }
+  let(:gea1) {
+    fea = RubySMB::Field::SmbGea.new
+    fea.attribute_name = 'foo'
+    fea
+  }
+  let(:gea2) {
+    fea = RubySMB::Field::SmbGea.new
+    fea.attribute_name = 'hello world'
+    fea
+  }
+
+  it { is_expected.to respond_to :size_of_list }
+  it { is_expected.to respond_to :gea_list }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#size_of_list' do
+    it 'shows the size, in bytes, of the fea_list' do
+      list.gea_list << gea1
+      total_size = list.size_of_list.do_num_bytes + gea1.do_num_bytes
+      expect(list.size_of_list).to eq total_size
+    end
+
+    it 'changes dynamically as new GEAs are added' do
+      list.gea_list << gea1
+      total_size = list.size_of_list.do_num_bytes + gea1.do_num_bytes
+      expect(list.size_of_list).to eq total_size
+      list.gea_list << gea2
+      total_size += gea2.do_num_bytes
+      expect(list.size_of_list).to eq total_size
+    end
+  end
+end