ruby_smb 1.0.3 → 1.0.4

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

@@ -4,15 +4,13 @@ module RubySMB
       # 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
+        COMMAND = RubySMB::SMB2::Commands::TREE_DISCONNECT
+
         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
-          smb2_header.command = RubySMB::SMB2::Commands::TREE_DISCONNECT
-        end
       end
     end
   end

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

@@ -4,13 +4,14 @@ module RubySMB
       # 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
+        COMMAND = RubySMB::SMB2::Commands::TREE_DISCONNECT
+
         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

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

@@ -4,6 +4,8 @@ module RubySMB
       # An SMB2 Write Request Packet as defined in
       # [2.2.21 SMB2 WRITE Request](https://msdn.microsoft.com/en-us/library/cc246532.aspx)
       class WriteRequest < RubySMB::GenericPacket
+        COMMAND = RubySMB::SMB2::Commands::WRITE
+
         endian :little
 
         smb2_header           :smb2_header
@@ -19,10 +21,6 @@ module RubySMB
         uint32                :flags,                 label: 'Flags'
         string                :buffer,                label: 'Write Data Buffer'
 
-        def initialize_instance
-          super
-          smb2_header.command = RubySMB::SMB2::Commands::WRITE
-        end
       end
     end
   end

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

@@ -4,6 +4,8 @@ module RubySMB
       # An SMB2 Write Response Packet as defined in
       # [2.2.22 SMB2 WRITE Response](https://msdn.microsoft.com/en-us/library/cc246533.aspx)
       class WriteResponse < RubySMB::GenericPacket
+        COMMAND = RubySMB::SMB2::Commands::WRITE
+
         endian :little
 
         smb2_header           :smb2_header
@@ -17,7 +19,6 @@ module RubySMB
 
         def initialize_instance
           super
-          smb2_header.command = RubySMB::SMB2::Commands::WRITE
           smb2_header.flags.reply = 1
         end
       end

data/lib/ruby_smb/smb2/pipe.rb

@@ -14,7 +14,7 @@ module RubySMB
       #
       # @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::InvalidPacket] if not a valid FIoctlResponse 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
@@ -24,19 +24,19 @@ module RubySMB
         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)
+        response = RubySMB::SMB2::Packet::IoctlResponse.read(raw_response)
+        unless response.valid?
+          raise RubySMB::Error::InvalidPacket.new(
+            expected_proto: RubySMB::SMB2::SMB2_PROTOCOL_ID,
+            expected_cmd:   RubySMB::SMB2::Packet::IoctlResponse::COMMAND,
+            received_proto: response.smb2_header.protocol,
+            received_cmd:   response.smb2_header.command
+          )
         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
 

data/lib/ruby_smb/smb2/tree.rb

@@ -34,11 +34,20 @@ module RubySMB
       # Disconnects this Tree from the current session
       #
       # @return [WindowsError::ErrorCode] the NTStatus sent back by the server.
+      # @raise [RubySMB::Error::InvalidPacket] if the response is not a TreeDisconnectResponse packet
       def disconnect!
         request = RubySMB::SMB2::Packet::TreeDisconnectRequest.new
         request = set_header_fields(request)
         raw_response = client.send_recv(request)
         response = RubySMB::SMB2::Packet::TreeDisconnectResponse.read(raw_response)
+        unless response.valid?
+          raise RubySMB::Error::InvalidPacket.new(
+            expected_proto: RubySMB::SMB2::SMB2_PROTOCOL_ID,
+            expected_cmd:   RubySMB::SMB2::Packet::TreeDisconnectResponse::COMMAND,
+            received_proto: response.smb2_header.protocol,
+            received_cmd:   response.smb2_header.command
+          )
+        end
         response.status_code
       end
 
@@ -89,9 +98,16 @@ module RubySMB
 
         raw_response  = client.send_recv(create_request)
         response      = RubySMB::SMB2::Packet::CreateResponse.read(raw_response)
-
-        if response.is_a?(RubySMB::SMB2::Packet::ErrorPacket)
-          raise RubySMB::Error::RubySMBError
+        unless response.valid?
+          raise RubySMB::Error::InvalidPacket.new(
+            expected_proto: RubySMB::SMB2::SMB2_PROTOCOL_ID,
+            expected_cmd:   RubySMB::SMB2::Packet::CreateResponse::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
         end
 
         case @share_type
@@ -102,7 +118,7 @@ module RubySMB
         # when 0x03
         #   it's a printer!
         else
-          raise RubySMB::Error::RubySMBError
+          raise RubySMB::Error::RubySMBError, 'Unsupported share type'
         end
       end
 
@@ -116,6 +132,7 @@ module RubySMB
       # @param pattern [String] search pattern
       # @param type [Class] file information class
       # @return [Array] array of directory structures
+      # @raise [RubySMB::Error::InvalidPacket] if the response is not a QueryDirectoryResponse packet
       def list(directory: nil, pattern: '*', type: RubySMB::Fscc::FileInformation::FileIdFullDirectoryInformation)
         create_response = open_directory(directory: directory)
         file_id         = create_response.file_id
@@ -133,13 +150,20 @@ module RubySMB
         loop do
           response            = client.send_recv(directory_request)
           directory_response  = RubySMB::SMB2::Packet::QueryDirectoryResponse.read(response)
+          unless directory_response.valid?
+            raise RubySMB::Error::InvalidPacket.new(
+              expected_proto: RubySMB::SMB2::SMB2_PROTOCOL_ID,
+              expected_cmd:   RubySMB::SMB2::Packet::QueryDirectoryResponse::COMMAND,
+              received_proto: directory_response.smb2_header.protocol,
+              received_cmd:   directory_response.smb2_header.command
+            )
+          end
 
           status_code         = directory_response.smb2_header.nt_status.to_nt_status
 
           break if status_code == WindowsError::NTStatus::STATUS_NO_MORE_FILES
 
           unless status_code == WindowsError::NTStatus::STATUS_SUCCESS
-
             raise RubySMB::Error::UnexpectedStatusCode, status_code.to_s
           end
 
@@ -162,6 +186,7 @@ module RubySMB
       # @param write [Boolean] whether to request write access
       # @param delete [Boolean] whether to request delete access
       # @return [RubySMB::SMB2::Packet::CreateResponse] the response packet returned from the server
+      # @raise [RubySMB::Error::InvalidPacket] if the response is not a CreateResponse packet
       def open_directory(directory: nil, disposition: RubySMB::Dispositions::FILE_OPEN,
                          impersonation: RubySMB::ImpersonationLevels::SEC_IMPERSONATE,
                          read: true, write: false, delete: false)
@@ -169,7 +194,20 @@ module RubySMB
         create_request  = open_directory_packet(directory: directory, disposition: disposition,
                                                 impersonation: impersonation, read: read, write: write, delete: delete)
         raw_response    = client.send_recv(create_request)
-        RubySMB::SMB2::Packet::CreateResponse.read(raw_response)
+        response = RubySMB::SMB2::Packet::CreateResponse.read(raw_response)
+        unless response.valid?
+          raise RubySMB::Error::InvalidPacket.new(
+            expected_proto: RubySMB::SMB2::SMB2_PROTOCOL_ID,
+            expected_cmd:   RubySMB::SMB2::Packet::CreateResponse::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
+        end
+
+        response
       end
 
       # Creates the Packet for the #open_directory method.

data/lib/ruby_smb/version.rb

@@ -1,3 +1,3 @@
 module RubySMB
-  VERSION = '1.0.3'.freeze
+  VERSION = '1.0.4'.freeze
 end

data/spec/lib/ruby_smb/client_spec.rb

@@ -9,6 +9,7 @@ RSpec.describe RubySMB::Client do
   let(:smb1_client) { described_class.new(dispatcher, smb2: false, username: username, password: password) }
   let(:smb2_client) { described_class.new(dispatcher, smb1: false, username: username, password: password) }
   let(:empty_packet) { RubySMB::SMB1::Packet::EmptyPacket.new }
+  let(:error_packet) { RubySMB::SMB2::Packet::ErrorPacket.new }
 
   describe '#initialize' do
     it 'should raise an ArgumentError without a valid dispatcher' do
@@ -153,6 +154,94 @@ RSpec.describe RubySMB::Client do
     end
   end
 
+  describe '#logoff!' do
+    context 'with SMB1' do
+      let(:raw_response) { double('Raw response') }
+      let(:logoff_response) {
+        RubySMB::SMB1::Packet::LogoffResponse.new(smb_header: {:command => RubySMB::SMB1::Commands::SMB_COM_LOGOFF} )
+      }
+      before :example do
+        allow(smb1_client).to receive(:send_recv).and_return(raw_response)
+        allow(RubySMB::SMB1::Packet::LogoffResponse).to receive(:read).and_return(logoff_response)
+        allow(smb1_client).to receive(:wipe_state!)
+      end
+
+      it 'creates a LogoffRequest packet' do
+        expect(RubySMB::SMB1::Packet::LogoffRequest).to receive(:new).and_call_original
+        smb1_client.logoff!
+      end
+
+      it 'calls #send_recv' do
+        expect(smb1_client).to receive(:send_recv)
+        smb1_client.logoff!
+      end
+
+      it 'reads the raw response as a LogoffResponse packet' do
+        expect(RubySMB::SMB1::Packet::LogoffResponse).to receive(:read).with(raw_response)
+        smb1_client.logoff!
+      end
+
+      it 'raise an InvalidPacket exception when the response is an empty packet' do
+        allow(RubySMB::SMB1::Packet::LogoffResponse).to receive(:read).and_return(RubySMB::SMB1::Packet::EmptyPacket.new)
+        expect {smb1_client.logoff!}.to raise_error(RubySMB::Error::InvalidPacket)
+      end
+
+      it 'raise an InvalidPacket exception when the response is not valid' do
+        allow(logoff_response).to receive(:valid?).and_return(false)
+        expect {smb1_client.logoff!}.to raise_error(RubySMB::Error::InvalidPacket)
+      end
+
+      it 'calls #wipe_state!' do
+        expect(smb1_client).to receive(:wipe_state!)
+        smb1_client.logoff!
+      end
+
+      it 'returns the expected status code' do
+        logoff_response.smb_header.nt_status = WindowsError::NTStatus::STATUS_PENDING.value
+        allow(RubySMB::SMB1::Packet::LogoffResponse).to receive(:read).and_return(logoff_response)
+        expect(smb1_client.logoff!).to eq(WindowsError::NTStatus::STATUS_PENDING)
+      end
+    end
+
+    context 'with SMB2' do
+      let(:raw_response) { double('Raw response') }
+      let(:logoff_response) {
+        RubySMB::SMB2::Packet::LogoffResponse.new(smb_header: {:command => RubySMB::SMB2::Commands::LOGOFF} )
+      }
+      before :example do
+        allow(smb2_client).to receive(:send_recv).and_return(raw_response)
+        allow(RubySMB::SMB2::Packet::LogoffResponse).to receive(:read).and_return(logoff_response)
+        allow(smb2_client).to receive(:wipe_state!)
+      end
+
+      it 'creates a LogoffRequest packet' do
+        expect(RubySMB::SMB2::Packet::LogoffRequest).to receive(:new).and_call_original
+        smb2_client.logoff!
+      end
+
+      it 'calls #send_recv' do
+        expect(smb2_client).to receive(:send_recv)
+        smb2_client.logoff!
+      end
+
+      it 'reads the raw response as a LogoffResponse packet' do
+        expect(RubySMB::SMB2::Packet::LogoffResponse).to receive(:read).with(raw_response)
+        smb2_client.logoff!
+      end
+
+      it 'raise an InvalidPacket exception when the response is an error packet' do
+        allow(RubySMB::SMB2::Packet::LogoffResponse).to receive(:read).and_return(RubySMB::SMB2::Packet::ErrorPacket.new)
+        expect {smb2_client.logoff!}.to raise_error(RubySMB::Error::InvalidPacket)
+      end
+
+      it 'raise an InvalidPacket exception when the response is not a LOGOFF command' do
+        logoff_response.smb2_header.command = RubySMB::SMB2::Commands::ECHO
+        allow(RubySMB::SMB2::Packet::LogoffResponse).to receive(:read).and_return(logoff_response)
+        expect {smb2_client.logoff!}.to raise_error(RubySMB::Error::InvalidPacket)
+      end
+    end
+  end
+
   context 'NetBIOS Session Service' do
     describe '#session_request' do
       let(:session_header)  { RubySMB::Nbss::SessionHeader.new }
@@ -197,6 +286,11 @@ RSpec.describe RubySMB::Client do
         allow(dispatcher).to receive(:recv_packet).and_return(negative_session_response.to_binary_s)
         expect { client.session_request }.to raise_error(RubySMB::Error::NetBiosSessionService)
       end
+
+      it 'raises an InvalidPacket exception when an error occurs while reading' do
+        allow(RubySMB::Nbss::SessionHeader).to receive(:read).and_raise(IOError)
+        expect { client.session_request }.to raise_error(RubySMB::Error::InvalidPacket)
+      end
     end
 
     describe '#session_request_packet' do
@@ -332,10 +426,15 @@ RSpec.describe RubySMB::Client do
           expect(smb1_client.negotiate_response(smb1_extended_response_raw)).to eq smb1_extended_response
         end
 
-        it 'raises an exception if the Response is invalid' do
+        it 'raises an exception if the response is not a SMB packet' do
           expect { smb1_client.negotiate_response(random_junk) }.to raise_error(RubySMB::Error::InvalidPacket)
         end
 
+        it 'raises an InvalidPacket error if the response is not a valid response' do
+          empty_packet.smb_header.command = RubySMB::SMB2::Commands::NEGOTIATE
+          expect { smb1_client.negotiate_response(empty_packet.to_binary_s) }.to raise_error(RubySMB::Error::InvalidPacket)
+        end
+
         it 'considers the response invalid if it is not an actual Negotiate Response' do
           bogus_response = smb1_extended_response
           bogus_response.smb_header.command = 0xff
@@ -357,6 +456,12 @@ RSpec.describe RubySMB::Client do
         it 'raises an exception if the Response is invalid' do
           expect { smb2_client.negotiate_response(random_junk) }.to raise_error(RubySMB::Error::InvalidPacket)
         end
+
+        it 'considers the response invalid if it is not an actual Negotiate Response' do
+          bogus_response = smb2_response
+          bogus_response.smb2_header.command = RubySMB::SMB2::Commands::ECHO
+          expect { smb2_client.negotiate_response(bogus_response.to_binary_s) }.to raise_error(RubySMB::Error::InvalidPacket)
+        end
       end
 
       context 'with SMB1 and SMB2 enabled' do
@@ -624,7 +729,7 @@ RSpec.describe RubySMB::Client do
           expect { smb1_client.smb1_ntlmssp_challenge_packet(response.to_binary_s) }.to raise_error(RubySMB::Error::UnexpectedStatusCode)
         end
 
-        it 'raises an InvalidPacket if the Command field is wrong' do
+        it 'raise an InvalidPacket exception when the response is not valid' do
           expect { smb1_client.smb1_ntlmssp_challenge_packet(wrong_command.to_binary_s) }.to raise_error(RubySMB::Error::InvalidPacket)
         end
       end
@@ -645,7 +750,7 @@ RSpec.describe RubySMB::Client do
           expect(smb1_client.smb1_ntlmssp_final_packet(response.to_binary_s)).to eq response
         end
 
-        it 'raises an InvalidPacket if the Command field is wrong' do
+        it 'raise an InvalidPacket exception when the response is not valid' do
           expect { smb1_client.smb1_ntlmssp_final_packet(wrong_command.to_binary_s) }.to raise_error(RubySMB::Error::InvalidPacket)
         end
       end
@@ -717,12 +822,7 @@ RSpec.describe RubySMB::Client do
             expect(smb1_client.smb1_anonymous_auth_response(anonymous_response.to_binary_s)).to eq anonymous_response
           end
 
-          it 'returns an empty packet if the raw data is not a valid response' do
-            empty_packet.smb_header.command = RubySMB::SMB1::Commands::SMB_COM_SESSION_SETUP
-            expect(smb1_client.smb1_anonymous_auth_response(empty_packet.to_binary_s)).to eq empty_packet
-          end
-
-          it 'raises an InvalidPacket error if the command is wrong' do
+          it 'raise an InvalidPacket exception when the response is not valid' do
             anonymous_response.smb_header.command = RubySMB::SMB1::Commands::SMB_COM_NEGOTIATE
             expect { smb1_client.smb1_anonymous_auth_response(anonymous_response.to_binary_s) }.to raise_error(RubySMB::Error::InvalidPacket)
           end
@@ -829,7 +929,7 @@ RSpec.describe RubySMB::Client do
           expect { smb2_client.smb2_ntlmssp_challenge_packet(response.to_binary_s) }.to raise_error(RubySMB::Error::UnexpectedStatusCode)
         end
 
-        it 'raises an InvalidPacket if the Command field is wrong' do
+        it 'raise an InvalidPacket exception when the response is not valid' do
           expect { smb2_client.smb2_ntlmssp_challenge_packet(wrong_command.to_binary_s) }.to raise_error(RubySMB::Error::InvalidPacket)
         end
       end
@@ -888,7 +988,7 @@ RSpec.describe RubySMB::Client do
           expect(smb2_client.smb2_ntlmssp_final_packet(response.to_binary_s)).to eq response
         end
 
-        it 'raises an InvalidPacket if the Command field is wrong' do
+        it 'raise an InvalidPacket exception when the response is not valid' do
           expect { smb2_client.smb2_ntlmssp_final_packet(wrong_command.to_binary_s) }.to raise_error(RubySMB::Error::InvalidPacket)
         end
       end
@@ -1199,6 +1299,12 @@ RSpec.describe RubySMB::Client do
         expect(smb1_client).to receive(:send_recv).and_return(echo_response.to_binary_s)
         expect(smb1_client.echo).to eq WindowsError::NTStatus::STATUS_ABANDONED
       end
+
+      it 'raise an InvalidPacket exception when the response is not valid' do
+        echo_response.smb_header.command = RubySMB::SMB1::Commands::SMB_COM_SESSION_SETUP
+        allow(smb1_client).to receive(:send_recv).and_return(echo_response.to_binary_s)
+        expect { smb1_client.echo }.to raise_error(RubySMB::Error::InvalidPacket)
+      end
     end
 
     context 'with SMB2' do
@@ -1210,6 +1316,12 @@ RSpec.describe RubySMB::Client do
         expect(smb2_client).to receive(:send_recv).with(echo_request).and_return(echo_response.to_binary_s)
         expect(smb2_client.smb2_echo).to eq echo_response
       end
+
+      it 'raise an InvalidPacket exception when the response is not valid' do
+        echo_response.smb2_header.command = RubySMB::SMB2::Commands::SESSION_SETUP
+        allow(smb2_client).to receive(:send_recv).and_return(echo_response.to_binary_s)
+        expect { smb2_client.smb2_echo }.to raise_error(RubySMB::Error::InvalidPacket)
+      end
     end
   end
 

data/spec/lib/ruby_smb/generic_packet_spec.rb

@@ -63,8 +63,13 @@ RSpec.describe RubySMB::GenericPacket do
         expect(RubySMB::SMB1::Packet::NegotiateResponse.read(smb1_error_packet.to_binary_s)).to be_a RubySMB::SMB1::Packet::EmptyPacket
       end
 
-      it 'reraises the exception if it is not a valid error packet either' do
-        expect{RubySMB::SMB1::Packet::NegotiateResponse.read('a')}.to raise_error(EOFError)
+      it 'raises an InvaliPacket exception if it is not a valid error packet either' do
+        expect{RubySMB::SMB1::Packet::NegotiateResponse.read('a')}.to raise_error(RubySMB::Error::InvalidPacket)
+      end
+
+      it 'sets the EmptyPacket#original_command attribute to the original COMMAND' do
+        packet = RubySMB::SMB1::Packet::NegotiateResponse.read(smb1_error_packet.to_binary_s)
+        expect(packet.original_command).to eq RubySMB::SMB1::Packet::NegotiateResponse::COMMAND
       end
     end
 
@@ -75,8 +80,51 @@ RSpec.describe RubySMB::GenericPacket do
         expect(RubySMB::SMB2::Packet::NegotiateResponse.read(smb2_error_packet.to_binary_s)).to be_a RubySMB::SMB2::Packet::ErrorPacket
       end
 
-      it 'reraises the exception if it is not a valid error packet either' do
-        expect{RubySMB::SMB2::Packet::NegotiateResponse.read('a')}.to raise_error(EOFError)
+      it 'raises an InvaliPacket exception if it is not a valid error packet either' do
+        expect{RubySMB::SMB2::Packet::NegotiateResponse.read('a')}.to raise_error(RubySMB::Error::InvalidPacket)
+      end
+
+      it 'sets the ErrorPacket#original_command attribute to the original COMMAND' do
+        packet = RubySMB::SMB2::Packet::NegotiateResponse.read(smb2_error_packet.to_binary_s)
+        expect(packet.original_command).to eq RubySMB::SMB2::Packet::NegotiateResponse::COMMAND
+      end
+    end
+  end
+
+  describe '#valid?' do
+    context 'when reading an SMB1 packet' do
+      let(:packet) { RubySMB::SMB1::Packet::NegotiateResponse.new }
+
+      it 'returns true if the packet protocol ID and header command are valid' do
+        expect(packet).to be_valid
+      end
+
+      it 'returns false if the packet protocol ID is wrong' do
+        packet.smb_header.protocol = RubySMB::SMB2::SMB2_PROTOCOL_ID
+        expect(packet).to_not be_valid
+      end
+
+      it 'returns false if the packet header command is wrong' do
+        packet.smb_header.command = RubySMB::SMB1::Commands::SMB_COM_TREE_CONNECT
+        expect(packet).to_not be_valid
+      end
+    end
+
+    context 'when reading an SMB2 packet' do
+      let(:packet) { RubySMB::SMB2::Packet::NegotiateResponse.new }
+
+      it 'returns true if the packet protocol ID and header command are valid' do
+        expect(packet).to be_valid
+      end
+
+      it 'returns false if the packet protocol ID is wrong' do
+        packet.smb2_header.protocol = RubySMB::SMB1::SMB_PROTOCOL_ID
+        expect(packet).to_not be_valid
+      end
+
+      it 'returns false if the packet header command is wrong' do
+        packet.smb2_header.command = RubySMB::SMB2::Commands::TREE_CONNECT
+        expect(packet).to_not be_valid
       end
     end
   end