ruby_smb 0.0.20 → 0.0.21

data/lib/ruby_smb/smb1/packet/trans/subcommands.rb

@@ -0,0 +1,11 @@
+module RubySMB
+  module SMB1
+    module Packet
+      module Trans
+        module Subcommands
+          PEEK_NMPIPE        = 0x0023
+        end
+      end
+    end
+  end
+end

data/lib/ruby_smb/smb1/packet/trans2/find_next2_response.rb

@@ -24,7 +24,7 @@ module RubySMB
             end
           end
 
-          # The Trans2 Data Blcok for this particular Subcommand
+          # The Trans2 Data Block for this particular Subcommand
           class Trans2Data < BinData::Record
             rest :buffer, label: 'Results Buffer'
 

data/lib/ruby_smb/smb1/pipe.rb

@@ -0,0 +1,65 @@
+module RubySMB
+  module SMB1
+    # Represents a pipe on the Remote server that we can perform
+    # various I/O operations on.
+    class Pipe < File
+
+      # Reference: https://msdn.microsoft.com/en-us/library/ee441883.aspx
+      STATUS_DISCONNECTED = 0x0001
+      STATUS_LISTENING    = 0x0002
+      STATUS_OK           = 0x0003
+      STATUS_CLOSED       = 0x0004
+
+      # Performs a peek operation on the named pipe
+      #
+      # @param peek_size [Integer] Amount of data to peek
+      # @return [RubySMB::SMB1::Packet::Trans::PeekNmpipeResponse]
+      # @raise [RubySMB::Error::InvalidPacket] If not a valid PeekNmpipeResponse
+      # @raise [RubySMB::Error::UnexpectedStatusCode] If status is not STATUS_BUFFER_OVERFLOW or STATUS_SUCCESS
+      def peek(peek_size: 0)
+        packet = RubySMB::SMB1::Packet::Trans::PeekNmpipeRequest.new
+        packet.fid = @fid
+        packet.parameter_block.max_data_count = peek_size
+        packet = @tree.set_header_fields(packet)
+        raw_response = @tree.client.send_recv(packet)
+        response = RubySMB::SMB1::Packet::Trans::PeekNmpipeResponse.read(raw_response)
+
+        unless response.status_code == WindowsError::NTStatus::STATUS_BUFFER_OVERFLOW or response.status_code == WindowsError::NTStatus::STATUS_SUCCESS
+          raise RubySMB::Error::UnexpectedStatusCode, response.status_code.name
+        end
+
+        unless response.smb_header.command == RubySMB::SMB1::Commands::SMB_COM_TRANSACTION
+          raise RubySMB::Error::InvalidPacket, 'Not a TransResponse packet'
+        end
+        response
+      end
+
+      # @return [Integer] The number of bytes available to be read from the pipe
+      def peek_available
+        packet = peek
+        # Only 1 of these should be non-zero
+        packet.data_block.trans_parameters.read_data_available or packet.data_block.trans_parameters.message_bytes_length
+      end
+
+      # @return [Integer] Pipe status
+      def peek_state
+        packet = peek
+        packet.data_block.trans_parameters.pipe_state
+      end
+
+      # @return [Boolean] True if pipe is connected, false otherwise
+      def is_connected?
+        begin
+          state = peek_state
+        rescue RubySMB::Error::UnexpectedStatusCode => e
+          if e.message == 'STATUS_INVALID_HANDLE'
+            return false
+          end
+          raise e
+        end
+        state == STATUS_OK
+      end
+
+    end
+  end
+end

data/lib/ruby_smb/smb1/tree.rb

@@ -120,7 +120,14 @@ module RubySMB
           raise RubySMB::Error::UnexpectedStatusCode, response.status_code.name
         end
 
-        RubySMB::SMB1::File.new(name: filename, tree: self, response: response)
+        case response.parameter_block.resource_type 
+        when RubySMB::SMB1::ResourceType::BYTE_MODE_PIPE, RubySMB::SMB1::ResourceType::MESSAGE_MODE_PIPE
+          RubySMB::SMB1::Pipe.new(name: filename, tree: self, response: response)
+        when RubySMB::SMB1::ResourceType::DISK
+          RubySMB::SMB1::File.new(name: filename, tree: self, response: response)
+        else
+          raise RubySMB::Error::RubySMBError
+        end
       end
 
       # List `directory` on the remote share.

data/lib/ruby_smb/smb2.rb

@@ -14,5 +14,6 @@ module RubySMB
     require 'ruby_smb/smb2/packet'
     require 'ruby_smb/smb2/tree'
     require 'ruby_smb/smb2/file'
+    require 'ruby_smb/smb2/pipe'
   end
 end

data/lib/ruby_smb/smb2/file.rb

@@ -94,8 +94,8 @@ module RubySMB
       # @param offset [Integer] the byte offset in the file to start reading from
       # @return [String] the data read from the file
       def read(bytes: size, offset: 0)
-        atomic_read_size = if bytes > MAX_PACKET_SIZE
-                             MAX_PACKET_SIZE
+        atomic_read_size = if bytes > tree.client.server_max_read_size
+                             tree.client.server_max_read_size
                            else
                              bytes
                            end
@@ -110,7 +110,7 @@ module RubySMB
 
         while remaining_bytes > 0
           offset += atomic_read_size
-          atomic_read_size = remaining_bytes if remaining_bytes < MAX_PACKET_SIZE
+          atomic_read_size = remaining_bytes if remaining_bytes < tree.client.server_max_read_size
 
           read_request = read_packet(read_length: atomic_read_size, offset: offset)
           raw_response = tree.client.send_recv(read_request)
@@ -184,9 +184,9 @@ module RubySMB
       def write(data:'', offset: 0)
         buffer            = data.dup
         bytes             = data.length
-        atomic_write_size = if bytes > MAX_PACKET_SIZE
-                             MAX_PACKET_SIZE
-                           else
+        atomic_write_size = if bytes > tree.client.server_max_write_size
+                              tree.client.server_max_write_size
+                            else
                              bytes
                             end
 

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

@@ -7,6 +7,7 @@ module RubySMB
         endian       :little
         smb2_header  :smb2_header
         uint16       :structure_size, label: 'Structure Size', initial_value: 4
+        uint16       :reserved, label: 'Reserved', initial_value: 0
 
         def initialize_instance
           super

data/lib/ruby_smb/smb2/pipe.rb

@@ -0,0 +1,69 @@
+module RubySMB
+  module SMB2
+    # Represents a pipe on the Remote server that we can perform
+    # various I/O operations on.
+    class Pipe < File
+
+      STATUS_CONNECTED = 0x00000003
+      STATUS_CLOSING   = 0x00000004
+
+      # Performs a peek operation on the named pipe
+      #
+      # @param peek_size [Integer] Amount of data to peek
+      # @return [RubySMB::SMB2::Packet::IoctlResponse]
+      # @raise [RubySMB::Error::InvalidPacket] if not a valid FSCTL_PIPE_PEEK response
+      # @raise [RubySMB::Error::UnexpectedStatusCode] If status is not STATUS_BUFFER_OVERFLOW or STATUS_SUCCESS
+      def peek(peek_size: 0)
+        packet = RubySMB::SMB2::Packet::IoctlRequest.new
+        packet.ctl_code = RubySMB::Fscc::ControlCodes::FSCTL_PIPE_PEEK
+        packet.flags.is_fsctl = true
+        # read at least 16 bytes for state, avail, msg_count, first_msg_len
+        packet.max_output_response = 16 + peek_size
+        packet = set_header_fields(packet)
+        raw_response = @tree.client.send_recv(packet)
+        begin
+          response = RubySMB::SMB2::Packet::IoctlResponse.read(raw_response)
+        rescue IOError
+          response = RubySMB::SMB2::Packet::ErrorPacket.read(raw_response)
+        end
+
+        unless response.status_code == WindowsError::NTStatus::STATUS_BUFFER_OVERFLOW or response.status_code == WindowsError::NTStatus::STATUS_SUCCESS
+          raise RubySMB::Error::UnexpectedStatusCode, response.status_code.name
+        end
+
+        unless response.smb2_header.command == RubySMB::SMB2::Commands::IOCTL
+          raise RubySMB::Error::InvalidPacket, 'Not an IoctlResponse packet'
+        end
+        response
+      end
+
+      # @return [Integer] The number of bytes available to be read from the pipe
+      def peek_available
+        packet = peek
+        state, avail, msg_count, first_msg_len = packet.buffer.unpack('VVVV')
+        # Only 1 of these should be non-zero
+        avail or first_msg_len
+      end
+
+      # @return [Integer] Pipe status
+      def peek_state
+        packet = peek
+        packet.buffer.unpack('V')[0]
+      end
+
+      # @return [Boolean] True if pipe is connected, false otherwise
+      def is_connected?
+        begin
+          state = peek_state
+        rescue RubySMB::Error::UnexpectedStatusCode => e
+          if e.message == 'STATUS_FILE_CLOSED'
+            return false
+          end
+          raise e
+        end
+        state == STATUS_CONNECTED
+      end
+
+    end
+  end
+end

data/lib/ruby_smb/smb2/tree.rb

@@ -28,6 +28,7 @@ module RubySMB
         @share              = share
         @id                 = response.smb2_header.tree_id
         @permissions        = response.maximal_access
+        @share_type         = response.share_type
       end
 
       # Disconnects this Tree from the current session
@@ -89,7 +90,16 @@ module RubySMB
         raw_response  = client.send_recv(create_request)
         response      = RubySMB::SMB2::Packet::CreateResponse.read(raw_response)
 
-        RubySMB::SMB2::File.new(name: filename, tree: self, response: response)
+        case @share_type
+        when 0x01
+          RubySMB::SMB2::File.new(name: filename, tree: self, response: response)
+        when 0x02
+          RubySMB::SMB2::Pipe.new(name: filename, tree: self, response: response)
+        # when 0x03
+        #   it's a printer!
+        else
+          raise RubySMB::Error::RubySMBError
+        end
       end
 
       # List `directory` on the remote share.

data/lib/ruby_smb/version.rb

@@ -1,3 +1,3 @@
 module RubySMB
-  VERSION = '0.0.20'.freeze
+  VERSION = '0.0.21'.freeze
 end

data/spec/lib/ruby_smb/nbss/session_header_spec.rb

@@ -16,14 +16,14 @@ RSpec.describe RubySMB::Nbss::SessionHeader do
   end
 
   describe '#flags' do
-    it 'is a 8-bit Unsigned Integer' do
-      expect(session_header.flags).to be_a BinData::Uint8
+    it 'is a 7-bit Unsigned Integer' do
+      expect(session_header.flags).to be_a BinData::Bit7
     end
   end
 
   describe '#packet_length' do
-    it 'is a 16-bit Unsigned Integer' do
-      expect(session_header.packet_length).to be_a BinData::Uint16be
+    it 'is a 17-bit Unsigned Integer' do
+      expect(session_header.packet_length).to be_a BinData::Bit17
     end
   end
 end

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

@@ -0,0 +1,26 @@
+RSpec.describe RubySMB::SMB1::BitField::TransFlags do
+  subject(:flags) { described_class.new }
+
+  it { is_expected.to respond_to :no_response }
+  it { is_expected.to respond_to :disconnect }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#no_response' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.no_response).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :no_response, 'C', 0x02
+  end
+
+  describe '#disconnect' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.disconnect).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :disconnect, 'C', 0x01
+  end
+end

data/spec/lib/ruby_smb/smb1/packet/trans/peek_nmpipe_request_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+RSpec.describe RubySMB::SMB1::Packet::Trans::PeekNmpipeRequest do
+
+  subject(:packet) { described_class.new }
+
+  describe '#smb_header' do
+    subject(:header) { packet.smb_header }
+
+    it 'is a standard SMB Header' do
+      expect(header).to be_a RubySMB::SMB1::SMBHeader
+    end
+
+    it 'should have the command set to SMB_COM_TRANSACTION' do
+      expect(header.command).to eq RubySMB::SMB1::Commands::SMB_COM_TRANSACTION
+    end
+
+    it 'should not have the response flag set' do
+      expect(header.flags.reply).to eq 0
+    end
+  end
+
+  describe '#parameter_block' do
+    subject(:parameter_block) { packet.parameter_block }
+
+    it 'is a standard Trans ParameterBlock' do
+      expect(parameter_block).to be_a RubySMB::SMB1::Packet::Trans::Request::ParameterBlock
+    end
+
+    it 'should have a setup_count of 2' do
+      expect(parameter_block.setup_count).to eq 2
+    end
+
+    it 'should have subcommand PEEK_NMPIPE' do
+      expect(parameter_block.setup[0]).to eq RubySMB::SMB1::Packet::Trans::Subcommands::PEEK_NMPIPE
+    end
+  end
+
+  describe '#data_block' do
+    subject(:data_block) { packet.data_block }
+
+    it 'should have a name of \\PIPE\\' do
+      expect(data_block.name).to eq "\\PIPE\\"
+    end
+  end
+
+end

data/spec/lib/ruby_smb/smb1/packet/trans/peek_nmpipe_response_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+RSpec.describe RubySMB::SMB1::Packet::Trans::PeekNmpipeResponse do
+
+  subject(:packet) { described_class.new }
+
+  describe '#smb_header' do
+    subject(:header) { packet.smb_header }
+
+    it 'is a standard SMB Header' do
+      expect(header).to be_a RubySMB::SMB1::SMBHeader
+    end
+
+    it 'should have the command set to SMB_COM_TRANSACTION' do
+      expect(header.command).to eq RubySMB::SMB1::Commands::SMB_COM_TRANSACTION
+    end
+
+    it 'should have the response flag set' do
+      expect(header.flags.reply).to eq 1
+    end
+  end
+
+  describe '#parameter_block' do
+    subject(:parameter_block) { packet.parameter_block }
+
+    it 'is a standard Trans ParameterBlock' do
+      expect(parameter_block).to be_a RubySMB::SMB1::Packet::Trans::Response::ParameterBlock
+    end
+  end
+
+end

data/spec/lib/ruby_smb/smb1/packet/trans/request_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+RSpec.describe RubySMB::SMB1::Packet::Trans::Request do
+  subject(:packet) { described_class.new }
+
+  describe '#smb_header' do
+    subject(:header) { packet.smb_header }
+
+    it 'is a standard SMB Header' do
+      expect(header).to be_a RubySMB::SMB1::SMBHeader
+    end
+
+    it 'should have the command set to SMB_COM_NEGOTIATE' do
+      expect(header.command).to eq RubySMB::SMB1::Commands::SMB_COM_TRANSACTION
+    end
+
+    it 'should not have the response flag set' do
+      expect(header.flags.reply).to eq 0
+    end
+  end
+
+  describe '#parameter_block' do
+    subject(:parameter_block) { packet.parameter_block }
+
+    it 'is a standard ParameterBlock' do
+      expect(parameter_block).to be_a RubySMB::SMB1::ParameterBlock
+    end
+
+    it { is_expected.to respond_to :total_parameter_count }
+    it { is_expected.to respond_to :total_data_count }
+    it { is_expected.to respond_to :max_parameter_count }
+    it { is_expected.to respond_to :max_data_count }
+    it { is_expected.to respond_to :max_setup_count }
+    it { is_expected.to respond_to :timeout }
+    it { is_expected.to respond_to :parameter_count }
+    it { is_expected.to respond_to :parameter_offset }
+    it { is_expected.to respond_to :data_count }
+    it { is_expected.to respond_to :data_offset }
+    it { is_expected.to respond_to :setup_count }
+
+    describe 'flags' do
+      it 'is a trans_flags BitField' do
+        expect(parameter_block.flags).to be_a RubySMB::SMB1::BitField::TransFlags
+      end
+    end
+
+    describe 'parameter_count' do
+      it 'is a count of bytes in the data_block trans_parameters field' do
+        packet.data_block.trans_parameters = "\x00\x01\x02\x03"
+        expect(parameter_block.parameter_count).to eq 4
+      end
+    end
+
+    describe 'parameter_offset' do
+      it ' contains the absolute_offset to the data_block trans_parameters field' do
+        expect(parameter_block.parameter_offset).to eq packet.data_block.trans_parameters.abs_offset
+      end
+    end
+
+    describe 'data_count' do
+      it 'is a count of bytes in the data_block trans_data field' do
+        packet.data_block.trans_data = "\x00\x01\x02\x03"
+        expect(parameter_block.data_count).to eq 4
+      end
+    end
+
+    describe 'data_offset' do
+      it 'contains the absolute_offset to the data_block trans_data field' do
+        expect(parameter_block.data_offset).to eq packet.data_block.trans_data.abs_offset
+      end
+    end
+  end
+
+  describe '#data_block' do
+    subject(:data_block) { packet.data_block }
+
+    it 'is a standard DataBlock' do
+      expect(data_block).to be_a RubySMB::SMB1::DataBlock
+    end
+
+    it { is_expected.to respond_to :name }
+    it { is_expected.to respond_to :trans_parameters }
+    it { is_expected.to respond_to :trans_data }
+
+    it 'should keep #trans_parameters 4-byte aligned' do
+      expect(data_block.trans_parameters.abs_offset % 4).to eq 0
+    end
+
+    it 'should keep #trans_data 4-byte aligned' do
+      data_block.trans_parameters = 'a'
+      expect(data_block.trans_data.abs_offset % 4).to eq 0
+    end
+  end
+end