CRYPTAGE AVEC DES

#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++)
*q=0;

div=d;

do
{
div2 = div / 2;
*(b+j) =(div - div2*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++)
{
*p=*a;
a++;
}
a= b+n;
for (q=d; q<d+n; q++)
{
*q=*a;
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++)
{
*p=*(p+1);
}
*(a+27)= aux;
if ((r!= 1)&&(r!= 2)&&(r!= 9)&&(r!= 16))
{
p= a;
aux = *p;
for ( p=a ;p<a+27 ; p++)
{
*p=*(p+1);
}
*(a+27)= aux;
}
}



//////////////////////////////////////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=*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++)
 {
 *(q+j)=*(a+j);
 }
 convertBinDec(q,l,c);
 convert (s1[*l][*c],r);


for (s=0;s<4;s++)
{
 *(h+s)=*(r+i);
 i++;
}

////////////////////

i=60;
k=0;

///////////////////
  for (j=6;j<12;j++)
 {
*(q+k)=*(a+j);
k++;
 }
 convertBinDec(q,l,c);
 convert (s2[*l][*c],r);



for (s=4;s<8;s++)
{
 *(h+s)=*(r+i);
 i++;
}

////////////////////
i=60;
 k=0;
///////////////////
  for (j=12;j<18;j++)
 {
*(q+k)=*(a+j);
k++;
 }
 convertBinDec(q,l,c);
 convert (s3[*l][*c],r);


for (s=8;s<12;s++)
{
 *(h+s)=*(r+i);
 i++;
}

////////////////////
i=60;
 k=0;
///////////////////
  for (j=18;j<24;j++)
 {
*(q+k)=*(a+j);
k++;
 }
  convertBinDec(q,l,c);
 convert (s4[*l][*c],r);
for (s=12;s<16;s++)
{
 *(h+s)=*(r+i);
 i++;
}


////////////////////
i=60;
 k=0;
///////////////////
  for (j=24;j<30;j++)
 {
*(q+k)=*(a+j);
k++;
 }
  convertBinDec(q,l,c);
 convert (s5[*l][*c],r);
for (s=16;s<20;s++)
{
 *(h+s)=*(r+i);
 i++;
}

////////////////////
i=60;
 k=0;
///////////////////
  for (j=30;j<36;j++)
 {
*(q+k)=*(a+j);
k++;
 }
  convertBinDec(q,l,c);
 convert (s6[*l][*c],r);
for (s=20;s<24;s++)
{
 *(h+s)=*(r+i);
 i++;
}

////////////////////
i=60;
 k=0;
///////////////////
  for (j=36;j<42;j++)
 {
*(q+k)=*(a+j);
k++;
 }
  convertBinDec(q,l,c);
 convert (s7[*l][*c],r);
for (s=24;s<28;s++)
{
 *(h+s)=*(r+i);
 i++;
}
////////////////////////
i=60;
 k=0;
///////////////////
  for (j=42;j<48;j++)
 {
*(q+k)=*(a+j);
k++;
 }
  convertBinDec(q,l,c);
 convert (s8[*l][*c],r);
for (s=28;s<32;s++)
{
 *(h+s)=*(r+i);
 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++)
 *(t2+j)=*(texte+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++)
*(aux+j)=*(droite+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)
 *(bloc+j)=*(droite+j);
 else
 {
 *(bloc+j)=*(gauche+k);
 k++;
} }

if (mode == 1)
{
pf(bloc,tcrypte);
}
else
{
for (j=0;j<64;j++)
 *(tcrypte+j)=*(bloc+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++)
*p=0;

div=d;

do
{
div2 = div / 2;
*(b+j) =(div - div2*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=*(b+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();
}

09 février 2007 12:57:19 :

ajout de la source

21 mars 2007 13:33:57 :

le compilateur utilisé