ruby_smb 0.0.12 → 0.0.13

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

@@ -0,0 +1,194 @@
+require 'spec_helper'
+
+RSpec.describe RubySMB::Field::SecurityDescriptor do
+  subject(:descriptor) {
+    struct = described_class.new
+    struct.owner_sid = 'ABCD'
+    struct.group_sid = 'ABCD'
+    struct.sacl      = 'ABCD'
+    struct.dacl      = 'ABCD'
+    struct
+  }
+
+  it { is_expected.to respond_to :revision }
+  it { is_expected.to respond_to :sbz1 }
+  it { is_expected.to respond_to :control }
+  it { is_expected.to respond_to :offset_owner }
+  it { is_expected.to respond_to :offset_group }
+  it { is_expected.to respond_to :offset_sacl }
+  it { is_expected.to respond_to :offset_dacl }
+  it { is_expected.to respond_to :owner_sid }
+  it { is_expected.to respond_to :group_sid }
+  it { is_expected.to respond_to :sacl }
+  it { is_expected.to respond_to :dacl }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  it 'tracks the offset to the #owner_sid' do
+    expect(descriptor.offset_owner).to eq descriptor.owner_sid.rel_offset
+  end
+
+  it 'tracks the offset to the #group_sid' do
+    expect(descriptor.offset_group).to eq descriptor.group_sid.rel_offset
+  end
+
+  it 'tracks the offset to the #sacl' do
+    expect(descriptor.offset_sacl).to eq descriptor.sacl.rel_offset
+  end
+
+  it 'tracks the offset to the #dacl' do
+    expect(descriptor.offset_dacl).to eq descriptor.dacl.rel_offset
+  end
+
+  describe '#control' do
+    subject(:control) { descriptor.control }
+
+    it { is_expected.to respond_to :owner_defaulted }
+    it { is_expected.to respond_to :group_defaulted }
+    it { is_expected.to respond_to :dacl_present }
+    it { is_expected.to respond_to :dacl_defaulted }
+    it { is_expected.to respond_to :sacl_present }
+    it { is_expected.to respond_to :sacl_defaulted }
+    it { is_expected.to respond_to :server_security }
+    it { is_expected.to respond_to :dacl_trusted }
+    it { is_expected.to respond_to :dacl_computed_inheritance }
+    it { is_expected.to respond_to :sacl_computed_inheritance }
+    it { is_expected.to respond_to :dacl_auto_inherited }
+    it { is_expected.to respond_to :sacl_auto_inherited }
+    it { is_expected.to respond_to :dacl_protected }
+    it { is_expected.to respond_to :sacl_protected }
+    it { is_expected.to respond_to :rm_control_valid }
+    it { is_expected.to respond_to :self_relative }
+
+    describe '#self_relative' do
+      it 'is a 1-bit flag' do
+        expect(control.self_relative).to be_a BinData::Bit1
+      end
+
+      it_behaves_like 'bit field with one flag set', :self_relative, 'v', 0x0001
+    end
+
+    describe '#rm_control_valid' do
+      it 'is a 1-bit flag' do
+        expect(control.rm_control_valid).to be_a BinData::Bit1
+      end
+
+      it_behaves_like 'bit field with one flag set', :rm_control_valid, 'v', 0x0002
+    end
+
+    describe '#sacl_protected' do
+      it 'is a 1-bit flag' do
+        expect(control.sacl_protected).to be_a BinData::Bit1
+      end
+
+      it_behaves_like 'bit field with one flag set', :sacl_protected, 'v', 0x0004
+    end
+
+    describe '#dacl_protected' do
+      it 'is a 1-bit flag' do
+        expect(control.dacl_protected).to be_a BinData::Bit1
+      end
+
+      it_behaves_like 'bit field with one flag set', :dacl_protected, 'v', 0x0008
+    end
+
+    describe '#sacl_auto_inherited' do
+      it 'is a 1-bit flag' do
+        expect(control.sacl_auto_inherited).to be_a BinData::Bit1
+      end
+
+      it_behaves_like 'bit field with one flag set', :sacl_auto_inherited, 'v', 0x0010
+    end
+
+    describe '#dacl_auto_inherited' do
+      it 'is a 1-bit flag' do
+        expect(control.dacl_auto_inherited).to be_a BinData::Bit1
+      end
+
+      it_behaves_like 'bit field with one flag set', :dacl_auto_inherited, 'v', 0x0020
+    end
+
+    describe '#sacl_computed_inheritance' do
+      it 'is a 1-bit flag' do
+        expect(control.sacl_computed_inheritance).to be_a BinData::Bit1
+      end
+
+      it_behaves_like 'bit field with one flag set', :sacl_computed_inheritance, 'v', 0x0040
+    end
+
+    describe '#dacl_computed_inheritance' do
+      it 'is a 1-bit flag' do
+        expect(control.dacl_computed_inheritance).to be_a BinData::Bit1
+      end
+
+      it_behaves_like 'bit field with one flag set', :dacl_computed_inheritance, 'v', 0x0080
+    end
+
+    describe '#dacl_trusted' do
+      it 'is a 1-bit flag' do
+        expect(control.dacl_trusted).to be_a BinData::Bit1
+      end
+
+      it_behaves_like 'bit field with one flag set', :dacl_trusted, 'v', 0x0100
+    end
+
+    describe '#server_security' do
+      it 'is a 1-bit flag' do
+        expect(control.server_security).to be_a BinData::Bit1
+      end
+
+      it_behaves_like 'bit field with one flag set', :server_security, 'v', 0x0200
+    end
+
+    describe '#sacl_defaulted' do
+      it 'is a 1-bit flag' do
+        expect(control.sacl_defaulted).to be_a BinData::Bit1
+      end
+
+      it_behaves_like 'bit field with one flag set', :sacl_defaulted, 'v', 0x0400
+    end
+
+    describe '#sacl_present' do
+      it 'is a 1-bit flag' do
+        expect(control.sacl_present).to be_a BinData::Bit1
+      end
+
+      it_behaves_like 'bit field with one flag set', :sacl_present, 'v', 0x0800
+    end
+
+    describe '#dacl_defaulted' do
+      it 'is a 1-bit flag' do
+        expect(control.dacl_defaulted).to be_a BinData::Bit1
+      end
+
+      it_behaves_like 'bit field with one flag set', :dacl_defaulted, 'v', 0x1000
+    end
+
+    describe '#dacl_present' do
+      it 'is a 1-bit flag' do
+        expect(control.dacl_present).to be_a BinData::Bit1
+      end
+
+      it_behaves_like 'bit field with one flag set', :dacl_present, 'v', 0x2000
+    end
+
+    describe '#group_defaulted' do
+      it 'is a 1-bit flag' do
+        expect(control.group_defaulted).to be_a BinData::Bit1
+      end
+
+      it_behaves_like 'bit field with one flag set', :group_defaulted, 'v', 0x4000
+    end
+
+    describe '#owner_defaulted' do
+      it 'is a 1-bit flag' do
+        expect(control.owner_defaulted).to be_a BinData::Bit1
+      end
+
+      it_behaves_like 'bit field with one flag set', :owner_defaulted, 'v', 0x8000
+    end
+  end
+end
+

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

@@ -0,0 +1,38 @@
+RSpec.describe RubySMB::Field::SmbFeaList do
+  subject(:list) { described_class.new }
+  let(:fea1)  {
+    fea = RubySMB::Field::SmbFea.new
+    fea.attribute_name  = 'foo'
+    fea.attribute_value = 'bar'
+    fea
+  }
+  let(:fea2)  {
+    fea = RubySMB::Field::SmbFea.new
+    fea.attribute_name  = 'hello world'
+    fea.attribute_value = 'this is a test'
+    fea
+  }
+
+
+  it { is_expected.to respond_to :size_of_list }
+  it { is_expected.to respond_to :fea_list }
+
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#size_of_list' do
+    it 'shows the size, in bytes, of the fea_list' do
+      list.fea_list << fea1
+      expect(list.size_of_list).to eq fea1.do_num_bytes
+    end
+
+    it 'changes dynamically as new FEAs are added' do
+      list.fea_list << fea1
+      expect(list.size_of_list).to eq fea1.do_num_bytes
+      list.fea_list << fea2
+      expect(list.size_of_list).to eq (fea1.do_num_bytes + fea2.do_num_bytes )
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+RSpec.describe RubySMB::Field::SmbFea do
+  subject(:fea) { described_class.new }
+
+  it { is_expected.to respond_to :ea_flag }
+  it { is_expected.to respond_to :attribute_name_length }
+  it { is_expected.to respond_to :attribute_value_length }
+  it { is_expected.to respond_to :attribute_name }
+  it { is_expected.to respond_to :attribute_value }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#attribute_name_length' do
+    it 'reflects the size of the attribute_name field' do
+      fea.attribute_name = 'TEST'
+      expect(fea.attribute_name_length).to eq 4
+    end
+  end
+
+  describe '#attribute_value_length' do
+    it 'reflects the size of the attribute_value field' do
+      fea.attribute_value = 'TEST'
+      expect(fea.attribute_value_length).to eq 4
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+RSpec.describe RubySMB::Field::Utime do
+  subject(:time) { described_class.read(binary_filetime) }
+
+  let(:binary_filetime) { "\x94\xD1\xE5U" }
+  let(:int_filetime) { time_filetime.to_i }
+  let(:str_filetime) { '2015-09-01T11:25:56-05:00' }
+  let(:time_filetime) { Time.parse str_filetime }
+  let(:datetime_filetime) { time_filetime.to_datetime }
+
+  it { is_expected.to respond_to :val }
+  it { is_expected.to respond_to :get }
+  it { is_expected.to respond_to :set }
+  it { is_expected.to respond_to :to_time }
+  it { is_expected.to respond_to :to_datetime }
+
+  describe '#val' do
+    it 'should b an Unsigned 32-bit Integer' do
+      expect(time.val).to be_a BinData::Uint32le
+    end
+  end
+
+  describe '#get' do
+    it 'returns the expected integer value' do
+      expect(time.val).to eq int_filetime
+    end
+  end
+
+  describe '#to_time' do
+    it 'returns a Time object representing the correct time' do
+      expect(time.to_time).to eq time_filetime
+    end
+  end
+
+  describe '#to_datetime' do
+    it 'returns a DateTime object representing the correct time' do
+      expect(time.to_datetime).to eq datetime_filetime
+    end
+  end
+
+  describe '#set' do
+    subject(:empty_filetime) { described_class.new }
+    it 'will take a Time object correctly but lose Nanoseconds' do
+      empty_filetime.set time_filetime
+      val = empty_filetime.get
+      expect(val / 10_000_000).to eq (int_filetime / 10_000_000)
+    end
+
+    it 'will take a DateTime object correctly but lose Nanoseconds' do
+      empty_filetime.set datetime_filetime
+      val = empty_filetime.get
+      expect(val / 10_000_000).to eq (int_filetime / 10_000_000)
+    end
+
+    it 'will accept a raw integer value and set it' do
+      empty_filetime.set int_filetime
+      expect(empty_filetime.get).to eq int_filetime
+    end
+  end
+end

data/spec/lib/ruby_smb/smb1/bit_field/create_options_spec.rb

@@ -0,0 +1,181 @@
+require 'spec_helper'
+
+RSpec.describe RubySMB::SMB1::BitField::CreateOptions do
+  subject(:options) { described_class.new }
+
+  it { is_expected.to respond_to :create_tree_connection }
+  it { is_expected.to respond_to :non_directory_file }
+  it { is_expected.to respond_to :synchronous_io_nonalert }
+  it { is_expected.to respond_to :synchronous_io_alert }
+  it { is_expected.to respond_to :no_intermediate_buffer }
+  it { is_expected.to respond_to :sequential_only }
+  it { is_expected.to respond_to :write_through }
+  it { is_expected.to respond_to :directory_file }
+  it { is_expected.to respond_to :no_compression }
+  it { is_expected.to respond_to :open_for_backup_intent }
+  it { is_expected.to respond_to :open_by_file_id }
+  it { is_expected.to respond_to :delete_on_close }
+  it { is_expected.to respond_to :random_access }
+  it { is_expected.to respond_to :open_for_recovery }
+  it { is_expected.to respond_to :no_ea_knowledge }
+  it { is_expected.to respond_to :complete_if_oplocked }
+  it { is_expected.to respond_to :open_for_free_space_query }
+  it { is_expected.to respond_to :open_no_recall }
+  it { is_expected.to respond_to :reserve_opfilter }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#create_tree_connection' do
+    it 'is a 1-bit flag' do
+      expect(options.create_tree_connection).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :create_tree_connection, 'V', 0x00000080
+  end
+
+  describe '#non_directory_file' do
+    it 'is a 1-bit flag' do
+      expect(options.non_directory_file).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :non_directory_file, 'V', 0x00000040
+  end
+
+  describe '#synchronous_io_nonalert' do
+    it 'is a 1-bit flag' do
+      expect(options.synchronous_io_nonalert).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :synchronous_io_nonalert, 'V', 0x00000020
+  end
+
+  describe '#synchronous_io_alert' do
+    it 'is a 1-bit flag' do
+      expect(options.synchronous_io_alert).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :synchronous_io_alert, 'V', 0x00000010
+  end
+
+  describe '#no_intermediate_buffer' do
+    it 'is a 1-bit flag' do
+      expect(options.no_intermediate_buffer).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :no_intermediate_buffer, 'V', 0x00000008
+  end
+
+  describe '#sequential_only' do
+    it 'is a 1-bit flag' do
+      expect(options.sequential_only).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :sequential_only, 'V', 0x00000004
+  end
+
+  describe '#write_through' do
+    it 'is a 1-bit flag' do
+      expect(options.write_through).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :write_through, 'V', 0x00000002
+  end
+
+  describe '#directory_file' do
+    it 'is a 1-bit flag' do
+      expect(options.directory_file).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :directory_file, 'V', 0x00000001
+  end
+
+  describe '#no_compression' do
+    it 'is a 1-bit flag' do
+      expect(options.no_compression).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :no_compression, 'V', 0x00008000
+  end
+
+  describe '#open_for_backup_intent' do
+    it 'is a 1-bit flag' do
+      expect(options.open_for_backup_intent).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :open_for_backup_intent, 'V', 0x00004000
+  end
+
+  describe '#open_by_file_id' do
+    it 'is a 1-bit flag' do
+      expect(options.open_by_file_id).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :open_by_file_id, 'V', 0x00002000
+  end
+
+  describe '#delete_on_close' do
+    it 'is a 1-bit flag' do
+      expect(options.delete_on_close).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :delete_on_close, 'V', 0x00001000
+  end
+
+  describe '#random_access' do
+    it 'is a 1-bit flag' do
+      expect(options.random_access).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :random_access, 'V', 0x00000800
+  end
+
+  describe '#open_for_recovery' do
+    it 'is a 1-bit flag' do
+      expect(options.open_for_recovery).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :open_for_recovery, 'V', 0x00000400
+  end
+
+  describe '#no_ea_knowledge' do
+    it 'is a 1-bit flag' do
+      expect(options.no_ea_knowledge).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :no_ea_knowledge, 'V', 0x00000200
+  end
+
+  describe '#complete_if_oplocked' do
+    it 'is a 1-bit flag' do
+      expect(options.complete_if_oplocked).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :complete_if_oplocked, 'V', 0x00000100
+  end
+
+  describe '#open_for_free_space_query' do
+    it 'is a 1-bit flag' do
+      expect(options.open_for_free_space_query).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :open_for_free_space_query, 'V', 0x00800000
+  end
+
+  describe '#open_no_recall' do
+    it 'is a 1-bit flag' do
+      expect(options.open_no_recall).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :open_no_recall, 'V', 0x00400000
+  end
+
+  describe '#reserve_opfilter' do
+    it 'is a 1-bit flag' do
+      expect(options.reserve_opfilter).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :reserve_opfilter, 'V', 0x00100000
+  end
+end

data/spec/lib/ruby_smb/smb1/bit_field/open2_access_mode_spec.rb

@@ -0,0 +1,81 @@
+RSpec.describe RubySMB::SMB1::BitField::Open2AccessMode do
+  subject(:flags) { described_class.new }
+
+  it { is_expected.to respond_to :sharing_mode }
+  it { is_expected.to respond_to :access_mode }
+  it { is_expected.to respond_to :writethrough }
+  it { is_expected.to respond_to :cache_mode }
+  it { is_expected.to respond_to :reference_locality }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe 'access_mode' do
+    it 'should be a 3-bit field per the SMB spec' do
+      expect(flags.access_mode).to be_a BinData::Bit3
+    end
+
+    it_behaves_like 'bit field with one flag set', :access_mode, 'v', 0x0001
+  end
+
+  describe 'sharing_mode' do
+    it 'should be a 3-bit field per the SMB spec' do
+      expect(flags.sharing_mode).to be_a BinData::Bit3
+    end
+
+    it_behaves_like 'bit field with one flag set', :sharing_mode, 'v', 0x0010
+  end
+
+  describe 'reference_locality' do
+    it 'should be a 3-bit field per the SMB spec' do
+      expect(flags.reference_locality).to be_a BinData::Bit3
+    end
+
+    it_behaves_like 'bit field with one flag set', :reference_locality, 'v', 0x0100
+  end
+
+  describe 'cache_mode' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.cache_mode).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :cache_mode, 'v', 0x1000
+  end
+
+  describe 'writethrough' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.writethrough).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :writethrough, 'v', 0x4000
+  end
+
+  describe '#set_access_mode' do
+    it 'sets access mode to 0 when given :r' do
+      flags.set_access_mode :r
+      expect(flags.access_mode).to eq 0
+    end
+
+    it 'sets access mode to 1 when given :w' do
+      flags.set_access_mode :w
+      expect(flags.access_mode).to eq 1
+    end
+
+    it 'sets access mode to 2 when given :rw' do
+      flags.set_access_mode :rw
+      expect(flags.access_mode).to eq 2
+    end
+
+    it 'sets access mode to 3 when given :x' do
+      flags.set_access_mode :r
+      expect(flags.access_mode).to eq 0
+    end
+
+    it 'raises an ArgumentError if given an invalid mode' do
+      expect{flags.set_access_mode('abcd')}.to raise_error(ArgumentError)
+    end
+  end
+
+
+end

data/spec/lib/ruby_smb/smb1/bit_field/open2_flags_spec.rb

@@ -0,0 +1,62 @@
+RSpec.describe RubySMB::SMB1::BitField::Open2Flags do
+  subject(:flags) { described_class.new }
+
+  it { is_expected.to respond_to :req_easize }
+  it { is_expected.to respond_to :req_opbatch }
+  it { is_expected.to respond_to :req_oplock }
+  it { is_expected.to respond_to :req_attrib }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe 'req_attrib' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.req_attrib).to be_a BinData::Bit1
+    end
+
+    it 'should have a default value of 1' do
+      expect(flags.req_attrib).to eq 1
+    end
+
+    it_behaves_like 'bit field with one flag set', :req_attrib, 'v', 0x0001
+  end
+
+  describe 'req_oplock' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.req_oplock).to be_a BinData::Bit1
+    end
+
+    it 'should have a default value of 0' do
+      expect(flags.req_oplock).to eq 0
+    end
+
+    it_behaves_like 'bit field with one flag set', :req_oplock, 'v', 0x0002
+  end
+
+  describe 'req_opbatch' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.req_opbatch).to be_a BinData::Bit1
+    end
+
+    it 'should have a default value of 0' do
+      expect(flags.req_opbatch).to eq 0
+    end
+
+    it_behaves_like 'bit field with one flag set', :req_opbatch, 'v', 0x0004
+  end
+
+  describe 'req_easize' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.req_easize).to be_a BinData::Bit1
+    end
+
+    it 'should have a default value of 1' do
+      expect(flags.req_easize).to eq 1
+    end
+
+    it_behaves_like 'bit field with one flag set', :req_easize, 'v', 0x0008
+  end
+
+
+end

data/spec/lib/ruby_smb/smb1/bit_field/open2_open_mode_spec.rb

@@ -0,0 +1,27 @@
+RSpec.describe RubySMB::SMB1::BitField::Open2OpenMode do
+  subject(:flags) { described_class.new }
+
+  it { is_expected.to respond_to :file_exists_opts }
+  it { is_expected.to respond_to :create_file }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe 'file_exists_opts' do
+    it 'should be a 2-bit field per the SMB spec' do
+      expect(flags.file_exists_opts).to be_a BinData::Bit2
+    end
+
+    it_behaves_like 'bit field with one flag set', :file_exists_opts, 'v', 0x0001
+  end
+
+  describe 'create_file' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.create_file).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :create_file, 'v', 0x0010
+  end
+
+end