ruby_smb 0.0.8

data/spec/lib/ruby_smb/dispatcher/socket_spec.rb

@@ -0,0 +1,60 @@
+RSpec.describe RubySMB::Dispatcher::Socket do
+  let(:fake_tcp_socket) { StringIO.new('deadbeef') }
+
+  subject(:smb_socket) { described_class.new(fake_tcp_socket) }
+  let(:negotiate_response) { RubySMB::SMB2::Packet::NegotiateResponse.new }
+  let(:nbss) { smb_socket.nbss(negotiate_response) }
+  let(:response_packet) { nbss + negotiate_response.to_binary_s }
+
+  # Don't try to actually select on our StringIO fake socket
+  before(:each) do
+    allow(IO).to receive(:select).and_return(nil)
+  end
+
+  describe '#connect' do
+    it 'should support setting a custom socket object' do
+      socket = described_class.connect('172.16.22.165', socket: fake_tcp_socket)
+      expect(socket.tcp_socket).to eq(fake_tcp_socket)
+    end
+
+    it 'should default to setting up a TCPSocket' do
+      host = '172.16.22.165'
+      port = 445
+      expect(TCPSocket).to receive(:new).with(host, port)
+      described_class.connect(host)
+    end
+  end
+
+  describe '#recv_packet' do
+    let(:blank_socket) { StringIO.new('') }
+    let(:response_socket) { StringIO.new(response_packet) }
+
+    describe 'when reading from the socket results in a nil value' do
+      it 'should raise Error::NetBiosSessionService' do
+        smb_socket.tcp_socket = blank_socket
+        expect { smb_socket.recv_packet }.to raise_error(::RubySMB::Error::NetBiosSessionService)
+      end
+    end
+
+    describe 'when reading an SMB Response packet' do
+      it 'reads a number of bytes defined in the nbss header' do
+        smb_socket.tcp_socket = response_socket
+        expect(response_socket).to receive(:read).with(4).and_call_original
+        expect(response_socket).to receive(:read).with(negotiate_response.do_num_bytes).and_call_original
+        smb_socket.recv_packet
+      end
+    end
+  end
+
+  describe '#send_packet' do
+    it 'calls nbss to create the nbss header for the packet' do
+      expect(smb_socket).to receive(:nbss).with(negotiate_response).and_return(nbss)
+      smb_socket.send_packet(negotiate_response)
+    end
+
+    it 'writes the packet to the socket' do
+      expect(fake_tcp_socket).to receive(:write).with(response_packet).and_call_original
+      smb_socket.send_packet(negotiate_response)
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+RSpec.describe RubySMB::Field::FileTime do
+  subject(:file_time) { described_class.read(binary_filetime) }
+
+  let(:binary_filetime) { "\x36\x32\xe8\xe0\xd2\xe4\xd0\x01" }
+  let(:int_filetime) { binary_filetime.unpack('Q<').first }
+  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 64-bit Integer' do
+      expect(file_time.val).to be_a BinData::Uint64le
+    end
+  end
+
+  describe '#get' do
+    it 'returns the expected integer value' do
+      expect(file_time.val).to eq int_filetime
+    end
+  end
+
+  describe '#to_time' do
+    it 'returns a Time object representing the correct time' do
+      expect(file_time.to_time).to eq time_filetime
+    end
+  end
+
+  describe '#to_datetime' do
+    it 'returns a DateTime object representing the correct time' do
+      expect(file_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/field/nt_status_spec.rb

@@ -0,0 +1,19 @@
+RSpec.describe RubySMB::Field::NtStatus do
+  subject(:nt_status) { described_class.new }
+
+  it { is_expected.to respond_to :to_nt_status }
+
+  it 'is a Unsigned 32-bit little endian integer' do
+    expect(nt_status).to be_a BinData::Uint32le
+  end
+
+  describe '#to_nt_status' do
+    it 'should return a WindowsError::ErrorCode' do
+      expect(nt_status.to_nt_status).to be_a WindowsError::ErrorCode
+    end
+
+    it 'should return the correct ErrorCode' do
+      expect(nt_status.to_nt_status).to eq WindowsError::NTStatus::STATUS_SUCCESS
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+RSpec.describe RubySMB::Field::Stringz16 do
+  subject(:stringz16) { described_class.new }
+
+  it 'starts as an empty string' do
+    expect(stringz16).to eq ""
+  end
+
+  context 'with a value already set' do
+    let(:abcd) { described_class.new("ABCD") }
+
+    it 'should be UTF-16le' do
+      expect(abcd).to eq "ABCD".encode("utf-16le")
+    end
+
+    it 'should include the NULL terminator on binary output' do
+      expect(abcd.to_binary_s).to eq "A\x00B\x00C\x00D\x00\x00\x00"
+    end
+  end
+
+  context 'with a null terminator in the middle' do
+    let(:null_terminator) { described_class.new("ABCD\x00EFG") }
+
+    it 'drops everything after the null terminator' do
+      expect(null_terminator).to eq "ABCD".encode("utf-16le")
+    end
+  end
+
+  context 'when reading data in' do
+
+    it 'stops at the first double null byte' do
+      io = StringIO.new("A\x00B\x00C\x00D\x00\x00\x00E\x00F\x00")
+      stringz16.read(io)
+      expect(stringz16.to_binary_s).to eq "A\x00B\x00C\x00D\x00\x00\x00"
+    end
+
+    it 'handles a zero length string' do
+      io = StringIO.new("\x00\x00A\x00")
+      stringz16.read(io)
+      expect(stringz16).to eq ""
+    end
+
+    it 'fails if no null terminator is found' do
+      io = StringIO.new("A\x00B\x00C\x00D\x00")
+      expect{ stringz16.read(io) }.to raise_error(EOFError)
+    end
+  end
+
+end

data/spec/lib/ruby_smb/generic_packet_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+RSpec.describe RubySMB::GenericPacket do
+
+  class TestPacket < RubySMB::GenericPacket
+    endian :little
+    uint8  :first_value,  initial_value: 0x01
+    uint16 :second_value, initial_value: 0x02
+    array  :array_value,  type: :dialect, read_until: :eof
+  end
+
+  class ParentTestPacket <  RubySMB::GenericPacket
+    endian :little
+    uint8  :header
+    test_packet :test_packet
+  end
+
+  subject(:test_packet) { TestPacket.new(first_value: 16, second_value: 4056, array_value: [RubySMB::SMB1::Dialect.new(dialect_string: 'test')]) }
+  let(:parent_packet) { ParentTestPacket.new }
+
+  describe '#describe class method' do
+    it 'outputs a string representing the structure of the packet' do
+      str = "\nFirst_value                   (Uint8)    \n"+
+      "Second_value                  (Uint16le) \n"+
+      "Array_value                   (Array)    "
+      expect(TestPacket.describe).to eq str
+    end
+
+    it 'handles nested record structures as well' do
+      str = "\nHeader                        (Uint8)    \n"+
+        "TEST_PACKET                              \n"+
+        "\tFirst_value                  (Uint8)    \n"+
+        "\tSecond_value                 (Uint16le) \n"+
+        "\tArray_value                  (Array)    "
+      expect(ParentTestPacket.describe).to eq str
+    end
+  end
+
+  describe '#display' do
+    it 'shows the actual contents of the packet fields' do
+      str = "\nFIRST_VALUE                   16\n" +
+      "SECOND_VALUE                  4056\n" +
+      "ARRAY_VALUE\n" +
+      "\tBuffer Format ID             2\n" +
+      "\tDialect Name                 test"
+      expect(test_packet.display).to eq str
+    end
+
+    it 'handles nested record structures as well' do
+      str = "\nHEADER                        0\n" +
+      "TEST_PACKET\n" +
+      "\tFirst_value                  1\n" +
+      "\tSecond_value                 2\n" +
+      "\tARRAY_VALUE"
+      expect(parent_packet.display).to eq str
+    end
+  end
+end

data/spec/lib/ruby_smb/smb1/andx_block_spec.rb

@@ -0,0 +1,41 @@
+RSpec.describe RubySMB::SMB1::AndXBlock do
+  subject(:andx_block) { described_class.new }
+
+  it { is_expected.to respond_to :andx_command }
+  it { is_expected.to respond_to :andx_reserved }
+  it { is_expected.to respond_to :andx_offset }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe 'andx_command' do
+    it 'should be a 8-bit field per the SMB spec' do
+      expect(andx_block.andx_command).to be_a BinData::Bit8
+    end
+
+    it 'should be hardcoded to SMB_COM_NO_ANDX_COMMAND by default per the SMB spec' do
+      expect(andx_block.andx_command).to eq RubySMB::SMB1::Commands::SMB_COM_NO_ANDX_COMMAND
+    end
+  end
+
+  describe 'andx_reserved' do
+    it 'should be a 8-bit field per the SMB spec' do
+      expect(andx_block.andx_reserved).to be_a BinData::Bit8
+    end
+
+    it 'should be hardcoded to 0 by default per the SMB spec' do
+      expect(andx_block.andx_reserved).to eq 0
+    end
+  end
+
+  describe 'andx_offset' do
+    it 'should be a 16-bit field per the SMB spec' do
+      expect(andx_block.andx_offset).to be_a BinData::Bit16
+    end
+
+    it 'should be hardcoded to 0 by default per the SMB spec' do
+      expect(andx_block.andx_offset).to eq 0
+    end
+  end
+end

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

@@ -0,0 +1,245 @@
+RSpec.describe RubySMB::SMB1::BitField::Capabilities do
+  subject(:capabilities) { described_class.new }
+
+  it { is_expected.to respond_to :level_2_oplocks }
+  it { is_expected.to respond_to :nt_status }
+  it { is_expected.to respond_to :rpc_remote_apis }
+  it { is_expected.to respond_to :nt_smbs }
+  it { is_expected.to respond_to :large_files }
+  it { is_expected.to respond_to :unicode }
+  it { is_expected.to respond_to :mpx_mode }
+  it { is_expected.to respond_to :raw_mode }
+  it { is_expected.to respond_to :large_writex }
+  it { is_expected.to respond_to :large_readx }
+  it { is_expected.to respond_to :info_level_passthru }
+  it { is_expected.to respond_to :dfs }
+  it { is_expected.to respond_to :reserved1 }
+  it { is_expected.to respond_to :bulk_transfer }
+  it { is_expected.to respond_to :nt_find }
+  it { is_expected.to respond_to :lock_and_read }
+  it { is_expected.to respond_to :unix }
+  it { is_expected.to respond_to :reserved2 }
+  it { is_expected.to respond_to :lwio }
+  it { is_expected.to respond_to :extended_security }
+  it { is_expected.to respond_to :reserved3 }
+  it { is_expected.to respond_to :dynamic_reauth }
+  it { is_expected.to respond_to :reserved4 }
+  it { is_expected.to respond_to :compressed_data }
+  it { is_expected.to respond_to :reserved5 }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#level_2_oplocks' do
+    it 'is a 1-bit flag' do
+      expect(capabilities.level_2_oplocks).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :level_2_oplocks, 'V', 0x00000080
+  end
+
+  describe '#nt_status' do
+    it 'is a 1-bit flag' do
+      expect(capabilities.nt_status).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :nt_status, 'V', 0x00000040
+  end
+
+  describe '#rpc_remote_apis' do
+    it 'is a 1-bit flag' do
+      expect(capabilities.rpc_remote_apis).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :rpc_remote_apis, 'V', 0x00000020
+  end
+
+  describe '#nt_smbs' do
+    it 'is a 1-bit flag' do
+      expect(capabilities.nt_smbs).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :nt_smbs, 'V', 0x00000010
+  end
+
+  describe '#large_files' do
+    it 'is a 1-bit flag' do
+      expect(capabilities.large_files).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :large_files, 'V', 0x00000008
+  end
+
+  describe '#unicode' do
+    it 'is a 1-bit flag' do
+      expect(capabilities.unicode).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :unicode, 'V', 0x00000004
+  end
+
+  describe '#mpx_mode' do
+    it 'is a 1-bit flag' do
+      expect(capabilities.mpx_mode).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :mpx_mode, 'V', 0x00000002
+  end
+
+  describe '#raw_mode' do
+    it 'is a 1-bit flag' do
+      expect(capabilities.raw_mode).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :raw_mode, 'V', 0x00000001
+  end
+
+  describe '#large_writex' do
+    it 'is a 1-bit flag' do
+      expect(capabilities.large_writex).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :large_writex, 'V', 0x00008000
+  end
+
+  describe '#large_readx' do
+    it 'is a 1-bit flag' do
+      expect(capabilities.large_readx).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :large_readx, 'V', 0x00004000
+  end
+
+  describe '#info_level_passthru' do
+    it 'is a 1-bit flag' do
+      expect(capabilities.info_level_passthru).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :info_level_passthru, 'V', 0x00002000
+  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', 0x00001000
+  end
+
+  describe '#reserved1' do
+    it 'is a 1-bit flag' do
+      expect(capabilities.reserved1).to be_a BinData::Bit1
+    end
+
+    it 'should have a default value of 0' do
+      expect(capabilities.reserved1).to eq 0
+    end
+  end
+
+  describe '#bulk_transfer' do
+    it 'is a 1-bit flag' do
+      expect(capabilities.bulk_transfer).to be_a BinData::Bit1
+    end
+
+    it 'should have a default value of 0' do
+      expect(capabilities.bulk_transfer).to eq 0
+    end
+  end
+
+  describe '#nt_find' do
+    it 'is a 1-bit flag' do
+      expect(capabilities.nt_find).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :nt_find, 'V', 0x00000200
+  end
+
+  describe '#lock_and_read' do
+    it 'is a 1-bit flag' do
+      expect(capabilities.lock_and_read).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :lock_and_read, 'V', 0x00000100
+  end
+
+  describe '#unix' do
+    it 'is a 1-bit flag' do
+      expect(capabilities.unix).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :unix, 'V', 0x00800000
+  end
+
+  describe '#reserved2' do
+    it 'is a 6-bit reserved space' do
+      expect(capabilities.reserved2).to be_a BinData::Bit6
+    end
+
+    it 'should have a default value of 0' do
+      expect(capabilities.reserved2).to eq 0
+    end
+  end
+
+  describe '#lwio' do
+    it 'is a 1-bit flag' do
+      expect(capabilities.lwio).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :lwio, 'V', 0x00010000
+  end
+
+  describe '#extended_security' do
+    it 'is a 1-bit flag' do
+      expect(capabilities.extended_security).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :extended_security, 'V', 0x80000000
+  end
+
+  describe '#reserved3' do
+    it 'is a 1-bit flag' do
+      expect(capabilities.reserved3).to be_a BinData::Bit1
+    end
+
+    it 'should have a default value of 0' do
+      expect(capabilities.reserved3).to eq 0
+    end
+  end
+
+  describe '#dynamic_reauth' do
+    it 'is a 1-bit flag' do
+      expect(capabilities.dynamic_reauth).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :dynamic_reauth, 'V', 0x20000000
+  end
+
+  describe '#reserved4' do
+    it 'is a 3-bit reserved space' do
+      expect(capabilities.reserved4).to be_a BinData::Bit3
+    end
+
+    it 'should have a default value of 0' do
+      expect(capabilities.reserved1).to eq 0
+    end
+  end
+
+  describe '#compressed_data' do
+    it 'is a 1-bit flag' do
+      expect(capabilities.compressed_data).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :compressed_data, 'V', 0x02000000
+  end
+
+  describe '#reserved5' do
+    it 'is a 1-bit flag' do
+      expect(capabilities.reserved5).to be_a BinData::Bit1
+    end
+
+    it 'should have a default value of 0' do
+      expect(capabilities.reserved5).to eq 0
+    end
+  end
+end

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

@@ -0,0 +1,146 @@
+RSpec.describe RubySMB::SMB1::BitField::HeaderFlags2 do
+  subject(:flags2) { described_class.new }
+
+  it { is_expected.to respond_to :unicode }
+  it { is_expected.to respond_to :nt_status }
+  it { is_expected.to respond_to :paging_io }
+  it { is_expected.to respond_to :dfs }
+  it { is_expected.to respond_to :extended_security }
+  it { is_expected.to respond_to :reparse_path }
+  it { is_expected.to respond_to :reserved1 }
+  it { is_expected.to respond_to :is_long_name }
+  it { is_expected.to respond_to :reserved2 }
+  it { is_expected.to respond_to :signature_required }
+  it { is_expected.to respond_to :compressed }
+  it { is_expected.to respond_to :security_signature }
+  it { is_expected.to respond_to :eas }
+  it { is_expected.to respond_to :long_names }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe 'unicode' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags2.unicode).to be_a BinData::Bit1
+    end
+
+    it 'should have a default value of 0' do
+      expect(flags2.unicode).to eq 0
+    end
+
+    it_behaves_like 'bit field with one flag set', :unicode, 'v', 0x8000
+  end
+
+  describe 'nt_status' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags2.nt_status).to be_a BinData::Bit1
+    end
+
+    it 'should have a default value of 1' do
+      expect(flags2.nt_status).to eq 1
+    end
+
+    it_behaves_like 'bit field with one flag set', :nt_status, 'v', 0x4000
+  end
+
+  describe 'paging_io' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags2.paging_io).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :paging_io, 'v', 0x2000
+  end
+
+  describe 'dfs' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags2.dfs).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :dfs, 'v', 0x1000
+  end
+
+  describe 'extended_security' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags2.extended_security).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :extended_security, 'v', 0x0800
+  end
+
+  describe 'reparse_path' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags2.reparse_path).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :reparse_path, 'v', 0x0400
+  end
+
+  describe 'reserved1' do
+    it 'should be a 3-bit field per the SMB spec' do
+      expect(flags2.reserved1).to be_a BinData::Bit1
+    end
+
+    it 'should have a default value of 0' do
+      expect(flags2.reserved1).to eq 0
+    end
+  end
+
+  describe 'is_long_name' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags2.is_long_name).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :is_long_name, 'v', 0x0040
+  end
+
+  describe 'reserved2' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags2.reserved2).to be_a BinData::Bit1
+    end
+
+    it 'should have a default value of 0' do
+      expect(flags2.reserved2).to eq 0
+    end
+  end
+
+  describe 'signature_required' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags2.signature_required).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :signature_required, 'v', 0x0010
+  end
+
+  describe 'compressed' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags2.compressed).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :compressed, 'v', 0x0008
+  end
+
+  describe 'security_signature' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags2.security_signature).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :security_signature, 'v', 0x0004
+  end
+
+  describe 'eas' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags2.eas).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :eas, 'v', 0x0002
+  end
+
+  describe 'long_names' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags2.long_names).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :long_names, 'v', 0x0001
+  end
+end