Envie d'un déblocage pour ce code en C

Bonjour à tous, voilà j'aimerai que vous aidiez sur la fonction decrypter de mon code donc le but est de crypter et decrypter un fichier texte. En fait je crypte sans problème, mais quand il faut décrypter, sans autre chose.

N.B: j'ai utilisé le cryptage symetrique.



voici le code:


#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#include<time.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

// Programme principal

main()
{

// Déclaration des variables

char fichier[128] ;
int choix = 0 ;
char continu = 1 ;

// Déclaration des fonctions

void lecture( char lire[128] ) ;
void crypter( char crypt[128] ) ;
void decrypter( char decrypt[128] ) ;


////////////////////////////////////////////////////////

// Entrer du fichier avec son chemin

printf( "\nFichier : " ) ;
scanf( "%s" , &fichier ) ;

// Boucle principale

while ( continu == 1 )
{

system("cls") ;
printf( "\nCryptage IUT1 GEII Projet XX9" ) ;
printf( "\nVersion Beta 1.2\n" ) ;
printf( "\n\nfichier : %s",fichier ) ;
printf( "\n\nFonctions :" ) ;
printf( "\n\n(1) Lire le fichier" ) ;
printf( "\n(2) Cryptage" ) ;
printf( "\n(3) Decryptage" ) ;
printf( "\n(4) Exit" ) ;
printf( "\n\nChoix : " ) ;

choix = 0 ;

choix = getchar() ;

// On lance la fonction choisie

switch (choix)
{
case 49 :
lecture( fichier ) ;
break;
case 50 :
crypter( fichier ) ;
break;
case 51 :
decrypter( fichier ) ;
break;
case 52 :
continu = 0 ;
break;
}
printf( "\n" ) ;
}

printf( "\n\nRetour au dos\n" ) ;


}

////////////////////////////////////////////////////////

// Les fonctions

////////////////////////////////////////////////////////

// Fonction affichage du fichier


void lecture( char lire[128] )
{
void *contenu;
struct stat infos;
int fd;

system ("cls") ;
printf ( "\n\nLecture du fichier %s :\n\n\n\n", lire ) ;

// Ouverture du fichier en lecture seule
fd = open(lire, O_RDONLY);

//On recupere les infos du fichier dont la taille
fstat(fd, &infos);

// je malloc de la taille du fichier :P
contenu = malloc(infos.st_size);

//Je lis le fichier et je stocke tout ca dans contenu
read(fd, contenu, infos.st_size);

// j affiche sur la sortie standard contenu
write(1, contenu, infos.st_size);

puts("\n\n\n");
free(contenu);
close(fd);
system("pause");
}

////////////////////////////////////////////////////////

// Fonction de cryptage

void crypter( char crypt[128] )
{
int car1 ;
int code1 ;
int hasard1 ;
int tmp1 ;
char cmpt1 ;
FILE *fp1 ;
FILE *fp1_tmp ;


// On demande une clef

printf( "\n\nClef (0-2^16) : " ) ;
scanf( "%i" , &code1 ) ;

//On initialise le générateur aléatoire et on prend une valeur au hasard

time( &tmp1 ) ;
srand( tmp1 ) ;
tmp1 = hasard1 / 256 ;
hasard1 = hasard1 - (256 * tmp1);

//Ouverture du fichier en lecture

fp1 = fopen( crypt , "r" ) ;

// Ouverture du fichier file.tmp en écriture

fp1_tmp = fopen( "file.tmp" , "w" ) ;

// On sauve hasard dans le fichier pour le décryptage

fputc( hasard1 , fp1_tmp ) ;
cmpt1 = 0 ;

while ( ( car1 = fgetc( fp1 ) ) != EOF )
{
cmpt1 ++ ;

// On additionne selon le compteur 'cmpt1'

switch (cmpt1)
{
case 1 :
car1 = car1 + code1 ;
break;
case 2 :
car1 = car1 + hasard1 ;
break;
case 3 :
car1 = car1 + hasard1 +code1 ;
cmpt1 = 0 ;
break;
}

// On remet 'car1' entre 0 et 255 (valeur min et max d'un octet) et on le sauve dans 'file.tmp'

tmp1 = car1 / 256 ;
car1 = car1 - (256 * tmp1);
fputc( car1 , fp1_tmp ) ;
}

// Fermeture des fichiers et on renomme le fichier .tmp

fclose( fp1_tmp ) ;
fclose( fp1 ) ;

remove( crypt ) ;
rename( "file.tmp" , crypt ) ;

printf( "\nCryptage terminer\n" ) ;
getch() ;
}

////////////////////////////////////////////////////////


//Fonction de décryptage

void decrypter( char decrypt[128] )

{
int car2 ;
int code2 ;
int hasard2 ;
int tmp2 ;
char cmpt2 ;
FILE *fp2 ;
FILE *fp2_tmp ;

//On demande une clef

printf( "\n\nClef (0-2^16) : " ) ;
scanf( "%i" , &code2 ) ;

//Ouverture des fichiers

fp2 = fopen( decrypt , "r" ) ;
fp2_tmp = fopen( "file.tmp" , "w" ) ;

//On lit la valeur prise au hasard au cryptage

hasard2 = fgetc( fp2 ) ;

while ( ( car2 = fgetc( fp2 ) ) != EOF )
{
cmpt2 ++ ;

//On soustrait selon le compteur 'cmpt2'

switch (cmpt2)
{
case 1 :
car2 = car2 - code2 ;
break;
case 2 :
car2 = car2 - hasard2 ;
break;
case 3 :
car2 = car2 - hasard2 - code2 ;
cmpt2 = 0 ;
break;
}

//On remet 'car2' entre 0 et 255 (valeur min et max d'un octet) et on le sauve dans 'file.tmp'

if ( car2 < 0 )
car2 = 0 - car2 ;
tmp2 = car2 / 256 ;
car2 = car2 - (256 * tmp2);
fputc( car2 , fp2_tmp ) ;
}

//Fermeture des fichiers et on renomme le fichier .tmp

fclose( fp2_tmp ) ;
fclose( fp2 ) ;

remove( decrypt ) ;
rename( "file.tmp" , decrypt ) ;

printf( "\nDecryptage terminer\n" ) ;
getch() ;
}

// Fin