· Web viewRéaliser un programme en C permettant de chiffrer un message à l’aide d’un...

VERNEY Nicolas MOULAIRE Anthony S2D

Apprendre autrement : CRYPTOGRAPHIE ET

PROGRAMMATION :

Chiffrement par permutations

Objectifs : Réaliser un programme en C permettant de chiffrer un message à l’aide d’un algorithme de chiffrement par permutations. Proposer ensuite un algorithme réalisant une cryptanalyse de ce moyen de chiffrement.

SOMMAIRE :

Introduction

I) Présentation et définitions du projet :

II) Tâches à réaliser et inconvénients pendant la réalisation du projet :

1ére partie du projet

2éme partie du projet

Inconvénients

Conclusion

Introduction

Le chiffrement par permutation est un outil informatique en langage C, qui est souvent utilisé pour la cryptographie. Il permet de transformer à l’aide d’une clé de chiffrement, des informations ou signaux clairs en informations ou signaux incompréhensibles pour des personnes n’ayant pas connaissance de cette clé. La cryptographie permet de protéger la confidentialité des informations fournies dans le message crypté.

I) Présentation et définitions du projet :

Définitions :

-La cryptographie est une discipline s'attachant à protéger des messages (assurant confidentialité du message) en s'aidant souvent de secrets ou clés.

-Le chiffrement est en cryptographie le procédé grâce auquel on souhaite rendre la compréhension d'un document impossible à toute personne qui n'a pas la clé de chiffrement.

-Une clé de chiffrement est un paramètre utilisé en entrée d'une opération cryptographique. C’est une clé qui est gardée secrète, et qui n’est connue que de ceux qui l’utilisent.

-La cryptanalyse consiste à tenter de déchiffrer un message ayant été chiffré sans posséder la clé de chiffrement.

-Un crypto système est un terme utilisé en cryptographie pour désigner un ensemble composé d'algorithmes, ainsi que de textes chiffrés et des clés possibles.

-Un algorithme en langage C, est une suite finie d’instructions permettant la résolution d’un problème.

-Crypter un texte est le fait de transformer un texte clair en texte codé.

-Décrypter un message est le fait de retrouver le message clair à partir du message codé.

-Un cryptogramme est un texte qui a été crypté.

Présentation :

Dans notre projet, nous devons réaliser un programme en C, qui permet de chiffrer un message, afin que le message ne puisse pas être compris par une personne extérieure au programme.

Nous avons commencé par réaliser un algorithme qui demande à un utilisateur d’entrer un message, et qui lui retourne ce même message, crypté avec une clé de chiffrement prédéfinie.

Comme nous nous servons d’une clé de chiffrement, nous avons le choix entre la définir au début du programme, ou laisser l’utilisateur la choisir. Nous avons choisi de la prédéfinir nous même au début du programme.

Nous avons ensuite réalisé le programme qui permet le chiffrement par permutations du message entré par l’utilisateur de celui-ci, programme que l’on détaillera dans la deuxième partie du projet. Celui est composé d’une fonction, avec une matrice (ou clé de chiffrement) que nous avons prédéfinie. Le programme demandera à l’utilisateur d’écrire un message, une fois le message écrit, la fonction réalise le cryptage et transmet le nouveau message crypté dans un tableau.

Nous allons ensuite proposer une méthode de cryptanalyse, c’est-à-dire une méthode permettant de déchiffrer le message crypté, sans avoir la clé de chiffrement. Dans cette partie, le principe est de créer un programme espion, c’est-à-dire un programme comprenant toutes les possibilités de permutations du message crypté. Cela signifie que, suivant la taille du message à afficher, le nombre de possibilités de permutations augmentent avec le nombre de lettres du message crypté. Le nombre de possibilités correspond à une valeur mathématique bien précise, qui est « n ! ». Cette valeur se prononce « n factorielle », le n correspondant au nombre de lettres du message crypté. Le calcul correspond à la valeur

Exemple de chiffrement par permutations :

II) Tâches à réaliser pendant la réalisation du projet:

1ère partie du projet: Le chiffrement et le déchiffrement

Le chiffrement: Dans cette première partie, nous devons créer un algorithme qui permet de permuter les lettres d’un mot, afin de rendre ce mot incompréhensible à toute personne extérieure au programme, et ne possédant pas la clé de chiffrement. Pour cela, nous avons déclaré deux tableaux dans la fonction principale, chacun étant utilisé pour ranger le mot permuté ou non.

Après les deux tableaux, nous avons déclaré une matrice servant à permuter le mot donné par l’utilisateur.

Nous avons ensuite déclaré deux entiers, que l’on a initialisés à 0, le premier (k) étant utilisé pour incrémenter les tableaux où les mots sont codés, c’est-à-dire pour permettre de placer chaque lettre du mot dans une case différente du tableau. Le deuxième (i) est l’entier qui permet le changement de lignes et de colonnes dans les deux matrices, afin que chaque lettre du tableau puisse être permutée par la matrice associée à sa case dans le tableau.

Nous nous sommes aussi servis de la fonction strlen(), qui est une fonction permettant de calculer le nombre de lettres dans chaque mot. Cette fonction nous permet ici de fixer une limite à l’incrémentation des matrices et des tableaux, c’est-à-dire afin que l’incrémentation puisse s’arrêter juste à la fin du mot.

De plus, nous avons utilisé une fonction while, qui signifie tant que, afin de mettre chaque lettre du mot dans sa nouvelle case du deuxième tableau pour obtenir le mot permuté, tant que la valeur de la case est inférieure à la valeur du nombre de lettres du mot.

Pour finir, la fonction cout permet d’afficher à l’écran chaque phrase utilisée. Dans ce programme, nous utilisons cette fonction pour demander un mot à l’utilisateur de ce programme, mais surtout pour afficher le mot qui a été permuté. Les phrases précédées de deux « / » dans notre programme, et écrites en vert, sont des commentaires supplémentaires pour une meilleure compréhension.

Notre programme de chiffrement :

#include <iostream>#include <conio.h>#include <string.h> using namespace std;

int main(void){

char mot1[8]; // tableau où le mot donné par l'utilisateur est rangé

char permu_tab[8]; // tableau où le mot permuté est rangé

char permu_tab2[8]; // tableau où le mot initial est rangé

int matrice[7][7]={ // matrice permettant de permuter le mot

{0,0,1,0,0,0,0},//1{0,0,0,0,1,0,0},//2{1,0,0,0,0,0,0},//3{0,0,0,1,0,0,0},//4{0,0,0,0,0,1,0},//5{0,1,0,0,0,0,0},//6{0,0,0,0,0,0,1}};//7

int matrice1[7][7]={ // matrice permettant de retrouver le mot initial

{0,0,1,0,0,0,0},//1{0,0,0,0,0,1,0},//6{1,0,0,0,0,0,0},//3{0,0,0,1,0,0,0},//4{0,1,0,0,0,0,0},//2{0,0,0,0,1,0,0},//5{0,0,0,0,0,0,1}};//7int k=0;

// réel permettant d'incrementer les tableaux où le mot est codé int i=0;

// réel permettant de changer de ligne et de colonne dans la matrice

cout<<"Donner un mot de 7 lettres"<<endl;cin>>mot1;cout<<"Le nombre de lettres est "<<strlen(mot1)<<endl;

//strlen permet de savoir combien de lettres possède le mot donné par l'utilisateur

while(k<(int)strlen(mot1)) { permu_tab[k]=mot1[0]*matrice[0][k];

// initialise la première case du tableau permu_tab par la mutiplication entre la première lettre du mot et le nombre présent dans la matrice ligne 0 et colonne 0 de la matrice

i=1;while(i<(int)strlen(mot1)){

permu_tab[k]= permu_tab[k]+mot1[i]*matrice[i][k];// incrémente le tableau permu_tab par la multiplication entre les différentes lettres du mot et la matrice

i++;// incrémentation du réel pour que nous changions de lettre dans le mot et de colonne dans la matrice

}

k++;// incrémentation du réel pour pouvoir changer de case dans le tableau où le mot est permuté ainsi que les lignes dans la matrice

}permu_tab[k]='\0';cout<< "Le mot permuté est "<<permu_tab<<endl;

Le déchiffrement: Dans cette partie, nous avons créé un programme qui permet le déchiffrement d’un mot permuté, c’est-à-dire qu’il retrouve le mot initial qui a été permuté, en connaissant la première clé de chiffrement.

Pour réaliser ce programme, nous avons utilisé deux tableaux, le premier étant le deuxième tableau du programme de chiffrement, afin d’avoir le mot permuté dès le début de la programmation.Le deuxième tableau déclaré pour ce programme va être utilisé pour placer le mot déchiffré, en ajoutant une lettre par mot.

Nous avons utilisé les deux mêmes entiers que pour le programme de chiffrement (i et k), mais nous les avons réinitialisé à 0 afin qu’ils puissent être de nouveau utilisés comme précédemment.

Nous avons donc déclaré un troisième tableau, ainsi qu’une deuxième matrice.Cette deuxième matrice est la matrice « inverse » de la première, c’est-à-dire que nous l’avons écrite afin qu’elle permute de nouveau, le mot permuté lors du programme de chiffrement. Grâce à cette matrice, on retrouve donc le mot initialement écrit par l’utilisateur.

Notre programme de déchiffrement:

i=0;k=0;while(k<(int)strlen(permu_tab)){ permu_tab2[k]=permu_tab[0]*matrice1[0][k];

// initialise la premiere case du tableau permu_tab par la mutiplicationentre la première lettre du mot et le nombre présent dans la matrice ligne 0 et colonne 0 de la matrice

i=1;

while(i<(int)strlen(mot1)){

permu_tab2[k]= permu_tab2[k]+permu_tab[i]*matrice1[i][k];// incrémente le tableau permu_tab par la multiplicationentre les différentes lettres du mot et la matrice.


}k++;

// incrémentation du réel pour pouvoir changer de case dans le tableau où le mot est permuté ainsi que les lignes dans la matrice

}permu_tab2[k]='\0';

cout<< "Le mot initial est "<<permu_tab2<<endl;

//return 0;getch();

}

2ème partie du projet: la cryptanalyse

Dans cette deuxième partie, nous avons créé un programme de cryptanalyse, c’est à dire un programme qui doit déchiffrer le message crypté précédemment, mais sans connaître la clé de chiffrement. Dans ce programme, nous devons créer une fonction qui exécute toutes les possibilités de permutations des lettres écrite dans le message crypté.

Par exemple, pour un message de 7 lettres, il existe 7 factorielles, c’est à dire 7x6x5x4x3x2 possibilités de permutations des lettres du message. Dans notre cas, pour un message de 4 lettres, il existe donc 24 possibilités de permutations, un nombre trop important pour les effectuer sans un programme informatique. Dans ce programme nous devons donc afficher les 24 valeurs à l’écran, pour que l’utilisateur puisse choisir celle qui lui paraît la plus cohérente.

Nous avons donc déclaré 24 matrices, suivies de 24 tableaux, afin d’afficher à chaque fois les différents mots trouvés dans différents tableaux. Chaque matrice va permettre de permuté les lettres du mot de 4 lettres écrit par l’utilisateur. Chacune des matrices vont effectuer une permutation des lettres différentes, afin d’avoir toutes les possibilités existantes de ce mot.

C’est une méthode utilisée pour les personnes dites « espionnes », afin de pouvoir déchiffrer les messages cryptés, sans avoir la clé de chiffrement ou de déchiffrement.

Notre programme de cryptanalyse:

#include<iostream>#include<conio.h>#include <string.h> using namespace std;

int main(void){

char mot2[5];// tableau où le mot donné par l'utilisateur est rangé

char mot_permu[5];char mot_permu1[5];char mot_permu2[5];char mot_permu3[5];char mot_permu4[5];char mot_permu5[5];char mot_permu6[5];char mot_permu7[5];char mot_permu8[5];char mot_permu9[5];char mot_permu10[5];char mot_permu11[5];char mot_permu12[5];char mot_permu13[5];char mot_permu14[5];char mot_permu15[5];char mot_permu16[5];char mot_permu17[5];char mot_permu18[5];char mot_permu19[5];char mot_permu20[5];char mot_permu21[5];char mot_permu22[5];char mot_permu23[5];

// 24 tableaux pour trouver le mot initial// représentente les 24 matrices pour trouver le bon mot

int matrice[4][4]={//1{1,0,0,0},{0,1,0,0},{0,0,1,0},{0,0,0,1}};int matrice1[4][4]={//2{1,0,0,0},{0,1,0,0},{0,0,0,1},{0,0,1,0}};int matrice2[4][4]={//3{1,0,0,0},{0,0,1,0},{0,1,0,0},{0,0,0,1}};int matrice3[4][4]={//4{1,0,0,0},{0,0,1,0},

{0,0,0,1},{0,1,0,0}};int matrice4[4][4]={//5{1,0,0,0},{0,0,0,1},{0,1,0,0},{0,0,1,0}};int matrice5[4][4]={//6{1,0,0,0},{0,0,0,1},{0,0,1,0},{0,1,0,0}};int matrice6[4][4]={//7{0,1,0,0},{1,0,0,0},{0,0,1,0},{0,0,0,1}};int matrice7[4][4]={//8{0,1,0,0},{1,0,0,0},{0,0,0,1},{0,0,1,0}};int matrice8[4][4]={//9{0,1,0,0},{0,0,1,0},{1,0,0,0},{0,0,0,1}};int matrice9[4][4]={//10{0,1,0,0},{0,0,1,0},{0,0,0,1},{1,0,0,0}};int matrice10[4][4]={//11{0,1,0,0},{0,0,0,1},{1,0,0,0},{0,0,1,0}};int matrice11[4][4]={//12{0,1,0,0},{0,0,0,1},{0,0,1,0},{1,0,0,0}};int matrice12[4][4]={//13{0,0,1,0},{1,0,0,0},{0,1,0,0},{0,0,0,1}};int matrice13[4][4]={//14{0,0,1,0},{1,0,0,0},{0,0,0,1},{0,1,0,0}};int matrice14[4][4]={//15{0,0,1,0},{0,1,0,0},{1,0,0,0},{0,0,0,1}};int matrice15[4][4]={//16{0,0,1,0},{0,1,0,0},{0,0,0,1},

{1,0,0,0}};int matrice16[4][4]={//17{0,0,1,0},{0,0,0,1},{1,0,0,0},{0,1,0,0}};int matrice17[4][4]={//18{0,0,1,0},{0,0,0,1},{0,1,0,0},{1,0,0,0}};int matrice18[4][4]={//19{0,0,0,1},{1,0,0,0},{0,1,0,0},{0,0,1,0}};int matrice19[4][4]={//20{0,0,0,1},{1,0,0,0},{0,0,1,0},{0,1,0,0}};int matrice20[4][4]={//21{0,0,0,1},{0,1,0,0},{1,0,0,0},{0,0,1,0}};int matrice21[4][4]={//22{0,0,0,1},{0,1,0,0},{0,0,1,0},{1,0,0,0}};int matrice22[4][4]={//23{0,0,0,1},{0,0,1,0},{1,0,0,0},{0,1,0,0}};int matrice23[4][4]={//24{1,0,0,0},{0,1,0,0},{0,0,1,0},{0,0,0,1}};

int k=0;// réel permettant d'incrémenter les tableaux où le mot est codé

int i=0;// réel permettant de changer de ligne et de colonne dans la matrice

cout<<"Donner un mot de 4 lettres"<<endl;cin>>mot2;cout<<"Le nombre de lettres est "<<strlen(mot2)<<endl;

//strlen permet de savoir combien de lettre a le mot donné par l'utilisateur

while(k<(int)strlen(mot2)) {

mot_permu[k]=mot2[0]*matrice[0][k];// initialise la première case du tableau permu_tab par la multiplicationentre la première lettre du mot et le nombre présent dans la matrice ligne 0 et colonne 0 de la matrice

i=1;while(i<(int)strlen(mot2))

{mot_permu[k]= mot_permu[k]+mot2[i]*matrice[i][k];

// incrémente le tableau permu_tab par la multiplication entre les différentes lettres du mot et la matrice


}k++;

// incrémentation du réel pour pouvoir changer de case dans le tableau où le mot est permuté ainsi que les lignes dans la matrice

}mot_permu[k]='\0';cout<< "La première permutation est "<<mot_permu<<endl;

i=0;k=0;


mot_permu1[k]=mot2[0]*matrice1[0][k];i=1;while(i<(int)strlen(mot2)){

mot_permu1[k]= mot_permu1[k]+mot2[i]*matrice1[i][k];i++;

}k++;

}mot_permu1[k]='\0';cout<< "La deuxième permutation est "<<mot_permu1<<endl;

i=0;k=0;




}k++;

}mot_permu2[k]='\0';cout<< "La troisième permutation est "<<mot_permu2<<endl;

i=0;k=0;



mot_permu3[k]= mot_permu3[k]+mot2[i]*matrice3[i][k];

i++;}k++;

}mot_permu3[k]='\0';cout<< "La quatrième permutation est "<<mot_permu3<<endl;

i=0;k=0;




}k++;

}mot_permu4[k]='\0';cout<< "La cinquième permutation est "<<mot_permu4<<endl;

i=0;k=0;




}k++;

}mot_permu5[k]='\0';cout<< "La sixième permutation est "<<mot_permu5<<endl;

i=0;k=0;




}k++;

}mot_permu6[k]='\0';cout<< "La septième permutation est "<<mot_permu6<<endl;

i=0;k=0;




}k++;

}mot_permu7[k]='\0';cout<< "La huitième permutation est "<<mot_permu7<<endl;

i=0;k=0;




}k++;

}mot_permu8[k]='\0';cout<< "La neuvième permutation est "<<mot_permu8<<endl;

i=0;k=0;




}k++;

}mot_permu9[k]='\0';cout<< "La dixième permutation est "<<mot_permu9<<endl;

i=0;k=0;




}k++;

}mot_permu10[k]='\0';cout<< "La onzième permutation est "<<mot_permu10<<endl;

i=0;k=0;




}k++;

}mot_permu11[k]='\0';cout<< "La douzième permutation est "<<mot_permu11<<endl;

i=0;k=0;




}k++;

}mot_permu12[k]='\0';cout<< "La treizième permutation est "<<mot_permu12<<endl;

i=0;k=0;




}k++;

}mot_permu13[k]='\0';cout<< "La quartozième permutation est "<<mot_permu13<<endl;

i=0;k=0;


mot_permu14[k]=mot2[0]*matrice14[0][k];

i=1;while(i<(int)strlen(mot2)){


}k++;

}mot_permu14[k]='\0';cout<< "La quinzième permutation est "<<mot_permu14<<endl;

i=0;k=0;




}k++;

}mot_permu15[k]='\0';cout<< "La seizième permutation est "<<mot_permu15<<endl;

i=0;k=0;




}k++;

}mot_permu16[k]='\0';cout<< "La dix-septième permutation est "<<mot_permu16<<endl;

i=0;k=0;




}k++;

}mot_permu17[k]='\0';cout<< "La dix-huitième permutation est "<<mot_permu17<<endl;

i=0;k=0;




}k++;

}mot_permu18[k]='\0';cout<< "La dix-neuvième permutation est "<<mot_permu18<<endl;

i=0;k=0;




}k++;

}mot_permu19[k]='\0';cout<< "La vingtième permutation est "<<mot_permu19<<endl;

i=0;k=0;




}k++;

}mot_permu20[k]='\0';cout<< "La vingt et unième permutation est "<<mot_permu20<<endl;

i=0;k=0;




}k++;

}mot_permu21[k]='\0';cout<< "La vingt deuxième permutation est "<<mot_permu21<<endl;

i=0;k=0;




}k++;

}mot_permu22[k]='\0';cout<< "La vingt troisième permutation est "<<mot_permu22<<endl;

i=0;k=0;




}k++;

}mot_permu23[k]='\0';cout<< "La dernière permutation est "<<mot_permu23<<endl;

getch();}

On peut voir dans l’exemple suivant que la douzième permutation donne bien le prénom « Yoan ».

Matériaux utilisés pour la réalisation du projet:

Visual Studio 2008 Internet : -www.apprendre-informatique.com

-sites.univ-provence.fr -www.siteduzéro.com

Conclusion:

On peut conclure que ses programmes nous ont permis d’améliorer notre niveau en Informatique Industriel, mais surtout à l’utilisation du langage C++.

Pour réaliser ses programmes, nous avons dû effectuer différentes recherches, comme pour l’utilisation et la déclaration d’une matrice en langage C++. Ce projet nous a aussi permis d’apprendre à travailler en équipe, et de nous mettre dans des conditions réelles de travail. L’élaboration de ce projet nous a permis de transformer les connaissances théoriques apprises en cours en expériences pratiques.

Nous avons appris aussi à gérer la répartition des tâches dans ce projet, afin d’optimiser au maximum notre temps de travail.

Nous avons donc apprécié ce projet, qui est pour les élèves, une façon intéressante d’apprendre et d’utiliser la théorie vue en cours.

· Web viewRéaliser un programme en C permettant de chiffrer un message à l’aide d’un...

Documents

Transcript of · Web viewRéaliser un programme en C permettant de chiffrer un message à l’aide d’un...