00001 #include "tools.h"
00002 
00003 #define A_SIZE ('z' - 'a' + 1)  // Taille de l'alphabet
00004 
00005 int char_to_Z26(char c, int * res) {
00006         if ( (c >= 'a') && (c <= 'z') ) {// A-t-on bien un élément de [a-z]?
00007                 *res = c - 'a';
00008                 return 0;
00009         } 
00010         return 1; // Erreur
00011 }
00012 int Z26_to_char(int i, char * res) {
00013         if ( (i >= 0) && (i < A_SIZE) ) {
00014                 *res = i + 'a';
00015                 return 0;
00016         }
00017         return 1; // Erreur
00018 }
00019 
00020 int chiffrement_affine_Z26(int a, int b, int x, int * res) {
00021         *res = x;
00022         if ( pgcd(a,A_SIZE) != 1 ) return -1; // Vérification de clef valide.
00023         if ( (x >= 0) && (x < A_SIZE) ) {
00024                 *res = (a*x + b) % A_SIZE;
00025                 return 0;
00026         } 
00027         return 1;
00028 }
00029 int dechiffrement_affine_Z26(int inv_a, int b, int y, int * res) {
00030         *res = y;
00031         if ( pgcd(inv_a,A_SIZE) != 1 ) return -1; // Vérification de clef valide.
00032         if ( (y >= 0) && (y < A_SIZE) ) {
00033                 *res = (inv_a*(A_SIZE + y - b)) % A_SIZE;
00034                 return 0;
00035         }
00036         return 1;
00037 }
00038 
00039 int chiffrement_affine_Z26_fichier(int a, int b, const char * filein,
00040                                    const char * fileout) {
00041         FILE *f_in, *f_out;
00042         char c, res_c;
00043         int i, res_i;
00044 
00045         if ( pgcd(a,A_SIZE) != 1 ) { // Vérifier la validité de la clef.
00046                 fprintf(stderr, "\nErreur: Clef invalide (a,b)=(%d,%d):"
00047                         " pgcd(a,%d) != 1\n", a, b, A_SIZE);
00048                 return 1;
00049         }
00050         if ((f_in = fopen(filein,"r")) == NULL) { // Ouvrir  filein en lecture...
00051                 fprintf(stderr, "\nErreur: Impossible de lire %s\n",filein);
00052                 return 1;
00053         }
00054         if ((f_out = fopen(fileout,"w")) == NULL) { // ... et fileout en écriture.
00055                 fprintf(stderr, "\nErreur: Impossible d'écrire dans %s\n",fileout);
00056                 return 1;
00057         }
00058         // Chiffrement du fichier f_in.
00059         while (1) {
00060                 c = res_c = getc(f_in);
00061                 if ( feof(f_in) ) break;
00062                 if ( ! char_to_Z26(c, &i) ) {
00063                         chiffrement_affine_Z26(a,b,i,&res_i);
00064                         Z26_to_char(res_i, &res_c);
00065                 }
00066                 putc(res_c, f_out);
00067         }
00068         // Fermeture des flots de données.
00069         fclose(f_in);
00070         fclose(f_out);
00071         return 0;
00072 }
00073 int dechiffrement_affine_Z26_fichier(int a, int b, const char * filein,
00074                                      const char * fileout) {
00075         FILE *f_in, *f_out;
00076         char c, res_c;
00077         int i=0, res_i, inv_a;
00078 
00079         if ( inv_mod(a, A_SIZE, &inv_a) == 1 ) { // Vérifier la validité de la clef.
00080                 fprintf(stderr,"\nErreur: Clef invalide car pgcd(a,%d)!=1\n",
00081                         A_SIZE);
00082                 return 1;
00083         }
00084         if ((f_in = fopen(filein,"r")) == NULL) { // Ouvrir filein en lecture...
00085                 fprintf(stderr, "\nErreur: Impossible de lire %s\n",filein);
00086                 return 1;
00087         }
00088         if ((f_out = fopen(fileout,"w")) == NULL) { // ... et fileout en écriture.
00089                 fprintf(stderr, "\nErreur: Impossible d'écrire dans %s\n",fileout);
00090                 return 1;
00091         }
00092         // Déchiffrement du fichier f_in.
00093         while (1) {
00094                 c = res_c = getc(f_in);
00095                 if ( feof(f_in) ) break;
00096                 if ( ! char_to_Z26(c, &i) ) {
00097                         dechiffrement_affine_Z26(inv_a,b,i,&res_i);
00098                         Z26_to_char(res_i, &res_c);
00099                 }
00100                 putc(res_c, f_out);
00101         }
00102         // Fermeture des flots de données.
00103         fclose(f_in);
00104         fclose(f_out);
00105         return 0;
00106 }
00107 
00108 int main()
00109 {
00110         char * clear_file    = "texte_clair.txt";
00111         char * cypher_file   = "Out_texte_chiffre.txt";
00112         char * decypher_file = "Out_texte_dechiffre.txt";
00113  
00114         int a = 1, b = 2, inv_a;
00115         if ( inv_mod(a, A_SIZE, &inv_a) ) {
00116                 fprintf(stderr, "Clef invalide\n");
00117                 return 1;
00118         }
00119     
00120         printf("Chiffrement affine par clef K=(a,b)=(%d,%d)      :",a,b);
00121         printf(" %s -> %s\n", clear_file, cypher_file);
00122         if ( chiffrement_affine_Z26_fichier(a,b,clear_file,cypher_file) ) {
00123                 fprintf(stderr, "   Impossible de chiffrer %s\n", clear_file);
00124                 return 1;
00125         }
00126     
00127         printf("\nDéchiffrement affine par clef K=(a^-1,b)=(%d,%d) :",inv_a,b);
00128         printf(" %s -> %s\n", cypher_file, decypher_file);
00129         if ( dechiffrement_affine_Z26_fichier(inv_a,b,cypher_file,decypher_file ) ) {
00130                 fprintf(stderr, "   Impossible de dechiffrer %s\n", cypher_file);
00131                 return 1;
00132         }
00133     
00134  
00135     
00136 
00137         return 0;
00138 }