ruby_smb 2.0.12 → 3.0.2

data/spec/lib/ruby_smb/dcerpc/winreg/query_value_response_spec.rb

@@ -3,7 +3,6 @@ RSpec.describe RubySMB::Dcerpc::Winreg::QueryValueResponse do
 
   it { is_expected.to respond_to :lp_type }
   it { is_expected.to respond_to :lp_data }
-  it { is_expected.to respond_to :pad }
   it { is_expected.to respond_to :lpcb_data }
   it { is_expected.to respond_to :lpcb_len }
   it { is_expected.to respond_to :error_status }
@@ -14,43 +13,32 @@ RSpec.describe RubySMB::Dcerpc::Winreg::QueryValueResponse do
   end
 
   describe '#lp_type' do
-    it 'is a NdrLpDword structure' do
-      expect(packet.lp_type).to be_a RubySMB::Dcerpc::Ndr::NdrLpDword
+    it 'is a Ndr::NdrUint32Ptr structure' do
+      expect(packet.lp_type).to be_a RubySMB::Dcerpc::Ndr::NdrUint32Ptr
     end
   end
 
   describe '#lp_data' do
-    it 'is a NdrLpByteArray structure' do
-      expect(packet.lp_data).to be_a RubySMB::Dcerpc::Ndr::NdrLpByteArray
-    end
-  end
-
-  describe '#pad' do
-    it 'is a string' do
-      expect(packet.pad).to be_a BinData::String
-    end
-
-    it 'should keep #lpcb_data 4-byte aligned' do
-      packet.lp_data = 'spec_test'.bytes
-      expect(packet.lpcb_data.abs_offset % 4).to eq 0
+    it 'is a NdrNdrByteArrayPtr structure' do
+      expect(packet.lp_data).to be_a RubySMB::Dcerpc::Ndr::NdrByteArrayPtr
     end
   end
 
   describe '#lpcb_data' do
-    it 'is a NdrLpDword structure' do
-      expect(packet.lpcb_data).to be_a RubySMB::Dcerpc::Ndr::NdrLpDword
+    it 'is a Ndr::NdrUint32Ptr structure' do
+      expect(packet.lpcb_data).to be_a RubySMB::Dcerpc::Ndr::NdrUint32Ptr
     end
   end
 
   describe '#lpcb_len' do
-    it 'is a NdrLpDword structure' do
-      expect(packet.lpcb_len).to be_a RubySMB::Dcerpc::Ndr::NdrLpDword
+    it 'is a Ndr::NdrUint32Ptr structure' do
+      expect(packet.lpcb_len).to be_a RubySMB::Dcerpc::Ndr::NdrUint32Ptr
     end
   end
 
   describe '#error_status' do
-    it 'is a 32-bit unsigned integer' do
-      expect(packet.error_status).to be_a BinData::Uint32le
+    it 'is a NdrUint32' do
+      expect(packet.error_status).to be_a RubySMB::Dcerpc::Ndr::NdrUint32
     end
   end
 

data/spec/lib/ruby_smb/dcerpc/winreg/regsam_spec.rb

@@ -29,4 +29,8 @@ RSpec.describe RubySMB::Dcerpc::Winreg::Regsam do
   it 'is little endian' do
     expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
   end
+
+  it 'it is a Ndr::NdrStruct' do
+    expect(described_class).to be < RubySMB::Dcerpc::Ndr::NdrStruct
+  end
 end

data/spec/lib/ruby_smb/dcerpc/winreg/save_key_request_spec.rb

@@ -16,7 +16,6 @@ RSpec.describe RubySMB::Dcerpc::Winreg::SaveKeyRequest do
 
   it { is_expected.to respond_to :hkey }
   it { is_expected.to respond_to :lp_file }
-  it { is_expected.to respond_to :pad }
   it { is_expected.to respond_to :lp_security_attributes }
 
   describe '#hkey' do
@@ -31,17 +30,6 @@ RSpec.describe RubySMB::Dcerpc::Winreg::SaveKeyRequest do
     end
   end
 
-  describe '#pad' do
-    it 'is a string' do
-      expect(packet.pad).to be_a BinData::String
-    end
-
-    it 'should keep #lp_security_attributes 4-byte aligned' do
-      packet.lp_file = "test"
-      expect(packet.lp_security_attributes.abs_offset % 4).to eq 0
-    end
-  end
-
   describe '#lp_security_attributes' do
     it 'is a PrpcSecurityAttributes structure' do
       expect(packet.lp_security_attributes).to be_a RubySMB::Dcerpc::PrpcSecurityAttributes

data/spec/lib/ruby_smb/dcerpc/winreg/save_key_response_spec.rb

@@ -8,8 +8,8 @@ RSpec.describe RubySMB::Dcerpc::Winreg::SaveKeyResponse do
   end
 
   describe '#error_status' do
-    it 'is a 32-bit unsigned integer' do
-      expect(packet.error_status).to be_a BinData::Uint32le
+    it 'is a NdrUint32' do
+      expect(packet.error_status).to be_a RubySMB::Dcerpc::Ndr::NdrUint32
     end
   end
 

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

@@ -133,16 +133,14 @@ RSpec.describe RubySMB::Dcerpc::Winreg do
     let(:handle)                      { double('Handle') }
     let(:value_name)                  { double('Value Name') }
     let(:query_value_request_packet) { double('Query Value Request Packet #1') }
-    let(:lp_data1)                    { double('LpData #1') }
-    let(:lp_data2)                    { double('LpData #2') }
+    let(:lp_data)                    { double('LpData #2') }
     let(:response1)                   { double('Response #1') }
     let(:response2)                   { double('Response #2') }
     let(:query_value_response1)       { double('Query Value Response #1') }
     let(:query_value_response2)       { double('Query Value Response #2') }
     let(:data)                        { double('Data') }
     let(:lpcb_data)                   { double('LpcbData') }
-    let(:lpcb_data_referent)          { double('LpcbData Referent') }
-    let(:lp_data2_referent)           { double('LpData Referent') }
+    let(:max_count)                   { 5 }
     before :example do
       allow(described_class::QueryValueRequest).to receive(:new).and_return(query_value_request_packet)
       allow(query_value_request_packet).to receive_messages(
@@ -150,10 +148,9 @@ RSpec.describe RubySMB::Dcerpc::Winreg do
         :lpcb_data= => nil,
         :lpcb_len=  => nil,
         :lp_data=   => nil,
-        :lp_data    => lp_data2,
+        :lp_data    => lp_data,
       )
-      allow(lp_data2).to receive(:referent).and_return(lp_data2_referent)
-      allow(lp_data2_referent).to receive(:max_count=)
+      allow(lp_data).to receive(:max_count=)
       first_request = true
       allow(winreg).to receive(:dcerpc_request) do |arg|
         if first_request
@@ -171,7 +168,7 @@ RSpec.describe RubySMB::Dcerpc::Winreg do
         :data         => data
       )
       allow(query_value_response1).to receive(:lpcb_data).and_return(lpcb_data)
-      allow(lpcb_data).to receive(:referent).and_return(lpcb_data_referent)
+      allow(lpcb_data).to receive(:to_i).and_return(max_count)
     end
 
     it 'create the expected QueryValueRequest packets' do
@@ -186,7 +183,7 @@ RSpec.describe RubySMB::Dcerpc::Winreg do
       expect(query_value_request_packet).to have_received(:lpcb_len=).with(0)
       expect(query_value_request_packet).to have_received(:lpcb_data=).with(lpcb_data)
       expect(query_value_request_packet).to have_received(:lp_data=).with([])
-      expect(lp_data2_referent).to have_received(:max_count=).with(lpcb_data_referent)
+      expect(lp_data).to have_received(:max_count=).with(max_count)
     end
 
     it 'sends the expected dcerpc requests' do
@@ -293,19 +290,13 @@ RSpec.describe RubySMB::Dcerpc::Winreg do
     let(:response)                      { double('Response') }
     let(:query_info_key_response)       { double('CloseKey Response') }
     let(:lp_class)                      { double('LpClass') }
-    let(:lp_class_referent)             { double('LpClass referent') }
-    let(:lp_class_buf_ref)              { double('LpClass buffer referent') }
     before :example do
       allow(described_class::QueryInfoKeyRequest).to receive(:new).and_return(query_info_key_request_packet)
       allow(query_info_key_request_packet).to receive_messages(
         :lp_class= => nil,
         :lp_class  => lp_class,
       )
-      allow(lp_class).to receive(:referent).and_return(lp_class_referent)
-      allow(lp_class_referent).to receive(:actual_count=)
-      allow(lp_class).to receive(:maximum_length=)
-      allow(lp_class).to receive_message_chain(:buffer, :referent => lp_class_buf_ref)
-      allow(lp_class_buf_ref).to receive(:max_count=)
+      allow(lp_class).to receive(:set_max_buffer_size)
       allow(winreg).to receive(:dcerpc_request).and_return(response)
       allow(described_class::QueryInfoKeyResponse).to receive(:read).and_return(query_info_key_response)
       allow(query_info_key_response).to receive(:error_status).and_return(WindowsError::Win32::ERROR_SUCCESS)
@@ -323,10 +314,7 @@ RSpec.describe RubySMB::Dcerpc::Winreg do
 
     it 'sets the expected fields on the request packet' do
       winreg.query_info_key(handle)
-      expect(query_info_key_request_packet).to have_received(:lp_class=).with('')
-      expect(lp_class_referent).to have_received(:actual_count=).with(0)
-      expect(lp_class).to have_received(:maximum_length=).with(1024)
-      expect(lp_class_buf_ref).to have_received(:max_count=).with(1024 / 2)
+      expect(lp_class).to have_received(:set_max_buffer_size).with(RubySMB::Dcerpc::Winreg::BUFFER_SIZE)
     end
 
     it 'creates a QueryInfoKeyResponse structure from the expected dcerpc response' do
@@ -358,31 +346,22 @@ RSpec.describe RubySMB::Dcerpc::Winreg do
     let(:index)                    { double('Index') }
     let(:enum_key_request_packet)  { double('enum_key Request Packet') }
     let(:lp_name)                  { double('Lp Name') }
-    let(:buffer)                   { double('Buffer') }
-    let(:lp_name_buffer_referent)  { double('Lp Name buffer referent') }
     let(:response)                 { double('Response') }
     let(:enum_key_response)        { double('enum_key Response') }
-    let(:result_str)               { double('Result String') }
+    let(:result_str)               { { buffer: 'reg key' } }
     let(:lp_class)                 { double('Lp Class') }
-    let(:lp_class_buffer_referent) { double('Lp Class buffer referent') }
     before :example do
       allow(described_class::EnumKeyRequest).to receive(:new).and_return(enum_key_request_packet)
       allow(enum_key_request_packet).to receive_messages(
-        :lpft_last_write_time= => nil,
-        :lp_class=             => nil,
         :lp_name               => lp_name,
         :lp_class              => lp_class
       )
-      allow(lp_class).to receive(:referent).and_return(lp_class_buffer_referent)
-      allow(lp_class_buffer_referent).to receive(:buffer=)
-      allow(lp_name).to receive(:buffer).and_return(buffer)
-      allow(lp_name).to receive(:buffer=)
-      allow(buffer).to receive(:referent).and_return(lp_name_buffer_referent)
-      allow(lp_name_buffer_referent).to receive(:max_count=)
+      allow(lp_class).to receive(:instantiate_referent)
+      allow(lp_name).to receive(:set_max_buffer_size)
       allow(winreg).to receive(:dcerpc_request).and_return(response)
       allow(described_class::EnumKeyResponse).to receive(:read).and_return(enum_key_response)
       allow(enum_key_response).to receive(:error_status).and_return(WindowsError::Win32::ERROR_SUCCESS)
-      allow(enum_key_response).to receive_message_chain(:lp_name, :to_s => result_str)
+      allow(enum_key_response).to receive_message_chain(:lp_name, :[] => result_str)
     end
 
     it 'create the expected EnumKeyRequest packet' do
@@ -392,11 +371,8 @@ RSpec.describe RubySMB::Dcerpc::Winreg do
 
     it 'sets the expected parameters on the request packet' do
       winreg.enum_key(handle, index)
-      expect(enum_key_request_packet).to have_received(:lpft_last_write_time=).with(0)
-      expect(enum_key_request_packet).to have_received(:lp_class=).with('')
-      expect(lp_class_buffer_referent).to have_received(:buffer=).with(:null)
-      expect(lp_name).to have_received(:buffer=).with('')
-      expect(lp_name_buffer_referent).to have_received(:max_count=).with(256)
+      expect(lp_class).to have_received(:instantiate_referent)
+      expect(lp_name).to have_received(:set_max_buffer_size).with(RubySMB::Dcerpc::Winreg::BUFFER_SIZE)
     end
 
     it 'sends the expected dcerpc request' do
@@ -433,22 +409,18 @@ RSpec.describe RubySMB::Dcerpc::Winreg do
     let(:index)                     { double('Index') }
     let(:enum_value_request_packet) { double('EnumValue Request Packet') }
     let(:lp_value_name)             { double('Lp Value Name') }
-    let(:buffer)                    { double('Buffer') }
     let(:referent)                  { double('Referent') }
     let(:response)                  { double('Response') }
     let(:enum_value_response)       { double('EnumValue Response') }
-    let(:result_str)                { double('Result String') }
+    let(:result_str)                { {buffer: 'reg value'} }
     before :example do
       allow(described_class::EnumValueRequest).to receive(:new).and_return(enum_value_request_packet)
       allow(enum_value_request_packet).to receive(:lp_value_name).and_return(lp_value_name)
-      allow(lp_value_name).to receive(:buffer).and_return(buffer)
-      allow(lp_value_name).to receive(:buffer=)
-      allow(buffer).to receive(:referent).and_return(referent)
-      allow(referent).to receive(:max_count=)
+      allow(lp_value_name).to receive(:set_max_buffer_size)
       allow(winreg).to receive(:dcerpc_request).and_return(response)
       allow(described_class::EnumValueResponse).to receive(:read).and_return(enum_value_response)
       allow(enum_value_response).to receive(:error_status).and_return(WindowsError::Win32::ERROR_SUCCESS)
-      allow(enum_value_response).to receive_message_chain(:lp_value_name, :to_s => result_str)
+      allow(enum_value_response).to receive_message_chain(:lp_value_name, :[] => result_str)
     end
 
     it 'create the expected EnumValueRequest packet' do
@@ -458,8 +430,7 @@ RSpec.describe RubySMB::Dcerpc::Winreg do
 
     it 'sets the expected buffer on the request packet' do
       winreg.enum_value(handle, index)
-      expect(referent).to have_received(:max_count=).with(256)
-      expect(lp_value_name).to have_received(:buffer=).with('')
+      expect(lp_value_name).to have_received(:set_max_buffer_size).with(RubySMB::Dcerpc::Winreg::BUFFER_SIZE)
     end
 
     it 'sends the expected dcerpc request' do

data/spec/lib/ruby_smb/dcerpc/wkssvc/netr_wksta_get_info_request_spec.rb

@@ -0,0 +1,43 @@
+RSpec.describe RubySMB::Dcerpc::Wkssvc::WkssvcIdentifyHandle do
+  subject(:packet) { described_class.new }
+
+  it 'is a Ndr::NdrWideStringPtr' do
+    expect(packet).to be_a(RubySMB::Dcerpc::Ndr::NdrWideStringPtr)
+  end
+end
+
+RSpec.describe RubySMB::Dcerpc::Wkssvc::NetrWkstaGetInfoRequest do
+  subject(:packet) { described_class.new }
+
+  it { is_expected.to respond_to :server_name }
+  it { is_expected.to respond_to :level }
+  it { is_expected.to respond_to :opnum }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+  it 'is a BinData::Record' do
+    expect(packet).to be_a(BinData::Record)
+  end
+  describe '#server_name' do
+    it 'is a WkssvcIdentifyHandle structure' do
+      expect(packet.server_name).to be_a RubySMB::Dcerpc::Wkssvc::WkssvcIdentifyHandle
+    end
+  end
+  describe '#level' do
+    it 'is a NdrUint32 structure' do
+      expect(packet.level).to be_a RubySMB::Dcerpc::Ndr::NdrUint32
+    end
+  end
+  describe '#initialize_instance' do
+    it 'sets #opnum to NETR_WKSTA_GET_INFO constant' do
+      expect(packet.opnum).to eq(RubySMB::Dcerpc::Wkssvc::NETR_WKSTA_GET_INFO)
+    end
+  end
+  it 'reads itself' do
+    new_class = described_class.new(server_name: 'TestServer', level: 4)
+    expect(packet.read(new_class.to_binary_s)).to eq(
+      {server_name: 'TestServer'.encode('utf-16le'), level: 4}
+    )
+  end
+end