CRYPTER AVEC VIGENERE

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

#define CAPACITE 1000  //taille maxi de la chaine à étudier, peut être porté jusqu'à 4 milliards sans problème. (4 milliards : 5000 livres de Zola)
  

typedef unsigned long ul;
char * alphabet="ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ";


//fonction qui compte le nombre d'occurence d'une lettre donnée dans une chaine donnée
ul comptage(char c, char * chaine)
{
ul nb=0;              
ul i,l=strlen(chaine);
for (i=0; i<l;i++)
    if (chaine[i]==c) nb++;

return nb;
}


//renvoie la position de c dans chaine. -1 si inexistant
ul pos(char c,char * chaine)
{
ul i=0,l=strlen(chaine);
while ((c!=chaine[i]) && (i<l))
    i++;
if (i==l) return -1;
     else return i;
}

//fonction de majuscule de lettre
unsigned char upcase(unsigned char c)
{
if ((c>=97)&&(c<=122))
    return c-32;

switch(c)
    {
    case 'à':
    case 'â':
    case 134: case 142: case 143:
    case 'ä': return 'A';
    case 'é': case 144:
    case 'è':
    case 'ê':
    case 'ë': return 'E';
    case 'ì':
    case 'î':
    case 'ï': return 'I';
    case 'ô': case 153:
    case 'ö':
    case 'ò': return 'O';
    case 'ù': case 154:
    case 'ü': return 'U';
    case 'ç': 
    case 155: return 'C';
    case 'ñ': 
    case 165: return 'N';
    case 152: return 'Y';
    default: return c;
    }
}


//fonction de majuscules de chaine
char * upcase_string(char * chaine)
{
ul l=strlen(chaine),i;
char * chaine2=(char*)malloc((l+1)*sizeof(char));
for(i=0; i<l; i++)
    chaine2[i]=upcase(chaine[i]);
       
return chaine2;
}


//fonction de lecture de chaine de caractère dans un fichier 'nom_fichier'
char * lecture(char *nom_fichier)
{
FILE *fichier=fopen(nom_fichier,"r");
if (fichier==NULL) return "\0";

ul i=0;
char *chaine=(char*)calloc(CAPACITE,sizeof(char));

while ((i<CAPACITE) && (fread(&chaine[i],1,sizeof(char),fichier)))
    i++;
 
fclose(fichier);       
return chaine;
}

//procédure d'écriture d'une chaine dans un fichier
void enregistrer(char *chaine, char *nom_fichier)
{
FILE *fichier=fopen(nom_fichier,"w");
if (fichier==NULL) 
    {printf("nom de fichier de sortie invalide");
     return;
    }     

fwrite(chaine,sizeof(char), strlen(chaine),fichier);
fclose(fichier);
return;
}


// fonction de nettoyage
char * nettoyage(char *sale)
{
char *chaine2=(char*)calloc(CAPACITE,sizeof(char));
char *autorise="ABCDEFGHIJKLMNOPQRSTUVWXYZ .,;:!?'()-\"";
ul i,j=0,l=strlen(sale);
  
for (i=0; i<l; i++)    //on n'accepte que les caractères présents dans autorise
    if (pos(sale[i],autorise)!=-1)
           {chaine2[j]=sale[i];
            j++;
           } 
      
return chaine2;
}

//fonction qui retire toute le ponctuation
char * deponctuation(char *chaine)
{
char * chaine2=(char*)calloc(strlen(chaine),sizeof(char));
ul i,j=0, l=strlen(chaine);

for (i=0; i<l; i++)
    if (pos(chaine[i], ",.;: ?!()'\"")==-1)
        {chaine2[j]=chaine[i];
         j++;
        }

return chaine2;
}

//fonction qui remet la ponctuation d'après le modèle de chaine2
char * reponctuation(char *chaine, char *chaine2)
{
ul i,j=0,l=strlen(chaine2);
char *chaine3=(char*)calloc(CAPACITE, sizeof(char));

//on parcourt les 2 chaines et on intercale une car de poncutation si besoin est
for (i=0; i<=l; i++)
    if (pos(chaine2[i]," .,;:!?'()-\"")==-1)
        {chaine3[i]=chaine[j]; 
         j++;
        }
        else 
        chaine3[i]=chaine2[i];

return chaine3;
}

//fonction de chiffrement d'une chaine upcasée avec une clef
char * chiffrer(char * clair, char * clef)
{
char * chiffre= (char*)calloc(strlen(clair)+1,sizeof(char));
ul i, l1=strlen(clef), l2=strlen(clair);

ul indice;

for (i=0; i<l2; i++)
    {
    indice=i%l1;
    chiffre[i]=alphabet[pos(clair[i], alphabet)+pos(clef[indice],alphabet)];
    //chiffre=strncat(chiffre, alphabet+pos(clair[i],alphabet)+pos(clef[indice],alphabet),1);  //même chose que sur la ligne d'au dessus
    }

return chiffre;
}

//fonction qui vérifie la validité d'une clef : que des lettres.
int iskey(char *key)
{
ul i, l=strlen(key);
for (i=0; i<l; i++)
    if (pos(key[i], alphabet)==-1)
        return 0;

return 1;   
}


///////////////////////////////////////////////////////////////////
//
//          main
//          vérification des arguments de la ligne de commande
//
///////////////////////////////////////////////////////////////////



int main(int argc, char **argv) // vig_decrypt <in_file> <out_file> <key>
{
    if (argc!=4)
        {
            printf("Utilisation : vig_decrypt <fichier d'entr%ce> <fichier de sortie> <CLEF>\n\n", 130);
            return 1;
        }        
    
    else //vérification des arguments
        {
            FILE *fichier=fopen(argv[1],"r");
            if (fichier==NULL) 
                 {printf("%s introuvable", argv[1]);
                  return 2;
                 }     
                 
                 //on laisse le fichier ouvert
                 
            //la vérification de argv[2] se fait lors de l'enregistrement, à la fin
            
            char *clair=nettoyage(upcase_string(lecture(argv[1])));
            
            
            if (iskey(argv[3]))        
                {
                 enregistrer(reponctuation(chiffrer(deponctuation(clair), argv[3]), clair), argv[2]);
                 free(clair);
                 fclose(fichier);
                }
                            
            else printf("clef de chiffrement invalide");                         
                              
        }    
        
return 0;    
}