ruby_smb 0.0.8 → 0.0.9

data/lib/ruby_smb/smb2/packet/tree_connect_response.rb

@@ -0,0 +1,50 @@
+module RubySMB
+  module SMB2
+    module Packet
+
+      # An SMB2 TreeConnectResponse Packet as defined in
+      # [2.2.10 SMB2 TREE_CONNECT Response](https://msdn.microsoft.com/en-us/library/cc246499.aspx)
+      class TreeConnectResponse < RubySMB::GenericPacket
+        endian  :little
+        smb2_header           :smb2_header
+        uint16                :structure_size, label: 'Structure Size', initial_value: 16
+        uint8                 :share_type,     label: 'Share Type',     initial_value: 0x01
+        uint8                 :reserved,       label: 'Reserved Space', initial_value: 0x00
+        share_flags           :share_flags
+        share_capabilities    :capabilities
+        directory_access_mask :maximal_access, label: 'Maximal Access'
+
+        def initialize_instance
+          super
+          smb2_header.command = RubySMB::SMB2::Commands::TREE_CONNECT
+          smb2_header.flags.reply = 1
+        end
+
+        # Returns the ACCESS_MASK for the Maximal Share Access Rights. The packet
+        # defaults this to a {RubySMB::SMB2::BitField::DirectoryAccessMask}. If it is anything other than
+        # a directory that has been connected to, it will re-cast it as a {RubySMB::SMB2::BitField::FileAccessMask}
+        #
+        # @return [RubySMB::SMB2::BitField::DirectoryAccessMask] if a directory was connected to
+        # @return [RubySMB::SMB2::BitField::FileAccessMask] if anything else was connected to
+        def access_rights
+          if is_directory?
+            self.maximal_access
+          else
+            mask = self.maximal_access.to_binary_s
+            RubySMB::SMB2::BitField::FileAccessMask.read(mask)
+          end
+        end
+
+        # Checks if the remote Tree is a directory
+        #
+        # @return [Boolean]
+        def is_directory?
+          self.share_type == 0x01
+        end
+
+
+
+      end
+    end
+  end
+end

data/lib/ruby_smb/smb2/packet/tree_disconnect_request.rb

@@ -0,0 +1,21 @@
+module RubySMB
+  module SMB2
+    module Packet
+
+      # An SMB2 TreeDisconnectRequest Packet as defined in
+      # [2.2.11 SMB2 TREE_DISCONNECT Request](https://msdn.microsoft.com/en-us/library/cc246500.aspx)
+      class TreeDisconnectRequest < RubySMB::GenericPacket
+        endian       :little
+        smb2_header  :smb2_header
+        uint16       :structure_size, label: 'Structure Size', initial_value: 4
+
+
+        def initialize_instance
+          super
+          smb2_header.command = RubySMB::SMB2::Commands::TREE_DISCONNECT
+        end
+
+      end
+    end
+  end
+end

data/lib/ruby_smb/smb2/packet/tree_disconnect_response.rb

@@ -0,0 +1,22 @@
+module RubySMB
+  module SMB2
+    module Packet
+
+      # An SMB2 TreeDisconnectResponse Packet as defined in
+      # [2.2.12 SMB2 TREE_DISCONNECT Response](https://msdn.microsoft.com/en-us/library/cc246501.aspx)
+      class TreeDisconnectResponse < RubySMB::GenericPacket
+        endian       :little
+        smb2_header  :smb2_header
+        uint16       :structure_size, label: 'Structure Size', initial_value: 4
+
+
+        def initialize_instance
+          super
+          smb2_header.command = RubySMB::SMB2::Commands::TREE_DISCONNECT
+          smb2_header.flags.reply = 1
+        end
+
+      end
+    end
+  end
+end

data/lib/ruby_smb/smb2/smb2_header.rb

@@ -11,9 +11,9 @@ module RubySMB
       uint16              :command,           label: 'Command'
       uint16              :credits,           label: 'Credit Request/Response'
       smb2_header_flags   :flags,             label: 'Flags'
-      uint32              :next_command,      label: 'Command Chain Offset', initial_value: 0
-      uint64              :message_id,        label: 'Message ID'
-      uint32              :process_id,        label: 'Process ID', initial_value: 0x0000feff
+      uint32              :next_command,      label: 'Command Chain Offset',   initial_value: 0
+      uint64              :message_id,        label: 'Message ID',             initial_value: 0
+      uint32              :process_id,        label: 'Process ID',             initial_value: 0x0000feff
       uint32              :tree_id,           label: 'Tree ID'
       uint64              :session_id,        label: 'Session ID'
       string              :signature,         label: 'Signature', length: 16

data/lib/ruby_smb/smb2/tree.rb

@@ -0,0 +1,51 @@
+module RubySMB
+  module SMB2
+
+    # An SMB2 connected remote Tree, as returned by a
+    # [RubySMB::SMB2::Packet::TreeConnectRequest]
+    class Tree
+
+      # The client this Tree is connected through
+      # @!attribute [rw] client
+      #   @return [RubySMB::Client]
+      attr_accessor :client
+
+      # The current Maximal Share Permissions
+      # @!attribute [rw] permissions
+      #   @return [RubySMB::SMB2::BitField::DirectoryAccessMask]
+      attr_accessor :permissions
+
+      # The share path associated with this Tree
+      # @!attribute [rw] share
+      #   @return [String]
+      attr_accessor :share
+
+      # The Tree ID for this Tree
+      # @!attribute [rw] id
+      #   @return [Integer]
+      attr_accessor :id
+
+      def initialize(client:, share:, response:)
+        @client             = client
+        @share              = share
+        @id                 = response.smb2_header.tree_id
+        @permissions        = response.maximal_access
+      end
+
+      # Disconnects this Tree from the current session
+      #
+      # @return [WindowsError::ErrorCode] the NTStatus sent back by the server.
+      def disconnect!
+        request = RubySMB::SMB2::Packet::TreeDisconnectRequest.new
+        request.smb2_header.tree_id = self.id
+        request.smb2_header.credit_charge = 1
+        request.smb2_header.credits = 256
+        raw_response = self.client.send_recv(request)
+        response = RubySMB::SMB2::Packet::TreeDisconnectResponse.read(raw_response)
+        response.status_code
+      end
+
+
+    end
+  end
+end

data/lib/ruby_smb/version.rb

@@ -1,3 +1,3 @@
 module RubySMB
-  VERSION = '0.0.8'.freeze
+  VERSION = '0.0.9'
 end

data/ruby_smb.gemspec

@@ -31,7 +31,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'yard'
 
-  spec.add_runtime_dependency 'rubyntlm', '~> 0.5'
+  spec.add_runtime_dependency 'rubyntlm'
   spec.add_runtime_dependency 'bit-struct'
   spec.add_runtime_dependency 'windows_error'
   spec.add_runtime_dependency 'bindata'

data/spec/lib/ruby_smb/client_spec.rb

@@ -49,8 +49,8 @@ RSpec.describe RubySMB::Client do
   end
 
   describe '#send_recv' do
-    let(:smb1_request) { RubySMB::SMB1::Packet::SessionSetupRequest.new }
-    let(:smb2_request) { RubySMB::SMB2::Packet::SessionSetupRequest.new }
+    let(:smb1_request) { RubySMB::SMB1::Packet::TreeConnectRequest.new }
+    let(:smb2_request) { RubySMB::SMB2::Packet::TreeConnectRequest.new }
 
     before(:each) do
       expect(dispatcher).to receive(:send_packet).and_return(nil)
@@ -570,7 +570,12 @@ RSpec.describe RubySMB::Client do
 
   context 'Signing' do
     describe '#smb2_sign' do
-      let(:request1) { RubySMB::SMB2::Packet::SessionSetupRequest.new }
+      let(:request1) {
+        packet = RubySMB::SMB2::Packet::SessionSetupRequest.new
+        packet.smb2_header.flags.signed = 1
+        packet.smb2_header.signature = "\x00" * 16
+        packet
+      }
       let(:fake_hmac) { "\x31\x07\x78\x3e\x35\xd7\x0e\x89\x08\x43\x8a\x18\xcd\x78\x52\x39".force_encoding("ASCII-8BIT") }
 
       context 'if signing is required and we have a session key' do
@@ -610,7 +615,7 @@ RSpec.describe RubySMB::Client do
           smb1_client.signing_required = true
           raw = request1.to_binary_s
           adjusted_request = RubySMB::SMB1::Packet::SessionSetupRequest.read(raw)
-          adjusted_request.smb_header.security_features = smb1_client.sequence_counter
+          adjusted_request.smb_header.security_features = [smb1_client.sequence_counter].pack('Q<')
           expect(OpenSSL::Digest::MD5).to receive(:digest).with(smb1_client.session_key + adjusted_request.to_binary_s).and_return(fake_sig)
           expect(smb1_client.smb1_sign(request1).smb_header.security_features).to eq fake_sig
         end
@@ -634,5 +639,110 @@ RSpec.describe RubySMB::Client do
     end
   end
 
+  context '#increment_smb_message_id' do
+    let(:request_packet) { RubySMB::SMB2::Packet::NegotiateRequest.new }
 
+    it 'sets the message_id on the packet header to the client message_id' do
+      id = client.smb2_message_id
+      expect(client.increment_smb_message_id(request_packet).smb2_header.message_id).to eq id
+    end
+
+    it 'increments the client message id' do
+      client.smb2_message_id = 1
+      expect{ client.increment_smb_message_id(request_packet) }.to change{ client.smb2_message_id}.by(1)
+    end
+  end
+
+  context 'connecting to a share' do
+    let(:path) { '\\192.168.1.1\example' }
+    let(:tree_id) { 2049 }
+    context 'with SMB1' do
+      let(:request) { RubySMB::SMB1::Packet::TreeConnectRequest.new }
+      let(:response) {
+        packet = RubySMB::SMB1::Packet::TreeConnectResponse.new
+        packet.smb_header.tid = tree_id
+        packet.parameter_block.access_rights.read("\xff\x01\x1f\x00")
+        packet.data_block.service = 'A:'
+        packet
+      }
+
+      describe '#smb1_tree_connect' do
+        it 'builds and sends a TreeconnectRequest for the supplied share' do
+          allow(RubySMB::SMB1::Packet::TreeConnectRequest).to receive(:new).and_return(request)
+          modified_request = request
+          modified_request.data_block.path = path
+          expect(smb1_client).to receive(:send_recv).with(modified_request).and_return(response.to_binary_s)
+          smb1_client.smb1_tree_connect(path)
+        end
+
+        it 'sends the response to #smb1_tree_from_response' do
+          expect(smb1_client).to receive(:send_recv).and_return(response.to_binary_s)
+          expect(smb1_client).to receive(:smb1_tree_from_response).with(path, response)
+          smb1_client.smb1_tree_connect(path)
+        end
+      end
+
+      describe '#smb1_tree_from_response' do
+        it 'raises an InvalidPacket exception if the command is not TREE_CONNECT' do
+          response.smb_header.command = RubySMB::SMB1::Commands::SMB_COM_NEGOTIATE
+          expect{ smb1_client.smb1_tree_from_response(path,response) }.to raise_error(RubySMB::Error::InvalidPacket)
+        end
+
+        it 'raises an UnexpectedStatusCode exception if we do not get STATUS_SUCCESS' do
+          response.smb_header.nt_status = 0xc0000015
+          expect{ smb1_client.smb1_tree_from_response(path,response) }.to raise_error(RubySMB::Error::UnexpectedStatusCode, 'STATUS_NONEXISTENT_SECTOR')
+        end
+
+        it 'creates a new Tree from itself, the share path, and the response packet' do
+          expect(RubySMB::SMB1::Tree).to receive(:new).with(client:smb1_client, share:path, response:response)
+          smb1_client.smb1_tree_from_response(path,response)
+        end
+      end
+    end
+
+    context 'with SMB2' do
+      let(:request) { RubySMB::SMB2::Packet::TreeConnectRequest.new  }
+      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
+      }
+
+      describe '#smb2_tree_connect' do
+        it 'builds and sends a TreeconnectRequest for the supplied share' do
+          allow(RubySMB::SMB2::Packet::TreeConnectRequest).to receive(:new).and_return(request)
+          modified_request = request
+          modified_request.encode_path(path)
+          expect(smb2_client).to receive(:send_recv).with(modified_request).and_return(response.to_binary_s)
+          smb2_client.smb2_tree_connect(path)
+        end
+
+        it 'sends the response to #smb2_tree_from_response' do
+          expect(smb2_client).to receive(:send_recv).and_return(response.to_binary_s)
+          expect(smb2_client).to receive(:smb2_tree_from_response).with(path, response)
+          smb2_client.smb2_tree_connect(path)
+        end
+      end
+
+      describe '#smb2_tree_from_response' do
+        it 'raises an InvalidPacket exception if the command is not TREE_CONNECT' do
+          response.smb2_header.command = RubySMB::SMB2::Commands::NEGOTIATE
+          expect{ smb2_client.smb2_tree_from_response(path,response) }.to raise_error(RubySMB::Error::InvalidPacket)
+        end
+
+        it 'raises an UnexpectedStatusCode exception if we do not get STATUS_SUCCESS' do
+          response.smb2_header.nt_status = 0xc0000015
+          expect{ smb2_client.smb2_tree_from_response(path,response) }.to raise_error(RubySMB::Error::UnexpectedStatusCode, 'STATUS_NONEXISTENT_SECTOR')
+        end
+
+        it 'creates a new Tree from itself, the share path, and the response packet' do
+          expect(RubySMB::SMB2::Tree).to receive(:new).with(client:smb2_client, share:path, response:response)
+          smb2_client.smb2_tree_from_response(path,response)
+        end
+      end
+
+    end
+  end
 end

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

@@ -0,0 +1,190 @@
+RSpec.describe RubySMB::SMB1::BitField::DirectoryAccessMask do
+  subject(:flags) { described_class.new }
+
+  it { is_expected.to respond_to :read_attr }
+  it { is_expected.to respond_to :delete_child }
+  it { is_expected.to respond_to :traverse }
+  it { is_expected.to respond_to :write_ea }
+  it { is_expected.to respond_to :read_ea }
+  it { is_expected.to respond_to :add_subdir }
+  it { is_expected.to respond_to :add_file }
+  it { is_expected.to respond_to :list }
+  it { is_expected.to respond_to :write_attr }
+  it { is_expected.to respond_to :synchronize }
+  it { is_expected.to respond_to :write_owner }
+  it { is_expected.to respond_to :write_dac }
+  it { is_expected.to respond_to :read_control }
+  it { is_expected.to respond_to :delete_access }
+  it { is_expected.to respond_to :generic_read }
+  it { is_expected.to respond_to :generic_write }
+  it { is_expected.to respond_to :generic_execute }
+  it { is_expected.to respond_to :generic_all }
+  it { is_expected.to respond_to :maximum }
+  it { is_expected.to respond_to :system_security }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#list' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.list).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :list, 'V', 0x00000001
+  end
+
+
+  describe '#add_file' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.add_file).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :add_file, 'V', 0x00000002
+  end
+
+  describe '#add_subdir' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.add_subdir).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :add_subdir, 'V', 0x00000004
+  end
+
+  describe '#read_ea' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.read_ea).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :read_ea, 'V', 0x00000008
+  end
+
+  describe '#write_ea' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.write_ea).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :write_ea, 'V', 0x00000010
+  end
+
+  describe '#traverse' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.traverse).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :traverse, 'V', 0x00000020
+  end
+
+  describe '#delete_child' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.delete_child).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :delete_child, 'V', 0x00000040
+  end
+
+  describe '#read_attr' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.read_attr).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :read_attr, 'V', 0x00000080
+  end
+
+  describe '#write_attr' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.write_attr).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :write_attr, 'V', 0x00000100
+  end
+
+  describe '#delete_access' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.delete_access).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :delete_access, 'V', 0x00010000
+  end
+
+  describe '#read_control' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.read_control).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :read_control, 'V', 0x00020000
+  end
+
+  describe '#write_dac' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.write_dac).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :write_dac, 'V', 0x00040000
+  end
+
+  describe '#write_owner' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.write_owner).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :write_owner, 'V', 0x00080000
+  end
+
+  describe '#synchronize' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.synchronize).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :synchronize, 'V', 0x00100000
+  end
+
+  describe '#system_security' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.system_security).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :system_security, 'V', 0x01000000
+  end
+
+  describe '#maximum' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.maximum).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :maximum, 'V', 0x02000000
+  end
+
+  describe '#generic_all' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.generic_all).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :generic_all, 'V', 0x10000000
+  end
+
+  describe '#generic_execute' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.generic_execute).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :generic_execute, 'V', 0x20000000
+  end
+
+  describe '#generic_write' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.generic_write).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :generic_write, 'V', 0x40000000
+  end
+
+  describe '#generic_read' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.generic_read).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :generic_read, 'V', 0x80000000
+  end
+
+end