ruby_smb 1.1.0 → 2.0.0

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/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
+

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

@@ -9,6 +9,7 @@ RSpec.describe RubySMB::SMB2::Packet::TreeConnectRequest do
   it { is_expected.to respond_to :path_offset }
   it { is_expected.to respond_to :path_length }
   it { is_expected.to respond_to :path }
+  it { is_expected.to respond_to :tree_connect_request_extension }
 
   it 'is little endian' do
     expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
@@ -30,18 +31,347 @@ RSpec.describe RubySMB::SMB2::Packet::TreeConnectRequest do
     end
   end
 
-  describe '#encode_path' do
-    let(:path) { '\\192.168.1.1\\example' }
-    let(:encoded_path) { path.encode('utf-16le').force_encoding('binary') }
+  describe '#structure_size' do
+    it 'should be a 16-bit unsigned integer' do
+      expect(packet.structure_size).to be_a BinData::Uint16le
+    end
+
+    it 'should have a default value of 9 as per the SMB2 spec' do
+      expect(packet.structure_size).to eq 9
+    end
+  end
+
+  describe '#flags' do
+    it 'should be a 16-bit unsigned integer' do
+      expect(packet.flags).to be_a BinData::Uint16le
+    end
+  end
+
+  describe '#path_offset' do
+    it 'should be a 16-bit unsigned integer' do
+      expect(packet.path_offset).to be_a BinData::Uint16le
+    end
+
+    context 'when flags is set to SMB2_TREE_CONNECT_FLAG_EXTENSION_PRESENT' do
+      it 'should be set to the offset, in bytes, of the full share path name from the beginning of the packet header' do
+        packet.flags = described_class::SMB2_TREE_CONNECT_FLAG_EXTENSION_PRESENT
+        expect(packet.path_offset).to eq(88)
+      end
+    end
+
+    context 'when flags is not set to SMB2_TREE_CONNECT_FLAG_EXTENSION_PRESENT' do
+      it 'should be set to the offset, in bytes, of the full share path name from the beginning of the packet header' do
+        expect(packet.path_offset).to eq(72)
+      end
+    end
+  end
+
+  describe '#path_length' do
+    let(:path) { '\\\\server\\path' }
+
+    it 'should be a 16-bit unsigned integer' do
+      expect(packet.path_length).to be_a BinData::Uint16le
+    end
+
+    context 'when flags is set to SMB2_TREE_CONNECT_FLAG_EXTENSION_PRESENT' do
+      it 'should be the length of the full share path name (unicode) in bytes' do
+        packet.flags = described_class::SMB2_TREE_CONNECT_FLAG_EXTENSION_PRESENT
+        packet.tree_connect_request_extension.path = path
+        expect(packet.path_length).to eq(path.length * 2)
+      end
+    end
+
+    context 'when flags is not set to SMB2_TREE_CONNECT_FLAG_EXTENSION_PRESENT' do
+      it 'should be the length of the full share path name (unicode) in bytes' do
+        packet.path = path
+        expect(packet.path_length).to eq(path.length * 2)
+      end
+    end
+  end
+
+  describe '#path' do
+    it 'should be a unicode string' do
+      expect(packet.path).to be_a RubySMB::Field::String16
+    end
+
+    it 'exists if #flags is not set to SMB2_TREE_CONNECT_FLAG_EXTENSION_PRESENT' do
+      packet.flags = described_class::SMB2_TREE_CONNECT_FLAG_REDIRECT_TO_OWNER
+      expect(packet.path?).to be true
+    end
+  end
+
+  describe '#tree_connect_request_extension' do
+    it 'is a TreeConnectRequestExtension structure' do
+      expect(packet.tree_connect_request_extension).to be_a RubySMB::SMB2::Packet::TreeConnectRequestExtension
+    end
+
+    it 'exists if #flags is set to SMB2_TREE_CONNECT_FLAG_EXTENSION_PRESENT' do
+      packet.flags = described_class::SMB2_TREE_CONNECT_FLAG_EXTENSION_PRESENT
+      expect(packet.tree_connect_request_extension?).to be true
+    end
+  end
+
+  it 'reads binary data as expected' do
+    data = described_class.new
+    expect(described_class.read(data.to_binary_s)).to eq(data)
+    data = described_class.new(flags: described_class::SMB2_TREE_CONNECT_FLAG_EXTENSION_PRESENT)
+    data.tree_connect_request_extension.tree_connect_contexts << RubySMB::SMB2::Packet::TreeConnectContext.new(context_type: 1)
+    expect(described_class.read(data.to_binary_s)).to eq(data)
+  end
+end
+
+RSpec.describe RubySMB::SMB2::Packet::TreeConnectRequestExtension do
+  subject(:packet) { described_class.new }
+
+  it { is_expected.to respond_to :tree_connect_context_offset }
+  it { is_expected.to respond_to :tree_connect_context_count }
+  it { is_expected.to respond_to :reserved }
+  it { is_expected.to respond_to :path }
+  it { is_expected.to respond_to :tree_connect_contexts }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#tree_connect_context_offset' do
+    it 'is a 32-bit unsigned integer' do
+      expect(packet.tree_connect_context_offset).to be_a BinData::Uint32le
+    end
+
+    it 'is the offset from the start of the SMB2 TREE_CONNECT request of an array of tree connect contexts' do
+      tc = RubySMB::SMB2::Packet::TreeConnectRequest.new(
+        flags: RubySMB::SMB2::Packet::TreeConnectRequest::SMB2_TREE_CONNECT_FLAG_EXTENSION_PRESENT
+      )
+      expect(tc.tree_connect_request_extension.tree_connect_context_offset).to eq(16)
+    end
+  end
+
+  describe '#tree_connect_context_count' do
+    it 'should be a 16-bit unsigned integer' do
+      expect(packet.tree_connect_context_count).to be_a BinData::Uint16le
+    end
+
+    it 'should be the #tree_connect_contexts size' do
+      packet.tree_connect_contexts << RubySMB::SMB2::Packet::TreeConnectContext.new(context_type: 1)
+      packet.tree_connect_contexts << RubySMB::SMB2::Packet::TreeConnectContext.new(context_type: 1)
+      expect(packet.tree_connect_context_count).to eq(2)
+    end
+  end
+
+  describe '#reserved' do
+    it 'should be a binary string' do
+      expect(packet.reserved).to be_a BinData::String
+    end
+
+    it 'is 10-bytes long' do
+      expect(packet.reserved.length).to eq(10)
+    end
+  end
+
+  describe '#path' do
+    it 'should be a unicode string' do
+      expect(packet.path).to be_a RubySMB::Field::String16
+    end
+  end
+
+  describe '#tree_connect_contexts' do
+    it 'is an Array field' do
+      expect(packet.tree_connect_contexts).to be_a BinData::Array
+    end
+
+    it 'has #tree_connect_context_count elements' do
+      packet.tree_connect_context_count = 3
+      expect(packet.tree_connect_contexts.size).to eq(3)
+    end
+  end
+
+  it 'reads binary data as expected' do
+    data = described_class.new
+    expect(described_class.read(data.to_binary_s)).to eq(data)
+    data.tree_connect_contexts << RubySMB::SMB2::Packet::TreeConnectContext.new(context_type: 1)
+    data.tree_connect_contexts << RubySMB::SMB2::Packet::TreeConnectContext.new(context_type: 1)
+    expect(described_class.read(data.to_binary_s)).to eq(data)
+  end
+end
+
+RSpec.describe RubySMB::SMB2::Packet::TreeConnectContext do
+  subject(:packet) do
+    described_class.new(
+      context_type: described_class::SMB2_REMOTED_IDENTITY_TREE_CONNECT_CONTEXT_ID
+    )
+  end
+
+  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 '#context_type' do
+    it 'should be a 16-bit unsigned integer' do
+      expect(packet.context_type).to be_a BinData::Uint16le
+    end
+  end
+
+  describe '#data_length' do
+    it 'should be a 16-bit unsigned integer' do
+      expect(packet.data_length).to be_a BinData::Uint16le
+    end
+
+    it 'is the length, in bytes, of the Data field' do
+      expect(packet.data_length).to eq(packet.data.to_binary_s.size)
+    end
+  end
+
+  describe '#reserved' do
+    it 'is a 32-bit unsigned integer' do
+      expect(packet.reserved).to be_a BinData::Uint32le
+    end
+  end
+
+  describe '#data' do
+    it 'is a BinData Choice' do
+      expect(packet.data).to be_a BinData::Choice
+    end
+
+    it 'contains the structure defined by #context_type' do
+      expect(packet.data).to eq(RubySMB::SMB2::Packet::RemotedIdentityTreeConnectContext.new)
+    end
+  end
+
+  it 'reads binary data as expected' do
+    data = described_class.new(context_type: 1)
+    expect(described_class.read(data.to_binary_s)).to eq(data)
+  end
+end
+
+RSpec.describe RubySMB::SMB2::Packet::RemotedIdentityTreeConnectContext do
+  subject(:packet) { described_class.new }
+
+  it { is_expected.to respond_to :ticket_type }
+  it { is_expected.to respond_to :ticket_size }
+  it { is_expected.to respond_to :user }
+  it { is_expected.to respond_to :user_name }
+  it { is_expected.to respond_to :domain }
+  it { is_expected.to respond_to :groups }
+  it { is_expected.to respond_to :restricted_groups }
+  it { is_expected.to respond_to :privileges }
+  it { is_expected.to respond_to :primary_group }
+  it { is_expected.to respond_to :owner }
+  it { is_expected.to respond_to :default_dacl }
+  it { is_expected.to respond_to :device_groups }
+  it { is_expected.to respond_to :user_claims }
+  it { is_expected.to respond_to :device_claims }
+  it { is_expected.to respond_to :ticket_info }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#ticket_type' do
+    it 'should be a 16-bit unsigned integer' do
+      expect(packet.ticket_type).to be_a BinData::Uint16le
+    end
+
+    it 'should be 1' do
+      expect(packet.ticket_type).to eq(1)
+    end
+  end
+
+  describe '#ticket_size' do
+    it 'should be a 16-bit unsigned integer' do
+      expect(packet.ticket_size).to be_a BinData::Uint16le
+    end
+
+    it 'is the total size of this structure' do
+      packet.ticket_info = 'Ticket Info'
+      expect(packet.ticket_size).to eq(packet.num_bytes)
+    end
+  end
+
+  describe '#user' do
+    it 'should be a 16-bit unsigned integer' do
+      expect(packet.user).to be_a BinData::Uint16le
+    end
+  end
+
+  describe '#user_name' do
+    it 'should be a 16-bit unsigned integer' do
+      expect(packet.user_name).to be_a BinData::Uint16le
+    end
+  end
 
-    it 'sets the path string to a UTF-16LE version of the supplied string' do
-      packet.encode_path(path)
-      expect(packet.path).to eq encoded_path
+  describe '#domain' do
+    it 'should be a 16-bit unsigned integer' do
+      expect(packet.domain).to be_a BinData::Uint16le
     end
+  end
 
-    it 'updates the #path_length' do
-      packet.encode_path(path)
-      expect(packet.path_length).to eq encoded_path.length
+  describe '#groups' do
+    it 'should be a 16-bit unsigned integer' do
+      expect(packet.groups).to be_a BinData::Uint16le
     end
   end
+
+  describe '#restricted_groups' do
+    it 'should be a 16-bit unsigned integer' do
+      expect(packet.restricted_groups).to be_a BinData::Uint16le
+    end
+  end
+
+  describe '#privileges' do
+    it 'should be a 16-bit unsigned integer' do
+      expect(packet.privileges).to be_a BinData::Uint16le
+    end
+  end
+
+  describe '#primary_group' do
+    it 'should be a 16-bit unsigned integer' do
+      expect(packet.primary_group).to be_a BinData::Uint16le
+    end
+  end
+
+  describe '#owner' do
+    it 'should be a 16-bit unsigned integer' do
+      expect(packet.owner).to be_a BinData::Uint16le
+    end
+  end
+
+  describe '#default_dacl' do
+    it 'should be a 16-bit unsigned integer' do
+      expect(packet.default_dacl).to be_a BinData::Uint16le
+    end
+  end
+
+  describe '#device_groups' do
+    it 'should be a 16-bit unsigned integer' do
+      expect(packet.device_groups).to be_a BinData::Uint16le
+    end
+  end
+
+  describe '#user_claims' do
+    it 'should be a 16-bit unsigned integer' do
+      expect(packet.user_claims).to be_a BinData::Uint16le
+    end
+  end
+
+  describe '#device_claims' do
+    it 'should be a 16-bit unsigned integer' do
+      expect(packet.device_claims).to be_a BinData::Uint16le
+    end
+  end
+
+  describe '#ticket_info' do
+    it 'should be string' do
+      expect(packet.ticket_info).to be_a BinData::String
+    end
+  end
+
+  it 'reads binary data as expected' do
+    data = described_class.new(ticket_info: 'ticket info')
+    expect(described_class.read(data.to_binary_s)).to eq(data)
+  end
 end