ruby_smb 0.0.21 → 0.0.22

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

@@ -1,14 +1,262 @@
-require 'spec_helper'
-
 RSpec.describe RubySMB::Dcerpc::Bind do
+  let(:uuid) { '12345678-1234-4321-5678-123456789012' }
+  let(:ver_major) { 2 }
+  let(:ver_minor) { 8 }
+  let :endpoint do
+    endpoint = Module.new
+    endpoint.const_set('UUID', uuid)
+    endpoint.const_set('VER_MAJOR', ver_major)
+    endpoint.const_set('VER_MINOR', ver_minor)
+    endpoint
+  end
+
+  subject(:packet) { described_class.new }
+
+  it { is_expected.to respond_to :pdu_header }
+  it { is_expected.to respond_to :max_xmit_frag }
+  it { is_expected.to respond_to :max_recv_frag }
+  it { is_expected.to respond_to :assoc_group_id }
+  it { is_expected.to respond_to :p_context_list }
+  it { is_expected.to respond_to :auth_verifier }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#pdu_header' do
+    subject(:header) { packet.pdu_header }
+
+    it 'is a standard PDU Header' do
+      expect(header).to be_a RubySMB::Dcerpc::PDUHeader
+    end
+
+    it 'should have the #ptype field set to PTypes::BIND' do
+      expect(header.ptype).to eq RubySMB::Dcerpc::PTypes::BIND
+    end
+  end
+
+  describe '#max_xmit_frag' do
+    it 'should be a 16-bit unsigned integer' do
+      expect(packet.max_xmit_frag).to be_a BinData::Uint16le
+    end
+
+    it 'should have a default value of 0xFFFF' do
+      expect(packet.max_xmit_frag).to eq 0xFFFF
+    end
+  end
+
+  describe '#max_recv_frag' do
+    it 'should be a 16-bit unsigned integer' do
+      expect(packet.max_recv_frag).to be_a BinData::Uint16le
+    end
+
+    it 'should have a default value of 0xFFFF' do
+      expect(packet.max_recv_frag).to eq 0xFFFF
+    end
+  end
+
+  describe '#assoc_group_id' do
+    it 'should be a 32-bit unsigned integer' do
+      expect(packet.assoc_group_id).to be_a BinData::Uint32le
+    end
+  end
+
+  describe '#p_context_list' do
+    it 'should be a PContListT structure' do
+      expect(packet.p_context_list).to be_a RubySMB::Dcerpc::PContListT
+    end
+
+    it 'should have an #endpoint parameter' do
+      expect(packet.p_context_list.has_parameter?(:endpoint)).to be true
+    end
+  end
+
+  describe '#auth_verifier' do
+    it 'should be a string' do
+      expect(packet.auth_verifier).to be_a BinData::String
+    end
+
+    it 'should not exist if the #auth_length PDU header field is 0' do
+      packet.pdu_header.auth_length = 0
+      expect(packet.auth_verifier?).to be false
+    end
+
+    it 'should exist only if the #auth_length PDU header field is greater than 0' do
+      packet.pdu_header.auth_length = 10
+      expect(packet.auth_verifier?).to be true
+    end
+
+    it 'reads #auth_length bytes' do
+      auth_verifier = '12345678'
+      packet.pdu_header.auth_length = 6
+      packet.auth_verifier.read(auth_verifier)
+      expect(packet.auth_verifier).to eq(auth_verifier[0,6])
+    end
+  end
+
+  it 'reads its own binary representation and output the same packet' do
+    packet = described_class.new(endpoint: endpoint)
+    packet.auth_verifier = '123456'
+    packet.pdu_header.auth_length = 6
+    binary = packet.to_binary_s
+    expect(described_class.read(binary)).to eq(packet)
+  end
+end
+
+RSpec.describe RubySMB::Dcerpc::PContListT do
+  let(:uuid) { '12345678-1234-4321-5678-123456789012' }
+  let(:ver_major) { 2 }
+  let(:ver_minor) { 8 }
+  let :endpoint do
+    endpoint = Module.new
+    endpoint.const_set('UUID', uuid)
+    endpoint.const_set('VER_MAJOR', ver_major)
+    endpoint.const_set('VER_MINOR', ver_minor)
+    endpoint
+  end
+
+  subject(:packet) { described_class.new }
+
+  it { is_expected.to respond_to :n_context_elem }
+  it { is_expected.to respond_to :p_cont_elem }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
 
-  describe '#initialize' do
+  describe '#n_context_elem' do
+    it 'should be a 8-bit unsigned integer' do
+      expect(packet.n_context_elem).to be_a BinData::Uint8
+    end
+
+    it 'should have the default value 1' do
+      expect(packet.n_context_elem).to eq 1
+    end
+  end
+
+  describe '#p_cont_elem' do
+    it 'should be an array of type PContElemT' do
+      expect(packet.p_cont_elem).to be_a BinData::Array
+      type = packet.p_cont_elem.get_parameter(:type)
+      expect(type.instantiate).to be_a RubySMB::Dcerpc::PContElemT
+    end
+
+    it 'should have #n_context_elem elements' do
+      n_elements = 4
+      packet.n_context_elem = n_elements
+      expect(packet.p_cont_elem.size).to eq n_elements
+    end
+
+    it 'should have an #endpoint parameter' do
+      expect(packet.p_cont_elem.has_parameter?(:endpoint)).to be true
+    end
+  end
+
+  it 'reads its own binary representation and output the same packet' do
+    packet = described_class.new(endpoint: endpoint)
+    binary = packet.to_binary_s
+    expect(described_class.read(binary)).to eq(packet)
+  end
+end
+
+RSpec.describe RubySMB::Dcerpc::PContElemT do
+  let(:uuid) { '12345678-1234-4321-5678-123456789012' }
+  let(:ver_major) { 2 }
+  let(:ver_minor) { 8 }
+  let :endpoint do
+    endpoint = Module.new
+    endpoint.const_set('UUID', uuid)
+    endpoint.const_set('VER_MAJOR', ver_major)
+    endpoint.const_set('VER_MINOR', ver_minor)
+    endpoint
+  end
+
+  subject(:packet) { described_class.new }
+
+  it { is_expected.to respond_to :p_cont_id }
+  it { is_expected.to respond_to :n_transfer_syn }
+  it { is_expected.to respond_to :abstract_syntax }
+  it { is_expected.to respond_to :transfer_syntaxes }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#p_cont_id' do
+    it 'should be a 16-bit unsigned integer' do
+      expect(packet.p_cont_id).to be_a BinData::Uint16le
+    end
+  end
+
+  describe '#n_transfer_syn' do
+    it 'should be a 8-bit unsigned integer' do
+      expect(packet.n_transfer_syn).to be_a BinData::Uint8
+    end
+
+    it 'should have the default value 1' do
+      expect(packet.n_transfer_syn).to eq 1
+    end
+  end
+
+  describe '#abstract_syntax' do
+    it 'should be a PSyntaxIdT structure' do
+      expect(packet.abstract_syntax).to be_a RubySMB::Dcerpc::PSyntaxIdT
+    end
+
+    it 'should have an #uuid parameter' do
+      expect(packet.abstract_syntax.has_parameter?(:uuid)).to be true
+    end
+
+    it 'should have a #ver_major parameter' do
+      expect(packet.abstract_syntax.has_parameter?(:ver_major)).to be true
+    end
+
+    it 'should have a #ver_minor parameter' do
+      expect(packet.abstract_syntax.has_parameter?(:ver_minor)).to be true
+    end
 
-    let(:bind){described_class.new(endpoint: RubySMB::Dcerpc::Srvsvc)}
-    let(:abstract_syntax){bind.p_context_elem.p_cont_elem[0].abstract_syntax}
+    it 'should be initialized with the #endpoint constants' do
+      p_cont_elem_t = described_class.new(endpoint: endpoint)
 
-    it 'should set the abstract syntax to SrvsvcSyntax' do
-      expect(abstract_syntax).to eq RubySMB::Dcerpc::Srvsvc::SrvSvcSyntax.new
+      expect(p_cont_elem_t.abstract_syntax.if_uuid).to eq(uuid)
+      expect(p_cont_elem_t.abstract_syntax.if_ver_major).to eq(ver_major)
+      expect(p_cont_elem_t.abstract_syntax.if_ver_minor).to eq(ver_minor)
     end
+
+    it 'should be initialized with the #endpoint constants when passed as a parameter to Bind' do
+      bind = RubySMB::Dcerpc::Bind.new(endpoint: endpoint)
+      p_cont_elem_t = bind.p_context_list.p_cont_elem.first
+
+      expect(p_cont_elem_t.abstract_syntax.if_uuid).to eq(uuid)
+      expect(p_cont_elem_t.abstract_syntax.if_ver_major).to eq(ver_major)
+      expect(p_cont_elem_t.abstract_syntax.if_ver_minor).to eq(ver_minor)
+    end
+  end
+
+  describe '#transfer_syntaxes' do
+    it 'should be an array of type PSyntaxIdT' do
+      expect(packet.transfer_syntaxes).to be_a BinData::Array
+      type = packet.transfer_syntaxes.get_parameter(:type)
+      expect(type.instantiate).to be_a RubySMB::Dcerpc::PSyntaxIdT
+    end
+
+    it 'should have #n_transfer_syn elements' do
+      n_elements = 4
+      packet.n_transfer_syn = n_elements
+      expect(packet.transfer_syntaxes.size).to eq n_elements
+    end
+
+    it 'sets its elements to the NDR presentation syntax' do
+      expect(packet.transfer_syntaxes[0].if_uuid).to eq RubySMB::Dcerpc::Ndr::UUID
+      expect(packet.transfer_syntaxes[0].if_ver_major).to eq RubySMB::Dcerpc::Ndr::VER_MAJOR
+      expect(packet.transfer_syntaxes[0].if_ver_minor).to eq RubySMB::Dcerpc::Ndr::VER_MINOR
+    end
+  end
+
+  it 'reads its own binary representation and output the same packet' do
+    packet = described_class.new(endpoint: endpoint)
+    packet.n_transfer_syn = 2
+    binary = packet.to_binary_s
+    expect(described_class.read(binary)).to eq(packet)
   end
 end

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

@@ -0,0 +1,31 @@
+RSpec.describe RubySMB::Dcerpc::PSyntaxIdT do
+  subject(:packet) { described_class.new }
+
+  it { is_expected.to respond_to :if_uuid }
+  it { is_expected.to respond_to :if_ver_major }
+  it { is_expected.to respond_to :if_ver_minor }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#if_uuid' do
+    it 'is a Uuid' do
+      expect(packet.if_uuid).to be_a RubySMB::Dcerpc::Uuid
+    end
+  end
+
+  describe '#if_ver_major' do
+    it 'should be a 16-bit unsigned integer' do
+      expect(packet.if_ver_major).to be_a BinData::Uint16le
+    end
+  end
+
+  describe '#if_ver_minor' do
+    it 'should be a 16-bit unsigned integer' do
+      expect(packet.if_ver_minor).to be_a BinData::Uint16le
+    end
+  end
+
+end
+

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

@@ -0,0 +1,84 @@
+RSpec.describe RubySMB::Dcerpc::PDUHeader do
+  subject(:packet) { described_class.new }
+
+  it { is_expected.to respond_to :rpc_vers }
+  it { is_expected.to respond_to :rpc_vers_minor }
+  it { is_expected.to respond_to :ptype }
+  it { is_expected.to respond_to :pfc_flags }
+  it { is_expected.to respond_to :packed_drep }
+  it { is_expected.to respond_to :frag_length }
+  it { is_expected.to respond_to :auth_length }
+  it { is_expected.to respond_to :call_id }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#rpc_vers' do
+    it 'should be a 8-bit unsigned integer' do
+      expect(packet.rpc_vers).to be_a BinData::Uint8
+    end
+
+    it 'should have a default value of 5' do
+      expect(packet.rpc_vers).to eq 5
+    end
+  end
+
+  describe '#rpc_vers_minor' do
+    it 'should be a 8-bit unsigned integer' do
+      expect(packet.rpc_vers_minor).to be_a BinData::Uint8
+    end
+  end
+
+  describe '#ptype' do
+    it 'should be a 8-bit unsigned integer' do
+      expect(packet.ptype).to be_a BinData::Uint8
+    end
+  end
+
+  describe '#pfc_flags' do
+    it 'should be a custom structure' do
+      expect(packet.pfc_flags).to be_a BinData::Struct
+    end
+  end
+
+  describe '#packed_drep' do
+    it 'should be a 32-bit unsigned integer' do
+      expect(packet.packed_drep).to be_a BinData::Uint32le
+    end
+
+    it 'should have a default value of 0x10' do
+      expect(packet.packed_drep).to eq 0x10
+    end
+  end
+
+  describe '#frag_length' do
+    it 'should be a 16-bit unsigned integer' do
+      expect(packet.frag_length).to be_a BinData::Uint16le
+    end
+
+    it 'should be the size of the full packet' do
+      bind_ack = RubySMB::Dcerpc::BindAck.new
+      expect(bind_ack.pdu_header.frag_length).to eq(bind_ack.do_num_bytes)
+    end
+  end
+
+  describe '#auth_length' do
+    it 'should be a 16-bit unsigned integer' do
+      expect(packet.auth_length).to be_a BinData::Uint16le
+    end
+  end
+
+  describe '#call_id' do
+    it 'should be a 32-bit unsigned integer' do
+      expect(packet.call_id).to be_a BinData::Uint32le
+    end
+
+    it 'should have a default value of 1' do
+      expect(packet.call_id).to eq 1
+    end
+  end
+
+end
+
+

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

@@ -1,21 +1,114 @@
-require 'spec_helper'
-
 RSpec.describe RubySMB::Dcerpc::Request do
+  subject(:packet) { described_class.new }
+
+  it { is_expected.to respond_to :pdu_header }
+  it { is_expected.to respond_to :alloc_hint }
+  it { is_expected.to respond_to :p_cont_id }
+  it { is_expected.to respond_to :opnum }
+  it { is_expected.to respond_to :object }
+  it { is_expected.to respond_to :stub }
+  it { is_expected.to respond_to :auth_verifier }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#pdu_header' do
+    subject(:header) { packet.pdu_header }
+
+    it 'is a standard PDU Header' do
+      expect(header).to be_a RubySMB::Dcerpc::PDUHeader
+    end
+
+    it 'should have the #ptype field set to PTypes::BIND_ACK' do
+      expect(header.ptype).to eq RubySMB::Dcerpc::PTypes::REQUEST
+    end
+  end
+
+  describe '#alloc_hint' do
+    it 'should be a 32-bit unsigned integer' do
+      expect(packet.alloc_hint).to be_a BinData::Uint32le
+    end
+
+    it 'should be the size of the #stub field' do
+      packet = described_class.new({ :opnum => RubySMB::Dcerpc::Srvsvc::NET_SHARE_ENUM_ALL }, host: '1.2.3.4')
+      expect(packet.alloc_hint).to eq(packet.stub.do_num_bytes)
+    end
+  end
+
+  describe '#p_cont_id' do
+    it 'should be a 16-bit unsigned integer' do
+      expect(packet.p_cont_id).to be_a BinData::Uint16le
+    end
+  end
+
+  describe '#opnum' do
+    it 'should be a 16-bit unsigned integer' do
+      expect(packet.opnum).to be_a BinData::Uint16le
+    end
+  end
+
+  describe '#object' do
+    it 'is a Uuid' do
+      expect(packet.object).to be_a RubySMB::Dcerpc::Uuid
+    end
+
+    it 'only exists if #object_uuid header flag is set' do
+      packet.pdu_header.pfc_flags.object_uuid = 1
+      expect(packet.object?).to be true
+    end
+
+    it 'does not  exist if #object_uuid header flag is not set' do
+      packet.pdu_header.pfc_flags.object_uuid = 0
+      expect(packet.object?).to be false
+    end
+  end
+
+  describe '#stub' do
+    it 'is a Bindata Choice' do
+      expect(packet.stub).to be_a BinData::Choice
+    end
 
-  describe 'when making a NetShareEnumAll dcerpc request' do
-    let(:request){
-      described_class.new(
-          opnum: RubySMB::Dcerpc::Srvsvc::NetShareEnumAll::Opnum,
-          stub: RubySMB::Dcerpc::Srvsvc::NetShareEnumAll.new(host: '192.161.204.122').to_binary_s
-      )
-    }
+    context 'with a NetShareEnumAll stub' do
 
-    it 'should create a Request struct with NetShareEnumAll as stub with size of 106' do
-      expect(request.do_num_bytes).to eq 104
+      it 'uses opnum as a selector' do
+        packet = described_class.new({ :opnum => RubySMB::Dcerpc::Srvsvc::NET_SHARE_ENUM_ALL }, host: '1.2.3.4')
+        expect(packet.stub.selection).to eq(packet.opnum)
+      end
+    end
+  end
+
+  describe '#auth_verifier' do
+    it 'should be a string' do
+      expect(packet.auth_verifier).to be_a BinData::String
+    end
+
+    it 'should not exist if the #auth_length PDU header field is 0' do
+      packet.pdu_header.auth_length = 0
+      expect(packet.auth_verifier?).to be false
     end
 
-    it 'should set the correct opnum' do
-      expect(request.opnum).to eq 0xF
+    it 'should exist only if the #auth_length PDU header field is greater than 0' do
+      packet.pdu_header.auth_length = 10
+      expect(packet.auth_verifier?).to be true
+    end
+
+    it 'reads #auth_length bytes' do
+      auth_verifier = '12345678'
+      packet.pdu_header.auth_length = 6
+      packet.auth_verifier.read(auth_verifier)
+      expect(packet.auth_verifier).to eq(auth_verifier[0,6])
     end
   end
+
+  it 'reads its own binary representation and output the same packet' do
+    packet = described_class.new({ :opnum => RubySMB::Dcerpc::Srvsvc::NET_SHARE_ENUM_ALL }, host: '1.2.3.4')
+    packet.pdu_header.pfc_flags.object_uuid = 1
+    packet.object = '8a885d04-1ceb-11c9-9fe8-08002b104860'
+    packet.auth_verifier = '123456'
+    packet.pdu_header.auth_length = 6
+    binary = packet.to_binary_s
+    expect(described_class.read(binary)).to eq(packet)
+  end
 end
+