ruby_smb 0.0.21 → 0.0.22

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

@@ -1,15 +1,96 @@
-require 'spec_helper'
-
 RSpec.describe RubySMB::Dcerpc::Response do
+  subject(:packet) { described_class.new }
+
+  it { is_expected.to respond_to :pdu_header }
+  it { is_expected.to respond_to :alloc_hint }
+  it { is_expected.to respond_to :p_cont_id }
+  it { is_expected.to respond_to :cancel_count }
+  it { is_expected.to respond_to :stub }
+  it { is_expected.to respond_to :auth_verifier }
 
-  let(:raw_response){'0500020310000000b801000000000000a00100000000000001000000010000000000020006000000040002000600000008000200000000800c00020010000200000000001400020018000200000000801c00020020000200000000002400020028000200030000802c000200300002000000000034000200070000000000000007000000410044004d0049004e002400000000000d000000000000000d000000520065006d006f00740065002000410064006d0069006e0000000000020000000000000002000000430000000100000000000000010000000000000003000000000000000300000043002400000000000e000000000000000e000000440065006600610075006c007400200073006800610072006500000007000000000000000700000064006f00670065003600340000000000010000000000000001000000000000000500000000000000050000004900500043002400000000000b000000000000000b000000520065006d006f00740065002000490050004300000000000600000000000000060000005500730065007200730000000100000000000000010000000000000006000000380002000000000000000000'.strip.gsub(/([A-Fa-f0-9]{1,2})\s*?/) { $1.hex.chr }}
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
 
-  describe '#read' do
+  describe '#pdu_header' do
+    subject(:header) { packet.pdu_header }
+
+    it 'is a standard PDU Header' do
+      expect(header).to be_a RubySMB::Dcerpc::PDUHeader
+    end
 
-    let(:response){described_class.read(raw_response)}
+    it 'should have the #ptype field set to PTypes::RESPONSE' do
+      expect(header.ptype).to eq RubySMB::Dcerpc::PTypes::RESPONSE
+    end
+  end
+
+  describe '#alloc_hint' do
+    it 'should be a 32-bit unsigned integer' do
+      expect(packet.alloc_hint).to be_a BinData::Uint32le
+    end
 
-    it 'should use the alloc_hint to determine stub length' do
-      expect(response.stub.do_num_bytes).to eq response.alloc_hint
+    it 'should be the size of the #stub field' do
+      stub = 'ABCD'
+      packet.stub = stub
+      expect(packet.alloc_hint).to eq(stub.length)
     end
   end
-end
+
+  describe '#p_cont_id' do
+    it 'should be a 16-bit unsigned integer' do
+      expect(packet.p_cont_id).to be_a BinData::Uint16le
+    end
+  end
+
+  describe '#cancel_count' do
+    it 'should be a 8-bit unsigned integer' do
+      expect(packet.cancel_count).to be_a BinData::Uint8
+    end
+  end
+
+  describe '#stub' do
+    it 'is a string' do
+      expect(packet.stub).to be_a BinData::String
+    end
+
+    it 'reads the expected number of bytes' do
+      stub = 'ABCDEFGH'
+      packet.pdu_header.frag_length = 28
+      packet.stub.read(stub)
+      expect(packet.stub).to eq(stub[0,4])
+    end
+  end
+
+  describe '#auth_verifier' do
+    it 'should be a string' do
+      expect(packet.auth_verifier).to be_a BinData::String
+    end
+
+    it 'should not exist if the #auth_length PDU header field is 0' do
+      packet.pdu_header.auth_length = 0
+      expect(packet.auth_verifier?).to be false
+    end
+
+    it 'should exist only if the #auth_length PDU header field is greater than 0' do
+      packet.pdu_header.auth_length = 10
+      expect(packet.auth_verifier?).to be true
+    end
+
+    it 'reads #auth_length bytes' do
+      auth_verifier = '12345678'
+      packet.pdu_header.auth_length = 6
+      packet.auth_verifier.read(auth_verifier)
+      expect(packet.auth_verifier).to eq(auth_verifier[0,6])
+    end
+  end
+
+  it 'reads its own binary representation and output the same packet' do
+    packet.stub = 'ABCD'
+    packet.auth_verifier = '123456'
+    packet.pdu_header.auth_length = 6
+    binary = packet.to_binary_s
+    expect(described_class.read(binary)).to eq(packet)
+  end
+end
+
+

data/spec/lib/ruby_smb/dcerpc/srvsvc/net_share_enum_all_spec.rb

@@ -0,0 +1,176 @@
+RSpec.describe RubySMB::Dcerpc::Srvsvc::NetShareEnumAll do
+  subject(:packet) { described_class.new(host: '1.2.3.4') }
+
+  it { is_expected.to respond_to :referent_id }
+  it { is_expected.to respond_to :max_count }
+  it { is_expected.to respond_to :offset }
+  it { is_expected.to respond_to :actual_count }
+  it { is_expected.to respond_to :server_unc }
+  it { is_expected.to respond_to :pad }
+  it { is_expected.to respond_to :level }
+  it { is_expected.to respond_to :ctr }
+  it { is_expected.to respond_to :ctr_referent_id }
+  it { is_expected.to respond_to :ctr_count }
+  it { is_expected.to respond_to :pointer_to_array }
+  it { is_expected.to respond_to :max_buffer }
+  it { is_expected.to respond_to :resume_referent_id }
+  it { is_expected.to respond_to :resume_handle }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#referent_id' do
+    it 'should be a 32-bit unsigned integer' do
+      expect(packet.referent_id).to be_a BinData::Uint32le
+    end
+
+    it 'should have a default value of 1' do
+      expect(packet.referent_id).to eq 1
+    end
+  end
+
+  describe '#max_count' do
+    it 'should be a 32-bit unsigned integer' do
+      expect(packet.max_count).to be_a BinData::Uint32le
+    end
+
+    it 'should be the number of unicode characters in the #server_unc field' do
+      expect(packet.max_count).to eq(packet.server_unc.do_num_bytes / 2)
+    end
+  end
+
+  describe '#offset' do
+    it 'should be a 32-bit unsigned integer' do
+      expect(packet.offset).to be_a BinData::Uint32le
+    end
+
+    it 'should have a default value of 0' do
+      expect(packet.offset).to eq 0
+    end
+  end
+
+  describe '#actual_count' do
+    it 'should be a 32-bit unsigned integer' do
+      expect(packet.actual_count).to be_a BinData::Uint32le
+    end
+
+    it 'should be the same value than #max_count' do
+      expect(packet.actual_count).to eq(packet.max_count)
+    end
+  end
+
+  describe '#server_unc' do
+    it 'is a Stringz16' do
+      expect(packet.server_unc).to be_a RubySMB::Field::Stringz16
+    end
+
+    it 'uses the #host parameter value to create the UNC unicode string' do
+      expect(packet.server_unc).to eq("\\\\#{"1.2.3.4".encode('utf-8')}".encode('utf-16le'))
+    end
+  end
+
+  describe '#pad' do
+    it 'should keep #level 4-byte aligned' do
+      expect(packet.level.abs_offset % 4).to eq 0
+    end
+  end
+
+  describe '#level' do
+    it 'should be a 32-bit unsigned integer' do
+      expect(packet.level).to be_a BinData::Uint32le
+    end
+
+    it 'should have a default value of 1' do
+      expect(packet.level).to eq 1
+    end
+  end
+
+  describe '#ctr' do
+    it 'should be a 32-bit unsigned integer' do
+      expect(packet.ctr).to be_a BinData::Uint32le
+    end
+
+    it 'should have a default value of 1' do
+      expect(packet.ctr).to eq 1
+    end
+  end
+
+  describe '#ctr_referent_id' do
+    it 'should be a 32-bit unsigned integer' do
+      expect(packet.ctr_referent_id).to be_a BinData::Uint32le
+    end
+
+    it 'should have a default value of 1' do
+      expect(packet.ctr_referent_id).to eq 1
+    end
+  end
+
+  describe '#ctr_count' do
+    it 'should be a 32-bit unsigned integer' do
+      expect(packet.ctr_count).to be_a BinData::Uint32le
+    end
+
+    it 'should have a default value of 0' do
+      expect(packet.ctr_count).to eq 0
+    end
+  end
+
+  describe '#pointer_to_array' do
+    it 'should be a 32-bit unsigned integer' do
+      expect(packet.pointer_to_array).to be_a BinData::Uint32le
+    end
+
+    it 'should have a default value of 0' do
+      expect(packet.pointer_to_array).to eq 0
+    end
+  end
+
+  describe '#max_buffer' do
+    it 'should be a 32-bit unsigned integer' do
+      expect(packet.max_buffer).to be_a BinData::Uint32le
+    end
+
+    it 'should have a default value of 4294967295' do
+      expect(packet.max_buffer).to eq 4294967295
+    end
+  end
+
+  describe '#resume_referent_id' do
+    it 'should be a 32-bit unsigned integer' do
+      expect(packet.resume_referent_id).to be_a BinData::Uint32le
+    end
+
+    it 'should have a default value of 1' do
+      expect(packet.resume_referent_id).to eq 1
+    end
+  end
+
+  describe '#resume_handle' do
+    it 'should be a 32-bit unsigned integer' do
+      expect(packet.resume_handle).to be_a BinData::Uint32le
+    end
+
+    it 'should have a default value of 0' do
+      expect(packet.resume_handle).to eq 0
+    end
+  end
+
+  describe '#pad_length' do
+    it 'returns 0 when #level is already 4-byte aligned' do
+      expect(packet.pad_length).to eq 0
+    end
+
+    it 'returns 2 when #level is only 2-byte aligned' do
+      packet.server_unc = packet.server_unc + 'A'.encode('utf-16le')
+      expect(packet.pad_length).to eq 2
+    end
+  end
+
+  describe 'class method self.parse_response' do
+    # TODO: this class method will be refactored to use proper BinData NDR
+    # fields once they are ready (see https://github.com/rapid7/ruby_smb/issues/124)
+  end
+end
+
+

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

@@ -1,4 +1,100 @@
-require 'spec_helper'
+RSpec.describe RubySMB::Dcerpc::Uuid do
+  subject(:packet) { described_class.new }
+
+  it { is_expected.to respond_to :time_low }
+  it { is_expected.to respond_to :time_mid }
+  it { is_expected.to respond_to :time_hi_and_version }
+  it { is_expected.to respond_to :clock_seq_hi_and_reserved }
+  it { is_expected.to respond_to :clock_seq_low }
+  it { is_expected.to respond_to :node }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#time_low' do
+    it 'should be a 32-bit unsigned integer' do
+      expect(packet.time_low).to be_a BinData::Uint32le
+    end
+  end
+
+  describe '#time_mid' do
+    it 'should be a 16-bit unsigned integer' do
+      expect(packet.time_mid).to be_a BinData::Uint16le
+    end
+  end
+
+  describe '#time_hi_and_version' do
+    it 'should be a 16-bit unsigned integer' do
+      expect(packet.time_hi_and_version).to be_a BinData::Uint16le
+    end
+  end
+
+  describe '#clock_seq_hi_and_reserved' do
+    it 'should be a 8-bit unsigned integer' do
+      expect(packet.clock_seq_hi_and_reserved).to be_a BinData::Uint8
+    end
+  end
+
+  describe '#clock_seq_low' do
+    it 'should be a 8-bit unsigned integer' do
+      expect(packet.clock_seq_low).to be_a BinData::Uint8
+    end
+  end
+
+  describe '#node' do
+    it 'should be an Array' do
+      expect(packet.node).to be_a BinData::Array
+    end
+
+    it 'should have 6 elements' do
+      expect(packet.node.size).to eq 6
+    end
+
+    it 'should have 8-bit unsigned integer elements' do
+      expect(packet.node[0]).to be_a BinData::Uint8
+    end
+  end
+
+  context 'when using a string representation of UUID' do
+    let(:uuid_string){ '8a885d04-1ceb-11c9-9fe8-08002b104860' }
+
+    before :example do
+      packet.set(uuid_string)
+    end
+
+    describe '#get' do
+      it 'returns the correct string representation of UUID' do
+        expect(packet.get).to eq uuid_string
+      end
+    end
+
+    describe '#set' do
+      it 'sets the expected values' do
+        expect(packet.time_low).to eq 0x8A885D04
+        expect(packet.time_mid).to eq 0x1CEb
+        expect(packet.time_hi_and_version).to eq 0x11C9
+        expect(packet.clock_seq_hi_and_reserved).to eq 0x9F
+        expect(packet.clock_seq_low).to eq 0xE8
+        expect(packet.node).to eq [0x08, 0x00, 0x2B, 0x10, 0x48, 0x60]
+      end
+    end
+  end
+
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 RSpec.describe RubySMB::Dcerpc::Uuid do
   let(:uuid_string){'8a885d04-1ceb-11c9-9fe8-08002b104860'}

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

@@ -1,9 +1,20 @@
 RSpec.describe RubySMB::SMB1::DataBlock do
   subject(:data_block) { described_class.new }
 
+  let(:record_class) do
+    Class.new(described_class) do
+      int8  :field1
+      int32 :field2
+    end
+  end
+
   it { is_expected.to respond_to :byte_count }
 
-  describe 'byte_count' do
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#byte_count' do
     it 'should be a 16-bit field per the SMB spec' do
       expect(data_block.byte_count).to be_a BinData::Uint16le
     end
@@ -20,7 +31,36 @@ RSpec.describe RubySMB::SMB1::DataBlock do
     end
   end
 
-  it 'is little endian' do
-    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  describe 'class method #data_fields' do
+    it 'lists all the fields except #byte_count field' do
+      expect(record_class.data_fields).to eq([:field1, :field2])
+    end
   end
+
+  describe '#calculate_byte_count' do
+    it 'returns the expected expected packet size' do
+      expect(record_class.new.calculate_byte_count).to eq(5)
+    end
+
+    it 'does not count disabled fields' do
+      record_class.class_eval do
+        int8  :field3, onlyif: -> { false }
+      end
+      expect(record_class.new.calculate_byte_count).to eq(5)
+    end
+  end
+
+  describe '#field_enabled?' do
+    it 'returns true when the field is enabled' do
+      expect(record_class.new.field_enabled?(:field1)).to be true
+    end
+
+    it 'returns false when the field is disabled' do
+      record_class.class_eval do
+        int8  :field3, onlyif: -> { false }
+      end
+      expect(record_class.new.field_enabled?(:field3)).to be false
+    end
+  end
+
 end

data/spec/lib/ruby_smb/smb1/packet/trans/data_block_spec.rb

@@ -0,0 +1,137 @@
+RSpec.describe RubySMB::SMB1::Packet::Trans::DataBlock do
+  let(:data_block_class) { Class.new(described_class) }
+  subject(:data_block_obj) { data_block_class.new }
+
+  it { is_expected.to respond_to :enable_padding }
+  it { is_expected.to respond_to :enable_padding= }
+
+  it 'is a standard DataBlock' do
+    expect(data_block_obj).to be_a RubySMB::SMB1::DataBlock
+  end
+
+  describe '#enable_padding' do
+    it 'is true by default' do
+      expect(data_block_obj.enable_padding).to be true
+    end
+  end
+
+  describe '#pad1_length' do
+    context 'when enable_padding is false' do
+      it 'returns 0' do
+        data_block_obj.enable_padding = false
+        expect(data_block_obj.send(:pad1_length)).to eq(0)
+      end
+    end
+
+    context 'when enable_padding is true' do
+      context 'when #name field exists' do
+        let(:my_name) { double('name') }
+
+        before :example do
+          data_block_class.class_exec{
+            def name() end
+          }
+          allow(data_block_obj).to receive(:name).and_return(my_name)
+          allow(data_block_obj).to receive(:respond_to?).with(:name).and_return(true)
+          allow(my_name).to receive(:abs_offset).and_return(0)
+          allow(my_name).to receive(:to_binary_s).and_return("")
+        end
+
+        it 'returns 0 if trans_parameters is 4-byte aligned' do
+          expect(data_block_obj.send(:pad1_length)).to eq(0)
+        end
+
+        it 'returns the correct number of byte if trans_parameters is not 4-byte aligned' do
+          allow(my_name).to receive(:abs_offset).and_return(1)
+          expect(data_block_obj.send(:pad1_length)).to eq(3)
+        end
+      end
+
+      context 'when #name field does not exist' do
+        let(:byte_count) { double('byte_count') }
+
+        before :example do
+          data_block_class.class_exec{
+            def byte_count() end
+          }
+          allow(data_block_obj).to receive(:byte_count).and_return(byte_count)
+          allow(data_block_obj).to receive(:respond_to?).with(:name).and_return(false)
+          allow(byte_count).to receive(:abs_offset).and_return(2)
+        end
+
+        it 'returns 0 if trans_parameters is 4-byte aligned' do
+          expect(data_block_obj.send(:pad1_length)).to eq(0)
+        end
+
+        it 'returns the correct number of byte if trans_parameters is not 4-byte aligned' do
+          allow(byte_count).to receive(:abs_offset).and_return(1)
+          expect(data_block_obj.send(:pad1_length)).to eq(1)
+        end
+      end
+    end
+  end
+
+  describe '#pad2_length' do
+    context 'when enable_padding is false' do
+      it 'returns 0' do
+        data_block_obj.enable_padding = false
+        expect(data_block_obj.send(:pad2_length)).to eq(0)
+      end
+    end
+
+    context 'when enable_padding is true' do
+      let(:trans_parameters) { double('trans_parameters') }
+
+      before :example do
+        data_block_class.class_exec{
+          def trans_parameters() end
+        }
+        allow(data_block_obj).to receive(:trans_parameters).and_return(trans_parameters)
+        allow(data_block_obj).to receive(:respond_to?).with(:name).and_return(false)
+        allow(trans_parameters).to receive(:abs_offset).and_return(0)
+        allow(trans_parameters).to receive(:length).and_return(0)
+      end
+
+      it 'returns 0 if trans_parameters is 4-byte aligned' do
+        expect(data_block_obj.send(:pad2_length)).to eq(0)
+      end
+
+      it 'returns the correct number of byte if trans_parameters is not 4-byte aligned' do
+        allow(trans_parameters).to receive(:abs_offset).and_return(1)
+        expect(data_block_obj.send(:pad2_length)).to eq(3)
+      end
+    end
+  end
+
+  describe '#pad_name_length' do
+    context 'when enable_padding is false' do
+      it 'returns 0' do
+        data_block_obj.enable_padding = false
+        expect(data_block_obj.send(:pad_name_length)).to eq(0)
+      end
+    end
+
+    context 'when enable_padding is true' do
+      let(:byte_count) { double('byte_count') }
+
+      before :example do
+        data_block_class.class_exec{
+          def byte_count() end
+        }
+        allow(data_block_obj).to receive(:byte_count).and_return(byte_count)
+        allow(data_block_obj).to receive(:respond_to?).with(:name).and_return(false)
+        allow(byte_count).to receive(:abs_offset).and_return(0)
+      end
+
+      it 'returns 0 if trans_parameters is 4-byte aligned' do
+        expect(data_block_obj.send(:pad_name_length)).to eq(0)
+      end
+
+      it 'returns the correct number of byte if trans_parameters is not 4-byte aligned' do
+        allow(byte_count).to receive(:abs_offset).and_return(1)
+        expect(data_block_obj.send(:pad_name_length)).to eq(1)
+      end
+    end
+  end
+end
+