#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 gnrer 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 rsultat 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 dfinie 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 dun 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();
}