ruby_smb 2.0.0 → 2.0.5

data/spec/lib/ruby_smb/error_spec.rb

@@ -9,16 +9,45 @@ RSpec.describe RubySMB::Error::InvalidPacket do
   end
 
   context 'with a Hash' do
-    it 'outputs the expected error message' do
-      ex = described_class.new(
+    let(:ex) do
+      described_class.new(
         expected_proto:  RubySMB::SMB1::SMB_PROTOCOL_ID,
         expected_cmd:    RubySMB::SMB1::Packet::NegotiateResponseExtended::COMMAND,
         expected_custom: "extended_security=1",
-        received_proto:  RubySMB::SMB2::SMB2_PROTOCOL_ID,
-        received_cmd:    RubySMB::SMB2::Packet::NegotiateResponse::COMMAND,
+        packet:          packet,
         received_custom: "extended_security=0"
       )
-      expect(ex.to_s).to eq('Expecting SMB1 protocol with command=114 (extended_security=1), got SMB2 protocol with command=0 (extended_security=0)')
+    end
+
+    context 'with an SMB2 packet' do
+      let(:packet) { RubySMB::SMB2::Packet::NegotiateResponse.new }
+
+      it 'outputs the expected error message' do
+        expect(ex.to_s).to eq('Expecting SMB1 protocol with command=114 (extended_security=1), got SMB2 protocol with command=0 (extended_security=0), Status: (0x00000000) STATUS_SUCCESS: The operation completed successfully.')
+      end
+    end
+
+    context 'with an SMB1 packet' do
+      let(:packet) { RubySMB::SMB1::Packet::ReadAndxRequest.new }
+
+      it 'outputs the expected error message' do
+        expect(ex.to_s).to eq('Expecting SMB1 protocol with command=114 (extended_security=1), got SMB1 protocol with command=46 (extended_security=0), Status: (0x00000000) STATUS_SUCCESS: The operation completed successfully.')
+      end
+    end
+
+    context 'without packet' do
+      let(:ex) do
+        described_class.new(
+          expected_proto:  RubySMB::SMB1::SMB_PROTOCOL_ID,
+          expected_cmd:    RubySMB::SMB1::Packet::NegotiateResponseExtended::COMMAND,
+          expected_custom: "extended_security=1",
+          received_custom: "extended_security=0"
+        )
+      end
+
+      it 'outputs the expected error message' do
+        expect(ex.to_s).to eq('Expecting SMB1 protocol with command=114 (extended_security=1), got ??? protocol with command=??? (extended_security=0)')
+      end
     end
   end
 

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

@@ -44,5 +44,17 @@ RSpec.describe RubySMB::Field::Stringz16 do
       io = StringIO.new("A\x00B\x00C\x00D\x00")
       expect { stringz16.read(io) }.to raise_error(EOFError)
     end
+
+    it 'trims the string to #max_length and makes sure it ends with a null terminator' do
+      io = StringIO.new("A\x00B\x00C\x00D\x00")
+      str = described_class.new(max_length: 6)
+      expect(str.read(io).to_binary_s).to eq("A\x00B\x00\x00\x00".b)
+    end
+
+    it 'raises an exception when #max_length is not a multiple of two' do
+      io = StringIO.new("A\x00B\x00C\x00D\x00")
+      str = described_class.new(max_length: 5)
+      expect { str.read(io) }.to raise_error(ArgumentError)
+    end
   end
 end

data/spec/lib/ruby_smb/generic_packet_spec.rb

@@ -88,6 +88,13 @@ RSpec.describe RubySMB::GenericPacket do
         packet = RubySMB::SMB2::Packet::NegotiateResponse.read(smb2_error_packet.to_binary_s)
         expect(packet.original_command).to eq RubySMB::SMB2::Packet::NegotiateResponse::COMMAND
       end
+
+      context 'when the server returns an SMB1 error packet' do
+        let(:smb1_error_packet) { RubySMB::SMB1::Packet::EmptyPacket.new }
+        it 'returns the empty packet instead of the asked for class' do
+          expect(RubySMB::SMB2::Packet::NegotiateResponse.read(smb1_error_packet.to_binary_s)).to be_a RubySMB::SMB1::Packet::EmptyPacket
+        end
+      end
     end
   end
 

data/spec/lib/ruby_smb/nbss/session_header_spec.rb

@@ -2,8 +2,7 @@ RSpec.describe RubySMB::Nbss::SessionHeader do
   subject(:session_header) { described_class.new }
 
   it { is_expected.to respond_to :session_packet_type }
-  it { is_expected.to respond_to :flags }
-  it { is_expected.to respond_to :packet_length }
+  it { is_expected.to respond_to :stream_protocol_length }
 
   it 'is big endian' do
     expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :big
@@ -15,15 +14,9 @@ RSpec.describe RubySMB::Nbss::SessionHeader do
     end
   end
 
-  describe '#flags' do
-    it 'is a 7-bit Unsigned Integer' do
-      expect(session_header.flags).to be_a BinData::Bit7
-    end
-  end
-
-  describe '#packet_length' do
-    it 'is a 17-bit Unsigned Integer' do
-      expect(session_header.packet_length).to be_a BinData::Bit17
+  describe '#stream_protocol_length' do
+    it 'is a 24-bit Unsigned Integer' do
+      expect(session_header.stream_protocol_length).to be_a BinData::Uint24be
     end
   end
 end

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

@@ -521,9 +521,7 @@ RSpec.describe RubySMB::SMB1::File do
 
     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)
+      allow(response).to receive(:packet_smb_version)
       expect { file.close }.to raise_error(RubySMB::Error::InvalidPacket)
     end
 

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

@@ -80,9 +80,7 @@ RSpec.describe RubySMB::SMB1::Pipe do
 
     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)
+      allow(response).to receive(:packet_smb_version)
       expect { pipe.peek }.to raise_error(RubySMB::Error::InvalidPacket)
     end
 
@@ -149,12 +147,40 @@ RSpec.describe RubySMB::SMB1::Pipe do
       end
     end
 
+    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
+
     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
+
+    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
+
+    context 'with \'svcctl\' filename' do
+      it 'extends svcctl class' do
+        pipe = described_class.new(tree: tree, response: nt_create_andx_response, name: 'svcctl')
+        expect(pipe.respond_to?(:query_service_config)).to be true
+      end
+    end
+
+    context 'with \'\\svcctl\' filename' do
+      it 'extends svcctl class' do
+        pipe = described_class.new(tree: tree, response: nt_create_andx_response, name: '\\svcctl')
+        expect(pipe.respond_to?(:query_service_config)).to be true
+      end
+    end
   end
 
   describe '#dcerpc_request' do
@@ -238,8 +264,7 @@ RSpec.describe RubySMB::SMB1::Pipe do
 
     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(:packet_smb_version)
         allow(trans_nmpipe_response).to receive(:valid?).and_return(false)
         expect { pipe.dcerpc_request(stub_packet, options) }.to raise_error(RubySMB::Error::InvalidPacket)
       end

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

@@ -492,4 +492,26 @@ RSpec.describe RubySMB::SMB1::Tree do
     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 'prepends the filename with \\ 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/lib/ruby_smb/smb2/file_spec.rb

@@ -43,7 +43,7 @@ RSpec.describe RubySMB::SMB2::File do
   it { is_expected.to respond_to :size }
   it { is_expected.to respond_to :size_on_disk }
   it { is_expected.to respond_to :tree }
-  it { is_expected.to respond_to :encryption_required }
+  it { is_expected.to respond_to :tree_connect_encrypt_data }
 
   it 'pulls the attributes from the response packet' do
     expect(file.attributes).to eq create_response.file_attributes
@@ -73,8 +73,8 @@ RSpec.describe RubySMB::SMB2::File do
     expect(file.size_on_disk).to eq create_response.allocation_size
   end
 
-  it 'sets the encryption_required flag to false by default' do
-    expect(file.encryption_required).to be false
+  it 'sets the tree_connect_encrypt_data flag to false by default' do
+    expect(file.tree_connect_encrypt_data).to be false
   end
 
   describe '#set_header_fields' do
@@ -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,14 +129,14 @@ 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'
       end
 
       it 'calls Client #send_recv with encryption set if required' do
-        file.encryption_required = true
+        file.tree_connect_encrypt_data = true
         expect(client).to receive(:send_recv).with(small_read, encrypt: true)
         file.read
       end
@@ -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))
@@ -177,14 +182,14 @@ RSpec.describe RubySMB::SMB2::File do
       it 'calls Client #send_recv with encryption set if required' do
         read_request = double('Read Request')
         allow(file).to receive(:read_packet).and_return(read_request)
-        file.encryption_required = true
+        file.tree_connect_encrypt_data = true
         expect(client).to receive(:send_recv).twice.with(read_request, encrypt: true)
         file.read(bytes: (described_class::MAX_PACKET_SIZE * 2))
       end
 
       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
@@ -235,13 +263,18 @@ RSpec.describe RubySMB::SMB2::File do
       it 'calls Client #send_recv with encryption set if required' do
         write_request = double('Write Request')
         allow(file).to receive(:write_packet).and_return(write_request)
-        file.encryption_required = true
+        file.tree_connect_encrypt_data = true
         expect(client).to receive(:send_recv).once.with(write_request, encrypt: true).and_return(write_response.to_binary_s)
         file.write(data: 'test')
       end
     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))
@@ -250,10 +283,31 @@ RSpec.describe RubySMB::SMB2::File do
       it 'calls Client #send_recv with encryption set if required' do
         write_request = double('Write Request')
         allow(file).to receive(:write_packet).and_return(write_request)
-        file.encryption_required = true
+        file.tree_connect_encrypt_data = true
         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
@@ -307,7 +361,7 @@ RSpec.describe RubySMB::SMB2::File do
       it 'calls Client #send_recv with encryption set if required' do
         allow(file).to receive(:delete_packet)
         allow(RubySMB::SMB2::Packet::SetInfoResponse).to receive(:read).and_return(small_response)
-        file.encryption_required = true
+        file.tree_connect_encrypt_data = true
         expect(client).to receive(:send_recv).with(small_delete, encrypt: true)
         file.delete
       end
@@ -349,7 +403,7 @@ RSpec.describe RubySMB::SMB2::File do
 
       it 'calls Client #send_recv with encryption set if required' do
         allow(RubySMB::SMB2::Packet::SetInfoResponse).to receive(:read).and_return(small_response)
-        file.encryption_required = true
+        file.tree_connect_encrypt_data = true
         expect(client).to receive(:send_recv).with(small_rename, encrypt: true)
         file.rename('new_file.txt')
       end
@@ -393,7 +447,7 @@ RSpec.describe RubySMB::SMB2::File do
     end
 
     it 'calls Client #send_recv with encryption set if required' do
-      file.encryption_required = true
+      file.tree_connect_encrypt_data = true
       expect(client).to receive(:send_recv).with(request, encrypt: true)
       file.close
     end
@@ -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
 
@@ -465,7 +517,7 @@ RSpec.describe RubySMB::SMB2::File do
     it 'calls Client #send_recv with encryption set if required' do
       request = double('Request')
       allow(file).to receive(:read_packet).and_return(request)
-      file.encryption_required = true
+      file.tree_connect_encrypt_data = true
       expect(client).to receive(:send_recv).with(request, encrypt: true)
       file.send_recv_read
     end
@@ -528,7 +580,7 @@ RSpec.describe RubySMB::SMB2::File do
     end
 
     it 'calls Client #send_recv with encryption set if required' do
-      file.encryption_required = true
+      file.tree_connect_encrypt_data = true
       expect(client).to receive(:send_recv).with(request, encrypt: true)
       file.send_recv_write
     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
 
@@ -161,6 +159,13 @@ RSpec.describe RubySMB::SMB2::Pipe do
         expect(pipe.respond_to?(:has_registry_key?)).to be true
       end
     end
+
+    context 'with \'svcctl\' filename' do
+      it 'extends svcctl class' do
+        pipe = described_class.new(tree: tree, response: create_response, name: 'svcctl')
+        expect(pipe.respond_to?(:query_service_config)).to be true
+      end
+    end
   end
 
   describe '#dcerpc_request' do
@@ -254,8 +259,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