ruby_smb 1.1.0 → 2.0.4

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

@@ -0,0 +1,332 @@
+RSpec.describe RubySMB::SMB2::PreauthIntegrityCapabilities do
+  subject(:capability) { described_class.new }
+
+  it { is_expected.to respond_to :hash_algorithm_count }
+  it { is_expected.to respond_to :salt_length }
+  it { is_expected.to respond_to :hash_algorithms }
+  it { is_expected.to respond_to :salt }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#hash_algorithm_count' do
+    it 'is a 16-bit unsigned integer' do
+      expect(capability.hash_algorithm_count).to be_a BinData::Uint16le
+    end
+
+    it 'is set to the #hash_algorithms array size' do
+      array = [1, 2, 3]
+      capability.hash_algorithms = array
+      expect(capability.hash_algorithm_count).to eq(array.size)
+    end
+  end
+
+  describe '#salt_length' do
+    it 'is a 16-bit unsigned integer' do
+      expect(capability.salt_length).to be_a BinData::Uint16le
+    end
+
+    it 'is set to the #salt string size' do
+      salt = 'my_random_salt'
+      capability.salt = salt
+      expect(capability.salt_length).to eq(salt.size)
+    end
+  end
+
+  describe '#hash_algorithms' do
+    it 'is a BinData Array' do
+      expect(capability.hash_algorithms).to be_a BinData::Array
+    end
+
+    it 'has #hash_algorithm_count elements' do
+      capability.hash_algorithm_count = 3
+      expect(capability.hash_algorithms.size).to eq 3
+    end
+  end
+
+  describe '#salt' do
+    it 'is a string' do
+      expect(capability.salt).to be_a BinData::String
+    end
+
+    it 'should read #salt_length bytes' do
+      salt = 'my_random_salt'
+      capability.salt_length = 5
+      expect(capability.salt.read(salt)).to eq(salt[0,5])
+    end
+  end
+
+  it 'reads binary data as expected' do
+    data = described_class.new(
+      hash_algorithms: [described_class::SHA_512],
+      salt: 'test salt'
+    )
+    expect(described_class.read(data.to_binary_s)).to eq(data)
+  end
+end
+
+RSpec.describe RubySMB::SMB2::EncryptionCapabilities do
+  subject(:capability) { described_class.new }
+
+  it { is_expected.to respond_to :cipher_count }
+  it { is_expected.to respond_to :ciphers }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#cipher_count' do
+    it 'is a 16-bit unsigned integer' do
+      expect(capability.cipher_count).to be_a BinData::Uint16le
+    end
+
+    it 'is set to the #ciphers array size' do
+      array = [1, 2, 3]
+      capability.ciphers = array
+      expect(capability.cipher_count).to eq(array.size)
+    end
+  end
+
+  describe '#ciphers' do
+    it 'is a BinData Array' do
+      expect(capability.ciphers).to be_a BinData::Array
+    end
+
+    it 'has #cipher_count elements' do
+      capability.cipher_count = 3
+      expect(capability.ciphers.size).to eq 3
+    end
+  end
+
+  it 'reads binary data as expected' do
+    data = described_class.new(
+      ciphers: [described_class::AES_128_CCM, described_class::AES_128_GCM]
+    )
+    expect(described_class.read(data.to_binary_s)).to eq(data)
+  end
+end
+
+RSpec.describe RubySMB::SMB2::CompressionCapabilities do
+  subject(:capability) { described_class.new }
+
+  it { is_expected.to respond_to :compression_algorithm_count }
+  it { is_expected.to respond_to :padding }
+  it { is_expected.to respond_to :flags }
+  it { is_expected.to respond_to :compression_algorithms }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#compression_algorithm_count' do
+    it 'is a 16-bit unsigned integer' do
+      expect(capability.compression_algorithm_count).to be_a BinData::Uint16le
+    end
+
+    it 'is set to the #compression_algorithms array size' do
+      array = [1, 2, 3]
+      capability.compression_algorithms = array
+      expect(capability.compression_algorithm_count).to eq(array.size)
+    end
+  end
+
+  describe '#padding' do
+    it 'is a 16-bit unsigned integer' do
+      expect(capability.padding).to be_a BinData::Uint16le
+    end
+  end
+
+  describe '#flags' do
+    it 'is a 32-bit unsigned integer' do
+      expect(capability.flags).to be_a BinData::Uint32le
+    end
+  end
+
+  describe '#compression_algorithms' do
+    it 'is a BinData Array' do
+      expect(capability.compression_algorithms).to be_a BinData::Array
+    end
+
+    it 'has #compression_algorithm_count elements' do
+      capability.compression_algorithm_count = 3
+      expect(capability.compression_algorithms.size).to eq 3
+    end
+  end
+
+  it 'reads binary data as expected' do
+    data = described_class.new(
+      compression_algorithms: [described_class::LZNT1, described_class::LZ77]
+    )
+    expect(described_class.read(data.to_binary_s)).to eq(data)
+  end
+end
+
+RSpec.describe RubySMB::SMB2::NetnameNegotiateContextId  do
+  subject(:capability) { described_class.new }
+
+  it { is_expected.to respond_to :net_name }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#net_name' do
+    it 'is a unicode string' do
+      expect(capability.net_name).to be_a RubySMB::Field::Stringz16
+    end
+  end
+
+  it 'reads binary data as expected' do
+    data = described_class.new(
+      net_name: 'netname test'
+    )
+    expect(described_class.read(data.to_binary_s)).to eq(data)
+  end
+end
+
+RSpec.describe RubySMB::SMB2::NegotiateContext do
+  class FakePacket < BinData::Record
+    endian  :little
+    string :garbage
+    negotiate_context :nc
+  end
+
+  let(:test_packet) do
+    packet = FakePacket.new
+    packet.nc.context_type = described_class::SMB2_PREAUTH_INTEGRITY_CAPABILITIES
+    packet
+  end
+  subject(:negotiate_context) { described_class.new }
+
+  it { is_expected.to respond_to :pad }
+  it { is_expected.to respond_to :context_type }
+  it { is_expected.to respond_to :data_length }
+  it { is_expected.to respond_to :reserved }
+  it { is_expected.to respond_to :data }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#pad' do
+    it 'is a string' do
+      expect(negotiate_context.pad).to be_a BinData::String
+    end
+
+    it 'should keep the #context_type 8-byte aligned' do
+      test_packet.garbage = 'foo'
+      expect(test_packet.nc.context_type.abs_offset % 8).to eq(0)
+    end
+  end
+
+  describe '#context_type ' do
+    it 'is a 16-bit unsigned integer' do
+      expect(negotiate_context.context_type).to be_a BinData::Uint16le
+    end
+  end
+
+  describe '#data_length' do
+    it 'is a 16-bit unsigned integer' do
+      expect(negotiate_context.data_length).to be_a BinData::Uint16le
+    end
+
+    it 'should give the #data field length in bytes' do
+      expect(described_class.new(context_type: described_class::SMB2_ENCRYPTION_CAPABILITIES).data_length)
+        .to eq(RubySMB::SMB2::EncryptionCapabilities.new.num_bytes)
+    end
+  end
+
+  describe '#data' do
+    it 'is a BinData choice field' do
+      expect(negotiate_context.data).to be_a BinData::Choice
+    end
+
+    context 'with a SMB2_PREAUTH_INTEGRITY_CAPABILITIES context type' do
+      it 'selects the PreauthIntegrityCapabilities structure' do
+        expect(described_class.new(context_type: described_class::SMB2_PREAUTH_INTEGRITY_CAPABILITIES).data)
+          .to eq(RubySMB::SMB2::PreauthIntegrityCapabilities.new)
+      end
+    end
+
+    context 'with a SMB2_ENCRYPTION_CAPABILITIES context type' do
+      it 'selects the PreauthIntegrityCapabilities structure' do
+        expect(described_class.new(context_type: described_class::SMB2_ENCRYPTION_CAPABILITIES).data)
+          .to eq(RubySMB::SMB2::EncryptionCapabilities.new)
+      end
+    end
+
+    context 'with a SMB2_COMPRESSION_CAPABILITIES context type' do
+      it 'selects the PreauthIntegrityCapabilities structure' do
+        expect(described_class.new(context_type: described_class::SMB2_COMPRESSION_CAPABILITIES).data)
+          .to eq(RubySMB::SMB2::CompressionCapabilities.new)
+      end
+    end
+
+    context 'with a SMB2_NETNAME_NEGOTIATE_CONTEXT_ID context type' do
+      it 'selects the PreauthIntegrityCapabilities structure' do
+        expect(described_class.new(context_type: described_class::SMB2_NETNAME_NEGOTIATE_CONTEXT_ID).data)
+          .to eq(RubySMB::SMB2::NetnameNegotiateContextId.new)
+      end
+    end
+  end
+
+  describe '#pad_length' do
+    it 'returns 0 when #context_type is already 8-byte aligned' do
+      expect(test_packet.nc.pad_length).to eq(0)
+    end
+
+    it 'returns 2 when #context_type is only 2-byte aligned' do
+      test_packet.garbage = 'align' + 'A'
+      expect(test_packet.nc.pad_length).to eq(2)
+    end
+  end
+
+  context 'with a SMB2_PREAUTH_INTEGRITY_CAPABILITIES context type' do
+    it 'reads binary data as expected' do
+      data = described_class.new(
+        context_type: described_class::SMB2_PREAUTH_INTEGRITY_CAPABILITIES
+      )
+      data.data.hash_algorithms << RubySMB::SMB2::PreauthIntegrityCapabilities::SHA_512
+      data.data.salt = 'test salt'
+      expect(described_class.read(data.to_binary_s)).to eq(data)
+    end
+  end
+
+  context 'with a SMB2_ENCRYPTION_CAPABILITIES context type' do
+    it 'reads binary data as expected' do
+      data = described_class.new(
+        context_type: described_class::SMB2_ENCRYPTION_CAPABILITIES
+      )
+      data.data.ciphers = [
+        RubySMB::SMB2::EncryptionCapabilities::AES_128_CCM,
+        RubySMB::SMB2::EncryptionCapabilities::AES_128_GCM
+      ]
+      expect(described_class.read(data.to_binary_s)).to eq(data)
+    end
+  end
+
+  context 'with a SMB2_COMPRESSION_CAPABILITIES context type' do
+    it 'reads binary data as expected' do
+      data = described_class.new(
+        context_type: described_class::SMB2_COMPRESSION_CAPABILITIES
+      )
+      data.data.compression_algorithms = [
+        RubySMB::SMB2::CompressionCapabilities::LZNT1,
+        RubySMB::SMB2::CompressionCapabilities::LZ77
+      ]
+      expect(described_class.read(data.to_binary_s)).to eq(data)
+    end
+  end
+
+  context 'with a SMB2_NETNAME_NEGOTIATE_CONTEXT_ID context type' do
+    it 'reads binary data as expected' do
+      data = described_class.new(
+        context_type: described_class::SMB2_NETNAME_NEGOTIATE_CONTEXT_ID
+      )
+      data.data.net_name = 'netname test'
+      expect(described_class.read(data.to_binary_s)).to eq(data)
+    end
+  end
+end
+

data/spec/lib/ruby_smb/smb2/packet/compression_transform_header_spec.rb

@@ -0,0 +1,108 @@
+RSpec.describe RubySMB::SMB2::Packet::CompressionTransformHeader do
+  subject(:packet) { described_class.new }
+
+  it { is_expected.to respond_to :protocol }
+  it { is_expected.to respond_to :original_compressed_segment_size }
+  it { is_expected.to respond_to :compression_algorithm }
+  it { is_expected.to respond_to :flags }
+  it { is_expected.to respond_to :offset }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#protocol' do
+    it 'is a 32-bit field' do
+      expect(packet.protocol).to be_a BinData::Bit32
+    end
+
+    it 'is initialized with the value 0xFC534D42' do
+      expect(packet.protocol).to eq(0xFC534D42)
+    end
+  end
+
+  describe '#original_compressed_segment_size ' do
+    it 'is a 32-bit unsigned integer' do
+      expect(packet.original_compressed_segment_size).to be_a BinData::Uint32le
+    end
+  end
+
+  describe '#compression_algorithm ' do
+    it 'is a 16-bit unsigned integer' do
+      expect(packet.compression_algorithm).to be_a BinData::Uint16le
+    end
+  end
+
+  describe '#flags ' do
+    it 'is a 16-bit unsigned integer' do
+      expect(packet.flags).to be_a BinData::Uint16le
+    end
+  end
+
+  describe '#offset' do
+    it 'is a 32-bit unsigned integer' do
+      expect(packet.offset).to be_a BinData::Uint32le
+    end
+  end
+
+  it 'reads binary data as expected' do
+    data = described_class.new
+    expect(described_class.read(data.to_binary_s)).to eq(data)
+  end
+end
+
+RSpec.describe RubySMB::SMB2::Packet::Smb2CompressionPayloadHeader do
+  subject(:packet) { described_class.new }
+
+  it { is_expected.to respond_to :algorithm_id }
+  it { is_expected.to respond_to :payload_length }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#algorithm_id ' do
+    it 'is a 16-bit unsigned integer' do
+      expect(packet.algorithm_id).to be_a BinData::Uint16le
+    end
+  end
+
+  describe '#payload_length' do
+    it 'is a 32-bit unsigned integer' do
+      expect(packet.payload_length).to be_a BinData::Uint32le
+    end
+  end
+
+  it 'reads binary data as expected' do
+    data = described_class.new
+    expect(described_class.read(data.to_binary_s)).to eq(data)
+  end
+end
+
+RSpec.describe RubySMB::SMB2::Packet::Smb2CompressionPatternPayloadV1 do
+  subject(:packet) { described_class.new }
+
+  it { is_expected.to respond_to :pattern }
+  it { is_expected.to respond_to :repetitions }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#pattern' do
+    it 'is a 8-bit unsigned integer' do
+      expect(packet.pattern).to be_a BinData::Uint8
+    end
+  end
+
+  describe '#repetitions' do
+    it 'is a 32-bit unsigned integer' do
+      expect(packet.repetitions).to be_a BinData::Uint32le
+    end
+  end
+
+  it 'reads binary data as expected' do
+    data = described_class.new
+    expect(described_class.read(data.to_binary_s)).to eq(data)
+  end
+end

data/spec/lib/ruby_smb/smb2/packet/negotiate_request_spec.rb

@@ -8,6 +8,7 @@ RSpec.describe RubySMB::SMB2::Packet::NegotiateRequest do
   it { is_expected.to respond_to :reserved1 }
   it { is_expected.to respond_to :capabilities }
   it { is_expected.to respond_to :client_guid }
+  it { is_expected.to respond_to :negotiate_context_info}
   it { is_expected.to respond_to :client_start_time }
   it { is_expected.to respond_to :dialects }
 
@@ -45,6 +46,11 @@ RSpec.describe RubySMB::SMB2::Packet::NegotiateRequest do
     it 'should be a 16-bit unsigned integer' do
       expect(packet.dialect_count).to be_a BinData::Uint16le
     end
+
+    it 'is initially set to the #dialects array size' do
+      packet.dialects = [1,2,3]
+      expect(packet.dialect_count).to eq(3)
+    end
   end
 
   describe '#security_mode' do
@@ -69,7 +75,65 @@ RSpec.describe RubySMB::SMB2::Packet::NegotiateRequest do
     end
   end
 
+  describe '#negotiate_context_info' do
+    it 'only exists if the 0x0311 dialect is included' do
+      packet.dialects << 0x0311
+      expect(packet.negotiate_context_info?).to be true
+    end
+
+    it 'does not exist if the 0x0311 dialect is not included' do
+      packet.dialects << 0x0300
+      expect(packet.negotiate_context_info?).to be false
+    end
+
+    it 'should be a Struct field' do
+      expect(packet.negotiate_context_info).to be_a BinData::Struct
+    end
+
+    subject(:struct) do
+      packet.dialects << 0x0311
+      packet.negotiate_context_info
+    end
+    it { is_expected.to respond_to :negotiate_context_offset }
+    it { is_expected.to respond_to :negotiate_context_count }
+
+    describe '#negotiate_context_offset' do
+      it 'should be a 32-bit unsigned integer' do
+        expect(struct.negotiate_context_offset).to be_a BinData::Uint32le
+      end
+
+      it 'is set to the #negotiate_context_list absolute offset' do
+        expect(struct.negotiate_context_offset).to eq(packet.negotiate_context_list.abs_offset)
+      end
+    end
+
+    describe '#negotiate_context_count' do
+      it 'should be a 16-bit unsigned integer' do
+        expect(struct.negotiate_context_count).to be_a BinData::Uint16le
+      end
+
+      it 'is set to the #negotiate_context_list array size' do
+        nc = RubySMB::SMB2::NegotiateContext.new(
+          context_type: RubySMB::SMB2::NegotiateContext::SMB2_PREAUTH_INTEGRITY_CAPABILITIES
+        )
+        packet.negotiate_context_list << nc
+        packet.negotiate_context_list << nc
+        expect(struct.negotiate_context_count).to eq(2)
+      end
+    end
+  end
+
   describe '#client_start_time' do
+    it 'does not exist if the 0x0311 dialect is included' do
+      packet.dialects << 0x0311
+      expect(packet.client_start_time?).to be false
+    end
+
+    it 'only exists if the 0x0311 dialect is not included' do
+      packet.dialects << 0x0300
+      expect(packet.client_start_time?).to be true
+    end
+
     it 'should be a Filetime field' do
       expect(packet.client_start_time).to be_a RubySMB::Field::FileTime
     end
@@ -85,15 +149,51 @@ RSpec.describe RubySMB::SMB2::Packet::NegotiateRequest do
     end
   end
 
+  describe '#pad' do
+    it 'only exists if the 0x0311 dialect is included' do
+      packet.dialects << 0x0311
+      expect(packet.pad?).to be true
+    end
+
+    it 'does not exist if the 0x0311 dialect is not included' do
+      packet.dialects << 0x0300
+      expect(packet.pad?).to be false
+    end
+
+    it 'should be a binary string' do
+      expect(packet.pad).to be_a BinData::String
+    end
+
+    it 'should keep #negotiate_context_list 8-byte aligned' do
+      packet.dialects << 0x0311
+      expect(packet.negotiate_context_list.abs_offset % 8).to eq 0
+    end
+  end
+
+  describe '#negotiate_context_list' do
+    it 'only exists if the 0x0311 dialect is included' do
+      packet.dialects << 0x0311
+      expect(packet.negotiate_context_list?).to be true
+    end
+
+    it 'does not exist if the 0x0311 dialect is not included' do
+      packet.dialects << 0x0300
+      expect(packet.negotiate_context_list?).to be false
+    end
+
+    it 'is an array field as per the SMB spec' do
+      expect(packet.negotiate_context_list).to be_a BinData::Array
+    end
+  end
+
   describe '#add_dialect' do
     it 'adds the dialect to the Dialects array' do
       packet.add_dialect 0x0201
       expect(packet.dialects).to include(0x0201)
     end
 
-    it 'updates the #dialect_count field' do
-      packet.add_dialect 0x0201
-      expect(packet.dialect_count).to eq 1
+    it 'raises an ArgumentError exceptionif it is not an Integer' do
+      expect { packet.add_dialect('dialect') }.to raise_error(ArgumentError)
     end
   end
 
@@ -119,4 +219,39 @@ RSpec.describe RubySMB::SMB2::Packet::NegotiateRequest do
       expect(packet.dialect_count).to eq 3
     end
   end
+
+  describe '#add_negotiate_context' do
+    it 'raises an ArgumentError exceptionif it is not a NegotiateContext structure' do
+      expect { packet.add_negotiate_context('nc') }.to raise_error(ArgumentError)
+    end
+
+    it 'updates the NegotiateContext#pad length to make sure the structure is 8-byte aligned' do
+      packet.dialects << 0x0311
+      [
+        RubySMB::SMB2::NegotiateContext::SMB2_PREAUTH_INTEGRITY_CAPABILITIES,
+        RubySMB::SMB2::NegotiateContext::SMB2_ENCRYPTION_CAPABILITIES,
+        RubySMB::SMB2::NegotiateContext::SMB2_COMPRESSION_CAPABILITIES,
+        RubySMB::SMB2::NegotiateContext::SMB2_NETNAME_NEGOTIATE_CONTEXT_ID
+      ].each do |context_type|
+        nc = RubySMB::SMB2::NegotiateContext.new(context_type: context_type)
+        packet.add_negotiate_context(nc)
+        expect(packet.negotiate_context_list.last.context_type.abs_offset % 8).to eq 0
+      end
+    end
+  end
+
+  it 'reads binary data as expected' do
+    data = described_class.new
+    data.set_dialects([0x0202, 0x0210, 0x0311])
+    [
+      RubySMB::SMB2::NegotiateContext::SMB2_PREAUTH_INTEGRITY_CAPABILITIES,
+      RubySMB::SMB2::NegotiateContext::SMB2_ENCRYPTION_CAPABILITIES,
+      RubySMB::SMB2::NegotiateContext::SMB2_COMPRESSION_CAPABILITIES,
+      RubySMB::SMB2::NegotiateContext::SMB2_NETNAME_NEGOTIATE_CONTEXT_ID
+    ].each do |context_type|
+      nc = RubySMB::SMB2::NegotiateContext.new(context_type: context_type)
+      data.add_negotiate_context(nc)
+      expect(described_class.read(data.to_binary_s)).to eq(data)
+    end
+  end
 end