ruby_smb 1.0.3 → 2.0.1

data/lib/ruby_smb/dispatcher/socket.rb

@@ -48,7 +48,7 @@ module RubySMB
           end
 
         rescue IOError, Errno::ECONNABORTED, Errno::ECONNRESET => e
-          raise RubySMB::Error::CommunicationError, "An error occured writing to the Socket: #{e.message}"
+          raise RubySMB::Error::CommunicationError, "An error occurred writing to the Socket: #{e.message}"
         end
         nil
       end
@@ -61,13 +61,14 @@ module RubySMB
       #   which are assumed to be the NetBiosSessionService header.
       # @raise [RubySMB::Error::CommunicationError] if the read timeout expires or an error occurs when reading the socket
       def recv_packet(full_response: false)
+        raise RubySMB::Error::CommunicationError, 'Connection has already been closed' if @tcp_socket.closed?
         if IO.select([@tcp_socket], nil, nil, @read_timeout).nil?
           raise RubySMB::Error::CommunicationError, "Read timeout expired when reading from the Socket (timeout=#{@read_timeout})"
         end
 
         begin
           nbss_data = @tcp_socket.read(4)
-          raise IOError if nbss_data.nil?
+          raise RubySMB::Error::CommunicationError, 'Socket read returned nil' if nbss_data.nil?
           nbss_header = RubySMB::Nbss::SessionHeader.read(nbss_data)
         rescue IOError
           raise ::RubySMB::Error::NetBiosSessionService, 'NBSS Header is missing'
@@ -84,7 +85,7 @@ module RubySMB
         end
         data
       rescue Errno::EINVAL, Errno::ECONNABORTED, Errno::ECONNRESET, TypeError, NoMethodError => e
-        raise RubySMB::Error::CommunicationError, "An error occured reading from the Socket #{e.message}"
+        raise RubySMB::Error::CommunicationError, "An error occurred reading from the Socket #{e.message}"
       end
     end
   end

data/lib/ruby_smb/error.rb

@@ -15,10 +15,66 @@ module RubySMB
 
     # Raised when trying to parse raw binary into a Packet and the data
     # is invalid.
-    class InvalidPacket < RubySMBError; end
+    class InvalidPacket < RubySMBError
+      def initialize(args = nil)
+        if args.nil?
+          super
+        elsif args.is_a? String
+          super(args)
+        elsif args.is_a? Hash
+          expected_proto = args[:expected_proto] ? translate_protocol(args[:expected_proto]) : "???"
+          expected_cmd = args[:expected_cmd] || "???"
+          received_proto = args[:received_proto] ? translate_protocol(args[:received_proto]) : "???"
+          received_cmd = args[:received_cmd] || "???"
+          super(
+            "Expecting #{expected_proto} protocol "\
+            "with command=#{expected_cmd}"\
+            "#{(" (" + args[:expected_custom] + ")") if args[:expected_custom]}, "\
+            "got #{received_proto} protocol "\
+            "with command=#{received_cmd}"\
+            "#{(" (" + args[:received_custom] + ")") if args[:received_custom]}"
+          )
+        else
+          raise ArgumentError, "InvalidPacket expects a String or a Hash, got a #{args.class}"
+        end
+      end
+
+      def translate_protocol(proto)
+        case proto
+        when RubySMB::SMB1::SMB_PROTOCOL_ID
+          'SMB1'
+        when RubySMB::SMB2::SMB2_PROTOCOL_ID
+          'SMB2'
+        else
+          raise ArgumentError, 'Unknown SMB protocol'
+        end
+      end
+      private :translate_protocol
+    end
 
     # Raised when a response packet has a NTStatus code that was unexpected.
-    class UnexpectedStatusCode < RubySMBError; end
+    class UnexpectedStatusCode < RubySMBError
+      attr_reader :status_code
+
+      def initialize(status_code)
+        case status_code
+        when WindowsError::ErrorCode
+          @status_code = status_code
+        when Integer
+          @status_code = WindowsError::NTStatus.find_by_retval(status_code).first
+          if @status_code.nil?
+            @status_code = WindowsError::ErrorCode.new("0x#{status_code.to_s(16)}", status_code, "Unknown 0x#{status_code.to_s(16)}")
+          end
+        else
+          raise ArgumentError, "Status code must be a WindowsError::ErrorCode or an Integer, got #{status_code.class}"
+        end
+        super
+      end
+
+      def to_s
+        "The server responded with an unexpected status code: #{status_code.name}"
+      end
+    end
 
     # Raised when an error occurs with the underlying socket.
     class CommunicationError < RubySMBError; end
@@ -26,5 +82,15 @@ module RubySMB
     # Raised when Protocol Negotiation fails, possibly due to an
     # unsupported protocol.
     class NegotiationFailure < RubySMBError; end
+
+    # Raised when trying to parse raw binary into a BitField and the data
+    # is invalid.
+    class InvalidBitField < RubySMBError; end
+
+    # Raised when an encryption operation fails
+    class EncryptionError < RubySMBError; end
+
+    # Raised when an signing operation fails
+    class SigningError < RubySMBError; end
   end
 end

data/lib/ruby_smb/generic_packet.rb

@@ -45,14 +45,16 @@ module RubySMB
       rescue IOError => e
         case self.to_s
           when /EmptyPacket|ErrorPacket/
-            raise e
+            raise RubySMB::Error::InvalidPacket, 'Not a valid SMB packet'
           when /SMB1/
-            RubySMB::SMB1::Packet::EmptyPacket.read(val)
+            packet = RubySMB::SMB1::Packet::EmptyPacket.read(val)
           when /SMB2/
-            RubySMB::SMB2::Packet::ErrorPacket.read(val)
+            packet = RubySMB::SMB2::Packet::ErrorPacket.read(val)
           else
-            raise e
+            raise RubySMB::Error::InvalidPacket, 'Not a valid SMB packet'
         end
+        packet.original_command = self::COMMAND
+        packet
       end
     end
 
@@ -72,6 +74,33 @@ module RubySMB
       status_code
     end
 
+    # Validates the packet protocol ID and the SMB command
+    #
+    # @return [TrueClass, FalseClass] true if the packet is valid, false otherwise
+    def valid?
+      case packet_smb_version
+      when 'SMB1'
+        return smb_header.protocol == RubySMB::SMB1::SMB_PROTOCOL_ID &&
+          smb_header.command == self.class::COMMAND
+      when 'SMB2'
+        return smb2_header.protocol == RubySMB::SMB2::SMB2_PROTOCOL_ID &&
+          smb2_header.command == self.class::COMMAND
+      end
+    end
+
+    def initialize_instance
+      super
+
+      unless [RubySMB::SMB1::Packet::EmptyPacket, RubySMB::SMB2::Packet::ErrorPacket].any? {|klass| self.is_a? klass}
+        case packet_smb_version
+        when 'SMB1'
+          smb_header.command = self.class::COMMAND
+        when 'SMB2'
+          smb2_header.command = self.class::COMMAND
+        end
+      end
+    end
+
     # Returns an array of hashes representing the
     # fields for this record.
     #

data/lib/ruby_smb/smb1/commands.rb

@@ -10,7 +10,7 @@ module RubySMB
       SMB_COM_TRANSACTION2_SECONDARY  = 0x33
       SMB_COM_TREE_DISCONNECT         = 0x71
       SMB_COM_NEGOTIATE               = 0x72
-      SMB_COM_SESSION_SETUP           = 0x73
+      SMB_COM_SESSION_SETUP_ANDX      = 0x73
       SMB_COM_LOGOFF                  = 0x74
       SMB_COM_TREE_CONNECT            = 0x75
       SMB_COM_NT_TRANSACT             = 0xA0

data/lib/ruby_smb/smb1/file.rb

@@ -76,17 +76,22 @@ module RubySMB
       # Closes the handle to the remote file.
       #
       # @return [WindowsError::ErrorCode] the NTStatus code returned by the operation
-      # @raise [RubySMB::Error::InvalidPacket] if the response command is not SMB_COM_CLOSE
+      # @raise [RubySMB::Error::InvalidPacket] if the response packet is not valid
       # @raise [RubySMB::Error::UnexpectedStatusCode] if the response NTStatus is not STATUS_SUCCESS
       def close
         close_request = set_header_fields(RubySMB::SMB1::Packet::CloseRequest.new)
         raw_response  = @tree.client.send_recv(close_request)
         response = RubySMB::SMB1::Packet::CloseResponse.read(raw_response)
-        unless response.smb_header.command == RubySMB::SMB1::Commands::SMB_COM_CLOSE
-          raise RubySMB::Error::InvalidPacket, 'Not a CloseResponse packet'
+        unless response.valid?
+          raise RubySMB::Error::InvalidPacket.new(
+            expected_proto: RubySMB::SMB1::SMB_PROTOCOL_ID,
+            expected_cmd:   RubySMB::SMB1::Packet::CloseResponse::COMMAND,
+            received_proto: response.smb_header.protocol,
+            received_cmd:   response.smb_header.command
+          )
         end
         unless response.status_code == WindowsError::NTStatus::STATUS_SUCCESS
-          raise RubySMB::Error::UnexpectedStatusCode, response.status_code.name
+          raise RubySMB::Error::UnexpectedStatusCode, response.status_code
         end
         response.status_code
       end
@@ -98,7 +103,7 @@ module RubySMB
       # @param bytes [Integer] the number of bytes to read
       # @param offset [Integer] the byte offset in the file to start reading from
       # @return [String] the data read from the file
-      # @raise [RubySMB::Error::InvalidPacket] if the response command is not SMB_COM_READ_ANDX
+      # @raise [RubySMB::Error::InvalidPacket] if the response packet is not valid
       # @raise [RubySMB::Error::UnexpectedStatusCode] if the response NTStatus is not STATUS_SUCCESS
       def read(bytes: @size, offset: 0)
         atomic_read_size = if bytes > @tree.client.max_buffer_size
@@ -113,11 +118,16 @@ module RubySMB
           read_request = read_packet(read_length: atomic_read_size, offset: offset)
           raw_response = @tree.client.send_recv(read_request)
           response = RubySMB::SMB1::Packet::ReadAndxResponse.read(raw_response)
-          unless response.smb_header.command == RubySMB::SMB1::Commands::SMB_COM_READ_ANDX
-            raise RubySMB::Error::InvalidPacket, 'Not a ReadAndxResponse packet'
+          unless response.valid?
+            raise RubySMB::Error::InvalidPacket.new(
+              expected_proto: RubySMB::SMB1::SMB_PROTOCOL_ID,
+              expected_cmd:   RubySMB::SMB1::Packet::ReadAndxResponse::COMMAND,
+              received_proto: response.smb_header.protocol,
+              received_cmd:   response.smb_header.command
+            )
           end
           unless response.status_code == WindowsError::NTStatus::STATUS_SUCCESS
-            raise RubySMB::Error::UnexpectedStatusCode, response.status_code.name
+            raise RubySMB::Error::UnexpectedStatusCode, response.status_code
           end
 
           if response.is_a?(RubySMB::SMB1::Packet::ReadAndxResponse)
@@ -146,17 +156,27 @@ module RubySMB
       def read_packet(read_length: 0, offset: 0)
         read_request = set_header_fields(RubySMB::SMB1::Packet::ReadAndxRequest.new)
         read_request.parameter_block.max_count_of_bytes_to_return = read_length
+        read_request.parameter_block.min_count_of_bytes_to_return = read_length
+        read_request.parameter_block.remaining = read_length
         read_request.parameter_block.offset = offset
         read_request
       end
-      
+
       def send_recv_read(read_length: 0, offset: 0)
         read_request = read_packet(read_length: read_length, offset: offset)
         raw_response = tree.client.send_recv(read_request)
 
         response = RubySMB::SMB1::Packet::ReadAndxResponse.read(raw_response)
+        unless response.valid?
+          raise RubySMB::Error::InvalidPacket.new(
+            expected_proto: RubySMB::SMB1::SMB_PROTOCOL_ID,
+            expected_cmd:   RubySMB::SMB1::Packet::ReadAndxResponse::COMMAND,
+            received_proto: response.smb_header.protocol,
+            received_cmd:   response.smb_header.command
+          )
+        end
         unless response.status_code == WindowsError::NTStatus::STATUS_SUCCESS
-          raise RubySMB::Error::UnexpectedStatusCode, response.status_code.name
+          raise RubySMB::Error::UnexpectedStatusCode, response.status_code
         end
 
         response.data_block.data.to_binary_s
@@ -165,9 +185,18 @@ module RubySMB
       # Delete a file on close
       #
       # @return [WindowsError::ErrorCode] the NTStatus Response code
+      # @raise [RubySMB::Error::InvalidPacket] if the response packet is not valid
       def delete
         raw_response = @tree.client.send_recv(delete_packet)
         response = RubySMB::SMB1::Packet::Trans2::SetFileInformationResponse.read(raw_response)
+        unless response.valid?
+          raise RubySMB::Error::InvalidPacket.new(
+            expected_proto: RubySMB::SMB1::SMB_PROTOCOL_ID,
+            expected_cmd:   RubySMB::SMB1::Packet::Trans2::SetFileInformationResponse::COMMAND,
+            received_proto: response.smb_header.protocol,
+            received_cmd:   response.smb_header.command
+          )
+        end
         response.status_code
       end
 
@@ -190,7 +219,7 @@ module RubySMB
       # @param data [String] the data to write to the file
       # @param offset [Integer] the offset in the file to start writing from
       # @return [Integer] the count of bytes written
-      # @raise [RubySMB::Error::InvalidPacket] if the response command is not SMB_COM_WRITE_ANDX
+      # @raise [RubySMB::Error::InvalidPacket] if the response packet is not valid
       # @raise [RubySMB::Error::UnexpectedStatusCode] if the response NTStatus is not STATUS_SUCCESS
       def write(data:, offset: 0)
         buffer = data.dup
@@ -206,11 +235,16 @@ module RubySMB
           write_request = write_packet(data: buffer.slice!(0, atomic_write_size), offset: offset)
           raw_response = @tree.client.send_recv(write_request)
           response = RubySMB::SMB1::Packet::WriteAndxResponse.read(raw_response)
-          unless response.smb_header.command == RubySMB::SMB1::Commands::SMB_COM_WRITE_ANDX
-            raise RubySMB::Error::InvalidPacket, 'Not a WriteAndxResponse packet'
+          unless response.valid?
+            raise RubySMB::Error::InvalidPacket.new(
+              expected_proto: RubySMB::SMB1::SMB_PROTOCOL_ID,
+              expected_cmd:   RubySMB::SMB1::Packet::WriteAndxResponse::COMMAND,
+              received_proto: response.smb_header.protocol,
+              received_cmd:   response.smb_header.command
+            )
           end
           unless response.status_code == WindowsError::NTStatus::STATUS_SUCCESS
-            raise RubySMB::Error::UnexpectedStatusCode, response.status_code.name
+            raise RubySMB::Error::UnexpectedStatusCode, response.status_code
           end
           bytes_written = response.parameter_block.count_low + (response.parameter_block.count_high << 16)
           total_bytes_written += bytes_written
@@ -235,12 +269,20 @@ module RubySMB
         write_request.parameter_block.remaining = write_request.parameter_block.data_length
         write_request
       end
-      
+
       def send_recv_write(data:'', offset: 0)
         pkt = write_packet(data: data, offset: offset)
         pkt.set_64_bit_offset(true)
         raw_response = @tree.client.send_recv(pkt)
         response = RubySMB::SMB1::Packet::WriteAndxResponse.read(raw_response)
+        unless response.valid?
+          raise RubySMB::Error::InvalidPacket.new(
+            expected_proto: RubySMB::SMB1::SMB_PROTOCOL_ID,
+            expected_cmd:   RubySMB::SMB1::Packet::WriteAndxResponse::COMMAND,
+            received_proto: response.smb_header.protocol,
+            received_cmd:   response.smb_header.command
+          )
+        end
         response.parameter_block.count_low
       end
 
@@ -248,9 +290,18 @@ module RubySMB
       #
       # @param new_file_name [String] the new name
       # @return [WindowsError::ErrorCode] the NTStatus Response code
+      # @raise [RubySMB::Error::InvalidPacket] if the response packet is not valid
       def rename(new_file_name)
         raw_response = tree.client.send_recv(rename_packet(new_file_name))
         response = RubySMB::SMB1::Packet::Trans2::SetFileInformationResponse.read(raw_response)
+        unless response.valid?
+          raise RubySMB::Error::InvalidPacket.new(
+            expected_proto: RubySMB::SMB1::SMB_PROTOCOL_ID,
+            expected_cmd:   RubySMB::SMB1::Packet::Trans2::SetFileInformationResponse::COMMAND,
+            received_proto: response.smb_header.protocol,
+            received_cmd:   response.smb_header.command
+          )
+        end
         response.status_code
       end
 

data/lib/ruby_smb/smb1/packet/close_request.rb

@@ -4,6 +4,8 @@ module RubySMB
       # A SMB1 SMB_COM_CLOSE Request Packet as defined in
       # [2.2.4.5.1 Request](https://msdn.microsoft.com/en-us/library/ee442151.aspx)
       class CloseRequest < RubySMB::GenericPacket
+        COMMAND = RubySMB::SMB1::Commands::SMB_COM_CLOSE
+
         # A SMB1 Parameter Block as defined by the {CloseRequest}
         class ParameterBlock < RubySMB::SMB1::ParameterBlock
           endian  :little
@@ -20,11 +22,6 @@ module RubySMB
         parameter_block   :parameter_block
         data_block        :data_block
 
-        def initialize_instance
-          super
-          smb_header.command = RubySMB::SMB1::Commands::SMB_COM_CLOSE
-        end
-
       end
     end
   end

data/lib/ruby_smb/smb1/packet/close_response.rb

@@ -4,6 +4,8 @@ module RubySMB
       # A SMB1 SMB_COM_CLOSE Response Packet as defined in
       # [2.2.4.5.2 Response](https://msdn.microsoft.com/en-us/library/ee441667.aspx)
       class CloseResponse < RubySMB::GenericPacket
+        COMMAND = RubySMB::SMB1::Commands::SMB_COM_CLOSE
+
         # A SMB1 Parameter Block as defined by the {CloseResponse}
         class ParameterBlock < RubySMB::SMB1::ParameterBlock
         end
@@ -18,7 +20,6 @@ module RubySMB
 
         def initialize_instance
           super
-          smb_header.command     = RubySMB::SMB1::Commands::SMB_COM_CLOSE
           smb_header.flags.reply = 1
         end
 

data/lib/ruby_smb/smb1/packet/echo_request.rb

@@ -4,6 +4,8 @@ module RubySMB
       # This class represents an SMB1 Echo Request Packet as defined in
       # [2.2.4.39.1 Request](https://msdn.microsoft.com/en-us/library/ee441746.aspx)
       class EchoRequest < RubySMB::GenericPacket
+        COMMAND = RubySMB::SMB1::Commands::SMB_COM_ECHO
+
         # The {RubySMB::SMB1::ParameterBlock} specific to this packet type.
         class ParameterBlock < RubySMB::SMB1::ParameterBlock
           uint16 :echo_count, label: 'Echo Count', initial_value: 1
@@ -18,10 +20,6 @@ module RubySMB
         parameter_block   :parameter_block
         data_block        :data_block
 
-        def initialize_instance
-          super
-          smb_header.command = RubySMB::SMB1::Commands::SMB_COM_ECHO
-        end
       end
     end
   end

data/lib/ruby_smb/smb1/packet/echo_response.rb

@@ -4,6 +4,8 @@ module RubySMB
       # This class represents an SMB1 Echo Request Packet as defined in
       # [2.2.4.39.2 Response](https://msdn.microsoft.com/en-us/library/ee441626.aspx)
       class EchoResponse < RubySMB::GenericPacket
+        COMMAND = RubySMB::SMB1::Commands::SMB_COM_ECHO
+
         # The {RubySMB::SMB1::ParameterBlock} specific to this packet type.
         class ParameterBlock < RubySMB::SMB1::ParameterBlock
           uint16 :sequence_number, label: 'Sequence Number'
@@ -20,7 +22,6 @@ module RubySMB
 
         def initialize_instance
           super
-          smb_header.command = RubySMB::SMB1::Commands::SMB_COM_ECHO
           smb_header.flags.reply = 1
         end
       end

data/lib/ruby_smb/smb1/packet/empty_packet.rb

@@ -1,12 +1,21 @@
 module RubySMB
   module SMB1
     module Packet
-      # This packet represent an SMB1 Response Packet when the parameter and
+      # This packet represent an SMB1 Error Response Packet when the parameter and
       # data blocks will be empty.
       class EmptyPacket < RubySMB::GenericPacket
+        attr_accessor :original_command
+
         smb_header        :smb_header
         parameter_block   :parameter_block
         data_block        :data_block
+
+        def valid?
+          return smb_header.protocol == RubySMB::SMB1::SMB_PROTOCOL_ID &&
+                 smb_header.command == @original_command &&
+                 parameter_block.word_count == 0 &&
+                 data_block.byte_count == 0
+        end
       end
     end
   end