ce code à été réaliser dans 3 jous uniquement pour le but de mini projet de cryptage
ce code à été présenter à issats
le compilateur est BorlantC++
Source / Exemple :
#include <stdio.h>
#include <conio.h>
#include <windows.h>
#include <stdlib.h>
char t[17]={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};// Tableau utiliser en convertion Binaire ---> Hexadecimale
//-------------------------------------fonction de convertion de base binaire à la base hexadicimale de taille 64bits
void convBinHex64 (int *b , char *h)
{
int *q, *a,i,j,*c1;
char *c;
c=(char*)malloc(16*sizeof(char));
q=(int*)malloc(64*sizeof(int));
a=(int*)malloc(4*sizeof(int));
c1=(int*)malloc(1*sizeof(int));
q=b;
c=h;
for(i=0;i<16;i++)
{
for (j=0;j<4;j++)
- (a+j)=*(q+j+i*4);
- c1= *(a+3)+*(a+2)*2+*(a+1)*4+*(a+0)*8;
- (c+i) = t[*c1];
}
}
//-------------------------------------fonction de convertion de base binaire à la base hexadicimale de taille 48 bits
void convBinHex48 (int *b , char *h)
{
int *q, *a,i,j,*c1;
char *c;
c=(char*)malloc(12*sizeof(char));
q=(int*)malloc(48*sizeof(int));
a=(int*)malloc(4*sizeof(int));
c1=(int*)malloc(1*sizeof(int));
q=b;
c=h;
for(i=0;i<12;i++)
{
for (j=0;j<4;j++)
- (a+j)=*(q+j+i*4);
- c1= *(a+3)+*(a+2)*2+*(a+1)*4+*(a+0)*8;
- (c+i) = t[*c1];
}
}
//-------------------------------------fonction de convertion de base binaire à la base hexadicimale de taille 32bits
void convBinHex32 (int *b , char *h)
{
int *q, *a,i,j,*c1;
char *c;
c=(char*)malloc(8*sizeof(char));
q=(int*)malloc(32*sizeof(int));
a=(int*)malloc(4*sizeof(int));
c1=(int*)malloc(1*sizeof(int));
q=b;
c=h;
for(i=0;i<8;i++)
{
for (j=0;j<4;j++)
- (a+j)=*(q+j+i*4);
- c1= *(a+3)+*(a+2)*2+*(a+1)*4+*(a+0)*8;
- (c+i) = t[*c1];
}
}
//-------------------------------------fonction de convertion de base binaire à la base hexadicimale de taille 28 bits
void convBinHex28 (int *b , char *h)
{
int *q, *a,i,j,*c1;
char *c;
c=(char*)malloc(7*sizeof(char));
q=(int*)malloc(28*sizeof(int));
a=(int*)malloc(4*sizeof(int));
c1=(int*)malloc(1*sizeof(int));
q=b;
c=h;
for(i=0;i<7;i++)
{
for (j=0;j<4;j++)
- (a+j)=*(q+j+i*4);
- c1= *(a+3)+*(a+2)*2+*(a+1)*4+*(a+0)*8;
- (c+i) = t[*c1];
}
}
//------------affiche tableau b avec l nombre de ligne et c nombre de colonne
void affiche_tab(int *b,int l,int c)
{int *p,*q;
for (p=b;p<b+l*c;p+=c)
{for (q=p;q<p+c;q++)
printf("%d",*q);
}
}
//------------convertion de dicimale vers binaire
void convert (int d,int *b)
{
int i,j=63, *p,*q;
int div,div2;
for(p=b;p<b+64;p+=8)
for(q=p;q<p+8;q++)
div=d;
do
{
div2 = div / 2;
j--;
div = div2;
} while (j > 0 && div2 != 0);
}
//------------Premutation de 64bits en 56bits
void pc1(int *a,int *b)//a de dimension 64 bits et b de dimension 56 bits
{ int *p1, *q1;
p1=(int*)malloc(64*sizeof(int));
q1=(int*)malloc(56*sizeof(int));
p1=a;q1=b;
- q1=*(p1+56);*(q1+1)=*(p1+48);*(q1+2)=*(p1+40);*(q1+3)=*(p1+32);*(q1+4)=*(p1+24);*(q1+5)=*(p1+16);*(q1+6)=*(p1+8);
- (q1+7)=*(p1);*(q1+8)=*(p1+57);*(q1+9)=*(p1+49);*(q1+10)=*(p1+41);*(q1+11)=*(p1+33);*(q1+12)=*(p1+25);*(q1+13)=*(p1+17);
- (q1+14)=*(p1+9);*(q1+15)=*(p1+1);*(q1+16)=*(p1+58);*(q1+17)=*(p1+50);*(q1+18)=*(p1+42);*(q1+19)=*(p1+34);*(q1+20)=*(p1+26);
- (q1+21)=*(p1+18);*(q1+22)=*(p1+10);*(q1+23)=*(p1+2);*(q1+24)=*(p1+59);*(q1+25)=*(p1+51);*(q1+26)=*(p1+43);*(q1+27)=*(p1+35);
- (q1+28)=*(p1+62);*(q1+29)=*(p1+54);*(q1+30)=*(p1+46);*(q1+31)=*(p1+38);*(q1+32)=*(p1+30);*(q1+33)=*(p1+22);*(q1+34)=*(p1+14);
- (q1+35)=*(p1+6);*(q1+36)=*(p1+61);*(q1+37)=*(p1+53);*(q1+38)=*(p1+45);*(q1+39)=*(p1+37);*(q1+40)=*(p1+29);*(q1+41)=*(p1+21);
- (q1+42)=*(p1+13);*(q1+43)=*(p1+5);*(q1+44)=*(p1+60);*(q1+45)=*(p1+52);*(q1+46)=*(p1+44);*(q1+47)=*(p1+36);*(q1+48)=*(p1+28);
- (q1+49)=*(p1+20);*(q1+50)=*(p1+12);*(q1+51)=*(p1+4);*(q1+52)=*(p1+27);*(q1+53)=*(p1+19);*(q1+54)=*(p1+11);*(q1+55)=*(p1+3);
}
//-------------Permutation de 56bits en 48 bits
void pc2(int *a,int *b) //a de dimension 56 et b de dimension 48
{ int *p, *q;
p=(int*)malloc(56*sizeof(int));
q=(int*)malloc(48*sizeof(int));
p=a;q=b;
- q=*(p+13); *(q+1)=*(p+16);*(q+2)=*(p+10);*(q+3)=*(p+23);*(q+4)=*p;*(q+5)=*(p+4);
- (q+6)=*(p+2); *(q+7)=*(p+27);*(q+8)=*(p+14);*(q+9)=*(p+5);*(q+10)=*(p+20);*(q+11)=*(p+9);
- (q+12)=*(p+22);*(q+13)=*(p+18);*(q+14)=*(p+11);*(q+15)=*(p+3);*(q+16)=*(p+25);*(q+17)=*(p+7);
- (q+18)=*(p+15);*(q+19)=*(p+6);*(q+20)=*(p+26);*(q+21)=*(p+19);*(q+22)=*(p+12);*(q+23)=*(p+1);
- (q+24)=*(p+40);*(q+25)=*(p+51);*(q+26)=*(p+30);*(q+27)=*(p+36);*(q+28)=*(p+46);*(q+29)=*(p+54);
- (q+30)=*(p+29);*(q+31)=*(p+39);*(q+32)=*(p+50);*(q+33)=*(p+44);*(q+34)=*(p+32);*(q+35)=*(p+47);
- (q+36)=*(p+43);*(q+37)=*(p+48);*(q+38)=*(p+38);*(q+39)=*(p+55);*(q+40)=*(p+33);*(q+41)=*(p+52);
- (q+42)=*(p+45);*(q+43)=*(p+41);*(q+44)=*(p+49);*(q+45)=*(p+35);*(q+46)=*(p+28);*(q+47)=*(p+31);
}
//--------------------permet d'avoir 48bits à partir de 32 bits
void expansion(int *b,int *a) //a de dimension 32 b de dimension 48
{ int *p2, *q2;
p2=(int*)malloc(32*sizeof(int));
q2=(int*)malloc(48*sizeof(int));
p2=b;q2=a;
- q2=*(p2+31);*(q2+1)=*(p2+0);*(q2+2)=*(p2+1);*(q2+3)=*(p2+2);*(q2+4)=*(p2+3);*(q2+5)=*(p2+4);
- (q2+6)=*(p2+3);*(q2+7)=*(p2+4);*(q2+8)=*(p2+5);*(q2+9)=*(p2+6);*(q2+10)=*(p2+7);*(q2+11)=*(p2+8);
- (q2+12)=*(p2+7);*(q2+13)=*(p2+8);*(q2+14)=*(p2+9);*(q2+15)=*(p2+10);*(q2+16)=*(p2+11);*(q2+17)=*(p2+12);
- (q2+18)=*(p2+11);*(q2+19)=*(p2+12);*(q2+20)=*(p2+13);*(q2+21)=*(p2+14);*(q2+22)=*(p2+15);*(q2+23)=*(p2+16);
- (q2+24)=*(p2+15);*(q2+25)=*(p2+16);*(q2+26)=*(p2+17);*(q2+27)=*(p2+18);*(q2+28)=*(p2+19);*(q2+29)=*(p2+20);
- (q2+30)=*(p2+19);*(q2+31)=*(p2+20);*(q2+32)=*(p2+21);*(q2+33)=*(p2+22);*(q2+34)=*(p2+23);*(q2+35)=*(p2+24);
- (q2+36)=*(p2+23);*(q2+37)=*(p2+24);*(q2+38)=*(p2+25);*(q2+39)=*(p2+26);*(q2+40)=*(p2+27);*(q2+41)=*(p2+28);
- (q2+42)=*(p2+27);*(q2+43)=*(p2+28);*(q2+44)=*(p2+29);*(q2+45)=*(p2+30);*(q2+46)=*(p2+31);*(q2+47)=*p2;
}
//---------------------permet diviser les 48 bits de cles divercifier en deux tableaux de 28 bits
void division (int *b ,int *g, int *d, int n)
{
int *a, *p,*q;
a=b;
p=g;
q=d;
for (p=g; p<g+n; p++)
{
a++;
}
a= b+n;
for (q=d; q<d+n; q++)
{
a++;
}
}
//---------------permet la rotation vers le gauche de tableau a en fonction de son tour r
void rotation ( int *a, int r)// a est de dimension 28 et r est le nombre de tour du clé
{
int *p, aux;
p= a;
aux = *p;
for ( p=a ;p<a+27 ; p++)
{
}
if ((r!= 1)&&(r!= 2)&&(r!= 9)&&(r!= 16))
{
p= a;
aux = *p;
for ( p=a ;p<a+27 ; p++)
{
}
}
}
//////////////////////////////////////FONCTION DE GENERATION DU CLES///////////////
//-----------Permet de générer les cles utiliser pour le chiffrement
void generation (int *b, int *cles,int ronde,int etat) // cles table contenant les 16 cles; si etat=1, on va afficher les itirations
{
int i,j,k,*p,*q,*t,*a,*g,*d,*n, t1[56];
char *aff_hex,*aff_hex1;
p=cles;
g=(int*)malloc(28*sizeof(int));
aff_hex=(char*)malloc(7*sizeof(char));
aff_hex1=(char*)malloc(13*sizeof(char));
d=(int*)malloc(28*sizeof(int));
t=(int*)malloc(56*sizeof(int));
q=(int*)malloc(56*sizeof(int));
a=(int*)malloc(48*sizeof(int));
n=(int*)malloc(48*sizeof(int));
//ronde=(int*)malloc(1*sizeof(int));
pc1 (b,t);// t est de 56 bits
division (t,g,d,28);
if (etat==1)
{
printf ("-----------------------------------------------------\n");
printf ("C0: ");
affiche_tab(g,1,28);
convBinHex28(g,aff_hex);
printf (" = ");
puts (aff_hex);
printf ("D0: ");
affiche_tab(d,1,28);
convBinHex28(d,aff_hex);
printf (" = ");
puts (aff_hex);
printf ("-----------------------------------------------------\n");
}
for (i=1; i<=ronde;i++)
{
rotation(g,i);
rotation(d,i);
if (etat==1)
{
printf ("C%d: ",i);
affiche_tab(g,1,28);
convBinHex28(g,aff_hex);
printf (" = ");
puts (aff_hex);
printf ("D%d: ",i);
affiche_tab(d,1,28);
convBinHex28(d,aff_hex);
printf (" = ");
puts (aff_hex);
}
k=0;
for (j=0;j<56;j++)
{
if (j<28)
t1[j]=*(g+j);
else
{
t1[j]=*(d+k);
k++ ;
} }
q=t1;
pc2 (q,a);// a est 48 bits
n=a;
int y;
for(n=a;n<a+48;n++)
{
p++;
}
if (etat==1)
{
printf ("K%d: ",i);
affiche_tab(a,1,48);
convBinHex48(a,aff_hex1);
printf (" = ");
puts(aff_hex1);
printf ("\n-----------------------------------------------------\n");
}
}
if (etat==1)
printf ("les iterations de cles sont termines........\n");
}
//////////////////////////////////////////////////////////////////////////////////
//------------Permutation initiale de bloc de 64bits
void pi(int *a,int *b)//a de dimension 64 bits permutation initiale
{ int *p, *q;
p=(int*)malloc(64*sizeof(int));
q=(int*)malloc(64*sizeof(int));
p=a;q=b;
- q=*(p+57);*(q+1)=*(p+49);*(q+2)=*(p+41);*(q+3)=*(p+33);*(q+4)=*(p+25);*(q+5)=*(p+17);*(q+6)=*(p+9);*(q+7)=*(p+1);
- (q+8)=*(p+59);*(q+9)=*(p+51);*(q+10)=*(p+43);*(q+11)=*(p+35);*(q+12)=*(p+27);*(q+13)=*(p+19);*(q+14)=*(p+11);*(q+15)=*(p+3);
- (q+16)=*(p+61);*(q+17)=*(p+53);*(q+18)=*(p+45);*(q+19)=*(p+37);*(q+20)=*(p+29);*(q+21)=*(p+21);*(q+22)=*(p+13);*(q+23)=*(p+5);
- (q+24)=*(p+63);*(q+25)=*(p+55);*(q+26)=*(p+47);*(q+27)=*(p+39);*(q+28)=*(p+31);*(q+29)=*(p+23);*(q+30)=*(p+15);*(q+31)=*(p+7);
- (q+32)=*(p+56);*(q+33)=*(p+48);*(q+34)=*(p+40);*(q+35)=*(p+32);*(q+36)=*(p+24);*(q+37)=*(p+16);*(q+38)=*(p+8);*(q+39)=*(p+0);
- (q+40)=*(p+58);*(q+41)=*(p+50);*(q+42)=*(p+42);*(q+43)=*(p+34);*(q+44)=*(p+26);*(q+45)=*(p+18);*(q+46)=*(p+10);*(q+47)=*(p+2);
- (q+48)=*(p+60);*(q+49)=*(p+52);*(q+50)=*(p+44);*(q+51)=*(p+36);*(q+52)=*(p+28);*(q+53)=*(p+20);*(q+54)=*(p+12);*(q+55)=*(p+4);
- (q+56)=*(p+62);*(q+57)=*(p+54);*(q+58)=*(p+46);*(q+59)=*(p+38);*(q+60)=*(p+30);*(q+61)=*(p+22);*(q+62)=*(p+14);*(q+63)=*(p+6);
}
//------------Permutation finale de bloc de 64bits
void pf(int *a,int *b)//a de dimension 64 bits permutation FINALE
{ int *p, *q;
p=(int*)malloc(64*sizeof(int));
q=(int*)malloc(64*sizeof(int));
p=a;q=b;
- q=*(p+39); *(q+1)=*(p+7); *(q+2)=*(p+47);*(q+3)=*(p+15);*(q+4)=*(p+55);*(q+5)=*(p+23);*(q+6)=*(p+63);*(q+7)=*(p+31);
- (q+8)=*(p+38); *(q+9)=*(p+6); *(q+10)=*(p+46);*(q+11)=*(p+14);*(q+12)=*(p+54);*(q+13)=*(p+22);*(q+14)=*(p+62);*(q+15)=*(p+30);
- (q+16)=*(p+37);*(q+17)=*(p+5); *(q+18)=*(p+45);*(q+19)=*(p+13);*(q+20)=*(p+53);*(q+21)=*(p+21);*(q+22)=*(p+61);*(q+23)=*(p+29);
- (q+24)=*(p+36);*(q+25)=*(p+4); *(q+26)=*(p+44);*(q+27)=*(p+12);*(q+28)=*(p+52);*(q+29)=*(p+20);*(q+30)=*(p+60);*(q+31)=*(p+28);
- (q+32)=*(p+35);*(q+33)=*(p+3); *(q+34)=*(p+43);*(q+35)=*(p+11);*(q+36)=*(p+51);*(q+37)=*(p+19);*(q+38)=*(p+59);*(q+39)=*(p+27);
- (q+40)=*(p+34);*(q+41)=*(p+2); *(q+42)=*(p+42);*(q+43)=*(p+10);*(q+44)=*(p+50);*(q+45)=*(p+18);*(q+46)=*(p+58);*(q+47)=*(p+26);
- (q+48)=*(p+33);*(q+49)=*(p+1); *(q+50)=*(p+41);*(q+51)=*(p+9);*(q+52)=*(p+49);*(q+53)=*(p+17);*(q+54)=*(p+57);*(q+55)=*(p+25);
- (q+56)=*(p+32);*(q+57)=*(p+0); *(q+58)=*(p+40);*(q+59)=*(p+8);*(q+60)=*(p+48);*(q+61)=*(p+16);*(q+62)=*(p+56);*(q+63)=*(p+24);
}
//----------permet la permutation de la résultat de s-box
void pp(int *a,int *b)//a de dimension 32 bits permutation p
{ int *p, *q;
p=(int*)malloc(32*sizeof(int));
q=(int*)malloc(32*sizeof(int));
p=a;
q=b;
- q=*(p+15); *(q+1)=*(p+6); *(q+2)=*(p+19); *(q+3)=*(p+20);
- (q+4)=*(p+28); *(q+5)=*(p+11); *(q+6)=*(p+27); *(q+7)=*(p+16);
- (q+8)=*p; *(q+9)=*(p+14); *(q+10)=*(p+22); *(q+11)=*(p+25);
- (q+12)=*(p+4); *(q+13)=*(p+17); *(q+14)=*(p+30); *(q+15)=*(p+9);
- (q+16)=*(p+1); *(q+17)=*(p+7); *(q+18)=*(p+23); *(q+19)=*(p+13);
- (q+20)=*(p+31); *(q+21)=*(p+26); *(q+22)=*(p+2); *(q+23)=*(p+8);
- (q+24)=*(p+18); *(q+25)=*(p+12); *(q+26)=*(p+29); *(q+27)=*(p+5);
- (q+28)=*(p+21); *(q+29)=*(p+10); *(q+30)=*(p+3); *(q+31)=*(p+24);
}
//-----------------convertir de binaire à la base dicimale
void convertBinDec (int *a, int *l , int *c )// a est de 6 bits
{
- l= *(a+5)+*a*2;
- c= *(a+4)+*(a+3)*2+*(a+2)*4+*(a+1)*8;
}
//--------------------permet d'avoir 32 bits à partir de 48bits
void s_box(int *a ,int *b)// a de 48 et b de 32
{
int s1[4][16],s2[4][16],s8[4][16],s3[4][16],s4[4][16],s5[4][16],s6[4][16],s7[4][16];
int s,i,k,j, *h,*p,*q,*r,*l,*c;
p=(int*)malloc(48*sizeof(int));
q=(int*)malloc(6*sizeof(int));
h=(int*)malloc(48*sizeof(int));
r=(int*)malloc(64*sizeof(int));
l=(int*)malloc(1*sizeof(int));
c=(int*)malloc(1*sizeof(int));
s1[0][0]=14; s1[0][1]=4; s1[0][2]=13; s1[0][3]=1; s1[0][4]=2; s1[0][5]=15; s1[0][6]=11; s1[0][7]=8; s1[0][8]=3; s1[0][9]=10; s1[0][10]=6; s1[0][11]=12; s1[0][12]=5; s1[0][13]=9; s1[0][14]=0; s1[0][15]=7;
s1[1][0]=0; s1[1][1]=15; s1[1][2]=7; s1[1][3]=4; s1[1][4]=14; s1[1][5]=2; s1[1][6]=13; s1[1][7]=1; s1[1][8]=10; s1[1][9]=6; s1[1][10]=12; s1[1][11]=11; s1[1][12]=9; s1[1][13]=5; s1[1][14]=3; s1[1][15]=8;
s1[2][0]=4; s1[2][1]=1; s1[2][2]=14; s1[2][3]=8; s1[2][4]=13; s1[2][5]=6; s1[2][6]=2; s1[2][7]=11; s1[2][8]=15; s1[2][9]=12; s1[2][10]=9; s1[2][11]=7; s1[2][12]=3; s1[2][13]=10; s1[2][14]=5; s1[2][15]=0;
s1[3][0]=15; s1[3][1]=12; s1[3][2]=8; s1[3][3]=2; s1[3][4]=4; s1[3][5]=9; s1[3][6]=1; s1[3][7]=7; s1[3][8]=5; s1[3][9]=11; s1[3][10]=3; s1[3][11]=14; s1[3][12]=10; s1[3][13]=0; s1[3][14]=6; s1[3][15]=13;
s2[0][0]=15; s2[0][1]=1; s2[0][2]=8; s2[0][3]=14; s2[0][4]=6; s2[0][5]=11; s2[0][6]=3; s2[0][7]=4; s2[0][8]=9; s2[0][9]=7; s2[0][10]=2; s2[0][11]=13; s2[0][12]=12; s2[0][13]=0; s2[0][14]=5; s2[0][15]=10;
s2[1][0]=3; s2[1][1]=13; s2[1][2]=4; s2[1][3]=7; s2[1][4]=15; s2[1][5]=2; s2[1][6]=8; s2[1][7]=14; s2[1][8]=12; s2[1][9]=0; s2[1][10]=1; s2[1][11]=10; s2[1][12]=6; s2[1][13]=9; s2[1][14]=11; s2[1][15]=5;
s2[2][0]=0; s2[2][1]=14; s2[2][2]=7; s2[2][3]=11; s2[2][4]=10; s2[2][5]=4; s2[2][6]=13; s2[2][7]=1; s2[2][8]=5; s2[2][9]=8; s2[2][10]=12; s2[2][11]=6; s2[2][12]=9; s2[2][13]=3; s2[2][14]=2; s2[2][15]=15;
s2[3][0]=13; s2[3][1]=8; s2[3][2]=10; s2[3][3]=1; s2[3][4]=3; s2[3][5]=15; s2[3][6]=4; s2[3][7]=2; s2[3][8]=11; s2[3][9]=6; s2[3][10]=7; s2[3][11]=12; s2[3][12]=0; s2[3][13]=5; s2[3][14]=14; s2[3][15]=9;
s3[0][0]=10; s3[0][1]=0; s3[0][2]=9; s3[0][3]=14; s3[0][4]=6; s3[0][5]=3; s3[0][6]=15; s3[0][7]=5; s3[0][8]=1; s3[0][9]=13; s3[0][10]=12; s3[0][11]=7; s3[0][12]=11; s3[0][13]=4; s3[0][14]=2; s3[0][15]=8;
s3[1][0]=13; s3[1][1]=7; s3[1][2]=0; s3[1][3]=9; s3[1][4]=3; s3[1][5]=4; s3[1][6]=6; s3[1][7]=10; s3[1][8]=2; s3[1][9]=8; s3[1][10]=5; s3[1][11]=14; s3[1][12]=12; s3[1][13]=11; s3[1][14]=15; s3[1][15]=1;
s3[2][0]=13; s3[2][1]=6; s3[2][2]=4; s3[2][3]=9; s3[2][4]=8; s3[2][5]=15; s3[2][6]=3; s3[2][7]=0; s3[2][8]=11; s3[2][9]=1; s3[2][10]=2; s3[2][11]=12; s3[2][12]=5; s3[2][13]=10; s3[2][14]=14; s3[2][15]=7;
s3[3][0]=1; s3[3][1]=10; s3[3][2]=13; s3[3][3]=0; s3[3][4]=6; s3[3][5]=9; s3[3][6]=8; s3[3][7]=7; s3[3][8]=4; s3[3][9]=15; s3[3][10]=14; s3[3][11]=3; s3[3][12]=11; s3[3][13]=5; s3[3][14]=2; s3[3][15]=12;
s4[0][0]=7; s4[0][1]=13; s4[0][2]=14; s4[0][3]=3; s4[0][4]=0; s4[0][5]=6; s4[0][6]=9; s4[0][7]=10; s4[0][8]=1; s4[0][9]=2; s4[0][10]=8; s4[0][11]=5; s4[0][12]=11; s4[0][13]=12; s4[0][14]=4; s4[0][15]=15;
s4[1][0]=13; s4[1][1]=8; s4[1][2]=11; s4[1][3]=5; s4[1][4]=6; s4[1][5]=15; s4[1][6]=0; s4[1][7]=3; s4[1][8]=4; s4[1][9]=7; s4[1][10]=2; s4[1][11]=12; s4[1][12]=1; s4[1][13]=10; s4[1][14]=14; s4[1][15]=9;
s4[2][0]=10; s4[2][1]=6; s4[2][2]=9; s4[2][3]=0; s4[2][4]=12; s4[2][5]=11; s4[2][6]=7; s4[2][7]=13; s4[2][8]=15; s4[2][9]=1; s4[2][10]=3; s4[2][11]=14; s4[2][12]=5; s4[2][13]=2; s4[2][14]=8; s4[2][15]=4;
s4[3][0]=3; s4[3][1]=15; s4[3][2]=0; s4[3][3]=6; s4[3][4]=10; s4[3][5]=1; s4[3][6]=13; s4[3][7]=8; s4[3][8]=9; s4[3][9]=4; s4[3][10]=5; s4[3][11]=11; s4[3][12]=12; s4[3][13]=7; s4[3][14]=2; s4[3][15]=14;
s5[0][0]=2; s5[0][1]=12; s5[0][2]=4; s5[0][3]=1; s5[0][4]=7; s5[0][5]=10; s5[0][6]=11; s5[0][7]=6; s5[0][8]=8; s5[0][9]=5; s5[0][10]=3; s5[0][11]=15; s5[0][12]=13; s5[0][13]=0; s5[0][14]=14; s5[0][15]=9;
s5[1][0]=14; s5[1][1]=11; s5[1][2]=2; s5[1][3]=12; s5[1][4]=4; s5[1][5]=7; s5[1][6]=13; s5[1][7]=1; s5[1][8]=5; s5[1][9]=0; s5[1][10]=15; s5[1][11]=10; s5[1][12]=3; s5[1][13]=9; s5[1][14]=8; s5[1][15]=6;
s5[2][0]=4; s5[2][1]=2; s5[2][2]=1; s5[2][3]=11; s5[2][4]=10; s5[2][5]=13; s5[2][6]=7; s5[2][7]=8; s5[2][8]=15; s5[2][9]=9; s5[2][10]=12; s5[2][11]=5; s5[2][12]=6; s5[2][13]=3; s5[2][14]=0; s5[2][15]=14;
s5[3][0]=11; s5[3][1]=8; s5[3][2]=12; s5[3][3]=7; s5[3][4]=1; s5[3][5]=14; s5[3][6]=2; s5[3][7]=13; s5[3][8]=6; s5[3][9]=15; s5[3][10]=0; s5[3][11]=9; s5[3][12]=10; s5[3][13]=4; s5[3][14]=5; s5[3][15]=3;
s6[0][0]=12; s6[0][1]=1; s6[0][2]=10; s6[0][3]=15; s6[0][4]=9; s6[0][5]=2; s6[0][6]=6; s6[0][7]=8; s6[0][8]=0; s6[0][9]=13; s6[0][10]=3; s6[0][11]=4; s6[0][12]=14; s6[0][13]=7; s6[0][14]=5; s6[0][15]=11;
s6[1][0]=10; s6[1][1]=15; s6[1][2]=4; s6[1][3]=2; s6[1][4]=7; s6[1][5]=12; s6[1][6]=9; s6[1][7]=5; s6[1][8]=6; s6[1][9]=1; s6[1][10]=13; s6[1][11]=14; s6[1][12]=0; s6[1][13]=11; s6[1][14]=3; s6[1][15]=8;
s6[2][0]=9; s6[2][1]=14; s6[2][2]=15; s6[2][3]=5; s6[2][4]=2; s6[2][5]=8; s6[2][6]=12; s6[2][7]=3; s6[2][8]=7; s6[2][9]=0; s6[2][10]=4; s6[2][11]=10; s6[2][12]=1; s6[2][13]=13; s6[2][14]=11; s6[2][15]=6;
s6[3][0]=4; s6[3][1]=3; s6[3][2]=2; s6[3][3]=12; s6[3][4]=9; s6[3][5]=5; s6[3][6]=15; s6[3][7]=10; s6[3][8]=11; s6[3][9]=14; s6[3][10]=1; s6[3][11]=7; s6[3][12]=6; s6[3][13]=0; s6[3][14]=8; s6[3][15]=13;
s7[0][0]=4; s7[0][1]=11; s7[0][2]=2; s7[0][3]=14; s7[0][4]=15; s7[0][5]=0; s7[0][6]=8; s7[0][7]=13; s7[0][8]=3; s7[0][9]=12; s7[0][10]=9; s7[0][11]=7; s7[0][12]=5; s7[0][13]=10; s7[0][14]=6; s7[0][15]=1;
s7[1][0]=13; s7[1][1]=0; s7[1][2]=11; s7[1][3]=7; s7[1][4]=4; s7[1][5]=9; s7[1][6]=1; s7[1][7]=10; s7[1][8]=14; s7[1][9]=3; s7[1][10]=5; s7[1][11]=12; s7[1][12]=2; s7[1][13]=15; s7[1][14]=8; s7[1][15]=6;
s7[2][0]=1; s7[2][1]=4; s7[2][2]=11; s7[2][3]=13; s7[2][4]=12; s7[2][5]=3; s7[2][6]=7; s7[2][7]=14; s7[2][8]=10; s7[2][9]=15; s7[2][10]=6; s7[2][11]=8; s7[2][12]=0; s7[2][13]=5; s7[2][14]=9; s7[2][15]=2;
s7[3][0]=6; s7[3][1]=11; s7[3][2]=13; s7[3][3]=8; s7[3][4]=1; s7[3][5]=4; s7[3][6]=10; s7[3][7]=7; s7[3][8]=9; s7[3][9]=5; s7[3][10]=0; s7[3][11]=15; s7[3][12]=14; s7[3][13]=2; s7[3][14]=3; s7[3][15]=12;
s8[0][0]=13; s8[0][1]=2; s8[0][2]=8; s8[0][3]=4; s8[0][4]=6; s8[0][5]=15; s8[0][6]=11; s8[0][7]=1; s8[0][8]=10; s8[0][9]=9; s8[0][10]=3; s8[0][11]=14; s8[0][12]=5; s8[0][13]=0; s8[0][14]=12; s8[0][15]=7;
s8[1][0]=1; s8[1][1]=15; s8[1][2]=13; s8[1][3]=8; s8[1][4]=10; s8[1][5]=3; s8[1][6]=7; s8[1][7]=4; s8[1][8]=12; s8[1][9]=5; s8[1][10]=6; s8[1][11]=11; s8[1][12]=0; s8[1][13]=14; s8[1][14]=9; s8[1][15]=2;
s8[2][0]=7; s8[2][1]=11; s8[2][2]=4; s8[2][3]=1; s8[2][4]=9; s8[2][5]=12; s8[2][6]=14; s8[2][7]=2; s8[2][8]=0; s8[2][9]=6; s8[2][10]=10; s8[2][11]=13; s8[2][12]=15; s8[2][13]=3; s8[2][14]=5; s8[2][15]=8;
s8[3][0]=2; s8[3][1]=1; s8[3][2]=14; s8[3][3]=7; s8[3][4]=4; s8[3][5]=10; s8[3][6]=8; s8[3][7]=13; s8[3][8]=15; s8[3][9]=12; s8[3][10]=9; s8[3][11]=10; s8[3][12]=3; s8[3][13]=5; s8[3][14]=6; s8[3][15]=11;
h=b;
s=0 ;
i=60;
///////////////////
//for (q=a;q<a+6;q++)
for (j=0;j<6;j++)
{
}
convertBinDec(q,l,c);
convert (s1[*l][*c],r);
for (s=0;s<4;s++)
{
i++;
}
////////////////////
i=60;
k=0;
///////////////////
for (j=6;j<12;j++)
{
k++;
}
convertBinDec(q,l,c);
convert (s2[*l][*c],r);
for (s=4;s<8;s++)
{
i++;
}
////////////////////
i=60;
k=0;
///////////////////
for (j=12;j<18;j++)
{
k++;
}
convertBinDec(q,l,c);
convert (s3[*l][*c],r);
for (s=8;s<12;s++)
{
i++;
}
////////////////////
i=60;
k=0;
///////////////////
for (j=18;j<24;j++)
{
k++;
}
convertBinDec(q,l,c);
convert (s4[*l][*c],r);
for (s=12;s<16;s++)
{
i++;
}
////////////////////
i=60;
k=0;
///////////////////
for (j=24;j<30;j++)
{
k++;
}
convertBinDec(q,l,c);
convert (s5[*l][*c],r);
for (s=16;s<20;s++)
{
i++;
}
////////////////////
i=60;
k=0;
///////////////////
for (j=30;j<36;j++)
{
k++;
}
convertBinDec(q,l,c);
convert (s6[*l][*c],r);
for (s=20;s<24;s++)
{
i++;
}
////////////////////
i=60;
k=0;
///////////////////
for (j=36;j<42;j++)
{
k++;
}
convertBinDec(q,l,c);
convert (s7[*l][*c],r);
for (s=24;s<28;s++)
{
i++;
}
////////////////////////
i=60;
k=0;
///////////////////
for (j=42;j<48;j++)
{
k++;
}
convertBinDec(q,l,c);
convert (s8[*l][*c],r);
for (s=28;s<32;s++)
{
i++;
}
////////////////////
}
//------------retourne la foncion xor entre deux bits
int xor (int a, int b)
{
if (a==b)
return 0;
else
return 1;
}
//------------------mettre le resultat de la fonction xor entre les deux tables texte et cles dans resultat
void exor (int *texte , int *cles, int *resultat, int n)// tous de n bits
{
int *p,*q,*v,i;
p=(int*)malloc(n*sizeof(int));
q=(int*)malloc(n*sizeof(int));
v=(int*)malloc(n*sizeof(int));
p=texte;
q=cles;
v=resultat;
for (i=0; i<n;i++)
- (v+i)=xor(*(p+i),*(q+i));
}
//-------------fonction ff permet de combiner la partie droite de texte avec le cles divercifier
//etat(1:affiche les iteration, 0:donner le resultat directement)
void ff(int *texte,int *cles,int *resultat,int etat)// texte de 32 bits cles de 48 bits resultat 32 bits
{
int *p,*q,*texte48,*r,*rr;
char *aff_hex,*aff_hex1,*aff_hex2,*aff_hex3;
aff_hex=(char*)malloc(13*sizeof(char));
aff_hex1=(char*)malloc(13*sizeof(char));
aff_hex2=(char*)malloc(13*sizeof(char));
aff_hex3=(char*)malloc(8*sizeof(char));
r=(int*)malloc(48*sizeof(int));
rr=(int*)malloc(32*sizeof(int));
texte48=(int*)malloc(49*sizeof(int));
p=(int*)malloc(48*sizeof(int));
q=(int*)malloc(48*sizeof(int));
expansion(texte,texte48);
exor(texte48,cles,r,48);
s_box(r,rr);
pp(rr,resultat);
if ( etat == 1)
{
printf(" E(A) :");
affiche_tab(texte48,1,48);
convBinHex48(texte48,aff_hex);
printf (" = ");
puts (aff_hex);
printf(" J :");
affiche_tab(cles,1,48);
convBinHex48(cles,aff_hex1);
printf (" = ");
puts (aff_hex1);
printf(" E(A)+J :");
affiche_tab(r,1,48);
convBinHex48(r,aff_hex2);
printf (" = ");
puts (aff_hex2);
printf(" C :");
affiche_tab(rr,1,32);
convBinHex32(rr,aff_hex3);
printf (" = ");
puts (aff_hex3);
printf("\n");
printf ("\n-----------------------------------------------------\n");
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
//---------------fonction globale qui permet de crypte le texte donner en parametre en utilisant le cles
//le resutat est envoyer en tcrypte. mode (DES ou DEA),ronde(nombre de ronde),etat(1:affiche les iteration, 0:donner le resultat directement)
void cryptage(int *texte,int *cles,int *tcrypte, int mode, int ronde,int etat)
{
int mod,*t2,*cles2,i,*aux,*cles1,j,*r,*rr,*bloc,k=0,*gauche,*droite;
char *aff_hex, *aff_hex1,*aff_hex5, *aff_hex11, *aff_hex3, *aff_hex55;
mod=1;
aff_hex=(char*)malloc(8*sizeof(char));
aff_hex1=(char*)malloc(8*sizeof(char));
aff_hex5=(char*)malloc(8*sizeof(char));
aff_hex11=(char*)malloc(8*sizeof(char));
aff_hex3=(char*)malloc(32*sizeof(char));
aff_hex55=(char*)malloc(32*sizeof(char));
t2=(int*)malloc(64*sizeof(int));
bloc=(int*)malloc(64*sizeof(int));
gauche=(int*)malloc(33*sizeof(int));
droite=(int*)malloc(33*sizeof(int));
cles2=(int*)malloc(48*sizeof(int));
aux=(int*)malloc(49*sizeof(int));
rr=(int*)malloc(49*sizeof(int));
r=(int*)malloc(32*sizeof(int));
cles1=(int*)malloc(48*16*sizeof(int));
generation(cles,cles1,ronde,etat); //cles1 est de dimension 16*48
if (mode == 1)
{
pi(texte,t2);
}
else
{
for (j=0;j<64;j++)
}
division(t2,gauche,droite,32);
if (etat == 1)
{
printf ("\n-----------------------------------------------------\n");
printf ("L0 :");
affiche_tab(gauche,1,32);
convBinHex32(gauche,aff_hex3);
printf (" = ");
puts (aff_hex3);
printf ("\n");
printf ("R0 :");
affiche_tab(droite,1,32);
convBinHex32(droite,aff_hex55);
printf (" = ");
puts (aff_hex55);
printf("\n");
}
for(i=0;i<ronde;i++)
{
for(j=0;j<32;j++)
for(j=0;j<48;j++)
- (cles2+j)=*(cles1+j+i*48);
ff(droite,cles2,r,etat);
exor(r,gauche,rr,32);
for(j=0;j<32;j++)
{
- (droite+j)=*(rr+j);
- (gauche+j)=*(aux+j);
}
if (etat == 1)
{
printf ("L%d :",i+1);
affiche_tab(gauche,1,32);
convBinHex32(gauche,aff_hex3);
printf (" = ");
puts (aff_hex3);
printf ("R%d :",i+1);
affiche_tab(droite,1,32);
convBinHex32(droite,aff_hex55);
printf (" = ");
puts (aff_hex55);
printf("\n");
}
}
k=0;
for (j=0;j<64;j++)
{
if (j<32)
else
{
k++;
} }
if (mode == 1)
{
pf(bloc,tcrypte);
}
else
{
for (j=0;j<64;j++)
}
printf("\n \n texte cryptee : \n");
////////////////////////////////////////////////////////////////
}
void menu()
{
//LE BOUTON NOUVEAU EST SELECTIONNE PAR DEFAULT.
textcolor(15);
printf("ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿\n");
printf("³ ³\n");
printf("³ Bien venue sur le progamme ³\n");
printf("³ ³\n");
printf("³ DES ³\n");
printf("³ ³\n");
printf("³ (DATA ENCRYPTION STANDARD) ³\n");
printf("³ ³\n");
printf("ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ\n");
//LEGENDE
printf("\n\n\n\n\nChoisissez ce que vous voulez faire.\n\n");
textbackground(9);
cprintf("\n\n\n\r h : Aide \n");
printf ("\n");
cprintf("\r k : Cles \n");
printf ("\n");
cprintf("\r t : Texte \n");
printf ("\n");
cprintf("\r r : Nombre de rondes \n");
printf ("\n");
cprintf("\r m : Mode de chiffrement (DES = 1, DEA = 0)\n");
printf ("\n");
cprintf("\r a : Affiche detaille \n");
printf ("\n");
cprintf("\r v : Information Supplementaire \n");
printf ("\n");
cprintf("\r b : Retour au Menu Principale \n");
printf ("\n");
cprintf("\r q : Quitter \n\n\n\n\n");
//SELECTION DES CHOIX.
}
//------------retourne le resultat de recherche du caractere f dans le table t declare comme parametre globale
int recherche(char f){
int i,r=0;
for(i=0;i<16;i++)
if (t[i]==f)
r=1;
return r;
}
//------------permet de convertir un entier decimale en binaire
void convert1 (int d,int *b)
{
int i,j=3, *p,*q;
int div,div2;
for(p=b;p<b+4;p++)
div=d;
do
{
div2 = div / 2;
j--;
div = div2;
} while (j >= 0 && div2 != 0);
}
//-----------permet de transformer un tableau en hexadecimale en un tableau en binaire
int transforme (char *tab,int *tab1)
{
int *b,*q,*u;
char *p;
q=(int*)malloc(64*sizeof(int));
p=(char*)malloc(16*sizeof(char));
b=(int*)malloc(4*sizeof(int));
int r=1,a,z;
q=tab1;
p=tab;
for(p=tab;p<tab+16;p++)
{
if (recherche(*p)==0)
{
p=tab+16;r=0;
}
a=(int)*p-48;
if (a>=17)
a=a-7;
convert1(a,b);
for(z=0;z<4;z++)
{
q++;
}
}
return (r);
}
//---------fonction utiliser dans l'animation
void ralentir(void) {
int i0;
for (i0 = 0; i0 < 1500; i0++){
gotoxy(1,1);
cputs("");
}
return;
}
//----------Animation
char *bye[] = {
"ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿",
"³ ÛÛÛÛÛ Û Û ÛÛÛÛÛÛ ³",
"³ Û Û Û Û Û ³",
"³ Û Û Û Û Û ³",
"³ Û Û Û Û Û ³",
"³ ÛÛÛÛÛ Û ÛÛÛÛÛ ³",
"³ Û Û Û Û ³",
"³ Û Û Û Û ³",
"³ Û Û Û Û ³",
"³ ÛÛÛÛÛ Û ÛÛÛÛÛÛ ³",
"ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´",
"³ ESC FIN DU PROGRAMME....................³",
"ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ"
};
//----------Animation
void effet_aller_retour(int col_depart,int col_fin, int ligne_depart) {
int i1, i2;
int max_menu = sizeof(bye) / sizeof(bye[0]);
// faire sortir le bye vers la droite
for (i2 = 0; i2 <= strlen(bye[0]) ; ++i2) {
for (i1 = 0; i1 < max_menu ; ++i1) {
gotoxy(col_depart,ligne_depart + i1 );
cprintf( "%1s", strlen(bye[i1])+ bye[i1] -i2);
}
ralentir(); // ralentir l'effet
}
ralentir(); // temps d'attente
// deplacer le bye vers la gauche
for (i2 = 0; col_depart-i2 >= col_fin ; ++i2) {
for (i1 = 0; i1 < max_menu ; ++i1) {
gotoxy(col_depart-i2,ligne_depart + i1 );
cprintf( "%1s ", bye[i1] );
}
ralentir(); // ralentir l'effet
}
ralentir(); // temps d'attente
// faire repartir le bye
for (i2 = 0; i2 <= strlen(bye[0]) ; ++i2) {
for (i1 = 0; i1 < max_menu ; ++i1) {
gotoxy(col_fin ,ligne_depart + i1 );
cprintf("%s ",bye[i1] + i2);
}
ralentir(); // ralentir l'effet
}
return ;
}
//----------Animation
char *DES[] = {
".......................................",
".ÛÛÛÛÛÛÛ........ÛÛÛÛÛÛÛÛÛ.....ÛÛÛÛÛÛÛÛ.",
".Û......Û.......Û.............Û........",
".Û.......Û......Û.............Û........",
".Û.......Û......Û.............Û........",
".Û........Û.....ÛÛÛÛÛÛÛ.......ÛÛÛÛÛÛÛÛ.",
".Û.......Û......Û....................Û.",
".Û.......Û......Û....................Û.",
".Û......Û.......Û....................Û.",
".ÛÛÛÛÛÛÛ........ÛÛÛÛÛÛÛÛÛ.....ÛÛÛÛÛÛÛÛ.",
"......................................."
};
//----------Animation
void effet2_haut_bas(int col, int ligne_depart,int ligne_fin) {
int i1, i2;
textbackground(0);
// nbre d'element dans le des
int max_menu = sizeof(DES) / sizeof(DES[0]);
for (i1 = 0; i1 < max_menu ; ++i1) {
for (i2 = 0; i2 < ligne_fin - i1 ; ++i2) {
gotoxy(col,ligne_depart + i2);
cprintf("%s",DES[ (max_menu -1) -i1]);
ralentir(); // ralentir l'effet
gotoxy(col,ligne_depart-1 + i2);
cprintf("%48c",'\0'); // ligne vide
}
}
return ;
}
void main()
{
//DEBUT DU PROGRAMME.
int chargement;
char sel, *cle_hex,*def_cle,*txt_hex,*def_txt,*aff_hex;
int i,rech,rech1, *p,*q,etat1=0,mode1=1,round =16,*b, *t,*tt,*b1,*a , *gauche, *droite,*cles,*tcry;
int *ronde,*etat,*mode,entrer ;
b=(int*)malloc(8*8*sizeof(int));//cle binaire
cle_hex=(char*)malloc(16*sizeof(char));//cle hexadecimal
def_cle=(char*)malloc(16*sizeof(char));//cle hexadecimal par defaut
txt_hex=(char*)malloc(16*sizeof(char));//Texte hexadecimal
def_txt=(char*)malloc(16*sizeof(char));//Texte hexadecimal par defaut
aff_hex=(char*)malloc(16*sizeof(char));//resultat de convertion hexadecimal
b1=(int*)malloc(8*8*sizeof(int));//texte
tcry=(int*)malloc(8*8*sizeof(int));
mode=(int*)malloc(1*sizeof(int));
etat=(int*)malloc(1*sizeof(int));
ronde =(int*)malloc(1*sizeof(int));
def_cle ="133457799BBCDFF1";
def_txt ="0123456789ABCDEF";
- ronde =16;
- etat=1;
- mode=1;
///////////////////////////////////////////Menu/////////////////////
char nom [200]={'R','e','a','l','i','s','e',' ','p','a','r',' ',':','\n','\t','\t','\t','\t','\t','-','A','b','b','a','s','s','i',' ','I','s','s','a','m','\n','\n','\t','\t','\t','\t','\t','-','M','a','b','r','o','u','k',' ','K','h','a','l','e','d','\n','\n','\t','\t','\t','\t','\t','-','O','m','r','a','n','i',' ','S','a','d','e','k','\n'};
int g;
//BARRE DE CHARGEMENT.
printf ("\n");
textcolor(15);
cprintf("Chargement en cours :\n\n\r");
textbackground(11);
for(chargement = 0; chargement < 80; chargement++)
{
cprintf(" "); Sleep(50);
}
entrer=0;
do{
// colonne = 15 ligne_depart = 1 ligne_fin = 24
effet2_haut_bas(18,8, 15); // decouper_haut_bas
if (entrer==0)
{entrer=1;
printf ("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n");
for(g= 0;g < 80;g++)
{
printf ("%c",nom[g]);Sleep(50);
}
printf ("\n\n\n\n");
textcolor(11);
textbackground(0);
cprintf("SVP Taper une touche pour passer........\r");
}}
while(!kbhit());
getch();
system("cls");
menu();
rech =transforme (def_cle,b);
rech1 =transforme (def_txt,b1);
do
{
sel = getch ();
switch(sel)
{
//AIDE.
case 'h':
system("cls");
textbackground(0);
system("cls");
printf ("l'objectif de ce programme est la realisation d'une implementation du \n\n cryptosysteme a cles secrtet DES en C\n\n");
printf("Ce projet est realiser par :Abbassi Issam, Mabrouk Khaled,Omrani Sadek \n\n 1er annee cycle de formation d'ingenieurs ");
printf("dans le cadre de travaux pratiques de \ncryptographie \n\n");
printf("Date de creation 09/12/2006 ");
printf("\n\n\n Plusieurs fonctions disponibles dans ce programme:");
cprintf("\n\n\n\r h : Aide ");
printf ("\n");
cprintf("\r k : Cles ");
printf ("\n");
cprintf("\r t : Texte ");
printf ("\n");
cprintf("\r r : Nombre de rondes ");
printf ("\n");
cprintf("\r m : Mode de chiffrement (DES = 1, DEA = 0)");
printf ("\n");
cprintf("\r a : Affiche detaille ");
printf ("\n");
cprintf("\r v : Information Supplementaire ");
printf ("\n");
cprintf("\r b : Retour au Menu Principale ");
cprintf("\r q : Quitter \n\n\n");
textcolor(4);
textbackground(0);
cprintf("\rREMARQUES \n\n\n\rSi l'utilisateur utilse la fonction de chiffrement sans modifier \n\n \rles parametres de cryptage (cles, texte, nb de ronde.... )\n\n");
cprintf("\rle systeme chiffre avec les valeurs par defaut: \n\n");
cprintf("\rcles = 13345779 9BBCDFF1 \n\n");
cprintf("\rtexte = 0123456789ABCDEF\n\n");
cprintf("\rNombre de ronde = 16 ");
break;
//CLES.
case 'k': system("cls");
textbackground(0);
system("cls");
printf("\n Donner votre cles en Hexadicimal : \n\n");
scanf("%s",cle_hex);
rech=transforme (cle_hex,b);
if (rech ==0)
{
printf ("\n Desole, Votre cles est non valide SVP verifier votre cles... \n\n Le systeme va choisir le cles par defaut... \n");
rech =transforme (def_cle,b);
getch ();
system("cls");
textbackground(0);
system("cls");
menu ();
}
else
{
printf ("\n Cles valide.... \n");
getch ();
system("cls");
textbackground(0);
system("cls");
menu ();
}
break;
//TEXTE.
case 't':
system("cls");
textbackground(0);
system("cls");
printf("\n Donner votre Texte en Hexadicimal : \n\n");
scanf("%s",txt_hex);
rech1=transforme (txt_hex,b1);
if (rech1 ==0)
{
printf ("\n Desole, Votre Texte est non valide SVP verifier votre Texte... \n\n Le systeme va choisir le Texte par defaut... \n");
rech =transforme (def_txt,b1);
getch ();
system("cls");
textbackground(0);
system("cls");
menu ();
}
else
{
printf ("\n Texte valide.... \n");
getch ();
system("cls");
textbackground(0);
system("cls");
menu ();
}
break;
//RONDE.
case 'r': do
{
textbackground(0);
system("cls");
printf("\nDonner le nombre de rondes (compris entre 1 et 16:) \n\n");
scanf("%d",ronde);
}
while ((*ronde <1) || (*ronde >16));
system("cls");
menu();
break;
//MODE DE CHIFFREMENT.
case 'm':
do
{
textbackground(0);
system("cls");
printf ("\n\n Donner SVP le mode du cryptage ( DES = 1 ; DEA = 0 ):\n");
printf("\t");
scanf (" %d",mode);
}
while ((*mode !=1) && (*mode !=0));
if ( *mode == 1)
printf("\n Vous avez choisi le mode DES :\n\n\n");
else
printf("\n Vous avez choisi le mode DEA :\n\n\n");
round =*ronde;
etat1 =*etat;
mode1 =*mode;
printf("\n Votre texte en claire est :\n\n");
printf("\n EN BINAIRE :\n");
affiche_tab(b1,1,64);
printf("\n EN HEXADECIMALE :\n");
convBinHex64(b1,aff_hex);
puts (aff_hex);
getch ();
cryptage(b1,b,tcry,mode1,round,etat1);
printf("\n");
printf("\n EN BINAIRE :\n");
affiche_tab(tcry,1,64);
printf("\n EN HEXADECIMALE :\n");
convBinHex64(tcry,aff_hex);
puts (aff_hex);
break;
//INFORMATION SUPPLEMENTAIRE.
case 'v':
system("cls");
textbackground(0);
system("cls");
printf("\n\n\t\tPresentation exhaustive du systeme DES\n\n\n\n");
printf("Ce systeme de chiffrement a cles privee est le plus connu. Un cryptosysteme\n\npermet a deux protagonistes");
printf("de communiquer ensemble sur un canal peu sur lorsqu'\n\nun opposant souhaite espionner cette conversation. Evidemment");
printf("cet opposant ne\n\ndoit pas comprendre les informations qui sont echangees. \n\n\n");
printf("Pour un cryptosysteme on définie les expressions suivantes: \n\n\n");
textcolor(13);
textbackground(0);
cprintf(" \r- Texte clair :");
printf(" Information que l'emetteur souhaite transmettre au recepteur\n\n\t\t(Ex : texte en francais, donnee numerique etc...).\n\n\n");
cprintf(" \r- Chiffrement :");
printf(" Processus de transformation d?un message M de telle maniere\n\n\t\ta le rendre incomprehensible. Ce processus est base sur une\n\n\t\tfonction de chiffrement E et permet de ");
printf("generer ainsi un message\n\n\t\tchiffre C = E(M).\n\n\n");
cprintf(" \r- Dechiffrement: ");
printf("Processus de reconstruction du message clair a partir du\n\n\t\tmessage chiffre, base sur une fonction de dechiffrement D.\n");
break;
//RETOUR AU MENU PRINCIPALE.
case 'b':
system("cls");
textbackground(0);
system("cls");
menu();
break;
//AFFICHE DETAILLES.
case 'a':
do
{
textbackground(0);
system("cls");
printf ("\n\n vous voulez vraiment afficher les detaille du cryptage ( OUI = 1 ; NON = 0 ):\n\n");
printf("\t");
scanf (" %d",etat);
}
while ((*etat !=1) && (*etat !=0));
system("cls");
menu ();
break;
//QUITTER.
case 'q':
textbackground(0);
system("cls");
system("cls");
_setcursortype(_NOCURSOR);
textcolor(LIGHTGREEN);
gotoxy(30, 3);
cprintf("TAPER ESC pour sortir ");
do {
textcolor(LIGHTCYAN);
// colonne depart = 37 colonne fin = 15 ligne depart = 4
effet_aller_retour(37,15, 10);
} while (!kbhit());
exit(0);
break;
}
//0 = QUITTER.
}
while (sel != 'q');
free(tcry);
getch();
}
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.