Cryptage
LES BASES CRYPTAGE
Explications sur les principes de bases pour le cryptage (XOR, substitution monoalphab彋ique...)
Aujourd'hui je vais expliquer les bases du cryptage, faudra pas s'attendre a un source C capable de cracker le cryptage de votre banque.
Comme vous vous en doutez le cryptage sert a prot嶲er des regards indiscrets un
message, un document, plein de trucs... Si vous suivez bien je vous donnerai un code C de cryptage XOR pas s嶰uris廥 mais pratique pour cacher des choses sur son hd car il pe crypter tous les types de fichiers ainsi qu'une source (encore en C) mettant en place un algorithme RSA !
Le cryptage de base
Mais avant voici un algorithme de cryptage tr鋊 simple qui va pas vous larguer : le chiffrement de c廥ar qui consiste a d廧lacer les lettres de l'alphabets de n (normalement 3 mais sa peut s'utiliser avec la nombre qu'on veux) rangs ce qui donne un tableau comma ceci :
(si n vaut 13)
a b c d e f g h i j k l m n o p q r s t u v w x y z
n o p q r s t u v w x y z a b c d e f g h i j k l m
Ainsi le message : "voila un exemple" donne : "ibvyn ha rkrzcyr"
L'algorithme c'est en fait le proc嶮 utiliser pour passer du texte normal au texte crypt.
Cet algorithme n'est pas sur car m瘱e si vous changiez la clef ( ici 13 c'est le nombre de lettres de d嶰alage) sa ne serais pas plus sur car l'alphabet ne contient que 26 caract鋨es ce qui nous fait que 26 possibilit廥 de cl廥, le code serait vite crack !
Voici une source permettant de crypter ou de d嶰rypter un code chiffr a l'aide du chiffrement de c廥ar : (nous sommes le 05/07/02 et sur le site de news hackers, il y a un mini challenge qui consiste a d嶰oder un code crypt a l'aide du chiffrement de c廥ar, donc ce code pourrait vous servir)
/*Debut du code******************/
#include
#include
main() {
char a;
int b;
char wait;
int choix;
char source[100];
char dest[100];
FILE *In, *Out;
int clef;
printf("Entrez le chemin d'acces du fichier source (*.txt)\n");
scanf("%s",&source);
printf("\nEntrez le chemin d'acces du fichier destination\n");
scanf("%s",&dest);
printf("\nEntrez la clef de chiffrement\n");
scanf("%d",&clef);
printf("\nQuelle operation souhaitez vous effectuer? (1 pour crypter, 2
pour decrypter)\n");
scanf("%d",&choix);
if((In = fopen(source,"r")) == NULL || (Out =
fopen(dest,"w")) == NULL) {
printf("Erreur, lors de la verificaton des fichiers");
exit(0);
}
if(clef > 100 || clef < 0) {
printf("Clef invalide");
exit(0);
}
if(choix == 2) {
clef = 26 - clef;
}
scanf("%c",&wait);
while((a = fgetc(In)) != EOF) {
if(a == ' ') {
putc(a,Out);
printf("%c",a);
}
else {
b = a;
b = ((b + (toupper(clef)) - 'A') % 26 ) + 'A';
printf("%c",b);
putc(b,Out);
}
}
printf("\nOperation terminee ! ( pour quitter)");
scanf("%c",&wait);
}
/*Coded by HyBRiD NIx, 2/7/02****/
/*Compiled with Visual C++ v6.0**/
/*Principe de l'algorithme par***/
/*Thakkar adapt par HyBRiD NIx**/
/*Fin du code/*******************/
La substitution monoalphabetique
(d廥ol pour le mot barbare, mais vous verez, c'est tr鋊 simple).
Cet algorithme consiste remplacer une lettre par une autre (vous voyez que c'est pas dur ;) ). C'est plus s嶰uris廥 que l'algorithme pr嶰嶮ant mais sa en reste toujours assez facile a d嶰oder car dans la langue francaise, les lettres ont un fr廦uence d'apparition que l'ont peut mesurer ainsi comme la fr廦uence d'apparition du 'e' dans un texte est d'environs 17%, un 'e' chang en 'r' dans un texte se remarquerai tr鋊 vite !
Mais toutes ces m彋hodes de cryptage qui op鋨ent sur l'alphabet ne sont pas
s嶰uris嶪s et je vous les d嶰onseillent !
Le cryptage 憝olue
Le cryptage par ordinateur d幨aisse les technique mono-alphab彋ique au profit
des algorithmes jouant sur les bits. Tout de suite, nous allons voir le plus simple de ces cryptages binaires : le XOR (ou "ou exclusif") ! Cette technique de base est utilis嶪s dans des algorithmes plus complexes et il est tr鋊 utile de le conna褾re :
La table du XOR
XOR | 0 | 1 ==> explications : cet op廨ateur binaire compare deux
nombre (on est dans le binaire : 0 et 1)
0 | 0 | 1 ainsi : 0 xor 1 donne 1
1 | 1 | 0 1 xor 0 donne 1
1 xor 1 donne 0
0 xor 0 donne 0
Exemple :
Texte clair : "exemple de xor"
cl : "clef" (je vous d嶰onseille d'utiliser des clefs a deux balles comme sa mais bon c'est pour l'exemple)
Le texte "exemple de xor" donne : (pour obtenir ce r廥ultat, j'ai convertit chaque lettres de la phrase en leur valeur ascii et je les ais convertis en binaire, sur 8bits (voir sur le site un zine sur le binaire ainsi que image, la table ascii -- la table ASCII (American Standard Code for Information Interchange) est un tableau r嶨廨enscent
0110010101111000011001000110110101110000011011000110010100000000011001000110010100000000011110000110111101110010
et la clef "clef" donne :
01100011011011000110010101100110
maintenant, il faut faire le xor :
01100101011110000110010001101101 <== 1ere partie du texte de la m瘱e longueur que la clef
01100011011011000110010101100110 <== clef
00000110000101000000000100001011 <== la 1ere partie crypt
01110000011011000110010100000000 <== 2e partie du texte de la m瘱e longueur
que la clef
01100011011011000110010101100110 <== clef
00010011000000000000000001100110 <== la 2e partie crypt
01100100011001010000000001111000 <== 3e partie du texte de la m瘱e longueur
que la clef
01100011011011000110010101100110 <== clef
00000111000010010110010100011110 <== la 3e partie crypt
0110111101110010 <== 4e partie du texte de la m瘱e longueur que la clef
0110001101101100 <== d嶵ut clef de la m瘱e longueur que le reste du texte
0000110000011110 <== la 4e partie crypt
Ensuite, on remet tous les segments de texte crypt ensemble :
0000011000010100000000010000101100010011000000000000000001100110000001110000100101100101000111100000110000011110
maintenant, faut le retransformer en binaire en texte :
Binaire D嶰imal(ou ascii) Hexa
00000110 = 6
00010100 = 20
00000001 = 1
00001011 = 11
00010011 = 19
00000000 = 0
00000000 = 0
01100110 = 102
00000111 = 7
00001001 = 9
01100101 = 101
00011110 = 30
00001100 = 12
00011110 = 30
Voila, comme ces caract鋨es sont impossibles a frapper, un petit programme C convertissant ces valeurs ascii s'impose :
/*Debut du code******************/
#include
main() {
char wait; //variable pour faire attendre a la fin du programme
char debut[] = "Voici le texte crypte : \"";
char fin[] = "\" Fin du texte crypte";
printf("%s%c%c%c%c%c%c%c%c%c%c%c%c%c%c%s",debut,6,20,1,11,19,0,0,102,7,9,101,30,12,30,fin);//affiche
les carct鋨es
printf("\nEntrer pour quitter");
//correspondants aux
scanf("%c", &wait);
//valeurs ascii
}
/*Coded by HyBRiD NIx, 2/7/02****/
/*Compiled with Visual C++ v6.0**/
/*Fin du code/*******************/
Voici comment marche le xor :).
PS pour le d嶰ryptage, c'est la m瘱e : convertir en binaire sur 8 bits le texte crypt, faire de m瘱e avec la clef (je vous la rappelle : "clef"), puis effectuer le xor comme je l'ai fait au dessus et reconvertir en ascii.
Petit code C de mise en place d'un cryptage XOR - il n'est pas s嶰uris (le nombre de cl廥 possibles est de 256) et je ne vous le donne qu'a titre d'exemple (ce qui ne vous emp璚he pas de l'utiliser pour planquer des fichiers sur votre disque moi c'est surtout pour que mon fr鋨e fouille pas trop dans mes affaires que j'ai fait sa.
/*Debut du code******************/
#include
#include
main() {
char chem_source[100]; //Tableau qui contiendra le
chemin d'acc鋊 au fichier source
char chem_dest[100]; //Tableau qui contiendra le
chemin d'acc鋊 au fichier destination
char wait; //Variable d'attente pour le
fin ddu cryptage
unsigned char byte; //C'est la variable qui
servira pour le XOR
int clef; //la variable de la clef de
cryptage
FILE *Source,*Crypt; //Les descripteurs de
fichiers
printf("Entrez le chemin d'acces du fichier source : (validez par
)\n");
scanf("%s",&chem_source); //on place le
chemin tap dans un tableau
fflush(stdin); //on vide le buffer
printf("\n\nEntrez le chemin d'acces du fichier destinaton : (validez par
)\n");
scanf("%s",&chem_dest); //on place le
chemin tap dans un tableau
fflush(stdin); //on vide le buffer
if ( ((Source = fopen(chem_source,"r")) == NULL) || ((Crypt =
fopen(chem_dest,"w")) == NULL) ) { //test si les fichiers
printf("Erreur lors de la verification de la validite des fichiers
!"); //sont valides
fcloseall(); //ferme tous les fichiers
exit(-1); //on quitte le programme
}
printf("\n\nEntrez la clef (entre 0 et 255 inclus)\n");
scanf("%d",&clef);
fflush(stdin);
if ( (clef > 255) || (clef < 0) ) { //test de la validit
de
printf("Clef invalide !"); //la clef
fcloseall(); //ferme tous les fichiers
exit(-1); //on quitte le programme
}
while (fread(&byte,1,1,Source)) { //li un octet du fichier
jusqu'a sa fin
byte ^= clef; //廦uivaut byte = byte ^
clef
fwrite(&byte,1,1,Crypt); //copie l'octet crypt
dans le fichier destination
}
fcloseall(); //ferme tous les fichiers
printf("\n\n\nFichier crypte avec succes ! ( pour
quitter)");
scanf("%c", &wait);
}
/*Coded by HyBRiD NIx, 2/7/02****/
/*Compiled with Visual C++ v6.0**/
/*Fin du code********************/
PETITE ASTUCE : Pour crypter plusieurs fichiers en meme temps, faites un zip de tous les fichiers a crypter et cryptez le !
LE CHIFFREMENT A CLEFS PUBLIQUES
Jusqu'a pr廥ent, je vous ait expliquer les fonctionnement de cryptage a clefs priv嶪s, c'est a dire que pour d嶰oder un texte crypt avec une clef priv嶪, il faut transmettre aux destinataire du message sa clef priv嶪. Cela pose un probl鋗e si une personne obtient votre clef, elle pourra d嶰hiffrer tous vos message. Face a ce probleme, des math幦aticiens on trouv廥 une solution : le chiffrement a clefs publiques. Il repose sur 2 clef : une clef publique pour crypter les choses et une clef priv嶪 pour les d嶰rypter. Sa parait impossible mais je vais vous donner un exemple, l'algorithme RSA.
LE RSA
C'est un systeme de cryptage a clef publique mis au point en 1977 par Rivest, Shamir et Adelman (d'ou son nom RSA).Cet algorithme diff鋨e l嶲鋨ement du syst鋗e classique du chiffrement a clefs publiques car il utilise deux clefs publiques (une pour crypter, l'autre pour d嶰rypter) et une clef priv嶪. Voici son fonctionnement :
A la base on a deux nombres A et B (normalement, pour que le chiffrement soit tr鋊 s嶰uris il faudrait prendre des nombres premiers d'une centaines de chiffres au minimum, mais ce tuto n'est 嶰rit que pour vous apprendre le fonctionnement du cryptage donc nous allons prendre des nombres premiers assez petits)
ON A A=5 ET B=11
Une petite source pour trouver des nombres premiers (je suis pas sur que c'est la mani鋨e la plus rapide mais sa marche) :
/*Debut du code******************/
#include
main() {
int r = //mettre le nombre de d廧art
int w = //mettre le nombre de fin
int i;
char wait;
int h = 0;
int j;
printf("Recherche demaree");
for(i=r;ifor(j=2;j<=i;j++) {
if (i % j == 0) {
h = 1;
goto suite;
}
}
if (h == 0) {
printf("nb premier trouve : %d\n",i);
scanf("%c",&wait);
fflush(stdin);
h = 0;
}
suite :
j = 2;
h = 0;
}
}
/*Coded by HyBRiD NIx, 5/7/02****/
/*Compiled with Visual C++ v6.0**/
/*Fin du code********************/
Ensuite, il faut calculer N : N = A * B
N = 5 * 11
N = 55
Ensuite on calcule R : R = (A - 1) * (B - 1)
R = 4 * 10
R = 40
On recherche de nouvelles variables A et B tel que : (A * B) modulo R = 1
Encore une source :
/*Debut du code******************/
#include
#include
main() {
int R = 40;
int A;
int B=5;
char wait;
for(A=2;A=A;A++) {
if ((A * B) % R == 1) {
if ( A != B ) {
printf("Trouve : A = %d et B = %d",A,B);
scanf("%c",&wait);
fflush(stdin);
}
}
if(A==B) {
A = 0;
B = B + 1;
}
}
}
/*Coded by HyBRiD NIx, 5/7/02****/
/*Compiled with Visual C++ v6.0**/
/*Fin du code********************/
On choisi A=3 et B=27 (m瘱e s'il y a une infinit de possibilit, mais il ne faut pas prendre deux valeurs semblables)
Nous avons besoin de A, B, N :
A = 3 sera la clef publique pour le cryptage
B = 11 sera la clef publique pourle d嶰ryptage
et N = 45 sera la clef secr鋈e.
Voici comment proc嶮er a partir de ces clefs :
Pour crypter : (T est le chiffre a crypter)
(T ^ A) modulo N = C
Pour T = 4 :
(4 ^ 3) % 55 = 9
Notre chiffre devient
Pour d嶰rypter : (C est le r廥ultat de l'op廨ation pr嶰嶮ente)
(C ^ B) modulo N = T
Pour C = 36 :
(9 ^ 27) % 55 = 4
Donc sa marche !
Mais bon la, vu que les nombres ne sont pas grand, sa n'assure pas une tr鋊
grande s嶰urit...
|
 讓我們程式搜尋結果更加完美 如果您覺得該文件有幫助到您，煩請按下我如果您覺得該文件是一個一無是處的文件，也煩請按下我 |
|
該文件您看起來是亂碼嗎？您可以切換編碼方式試試看！ISO-8859-1 | latin1 | euc-kr | euc-jp | CP936 | CP950 | UTF-8 | GB2312 | BIG5 |
|