ruby_smb 3.2.0 → 3.3.0

data/lib/ruby_smb/server/share/provider.rb

@@ -6,9 +6,51 @@ module RubySMB
         # type and name. It is shared across all client connections and
         # sessions.
         class Base
+          Hook = Struct.new(:request_class, :location, :callback)
+
           # @param [String] name The name of this share.
-          def initialize(name)
+          def initialize(name, hooks: nil)
             @name = name
+            @hooks = hooks || []
+          end
+
+          # Add a hook to be called when the specified request class is processed. Any hook that was previously
+          # installed for the request class and location will be removed. A hook installed with a location of :before
+          # will be called with the session and request as the only two arguments. The return value, if provided, will
+          # replace the request that is to be processed. A hook installed with a location of :after will be called with
+          # the session, request and response as the only three arguments. The return value, if provided, will replace
+          # the response that is to be sent to the client.
+          #
+          # @param [RubySMB::GenericPacket] request_class The request class to register the hook for.
+          # @param [Proc] callback The routine to be executed when the request class is being processed.
+          # @param [Symbol] location When the callback should be invoked. Must be either :before or :after.
+          def add_hook(request_class, callback: nil, location: :before, &block)
+            unless %i[ before after ].include?(location)
+              raise ArgumentError, 'the location argument must be :before or :after'
+            end
+
+            unless callback.nil? ^ block.nil?
+              raise ArgumentError, 'either a callback or a block must be specified'
+            end
+
+            # Remove any hooks that were previously installed, this enforces that only one hook can be present at a time
+            # for any particular request class and location combination.
+            remove_hook(request_class, location: location)
+            @hooks << Hook.new(request_class, location, callback || block)
+
+            nil
+          end
+
+          # Remove a hook for the specified request class.
+          #
+          # @param [RubySMB::GenericPacket] request_class The request class to register the hook for.
+          # @param [Symbol] location When the callback should be invoked.
+          def remove_hook(request_class, location: :before)
+            @hooks.filter! do |hook|
+              hook.request_class == request_class && hook.location == location
+            end
+
+            nil
           end
 
           # Create a new, session-specific processor instance for this share.
@@ -28,6 +70,11 @@ module RubySMB
           # @!attribute [r] name
           #   @return [String]
           attr_accessor :name
+
+          # The hooks installed for this share.
+          # @!attribute [r] hooks
+          #   @return [Array]
+          attr_accessor :hooks
         end
       end
     end

data/lib/ruby_smb/smb1/data_block.rb

@@ -11,7 +11,7 @@ module RubySMB
       # Class method to stub byte count calculation during
       # lazy evaluation.
       #
-      # @return [Fixnum] will always return 0
+      # @return [Integer] will always return 0
       def self.calculate_byte_count
         0
       end
@@ -28,7 +28,7 @@ module RubySMB
       # Calculates the size of the other fields in the DataBlock
       # in Bytes.
       #
-      # @return [Fixnum] The size of the DataBlock in Words
+      # @return [Integer] The size of the DataBlock in Words
       def calculate_byte_count
         total_count = 0
         self.class.data_fields.each do |field_name|

data/lib/ruby_smb/smb1/packet/nt_create_andx_request.rb

@@ -35,7 +35,7 @@ module RubySMB
           end
 
           uint64                             :allocation_size,     label: 'Allocation Size'
-          smb_ext_file_attributes            :ext_file_attributes, label: 'Extented File Attributes'
+          smb_ext_file_attributes            :ext_file_attributes, label: 'Extended File Attributes'
           share_access                       :share_access,        label: 'Share Access'
           # The following constants are defined in RubySMB::Dispositions
           uint32                             :create_disposition,  label: 'Create Disposition'

data/lib/ruby_smb/smb1/parameter_block.rb

@@ -11,7 +11,7 @@ module RubySMB
       # Class method to stub word count calculation during
       # lazy evaluation.
       #
-      # @param [Fixnum] will always return 0
+      # @param [Integer] will always return 0
       def self.calculate_word_count
         0
       end
@@ -28,7 +28,7 @@ module RubySMB
       # Calculates the size of the other fields in the ParameterBlock
       # in Words.
       #
-      # @return [Fixnum] The size of the ParameterBlock in Words
+      # @return [Integer] The size of the ParameterBlock in Words
       def calculate_word_count
         total_count = 0
         self.class.parameter_fields.each do |field_name|

data/lib/ruby_smb/smb1/pipe.rb

@@ -147,6 +147,10 @@ module RubySMB
             break if dcerpc_response.pdu_header.pfc_flags.last_frag == 1
             raw_data = read(bytes: @tree.client.max_buffer_size)
             dcerpc_response = dcerpc_response_from_raw_response(raw_data)
+            if options[:auth_level] &&
+               [RPC_C_AUTHN_LEVEL_PKT_INTEGRITY, RPC_C_AUTHN_LEVEL_PKT_PRIVACY].include?(options[:auth_level])
+              handle_integrity_privacy(dcerpc_response, auth_level: options[:auth_level], auth_type: options[:auth_type])
+            end
             stub_data << dcerpc_response.stub.to_s
           end
           stub_data

data/lib/ruby_smb/smb2/create_context.rb

@@ -51,8 +51,11 @@ module RubySMB
         def calc_buffer_size
           align = 8
           size = 0
-          size += name_length + ((align - name_length % align) % align)
-          size += data_length + ((align - data_length % align) % align)
+          size += name_length
+          size += ((align - size % align) % align) if name_offset < data_offset
+          size += data_length
+          size += ((align - size % align) % align) if data_offset < name_offset
+          size += ((align - size % align) % align) if next_offset != 0
           size
         end
 

data/lib/ruby_smb/smb2/packet/negotiate_request.rb

@@ -28,8 +28,8 @@ module RubySMB
 
         # Adds a dialect to the Dialects array
         #
-        # @param [Fixnum] the numeric code for the dialect you wish to add
-        # @return [Array<Fixnum>] the array of all currently selected dialects
+        # @param [Integer] the numeric code for the dialect you wish to add
+        # @return [Array<Integer>] the array of all currently selected dialects
         # @raise [ArgumentError] if the dialect is not an Integer
         def add_dialect(dialect)
           raise ArgumentError, 'Must be a number' unless dialect.is_a? Integer
@@ -40,8 +40,8 @@ module RubySMB
         # the dialect_count field appropriately. Will erase any previously set
         # dialects.
         #
-        # @param [Array<Fixnum>] the array of dialects to set
-        # @return [Array<Fixnum>] the current value of the dialects array
+        # @param [Array<Integer>] the array of dialects to set
+        # @return [Array<Integer>] the current value of the dialects array
         def set_dialects(add_dialects = [])
           self.dialects = []
           add_dialects.each do |dialect|
@@ -53,7 +53,7 @@ module RubySMB
         # Adds a Negotiate Context to the #negotiate_context_list
         #
         # @param [NegotiateContext] the Negotiate Context structure you wish to add
-        # @return [Array<Fixnum>] the array of all currently added Negotiate Contexts
+        # @return [Array<Integer>] the array of all currently added Negotiate Contexts
         # @raise [ArgumentError] if the dialect is not a NegotiateContext structure
         def add_negotiate_context(nc)
           raise ArgumentError, 'Must be a NegotiateContext' unless nc.is_a? NegotiateContext

data/lib/ruby_smb/smb2/packet/negotiate_response.rb

@@ -48,7 +48,7 @@ module RubySMB
         # Adds a Negotiate Context to the #negotiate_context_list
         #
         # @param [NegotiateContext] the Negotiate Context structure you wish to add
-        # @return [Array<Fixnum>] the array of all currently added Negotiate Contexts
+        # @return [Array<Integer>] the array of all currently added Negotiate Contexts
         # @raise [ArgumentError] if the dialect is not a NegotiateContext structure
         def add_negotiate_context(nc)
           raise ArgumentError, 'Must be a NegotiateContext' unless nc.is_a? NegotiateContext

data/lib/ruby_smb/smb2/pipe.rb

@@ -145,6 +145,10 @@ module RubySMB
             break if dcerpc_response.pdu_header.pfc_flags.last_frag == 1
             raw_data = read(bytes: @tree.client.max_buffer_size)
             dcerpc_response = dcerpc_response_from_raw_response(raw_data)
+            if options[:auth_level] &&
+               [RPC_C_AUTHN_LEVEL_PKT_INTEGRITY, RPC_C_AUTHN_LEVEL_PKT_PRIVACY].include?(options[:auth_level])
+              handle_integrity_privacy(dcerpc_response, auth_level: options[:auth_level], auth_type: options[:auth_type])
+            end
             stub_data << dcerpc_response.stub.to_s
           end
           stub_data

data/lib/ruby_smb/smb2/tree.rb

@@ -85,6 +85,7 @@ module RubySMB
       # @raise [RubySMB::Error::InvalidPacket] if the response is not a QueryDirectoryResponse packet
       def list(directory: nil, pattern: '*', type: RubySMB::Fscc::FileInformation::FileIdFullDirectoryInformation)
         create_response = open_directory(directory: directory)
+        opened_directory = RubySMB::SMB2::File.new(tree: self, response: create_response, name: directory)
         file_id         = create_response.file_id
 
         directory_request                         = RubySMB::SMB2::Packet::QueryDirectoryRequest.new
@@ -127,8 +128,9 @@ module RubySMB
           # Reset the message id so the client can update appropriately.
           directory_request.smb2_header.message_id = 0
         end
-
         files
+      ensure
+        opened_directory.close if opened_directory
       end
 
       # 'Opens' a directory file on the remote end, using a CreateRequest. This

data/lib/ruby_smb/utils.rb

@@ -0,0 +1,15 @@
+module RubySMB
+  module Utils
+
+    def self.safe_encode(str, encoding)
+      str.encode(encoding)
+    rescue EncodingError
+      if str.encoding == ::Encoding::ASCII_8BIT
+        str.dup.force_encoding(encoding)
+      else
+        raise
+      end
+    end
+
+  end
+end

data/lib/ruby_smb/version.rb

@@ -1,3 +1,3 @@
 module RubySMB
-  VERSION = '3.2.0'.freeze
+  VERSION = '3.3.0'.freeze
 end

data/lib/ruby_smb.rb

@@ -6,11 +6,13 @@ require 'openssl/ccm'
 require 'openssl/cmac'
 require 'windows_error'
 require 'windows_error/nt_status'
+require 'ruby_smb/ntlm/custom/string_encoder'
 # A packet parsing and manipulation library for the SMB1 and SMB2 protocols
 #
 # [[MS-SMB] Server Message Block (SMB) Protocol Version 1](https://msdn.microsoft.com/en-us/library/cc246482.aspx)
 # [[MS-SMB2] Server Message Block (SMB) Protocol Versions 2 and 3](https://msdn.microsoft.com/en-us/library/cc246482.aspx)
 module RubySMB
+  require 'ruby_smb/utils'
   require 'ruby_smb/error'
   require 'ruby_smb/create_actions'
   require 'ruby_smb/dispositions'

data/spec/lib/ruby_smb/client_spec.rb

@@ -2701,7 +2701,7 @@ RSpec.describe RubySMB::Client do
               session_key,
               "SMB2AESCCM\x00",
               "ServerIn \x00",
-              {length: 128}
+              length: 128
             ).and_call_original
             client.smb3_encrypt(data)
           end
@@ -2717,7 +2717,7 @@ RSpec.describe RubySMB::Client do
             session_key,
             "SMBC2SCipherKey\x00",
             '',
-            {length: 128}
+            length: 128
           ).and_call_original
           client.smb3_encrypt(data)
         end
@@ -2791,7 +2791,7 @@ RSpec.describe RubySMB::Client do
               session_key,
               "SMB2AESCCM\x00",
               "ServerOut\x00",
-              {length: 128}
+              length: 128
             ).and_call_original
             client.smb3_decrypt(transform_packet)
           end
@@ -2807,7 +2807,7 @@ RSpec.describe RubySMB::Client do
             session_key,
             "SMBS2CCipherKey\x00",
             '',
-            {length: 128}
+            length: 128
           ).and_call_original
           client.smb3_decrypt(transform_packet)
         end

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

@@ -9,7 +9,12 @@ RSpec.describe RubySMB::Dcerpc::Client do
   let(:endpoint) { RubySMB::Dcerpc::Samr }
 
   subject(:client) { described_class.new(host, endpoint) }
-  subject(:auth_client) { described_class.new(host, endpoint, username: 'testuser', password: '1234') }
+  subject(:auth_client) do
+    result = described_class.new(host, endpoint, username: 'testuser', password: '1234')
+    result.force_set_auth_params(RubySMB::Dcerpc::RPC_C_AUTHN_WINNT, RubySMB::Dcerpc::RPC_C_AUTHN_LEVEL_PKT_PRIVACY)
+   
+    result
+  end
 
   it { is_expected.to respond_to :domain }
   it { is_expected.to respond_to :local_workstation }
@@ -135,21 +140,21 @@ RSpec.describe RubySMB::Dcerpc::Client do
     describe '#add_auth_verifier' do
       let(:req) { RubySMB::Dcerpc::Bind.new }
       let(:auth_type) { RubySMB::Dcerpc::RPC_C_AUTHN_WINNT }
-      let(:auth_level) { 0 }
+      let(:auth_level) { RubySMB::Dcerpc::RPC_C_AUTHN_LEVEL_PKT_PRIVACY }
       let(:auth) { 'serialized auth value' }
 
       it 'sets #auth_value field to the expected value' do
-        auth_client.add_auth_verifier(req, auth, auth_type, auth_level)
+        auth_client.add_auth_verifier(req, auth)
         expect(req.auth_value).to eq(auth)
       end
 
       it 'sets PDUHeader #auth_length field to the expected value' do
-        auth_client.add_auth_verifier(req, auth, auth_type, auth_level)
+        auth_client.add_auth_verifier(req, auth)
         expect(req.pdu_header.auth_length).to eq(auth.length)
       end
 
       it 'sets #sec_trailer field to the expected value' do
-        auth_client.add_auth_verifier(req, auth, auth_type, auth_level)
+        auth_client.add_auth_verifier(req, auth)
         expect(req.sec_trailer.auth_type).to eq(auth_type)
         expect(req.sec_trailer.auth_level).to eq(auth_level)
         expect(req.sec_trailer.auth_context_id).to eq(auth_client.instance_variable_get(:@auth_ctx_id_base))
@@ -202,29 +207,29 @@ RSpec.describe RubySMB::Dcerpc::Client do
       end
 
       it 'add an auth verifier to the RpcAuth3 packet' do
-        auth_client.send_auth3(bindack, auth_type, auth_level)
-        expect(auth_client).to have_received(:add_auth_verifier).with(rpc_auth3, auth3, auth_type, auth_level)
+        auth_client.auth_provider_complete_handshake(bindack, auth_type: auth_type, auth_level: auth_level)
+        expect(auth_client).to have_received(:add_auth_verifier).with(rpc_auth3, auth3)
       end
 
       it 'sets the PDUHeader #call_id to the expected value' do
         auth_client.instance_variable_set(:@call_id, 56)
-        auth_client.send_auth3(bindack, auth_type, auth_level)
+        auth_client.auth_provider_complete_handshake(bindack, auth_type: auth_type, auth_level: auth_level)
         expect(rpc_auth3.pdu_header.call_id).to eq(56)
       end
 
       it 'sends the RpcAuth3 packet' do
-        auth_client.send_auth3(bindack, auth_type, auth_level)
+        auth_client.auth_provider_complete_handshake(bindack, auth_type: auth_type, auth_level: auth_level)
         expect(auth_client).to have_received(:send_packet).with(rpc_auth3)
       end
 
       it 'increments #call_id' do
-        auth_client.send_auth3(bindack, auth_type, auth_level)
+        auth_client.auth_provider_complete_handshake(bindack, auth_type: auth_type, auth_level: auth_level)
         expect(auth_client.instance_variable_get(:@call_id)).to eq(2)
       end
 
       context 'with RPC_C_AUTHN_WINNT auth_type' do
         it 'processes NTLM type2 message' do
-          auth_client.send_auth3(bindack, auth_type, auth_level)
+          auth_client.auth_provider_complete_handshake(bindack, auth_type: auth_type, auth_level: auth_level)
           expect(auth_client).to have_received(:process_ntlm_type2).with(auth)
         end
       end
@@ -300,7 +305,7 @@ RSpec.describe RubySMB::Dcerpc::Client do
 
       context 'with RPC_C_AUTHN_WINNT auth_type' do
         let(:kwargs) do {
-            auth_level: RubySMB::Dcerpc::RPC_C_AUTHN_LEVEL_DEFAULT,
+            auth_level: RubySMB::Dcerpc::RPC_C_AUTHN_LEVEL_PKT_PRIVACY,
             auth_type: RubySMB::Dcerpc::RPC_C_AUTHN_WINNT
           }
         end
@@ -310,7 +315,7 @@ RSpec.describe RubySMB::Dcerpc::Client do
           allow(client.ntlm_client).to receive(:init_context).and_return(type1_message)
           allow(type1_message).to receive(:serialize).and_return(auth)
           allow(client).to receive(:add_auth_verifier)
-          allow(client).to receive(:send_auth3)
+          allow(client).to receive(:auth_provider_complete_handshake)
         end
 
         it 'raises an exception if the NTLM client is not initialized' do
@@ -320,12 +325,12 @@ RSpec.describe RubySMB::Dcerpc::Client do
 
         it 'adds the auth verifier with a NTLM type1 message' do
           client.bind(**kwargs)
-          expect(client).to have_received(:add_auth_verifier).with(bind_req, auth, kwargs[:auth_type], kwargs[:auth_level])
+          expect(client).to have_received(:add_auth_verifier).with(bind_req, auth)
         end
 
         it 'sends an auth3 request' do
           client.bind(**kwargs)
-          expect(client).to have_received(:send_auth3).with(bindack_response, kwargs[:auth_type], kwargs[:auth_level])
+          expect(client).to have_received(:auth_provider_complete_handshake).with(bindack_response, auth_type: kwargs[:auth_type], auth_level: kwargs[:auth_level])
         end
       end
     end
@@ -372,10 +377,14 @@ RSpec.describe RubySMB::Dcerpc::Client do
 
   describe '#set_integrity_privacy' do
     let(:dcerpc_req) do
-      RubySMB::Dcerpc::Request.new(
+      req = RubySMB::Dcerpc::Request.new(
         { opnum: RubySMB::Dcerpc::Winreg::REG_ENUM_KEY },
         { endpoint: 'Winreg' }
       )
+      req.sec_trailer.auth_pad_length = 8
+      req.auth_pad = "\x00" * 8
+
+      req
     end
     let(:auth_level) { RubySMB::Dcerpc::RPC_C_AUTHN_LEVEL_PKT_PRIVACY }
     let(:auth_type) { RubySMB::Dcerpc::RPC_C_AUTHN_WINNT }
@@ -656,6 +665,8 @@ RSpec.describe RubySMB::Dcerpc::Client do
       # Make sure the encrypted stub includes the correct pad to make sure sec_trailer is 16-bytes aligned
       allow(session).to receive(:unseal_message).and_return(decrypted_stub + auth_pad)
       allow(session).to receive(:verify_signature).and_return true
+      dcerpc_res.sec_trailer.auth_type = auth_type
+      dcerpc_res.sec_trailer.auth_level = auth_level
     end
 
     it 'verifies the signature' do
@@ -698,6 +709,8 @@ RSpec.describe RubySMB::Dcerpc::Client do
     context 'without RPC_C_AUTHN_LEVEL_PKT_PRIVACY auth_level' do
       it 'does not encrypt the stub' do
         plain_stub = dcerpc_res.stub.to_binary_s
+        dcerpc_res.sec_trailer.auth_level = RubySMB::Dcerpc::RPC_C_AUTHN_LEVEL_PKT_INTEGRITY
+        dcerpc_res.sec_trailer.auth_type = RubySMB::Dcerpc::RPC_C_AUTHN_WINNT
         auth_client.handle_integrity_privacy(dcerpc_res, auth_level: RubySMB::Dcerpc::RPC_C_AUTHN_LEVEL_PKT_INTEGRITY, auth_type: auth_type)
         expect(dcerpc_res.stub).to eq(plain_stub)
         expect(session).to_not have_received(:unseal_message)
@@ -706,6 +719,8 @@ RSpec.describe RubySMB::Dcerpc::Client do
 
     context 'with an unsupported auth_level' do
       it 'raises an Argument exception' do
+        dcerpc_res.sec_trailer.auth_level = RubySMB::Dcerpc::RPC_C_AUTHN_LEVEL_PKT_INTEGRITY
+        dcerpc_res.sec_trailer.auth_type = 88
         expect { auth_client.handle_integrity_privacy(dcerpc_res, auth_level: auth_level, auth_type: 88) }.to raise_error(ArgumentError)
       end
     end

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

@@ -6,7 +6,10 @@ RSpec.describe RubySMB::Dcerpc::Drsr do
   end
 
   let(:drsr) do
-    RubySMB::Dcerpc::Client.new('1.2.3.4', RubySMB::Dcerpc::Drsr)
+    drsr = RubySMB::Dcerpc::Client.new('1.2.3.4', RubySMB::Dcerpc::Drsr)
+    drsr.force_set_auth_params(RubySMB::Dcerpc::RPC_C_AUTHN_WINNT, RubySMB::Dcerpc::RPC_C_AUTHN_LEVEL_PKT_PRIVACY)
+
+    drsr
   end
 
   describe described_class::DrsHandle do

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

@@ -4146,3 +4146,201 @@ RSpec.describe 'Alignment' do
     end
   end
 end
+
+RSpec.describe RubySMB::Dcerpc::Ndr::TypeSerialization1CommonTypeHeader do
+  it 'is a BinData::Record class' do
+    expect(described_class).to be < BinData::Record
+  end
+  it 'has :byte_align parameter set to the expected value' do
+    expect(described_class.default_parameters[:byte_align]).to eq(8)
+  end
+
+  subject { described_class.new }
+
+  it { is_expected.to respond_to :version }
+  it { is_expected.to respond_to :endianness }
+  it { is_expected.to respond_to :common_header_length }
+  it { is_expected.to respond_to :filler }
+
+  context 'with #version' do
+    it 'is a BinData::Uint8' do
+      expect(subject.version).to be_a BinData::Uint8
+    end
+    it 'returns 1 by default' do
+      expect(subject.version).to eq(1)
+    end
+  end
+
+  context 'with #endianness' do
+    it 'is a BinData::Uint8' do
+      expect(subject.endianness).to be_a BinData::Uint8
+    end
+    it 'returns 0x10 by default' do
+      expect(subject.endianness).to eq(0x10)
+    end
+  end
+
+  context 'with #common_header_length' do
+    it 'is a BinData::Uint16le' do
+      expect(subject.common_header_length).to be_a BinData::Uint16le
+    end
+    it 'returns 8 by default' do
+      expect(subject.common_header_length).to eq(8)
+    end
+  end
+
+  context 'with #filler' do
+    it 'is a BinData::Uint32le' do
+      expect(subject.filler).to be_a BinData::Uint32le
+    end
+    it 'returns 0xCCCCCCCC by default' do
+      expect(subject.filler).to eq(0xCCCCCCCC)
+    end
+  end
+
+  it 'reads itself' do
+    values = {version: 4, endianness: 0x33, common_header_length: 44, filler: 0xFFFFFFFF}
+    struct_instance = described_class.new(values)
+    expect(described_class.read(struct_instance.to_binary_s)).to eq(values)
+  end
+end
+
+RSpec.describe RubySMB::Dcerpc::Ndr::TypeSerialization1PrivateHeader do
+  it 'is a BinData::Record class' do
+    expect(described_class).to be < BinData::Record
+  end
+  it 'has :byte_align parameter set to the expected value' do
+    expect(described_class.default_parameters[:byte_align]).to eq(8)
+  end
+
+  subject { described_class.new }
+
+  it { is_expected.to respond_to :object_buffer_length }
+  it { is_expected.to respond_to :filler }
+
+  context 'with #object_buffer_length' do
+    it 'is a BinData::Uint32le' do
+      expect(subject.object_buffer_length).to be_a BinData::Uint32le
+    end
+    it 'calls its parent\'s #field_length method to set its default value' do
+      test_struct = Class.new(BinData::Record) do
+        endian :little
+        type_serialization1_private_header :header
+
+        def field_length(obj);end
+      end.new
+      expect(test_struct).to receive(:field_length).and_return(4)
+      expect(test_struct.header.object_buffer_length).to eq(4)
+    end
+    it 'sets the default value to 0 when its parent doesn\'t implemet #field_length' do
+      expect(subject.object_buffer_length).to eq(0)
+    end
+  end
+
+  context 'with #filler' do
+    it 'is a BinData::Uint32le' do
+      expect(subject.filler).to be_a BinData::Uint32le
+    end
+    it 'returns 0x00000000 by default' do
+      expect(subject.filler).to eq(0x00000000)
+    end
+  end
+
+  it 'reads itself' do
+    values = {object_buffer_length: 4, filler: 0xFFFFFFFF}
+    struct_instance = described_class.new(values)
+    expect(described_class.read(struct_instance.to_binary_s)).to eq(values)
+  end
+end
+
+RSpec.describe RubySMB::Dcerpc::Ndr::TypeSerialization1 do
+  it 'is a BinData::Record class' do
+    expect(described_class).to be < BinData::Record
+  end
+  it 'has :byte_align parameter set to the expected value' do
+    expect(described_class.default_parameters[:byte_align]).to eq(8)
+  end
+
+  subject { described_class.new }
+
+  it { is_expected.to respond_to :common_header }
+
+  context 'with #common_header' do
+    it 'is a TypeSerialization1CommonTypeHeader structure' do
+      expect(subject.common_header).to be_a RubySMB::Dcerpc::Ndr::TypeSerialization1CommonTypeHeader
+    end
+  end
+
+  it 'reads itself' do
+    values = {
+      common_header: {version: 4, endianness: 0x33, common_header_length: 44, filler: 0xFFFFFFFF}
+    }
+    struct_instance = described_class.new(values)
+    expect(described_class.read(struct_instance.to_binary_s)).to eq(values)
+  end
+
+  context 'when inherited' do
+    let(:test_struct) do
+      Class.new(RubySMB::Dcerpc::Ndr::NdrStruct) do
+        default_parameters byte_align: 8
+        endian :little
+
+        rpc_unicode_string :full_name
+        ndr_uint32 :user_id
+      end
+    end
+    before :example do
+      BinData::RegisteredClasses.register('test_struct', test_struct)
+    end
+    after :example do
+      BinData::RegisteredClasses.unregister('test_struct')
+    end
+
+    subject do
+      Class.new(described_class) do
+        default_parameter byte_align: 8
+        endian :little
+
+        test_struct :data1
+        uint32 :value1, initial_value: 5
+        uint32 :value2, initial_value: 6
+        test_struct :data2
+        uint32 :value3, initial_value: 7
+        test_struct :data3
+      end.new
+    end
+
+    it { is_expected.to respond_to :common_header }
+    it { is_expected.to respond_to :private_header1 }
+    it { is_expected.to respond_to :data1 }
+    it { is_expected.to respond_to :value1 }
+    it { is_expected.to respond_to :value2 }
+    it { is_expected.to respond_to :private_header2 }
+    it { is_expected.to respond_to :data2 }
+    it { is_expected.to respond_to :value3 }
+    it { is_expected.to respond_to :private_header3 }
+    it { is_expected.to respond_to :data3 }
+
+    it 'sets the expected default values' do
+      data_obj = test_struct.new
+      expect(subject.data1).to eq(data_obj)
+      expect(subject.value1).to eq(5)
+      expect(subject.value2).to eq(6)
+      expect(subject.data2).to eq(data_obj)
+      expect(subject.value3).to eq(7)
+      expect(subject.data3).to eq(data_obj)
+    end
+
+    it 'sets the correct private header\'s object_buffer_length field value' do
+      data1 = test_struct.new(full_name: 'test string')
+      subject.data1 = data1
+      expect(subject.private_header1.object_buffer_length).to eq(data1.num_bytes)
+      data2 = test_struct.new(full_name: 'another test string')
+      subject.data2 = data2
+      expect(subject.private_header2.object_buffer_length).to eq(data2.num_bytes)
+      data3 = test_struct.new(full_name: 'more string!!!')
+      subject.data3 = data3
+      expect(subject.private_header3.object_buffer_length).to eq(data3.num_bytes)
+    end
+  end
+end

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

@@ -134,12 +134,6 @@ RSpec.describe RubySMB::Dcerpc::Request do
       packet.pdu_header.auth_length = 10
       expect(packet.auth_pad?).to be true
     end
-
-    it 'makes sure #sec_trailer is 16-bytes aligned with the begining of the PDU body (stub)' do
-      packet.pdu_header.auth_length = 6
-      packet.stub = 'A' * rand(0xFF)
-      expect((packet.sec_trailer.abs_offset - packet.stub.abs_offset) % 16).to eq(0)
-    end
   end
 
   describe '#sec_trailer' do