ruby_smb 1.0.3 → 2.0.1

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

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

@@ -61,12 +61,28 @@ RSpec.describe RubySMB::SMB2::Packet::NegotiateResponse do
   end
 
   describe '#negotiate_context_count' do
+    it 'only exists if the 0x0311 dialect is included' do
+      packet.dialect_revision = 0x0311
+      expect(packet.negotiate_context_count?).to be true
+    end
+
+    it 'does not exist if the 0x0311 dialect is not included' do
+      packet.dialect_revision = 0x0300
+      expect(packet.negotiate_context_count?).to be false
+    end
+
     it 'is a 16-bit unsigned integer' do
       expect(packet.negotiate_context_count).to be_a BinData::Uint16le
     end
 
-    it 'has a default value of 0' do
-      expect(packet.negotiate_context_count).to eq 0
+    it 'is set to the #negotiate_context_list array size' do
+      packet.dialect_revision = 0x0311
+      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(packet.negotiate_context_count).to eq(2)
     end
   end
 
@@ -134,6 +150,16 @@ RSpec.describe RubySMB::SMB2::Packet::NegotiateResponse do
   end
 
   describe '#negotiate_context_offset' do
+    it 'only exists if the 0x0311 dialect is included' do
+      packet.dialect_revision = 0x0311
+      expect(packet.negotiate_context_offset?).to be true
+    end
+
+    it 'does not exist if the 0x0311 dialect is not included' do
+      packet.dialect_revision = 0x0300
+      expect(packet.negotiate_context_offset?).to be false
+    end
+
     it 'is a 32-bit unsigned integer' do
       expect(packet.negotiate_context_offset).to be_a BinData::Uint32le
     end
@@ -144,4 +170,96 @@ RSpec.describe RubySMB::SMB2::Packet::NegotiateResponse do
       expect(packet.security_buffer).to be_a BinData::String
     end
   end
+
+  describe '#pad' do
+    it 'only exists if the 0x0311 dialect is included' do
+      packet.dialect_revision = 0x0311
+      expect(packet.pad?).to be true
+    end
+
+    it 'does not exist if the 0x0311 dialect is not included' do
+      packet.dialect_revision = 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.dialect_revision = 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.dialect_revision = 0x0311
+      expect(packet.negotiate_context_list?).to be true
+    end
+
+    it 'does not exist if the 0x0311 dialect is not included' do
+      packet.dialect_revision = 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 '#find_negotiate_context' do
+    before :example do
+      packet.add_negotiate_context(
+        RubySMB::SMB2::NegotiateContext.new(context_type: RubySMB::SMB2::NegotiateContext::SMB2_PREAUTH_INTEGRITY_CAPABILITIES)
+      )
+      packet.add_negotiate_context(
+        RubySMB::SMB2::NegotiateContext.new(context_type: RubySMB::SMB2::NegotiateContext::SMB2_ENCRYPTION_CAPABILITIES)
+      )
+    end
+
+    it 'returns the expected Negotiate Context structure' do
+      expect(packet.find_negotiate_context(RubySMB::SMB2::NegotiateContext::SMB2_ENCRYPTION_CAPABILITIES)).to eq(packet.negotiate_context_list[1])
+    end
+
+    it 'returns nil if the Negotiate Context structure is not found' do
+      expect(packet.find_negotiate_context(10)).to be nil
+    end
+  end
+
+  describe '#add_negotiate_context' do
+    it 'raises an ArgumentError exception if 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.dialect_revision = 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.dialect_revision = 0x0311
+    data.security_buffer = 'security buf test'
+    [
+      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

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

@@ -60,5 +60,13 @@ RSpec.describe RubySMB::SMB2::Packet::QueryDirectoryResponse do
       packet.buffer = names_blob
       expect(packet.results(RubySMB::Fscc::FileInformation::FileNamesInformation)).to eq names_array
     end
+
+    context 'when the File Information is not a valid' do
+      it 'raises an InvalidPacket exception' do
+        packet.buffer = names_blob
+        allow(RubySMB::Fscc::FileInformation::FileNamesInformation).to receive(:read).and_raise(IOError)
+        expect { packet.results(RubySMB::Fscc::FileInformation::FileNamesInformation) }.to raise_error(RubySMB::Error::InvalidPacket)
+      end
+    end
   end
 end

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

@@ -0,0 +1,220 @@
+RSpec.describe RubySMB::SMB2::Packet::TransformHeader do
+  subject(:packet) { described_class.new }
+
+  it { is_expected.to respond_to :protocol }
+  it { is_expected.to respond_to :signature }
+  it { is_expected.to respond_to :nonce }
+  it { is_expected.to respond_to :original_message_size }
+  it { is_expected.to respond_to :flags }
+  it { is_expected.to respond_to :session_id }
+  it { is_expected.to respond_to :encrypted_data }
+
+  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 'has an initial value of 0xFD534D42' do
+      expect(packet.protocol).to eq(0xFD534D42)
+    end
+  end
+
+  describe '#signature' do
+    it 'is a String' do
+      expect(packet.signature).to be_a BinData::String
+    end
+  end
+
+  describe '#nonce' do
+    it 'is a String' do
+      expect(packet.nonce).to be_a BinData::String
+    end
+  end
+
+  describe '#original_message_size  ' do
+    it 'is a 32-bit unsigned integer' do
+      expect(packet.original_message_size).to be_a BinData::Uint32le
+    end
+  end
+
+  describe '#flags' do
+    it 'is a 16-bit unsigned integer' do
+      expect(packet.flags).to be_a BinData::Uint16le
+    end
+  end
+
+  describe '#session_id' do
+    it 'is a 64-bit unsigned integer' do
+      expect(packet.session_id).to be_a BinData::Uint64le
+    end
+  end
+
+  describe '#encrypted_data' do
+    it 'is an Array' do
+      expect(packet.encrypted_data).to be_a BinData::Array
+    end
+  end
+
+  describe '#decrypt' do
+    let(:key) { "\x56\x89\xd1\xbb\xf7\x45\xc0\xb6\x68\x81\x07\xe4\x7d\x35\xaf\xd3".b }
+    let(:data) { 'data'.b }
+    before :example do
+      packet.original_message_size = data.length
+    end
+
+    it 'raises the expected exception if the given algorithm is invalid' do
+      expect { packet.decrypt(key, algorithm: 'RC4') }.to raise_error(
+        RubySMB::Error::EncryptionError,
+        'Error while decrypting with \'RC4\' (ArgumentError: Invalid algorithm, must be either AES-128-CCM or AES-128-GCM)'
+      )
+    end
+
+    context 'with AES-128-GCM algorithm (default)' do
+      before :example do
+        begin
+          OpenSSL::Cipher.new('AES-128-GCM')
+        rescue
+          skip(
+            "This test cannot be run since the version of OpenSSL the ruby "\
+            "OpenSSL extension was built with (#{OpenSSL::OPENSSL_VERSION}) "\
+            "does not support AES-128-GCM cipher")
+        end
+        packet.encrypted_data = "\x06\x45\x16\x36".bytes
+        packet.signature = "\x63\xb2\xf9\xe0\xb7\x43\xdb\xaf\x26\x8e\xd7\x42\xd3\xb2\xde\x0d"
+        packet.nonce = "\xe1\xb0\xa7\x20\xd9\xd9\x69\x3c\x79\xd0\x9c\x53\x00\x00\x00\x00"
+      end
+
+      it 'generates a cipher using OpenSSL::Cipher' do
+        expect(OpenSSL::Cipher).to receive(:new).with('AES-128-GCM').and_call_original
+        packet.decrypt(key)
+      end
+
+      it 'returns the expected decrypted string' do
+        expect(packet.decrypt(key)).to eq(data)
+      end
+
+      it 'raises the expected exception if an error occurs' do
+        allow(OpenSSL::Cipher).to receive(:new).and_raise(
+          RuntimeError.new('unsupported cipher algorithm (AES-128-GCM)'))
+        expect { packet.decrypt(key) }.to raise_error(
+          RubySMB::Error::EncryptionError,
+          'Error while decrypting with \'AES-128-GCM\' (RuntimeError: unsupported cipher algorithm (AES-128-GCM))'
+        )
+      end
+    end
+
+    context 'with AES-128-CCM algorithm' do
+      before :example do
+        packet.encrypted_data = "\xf0\x05\x61\x91".bytes
+        packet.signature = "\xdd\x51\x9a\xc5\x6d\x38\x68\xdc\x36\x89\xb8\x99\xd8\x4a\xb8\x4a".b
+        packet.nonce = "\x8a\x6e\x2a\x87\x11\x61\x85\xd2\x15\x69\xf7\x00\x00\x00\x00\x00".b
+      end
+
+      it 'generates a cipher using OpenSSL::CCM' do
+        expect(OpenSSL::CCM).to receive(:new).with('AES', key, 16).and_call_original
+        packet.decrypt(key, algorithm: 'AES-128-CCM')
+      end
+
+      it 'returns the expected decrypted string' do
+        expect(packet.decrypt(key, algorithm: 'AES-128-CCM')).to eq(data)
+      end
+
+      it 'raises the expected exception if an error occurs' do
+        allow(OpenSSL::CCM).to receive(:new).and_raise(
+          OpenSSL::CCMError.new('unsupported cipher algorithm (AES-128-CCM)'))
+        expect { packet.decrypt(key, algorithm: 'AES-128-CCM') }.to raise_error(
+          RubySMB::Error::EncryptionError,
+          'Error while decrypting with \'AES-128-CCM\' (OpenSSL::CCMError: unsupported cipher algorithm (AES-128-CCM))'
+        )
+      end
+    end
+  end
+
+  describe '#encrypt' do
+    let(:key)    { "\x56\x89\xd1\xbb\xf7\x45\xc0\xb6\x68\x81\x07\xe4\x7d\x35\xaf\xd3".b }
+    let(:struct) { RubySMB::SMB2::Packet::TreeConnectRequest.new }
+
+    it 'raises the expected exception if the given algorithm is invalid' do
+      expect { packet.encrypt(struct, key, algorithm: 'RC4') }.to raise_error(
+        RubySMB::Error::EncryptionError,
+        'Error while encrypting with \'RC4\' (ArgumentError: Invalid algorithm, must be either AES-128-CCM or AES-128-GCM)'
+      )
+    end
+
+    context 'with AES-128-GCM algorithm (default)' do
+      before :example do
+        begin
+          OpenSSL::Cipher.new('AES-128-GCM')
+        rescue
+          skip(
+            "This test cannot be run since the version of OpenSSL the ruby "\
+            "OpenSSL extension was built with (#{OpenSSL::OPENSSL_VERSION}) "\
+            "does not support AES-128-GCM cipher")
+        end
+      end
+
+      it 'generates a cipher using OpenSSL::Cipher' do
+        expect(OpenSSL::Cipher).to receive(:new).with('AES-128-GCM').and_call_original
+        packet.encrypt(struct, key)
+      end
+
+      it 'encrypts a BinData structure' do
+        packet.encrypt(struct, key)
+        expect(packet.decrypt(key)).to eq(struct.to_binary_s)
+      end
+
+      it 'encrypts a string' do
+        packet.encrypt('data', key)
+        expect(packet.decrypt(key)).to eq('data')
+      end
+
+      it 'raises the expected exception if an error occurs' do
+        allow(OpenSSL::Cipher).to receive(:new).and_raise(
+          RuntimeError.new('unsupported cipher algorithm (AES-128-GCM)'))
+        expect { packet.encrypt('data', key) }.to raise_error(
+          RubySMB::Error::EncryptionError,
+          'Error while encrypting with \'AES-128-GCM\' (RuntimeError: unsupported cipher algorithm (AES-128-GCM))'
+        )
+      end
+    end
+
+    context 'with AES-128-CCM algorithm' do
+      it 'generates a cipher using OpenSSL::CCM' do
+        expect(OpenSSL::CCM).to receive(:new).with('AES', key, 16).and_call_original
+        packet.encrypt(struct, key, algorithm: 'AES-128-CCM')
+      end
+
+      it 'encrypts a BinData structure' do
+        packet.encrypt(struct, key, algorithm: 'AES-128-CCM')
+        expect(packet.decrypt(key, algorithm: 'AES-128-CCM')).to eq(struct.to_binary_s)
+      end
+
+      it 'encrypts a string' do
+        packet.encrypt('data', key, algorithm: 'AES-128-CCM')
+        expect(packet.decrypt(key, algorithm: 'AES-128-CCM')).to eq('data')
+      end
+
+      it 'raises the expected exception if an error occurs' do
+        allow(OpenSSL::CCM).to receive(:new).and_raise(
+          OpenSSL::CCMError.new('unsupported cipher algorithm (AES-128-CCM)'))
+        expect { packet.encrypt('data', key, algorithm: 'AES-128-CCM') }.to raise_error(
+          RubySMB::Error::EncryptionError,
+          'Error while encrypting with \'AES-128-CCM\' (OpenSSL::CCMError: unsupported cipher algorithm (AES-128-CCM))'
+        )
+      end
+    end
+  end
+
+  it 'reads binary data as expected' do
+    data = described_class.new
+    key = "\x56\x89\xd1\xbb\xf7\x45\xc0\xb6\x68\x81\x07\xe4\x7d\x35\xaf\xd3".b
+    struct = RubySMB::SMB2::Packet::TreeConnectRequest.new
+    data.encrypt(struct, key, algorithm: 'AES-128-CCM')
+    expect(described_class.read(data.to_binary_s)).to eq(data)
+  end
+end
+