ruby_smb 2.0.1 → 2.0.6

data/spec/lib/ruby_smb/dcerpc/netlogon/netr_server_authenticate3_request_spec.rb

@@ -0,0 +1,69 @@
+RSpec.describe RubySMB::Dcerpc::Netlogon::NetrServerAuthenticate3Request do
+  subject(:packet) { described_class.new }
+
+  it { is_expected.to respond_to :primary_name }
+  it { is_expected.to respond_to :account_name }
+  it { is_expected.to respond_to :secure_channel_type }
+  it { is_expected.to respond_to :computer_name }
+  it { is_expected.to respond_to :client_credential }
+  it { is_expected.to respond_to :flags }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#primary_name' do
+    it 'is a LogonsrvHandle structure' do
+      expect(packet.primary_name).to be_a RubySMB::Dcerpc::Netlogon::LogonsrvHandle
+    end
+  end
+
+  describe '#account_name' do
+    it 'is a NdrString structure' do
+      expect(packet.account_name).to be_a RubySMB::Dcerpc::Ndr::NdrString
+    end
+  end
+
+  describe '#secure_channel_type' do
+    it 'is a NetlogonSecureChannelType enum' do
+      expect(packet.secure_channel_type).to be_a RubySMB::Dcerpc::Netlogon::NetlogonSecureChannelType
+    end
+  end
+
+  describe '#computer_name' do
+    it 'is a NdrString structure' do
+      expect(packet.computer_name).to be_a RubySMB::Dcerpc::Ndr::NdrString
+    end
+  end
+
+  describe '#client_credential' do
+    it 'is a NetlogonCredential structure' do
+      expect(packet.client_credential).to be_a RubySMB::Dcerpc::Netlogon::NetlogonCredential
+    end
+  end
+
+  describe '#flags' do
+    it 'is a 32-bit unsigned integer' do
+      expect(packet.flags).to be_a BinData::Uint32le
+    end
+  end
+
+  describe '#initialize_instance' do
+    it 'sets #opnum to NETR_SERVER_AUTHENTICATE3 constant' do
+      expect(packet.opnum).to eq(RubySMB::Dcerpc::Netlogon::NETR_SERVER_AUTHENTICATE3)
+    end
+  end
+
+  it 'reads its own binary representation and outputs the same packet' do
+    packet = described_class.new(
+      primary_name: 'primary_name',
+      account_name: 'account_name',
+      secure_channel_type: 0,
+      computer_name: 'computer_name',
+      client_credential: "\x00" * 8,
+      flags: rand(0xffffffff)
+    )
+    binary = packet.to_binary_s
+    expect(described_class.read(binary)).to eq(packet)
+  end
+end

data/spec/lib/ruby_smb/dcerpc/netlogon/netr_server_authenticate3_response_spec.rb

@@ -0,0 +1,53 @@
+RSpec.describe RubySMB::Dcerpc::Netlogon::NetrServerAuthenticate3Response do
+  subject(:packet) { described_class.new }
+
+  it { is_expected.to respond_to :server_credential }
+  it { is_expected.to respond_to :negotiate_flags }
+  it { is_expected.to respond_to :account_rid }
+  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 '#server_credential' do
+    it 'is a NetlogonCredential structure' do
+      expect(packet.server_credential).to be_a RubySMB::Dcerpc::Netlogon::NetlogonCredential
+    end
+  end
+
+  describe '#negotiate_flags' do
+    it 'is a 32-bit unsigned integer' do
+      expect(packet.negotiate_flags).to be_a BinData::Uint32le
+    end
+  end
+
+  describe '#account_rid' do
+    it 'is a 32-bit unsigned integer' do
+      expect(packet.account_rid).to be_a BinData::Uint32le
+    end
+  end
+
+  describe '#error_status' do
+    it 'is a 32-bit unsigned integer' do
+      expect(packet.error_status).to be_a BinData::Uint32le
+    end
+  end
+
+  describe '#initialize_instance' do
+    it 'sets #opnum to NETR_SERVER_AUTHENTICATE3 constant' do
+      expect(packet.opnum).to eq(RubySMB::Dcerpc::Netlogon::NETR_SERVER_AUTHENTICATE3)
+    end
+  end
+
+  it 'reads its own binary representation and outputs the same packet' do
+    packet = described_class.new(
+      server_credential: "\x00" * 8,
+      negotiate_flags: rand(0xffffffff),
+      account_rid: rand(0xffffffff),
+      error_status: rand(0xffffffff)
+    )
+    binary = packet.to_binary_s
+    expect(described_class.read(binary)).to eq(packet)
+  end
+end

data/spec/lib/ruby_smb/dcerpc/netlogon/netr_server_password_set2_request_spec.rb

@@ -0,0 +1,69 @@
+RSpec.describe RubySMB::Dcerpc::Netlogon::NetrServerPasswordSet2Request do
+  subject(:packet) { described_class.new }
+
+  it { is_expected.to respond_to :primary_name }
+  it { is_expected.to respond_to :account_name }
+  it { is_expected.to respond_to :secure_channel_type }
+  it { is_expected.to respond_to :computer_name }
+  it { is_expected.to respond_to :authenticator }
+  it { is_expected.to respond_to :clear_new_password }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#primary_name' do
+    it 'is a LogonsrvHandle structure' do
+      expect(packet.primary_name).to be_a RubySMB::Dcerpc::Netlogon::LogonsrvHandle
+    end
+  end
+
+  describe '#account_name' do
+    it 'is a NdrString structure' do
+      expect(packet.account_name).to be_a RubySMB::Dcerpc::Ndr::NdrString
+    end
+  end
+
+  describe '#secure_channel_type' do
+    it 'is a NetlogonSecureChannelType enum' do
+      expect(packet.secure_channel_type).to be_a RubySMB::Dcerpc::Netlogon::NetlogonSecureChannelType
+    end
+  end
+
+  describe '#computer_name' do
+    it 'is a NdrString structure' do
+      expect(packet.computer_name).to be_a RubySMB::Dcerpc::Ndr::NdrString
+    end
+  end
+
+  describe '#authenticator' do
+    it 'is a NetlogonAuthenticator structure' do
+      expect(packet.authenticator).to be_a RubySMB::Dcerpc::Netlogon::NetlogonAuthenticator
+    end
+  end
+
+  describe '#clear_new_password' do
+    it 'is a NdrFixedByteArray structure' do
+      expect(packet.clear_new_password).to be_a RubySMB::Dcerpc::Ndr::NdrFixedByteArray
+    end
+  end
+
+  describe '#initialize_instance' do
+    it 'sets #opnum to NETR_SERVER_PASSWORD_SET2 constant' do
+      expect(packet.opnum).to eq(RubySMB::Dcerpc::Netlogon::NETR_SERVER_PASSWORD_SET2)
+    end
+  end
+
+  it 'reads its own binary representation and outputs the same packet' do
+    packet = described_class.new(
+      primary_name: 'primary_name',
+      account_name: 'account_name',
+      secure_channel_type: 0,
+      computer_name: 'computer_name',
+      authenticator: RubySMB::Dcerpc::Netlogon::NetlogonAuthenticator.new,
+      clear_new_password: "\x00" * 516
+    )
+    binary = packet.to_binary_s
+    expect(described_class.read(binary)).to eq(packet)
+  end
+end

data/spec/lib/ruby_smb/dcerpc/netlogon/netr_server_password_set2_response_spec.rb

@@ -0,0 +1,37 @@
+RSpec.describe RubySMB::Dcerpc::Netlogon::NetrServerPasswordSet2Response do
+  subject(:packet) { described_class.new }
+
+  it { is_expected.to respond_to :return_authenticator }
+  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 '#return_authenticator' do
+    it 'is a NetlogonAuthenticator structure' do
+      expect(packet.return_authenticator).to be_a RubySMB::Dcerpc::Netlogon::NetlogonAuthenticator
+    end
+  end
+
+  describe '#error_status' do
+    it 'is a 32-bit unsigned integer' do
+      expect(packet.error_status).to be_a BinData::Uint32le
+    end
+  end
+
+  describe '#initialize_instance' do
+    it 'sets #opnum to NETR_SERVER_PASSWORD_SET2 constant' do
+      expect(packet.opnum).to eq(RubySMB::Dcerpc::Netlogon::NETR_SERVER_PASSWORD_SET2)
+    end
+  end
+
+  it 'reads its own binary representation and outputs the same packet' do
+    packet = described_class.new(
+      return_authenticator: RubySMB::Dcerpc::Netlogon::NetlogonAuthenticator.new,
+      error_status: rand(0xffffffff)
+    )
+    binary = packet.to_binary_s
+    expect(described_class.read(binary)).to eq(packet)
+  end
+end

data/spec/lib/ruby_smb/dcerpc/netlogon/netr_server_req_challenge_request_spec.rb

@@ -0,0 +1,45 @@
+RSpec.describe RubySMB::Dcerpc::Netlogon::NetrServerReqChallengeRequest do
+  subject(:packet) { described_class.new }
+
+  it { is_expected.to respond_to :primary_name }
+  it { is_expected.to respond_to :computer_name }
+  it { is_expected.to respond_to :client_challenge }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#primary_name' do
+    it 'is a LogonsrvHandle structure' do
+      expect(packet.primary_name).to be_a RubySMB::Dcerpc::Netlogon::LogonsrvHandle
+    end
+  end
+
+  describe '#computer_name' do
+    it 'is a NdrString structure' do
+      expect(packet.computer_name).to be_a RubySMB::Dcerpc::Ndr::NdrString
+    end
+  end
+
+  describe '#client_challenge' do
+    it 'is a NetlogonCredential structure' do
+      expect(packet.client_challenge).to be_a RubySMB::Dcerpc::Netlogon::NetlogonCredential
+    end
+  end
+
+  describe '#initialize_instance' do
+    it 'sets #opnum to NETR_SERVER_REQ_CHALLENGE constant' do
+      expect(packet.opnum).to eq(RubySMB::Dcerpc::Netlogon::NETR_SERVER_REQ_CHALLENGE)
+    end
+  end
+
+  it 'reads its own binary representation and outputs the same packet' do
+    packet = described_class.new(
+      primary_name: 'primary_name',
+      computer_name: 'computer_name',
+      client_challenge: "\x00" * 8,
+    )
+    binary = packet.to_binary_s
+    expect(described_class.read(binary)).to eq(packet)
+  end
+end

data/spec/lib/ruby_smb/dcerpc/netlogon/netr_server_req_challenge_response_spec.rb

@@ -0,0 +1,37 @@
+RSpec.describe RubySMB::Dcerpc::Netlogon::NetrServerReqChallengeResponse do
+  subject(:packet) { described_class.new }
+
+  it { is_expected.to respond_to :server_challenge }
+  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 '#server_challenge' do
+    it 'is a NetlogonCredential structure' do
+      expect(packet.server_challenge).to be_a RubySMB::Dcerpc::Netlogon::NetlogonCredential
+    end
+  end
+
+  describe '#error_status' do
+    it 'is a 32-bit unsigned integer' do
+      expect(packet.error_status).to be_a BinData::Uint32le
+    end
+  end
+
+  describe '#initialize_instance' do
+    it 'sets #opnum to NETR_SERVER_REQ_CHALLENGE constant' do
+      expect(packet.opnum).to eq(RubySMB::Dcerpc::Netlogon::NETR_SERVER_REQ_CHALLENGE)
+    end
+  end
+
+  it 'reads its own binary representation and outputs the same packet' do
+    packet = described_class.new(
+      server_challenge: "\x00" * 8,
+      error_status: rand(0xffffffff)
+    )
+    binary = packet.to_binary_s
+    expect(described_class.read(binary)).to eq(packet)
+  end
+end

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

@@ -0,0 +1,161 @@
+RSpec.describe RubySMB::Dcerpc::RpcSecurityDescriptor do
+  subject(:packet) { described_class.new }
+
+  it { is_expected.to respond_to :lp_security_descriptor }
+  it { is_expected.to respond_to :cb_in_security_descriptor }
+  it { is_expected.to respond_to :cb_out_security_descriptor }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#lp_security_descriptor' do
+    it 'should be a NdrLpByteArray structure' do
+      expect(packet.lp_security_descriptor).to be_a RubySMB::Dcerpc::Ndr::NdrLpByteArray
+    end
+  end
+
+  describe '#cb_in_security_descriptor' do
+    it 'should be a 32-bit unsigned integer' do
+      expect(packet.cb_in_security_descriptor).to be_a BinData::Uint32le
+    end
+  end
+
+  describe '#cb_out_security_descriptor' do
+    it 'should be a 32-bit unsigned integer' do
+      expect(packet.cb_out_security_descriptor).to be_a BinData::Uint32le
+    end
+  end
+
+  describe '#read' do
+    context 'with a null pointer' do
+      it 'reads its own binary representation' do
+        raw = packet.to_binary_s
+        expect(described_class.read(raw)).to eq(packet)
+        expect(described_class.read(raw).to_binary_s).to eq(raw)
+      end
+    end
+
+    context 'with a normal RpcSecurityAttributes structure' do
+      it 'reads its own binary representation' do
+        packet.lp_security_descriptor = RubySMB::Dcerpc::Ndr::NdrLpByteArray.new([1, 2, 3])
+        packet.cb_in_security_descriptor = 90
+        packet.cb_out_security_descriptor = 33
+        raw = packet.to_binary_s
+        expect(described_class.read(raw)).to eq(packet)
+        expect(described_class.read(raw).to_binary_s).to eq(raw)
+      end
+    end
+  end
+end
+
+RSpec.describe RubySMB::Dcerpc::RpcSecurityAttributes do
+  subject(:packet) { described_class.new }
+
+  it { is_expected.to respond_to :n_length }
+  it { is_expected.to respond_to :rpc_security_descriptor }
+  it { is_expected.to respond_to :b_inheritHandle }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#n_length' do
+    it 'should be a 32-bit unsigned integer' do
+      expect(packet.n_length).to be_a BinData::Uint32le
+    end
+  end
+
+  describe '#rpc_security_descriptor' do
+    it 'should be a RpcSecurityDescriptor structure' do
+      expect(packet.rpc_security_descriptor).to be_a RubySMB::Dcerpc::RpcSecurityDescriptor
+    end
+  end
+
+  describe '#b_inheritHandle' do
+    it 'should be a 8-bit unsigned integer' do
+      expect(packet.b_inheritHandle).to be_a BinData::Uint8
+    end
+  end
+
+  describe '#read' do
+    context 'with a null pointer' do
+      it 'reads its own binary representation' do
+        raw = packet.to_binary_s
+        expect(described_class.read(raw)).to eq(packet)
+        expect(described_class.read(raw).to_binary_s).to eq(raw)
+      end
+    end
+
+    context 'with a normal RpcSecurityAttributes structure' do
+      it 'reads its own binary representation' do
+        packet.n_length = 3
+        packet.rpc_security_descriptor = RubySMB::Dcerpc::RpcSecurityDescriptor.new
+        packet.rpc_security_descriptor.lp_security_descriptor = [1, 2, 3]
+        packet.rpc_security_descriptor.cb_in_security_descriptor = 33
+        packet.rpc_security_descriptor.cb_out_security_descriptor = 22
+        packet.b_inheritHandle = 90
+        raw = packet.to_binary_s
+        expect(described_class.read(raw)).to eq(packet)
+        expect(described_class.read(raw).to_binary_s).to eq(raw)
+      end
+    end
+  end
+end
+
+RSpec.describe RubySMB::Dcerpc::PrpcSecurityAttributes do
+  it 'is NdrPointer subclass' do
+    expect(described_class).to be < RubySMB::Dcerpc::Ndr::NdrPointer
+  end
+
+  subject(:packet) { described_class.new }
+
+  it { is_expected.to respond_to :referent }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#referent' do
+    it 'should be a RpcSecurityAttributes structure' do
+      expect(packet.referent).to be_a RubySMB::Dcerpc::RpcSecurityAttributes
+    end
+
+    it 'exists if superclass #referent_id is not zero' do
+      packet.referent_id = 0xCCCC
+      expect(packet.referent?).to be true
+    end
+
+    it 'does not exist if superclass #referent_id is zero' do
+      packet.referent_id = 0
+      expect(packet.referent?).to be false
+    end
+  end
+
+  describe '#read' do
+    context 'with a null pointer' do
+      it 'reads its own binary representation' do
+        raw = packet.to_binary_s
+        expect(described_class.read(raw)).to eq(packet)
+        expect(described_class.read(raw).to_binary_s).to eq(raw)
+      end
+    end
+
+    context 'with a normal RpcSecurityAttributes structure' do
+      it 'reads its own binary representation' do
+        struct = RubySMB::Dcerpc::RpcSecurityAttributes.new
+        struct.n_length = 5
+        struct.rpc_security_descriptor = RubySMB::Dcerpc::RpcSecurityDescriptor.new
+        struct.rpc_security_descriptor.lp_security_descriptor = [1, 2, 3]
+        struct.rpc_security_descriptor.cb_in_security_descriptor = 33
+        struct.rpc_security_descriptor.cb_out_security_descriptor = 22
+        struct.b_inheritHandle = 4
+        packet.set(struct)
+        raw = packet.to_binary_s
+        expect(described_class.read(raw)).to eq(packet)
+        expect(described_class.read(raw).to_binary_s).to eq(raw)
+      end
+    end
+  end
+end
+