ruby_smb 0.0.8 → 0.0.9

data/spec/lib/ruby_smb/smb2/bit_field/share_capabilities_spec.rb

@@ -0,0 +1,54 @@
+RSpec.describe RubySMB::SMB2::BitField::ShareCapabilities do
+  subject(:capabilities) { described_class.new }
+
+  it { is_expected.to respond_to :asymmetric }
+  it { is_expected.to respond_to :cluster }
+  it { is_expected.to respond_to :scaleout }
+  it { is_expected.to respond_to :continuous }
+  it { is_expected.to respond_to :dfs }
+
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#dfs' do
+    it 'is a 1-bit flag' do
+      expect(capabilities.dfs).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :dfs, 'V', 0x00000008
+  end
+
+  describe '#continuous' do
+    it 'is a 1-bit flag' do
+      expect(capabilities.continuous).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :continuous, 'V', 0x00000010
+  end
+
+  describe '#scaleout' do
+    it 'is a 1-bit flag' do
+      expect(capabilities.scaleout).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :scaleout, 'V', 0x00000020
+  end
+
+  describe '#cluster' do
+    it 'is a 1-bit flag' do
+      expect(capabilities.cluster).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :cluster, 'V', 0x00000040
+  end
+
+  describe '#asymmetric' do
+    it 'is a 1-bit flag' do
+      expect(capabilities.asymmetric).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :asymmetric, 'V', 0x00000080
+  end
+end

data/spec/lib/ruby_smb/smb2/bit_field/share_flags_spec.rb

@@ -0,0 +1,184 @@
+RSpec.describe RubySMB::SMB2::BitField::ShareFlags do
+  subject(:flags) { described_class.new }
+
+  it { is_expected.to respond_to :dfs_root }
+  it { is_expected.to respond_to :dfs }
+  it { is_expected.to respond_to :encrypt }
+  it { is_expected.to respond_to :hash_v2 }
+  it { is_expected.to respond_to :hash_v1 }
+  it { is_expected.to respond_to :force_oplock }
+  it { is_expected.to respond_to :access_based_enum }
+  it { is_expected.to respond_to :namespace_caching }
+  it { is_expected.to respond_to :shared_delete }
+  it { is_expected.to respond_to :restrict_exclusive_opens }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#dfs' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.dfs).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :dfs, 'V', 0x00000001
+  end
+
+
+  describe '#dfs_root' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.dfs_root).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :dfs_root, 'V', 0x00000002
+  end
+
+  describe '#restrict_exclusive_opens' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.restrict_exclusive_opens).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :restrict_exclusive_opens, 'V', 0x00000100
+  end
+
+  describe '#shared_delete' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.shared_delete).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :shared_delete, 'V', 0x00000200
+  end
+
+  describe '#namespace_caching' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.namespace_caching).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :namespace_caching, 'V', 0x00000400
+  end
+
+  describe '#access_based_enum' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.access_based_enum).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :access_based_enum, 'V', 0x00000800
+  end
+
+  describe '#force_oplock' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.force_oplock).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :force_oplock, 'V', 0x00001000
+  end
+
+  describe '#hash_v1' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.hash_v1).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :hash_v1, 'V', 0x00002000
+  end
+
+  describe '#hash_v2' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.hash_v2).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :hash_v2, 'V', 0x00004000
+  end
+
+  describe '#encrypt' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.encrypt).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :encrypt, 'V', 0x00008000
+  end
+
+  describe '#set_manual_caching' do
+    it 'turns off the caching bits' do
+      flags.set_manual_caching
+      expect(flags.vdo_caching).to eq 0
+      expect(flags.auto_caching).to eq 0
+    end
+
+    it 'has a value of 0x00000000' do
+      flags.set_manual_caching
+      flag_val = flags.to_binary_s
+      flag_val = flag_val.unpack('V').first
+      expect(flag_val).to eq 0x00000000
+    end
+  end
+
+  describe '#set_auto_caching' do
+    it 'turns on the auto_caching bit' do
+      flags.set_auto_caching
+      expect(flags.vdo_caching).to eq 0
+      expect(flags.auto_caching).to eq 1
+    end
+
+    it 'has a value of 0x00000010' do
+      flags.set_auto_caching
+      flag_val = flags.to_binary_s
+      flag_val = flag_val.unpack('V').first
+      expect(flag_val).to eq 0x00000010
+    end
+  end
+
+  describe '#set_vdo_caching' do
+    it 'turns on the vdo_caching bits' do
+      flags.set_vdo_caching
+      expect(flags.vdo_caching).to eq 1
+      expect(flags.auto_caching).to eq 0
+    end
+
+    it 'has a value of 0x00000020' do
+      flags.set_vdo_caching
+      flag_val = flags.to_binary_s
+      flag_val = flag_val.unpack('V').first
+      expect(flag_val).to eq 0x00000020
+    end
+  end
+
+  describe '#set_no_caching' do
+    it 'turns on all the caching bits' do
+      flags.set_no_caching
+      expect(flags.vdo_caching).to eq 1
+      expect(flags.auto_caching).to eq 1
+    end
+
+    it 'has a value of 0x00000030' do
+      flags.set_no_caching
+      flag_val = flags.to_binary_s
+      flag_val = flag_val.unpack('V').first
+      expect(flag_val).to eq 0x00000030
+    end
+  end
+
+  describe '#caching_type' do
+    it 'returns VDO if only that flag is set' do
+      flags.vdo_caching = 1
+      expect(flags.caching_type).to eq :vdo
+    end
+
+    it 'returns Auto if only that flag is set' do
+      flags.auto_caching = 1
+      expect(flags.caching_type).to eq :auto
+    end
+
+    it 'returns No Caching if both caching flags are set' do
+      flags.auto_caching = 1
+      flags.vdo_caching = 1
+      expect(flags.caching_type).to eq :no_caching
+    end
+
+    it 'returns Manual if neither caching flags are set' do
+      flags.auto_caching = 0
+      flags.vdo_caching = 0
+      expect(flags.caching_type).to eq :manual
+    end
+
+  end
+end

data/spec/lib/ruby_smb/smb2/packet/tree_connect_request_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+RSpec.describe RubySMB::SMB2::Packet::TreeConnectRequest do
+
+  subject(:packet) { described_class.new }
+
+  it { is_expected.to respond_to :smb2_header }
+  it { is_expected.to respond_to :structure_size }
+  it { is_expected.to respond_to :flags }
+  it { is_expected.to respond_to :path_offset }
+  it { is_expected.to respond_to :path_length }
+  it { is_expected.to respond_to :path }
+
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#smb2_header' do
+    subject(:header) { packet.smb2_header }
+
+    it 'is a standard SMB Header' do
+      expect(header).to be_a RubySMB::SMB2::SMB2Header
+    end
+
+    it 'should have the command set to SMB_COM_NEGOTIATE' do
+      expect(header.command).to eq RubySMB::SMB2::Commands::TREE_CONNECT
+    end
+
+    it 'should not have the response flag set' do
+      expect(header.flags.reply).to eq 0
+    end
+  end
+
+  describe '#encode_path' do
+    let(:path) { "\\192.168.1.1\\example" }
+    let(:encoded_path) { path.encode("utf-16le").force_encoding("binary") }
+
+    it 'sets the path string to a UTF-16LE version of the supplied string' do
+      packet.encode_path(path)
+      expect(packet.path).to eq encoded_path
+    end
+
+    it 'updates the #path_length' do
+      packet.encode_path(path)
+      expect(packet.path_length).to eq encoded_path.length
+    end
+  end
+end

data/spec/lib/ruby_smb/smb2/packet/tree_connect_response_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+RSpec.describe RubySMB::SMB2::Packet::TreeConnectResponse do
+
+  subject(:packet) { described_class.new }
+
+  it { is_expected.to respond_to :smb2_header }
+  it { is_expected.to respond_to :structure_size }
+  it { is_expected.to respond_to :share_type }
+  it { is_expected.to respond_to :share_flags }
+  it { is_expected.to respond_to :capabilities }
+  it { is_expected.to respond_to :maximal_access }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#smb2_header' do
+    subject(:header) { packet.smb2_header }
+
+    it 'is a standard SMB Header' do
+      expect(header).to be_a RubySMB::SMB2::SMB2Header
+    end
+
+    it 'should have the command set to SMB_COM_NEGOTIATE' do
+      expect(header.command).to eq RubySMB::SMB2::Commands::TREE_CONNECT
+    end
+
+    it 'should have the response flag set' do
+      expect(header.flags.reply).to eq 1
+    end
+  end
+
+  describe '#is_directory?' do
+    it 'returns true if #share_type is 0x01' do
+      packet.share_type = 0x01
+      expect(packet.is_directory?).to be true
+    end
+
+    it 'returns false if #share_type is not 0x01' do
+      packet.share_type = 0x02
+      expect(packet.is_directory?).to be false
+    end
+  end
+
+  describe '#access_rights' do
+    it 'is a DirectoryAccessMask if the Tree is a directory' do
+      allow(packet).to receive(:is_directory?).and_return(true)
+      expect(packet.access_rights).to be_a RubySMB::SMB2::BitField::DirectoryAccessMask
+    end
+
+    it 'is a FileAccessMask if the Tree is not a directory' do
+      allow(packet).to receive(:is_directory?).and_return(false)
+      expect(packet.access_rights).to be_a RubySMB::SMB2::BitField::FileAccessMask
+    end
+  end
+end

data/spec/lib/ruby_smb/smb2/packet/tree_disconnect_request_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+RSpec.describe RubySMB::SMB2::Packet::TreeDisconnectRequest do
+
+  subject(:packet) { described_class.new }
+
+  it { is_expected.to respond_to :smb2_header }
+  it { is_expected.to respond_to :structure_size }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#smb2_header' do
+    subject(:header) { packet.smb2_header }
+
+    it 'is a standard SMB Header' do
+      expect(header).to be_a RubySMB::SMB2::SMB2Header
+    end
+
+    it 'should have the command set to SMB_COM_NEGOTIATE' do
+      expect(header.command).to eq RubySMB::SMB2::Commands::TREE_DISCONNECT
+    end
+
+    it 'should not have the response flag set' do
+      expect(header.flags.reply).to eq 0
+    end
+  end
+
+end

data/spec/lib/ruby_smb/smb2/packet/tree_disconnect_response_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+RSpec.describe RubySMB::SMB2::Packet::TreeDisconnectResponse do
+
+  subject(:packet) { described_class.new }
+
+  it { is_expected.to respond_to :smb2_header }
+  it { is_expected.to respond_to :structure_size }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#smb2_header' do
+    subject(:header) { packet.smb2_header }
+
+    it 'is a standard SMB Header' do
+      expect(header).to be_a RubySMB::SMB2::SMB2Header
+    end
+
+    it 'should have the command set to SMB_COM_NEGOTIATE' do
+      expect(header.command).to eq RubySMB::SMB2::Commands::TREE_DISCONNECT
+    end
+
+    it 'should have the response flag set' do
+      expect(header.flags.reply).to eq 1
+    end
+  end
+
+end

data/spec/lib/ruby_smb/smb2/tree_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+RSpec.describe RubySMB::SMB2::Tree do
+  let(:dispatcher) { RubySMB::Dispatcher::Socket.new(nil) }
+
+  let(:client) { RubySMB::Client.new(dispatcher, username: 'msfadmin', password: 'msfadmin') }
+  let(:tree_id) { 2049 }
+  let(:path) { '\\192.168.1.1\example' }
+  let(:response) {
+    packet = RubySMB::SMB2::Packet::TreeConnectResponse.new
+    packet.smb2_header.tree_id = tree_id
+    packet.maximal_access.read("\xff\x01\x1f\x00")
+    packet.share_type = 0x01
+    packet
+  }
+  subject(:tree) {
+    described_class.new(client:client, share:path, response:response )
+  }
+
+  it { is_expected.to respond_to :client }
+  it { is_expected.to respond_to :permissions }
+  it { is_expected.to respond_to :share }
+  it { is_expected.to respond_to :id }
+
+  it 'inherits the client that spawned it' do
+    expect(tree.client).to eq client
+  end
+
+  it 'inherits the permissions from the response packet' do
+    expect(tree.permissions).to eq response.maximal_access
+  end
+
+  it 'inherits the Tree id from the response packet' do
+    expect(tree.id).to eq response.smb2_header.tree_id
+  end
+
+  describe '#disconnect!' do
+    let(:disco_req) { RubySMB::SMB2::Packet::TreeDisconnectRequest.new }
+    let(:disco_resp) { RubySMB::SMB2::Packet::TreeDisconnectResponse.new }
+
+    it 'sends a TreeDisconnectRequest with the Tree ID in the header' do
+      allow(RubySMB::SMB2::Packet::TreeDisconnectRequest).to receive(:new).and_return(disco_req)
+      modified_req = disco_req
+      modified_req.smb2_header.tree_id = tree.id
+      expect(client).to receive(:send_recv).with(modified_req).and_return(disco_resp.to_binary_s)
+      tree.disconnect!
+    end
+
+    it 'returns the NTStatus code from the response' do
+      allow(client).to receive(:send_recv).and_return(disco_resp.to_binary_s)
+      expect(tree.disconnect!).to eq disco_resp.status_code
+    end
+  end
+end