[TP] Réaliser un crypteur de fichiers à l'aide de la fonction XOR

int xoring = 0x60 ^ 0x9B;

/*
    xor.c
    permet de crypter tout type de fichier à l'aide de la fonction XOR
    by VeNoM630
*/

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

/* On déclare notre prototype de fonction qui va :
    ouvrir un fichier en lecture,
    lire les octets, les 'xorer'
    et écrire dans le fichier ouvert en écriture.

    ici, "fin" correspond au pointeur de fichier lu,
    "fout" correspond au pointeur de fichier d'écriture,
    et "key" correspond à la clef de cryptage.
*/
void ReadXorAndWrite(FILE *fin,FILE *fout,char key[30]);

/*
    On va ensuite déclarer nos pointeurs de fichiers
    et nos variables dans la fonction main
*/
FILE *fptr1;
FILE *fptr2;

char filename1[30];
char filename2[30];
char clef[30];

/* On lance la fonction principale du programme : main() */
int main()
{
    /* On demande quel fichier il faut crypter */
    printf("Nom du fichier a analyser:\t");
    scanf("%s",filename1);

   /* On fait de même pour le fichier crypté à créer */
    printf("Nom du fichier crypte a creer :\t");
    scanf("%s",filename2);

    /* On demande la clef de cryptage XOR */
    printf("Entrez votre clef de cryptage :\t");
    scanf("%s",clef);

    /* Voila, l'utilisateur a soumis toutes les données,
    on va maintenant vérifier si on arrive à lire notre
    fichier 'filename1' en lecture binaire */
    if((fptr1 = fopen(filename1,"rb")) == NULL)
    {
        /* Si l'ouverture a echoué, on renvoie un message d'erreur */
        printf("Erreur, impossible d'ouvrir %s en lecture.\n",filename1);
        system("pause > nul");
        exit(EXIT_FAILURE);
    }
    else
    {
        /* Sinon, on vérifie si on arrive à écrire dans
        notre fichier 'filename' en mode ecriture binaire.
        Si le fichier n'existe pas, il est créé automatiquement */
        if((fptr2 = fopen(filename2,"wb")) == NULL)
        {
            /* Si l'ouverture a echoué, on renvoie un message d'erreur */
            printf("Erreur, impossible d'ouvrir %s en ecriture.\n",filename2);
            system("pause > nul");
            exit(EXIT_FAILURE);
        }
        else
        {
            /* Sinon, tout est bon, on exécute notre fonction que
            nous allons décrire ci-dessous (le prototype est déclaré
            avant la fonction main() */
            ReadXorAndWrite(fptr1,fptr2,clef);

            /* Puis on ferme les fichiers */
            fclose(fptr1);
            fclose(fptr2);
        }
    }
    /* On renvoie '0' pour montrer que le programme se termine normalement. */
    return 0;
}

/* Maintenant, on va décrire la fonction ReadXorAndWrite() */
void ReadXorAndWrite(FILE *fin,FILE *fout,char key[30])
{
    /* On va déclarer trois variables :
    - La première est celle qui va recevoir en mémoire
    l'octet lu dans fin;
    - La seconde est la variable qui contiendra en mémoire
    le XOR de l'octet lu et l'octet de la clef;
    - La troisième est une variable qui s'incrémentera
    au fil du temps pour se déplacer dans key[] et qui
    reviendra au début de la chaîne. */
    char ch;
    int xoring;
    int i = 0;

    /* On va ensuite faire une boucle infinie qui s'arrêtera en cas
    d'échec de lecture de fin, donc si il n'y a plus rien à lire dans
    fin */
    while(1)
    {
        /* Si l'on arrive plus à lire dans fin pour
        mémoriser en adresse mémoire de ch un élément qui correspond
        à l'octet, on 'break' pour sortir de la boucle */
        if(!fread(&ch,sizeof(char),1,fin))
            break;
        else
        {
            /* Sinon, on vérifie que nous ne sommes pas à la fin de la chaîne
            de key, donc si l'octet actuel de key n'est pas '\0'. */
            if(key[i] == '\0')
            {
                /* On remet le compteur i à 0 pour revenir en début de chaîne */
                i = 0;
            }
            /* On affecte à 'xoring' le xor de l'octet de fin et celui de la clef
            grâce à l'opérateur logique '^' */
            xoring = ch ^ key[i];

            /* Et enfin on écrit dans fout la valeur de xoring ! */
            fwrite(&xoring,sizeof(char),1,fout);
        }
        /* On a fini la condition, on incrémente 'i' et on ferme la boucle */
        i++;
    }
    /* On fait savoir à l'utilisateur que l'opération est terminée */
    printf("Le XOR est termine !\n");
    system("pause > nul");

    /* On referme la fonction, et c'est la fin du code */
}