ruby_smb 1.0.2 → 2.0.0

data/lib/ruby_smb/dcerpc/winreg/query_value_response.rb

@@ -0,0 +1,57 @@
+module RubySMB
+  module Dcerpc
+    module Winreg
+
+      # This class represents a BaseRegQueryValue Response Packet as defined in
+      # [3.1.5.17 BaseRegQueryValue (Opnum 17)](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-rrp/8bc10aa3-2f91-44e8-aa33-b3263c49ab9d)
+      class QueryValueResponse < BinData::Record
+        attr_reader :opnum
+
+        endian :little
+
+        ndr_lp_dword :lp_type
+        ndr_lp_byte  :lp_data
+        string       :pad, length: -> { pad_length }
+        ndr_lp_dword :lpcb_data
+        ndr_lp_dword :lpcb_len
+        uint32       :error_status
+
+        def initialize_instance
+          super
+          @opnum = REG_QUERY_VALUE
+        end
+
+        # Determines the correct length for the padding in front of
+        # #lpcb_data. It should always force a 4-byte alignment.
+        def pad_length
+          offset = (lp_data.abs_offset + lp_data.to_binary_s.length) % 4
+          (4 - offset) % 4
+        end
+
+        # Returns the data portion of the registry value formatted according to its type:
+        # [3.1.1.5 Values](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-rrp/3d64dbea-f016-4373-8cac-e43bf343837d)
+        def data
+          bytes = lp_data.bytes.to_a.pack('C*')
+          case lp_type
+          when 1,2
+            bytes.force_encoding('utf-16le').strip
+          when 3
+            bytes
+          when 4
+            bytes.unpack('V').first
+          when 5
+            bytes.unpack('N').first
+          when 7
+            str = bytes.force_encoding('utf-16le')
+            str.split("\0".encode('utf-16le'))
+          when 11
+            bytes.unpack('Q<').first
+          else
+            ""
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/ruby_smb/dcerpc/winreg/regsam.rb

@@ -0,0 +1,40 @@
+module RubySMB
+  module Dcerpc
+    module Winreg
+
+      # This class represents a REGSAM structure as defined in
+      # [2.2.3 REGSAM](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-rrp/fefbc801-b141-4bb1-9dcb-bf366da3ae7e)
+      # [2.4.3 ACCESS_MASK](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-dtyp/7a53f60e-e730-4dfe-bbe9-b21b62eb790b)
+      class Regsam < BinData::Record
+        endian  :little
+        bit2    :reserved,               label: 'Reserved Space'
+        bit1    :key_create_link,        label: 'Key Create Link'
+        bit1    :key_notify,             label: 'Key Notify'
+        bit1    :key_enumerate_sub_keys, label: 'Key Enumerate Sub Keys'
+        bit1    :key_create_sub_key,     label: 'Key Create Sub Key'
+        bit1    :key_set_value,          label: 'Key Set Value'
+        bit1    :key_query_value,        label: 'Key Query Value'
+        # byte boundary
+        bit6    :reserved2,              label: 'Reserved Space'
+        bit1    :key_wow64_32key,        label: 'Key Wow64 32key'
+        bit1    :key_wow64_64key,        label: 'Key Wow64 64key'
+        # byte boundary
+        bit3    :reserved3,              label: 'Reserved Space'
+        bit1    :synchronize,            label: 'Synchronize'
+        bit1    :write_owner,            label: 'Write Owner'
+        bit1    :write_dac,              label: 'Write DAC'
+        bit1    :read_control,           label: 'Read Control'
+        bit1    :delete_access,          label: 'Delete'
+        # byte boundary
+        bit1    :generic_read,           label: 'Generic Read'
+        bit1    :generic_write,          label: 'Generic Write'
+        bit1    :generic_execute,        label: 'Generic Execute'
+        bit1    :generic_all,            label: 'Generic All'
+        bit2    :reserved4,              label: 'Reserved Space'
+        bit1    :maximum,                label: 'Maximum Allowed'
+        bit1    :system_security,        label: 'System Security'
+      end
+
+    end
+  end
+end

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
@@ -66,7 +66,9 @@ module RubySMB
         end
 
         begin
-          nbss_header = RubySMB::Nbss::SessionHeader.read(@tcp_socket)
+          nbss_data = @tcp_socket.read(4)
+          raise IOError if nbss_data.nil?
+          nbss_header = RubySMB::Nbss::SessionHeader.read(nbss_data)
         rescue IOError
           raise ::RubySMB::Error::NetBiosSessionService, 'NBSS Header is missing'
         end
@@ -82,7 +84,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