ruby_smb 1.1.0 → 2.0.0

data/spec/lib/ruby_smb/crypto_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+RSpec.describe RubySMB::Crypto::KDF do
+  describe '.counter_mode' do
+    it 'generates the expected 128-bit key' do
+      expected_key = "\x3c\x5e\x0a\x1b\x0a\xce\xa5\xb2\x64\x3f\xab\x78\xdc\x82\x31\x3b".b
+      expect(described_class.counter_mode('ki', 'label', 'context')).to eq(expected_key)
+    end
+
+    it 'generates the expected 256-bit key' do
+      expected_key =
+        "\x33\x4d\xa9\x6d\x24\x7e\xcb\x14\xf6\x24\x00\x97\x26\x51\xd5\xb4"\
+        "\x54\x5f\xda\x95\xf0\x5a\xcb\x25\x92\x57\xae\x71\x1c\x37\x20\x5b".b
+      expect(described_class.counter_mode('ki', 'label', 'context', length: 256)).to eq(expected_key)
+    end
+
+    it 'raises the expected exception when an error occurs' do
+      allow(OpenSSL::Digest).to receive(:new).and_raise(OpenSSL::OpenSSLError)
+      expect { described_class.counter_mode('ki', 'label', 'context') }.to raise_error(
+        RubySMB::Error::EncryptionError,
+        "Crypto::KDF.counter_mode OpenSSL error: OpenSSL::OpenSSLError"
+      )
+    end
+  end
+end

data/spec/lib/ruby_smb/error_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+RSpec.describe RubySMB::Error::InvalidPacket do
+  context 'with a String' do
+    it 'outputs the expected error message' do
+      ex = described_class.new('My exception')
+      expect(ex.to_s).to eq('My exception')
+    end
+  end
+
+  context 'with a Hash' do
+    it 'outputs the expected error message' do
+      ex = described_class.new(
+        expected_proto:  RubySMB::SMB1::SMB_PROTOCOL_ID,
+        expected_cmd:    RubySMB::SMB1::Packet::NegotiateResponseExtended::COMMAND,
+        expected_custom: "extended_security=1",
+        received_proto:  RubySMB::SMB2::SMB2_PROTOCOL_ID,
+        received_cmd:    RubySMB::SMB2::Packet::NegotiateResponse::COMMAND,
+        received_custom: "extended_security=0"
+      )
+      expect(ex.to_s).to eq('Expecting SMB1 protocol with command=114 (extended_security=1), got SMB2 protocol with command=0 (extended_security=0)')
+    end
+  end
+
+  context 'with an unsupported type' do
+    it 'raises the expected exception' do
+      expect { described_class.new(['wrong']) }.to raise_error(
+        ArgumentError,
+        'InvalidPacket expects a String or a Hash, got a Array'
+      )
+    end
+  end
+end
+
+
+RSpec.describe RubySMB::Error::UnexpectedStatusCode do
+  context 'with a WindowsError::ErrorCode' do
+    it 'outputs the expected error message' do
+      ex = described_class.new(WindowsError::NTStatus::STATUS_BUFFER_OVERFLOW)
+      expect(ex.to_s).to eq('The server responded with an unexpected status code: STATUS_BUFFER_OVERFLOW')
+    end
+  end
+
+  context 'with an Integer' do
+    it 'outputs the expected error message' do
+      ex = described_class.new(0x80000005)
+      expect(ex.to_s).to eq('The server responded with an unexpected status code: STATUS_BUFFER_OVERFLOW')
+    end
+  end
+
+  context 'with an unsupported type' do
+    it 'raises the expected exception' do
+      expect { described_class.new(['wrong']) }.to raise_error(
+        ArgumentError,
+        'Status code must be a WindowsError::ErrorCode or an Integer, got Array'
+      )
+    end
+  end
+end

data/spec/lib/ruby_smb/smb1/packet/session_setup_legacy_request_spec.rb

@@ -10,8 +10,8 @@ RSpec.describe RubySMB::SMB1::Packet::SessionSetupLegacyRequest 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_SESSION_SETUP
+    it 'should have the command set to SMB_COM_SESSION_SETUP_ANDX' do
+      expect(header.command).to eq RubySMB::SMB1::Commands::SMB_COM_SESSION_SETUP_ANDX
     end
 
     it 'should not have the response flag set' do

data/spec/lib/ruby_smb/smb1/packet/session_setup_legacy_response_spec.rb

@@ -10,8 +10,8 @@ RSpec.describe RubySMB::SMB1::Packet::SessionSetupLegacyResponse 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_SESSION_SETUP
+    it 'should have the command set to SMB_COM_SESSION_SETUP_ANDX' do
+      expect(header.command).to eq RubySMB::SMB1::Commands::SMB_COM_SESSION_SETUP_ANDX
     end
 
     it 'should have the response flag set' do

data/spec/lib/ruby_smb/smb1/packet/session_setup_request_spec.rb

@@ -10,8 +10,8 @@ RSpec.describe RubySMB::SMB1::Packet::SessionSetupRequest 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_SESSION_SETUP
+    it 'should have the command set to SMB_COM_SESSION_SETUP_ANDX' do
+      expect(header.command).to eq RubySMB::SMB1::Commands::SMB_COM_SESSION_SETUP_ANDX
     end
 
     it 'should not have the response flag set' do

data/spec/lib/ruby_smb/smb1/packet/session_setup_response_spec.rb

@@ -11,7 +11,7 @@ RSpec.describe RubySMB::SMB1::Packet::SessionSetupResponse do
     end
 
     it 'should have the command set to SMB_COM_NEGOTIATE' do
-      expect(header.command).to eq RubySMB::SMB1::Commands::SMB_COM_SESSION_SETUP
+      expect(header.command).to eq RubySMB::SMB1::Commands::SMB_COM_SESSION_SETUP_ANDX
     end
 
     it 'should have the response flag set' do

data/spec/lib/ruby_smb/smb2/bit_field/session_flags_spec.rb

@@ -5,6 +5,7 @@ RSpec.describe RubySMB::SMB2::BitField::SessionFlags do
 
   it { is_expected.to respond_to :guest }
   it { is_expected.to respond_to :null }
+  it { is_expected.to respond_to :encrypt_data }
 
   it 'is little endian' do
     expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
@@ -25,4 +26,12 @@ RSpec.describe RubySMB::SMB2::BitField::SessionFlags do
 
     it_behaves_like 'bit field with one flag set', :null, 'v', 0x00000002
   end
+
+  describe '#encrypt_data' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.encrypt_data).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :encrypt_data, 'v', 0x00000004
+  end
 end

data/spec/lib/ruby_smb/smb2/bit_field/share_flags_spec.rb

@@ -1,6 +1,8 @@
 RSpec.describe RubySMB::SMB2::BitField::ShareFlags do
   subject(:flags) { described_class.new }
 
+  it { is_expected.to respond_to :vdo_caching }
+  it { is_expected.to respond_to :auto_caching }
   it { is_expected.to respond_to :dfs_root }
   it { is_expected.to respond_to :dfs }
   it { is_expected.to respond_to :encrypt }
@@ -11,11 +13,28 @@ RSpec.describe RubySMB::SMB2::BitField::ShareFlags do
   it { is_expected.to respond_to :namespace_caching }
   it { is_expected.to respond_to :shared_delete }
   it { is_expected.to respond_to :restrict_exclusive_opens }
+  it { is_expected.to respond_to :identity_remoting }
 
   it 'is little endian' do
     expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
   end
 
+  describe '#vdo_caching' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.vdo_caching).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :vdo_caching, 'V', 0x00000020
+  end
+
+  describe '#auto_caching' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.auto_caching).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :auto_caching, 'V', 0x00000010
+  end
+
   describe '#dfs' do
     it 'should be a 1-bit field per the SMB spec' do
       expect(flags.dfs).to be_a BinData::Bit1
@@ -96,6 +115,14 @@ RSpec.describe RubySMB::SMB2::BitField::ShareFlags do
     it_behaves_like 'bit field with one flag set', :encrypt, 'V', 0x00008000
   end
 
+  describe '#identity_remoting' do
+    it 'should be a 1-bit field per the SMB spec' do
+      expect(flags.identity_remoting).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :identity_remoting, 'V', 0x00040000
+  end
+
   describe '#set_manual_caching' do
     it 'turns off the caching bits' do
       flags.set_manual_caching

data/spec/lib/ruby_smb/smb2/file_spec.rb

@@ -43,6 +43,7 @@ RSpec.describe RubySMB::SMB2::File do
   it { is_expected.to respond_to :size }
   it { is_expected.to respond_to :size_on_disk }
   it { is_expected.to respond_to :tree }
+  it { is_expected.to respond_to :encryption_required }
 
   it 'pulls the attributes from the response packet' do
     expect(file.attributes).to eq create_response.file_attributes
@@ -52,10 +53,18 @@ RSpec.describe RubySMB::SMB2::File do
     expect(file.guid).to eq create_response.file_id
   end
 
-  it 'pulls the timestamps from the response packet' do
+  it 'pulls the last access timestamps from the response packet' do
     expect(file.last_access).to eq create_response.last_access.to_datetime
   end
 
+  it 'pulls the last change timestamps from the response packet' do
+    expect(file.last_change).to eq create_response.last_change.to_datetime
+  end
+
+  it 'pulls the last write timestamps from the response packet' do
+    expect(file.last_write).to eq create_response.last_write.to_datetime
+  end
+
   it 'pulls the size from the response packet' do
     expect(file.size).to eq create_response.end_of_file
   end
@@ -64,6 +73,10 @@ RSpec.describe RubySMB::SMB2::File do
     expect(file.size_on_disk).to eq create_response.allocation_size
   end
 
+  it 'sets the encryption_required flag to false by default' do
+    expect(file.encryption_required).to be false
+  end
+
   describe '#set_header_fields' do
     let(:request) { RubySMB::SMB2::Packet::ReadRequest.new }
     it 'calls the set_header_field method from the Tree' do
@@ -113,11 +126,17 @@ RSpec.describe RubySMB::SMB2::File do
 
       it 'uses a single packet to read the entire file' do
         expect(file).to receive(:read_packet).with(read_length: 108, offset: 0).and_return(small_read)
-        expect(client).to receive(:send_recv).with(small_read).and_return 'fake data'
+        expect(client).to receive(:send_recv).with(small_read, encrypt: false).and_return 'fake data'
         expect(RubySMB::SMB2::Packet::ReadResponse).to receive(:read).with('fake data').and_return(small_response)
         expect(file.read).to eq 'fake data'
       end
 
+      it 'calls Client #send_recv with encryption set if required' do
+        file.encryption_required = true
+        expect(client).to receive(:send_recv).with(small_read, encrypt: true)
+        file.read
+      end
+
       context 'when the response is not valid' do
         it 'raise an InvalidPacket exception' do
           small_response.smb2_header.command = RubySMB::SMB2::Commands::LOGOFF
@@ -155,6 +174,14 @@ RSpec.describe RubySMB::SMB2::File do
         file.read(bytes: (described_class::MAX_PACKET_SIZE * 2))
       end
 
+      it 'calls Client #send_recv with encryption set if required' do
+        read_request = double('Read Request')
+        allow(file).to receive(:read_packet).and_return(read_request)
+        file.encryption_required = true
+        expect(client).to receive(:send_recv).twice.with(read_request, encrypt: true)
+        file.read(bytes: (described_class::MAX_PACKET_SIZE * 2))
+      end
+
       context 'when the second response is not valid' do
         it 'raise an InvalidPacket exception' do
           allow(file).to receive(:read_packet).with(read_length: described_class::MAX_PACKET_SIZE, offset: described_class::MAX_PACKET_SIZE) do
@@ -204,6 +231,14 @@ RSpec.describe RubySMB::SMB2::File do
         expect(client).to receive(:send_recv).once.and_return(write_response.to_binary_s)
         file.write(data: 'test')
       end
+
+      it 'calls Client #send_recv with encryption set if required' do
+        write_request = double('Write Request')
+        allow(file).to receive(:write_packet).and_return(write_request)
+        file.encryption_required = true
+        expect(client).to receive(:send_recv).once.with(write_request, encrypt: true).and_return(write_response.to_binary_s)
+        file.write(data: 'test')
+      end
     end
 
     context 'for a large write' do
@@ -211,6 +246,14 @@ RSpec.describe RubySMB::SMB2::File do
         expect(client).to receive(:send_recv).twice.and_return(write_response.to_binary_s)
         file.write(data: SecureRandom.random_bytes(described_class::MAX_PACKET_SIZE + 1))
       end
+
+      it 'calls Client #send_recv with encryption set if required' do
+        write_request = double('Write Request')
+        allow(file).to receive(:write_packet).and_return(write_request)
+        file.encryption_required = true
+        expect(client).to receive(:send_recv).twice.with(write_request, encrypt: true).and_return(write_response.to_binary_s)
+        file.write(data: SecureRandom.random_bytes(described_class::MAX_PACKET_SIZE + 1))
+      end
     end
 
     it 'raises an InvalidPacket exception if the response is not valid' do
@@ -248,7 +291,7 @@ RSpec.describe RubySMB::SMB2::File do
 
       it 'uses a single packet to delete the entire file' do
         expect(file).to receive(:delete_packet).and_return(small_delete)
-        expect(client).to receive(:send_recv).with(small_delete).and_return 'raw_response'
+        expect(client).to receive(:send_recv).with(small_delete, encrypt: false).and_return 'raw_response'
         expect(RubySMB::SMB2::Packet::SetInfoResponse).to receive(:read).with('raw_response').and_return(small_response)
         expect(file.delete).to eq WindowsError::NTStatus::STATUS_SUCCESS
       end
@@ -260,6 +303,14 @@ RSpec.describe RubySMB::SMB2::File do
         allow(small_response).to receive(:valid?).and_return(false)
         expect { file.delete }.to raise_error(RubySMB::Error::InvalidPacket)
       end
+
+      it 'calls Client #send_recv with encryption set if required' do
+        allow(file).to receive(:delete_packet)
+        allow(RubySMB::SMB2::Packet::SetInfoResponse).to receive(:read).and_return(small_response)
+        file.encryption_required = true
+        expect(client).to receive(:send_recv).with(small_delete, encrypt: true)
+        file.delete
+      end
     end
   end
 
@@ -291,11 +342,18 @@ RSpec.describe RubySMB::SMB2::File do
 
       it 'uses a single packet to rename the entire file' do
         expect(file).to receive(:rename_packet).and_return(small_rename)
-        expect(client).to receive(:send_recv).with(small_rename).and_return 'raw_response'
+        expect(client).to receive(:send_recv).with(small_rename, encrypt: false).and_return 'raw_response'
         expect(RubySMB::SMB2::Packet::SetInfoResponse).to receive(:read).with('raw_response').and_return(small_response)
         expect(file.rename('new_file.txt')).to eq WindowsError::NTStatus::STATUS_SUCCESS
       end
 
+      it 'calls Client #send_recv with encryption set if required' do
+        allow(RubySMB::SMB2::Packet::SetInfoResponse).to receive(:read).and_return(small_response)
+        file.encryption_required = true
+        expect(client).to receive(:send_recv).with(small_rename, encrypt: true)
+        file.rename('new_file.txt')
+      end
+
       it 'raises an InvalidPacket exception if the response is not valid' do
         allow(client).to receive(:send_recv)
         allow(RubySMB::SMB2::Packet::SetInfoResponse).to receive(:read).and_return(small_response)
@@ -330,7 +388,13 @@ RSpec.describe RubySMB::SMB2::File do
     end
 
     it 'calls Client #send_recv with the expected request' do
-      expect(client).to receive(:send_recv).with(request)
+      expect(client).to receive(:send_recv).with(request, encrypt: false)
+      file.close
+    end
+
+    it 'calls Client #send_recv with encryption set if required' do
+      file.encryption_required = true
+      expect(client).to receive(:send_recv).with(request, encrypt: true)
       file.close
     end
 
@@ -394,7 +458,15 @@ RSpec.describe RubySMB::SMB2::File do
     it 'calls Client #send_recv with the expected request' do
       request = double('Request')
       allow(file).to receive(:read_packet).and_return(request)
-      expect(client).to receive(:send_recv).with(request)
+      expect(client).to receive(:send_recv).with(request, encrypt: false)
+      file.send_recv_read
+    end
+
+    it 'calls Client #send_recv with encryption set if required' do
+      request = double('Request')
+      allow(file).to receive(:read_packet).and_return(request)
+      file.encryption_required = true
+      expect(client).to receive(:send_recv).with(request, encrypt: true)
       file.send_recv_read
     end
 
@@ -408,33 +480,6 @@ RSpec.describe RubySMB::SMB2::File do
       expect { file.send_recv_read }.to raise_error(RubySMB::Error::InvalidPacket)
     end
 
-    context 'when the response status code is STATUS_PENDING' do
-      before :example do
-        allow(file).to receive(:sleep)
-        allow(read_response).to receive(:status_code).and_return(WindowsError::NTStatus::STATUS_PENDING)
-        allow(dispatcher).to receive(:recv_packet).and_return(raw_response)
-      end
-
-      it 'wait 1 second and calls Client dispatcher #recv_packet method one more time' do
-        expect(file).to receive(:sleep).with(1)
-        expect(dispatcher).to receive(:recv_packet)
-        file.send_recv_read
-      end
-
-      it 'parses the response as a SMB2 ReadResponse packet' do
-        expect(RubySMB::SMB2::Packet::ReadResponse).to receive(:read).twice.with(raw_response)
-        file.send_recv_read
-      end
-
-      it 'raises an InvalidPacket exception if the response is not valid' do
-        allow(dispatcher).to receive(:recv_packet) do
-          allow(read_response).to receive(:valid?).and_return(false)
-          raw_response
-        end
-        expect { file.send_recv_read }.to raise_error(RubySMB::Error::InvalidPacket)
-      end
-    end
-
     it 'raises an UnexpectedStatusCode exception if the response status code is not STATUS_SUCCESS' do
       allow(read_response).to receive(:status_code).and_return(WindowsError::NTStatus::STATUS_OBJECT_NAME_NOT_FOUND)
       expect { file.send_recv_read }.to raise_error(RubySMB::Error::UnexpectedStatusCode)
@@ -457,7 +502,7 @@ RSpec.describe RubySMB::SMB2::File do
 
     before :example do
       allow(file).to receive(:write_packet).and_return(request)
-      allow(client).to receive(:send_recv).and_return(raw_response)
+      allow(client).to receive(:send_recv).and_return(raw_response, encrypt: false)
       allow(RubySMB::SMB2::Packet::WriteResponse).to receive(:read).with(raw_response).and_return(write_response)
     end
 
@@ -478,40 +523,19 @@ RSpec.describe RubySMB::SMB2::File do
     end
 
     it 'calls Client #send_recv with the expected request' do
-      expect(client).to receive(:send_recv).with(request)
+      expect(client).to receive(:send_recv).with(request, encrypt: false)
       file.send_recv_write
     end
 
-    it 'parses the response as a SMB1 WriteResponse packet' do
-      expect(RubySMB::SMB2::Packet::WriteResponse).to receive(:read).with(raw_response)
+    it 'calls Client #send_recv with encryption set if required' do
+      file.encryption_required = true
+      expect(client).to receive(:send_recv).with(request, encrypt: true)
       file.send_recv_write
     end
 
-    context 'when the response status code is STATUS_PENDING' do
-      before :example do
-        allow(file).to receive(:sleep)
-        allow(write_response).to receive(:status_code).and_return(WindowsError::NTStatus::STATUS_PENDING)
-        allow(dispatcher).to receive(:recv_packet).and_return(raw_response)
-      end
-
-      it 'wait 1 second and calls Client dispatcher #recv_packet method one more time' do
-        expect(file).to receive(:sleep).with(1)
-        expect(dispatcher).to receive(:recv_packet)
-        file.send_recv_write
-      end
-
-      it 'parses the response as a SMB2 WriteResponse packet' do
-        expect(RubySMB::SMB2::Packet::WriteResponse).to receive(:read).twice.with(raw_response)
-        file.send_recv_write
-      end
-
-      it 'raises an InvalidPacket exception if the response is not valid' do
-        allow(dispatcher).to receive(:recv_packet) do
-          allow(write_response).to receive(:valid?).and_return(false)
-          raw_response
-        end
-        expect { file.send_recv_write }.to raise_error(RubySMB::Error::InvalidPacket)
-      end
+    it 'parses the response as a SMB1 WriteResponse packet' do
+      expect(RubySMB::SMB2::Packet::WriteResponse).to receive(:read).with(raw_response)
+      file.send_recv_write
     end
 
     it 'raises an InvalidPacket exception if the response is not valid' do