Attempting to read parts of a file at a time modifying it and saving it, then reversing the changes and saving it again. File currupts doing it

I am attempting to read a chunk of a large file (as blocks of bytes, not strings not chars, but bytes), encrypt it and saving it to a temporary file, until the whole file is read, where the temporary file will overwrite the original file. Then After the encryption process i'd decrypt it doing the same thing except decrypting than encrypting the data.

The encryption is simply sum each byte from the data with 1, decryption is subtracting each byte from the data with 1.

The Problem:

the problem i am facing is the file is not the same size after encrypting and decrypting it, and the file does not contain the same data as it began with.

Yes i have attempted to read the whole file using "FILE.ReadAllBytes(file)" and that worked, but due to situations where it could be possible to work with large files as 1-2 gb, i am resorting to reading chunks instead to avoid using the large amounts of ressourcess. Buffer size to be anything between 16 and 128 mb.

The code that i have is this:

Encryption process:

byte[] Data = new byte[bufferSize];
using (FileStream _temporaryFile_filestream = new FileStream(file + ".tmp", FileMode.Create, FileAccess.Write, FileShare.None))
{
  FileStream _originalFile_filestream = new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.None);
  int bytesRead = -1;

  while ((bytesRead = _originalFile_filestream.Read(Data, 0, bufferSize)) > 0){

    for (int i = 0; i < Data.Length; i++) {
      Data[i] += 1;
    }
  }

// Close files.
  _originalFile_filestream.Close();
  _temporaryFile_filestream.Close();
}

File.Delete(file);  //Removing original file

// Rewriting the encrypted data back to the original filename.
bufferSize = (640000 * 1024);   // 64 megabyte buffer size.
using (FileStream _originalFile_filestream = new FileStream(file, FileMode.Create, FileAccess.Write, FileShare.None)) {
  FileStream _temporaryFile_filestream = new FileStream(file + ".tmp", FileMode.Open, FileAccess.Read, FileShare.None);
  _originalFile_filestream.SetLength(_temporaryFile_filestream.Length);
  int bytesRead = -1;
  byte[] _data = new byte[bufferSize];

  while ((bytesRead = _temporaryFile_filestream.Read(_data, 0, bufferSize)) > 0) {
    _originalFile_filestream.Write(_data, 0, bytesRead);
  }
  // Close files.
  _originalFile_filestream.Close();
  _temporaryFile_filestream.Close();
}

File.Delete(file + ".tmp"); // Delete temporary file.

Decryption process:

byte[] Data = new byte[bufferSize];
using (FileStream _temporaryFile_filestream = new FileStream(file + ".tmp", FileMode.Create, FileAccess.Write, FileShare.None))
{
  FileStream _originalFile_filestream = new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.None);
  int bytesRead = -1;

  while ((bytesRead = _originalFile_filestream.Read(Data, 0, bufferSize)) > 0){

    for (int i = 0; i < Data.Length; i++) {
      Data[i] -= 1;
    }
  }

// Close files.
  _originalFile_filestream.Close();
  _temporaryFile_filestream.Close();
}

File.Delete(file);  //Removing original file

// Rewriting the encrypted data back to the original filename.
bufferSize = (640000 * 1024);   // 64 megabyte buffer size.
using (FileStream _originalFile_filestream = new FileStream(file, FileMode.Create, FileAccess.Write, FileShare.None)) {
  FileStream _temporaryFile_filestream = new FileStream(file + ".tmp", FileMode.Open, FileAccess.Read, FileShare.None);
  _originalFile_filestream.SetLength(_temporaryFile_filestream.Length);
  int bytesRead = -1;
  byte[] _data = new byte[bufferSize];

  while ((bytesRead = _temporaryFile_filestream.Read(_data, 0, bufferSize)) > 0) {
    _originalFile_filestream.Write(_data, 0, bytesRead);
  }
  // Close files.
  _originalFile_filestream.Close();
  _temporaryFile_filestream.Close();
}

File.Delete(file + ".tmp"); // Delete temporary file.

Welcome to programming Anas. We all had to start somewhere. Let's look at the main culprit of your problem and then I'll offer some other critiques.

Here's your first 'encryption' pass:

byte[] Data = new byte[bufferSize];
using (FileStream _temporaryFile_filestream = new FileStream(file + ".tmp", FileMode.Create, FileAccess.Write, FileShare.None))
{
  FileStream _originalFile_filestream = new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.None);
  int bytesRead = -1;

  while ((bytesRead = _originalFile_filestream.Read(Data, 0, bufferSize)) > 0){

    for (int i = 0; i < Data.Length; i++) {
      Data[i] += 1;
    }
  }

// Close files.
  _originalFile_filestream.Close();
  _temporaryFile_filestream.Close();
}

Not a bad first attempt, but you've skipped two points:

1. You get the number of bytes read from the file, but you don't actually use that value in the your 'encryption' loop.

2. You never actually write the modified bytes (or anything) to the temporary file.

3. You really should have a using for both streams.

4. There are much shorter ways to write those stream creations.

Let's rewrite that:

byte[] Data = new byte[bufferSize];
using (var original = File.OpenRead(file))
using (var temp = File.Create(file + ".tmp"))
{
	int readCount = 0;
	while ((readCount = _original.Read(Data, 0, bufferSize)) > 0)
	{
		// Only process the bytes we actually read
		for (int i = 0; i < readCount; i++)
			Data[i] += 1;
	}
	// Write back the number of bytes we processed
	temp.Write(Data, 0, readCount);
}

Note that disposing of a stream (which is handled automatically by the using statement) flushes and closes it automatically, so you don't need to do that explicitly.

Now the next part you are simply copying the content of your temp file back to the original... but you could just rename the file. So let's finish up your 'encrypt' method in the simplest way:

File.Delete(file);
File.Move(file + ".tmp", file);

If you really, really want to do copying the hard way then you can use the CopyTo method to write one stream's content into another. So we could have done this:

// Note that 'File.Create' will clear any existing content from the file
// if it exists, so we don't need to delete the file.
using (var original = File.Create(file))
using (var temp = File.OpenRead(file + ".tmp"))
{
	temp.CopyTo(original);
}

// Finish up by removing the temporary file
File.Delete(file + ".tmp");

The decode method is the same except for the Data[i] -= 1; to revert the change we made in the encoder, so that's simple enough to implement from this... but now we're writing the same code twice, and that's usually considered to be a Bad Idea (aka Code Smell). So let's try for something that we can use more generally.

Rather than writing the transformation code twice, let's create a single method that we can use for general file transformation. The actual transformation will be done by an external method that we supply as a parameter, so this will just do the read/write/rename side of things:

// 64KB blocks by default
const int DefaultBlockSize = 64 * 1024;

// Transform a file by calling the 'transform' method.
public static void TransformFile(string fileName, Action<byte[], int> transform, int blockSize = DefaultBlockSize)
{
	var tempFileName = fileName + ".tmp";
	
	// Read blocks, pass them to transform method, write to temp
	if (blockSize < 1024)
		blockSize = 1024;
	byte[] buffer = new byte[blockSize];
	
	using (var temp = File.Create(tempFileName))
	using (var source = File.OpenRead(fileName))
	{
		int readCount;
		while ((readCount = source.Read(buffer, 0, blockSize)) > 0)
		{
			// 'transform' changes the supplied buffer
			transform(buffer, readCount);
			temp.Write(buffer, 0, readCount);
		}
	}
	
	File.Delete(fileName);
	File.Move(tempFileName, fileName);
}

This should look familiar since it's basically the same as the code above, just with the actual transformation code moved out. Now instead of writing the same code twice you can call this single piece of code with different parameters to get different results. The outer shell - the process of reading, transforming and writing data - is the same for both encoding and decoding.

For your use case you can then write the 'Encode' and 'Decode' methods like this:

private static void EncodeTransform(byte[] buffer, int count)
{
	for (int i = 0; i < count; i++)
		buffer[i] += 1;
}

private static void DecodeTransform(byte[] buffer, int count)
{
	for (int i = 0; i < count; i++)
		buffer[i] -= 1;
}

public static void EncodeFile(string fileName)
{
	TransformFile(fileName, EncodeTransform);
}

public static void DecodeFile(string fileName)
{
	TransformFile(fileName, DecodeTransform);
}

From there you can adjust the transform methods as you wish, as long as they're symmetrical: the same size output as input, no headers or other additions to the file data, etc.

The TransformFile method doesn't care what you're doing with that data, it just reads blocks of the file, sends them to your transform method, then writes them back. You can use that for any block-style symmetric transformation you like.

Asymmetric transforms are a bit more involved since you might need to deal with things like reading different-sized blocks from the source. Imagine that you're compressing each block to an inconsisten smaller size, but to decompress you need to pass each block individually to the decompressor so you need to know how big each block is. If you compress 64K down to 5K you don't want to write a bunch of empty data, so how do you go about tracking that?

And of course when you decompress the data you'll need a larger buffer to put the data into when you're decompressing. How big does that buffer need to be?

At this point we're getting into themes involving file formats: file headers, block headers, asymmetric block sizes and so on.

I'll leave you with this old article by James McCaffrey relating to custom Stream implementations to do something similar. I hope it gives you some ideas.