ruby_smb 1.0.3 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2c631886979a7433c911311d4a86e396714d492c
-  data.tar.gz: 2239c4167668f032308e16d047b40e0f4c1587cb
+  metadata.gz: 7d5e35bee112d4186cdb919a1041dbd54c72739d
+  data.tar.gz: 002b2dcada90c5617d15d472f5d06c5f1474619d
 SHA512:
-  metadata.gz: 1fcc1eacddf7c95375b966772d580357ba321d31c157d277e4c4306e448696f0f1f1aa210f06b127db7f2ffad83b5086f30608e8cbeb0ad370339dd3e1630731
-  data.tar.gz: 9cb22ee1ce93621365fba1f3bb67f0855a92331e28fc388b42d10e7b32716e587bfb29dda783d8c5bf617b388735f02abdc805a84b438aa1bdad70317f93d4f5
+  metadata.gz: 8516db67fb88bb248314f69eefef87f8021fcc409fa637e43a1b97474665d28e8d24fe470283d895c65374479d13d372d9eed346814eebd6bf144b63805b8bf2
+  data.tar.gz: 21632505b70f1af84724a613eb2344fda82e7c60f63255eb92569bef752fd0dcdf1e0fcb58f7f3cf21200b79fdfc3e592fde3643a42b0b5002db963d5f54e3ba

data/lib/ruby_smb/client.rb

@@ -297,15 +297,32 @@ module RubySMB
     # Sends a LOGOFF command to the remote server to terminate the session
     #
     # @return [WindowsError::ErrorCode] the NTStatus of the response
+    # @raise [RubySMB::Error::InvalidPacket] if the response packet is not a LogoffResponse packet
     def logoff!
       if smb2
         request      = RubySMB::SMB2::Packet::LogoffRequest.new
         raw_response = send_recv(request)
         response     = RubySMB::SMB2::Packet::LogoffResponse.read(raw_response)
+        unless response.valid?
+          raise RubySMB::Error::InvalidPacket.new(
+            expected_proto: RubySMB::SMB2::SMB2_PROTOCOL_ID,
+            expected_cmd:   RubySMB::SMB2::Packet::LogoffResponse::COMMAND,
+            received_proto: response.smb2_header.protocol,
+            received_cmd:   response.smb2_header.command
+          )
+        end
       else
         request      = RubySMB::SMB1::Packet::LogoffRequest.new
         raw_response = send_recv(request)
         response     = RubySMB::SMB1::Packet::LogoffResponse.read(raw_response)
+        unless response.valid?
+          raise RubySMB::Error::InvalidPacket.new(
+            expected_proto: RubySMB::SMB1::SMB_PROTOCOL_ID,
+            expected_cmd:   RubySMB::SMB1::Packet::LogoffResponse::COMMAND,
+            received_proto: response.smb_header.protocol,
+            received_cmd:   response.smb_header.command
+          )
+        end
       end
       wipe_state!
       response.status_code
@@ -380,14 +397,19 @@ module RubySMB
     # @param name [String] the NetBIOS name to request
     # @return [TrueClass] if session request is granted
     # @raise [RubySMB::Error::NetBiosSessionService] if session request is refused
+    # @raise [RubySMB::Error::InvalidPacket] if the response packet is not a NBSS packet
     def session_request(name = '*SMBSERVER')
       session_request = session_request_packet(name)
       dispatcher.send_packet(session_request, nbss_header: false)
       raw_response = dispatcher.recv_packet(full_response: true)
-      session_header =  RubySMB::Nbss::SessionHeader.read(raw_response)
-      if session_header.session_packet_type == RubySMB::Nbss::NEGATIVE_SESSION_RESPONSE
-        negative_session_response =  RubySMB::Nbss::NegativeSessionResponse.read(raw_response)
-        raise RubySMB::Error::NetBiosSessionService, "Session Request failed: #{negative_session_response.error_msg}"
+      begin
+        session_header = RubySMB::Nbss::SessionHeader.read(raw_response)
+        if session_header.session_packet_type == RubySMB::Nbss::NEGATIVE_SESSION_RESPONSE
+          negative_session_response =  RubySMB::Nbss::NegativeSessionResponse.read(raw_response)
+          raise RubySMB::Error::NetBiosSessionService, "Session Request failed: #{negative_session_response.error_msg}"
+        end
+      rescue IOError
+        raise RubySMB::Error::InvalidPacket, 'Not a NBSS packet'
       end
 
       return true

data/lib/ruby_smb/client/authentication.rb

@@ -54,14 +54,15 @@ module RubySMB
       end
 
       def smb1_anonymous_auth_response(raw_response)
-        begin
-          packet = RubySMB::SMB1::Packet::SessionSetupLegacyResponse.read(raw_response)
-        rescue
-          packet = RubySMB::SMB1::Packet::EmptyPacket.read(raw_response)
-        end
-
-        unless packet.smb_header.command == RubySMB::SMB1::Commands::SMB_COM_SESSION_SETUP
-          raise RubySMB::Error::InvalidPacket, "Command was #{packet.smb_header.command} and not #{RubySMB::SMB1::Commands::SMB_COM_SESSION_SETUP}"
+        packet = RubySMB::SMB1::Packet::SessionSetupLegacyResponse.read(raw_response)
+
+        unless packet.valid?
+          raise RubySMB::Error::InvalidPacket.new(
+            expected_proto: RubySMB::SMB1::SMB_PROTOCOL_ID,
+            expected_cmd:   RubySMB::SMB1::Packet::SessionSetupLegacyResponse::COMMAND,
+            received_proto: packet.smb_header.protocol,
+            received_cmd:   packet.smb_header.command
+          )
         end
         packet
       end
@@ -147,14 +148,15 @@ module RubySMB
 
       # Takes the raw binary string and returns a {RubySMB::SMB1::Packet::SessionSetupResponse}
       def smb1_ntlmssp_final_packet(raw_response)
-        begin
-          packet = RubySMB::SMB1::Packet::SessionSetupResponse.read(raw_response)
-        rescue
-          packet = RubySMB::SMB1::Packet::EmptyPacket.read(raw_response)
-        end
+        packet = RubySMB::SMB1::Packet::SessionSetupResponse.read(raw_response)
 
-        unless packet.smb_header.command == RubySMB::SMB1::Commands::SMB_COM_SESSION_SETUP
-          raise RubySMB::Error::InvalidPacket, "Command was #{packet.smb_header.command} and not #{RubySMB::SMB1::Commands::SMB_COM_SESSION_SETUP}"
+        unless packet.valid?
+          raise RubySMB::Error::InvalidPacket.new(
+            expected_proto: RubySMB::SMB1::SMB_PROTOCOL_ID,
+            expected_cmd:   RubySMB::SMB1::Packet::SessionSetupResponse::COMMAND,
+            received_proto: packet.smb_header.protocol,
+            received_cmd:   packet.smb_header.command
+          )
         end
         packet
       end
@@ -162,15 +164,20 @@ module RubySMB
       # Takes the raw binary string and returns a {RubySMB::SMB1::Packet::SessionSetupResponse}
       def smb1_ntlmssp_challenge_packet(raw_response)
         packet = RubySMB::SMB1::Packet::SessionSetupResponse.read(raw_response)
-        status_code = packet.status_code
+        unless packet.valid?
+          raise RubySMB::Error::InvalidPacket.new(
+            expected_proto: RubySMB::SMB1::SMB_PROTOCOL_ID,
+            expected_cmd:   RubySMB::SMB1::Packet::SessionSetupResponse::COMMAND,
+            received_proto: packet.smb_header.protocol,
+            received_cmd:   packet.smb_header.command
+          )
+        end
 
+        status_code = packet.status_code
         unless status_code.name == 'STATUS_MORE_PROCESSING_REQUIRED'
           raise RubySMB::Error::UnexpectedStatusCode, status_code.to_s
         end
 
-        unless packet.smb_header.command == RubySMB::SMB1::Commands::SMB_COM_SESSION_SETUP
-          raise RubySMB::Error::InvalidPacket, "Command was #{packet.smb_header.command} and not #{RubySMB::SMB1::Commands::SMB_COM_SESSION_SETUP}"
-        end
         packet
       end
 
@@ -212,23 +219,34 @@ module RubySMB
       # Takes the raw binary string and returns a {RubySMB::SMB2::Packet::SessionSetupResponse}
       def smb2_ntlmssp_final_packet(raw_response)
         packet = RubySMB::SMB2::Packet::SessionSetupResponse.read(raw_response)
-        unless packet.smb2_header.command == RubySMB::SMB2::Commands::SESSION_SETUP
-          raise RubySMB::Error::InvalidPacket, "Command was #{packet.smb2_header.command} and not #{RubySMB::SMB2::Commands::SESSION_SETUP}"
+        unless packet.valid?
+          raise RubySMB::Error::InvalidPacket.new(
+            expected_proto: RubySMB::SMB2::SMB2_PROTOCOL_ID,
+            expected_cmd:   RubySMB::SMB2::Packet::SessionSetupResponse::COMMAND,
+            received_proto: packet.smb2_header.protocol,
+            received_cmd:   packet.smb2_header.command
+          )
         end
+
         packet
       end
 
       # Takes the raw binary string and returns a {RubySMB::SMB2::Packet::SessionSetupResponse}
       def smb2_ntlmssp_challenge_packet(raw_response)
         packet = RubySMB::SMB2::Packet::SessionSetupResponse.read(raw_response)
+        unless packet.valid?
+          raise RubySMB::Error::InvalidPacket.new(
+            expected_proto: RubySMB::SMB2::SMB2_PROTOCOL_ID,
+            expected_cmd:   RubySMB::SMB2::Packet::SessionSetupResponse::COMMAND,
+            received_proto: packet.smb2_header.protocol,
+            received_cmd:   packet.smb2_header.command
+          )
+        end
+
         status_code = packet.status_code
         unless status_code.name == 'STATUS_MORE_PROCESSING_REQUIRED'
           raise RubySMB::Error::UnexpectedStatusCode, status_code.to_s
         end
-
-        unless packet.smb2_header.command == RubySMB::SMB2::Commands::SESSION_SETUP
-          raise RubySMB::Error::InvalidPacket, "Command was #{packet.smb2_header.command} and not #{RubySMB::SMB2::Commands::SESSION_SETUP}"
-        end
         packet
       end
 

data/lib/ruby_smb/client/echo.rb

@@ -16,7 +16,16 @@ module RubySMB
         (count - 1).times do
           raw_response = dispatcher.recv_packet
         end
-        RubySMB::SMB1::Packet::EchoResponse.read(raw_response)
+        response = RubySMB::SMB1::Packet::EchoResponse.read(raw_response)
+        unless response.valid?
+          raise RubySMB::Error::InvalidPacket.new(
+            expected_proto: RubySMB::SMB1::SMB_PROTOCOL_ID,
+            expected_cmd:   RubySMB::SMB1::Packet::EchoResponse::COMMAND,
+            received_proto: response.smb_header.protocol,
+            received_cmd:   response.smb_header.command
+          )
+        end
+        response
       end
 
       # Sends an ECHO request packet and returns the
@@ -26,7 +35,16 @@ module RubySMB
       def smb2_echo
         request      = RubySMB::SMB2::Packet::EchoRequest.new
         raw_response = send_recv(request)
-        RubySMB::SMB2::Packet::EchoResponse.read(raw_response)
+        response = RubySMB::SMB2::Packet::EchoResponse.read(raw_response)
+        unless response.valid?
+          raise RubySMB::Error::InvalidPacket.new(
+            expected_proto: RubySMB::SMB2::SMB2_PROTOCOL_ID,
+            expected_cmd:   RubySMB::SMB2::Packet::EchoResponse::COMMAND,
+            received_proto: response.smb2_header.protocol,
+            received_cmd:   response.smb2_header.command
+          )
+        end
+        response
       end
     end
   end

data/lib/ruby_smb/client/negotiation.rb

@@ -47,23 +47,38 @@ module RubySMB
       def negotiate_response(raw_data)
         response = nil
         if smb1
-          begin
-            packet = RubySMB::SMB1::Packet::NegotiateResponseExtended.read raw_data
-          rescue StandardError => e
-            raise RubySMB::Error::InvalidPacket, "Not a Valid SMB1 Negoitate Response #{e.message}"
-          end
+          packet = RubySMB::SMB1::Packet::NegotiateResponseExtended.read raw_data
           response = packet if packet.valid?
         end
         if smb2 && response.nil?
-          begin
-            packet = RubySMB::SMB2::Packet::NegotiateResponse.read raw_data
-          rescue StandardError => e
-            raise RubySMB::Error::InvalidPacket, "Not a Valid SMB2 Negoitate Response #{e.message}"
-          end
-          response = packet
+          packet = RubySMB::SMB2::Packet::NegotiateResponse.read raw_data
+          response = packet if packet.valid?
         end
         if response.nil?
-          raise RubySMB::Error::InvalidPacket, 'No Valid Negotiate Response found'
+          if packet.packet_smb_version == 'SMB1'
+            extended_security = if packet.is_a? RubySMB::SMB1::Packet::NegotiateResponseExtended
+              packet.parameter_block.capabilities.extended_security
+            else
+              "n/a"
+            end
+            raise RubySMB::Error::InvalidPacket.new(
+              expected_proto:  RubySMB::SMB1::SMB_PROTOCOL_ID,
+              expected_cmd:    RubySMB::SMB1::Packet::NegotiateResponseExtended::COMMAND,
+              expected_custom: "extended_security=1",
+              received_proto:  packet.smb_header.protocol,
+              received_cmd:    packet.smb_header.command,
+              received_custom: "extended_security=#{extended_security}"
+            )
+          elsif packet.packet_smb_version == 'SMB2'
+            raise RubySMB::Error::InvalidPacket.new(
+              expected_proto:  RubySMB::SMB2::SMB2_PROTOCOL_ID,
+              expected_cmd:    RubySMB::SMB2::Packet::NegotiateResponse::COMMAND,
+              received_proto:  packet.smb2_header.protocol,
+              received_cmd:    packet.smb2_header.command
+            )
+          else
+            raise RubySMB::Error::InvalidPacket, 'Unknown SMB protocol version'
+          end
         end
         response
       end

data/lib/ruby_smb/client/tree_connect.rb

@@ -17,11 +17,7 @@ module RubySMB
         request.smb_header.tid = 65_535
         request.data_block.path = share
         raw_response = send_recv(request)
-        begin
-          response = RubySMB::SMB1::Packet::TreeConnectResponse.read(raw_response)
-        rescue EOFError
-          response = RubySMB::SMB1::Packet::EmptyPacket.read(raw_response)
-        end
+        response = RubySMB::SMB1::Packet::TreeConnectResponse.read(raw_response)
         smb1_tree_from_response(share, response)
       end
 
@@ -30,9 +26,16 @@ module RubySMB
       # @param share [String] the share path to connect to
       # @param response [RubySMB::SMB1::Packet::TreeConnectResponse] the response packet to parse into our Tree
       # @return [RubySMB::SMB1::Tree]
+      # @raise [RubySMB::Error::InvalidPacket] if the response command is not a TreeConnectResponse packet
+      # @raise [RubySMB::Error::UnexpectedStatusCode] if the response status code is not STATUS_SUCCESS
       def smb1_tree_from_response(share, response)
-        unless response.smb_header.command == RubySMB::SMB1::Commands::SMB_COM_TREE_CONNECT
-          raise RubySMB::Error::InvalidPacket, 'Not a TreeConnectResponse'
+        unless response.valid?
+          raise RubySMB::Error::InvalidPacket.new(
+            expected_proto: RubySMB::SMB1::SMB_PROTOCOL_ID,
+            expected_cmd:   RubySMB::SMB1::Packet::TreeConnectResponse::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
@@ -54,11 +57,7 @@ module RubySMB
         request.smb2_header.tree_id = 65_535
         request.encode_path(share)
         raw_response = send_recv(request)
-        begin
-          response = RubySMB::SMB2::Packet::TreeConnectResponse.read(raw_response)
-        rescue EOFError
-          response = RubySMB::SMB2::Packet::ErrorPacket.read(raw_response)
-        end
+        response = RubySMB::SMB2::Packet::TreeConnectResponse.read(raw_response)
         smb2_tree_from_response(share, response)
       end
 
@@ -67,9 +66,16 @@ module RubySMB
       # @param share [String] the share path to connect to
       # @param response [RubySMB::SMB2::Packet::TreeConnectResponse] the response packet to parse into our Tree
       # @return [RubySMB::SMB2::Tree]
+      # @raise [RubySMB::Error::InvalidPacket] if the response command is not a TreeConnectResponse packet
+      # @raise [RubySMB::Error::UnexpectedStatusCode] if the response status code is not STATUS_SUCCESS
       def smb2_tree_from_response(share, response)
-        unless response.smb2_header.command == RubySMB::SMB2::Commands::TREE_CONNECT
-          raise RubySMB::Error::InvalidPacket, 'Not a TreeConnectResponse'
+        unless response.valid?
+          raise RubySMB::Error::InvalidPacket.new(
+            expected_proto: RubySMB::SMB2::SMB2_PROTOCOL_ID,
+            expected_cmd:   RubySMB::SMB2::Packet::TreeConnectResponse::COMMAND,
+            received_proto: response.smb2_header.protocol,
+            received_cmd:   response.smb2_header.command
+          )
         end
         unless response.status_code == WindowsError::NTStatus::STATUS_SUCCESS
           raise RubySMB::Error::UnexpectedStatusCode, response.status_code.name

data/lib/ruby_smb/error.rb

@@ -15,7 +15,42 @@ 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
@@ -26,5 +61,9 @@ 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
   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/dcerpc.rb

@@ -43,8 +43,13 @@ module RubySMB
 
         trans_nmpipe_raw_response = @tree.client.send_recv(request)
         trans_nmpipe_response = RubySMB::SMB1::Packet::Trans::TransactNmpipeResponse.read(trans_nmpipe_raw_response)
-        unless trans_nmpipe_response.smb_header.command == RubySMB::SMB1::Commands::SMB_COM_TRANSACTION
-          raise RubySMB::Error::InvalidPacket, 'Not a Trans packet'
+        unless trans_nmpipe_response.valid?
+          raise RubySMB::Error::InvalidPacket.new(
+            expected_proto: RubySMB::SMB1::SMB_PROTOCOL_ID,
+            expected_cmd:   RubySMB::SMB1::Packet::Trans::TransactNmpipeResponse::COMMAND,
+            received_proto: trans_nmpipe_response.smb_header.protocol,
+            received_cmd:   trans_nmpipe_response.smb_header.command
+          )
         end
         unless trans_nmpipe_response.status_code == WindowsError::NTStatus::STATUS_SUCCESS
           raise RubySMB::Error::UnexpectedStatusCode, trans_nmpipe_response.status_code.name