Thread: Issues with writing data to binary files

Im trying to write my custom file encrypter, but the outfile fp2 is empty so I'm doing something wrong here:

Code:

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#defineSIZE(a) sizeof(a) / sizeof(a[0])

void encrypt(const char *fileName, const char *newFileName, const char *KWORD,
             int K)
{
  FILE *fp, *fp2;
  fp = fopen(fileName, "rb");
  fp2 = fopen(newFileName, "a+");
  if (!fp) {
    printf("\nError: Could not open the file %s\n", fileName);
  } else {
    printf("\nFile has been opened successfully\n");

    int block[8192], xorblock[8192];
    char banner[128];

    size_t allBytes, byteCount =
        fread(banner, sizeof(banner), sizeof(banner), fp);
    printf("BASE FILE BANNER: %s\n", banner);
    fseek(fp, 0, SEEK_SET);

    while (byteCount) {
      byteCount = fread(block, sizeof(block), sizeof(block), fp);
      allBytes += byteCount;
      printf("\rByte has been read: %zu\r", byteCount);

      for (size_t i = 0; i < SIZE(block); i++) {
        K = K % strlen(KWORD);
        volatile char kwordPos = KWORD[K];
        xorblock = block ^ (int) kwordPos;
        K++;
      }
      fwrite(xorblock, sizeof(xorblock), sizeof(xorblock), fp2);
    }
    printf("\nAll bytes read:%zu\n", allBytes);

  }
  fclose(fp);
  fclose(fp2);

  FILE *fp2read;
  fp2read = fopen(newFileName, "rb");
  char newBanner[128];
  fread(newBanner, sizeof(newBanner), sizeof(newBanner), fp2read);
  printf("\nNEW FILE BANNER: %s\n", newBanner);
}

int main()
{
  const char *myFileName = "Example.txt";
  char newFileName[17] = "_NEW_";
  const char *keyWord = "Keyword";
  int Key = 'K';

  strcat(newFileName, myFileName);
  encrypt(myFileName, newFileName, keyWord, Key);
  printf("%s%zu\n", newFileName, strlen(newFileName));
  printf("\nAll done.Quitting now.\n");
  return 0;
}

fsanitizer is showing that something is crashing pretty badly:

File has been opened successfullyBASE FILE BANNER: C plus plus


All bytes read:0
AddressSanitizer:DEADLYSIGNAL
================================================== ===============
==571==ERROR: AddressSanitizer: SEGV on unknown address 0x000000000000 (pc 0x7f2229726005 bp 0x7ffe1b18abe0 sp 0x7ffe1b18a320 T0)
==571==The signal is caused by a READ memory access.
==571==Hint: address points to the zero page.
AddressSanitizer:DEADLYSIGNAL
AddressSanitizer: nested bug in the same thread, aborting.

You should open both files in binary mode "rb" and "wb".

Key (a.k.a., K in encrypt) doesn't make sense. It's just an index mod strlen(KWORD). Why are you passing it in? Why would it start at 'K'? It should be a local starting at 0.

I assume the banner business is just a peek at the first part of the file for testing.
But you can't just print out the binary file's data as a string as you attempt to do at the end of encrypt.

"volatile" is unlikely to be of use to you.

The block (and xorblock) should be chars (bytes), not ints.
You don't need a separate xorblock. You could just xor the original block.

Your inner encrypt loop should be up to byteCount, not SIZE(block), since you may not have read an entire block, such as at the end of the file.

When reading and writing the blocks, you can't make the size and count members of fread/fwrite both the size of the block! The size is the size of each element (they should be chars, so 1), while the count is the number of elements to try to read/write. So the count for the fwrite should just be byteCount.

Try the following modification with:
my_encrypt Example.txt out.bin keyword
my_encrypt out.bin Example2.txt keyword
Then see if Example2.txt is the same as Example.txt.
You could also look at the binary data of out.bin (e.g., with hd out.bin on linux, or write your own little program to print out the hex values of the bytes).

Code:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
void encrypt(const char* fileName, const char* newFileName, const char* keyword)
{
    FILE *fin = fopen(fileName, "rb");
    if (!fin)
    {
        fprintf(stderr, "Error: Could not open the file %s\n", fileName);
        exit(EXIT_FAILURE);
    }
 
    FILE *fout = fopen(newFileName, "wb");
 
    char block[512];
    size_t keylen = strlen(keyword); 
    size_t allBytes = 0, byteCount, k = 0;
 
    while ((byteCount = fread(block, 1, sizeof(block), fin)) > 0)
    {
        allBytes += byteCount;
        for (size_t i = 0; i < byteCount; ++i)
        {
            block[i] ^= keyword[k];
            k = (k + 1) % keylen;
        }
        fwrite(block, 1, byteCount, fout);
    }
    printf("Bytes read: %zu\n", allBytes);
 
    fclose(fin);
    fclose(fout);
}
 
int main(int argc, char **argv)
{
    if (argc != 4)
    {
        fprintf(stderr, "Usage: my_encrypt INPUT_FILE OUTPUT_FILE KEYWORD\n");
        exit(EXIT_FAILURE);
    }
 
    encrypt(argv[1], argv[2], argv[3]);
 
    return 0;
}