ruby_smb 3.0.0 → 3.0.4

data/spec/lib/ruby_smb/dcerpc/print_system/driver_info2_spec.rb

@@ -0,0 +1,64 @@
+RSpec.describe RubySMB::Dcerpc::PrintSystem::DriverInfo2 do
+  subject(:struct) { described_class.new }
+
+  it { is_expected.to respond_to :c_version }
+  it { is_expected.to respond_to :p_name }
+  it { is_expected.to respond_to :p_environment }
+  it { is_expected.to respond_to :p_driver_path }
+  it { is_expected.to respond_to :p_data_file }
+  it { is_expected.to respond_to :p_config_file }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#c_version' do
+    it 'is a NdrUint32' do
+      expect(struct.c_version).to be_a RubySMB::Dcerpc::Ndr::NdrUint32
+    end
+  end
+
+  describe '#p_name' do
+    it 'is a NdrWideStringzPtr' do
+      expect(struct.p_name).to be_a RubySMB::Dcerpc::Ndr::NdrWideStringzPtr
+    end
+  end
+
+  describe '#p_environment' do
+    it 'is a NdrWideStringzPtr' do
+      expect(struct.p_environment).to be_a RubySMB::Dcerpc::Ndr::NdrWideStringzPtr
+    end
+  end
+
+  describe '#p_driver_path' do
+    it 'is a NdrWideStringzPtr' do
+      expect(struct.p_driver_path).to be_a RubySMB::Dcerpc::Ndr::NdrWideStringzPtr
+    end
+  end
+
+  describe '#p_data_file' do
+    it 'is a NdrWideStringzPtr' do
+      expect(struct.p_data_file).to be_a RubySMB::Dcerpc::Ndr::NdrWideStringzPtr
+    end
+  end
+
+  describe '#p_config_file' do
+    it 'is a NdrWideStringzPtr' do
+      expect(struct.p_config_file).to be_a RubySMB::Dcerpc::Ndr::NdrWideStringzPtr
+    end
+  end
+
+  it 'reads its own binary representation and outputs the same struct' do
+    struct = described_class.new(
+      c_version: 0,
+      p_name: 'p_name',
+      p_environment: 'p_environment',
+      p_driver_path: 'p_driver_path',
+      p_data_file: 'p_data_file',
+      p_config_file: 'p_config_file'
+    )
+    binary = struct.to_binary_s
+    expect(described_class.read(binary)).to eq(struct)
+  end
+end
+

data/spec/lib/ruby_smb/dcerpc/print_system/rpc_add_printer_driver_ex_request_spec.rb

@@ -0,0 +1,59 @@
+RSpec.describe RubySMB::Dcerpc::PrintSystem::RpcAddPrinterDriverExRequest do
+  subject(:packet) { described_class.new }
+
+  it { is_expected.to respond_to :p_name }
+  it { is_expected.to respond_to :p_driver_container }
+  it { is_expected.to respond_to :dw_file_copy_flags }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#p_name' do
+    it 'is a NdrWideStringzPtr' do
+      expect(packet.p_name).to be_a RubySMB::Dcerpc::Ndr::NdrWideStringzPtr
+    end
+  end
+
+  describe '#p_driver_container' do
+    it 'is a DriverContainer structure' do
+      expect(packet.p_driver_container).to be_a RubySMB::Dcerpc::PrintSystem::DriverContainer
+    end
+  end
+
+  describe '#dw_file_copy_flags' do
+    it 'is a NdrUint32' do
+      expect(packet.dw_file_copy_flags).to be_a RubySMB::Dcerpc::Ndr::NdrUint32
+    end
+  end
+
+  describe '#initialize_instance' do
+    it 'sets #opnum to RPC_ADD_PRINTER_DRIVER_EX constant' do
+      expect(packet.opnum).to eq(RubySMB::Dcerpc::PrintSystem::RPC_ADD_PRINTER_DRIVER_EX)
+    end
+  end
+
+  it 'reads its own binary representation and outputs the same packet' do
+    packet = described_class.new(
+      p_name: 'p_name',
+      p_driver_container: RubySMB::Dcerpc::PrintSystem::DriverContainer.new(
+        RubySMB::Dcerpc::PrintSystem::DriverContainer.new(
+          level: 2,
+          tag: 2,
+          driver_info: RubySMB::Dcerpc::PrintSystem::DriverInfo2.new(
+            c_version: 0,
+            p_name: 'p_name',
+            p_environment: 'p_environment',
+            p_driver_path: 'p_driver_path',
+            p_data_file: 'p_data_file',
+            p_config_file: 'p_config_file'
+          )
+        )
+      ),
+      dw_file_copy_flags: 0
+    )
+    binary = packet.to_binary_s
+    expect(described_class.read(binary)).to eq(packet)
+  end
+end
+

data/spec/lib/ruby_smb/dcerpc/print_system/rpc_add_printer_driver_ex_response_spec.rb

@@ -0,0 +1,30 @@
+RSpec.describe RubySMB::Dcerpc::PrintSystem::RpcAddPrinterDriverExResponse do
+  subject(:packet) { described_class.new }
+
+  it { is_expected.to respond_to :error_status }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#error_status' do
+    it 'is a NdrUint32' do
+      expect(packet.error_status).to be_a RubySMB::Dcerpc::Ndr::NdrUint32
+    end
+  end
+
+  describe '#initialize_instance' do
+    it 'sets #opnum to RPC_ADD_PRINTER_DRIVER_EX constant' do
+      expect(packet.opnum).to eq(RubySMB::Dcerpc::PrintSystem::RPC_ADD_PRINTER_DRIVER_EX)
+    end
+  end
+
+  it 'reads its own binary representation and outputs the same packet' do
+    packet = described_class.new(
+      error_status: 0
+    )
+    binary = packet.to_binary_s
+    expect(described_class.read(binary)).to eq(packet)
+  end
+end
+

data/spec/lib/ruby_smb/dcerpc/print_system/rpc_enum_printer_drivers_request_spec.rb

@@ -0,0 +1,62 @@
+RSpec.describe RubySMB::Dcerpc::PrintSystem::RpcEnumPrinterDriversRequest do
+  subject(:packet) { described_class.new }
+
+  it { is_expected.to respond_to :p_name }
+  it { is_expected.to respond_to :p_environment }
+  it { is_expected.to respond_to :level }
+  it { is_expected.to respond_to :p_drivers }
+  it { is_expected.to respond_to :cb_buf }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#p_name' do
+    it 'is a NdrWideStringzPtr' do
+      expect(packet.p_name).to be_a RubySMB::Dcerpc::Ndr::NdrWideStringzPtr
+    end
+  end
+
+  describe '#p_environment' do
+    it 'is a NdrWideStringzPtr' do
+      expect(packet.p_environment).to be_a RubySMB::Dcerpc::Ndr::NdrWideStringzPtr
+    end
+  end
+
+  describe '#level' do
+    it 'is a NdrUint32' do
+      expect(packet.level).to be_a RubySMB::Dcerpc::Ndr::NdrUint32
+    end
+  end
+
+  describe '#p_drivers' do
+    it 'is a RprnByteArrayPtr' do
+      expect(packet.p_drivers).to be_a RubySMB::Dcerpc::PrintSystem::RprnByteArrayPtr
+    end
+  end
+
+  describe '#cb_buf' do
+    it 'is a NdrUint32' do
+      expect(packet.cb_buf).to be_a RubySMB::Dcerpc::Ndr::NdrUint32
+    end
+  end
+
+  describe '#initialize_instance' do
+    it 'sets #opnum to RPC_ENUM_PRINTER_DRIVERS constant' do
+      expect(packet.opnum).to eq(RubySMB::Dcerpc::PrintSystem::RPC_ENUM_PRINTER_DRIVERS)
+    end
+  end
+
+  it 'reads its own binary representation and outputs the same packet' do
+    packet = described_class.new(
+      p_name: 'p_name',
+      p_environment: 'p_environment',
+      level: 0,
+      p_drivers: [0, 1, 2],
+      cb_buf: 0
+    )
+    binary = packet.to_binary_s
+    expect(described_class.read(binary)).to eq(packet)
+  end
+end
+

data/spec/lib/ruby_smb/dcerpc/print_system/rpc_enum_printer_drivers_response_spec.rb

@@ -0,0 +1,54 @@
+RSpec.describe RubySMB::Dcerpc::PrintSystem::RpcEnumPrinterDriversResponse do
+  subject(:packet) { described_class.new }
+
+  it { is_expected.to respond_to :p_drivers }
+  it { is_expected.to respond_to :pcb_needed }
+  it { is_expected.to respond_to :pc_returned }
+  it { is_expected.to respond_to :error_status }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#p_drivers' do
+    it 'is a RprnByteArrayPtr' do
+      expect(packet.p_drivers).to be_a RubySMB::Dcerpc::PrintSystem::RprnByteArrayPtr
+    end
+  end
+
+  describe '#pcb_needed' do
+    it 'is a NdrUint32' do
+      expect(packet.pcb_needed).to be_a RubySMB::Dcerpc::Ndr::NdrUint32
+    end
+  end
+
+  describe '#pc_returned' do
+    it 'is a NdrUint32' do
+      expect(packet.pc_returned).to be_a RubySMB::Dcerpc::Ndr::NdrUint32
+    end
+  end
+
+  describe '#error_status' do
+    it 'is a NdrUint32' do
+      expect(packet.error_status).to be_a RubySMB::Dcerpc::Ndr::NdrUint32
+    end
+  end
+
+  describe '#initialize_instance' do
+    it 'sets #opnum to RPC_ENUM_PRINTER_DRIVERS constant' do
+      expect(packet.opnum).to eq(RubySMB::Dcerpc::PrintSystem::RPC_ENUM_PRINTER_DRIVERS)
+    end
+  end
+
+  it 'reads its own binary representation and outputs the same packet' do
+    packet = described_class.new(
+      p_drivers: [0, 1, 2],
+      pcb_needed: 0,
+      pc_returned: 0,
+      error_status: 0
+    )
+    binary = packet.to_binary_s
+    expect(described_class.read(binary)).to eq(packet)
+  end
+end
+

data/spec/lib/ruby_smb/dcerpc/print_system/rpc_get_printer_driver_directory_request_spec.rb

@@ -0,0 +1,62 @@
+RSpec.describe RubySMB::Dcerpc::PrintSystem::RpcGetPrinterDriverDirectoryRequest do
+  subject(:packet) { described_class.new }
+
+  it { is_expected.to respond_to :p_name }
+  it { is_expected.to respond_to :p_environment }
+  it { is_expected.to respond_to :level}
+  it { is_expected.to respond_to :p_driver_directory }
+  it { is_expected.to respond_to :cb_buf }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#p_name' do
+    it 'is a NdrWideStringzPtr' do
+      expect(packet.p_name).to be_a RubySMB::Dcerpc::Ndr::NdrWideStringzPtr
+    end
+  end
+
+  describe '#p_environment' do
+    it 'is a NdrWideStringzPtr' do
+      expect(packet.p_environment).to be_a RubySMB::Dcerpc::Ndr::NdrWideStringzPtr
+    end
+  end
+
+  describe '#level' do
+    it 'is a NdrUint32' do
+      expect(packet.level).to be_a RubySMB::Dcerpc::Ndr::NdrUint32
+    end
+  end
+
+  describe '#p_driver_directory' do
+    it 'is a RprnByteArrayPtr' do
+      expect(packet.p_driver_directory).to be_a RubySMB::Dcerpc::PrintSystem::RprnByteArrayPtr
+    end
+  end
+
+  describe '#cb_buf' do
+    it 'is a NdrUint32' do
+      expect(packet.cb_buf).to be_a RubySMB::Dcerpc::Ndr::NdrUint32
+    end
+  end
+
+  describe '#initialize_instance' do
+    it 'sets #opnum to RPC_GET_PRINTER_DRIVER_DIRECTORY constant' do
+      expect(packet.opnum).to eq(RubySMB::Dcerpc::PrintSystem::RPC_GET_PRINTER_DRIVER_DIRECTORY)
+    end
+  end
+
+  it 'reads its own binary representation and outputs the same packet' do
+    packet = described_class.new(
+      p_name: 'p_name',
+      p_environment: 'p_environment',
+      level: 0,
+      p_driver_directory: [0, 1, 2],
+      cb_buf: 0
+    )
+    binary = packet.to_binary_s
+    expect(described_class.read(binary)).to eq(packet)
+  end
+end
+

data/spec/lib/ruby_smb/dcerpc/print_system/rpc_get_printer_driver_directory_response_spec.rb

@@ -0,0 +1,46 @@
+RSpec.describe RubySMB::Dcerpc::PrintSystem::RpcGetPrinterDriverDirectoryResponse do
+  subject(:packet) { described_class.new }
+
+  it { is_expected.to respond_to :p_driver_directory }
+  it { is_expected.to respond_to :pcb_needed }
+  it { is_expected.to respond_to :error_status }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#p_driver_directory' do
+    it 'is a RprnByteArrayPtr' do
+      expect(packet.p_driver_directory).to be_a RubySMB::Dcerpc::PrintSystem::RprnByteArrayPtr
+    end
+  end
+
+  describe '#pcb_needed' do
+    it 'is a NdrUint32' do
+      expect(packet.pcb_needed).to be_a RubySMB::Dcerpc::Ndr::NdrUint32
+    end
+  end
+
+  describe '#error_status' do
+    it 'is a NdrUint32' do
+      expect(packet.error_status).to be_a RubySMB::Dcerpc::Ndr::NdrUint32
+    end
+  end
+
+  describe '#initialize_instance' do
+    it 'sets #opnum to RPC_GET_PRINTER_DRIVER_DIRECTORY constant' do
+      expect(packet.opnum).to eq(RubySMB::Dcerpc::PrintSystem::RPC_GET_PRINTER_DRIVER_DIRECTORY)
+    end
+  end
+
+  it 'reads its own binary representation and outputs the same packet' do
+    packet = described_class.new(
+      p_driver_directory: [0, 1, 2],
+      pcb_needed: 0,
+      error_status: 0
+    )
+    binary = packet.to_binary_s
+    expect(described_class.read(binary)).to eq(packet)
+  end
+end
+

data/spec/lib/ruby_smb/field/nt_status_spec.rb

@@ -3,8 +3,12 @@ RSpec.describe RubySMB::Field::NtStatus do
 
   it { is_expected.to respond_to :to_nt_status }
 
-  it 'is a Unsigned 32-bit little endian integer' do
-    expect(nt_status).to be_a BinData::Uint32le
+  it 'uses an internal Unsigned 32-bit little endian integer' do
+    expect(nt_status.val).to be_a BinData::Uint32le
+  end
+
+  it 'returns an integer value' do
+    expect(nt_status.value).to be_a Integer
   end
 
   describe '#to_nt_status' do

data/spec/lib/ruby_smb/gss/provider/ntlm/authenticator_spec.rb

@@ -13,6 +13,10 @@ RSpec.describe RubySMB::Gss::Provider::NTLM::Authenticator do
     Net::NTLM::Message::Type2.new.response(user: username, password: '', domain: domain)
   end
 
+  before(:each) do
+    allow(authenticator).to receive(:logger).and_return(Logger.new(IO::NULL))
+  end
+
   describe '#initialize' do
     it 'defaults to a null session key' do
       expect(authenticator.session_key).to be_nil

data/spec/lib/ruby_smb/server/server_client_spec.rb

@@ -5,33 +5,24 @@ RSpec.describe RubySMB::Server::ServerClient do
   subject(:server_client) { described_class.new(server, dispatcher) }
 
   it { is_expected.to respond_to :dialect }
-  it { is_expected.to respond_to :identity }
-  it { is_expected.to respond_to :state }
-  it { is_expected.to respond_to :session_key }
+  it { is_expected.to respond_to :session_table }
 
   describe '#disconnect!' do
     it 'closes the socket' do
+      expect(dispatcher.tcp_socket).to receive(:closed?).with(no_args).and_return(false)
       expect(dispatcher.tcp_socket).to receive(:close).with(no_args).and_return(nil)
       server_client.disconnect!
     end
   end
 
   describe '#initialize' do
-    it 'starts in the negotiate state' do
-      expect(server_client.state).to eq :negotiate
-    end
-
     it 'starts without a dialect' do
       expect(server_client.dialect).to be_nil
       expect(server_client.metadialect).to be_nil
     end
 
-    it 'starts without an identity' do
-      expect(server_client.identity).to be_nil
-    end
-
-    it 'starts without a session_key' do
-      expect(server_client.session_key).to be_nil
+    it 'starts without any sessions' do
+      expect(server_client.session_table).to be_empty
     end
 
     it 'creates a new authenticator instance' do
@@ -66,33 +57,30 @@ RSpec.describe RubySMB::Server::ServerClient do
     before(:each) do
       expect(server_client).to receive(:recv_packet).and_return(packet)
       # this hook should ensure that the dispatcher loop returns after processing a single request
-      expect(dispatcher.tcp_socket).to receive(:closed?).and_return(true)
+      expect(dispatcher.tcp_socket).to receive(:closed?).with(no_args).and_return(true)
+      expect(server_client).to receive(:disconnect!).with(no_args).and_return(nil)
     end
 
-    it 'calls #handle_negotiate when the state is negotiate' do
+    it 'calls #handle_negotiate when the dialect is nil' do
       expect(server_client).to receive(:handle_negotiate).with(packet).and_return(nil)
-      server_client.instance_eval { @state = :negotiate }
-      server_client.run
-    end
-
-    it 'calls #handle_session_setup when the state is session_setup' do
-      expect(server_client).to receive(:handle_session_setup).with(packet).and_return(nil)
-      server_client.instance_eval { @state = :session_setup }
+      server_client.instance_eval { @dialect = nil }
       server_client.run
     end
 
-    it 'calls #authenticated when the state is authenticated' do
-      expect(server_client).to receive(:handle_authenticated).with(packet).and_return(nil)
-      server_client.instance_eval { @state = :authenticated }
+    it 'calls #handle_smb when the dialect is not nil' do
+      expect(server_client).to receive(:handle_smb).with(packet).and_return(nil)
+      server_client.instance_eval { @dialect = true }
       server_client.run
     end
   end
 
   describe '#send_packet' do
-    let(:packet) { RubySMB::GenericPacket.new }
+    let(:session_id) { rand(0xffffffff) }
+    let(:packet) { RubySMB::SMB2::Packet::SessionSetupResponse.new(smb2_header: { session_id: session_id }) }
 
     before(:each) do
       expect(dispatcher).to receive(:send_packet).with(packet).and_return(nil)
+      server_client.session_table[session_id] = RubySMB::Server::Session.new(session_id)
     end
 
     it 'sends a packet to the dispatcher' do
@@ -105,40 +93,35 @@ RSpec.describe RubySMB::Server::ServerClient do
           server_client.instance_eval { @dialect = dialect }
         end
 
-        context 'and the state is authenticated' do
+        context 'and the identity is anonymous' do
           before(:each) do
-            server_client.instance_eval { @state = :authenticated }
+            server_client.session_table[session_id].user_id = RubySMB::Gss::Provider::IDENTITY_ANONYMOUS
           end
 
-          context 'and the identity is anonymous' do
-            before(:each) do
-              server_client.instance_eval { @identity = RubySMB::Gss::Provider::IDENTITY_ANONYMOUS }
-            end
-
-            it 'does not sign packets' do
-              expect(server_client).to_not receive(:smb2_sign)
-              expect(server_client).to_not receive(:smb3_sign)
-              server_client.send_packet(packet)
-            end
+          it 'does not sign packets' do
+            expect(RubySMB::Signing).to_not receive(:smb2_sign)
+            expect(RubySMB::Signing).to_not receive(:smb3_sign)
+            server_client.send_packet(packet)
           end
+        end
 
-          context 'and the identity is not anonymous' do
-            before(:each) do
-              server_client.instance_eval { @identity = 'WORKGROUP\RubySMB'; @session_key = Random.new.bytes(16) }
-            end
+        context 'and the identity is not anonymous' do
+          before(:each) do
+            server_client.session_table[session_id].user_id = 'WORKGROUP\RubySMB'
+            server_client.session_table[session_id].key = Random.new.bytes(16)
+          end
 
-            it 'does sign packets' do
-              packet = RubySMB::GenericPacket.new
-              dialect_family = RubySMB::Dialect[dialect].family
-              if dialect_family == RubySMB::Dialect::FAMILY_SMB2
-                expect(server_client).to receive(:smb2_sign).with(packet).and_return(packet)
-                expect(server_client).to_not receive(:smb3_sign)
-              elsif dialect_family == RubySMB::Dialect::FAMILY_SMB3
-                expect(server_client).to receive(:smb3_sign).with(packet).and_return(packet)
-                expect(server_client).to_not receive(:smb2_sign)
-              end
-              server_client.send_packet(packet)
+          it 'does sign packets' do
+            dialect_family = RubySMB::Dialect[dialect].family
+            session = server_client.session_table[session_id]
+            if dialect_family == RubySMB::Dialect::FAMILY_SMB2
+              expect(RubySMB::Signing).to receive(:smb2_sign).with(packet, session.key).and_return(packet)
+              expect(RubySMB::Signing).to_not receive(:smb3_sign)
+            elsif dialect_family == RubySMB::Dialect::FAMILY_SMB3
+              expect(RubySMB::Signing).to receive(:smb3_sign).with(packet, session.key, dialect, any_args).and_return(packet)
+              expect(RubySMB::Signing).to_not receive(:smb2_sign)
             end
+            server_client.send_packet(packet)
           end
         end
       end

data/spec/lib/ruby_smb/server/session_spec.rb

@@ -0,0 +1,38 @@
+RSpec.describe RubySMB::Server::Session do
+  let(:user_id) { 'WORKGROUP\RubySMB' }
+  subject(:session) { described_class.new(rand(0xffffffff), user_id: user_id) }
+
+  it { is_expected.to respond_to :id }
+  it { is_expected.to respond_to :key }
+  it { is_expected.to respond_to :signing_required }
+  it { is_expected.to respond_to :tree_connect_table }
+  it { is_expected.to respond_to :creation_time }
+
+  describe '#initialize' do
+    it 'starts with no signing required' do
+      expect(session.signing_required).to be_falsey
+    end
+
+    it 'starts with no tree connections' do
+      expect(session.tree_connect_table).to be_empty
+    end
+
+    it 'starts in the in progress state' do
+      expect(session.state).to be :in_progress
+    end
+  end
+
+  describe '#is_anonymous' do
+    it 'is false' do
+      expect(session.is_anonymous).to be_falsey
+    end
+
+    context 'when the identity is set to anonymous' do
+      let(:user_id) { RubySMB::Gss::Provider::IDENTITY_ANONYMOUS }
+
+      it 'is true' do
+        expect(session.is_anonymous).to be_truthy
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+RSpec.describe RubySMB::Server::Share::Provider::Disk do
+  let(:name) { 'share' }
+  let(:path) { Dir.getwd }
+  subject(:share_provider) { described_class.new(name, path) }
+
+  it { is_expected.to respond_to :name }
+  it { is_expected.to respond_to :path }
+  it { is_expected.to respond_to :type }
+
+  describe '#TYPE' do
+    it 'is TYPE_DISK' do
+      expect(described_class::TYPE).to eq RubySMB::Server::Share::TYPE_DISK
+    end
+  end
+
+  describe '#initialize' do
+    it 'sets the name' do
+      expect(share_provider.name).to eq name
+    end
+
+    it 'sets the path' do
+      expect(share_provider.path).to be_a Pathname
+      expect(share_provider.path).to eq Pathname.new(path)
+    end
+
+    it 'sets the type correctly' do
+      expect(share_provider.type).to eq RubySMB::Server::Share::TYPE_DISK
+    end
+
+    it 'raises an ArgumentError for an invalid path' do
+      # __FILE__ is not a directory so it's invalid
+      expect { described_class.new(name, __FILE__) }.to raise_error(ArgumentError)
+    end
+  end
+end
+
+RSpec.describe RubySMB::Server::Share::Provider::Disk::Processor do
+  let(:session) { RubySMB::Server::Session.new(rand(0xffffffff)) }
+  let(:share_provider) { RubySMB::Server::Share::Provider::Disk.new('share', Dir.getwd) }
+  subject(:share_processor) { described_class.new(share_provider, nil, session) }
+
+  it { is_expected.to respond_to :provider }
+
+  describe '#maximal_access' do
+    # no path specified should be the root of the share
+    context 'with no path specified' do
+      let(:maximal_access) { share_processor.maximal_access }
+      it 'is a FileAccessMask' do
+        expect(maximal_access).to be_a RubySMB::SMB2::BitField::FileAccessMask
+      end
+
+      it 'marks the data as readable' do
+        expect(maximal_access.read_data).to eq 1
+      end
+
+      it 'marks the data attributes as readable' do
+        expect(maximal_access.read_attr).to eq 1
+      end
+    end
+  end
+end