Crypter avec vigenere

Soyez le premier à donner votre avis sur cette source.

Snippet vu 8 459 fois - Téléchargée 30 fois

Commenter

Contenu du snippet

programme très simple pour crypter un fichier grâce à l'algo de vigenere.
fonctionne en ligne de commande.

Source / Exemple : 


#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;    
}

Conclusion :


// Chiffre de Vigenère (sous réserve de modifications)
// Chiffrement
//
// par khayyam
//
// ce code peut poser des problèmes sous un environnement windows :
// un caractère supplémentaire est créé dans le fichier de sortie.
// mais sous unix, c'est impeccable.
//
//
//traduction en C d'un prog déjà écrit en Pascal

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (cs_khayyam)