ruby_smb 2.0.2 → 3.0.0

data/spec/lib/ruby_smb/smb2/file_spec.rb

@@ -107,6 +107,10 @@ RSpec.describe RubySMB::SMB2::File do
     it 'sets the offset of the packet' do
       expect(file.read_packet(offset: 55).offset).to eq 55
     end
+
+    it 'sets the credit_charge of the packet' do
+      expect(file.read_packet(credit_charge: 3).smb2_header.credit_charge).to eq 3
+    end
   end
 
   describe '#read' do
@@ -125,7 +129,7 @@ RSpec.describe RubySMB::SMB2::File do
       end
 
       it 'uses a single packet to read the entire file' do
-        expect(file).to receive(:read_packet).with(read_length: 108, offset: 0).and_return(small_read)
+        expect(file).to receive(:read_packet).with(read_length: 108, offset: 0, credit_charge: 0).and_return(small_read)
         expect(client).to receive(:send_recv).with(small_read, encrypt: false).and_return 'fake data'
         expect(RubySMB::SMB2::Packet::ReadResponse).to receive(:read).with('fake data').and_return(small_response)
         expect(file.read).to eq 'fake data'
@@ -161,14 +165,15 @@ RSpec.describe RubySMB::SMB2::File do
       }
 
       before :example do
+        client.server_supports_multi_credit = 1
         allow(file).to receive(:read_packet)
         allow(client).to receive(:send_recv)
         allow(RubySMB::SMB2::Packet::ReadResponse).to receive(:read).and_return(big_response)
       end
 
-      it 'uses a multiple packet to read the file in chunks' do
-        expect(file).to receive(:read_packet).once.with(read_length: described_class::MAX_PACKET_SIZE, offset: 0).and_return(big_read)
-        expect(file).to receive(:read_packet).once.with(read_length: described_class::MAX_PACKET_SIZE, offset: described_class::MAX_PACKET_SIZE).and_return(big_read)
+      it 'uses multiple packets to read the file in chunks' do
+        expect(file).to receive(:read_packet).once.with(read_length: described_class::MAX_PACKET_SIZE, offset: 0, credit_charge: 1).and_return(big_read)
+        expect(file).to receive(:read_packet).once.with(read_length: described_class::MAX_PACKET_SIZE, offset: described_class::MAX_PACKET_SIZE, credit_charge: 1).and_return(big_read)
         expect(client).to receive(:send_recv).twice.and_return 'fake data'
         expect(RubySMB::SMB2::Packet::ReadResponse).to receive(:read).twice.with('fake data').and_return(big_response)
         file.read(bytes: (described_class::MAX_PACKET_SIZE * 2))
@@ -184,7 +189,7 @@ RSpec.describe RubySMB::SMB2::File do
 
       context 'when the second response is not valid' do
         it 'raise an InvalidPacket exception' do
-          allow(file).to receive(:read_packet).with(read_length: described_class::MAX_PACKET_SIZE, offset: described_class::MAX_PACKET_SIZE) do
+          allow(file).to receive(:read_packet).with(read_length: described_class::MAX_PACKET_SIZE, offset: described_class::MAX_PACKET_SIZE, credit_charge: 1) do
             big_response.smb2_header.command = RubySMB::SMB2::Commands::LOGOFF
           end
           expect { file.read(bytes: (described_class::MAX_PACKET_SIZE * 2)) }.to raise_error(RubySMB::Error::InvalidPacket)
@@ -193,12 +198,31 @@ RSpec.describe RubySMB::SMB2::File do
 
       context 'when the second response status code is not STATUS_SUCCESS' do
         it 'raise an UnexpectedStatusCode exception' do
-          allow(file).to receive(:read_packet).with(read_length: described_class::MAX_PACKET_SIZE, offset: described_class::MAX_PACKET_SIZE) do
+          allow(file).to receive(:read_packet).with(read_length: described_class::MAX_PACKET_SIZE, offset: described_class::MAX_PACKET_SIZE, credit_charge: 1) do
             big_response.smb2_header.nt_status = WindowsError::NTStatus::STATUS_INVALID_HANDLE.value
           end
           expect { file.read(bytes: (described_class::MAX_PACKET_SIZE * 2)) }.to raise_error(RubySMB::Error::UnexpectedStatusCode)
         end
       end
+
+      context 'when the server does not support multi credits' do
+        it 'reads 65536 bytes at a time with no credit charge' do
+          client.server_supports_multi_credit = false
+          expect(file).to receive(:read_packet).once.with(read_length: 65536, offset: 0, credit_charge: 0).and_return(big_read)
+          expect(file).to receive(:read_packet).once.with(read_length: 65536, offset: 65536, credit_charge: 0).and_return(big_read)
+          file.read(bytes: (described_class::MAX_PACKET_SIZE * 4))
+        end
+      end
+
+      context 'when the server supports multi credits' do
+        it 'reads a number of bytes equal to #server_max_read_size, with the expected credit charge' do
+          credit_charge = (90000 - 1) / 65536 + 1
+          client.server_max_read_size = 90000
+          expect(file).to receive(:read_packet).once.with(read_length: 90000, offset: 0, credit_charge: credit_charge).and_return(big_read)
+          expect(file).to receive(:read_packet).once.with(read_length: (described_class::MAX_PACKET_SIZE * 4 - 90000), offset: 90000, credit_charge: credit_charge).and_return(big_read)
+          file.read(bytes: (described_class::MAX_PACKET_SIZE * 4))
+        end
+      end
     end
   end
 
@@ -222,6 +246,10 @@ RSpec.describe RubySMB::SMB2::File do
     it 'sets the buffer on the packet' do
       expect(file.write_packet(data:'hello').buffer).to eq 'hello'
     end
+
+    it 'sets the credit_charge on the packet header' do
+      expect(file.write_packet(credit_charge: 5).smb2_header.credit_charge).to eq 5
+    end
   end
 
   describe '#write' do
@@ -242,6 +270,11 @@ RSpec.describe RubySMB::SMB2::File do
     end
 
     context 'for a large write' do
+      before :example do
+        allow(client).to receive(:send_recv).and_return(write_response.to_binary_s)
+        client.server_supports_multi_credit = 1
+      end
+
       it 'sends multiple packets' do
         expect(client).to receive(:send_recv).twice.and_return(write_response.to_binary_s)
         file.write(data: SecureRandom.random_bytes(described_class::MAX_PACKET_SIZE + 1))
@@ -254,6 +287,27 @@ RSpec.describe RubySMB::SMB2::File do
         expect(client).to receive(:send_recv).twice.with(write_request, encrypt: true).and_return(write_response.to_binary_s)
         file.write(data: SecureRandom.random_bytes(described_class::MAX_PACKET_SIZE + 1))
       end
+
+      context 'when the server does not support multi credits' do
+        it 'writes 65536 bytes at a time with no credit charge' do
+          client.server_supports_multi_credit = false
+          data = SecureRandom.random_bytes(65536 * 2)
+          expect(file).to receive(:write_packet).once.with(data: data[0, 65536], offset: 0, credit_charge: 0)
+          expect(file).to receive(:write_packet).once.with(data: data[65536, (data.size - 65536)], offset: 65536, credit_charge: 0)
+          file.write(data: data)
+        end
+      end
+
+      context 'when the server supports multi credits' do
+        it 'reads a number of bytes equal to #server_max_write_size, with the expected credit charge' do
+          data = SecureRandom.random_bytes(90000 * 2)
+          credit_charge = (90000 - 1) / 65536 + 1
+          client.server_max_write_size = 90000
+          expect(file).to receive(:write_packet).once.with(data: data[0, 90000], offset: 0, credit_charge: credit_charge)
+          expect(file).to receive(:write_packet).once.with(data: data[90000, (data.size - 90000)], offset: 90000, credit_charge: credit_charge)
+          file.write(data: data)
+        end
+      end
     end
 
     it 'raises an InvalidPacket exception if the response is not valid' do
@@ -405,9 +459,7 @@ RSpec.describe RubySMB::SMB2::File do
 
     it 'raises an InvalidPacket exception if the response is not valid' do
       allow(response).to receive(:valid?).and_return(false)
-      smb2_header = double('SMB2 Header')
-      allow(response).to receive(:smb2_header).and_return(smb2_header)
-      allow(smb2_header).to receive_messages(:protocol => nil, :command => nil)
+      allow(response).to receive(:packet_smb_version)
       expect { file.close }.to raise_error(RubySMB::Error::InvalidPacket)
     end
 

data/spec/lib/ruby_smb/smb2/negotiate_context_spec.rb

@@ -162,7 +162,7 @@ RSpec.describe RubySMB::SMB2::CompressionCapabilities do
   end
 end
 
-RSpec.describe RubySMB::SMB2::NetnameNegotiateContextId  do
+RSpec.describe RubySMB::SMB2::NetnameNegotiateContextId do
   subject(:capability) { described_class.new }
 
   it { is_expected.to respond_to :net_name }
@@ -173,7 +173,7 @@ RSpec.describe RubySMB::SMB2::NetnameNegotiateContextId  do
 
   describe '#net_name' do
     it 'is a unicode string' do
-      expect(capability.net_name).to be_a RubySMB::Field::Stringz16
+      expect(capability.net_name).to be_a RubySMB::Field::String16
     end
   end
 

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

@@ -86,9 +86,7 @@ RSpec.describe RubySMB::SMB2::Pipe do
 
     it 'raises an InvalidPacket exception if the response is not valid' do
       allow(response).to receive(:valid?).and_return(false)
-      smb2_header = double('SMB2 Header')
-      allow(response).to receive(:smb2_header).and_return(smb2_header)
-      allow(smb2_header).to receive_messages(:protocol => nil, :command => nil)
+      allow(response).to receive(:packet_smb_version)
       expect { pipe.peek }.to raise_error(RubySMB::Error::InvalidPacket)
     end
 
@@ -148,17 +146,26 @@ RSpec.describe RubySMB::SMB2::Pipe do
       expect(pipe.size_on_disk).to eq(create_response.allocation_size)
     end
 
-    context 'with \'srvsvc\' filename' do
-      it 'extends Srvsvc class' do
-        pipe = described_class.new(tree: tree, response: create_response, name: 'srvsvc')
-        expect(pipe.respond_to?(:net_share_enum_all)).to be true
+    {
+      netlogon: RubySMB::Dcerpc::Netlogon,
+      srvsvc: RubySMB::Dcerpc::Srvsvc,
+      svcctl: RubySMB::Dcerpc::Svcctl,
+      winreg: RubySMB::Dcerpc::Winreg,
+      samr: RubySMB::Dcerpc::Samr,
+      wkssvc: RubySMB::Dcerpc::Wkssvc
+    }.each do |endpoint, klass|
+      context "with \'#{endpoint}\' filename" do
+        it "extends #{klass} class" do
+          pipe = described_class.new(tree: tree, response: create_response, name: endpoint.to_s)
+          expect(pipe).to be_a klass
+        end
       end
-    end
 
-    context 'with \'winreg\' filename' do
-      it 'extends Winreg class' do
-        pipe = described_class.new(tree: tree, response: create_response, name: 'winreg')
-        expect(pipe.respond_to?(:has_registry_key?)).to be true
+      context "with \'\\#{endpoint}\' filename" do
+        it "extends #{klass} class" do
+          pipe = described_class.new(tree: tree, response: create_response, name: "\\#{endpoint.to_s}")
+          expect(pipe).to be_a klass
+        end
       end
     end
   end
@@ -254,8 +261,7 @@ RSpec.describe RubySMB::SMB2::Pipe do
 
     context 'when the response is not an IoctlResponse packet' do
       it 'raises an InvalidPacket exception' do
-        allow(ioctl_response).to receive_message_chain(:smb2_header, :protocol)
-        allow(ioctl_response).to receive_message_chain(:smb2_header, :command)
+        allow(ioctl_response).to receive(:packet_smb_version)
         allow(ioctl_response).to receive(:valid?).and_return(false)
         expect { pipe.ioctl_send_recv(dcerpc_request, options) }.to raise_error(RubySMB::Error::InvalidPacket)
       end

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

@@ -195,7 +195,7 @@ RSpec.describe RubySMB::SMB2::Tree do
       allow(client).to receive(:send_recv) do |packet|
         expect(packet.file_information_class).to eq RubySMB::Fscc::FileInformation::FileIdFullDirectoryInformation::CLASS_LEVEL
         expect(packet.name).to eq '*'.encode('UTF-16LE')
-        expect(packet.output_length).to eq 65_535
+        expect(packet.output_length).to eq 65_536
       end
       tree.list
     end
@@ -288,6 +288,40 @@ RSpec.describe RubySMB::SMB2::Tree do
       end
     end
 
+    context 'when the dialect is 0x0202' do
+      it 'sets the packet output_length to 65536 and credit_charge header to 0' do
+        client.dialect = '0x0202'
+        allow(client).to receive(:send_recv) do |packet|
+          expect(packet.output_length).to eq(65536)
+          expect(packet.smb2_header.credit_charge).to eq(0)
+        end
+        tree.list
+      end
+    end
+
+    context 'when the server does not support multi credits' do
+      it 'sets the packet output_length to 65536 and credit_charge header to 0' do
+        client.server_supports_multi_credit = false
+        allow(client).to receive(:send_recv) do |packet|
+          expect(packet.output_length).to eq(65536)
+          expect(packet.smb2_header.credit_charge).to eq(0)
+        end
+        tree.list
+      end
+    end
+
+    context 'when the dialect is not 0x0202 and the server supports multi credits' do
+      it 'sets the packet output_length to server_max_read_size and credit_charge header to the expected value' do
+        client.server_supports_multi_credit = true
+        credit_charge = (90000 - 1) / 65536 + 1
+        client.server_max_read_size = 90000
+        allow(client).to receive(:send_recv) do |packet|
+          expect(packet.output_length).to eq(90000)
+          expect(packet.smb2_header.credit_charge).to eq(credit_charge)
+        end
+        tree.list
+      end
+    end
   end
 
   describe '#open_file' do
@@ -497,4 +531,27 @@ RSpec.describe RubySMB::SMB2::Tree do
       end
     end
   end
+
+  describe '#open_pipe' do
+    let(:opts) { { filename: '\\test', write: true } }
+    before :example do
+      allow(tree).to receive(:open_file)
+    end
+
+    it 'calls #open_file with the provided options' do
+      opts[:filename] ='test'
+      expect(tree).to receive(:open_file).with(**opts)
+      tree.open_pipe(**opts)
+    end
+
+    it 'remove the leading \\ from the filename if needed' do
+      expect(tree).to receive(:open_file).with(filename: 'test', write: true)
+      tree.open_pipe(**opts)
+    end
+
+    it 'does not modify the original option hash' do
+      tree.open_pipe(**opts)
+      expect(opts).to eq( { filename: '\\test', write: true } )
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -7,7 +7,7 @@ end
 require 'coveralls'
 require 'ruby_smb'
 
-if ENV['TRAVIS'] == 'true'
+if ENV['CI'] == 'true'
   # don't generate local report as it is inaccessible on travis-ci, which is
   # why coveralls is being used.
   SimpleCov.formatter = Coveralls::SimpleCov::Formatter

data/spec/support/bin_helper.rb

@@ -0,0 +1,9 @@
+class String
+  def hexlify
+    self.b.bytes.map {|c| "%02x" % c.ord}.join
+  end
+
+  def unhexlify
+    self.chars.each_slice(2).map {|c| c.join.to_i(16).chr}.join
+  end
+end