Cacher / coder le contenu d'un fichier ?

#include<stdio.h>

void encode (char const *f_in, char const *f_out, char const *cle)
{
   FILE *fp_in = fopen (f_in, "rb");
   if (fp_in != NULL)
   {
      FILE *fp_out = fopen (f_out, "wb");
      if (fp_out != NULL)
      {
         int c;
         int i_cle = 0;
         int const len_cle = strlen (cle);
         while ((c = fgetc (fp_in)) != EOF)
         {
            fputc ((c ^ cle[i_cle]) & 0xFF, fp_out);
            i_cle++;
            if (i_cle == len_cle)
            {
               i_cle = 0;
            }
         }
         fclose (fp_out);
      }
      fclose (fp_in);
   }
   else
   {
      perror (f_in);
   }
}

/* ---------------------------------------------------------------------
   dump()
   ---------------------------------------------------------------------
   Role : Dumper une zone memoire vers stdout
   ---------------------------------------------------------------------
   E : adresse de debut de la zone
   E : longueur a dumper (en octets)
   S :
   --------------------------------------------------------------------- */
void dump (void const *const p, size_t const len)
{
   int ok = 1;
   const char *szErrBuf = NULL;
   const char *szErrLen = NULL;

   if (p == NULL)
   {
      szErrBuf = "p=NULL";
      ok = 0;
   }

   if (len == 0)
   {
      szErrLen = "len=0";
      ok = 0;
   }

   if (ok)
   {
#define LEN 16
#define FMT "%p"
#define CAST (void const *)
#define uchar unsigned char
#define uint unsigned int
#define ulong unsigned long

      uchar const *const ao = p;
      size_t i;

      for (i = 0; i < len; i += LEN)
      {
         size_t j;

         /* Adresse de la ligne */
         printf (FMT " ", CAST (ao + i));

         for (j = i; j < i + LEN; j++)
         {
            if (j < len)
            {
               /* octets en hexa */
               printf ("%02X ", (uint) ao[j] & 0xFF);
            }
            else
            {
               printf ("   ");  /* 3 espaces */
            }
         }

         printf (" '");

         for (j = i; j < (i + LEN) && j < len; j++)
         {
            if (isprint (ao[j]))
            {
               /* octets en caracteres */
               printf ("%c", (int) ao[j]);
            }
            else
            {
               printf (".");
            }
         }
         printf ("'\n");
      }
#undef FMT
#undef CAST
#undef LEN
   }
   else
   {
      fprintf (stderr, "dump (%p, %lu) ERR : ", (void const *) p,
               (ulong) len);

      if (szErrBuf)
      {
         fprintf (stderr, "%s ", szErrBuf);
      }
      if (szErrLen)
      {
         fprintf (stderr, "%s ", szErrLen);
      }
      fprintf (stderr, "\n");
#undef uchar
#undef uint
#undef ulong
   }
}

void fdump (char const *fname)
{
   FILE *fp = fopen (fname, "rb");
   if (fp != NULL)
   {
      fseek (fp, 0, SEEK_END);
      {
         long len = ftell (fp);
         rewind (fp);
         if (len > 0)
         {
            unsigned char *a = malloc (len);
            int n = fread (a, 1, len, fp);
            printf ("%d byte%s read\n", n, n > 1 ? "s" : "");
            dump (a, len);
         }
         else
         {
            printf ("'%s' is empty\n", fname);
         }
      }
      fclose (fp);
   }
   else
   {
      perror (fname);
   }
}

int main (void)
{
   char const *fname = "data.txt";
   fdump (fname);
   encode (fname, "TEMPFILE", "sesame");
   fdump ("TEMPFILE");
   encode ("TEMPFILE", fname, "sesame");
   fdump (fname);
   return 0;
}