ruby_smb 0.0.18 → 0.0.19

data/spec/lib/ruby_smb/nbss/negative_session_response_spec.rb

@@ -0,0 +1,29 @@
+RSpec.describe RubySMB::Nbss::NegativeSessionResponse do
+  subject(:negative_session_response) { described_class.new }
+
+  it { is_expected.to respond_to :session_header }
+  it { is_expected.to respond_to :error_code }
+
+  it 'is big endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :big
+  end
+
+  describe '#session_header' do
+    it 'is a SessionHeader field' do
+      expect(negative_session_response.session_header).to be_a RubySMB::Nbss::SessionHeader
+    end
+  end
+
+  describe '#error_code' do
+    it 'is a 8-bit Unsigned Integer' do
+      expect(negative_session_response.error_code).to be_a BinData::Uint8
+    end
+  end
+
+  describe '#error_msg' do
+    it 'returns a string describing the error' do
+      negative_session_response.error_code = 0x80
+      expect(negative_session_response.error_msg).to eq 'Not listening on called name'
+    end
+  end
+end

data/spec/lib/ruby_smb/nbss/session_header_spec.rb

@@ -0,0 +1,30 @@
+RSpec.describe RubySMB::Nbss::SessionHeader do
+  subject(:session_header) { described_class.new }
+
+  it { is_expected.to respond_to :session_packet_type }
+  it { is_expected.to respond_to :flags }
+  it { is_expected.to respond_to :packet_length }
+
+  it 'is big endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :big
+  end
+
+  describe '#session_packet_type' do
+    it 'is a 8-bit Unsigned Integer' do
+      expect(session_header.session_packet_type).to be_a BinData::Uint8
+    end
+  end
+
+  describe '#flags' do
+    it 'is a 8-bit Unsigned Integer' do
+      expect(session_header.flags).to be_a BinData::Uint8
+    end
+  end
+
+  describe '#packet_length' do
+    it 'is a 16-bit Unsigned Integer' do
+      expect(session_header.packet_length).to be_a BinData::Uint16be
+    end
+  end
+end
+

data/spec/lib/ruby_smb/nbss/session_request_spec.rb

@@ -0,0 +1,30 @@
+RSpec.describe RubySMB::Nbss::SessionRequest do
+  subject(:session_request) { described_class.new }
+
+  it { is_expected.to respond_to :session_header }
+  it { is_expected.to respond_to :called_name }
+  it { is_expected.to respond_to :calling_name }
+
+  it 'is big endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :big
+  end
+
+  describe '#session_header' do
+    it 'is a SessionHeader field' do
+      expect(session_request.session_header).to be_a RubySMB::Nbss::SessionHeader
+    end
+  end
+
+  describe '#called_name' do
+    it 'is a string' do
+      expect(session_request.called_name).to be_a BinData::String
+    end
+  end
+
+  describe '#calling_name' do
+    it 'is a string' do
+      expect(session_request.calling_name).to be_a BinData::String
+    end
+  end
+end
+

data/spec/lib/ruby_smb/smb1/bit_field/create_options_spec.rb

@@ -171,6 +171,14 @@ RSpec.describe RubySMB::SMB1::BitField::CreateOptions do
     it_behaves_like 'bit field with one flag set', :open_no_recall, 'V', 0x00400000
   end
 
+  describe '#open_reparse_point' do
+    it 'is a 1-bit flag' do
+      expect(options.reserve_opfilter).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :open_reparse_point, 'V', 0x00200000
+  end
+
   describe '#reserve_opfilter' do
     it 'is a 1-bit flag' do
       expect(options.reserve_opfilter).to be_a BinData::Bit1
@@ -178,4 +186,4 @@ RSpec.describe RubySMB::SMB1::BitField::CreateOptions do
 
     it_behaves_like 'bit field with one flag set', :reserve_opfilter, 'V', 0x00100000
   end
-end
+end

data/spec/lib/ruby_smb/smb1/bit_field/directory_access_mask_spec.rb

@@ -34,7 +34,6 @@ RSpec.describe RubySMB::SMB1::BitField::DirectoryAccessMask do
     it_behaves_like 'bit field with one flag set', :list, 'V', 0x00000001
   end
 
-
   describe '#add_file' do
     it 'should be a 1-bit field per the SMB spec' do
       expect(flags.add_file).to be_a BinData::Bit1
@@ -186,5 +185,4 @@ RSpec.describe RubySMB::SMB1::BitField::DirectoryAccessMask do
 
     it_behaves_like 'bit field with one flag set', :generic_read, 'V', 0x80000000
   end
-
 end

data/spec/lib/ruby_smb/smb1/bit_field/file_access_mask_spec.rb

@@ -34,7 +34,6 @@ RSpec.describe RubySMB::SMB1::BitField::FileAccessMask do
     it_behaves_like 'bit field with one flag set', :read_data, 'V', 0x00000001
   end
 
-
   describe '#write_data' do
     it 'should be a 1-bit field per the SMB spec' do
       expect(flags.write_data).to be_a BinData::Bit1
@@ -186,5 +185,4 @@ RSpec.describe RubySMB::SMB1::BitField::FileAccessMask do
 
     it_behaves_like 'bit field with one flag set', :generic_read, 'V', 0x80000000
   end
-
 end

data/spec/lib/ruby_smb/smb1/bit_field/file_status_flags_spec.rb

@@ -0,0 +1,35 @@
+RSpec.describe RubySMB::SMB1::BitField::FileStatusFlags do
+  subject(:options) { described_class.new }
+
+  it { is_expected.to respond_to :reparse_tag }
+  it { is_expected.to respond_to :no_substreams }
+  it { is_expected.to respond_to :no_eas }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#reparse_tag' do
+    it 'is a 1-bit flag' do
+      expect(options.reparse_tag).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :reparse_tag, 'v', 0x0004
+  end
+
+  describe '#no_substreams' do
+    it 'is a 1-bit flag' do
+      expect(options.no_substreams).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :no_substreams, 'v', 0x0002
+  end
+
+  describe '#no_eas' do
+    it 'is a 1-bit flag' do
+      expect(options.no_eas).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :no_eas, 'v', 0x0001
+  end
+end

data/spec/lib/ruby_smb/smb1/bit_field/open2_access_mode_spec.rb

@@ -73,9 +73,7 @@ RSpec.describe RubySMB::SMB1::BitField::Open2AccessMode do
     end
 
     it 'raises an ArgumentError if given an invalid mode' do
-      expect{flags.set_access_mode('abcd')}.to raise_error(ArgumentError)
+      expect { flags.set_access_mode('abcd') }.to raise_error(ArgumentError)
     end
   end
-
-
 end

data/spec/lib/ruby_smb/smb1/bit_field/open2_flags_spec.rb

@@ -57,6 +57,4 @@ RSpec.describe RubySMB::SMB1::BitField::Open2Flags do
 
     it_behaves_like 'bit field with one flag set', :req_easize, 'v', 0x0008
   end
-
-
 end

data/spec/lib/ruby_smb/smb1/bit_field/open2_open_mode_spec.rb

@@ -23,5 +23,4 @@ RSpec.describe RubySMB::SMB1::BitField::Open2OpenMode do
 
     it_behaves_like 'bit field with one flag set', :create_file, 'v', 0x0010
   end
-
 end

data/spec/lib/ruby_smb/smb1/bit_field/optional_support_spec.rb

@@ -48,5 +48,4 @@ RSpec.describe RubySMB::SMB1::BitField::OptionalSupport do
 
     it_behaves_like 'bit field with one flag set', :extended_signature, 'v', 0x0020
   end
-
 end

data/spec/lib/ruby_smb/smb1/bit_field/security_flags_spec.rb

@@ -0,0 +1,26 @@
+RSpec.describe RubySMB::SMB1::BitField::SecurityFlags do
+  subject(:options) { described_class.new }
+
+  it { is_expected.to respond_to :effective_only }
+  it { is_expected.to respond_to :context_tracking }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+
+  describe '#effective_only' do
+    it 'is a 1-bit flag' do
+      expect(options.effective_only).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :effective_only, 'C', 0x02
+  end
+
+  describe '#context_tracking' do
+    it 'is a 1-bit flag' do
+      expect(options.context_tracking).to be_a BinData::Bit1
+    end
+
+    it_behaves_like 'bit field with one flag set', :context_tracking, 'C', 0x01
+  end
+end

data/spec/lib/ruby_smb/smb1/bit_field/share_access_spec.rb

@@ -32,7 +32,4 @@ RSpec.describe RubySMB::SMB1::BitField::ShareAccess do
 
     it_behaves_like 'bit field with one flag set', :share_delete, 'V', 0x00000004
   end
-
-
-
 end

data/spec/lib/ruby_smb/smb1/bit_field/smb_ext_file_attributes_spec.rb

@@ -9,13 +9,11 @@ RSpec.describe RubySMB::SMB1::BitField::SmbExtFileAttributes do
   it { is_expected.to respond_to :read_only }
   it { is_expected.to respond_to :compressed }
   it { is_expected.to respond_to :temporary }
-  it { is_expected.to respond_to :write_through }
-  it { is_expected.to respond_to :no_buffering }
-  it { is_expected.to respond_to :random_access }
-  it { is_expected.to respond_to :sequential_scan }
-  it { is_expected.to respond_to :delete_on_close }
-  it { is_expected.to respond_to :backup_semantics }
-  it { is_expected.to respond_to :posix_semantics }
+  it { is_expected.to respond_to :encrypted }
+  it { is_expected.to respond_to :not_content_indexed }
+  it { is_expected.to respond_to :offline }
+  it { is_expected.to respond_to :reparse_point }
+  it { is_expected.to respond_to :sparse }
 
   it 'is little endian' do
     expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
@@ -85,60 +83,43 @@ RSpec.describe RubySMB::SMB1::BitField::SmbExtFileAttributes do
     it_behaves_like 'bit field with one flag set', :compressed, 'V', 0x00000800
   end
 
-  describe 'posix_semantics' do
+  describe 'encrypted' do
     it 'should be a 1-bit field per the SMB spec' do
-      expect(attrs.posix_semantics).to be_a BinData::Bit1
+      expect(attrs.encrypted).to be_a BinData::Bit1
     end
 
-    it_behaves_like 'bit field with one flag set', :posix_semantics, 'V', 0x01000000
+    it_behaves_like 'bit field with one flag set', :encrypted, 'V', 0x00004000
   end
 
-  describe 'backup_semantics' do
+  describe 'not_content_indexed' do
     it 'should be a 1-bit field per the SMB spec' do
-      expect(attrs.backup_semantics).to be_a BinData::Bit1
+      expect(attrs.not_content_indexed).to be_a BinData::Bit1
     end
 
-    it_behaves_like 'bit field with one flag set', :backup_semantics, 'V', 0x02000000
+    it_behaves_like 'bit field with one flag set', :not_content_indexed, 'V', 0x00002000
   end
 
-  describe 'delete_on_close' do
+  describe 'offline' do
     it 'should be a 1-bit field per the SMB spec' do
-      expect(attrs.delete_on_close).to be_a BinData::Bit1
+      expect(attrs.offline).to be_a BinData::Bit1
     end
 
-    it_behaves_like 'bit field with one flag set', :delete_on_close, 'V', 0x04000000
+    it_behaves_like 'bit field with one flag set', :offline, 'V', 0x00001000
   end
 
-  describe 'sequential_scan' do
+  describe 'reparse_point' do
     it 'should be a 1-bit field per the SMB spec' do
-      expect(attrs.sequential_scan).to be_a BinData::Bit1
+      expect(attrs.reparse_point).to be_a BinData::Bit1
     end
 
-    it_behaves_like 'bit field with one flag set', :sequential_scan, 'V', 0x08000000
+    it_behaves_like 'bit field with one flag set', :reparse_point, 'V', 0x00000400
   end
 
-  describe 'random_access' do
+  describe 'sparse' do
     it 'should be a 1-bit field per the SMB spec' do
-      expect(attrs.random_access).to be_a BinData::Bit1
+      expect(attrs.sparse).to be_a BinData::Bit1
     end
 
-    it_behaves_like 'bit field with one flag set', :random_access, 'V', 0x10000000
+    it_behaves_like 'bit field with one flag set', :sparse, 'V', 0x00000200
   end
-
-  describe 'no_buffering' do
-    it 'should be a 1-bit field per the SMB spec' do
-      expect(attrs.no_buffering).to be_a BinData::Bit1
-    end
-
-    it_behaves_like 'bit field with one flag set', :no_buffering, 'V', 0x20000000
-  end
-
-  describe 'write_through' do
-    it 'should be a 1-bit field per the SMB spec' do
-      expect(attrs.write_through).to be_a BinData::Bit1
-    end
-
-    it_behaves_like 'bit field with one flag set', :write_through, 'V', 0x80000000
-  end
-
 end

data/spec/lib/ruby_smb/smb1/bit_field/smb_file_attributes_spec.rb

@@ -104,10 +104,4 @@ RSpec.describe RubySMB::SMB1::BitField::SmbFileAttributes do
 
     it_behaves_like 'bit field with one flag set', :search_archive, 'v', 0x2000
   end
-
-
-
-
-
-
 end

data/spec/lib/ruby_smb/smb1/bit_field/smb_nmpipe_status_spec.rb

@@ -48,6 +48,4 @@ RSpec.describe RubySMB::SMB1::BitField::SmbNmpipeStatus do
 
     it_behaves_like 'bit field with one flag set', :nonblocking, 'v', 0x8000
   end
-
-
 end

data/spec/lib/ruby_smb/smb1/bit_field/trans2_flags_spec.rb

@@ -23,6 +23,4 @@ RSpec.describe RubySMB::SMB1::BitField::Trans2Flags do
 
     it_behaves_like 'bit field with one flag set', :disconnect, 'C', 0x01
   end
-
-
 end

data/spec/lib/ruby_smb/smb1/bit_field/tree_connect_flags_spec.rb

@@ -32,6 +32,4 @@ RSpec.describe RubySMB::SMB1::BitField::TreeConnectFlags do
 
     it_behaves_like 'bit field with one flag set', :disconnect, 'C', 0x01
   end
-
-
 end

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

@@ -0,0 +1,469 @@
+RSpec.describe RubySMB::SMB1::File do
+
+  let(:dispatcher) { RubySMB::Dispatcher::Socket.new(double('socket')) }
+  let(:client) { RubySMB::Client.new(dispatcher, username: 'msfadmin', password: 'msfadmin') }
+  let(:connect_response) {
+    packet = RubySMB::SMB1::Packet::TreeConnectResponse.new
+    packet.smb_header.tid = 2051
+    packet.parameter_block.guest_access_rights.read("\xff\x01\x1f\x00")
+    packet.parameter_block.access_rights.read("\xff\x01\x1f\x01")
+    packet
+  }
+  let(:tree) { RubySMB::SMB1::Tree.new(client: client, share: '\\1.2.3.4\Share', response: connect_response) }
+  let(:nt_create_andx_response) {
+    response = RubySMB::SMB1::Packet::NtCreateAndxResponse.new
+    response.parameter_block.ext_file_attributes = { normal: 1 }
+    response.parameter_block.fid = 0x4000
+    response.parameter_block.last_access_time = DateTime.parse("2017-09-20T1:1:1")
+    response.parameter_block.last_change_time = DateTime.parse("2017-09-22T2:2:2")
+    response.parameter_block.last_write_time  = DateTime.parse("2017-09-25T3:3:3")
+    response.parameter_block.end_of_file = 53
+    response.parameter_block.allocation_size = 4096
+    response
+  }
+  let(:filename) { 'specfile.txt' }
+
+  subject(:file) {
+    described_class.new(tree: tree, response: nt_create_andx_response, name: filename)
+  }
+
+  it { is_expected.to respond_to :tree }
+  it { is_expected.to respond_to :name }
+  it { is_expected.to respond_to :attributes }
+  it { is_expected.to respond_to :fid }
+  it { is_expected.to respond_to :last_access }
+  it { is_expected.to respond_to :last_change }
+  it { is_expected.to respond_to :last_write }
+  it { is_expected.to respond_to :size }
+  it { is_expected.to respond_to :size_on_disk }
+
+  it 'raises an exception when tree is no provided' do
+    expect { described_class.new(tree: nil, response: nt_create_andx_response, name: filename) }.to raise_error(ArgumentError)
+  end
+
+  it 'raises an exception when response is no provided' do
+    expect { described_class.new(tree: tree, response: nil, name: filename) }.to raise_error(ArgumentError)
+  end
+
+  it 'raises an exception when name is no provided' do
+    expect { described_class.new(tree: tree, response: nt_create_andx_response, name: nil) }.to raise_error(ArgumentError)
+  end
+
+  it 'inherits the tree that spawned it' do
+    expect(file.tree).to eq tree
+  end
+
+  it 'sets the file name to the name passed as argument' do
+    expect(file.name).to eq filename
+  end
+
+  it 'inherits the attributes from the response packet' do
+    expect(file.attributes).to eq nt_create_andx_response.parameter_block.ext_file_attributes
+  end
+
+  it 'inherits the file ID from the response packet' do
+    expect(file.fid).to eq nt_create_andx_response.parameter_block.fid
+  end
+
+  it 'inherits the last_access from the response packet' do
+    expect(file.last_access).to eq nt_create_andx_response.parameter_block.last_access_time.to_datetime
+  end
+
+  it 'inherits the last_change from the response packet' do
+    expect(file.last_change).to eq nt_create_andx_response.parameter_block.last_change_time.to_datetime
+  end
+
+  it 'inherits the last_write from the response packet' do
+    expect(file.last_write).to eq nt_create_andx_response.parameter_block.last_write_time.to_datetime
+  end
+
+  it 'inherits the size from the response packet' do
+    expect(file.size).to eq nt_create_andx_response.parameter_block.end_of_file
+  end
+
+  it 'inherits the size_on_disk from the response packet' do
+    expect(file.size_on_disk).to eq nt_create_andx_response.parameter_block.allocation_size
+  end
+
+  describe '#set_header_fields' do
+    let(:request) { RubySMB::SMB1::Packet::ReadAndxRequest.new }
+    it 'calls the set_header_field method from the Tree' do
+      expect(tree).to receive(:set_header_fields).with(request).and_call_original
+      file.set_header_fields(request)
+    end
+
+    it 'sets the packet file_id from the guid' do
+      expect(file.set_header_fields(request).parameter_block.fid).to eq file.fid
+    end
+  end
+
+  describe '#read_packet' do
+    it 'creates a new ReadAndxRequest packet' do
+      expect(RubySMB::SMB1::Packet::ReadAndxRequest).to receive(:new).and_call_original
+      file.read_packet
+    end
+
+    it 'calls #set_header_fields to set ReadAndxRequest header fields' do
+      request = RubySMB::SMB1::Packet::ReadAndxRequest.new
+      allow(RubySMB::SMB1::Packet::ReadAndxRequest).to receive(:new).and_return(request)
+      expect(file).to receive(:set_header_fields).with(request).and_call_original
+      file.read_packet
+    end
+
+    it 'sets the read_length of the packet' do
+      expect(file.read_packet(read_length: 55).parameter_block.max_count_of_bytes_to_return).to eq 55
+    end
+
+    it 'sets the offset of the packet' do
+      expect(file.read_packet(offset: 55).parameter_block.offset).to eq 55
+    end
+  end
+
+  describe '#read' do
+    let(:read_data) { 'read data' }
+    let(:raw_response) { double('fake raw response data') }
+    let(:read_andx_response) {
+      res = RubySMB::SMB1::Packet::ReadAndxResponse.new
+      res.data_block.data = read_data
+      res
+    }
+
+    before :example do
+      allow(client).to receive(:send_recv).and_return(raw_response)
+      allow(RubySMB::SMB1::Packet::ReadAndxResponse).to receive(:read).with(raw_response).and_return(read_andx_response)
+    end
+
+    context 'when the number of bytes to read is not provided' do
+      it 'reads #size bytes by default' do
+        expect(file).to receive(:read_packet).with(read_length: file.size, offset: 0).once.and_call_original
+        expect(file.read).to eq(read_data)
+      end
+    end
+
+    context 'when the number of bytes to read is less than or equal to max_buffer_size' do
+      it 'reads only one packet with the number of bytes provided as argument' do
+        client.max_buffer_size = read_data.size
+        expect(file).to receive(:read_packet).with(read_length: read_data.size, offset: 0).once.and_call_original
+        expect(file.read(bytes: read_data.size)).to eq(read_data)
+      end
+    end
+
+    context 'when the number of bytes to read is greater than max_buffer_size' do
+      it 'reads multiple packets with at most max_buffer_size bytes per chunk' do
+        client.max_buffer_size = read_data.size - 1
+        read_io = StringIO.new(read_data)
+        expect(file).to receive(:read_packet).with(read_length: client.max_buffer_size, offset: 0).once.ordered.and_call_original
+        expect(file).to receive(:read_packet).with(read_length: (read_data.size - client.max_buffer_size), offset: client.max_buffer_size).once.ordered.and_call_original
+        allow(RubySMB::SMB1::Packet::ReadAndxResponse).to receive(:read).with(raw_response) do
+          read_andx_response.data_block.data = read_io.read(client.max_buffer_size)
+          read_andx_response
+        end
+        expect(file.read(bytes: read_data.size)).to eq(read_data)
+      end
+    end
+
+    context 'when sending the request packet and gets a response back' do
+      context 'when the response is not a ReadAndxResponse packet' do
+        it 'raise an InvalidPacket exception' do
+          read_andx_response.smb_header.command = RubySMB::SMB1::Commands::SMB_COM_ECHO
+          expect { file.read }.to raise_error(RubySMB::Error::InvalidPacket)
+        end
+      end
+
+      context 'when the response status code is not STATUS_SUCCESS' do
+        it 'raise an UnexpectedStatusCode exception' do
+          read_andx_response.smb_header.nt_status = WindowsError::NTStatus::STATUS_INVALID_HANDLE.value
+          expect { file.read }.to raise_error(RubySMB::Error::UnexpectedStatusCode)
+        end
+      end
+
+      context 'when the response is an EmptyPacket with the SMB_COM_READ_ANDX command and STATUS_SUCCESS status code' do
+        let(:empty_packet) do
+          empty_packet = RubySMB::SMB1::Packet::EmptyPacket.new
+          empty_packet.smb_header.command = RubySMB::SMB1::Commands::SMB_COM_READ_ANDX
+          empty_packet
+        end
+
+        it 'returns an empty string if it is the first request' do
+          allow(RubySMB::SMB1::Packet::ReadAndxResponse).to receive(:read).with(raw_response).and_return(empty_packet)
+          expect(file.read).to eq('')
+        end
+
+        it 'returns the current read data if it happens after the first request' do
+          partial_data = read_data[0..-2]
+          client.max_buffer_size = partial_data.size
+          first_request = true
+          allow(RubySMB::SMB1::Packet::ReadAndxResponse).to receive(:read).with(raw_response).twice do
+            if first_request
+              read_andx_response.data_block.data = partial_data
+              first_request = false
+              read_andx_response
+            else
+              empty_packet
+            end
+          end
+          expect(file.read(bytes: read_data.size)).to eq(partial_data)
+        end
+      end
+    end
+  end
+
+  describe '#write_packet' do
+    it 'creates a new WriteAndxRequest packet' do
+      expect(RubySMB::SMB1::Packet::WriteAndxRequest).to receive(:new).and_call_original
+      file.write_packet
+    end
+
+    it 'calls #set_header_fields to set WriteAndxRequest headers' do
+      request = RubySMB::SMB1::Packet::WriteAndxRequest.new
+      allow(RubySMB::SMB1::Packet::WriteAndxRequest).to receive(:new).and_return(request)
+      expect(file).to receive(:set_header_fields).with(request).and_call_original
+      file.write_packet
+    end
+
+    it 'sets the offset of the packet' do
+      expect(file.write_packet(offset: 55).parameter_block.offset).to eq 55
+    end
+
+    it 'sets the write_mode to writethrough_mode' do
+      expect(file.write_packet.parameter_block.write_mode.writethrough_mode).to eq 1
+    end
+
+    it 'sets the remaining number of bytes to data_length value' do
+      data = 'write data'
+      write_andx_request = file.write_packet(data: data)
+      expect(write_andx_request.parameter_block.remaining).to eq write_andx_request.parameter_block.data_length
+      expect(write_andx_request.parameter_block.remaining).to eq data.size
+    end
+
+    it 'sets the data of the packet' do
+      data = 'write data'
+      expect(file.write_packet(data: data).data_block.data).to eq data
+    end
+  end
+
+  describe '#write' do
+    let(:write_data) { 'write data' }
+    let(:raw_response) { double('fake raw response data') }
+    let(:write_andx_response) do
+      response = RubySMB::SMB1::Packet::WriteAndxResponse.new
+      response.parameter_block.count_low = write_data.size
+      response
+    end
+
+    before :example do
+      allow(client).to receive(:send_recv).and_return(raw_response)
+      allow(RubySMB::SMB1::Packet::WriteAndxResponse).to receive(:read).with(raw_response).and_return(write_andx_response)
+    end
+
+    describe 'offset' do
+      it 'writes from offset 0 by default' do
+        expect(file).to receive(:write_packet).with(data: write_data, offset: 0).and_call_original
+        file.write(data: write_data)
+      end
+
+      it 'writes from the offset passed as arguement' do
+        offset = 10
+        expect(file).to receive(:write_packet).with(data: write_data, offset: offset).and_call_original
+        file.write(data: write_data, offset: offset)
+      end
+    end
+
+    context 'when the buffer size is less than or equal to max_buffer_size' do
+      it 'sends only one packet with the entire buffer' do
+        client.max_buffer_size = write_data.size
+        expect(file).to receive(:write_packet).with(data: write_data, offset: 0).once.and_call_original
+        expect(file.write(data: write_data)).to eq write_data.size
+      end
+    end
+
+    context 'when the buffer size is greater than max_buffer_size' do
+      it 'sends multiple packets with at most max_buffer_size bytes per chunk' do
+        client.max_buffer_size = write_data.size - 1
+        first_data_chunk = write_data[0, client.max_buffer_size]
+        second_data_chunk = write_data[client.max_buffer_size..-1]
+        original_write_packet = file.method(:write_packet)
+
+        expect(file).to receive(:write_packet).with(data: first_data_chunk , offset: 0).once do
+          allow(RubySMB::SMB1::Packet::WriteAndxResponse).to receive(:read).with(raw_response) do
+            write_andx_response.parameter_block.count_low = first_data_chunk.size
+            write_andx_response
+          end
+          original_write_packet.call(data: first_data_chunk, offset: 0)
+        end
+        expect(file).to receive(:write_packet).with(data: second_data_chunk, offset: client.max_buffer_size).once do
+          allow(RubySMB::SMB1::Packet::WriteAndxResponse).to receive(:read).with(raw_response) do
+            write_andx_response.parameter_block.count_low = second_data_chunk.size
+            write_andx_response
+          end
+          original_write_packet.call(data: second_data_chunk, offset: client.max_buffer_size)
+        end
+        expect(file.write(data: write_data)).to eq write_data.size
+      end
+    end
+
+    context 'when sending the request packet and gets a response back' do
+      context 'when the response is not a WriteAndxResponse packet' do
+        it 'raise an InvalidPacket exception' do
+          write_andx_response.smb_header.command = RubySMB::SMB1::Commands::SMB_COM_ECHO
+          expect { file.write(data: write_data) }.to raise_error(RubySMB::Error::InvalidPacket)
+        end
+      end
+
+      context 'when the response status code is not STATUS_SUCCESS' do
+        it 'raise an UnexpectedStatusCode exception' do
+          write_andx_response.smb_header.nt_status = WindowsError::NTStatus::STATUS_INVALID_HANDLE.value
+          expect { file.write(data: write_data) }.to raise_error(RubySMB::Error::UnexpectedStatusCode)
+        end
+      end
+    end
+  end
+
+  describe '#append' do
+    it 'calls #write with the expected data and the offset set to the end of the file (file size)' do
+      data = 'append data'
+      expect(file).to receive(:write).with(data: data, offset: file.size)
+      file.append(data: data)
+    end
+  end
+
+  describe '#delete' do
+    let(:set_info_res) { RubySMB::SMB1::Packet::Trans2::SetFileInformationResponse.new }
+
+    before :example do
+      allow(client).to receive(:send_recv)
+      allow(RubySMB::SMB1::Packet::Trans2::SetFileInformationResponse).to receive(:read).and_return(set_info_res)
+    end
+
+    it 'calls #delete_packet' do
+      expect(file).to receive(:delete_packet)
+      file.delete
+    end
+
+    it 'returns the response NTStatus code' do
+      status = WindowsError::NTStatus::STATUS_SUCCESS
+      set_info_res.smb_header.nt_status = status.value
+      expect(file.delete).to eq status
+    end
+  end
+
+  describe '#delete_packet' do
+    let(:request) do
+      request = RubySMB::SMB1::Packet::Trans2::SetFileInformationRequest.new
+      passthrough_info_level = RubySMB::Fscc::FileInformation::FILE_DISPOSITION_INFORMATION +
+        RubySMB::Fscc::FileInformation::SMB_INFO_PASSTHROUGH
+      request.data_block.trans2_parameters.information_level = passthrough_info_level
+      request
+    end
+
+    before :example do
+      allow(RubySMB::SMB1::Packet::Trans2::SetFileInformationRequest).to receive(:new).and_return(request)
+    end
+
+    it 'creates a new Trans2 SetFileInformationRequest packet' do
+      expect(RubySMB::SMB1::Packet::Trans2::SetFileInformationRequest).to receive(:new).and_return(request)
+      file.delete_packet
+    end
+
+    it 'calls Tree #set_header_fields to set SetFileInformationRequest headers' do
+      expect(tree).to receive(:set_header_fields).with(request).and_call_original
+      file.delete_packet
+    end
+
+    it 'sets the Trans2 parameter #fid of the packet with the File FID' do
+      fid = 0x1000
+      file.fid = fid
+      expect(file.delete_packet.data_block.trans2_parameters.fid).to eq fid
+    end
+
+    it 'sets the Trans2 parameter #information_level of the packet' do
+      request.data_block.trans2_parameters.information_level = 0
+      passthrough_info_level = RubySMB::Fscc::FileInformation::FILE_DISPOSITION_INFORMATION +
+        RubySMB::Fscc::FileInformation::SMB_INFO_PASSTHROUGH
+      expect(file.delete_packet.data_block.trans2_parameters.information_level).to eq passthrough_info_level
+    end
+
+    it 'sets the File Information #delete_pending field of the packet' do
+      expect(file.delete_packet.data_block.trans2_data.info_level_struct.delete_pending).to eq 1
+    end
+
+    it 'sets the Trans2 ParameterBlock fields' do
+      parameter_block = file.delete_packet.parameter_block
+      expect(parameter_block.total_parameter_count).to eq request.parameter_block.parameter_count
+      expect(parameter_block.total_data_count).to eq request.parameter_block.data_count
+      expect(parameter_block.max_parameter_count).to eq request.parameter_block.parameter_count
+      expect(parameter_block.max_data_count).to eq 16_384
+    end
+  end
+
+  describe '#rename' do
+    let(:set_info_res) { RubySMB::SMB1::Packet::Trans2::SetFileInformationResponse.new }
+    let(:filename) { 'file.txt' }
+
+    before :example do
+      allow(client).to receive(:send_recv)
+      allow(RubySMB::SMB1::Packet::Trans2::SetFileInformationResponse).to receive(:read).and_return(set_info_res)
+    end
+
+    it 'calls #rename_packet' do
+      expect(file).to receive(:rename_packet)
+      file.rename(filename)
+    end
+
+    it 'returns the response NTStatus code' do
+      status = WindowsError::NTStatus::STATUS_SUCCESS
+      set_info_res.smb_header.nt_status = status.value
+      expect(file.rename(filename)).to eq status
+    end
+  end
+
+  describe '#rename_packet' do
+    let(:request) do
+      request = RubySMB::SMB1::Packet::Trans2::SetFileInformationRequest.new
+      passthrough_info_level = RubySMB::Fscc::FileInformation::FILE_RENAME_INFORMATION +
+        RubySMB::Fscc::FileInformation::SMB_INFO_PASSTHROUGH
+      request.data_block.trans2_parameters.information_level = passthrough_info_level
+      request
+    end
+
+    before :example do
+      allow(RubySMB::SMB1::Packet::Trans2::SetFileInformationRequest).to receive(:new).and_return(request)
+    end
+
+    it 'creates a new Trans2 SetFileInformationRequest packet' do
+      expect(RubySMB::SMB1::Packet::Trans2::SetFileInformationRequest).to receive(:new).and_return(request)
+      file.rename_packet(filename)
+    end
+
+    it 'calls Tree #set_header_fields to set SetFileInformationRequest headers' do
+      expect(tree).to receive(:set_header_fields).with(request).and_call_original
+      file.rename_packet(filename)
+    end
+
+    it 'sets the Trans2 parameter #fid of the packet with the File FID' do
+      fid = 0x1000
+      file.fid = fid
+      expect(file.rename_packet(filename).data_block.trans2_parameters.fid).to eq fid
+    end
+
+    it 'sets the Trans2 parameter #information_level of the packet' do
+      request.data_block.trans2_parameters.information_level = 0
+      passthrough_info_level = RubySMB::Fscc::FileInformation::FILE_RENAME_INFORMATION +
+        RubySMB::Fscc::FileInformation::SMB_INFO_PASSTHROUGH
+      expect(file.rename_packet(filename).data_block.trans2_parameters.information_level).to eq passthrough_info_level
+    end
+
+    it 'sets the File Information #rename_pending field of the packet' do
+      expect(file.rename_packet(filename).data_block.trans2_data.info_level_struct.file_name).to eq filename.encode('utf-16le').force_encoding('ASCII-8BIT')
+    end
+
+    it 'sets the Trans2 ParameterBlock fields' do
+      parameter_block = file.rename_packet(filename).parameter_block
+      expect(parameter_block.total_parameter_count).to eq request.parameter_block.parameter_count
+      expect(parameter_block.total_data_count).to eq request.parameter_block.data_count
+      expect(parameter_block.max_parameter_count).to eq request.parameter_block.parameter_count
+      expect(parameter_block.max_data_count).to eq 16_384
+    end
+  end
+end
+