Source Code DES

#include <stdio.h>
main()
{
int x,y,z,round,bin[64],binkey[64],ip[64],kp[64],left[28],right[28];
int kosong,kosong1,kosong2,empty,empty1,empty2,gabung[56],kiri[32],kanan[32];
int cp[48],key1[48],key2[48],key3[48],key4[48],key5[48],key6[48],key7[48];
int key8[48],key9[48],key10[48],key11[48],key12[48],key13[48],key14[48],key15[48],key16[48];
int a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,ep[48],counter,xor[48];
int sementara[8],binsbox[32],pbox[32],rikson[32],gultom[32],ga[64],fp[64],cipher[64];
char plain[8],key[8];

int sbox1[4][16]={
14,4,13,1,2,15,11,8,3,10,6,12,5,9,0,7,
0,15,7,4,14,2,13,1,10,6,12,11,9,5,3,8,
4,1,14,8,13,6,2,11,15,12,9,7,3,10,5,0,
15,12,8,2,4,9,1,7,5,11,3,14,10,0,6,13};

int sbox2[4][16]={
15,1,8,14,6,11,3,4,9,7,2,13,12,0,5,10,
3,13,4,7,15,2,8,14,12,0,1,10,6,9,11,5,
0,14,7,11,10,4,13,1,5,8,12,6,9,3,2,15,
13,8,10,1,3,15,4,2,11,6,7,12,0,5,14,9};

int sbox3[4][16]={
10,0,9,14,6,3,15,5,1,13,12,7,11,4,2,8,
13,7,0,9,3,4,6,10,2,8,5,14,12,11,15,1,
13,6,4,9,8,15,3,0,11,1,2,12,5,10,14,7,
1,10,13,0,6,9,8,7,4,15,14,3,11,5,2,12};

int sbox4[4][16]={
7,13,14,3,0,6,9,10,1,2,8,5,11,12,4,15,
13,8,11,5,6,15,0,3,4,7,2,12,1,10,14,9,
10,6,9,0,12,11,7,13,15,1,3,14,5,2,8,4,
3,15,0,6,10,1,13,8,9,4,5,11,12,7,2,14};

int sbox5[4][16]={
2,12,4,1,7,10,11,6,8,5,3,15,13,0,14,9,
14,11,2,12,4,7,13,1,5,0,15,10,3,9,8,16,
4,2,1,11,10,13,7,8,15,9,12,5,6,3,0,14,
11,8,12,7,1,14,2,13,6,15,0,9,10,4,5,3};

int sbox6[4][16]={
12,1,10,15,9,2,6,8,0,13,3,4,14,7,5,11,
10,15,4,2,7,12,9,5,6,1,13,14,0,11,3,8,
9,14,15,5,2,8,12,3,7,0,4,10,1,13,11,6,
4,3,2,12,9,5,15,10,11,14,1,7,6,0,8,13};

int sbox7[4][16]={
4,11,2,14,15,0,8,13,3,12,9,7,5,10.6,1,
13,0,11,7,4,9,1,10,14,3,5,12,2,15,8,6,
1,4,11,13,12,3,7,14,10,15,6,8,0,5,9,2,
6,11,13,8,1,4,10,7,9,5,0,15,14,2,3,12};

int sbox8[4][16]={
13,2,8,4,6,15,11,1,10,9,3,14,5,0,12,7,
1,15,13,8,10,3,7,4,12,5,6,11,0,14,9,2,
7,11,4,1,9,12,14,2,0,6,10,13,15,3,5,8,
2,1,14,7,4,10,8,13,15,12,9,0,3,5,6,11};

clrscr();
for(x=0;x<=5;x++){
sleep(1);
printf(“\7″);
gotoxy(20,10);printf(“  =============================\n”);
gotoxy(20,11);printf(“||                             ||\n”);
gotoxy(20,12);printf(“||        NESYA STEFANI        ||\n”);
gotoxy(20,13);printf(“||       PROGRAM ENKRIPSI      ||\n”);
gotoxy(20,14);printf(“||             DES             ||\n”);
gotoxy(20,15);printf(“||                             ||\n”);
gotoxy(20,16);printf(“  =============================\n”);
sleep(1);
clrscr();
}

/* INPUT PLAINTEXT */
printf(“Masukkan Plainteks:\n”);
for(x=0;x<=7;x++) {
plain[x]=getch();
putchar(plain[x]);
}
plain[8]=NULL;
clrscr();
for(x=0;x<=7;x++)
printf(” %d “,plain[x]);
sleep(1);
clrscr();

bin[0] =(plain[0]>>7)&1;    bin[8] =(plain[1]>>7)&1;
bin[1] =(plain[0]>>6)&1;    bin[9] =(plain[1]>>6)&1;
bin[2] =(plain[0]>>5)&1;    bin[10]=(plain[1]>>5)&1;
bin[3] =(plain[0]>>4)&1;    bin[11]=(plain[1]>>4)&1;
bin[4] =(plain[0]>>3)&1;    bin[12]=(plain[1]>>3)&1;
bin[5] =(plain[0]>>2)&1;    bin[13]=(plain[1]>>2)&1;
bin[6] =(plain[0]>>1)&1;    bin[14]=(plain[1]>>1)&1;
bin[7] = plain[0]&1;        bin[15]= plain[1]&1;

bin[16]=(plain[2]>>7)&1;    bin[24]=(plain[3]>>7)&1;
bin[17]=(plain[2]>>6)&1;    bin[25]=(plain[3]>>6)&1;
bin[18]=(plain[2]>>5)&1;    bin[26]=(plain[3]>>5)&1;
bin[19]=(plain[2]>>4)&1;    bin[27]=(plain[3]>>4)&1;
bin[20]=(plain[2]>>3)&1;    bin[28]=(plain[3]>>3)&1;
bin[21]=(plain[2]>>2)&1;    bin[29]=(plain[3]>>2)&1;
bin[22]=(plain[2]>>1)&1;    bin[30]=(plain[3]>>1)&1;
bin[23]= plain[2]&1;        bin[31]= plain[3]&1;

bin[32]=(plain[4]>>7)&1;    bin[40]=(plain[5]>>7)&1;
bin[33]=(plain[4]>>6)&1;    bin[41]=(plain[5]>>6)&1;
bin[34]=(plain[4]>>5)&1;    bin[42]=(plain[5]>>5)&1;
bin[35]=(plain[4]>>4)&1;    bin[43]=(plain[5]>>4)&1;
bin[36]=(plain[4]>>3)&1;    bin[44]=(plain[5]>>3)&1;
bin[37]=(plain[4]>>2)&1;    bin[45]=(plain[5]>>2)&1;
bin[38]=(plain[4]>>1)&1;    bin[46]=(plain[5]>>1)&1;
bin[39]= plain[4]&1;        bin[47]= plain[5]&1;

bin[48]=(plain[6]>>7)&1;    bin[56]=(plain[7]>>7)&1;
bin[49]=(plain[6]>>6)&1;    bin[57]=(plain[7]>>6)&1;
bin[50]=(plain[6]>>5)&1;    bin[58]=(plain[7]>>5)&1;
bin[51]=(plain[6]>>4)&1;    bin[59]=(plain[7]>>4)&1;
bin[52]=(plain[6]>>3)&1;    bin[60]=(plain[7]>>3)&1;
bin[53]=(plain[6]>>2)&1;    bin[61]=(plain[7]>>2)&1;
bin[54]=(plain[6]>>1)&1;    bin[62]=(plain[7]>>1)&1;
bin[55]= plain[6]&1;        bin[63]= plain[7]&1;

printf(“NILAI BINARI PLAINTEKS YANG ANDA MASUKKAN ADALAH :\n”);
for(x=0;x<=63;x++)
printf(“%d”,bin[x]);
sleep(1);
clrscr();

ip[0]=bin[57];    ip[8] =bin[59];    ip[16]=bin[61];    ip[24]=bin[63];
ip[1]=bin[49];    ip[9] =bin[51];    ip[17]=bin[53];    ip[25]=bin[55];
ip[2]=bin[41];    ip[10]=bin[43];    ip[18]=bin[45];    ip[26]=bin[47];
ip[3]=bin[33];    ip[11]=bin[35];    ip[19]=bin[37];    ip[27]=bin[39];
ip[4]=bin[25];    ip[12]=bin[27];    ip[20]=bin[29];    ip[28]=bin[31];
ip[5]=bin[17];    ip[13]=bin[19];    ip[21]=bin[21];    ip[29]=bin[23];
ip[6]=bin[9];    ip[14]=bin[11];    ip[22]=bin[13];    ip[30]=bin[15];
ip[7]=bin[1];    ip[15]=bin[3];    ip[23]=bin[5];    ip[31]=bin[7];

ip[32]=bin[56];    ip[40]=bin[58];    ip[48]=bin[60];    ip[56]=bin[62];
ip[33]=bin[48];    ip[41]=bin[50];    ip[49]=bin[52];    ip[57]=bin[54];
ip[34]=bin[40];    ip[42]=bin[42];    ip[50]=bin[44];    ip[58]=bin[46];
ip[35]=bin[32];    ip[43]=bin[34];    ip[51]=bin[36];    ip[59]=bin[38];
ip[36]=bin[24];    ip[44]=bin[26];    ip[52]=bin[28];    ip[60]=bin[30];
ip[37]=bin[16];    ip[45]=bin[18];    ip[53]=bin[20];    ip[61]=bin[22];
ip[38]=bin[8];    ip[46]=bin[10];    ip[54]=bin[12];    ip[62]=bin[14];
ip[39]=bin[0];    ip[47]=bin[2];    ip[55]=bin[4];    ip[63]=bin[6];

printf(“IP :\n”);
for(x=0;x<=63;x++)
printf(“%d”,ip[x]);
sleep(1);
clrscr();

/* INPUT KEY */
printf(“masukkan kunci Anda:\n”);
for(x=0;x<=7;x++) {
key[x]=getch();
putchar(key[x]);
}
key[8]=NULL;
clrscr();
printf(“KEY :\n”);
for(x=0;x<=7;x++)
printf(“%d”,key[x]);
sleep(1);
clrscr();

binkey[0] =(key[0]>>7)&1;    binkey[32]=(key[4]>>6)&1;
binkey[1] =(key[0]>>5)&1;    binkey[33]=(key[4]>>4)&1;
binkey[2] =(key[0]>>3)&1;    binkey[34]=(key[4]>>2)&1;
binkey[3] =(key[0]>>7)&1;    binkey[35]=(key[4]>>6)&1;
binkey[4] =(key[0]>>5)&1;    binkey[36]=(key[4]>>4)&1;
binkey[5] =(key[0]>>3)&1;    binkey[37]=(key[4]>>2)&1;
binkey[6] =(key[0]>>1)&1;    binkey[38]=(key[4]>>2)&1;
binkey[7] = key[0]&1;        binkey[39]= key[4]&1;

binkey[8] =(key[1]>>7)&1;    binkey[40]=(key[5]>>6)&1;
binkey[9] =(key[1]>>5)&1;    binkey[41]=(key[5]>>4)&1;
binkey[10]=(key[1]>>3)&1;    binkey[42]=(key[5]>>2)&1;
binkey[11]=(key[1]>>7)&1;    binkey[43]=(key[5]>>6)&1;
binkey[12]=(key[1]>>5)&1;    binkey[44]=(key[5]>>4)&1;
binkey[13]=(key[1]>>3)&1;    binkey[45]=(key[5]>>2)&1;
binkey[14]=(key[1]>>1)&1;    binkey[46]=(key[5]>>1)&1;
binkey[15]= key[1]&1;        binkey[47]= key[5]&1;

binkey[16]=(key[2]>>7)&1;    binkey[48]=(key[6]>>6)&1;
binkey[17]=(key[2]>>5)&1;    binkey[49]=(key[6]>>4)&1;
binkey[18]=(key[2]>>3)&1;    binkey[50]=(key[6]>>2)&1;
binkey[19]=(key[2]>>1)&1;    binkey[51]=(key[6]>>7)&1;
binkey[20]=(key[2]>>5)&1;    binkey[52]=(key[6]>>4)&1;
binkey[21]=(key[2]>>3)&1;    binkey[53]=(key[6]>>2)&1;
binkey[22]=(key[2]>>1)&1;    binkey[54]=(key[6]>>6)&1;
binkey[23]= key[2]&1;        binkey[55]= key[6]&1;

binkey[24]=(key[3]>>7)&1;    binkey[56]=(key[7]>>6)&1;
binkey[25]=(key[3]>>5)&1;    binkey[57]=(key[7]>>4)&1;
binkey[26]=(key[3]>>3)&1;    binkey[58]=(key[7]>>2)&1;
binkey[27]=(key[3]>>1)&1;    binkey[59]=(key[7]>>1)&1;
binkey[28]=(key[3]>>7)&1;    binkey[60]=(key[7]>>6)&1;
binkey[29]=(key[3]>>5)&1;    binkey[61]=(key[7]>>4)&1;
binkey[30]=(key[3]>>3)&1;    binkey[62]=(key[7]>>2)&1;
binkey[31]= key[3]&1;        binkey[63]= key[7]&1;

printf(“BINARY KEY :\n”);
for(x=0;x<=63;x++)
printf(“%d”,binkey[x]);
sleep(1);
clrscr();

kp[0] =binkey[56];    kp[14]=binkey[9];    kp[28]=binkey[62];    kp[42]=binkey[13];
kp[1] =binkey[48];    kp[15]=binkey[1];    kp[29]=binkey[54];    kp[43]=binkey[5];
kp[2] =binkey[40];    kp[16]=binkey[58];    kp[30]=binkey[46];    kp[44]=binkey[60];
kp[3] =binkey[33];    kp[17]=binkey[50];    kp[31]=binkey[38];    kp[45]=binkey[52];
kp[4] =binkey[25];    kp[18]=binkey[42];    kp[32]=binkey[30];    kp[46]=binkey[44];
kp[5] =binkey[16];    kp[19]=binkey[34];    kp[33]=binkey[22];    kp[47]=binkey[36];
kp[6] =binkey[8];    kp[20]=binkey[26];    kp[34]=binkey[14];    kp[48]=binkey[28];
kp[7] =binkey[0];    kp[21]=binkey[18];    kp[35]=binkey[6];    kp[49]=binkey[20];
kp[8] =binkey[57];    kp[22]=binkey[10];    kp[36]=binkey[61];    kp[50]=binkey[12];
kp[9] =binkey[49];    kp[23]=binkey[2];    kp[37]=binkey[53];    kp[51]=binkey[4];
kp[10]=binkey[41];    kp[24]=binkey[59];    kp[38]=binkey[45];    kp[52]=binkey[27];
kp[11]=binkey[33];    kp[25]=binkey[51];    kp[39]=binkey[37];    kp[53]=binkey[19];
kp[12]=binkey[25];    kp[26]=binkey[43];    kp[40]=binkey[29];    kp[54]=binkey[11];
kp[13]=binkey[17];    kp[27]=binkey[35];    kp[41]=binkey[21];    kp[55]=binkey[3];

printf(“KP :\n”);
for(x=0;x<=55;x++)
printf(“%d”,kp[x]);
sleep(1);
clrscr();

for(x=0;x<=27;x++){
left[x] =kp[x];
right[x]=kp[x+28];
}

printf(“BAGI DUA\n”);
printf(“KIRI   : “);
for(x=0;x<=27;x++)
printf(“%d”,left[x]);
printf(“\nKANAN : “);
for(x=0;x<=27;x++)
printf(“%d”,right[x]);
sleep(1);
clrscr();
round=1;
looping:
printf(“ROUND : %d”,round);
sleep(2);
clrscr();
if(round==1||round==2||round==9||round==16){
kosong=left[0];
empty=right[0];
for(x=0;x<=26;x++){
left[x]=left[x+1];
right[x]=right[x+1];
}
left[27]=kosong;
right[27]=empty;
}

else {
kosong1=left[0];
kosong2=left[1];
empty1=right[0];
empty2=right[1];
for(x=0;x<=25;x++){
left[x]=left[x+2];
right[x]=right[x+2];
}
left[26]=kosong1;
left[27]=kosong2;
right[26]=empty1;
right[27]=empty2;
}
printf(“SHIFT\n”);
printf(“KIRI SEKARANG :”);
for(x=0;x<=27;x++)
printf(“%d”,left[x]);
printf(“\nKANAN SEKARANG :”);
for(x=0;x<=27;x++)
printf(“%d”,right[x]);
sleep(1);
clrscr();

for(x=0;x<=27;x++){
gabung[x]=left[x];
gabung[x+28]=right[x];
}
printf(“GABUNG\n”);
for(x=0;x<=55;x++)
printf(“%d”,gabung[x]);
sleep(1);
clrscr();

cp[0] =gabung[13];    cp[12]=gabung[22];    cp[24]=gabung[40];    cp[36]=gabung[43];
cp[1] =gabung[16];    cp[13]=gabung[18];    cp[25]=gabung[51];    cp[37]=gabung[48];
cp[2] =gabung[10];    cp[14]=gabung[11];    cp[26]=gabung[30];    cp[38]=gabung[38];
cp[3] =gabung[23];    cp[15]=gabung[3];    cp[27]=gabung[36];    cp[39]=gabung[55];
cp[4] =gabung[0];    cp[16]=gabung[25];    cp[28]=gabung[46];    cp[40]=gabung[33];
cp[5] =gabung[4];    cp[17]=gabung[7];    cp[29]=gabung[55];    cp[41]=gabung[52];
cp[6] =gabung[2];    cp[18]=gabung[15];    cp[30]=gabung[29];    cp[42]=gabung[45];
cp[7] =gabung[27];    cp[19]=gabung[6];    cp[31]=gabung[39];    cp[43]=gabung[41];
cp[8] =gabung[14];    cp[20]=gabung[26];    cp[32]=gabung[50];    cp[44]=gabung[49];
cp[9] =gabung[5];    cp[21]=gabung[19];    cp[33]=gabung[44];    cp[45]=gabung[35];
cp[10]=gabung[20];    cp[22]=gabung[12];    cp[34]=gabung[32];    cp[46]=gabung[28];
cp[11]=gabung[9];    cp[23]=gabung[1];    cp[35]=gabung[47];    cp[47]=gabung[31];

printf(“CP :\n”);
for(x=0;x<=47;x++)
printf(“%d”,cp[x]);
sleep(1);
clrscr();

for(x=0;x<=47;x++){
if(round==1) key1[x]=cp[x];
if(round==2) key2[x]=cp[x];
if(round==3) key3[x]=cp[x];
if(round==4) key4[x]=cp[x];
if(round==5) key5[x]=cp[x];
if(round==6) key6[x]=cp[x];
if(round==7) key7[x]=cp[x];
if(round==8) key8[x]=cp[x];
if(round==9) key9[x]=cp[x];
if(round==10) key10[x]=cp[x];
if(round==11) key11[x]=cp[x];
if(round==12) key12[x]=cp[x];
if(round==13) key13[x]=cp[x];
if(round==14) key14[x]=cp[x];
if(round==15) key15[x]=cp[x];
if(round==16) key16[x]=cp[x];
}
round++;
if(round==17) goto next;
else goto looping;

next:
for(x=0;x<=31;x++){
kiri[x]=ip[x];
kanan[x]=ip[x+32];
}

printf(“IP DIBAGI DUA\n”);
printf(“KIRI:\n”);
for(x=0;x<=31;x++)
printf(“%d”,kiri[x]);
printf(“\nKANAN:\n”);
for(x=0;x<=31;x++)
printf(“%d”,kanan[x]);
sleep(1);
clrscr();
counter=1;
back:
printf(“COUNTER : %d”,counter);
sleep(1);
clrscr();
ep[0] =kanan[31];    ep[12]=kanan[7];    ep[24]=kanan[15];    ep[36]=kanan[23];
ep[1] =kanan[0];    ep[13]=kanan[8];    ep[25]=kanan[16];    ep[37]=kanan[24];
ep[2] =kanan[1];    ep[14]=kanan[9];    ep[26]=kanan[17];    ep[38]=kanan[25];
ep[3] =kanan[2];    ep[15]=kanan[10];    ep[27]=kanan[18];    ep[39]=kanan[26];
ep[4] =kanan[3];    ep[16]=kanan[11];    ep[28]=kanan[19];    ep[40]=kanan[27];
ep[5] =kanan[4];    ep[17]=kanan[12];    ep[29]=kanan[20];    ep[41]=kanan[28];
ep[6] =kanan[3];    ep[18]=kanan[11];    ep[30]=kanan[19];    ep[42]=kanan[27];
ep[7] =kanan[4];    ep[19]=kanan[12];    ep[31]=kanan[20];    ep[43]=kanan[28];
ep[8] =kanan[5];    ep[20]=kanan[13];    ep[32]=kanan[21];    ep[44]=kanan[29];
ep[9] =kanan[6];    ep[21]=kanan[14];    ep[33]=kanan[22];    ep[45]=kanan[30];
ep[10]=kanan[7];    ep[22]=kanan[15];    ep[34]=kanan[23];    ep[46]=kanan[31];
ep[11]=kanan[8];    ep[23]=kanan[16];    ep[35]=kanan[24];    ep[47]=kanan[0];

printf(“EP:\n”);
for(x=0;x<=47;x++)
printf(“%d”,ep[x]);
sleep(1);
clrscr();

for(x=0;x<=47;x++){
if(counter==1)
xor[x]=ep[x]^key1[x];
if(counter==2)
xor[x]=ep[x]^key2[x];
if(counter==3)
xor[x]=ep[x]^key3[x];
if(counter==4)
xor[x]=ep[x]^key4[x];
if(counter==5)
xor[x]=ep[x]^key5[x];
if(counter==6)
xor[x]=ep[x]^key6[x];
if(counter==7)
xor[x]=ep[x]^key7[x];
if(counter==8)
xor[x]=ep[x]^key8[x];
if(counter==9)
xor[x]=ep[x]^key9[x];
if(counter==10)
xor[x]=ep[x]^key10[x];
if(counter==11)
xor[x]=ep[x]^key11[x];
if(counter==12)
xor[x]=ep[x]^key12[x];
if(counter==13)
xor[x]=ep[x]^key13[x];
if(counter==14)
xor[x]=ep[x]^key14[x];
if(counter==15)
xor[x]=ep[x]^key15[x];
if(counter==16)
xor[x]=ep[x]^key16[x];
}

a=(xor[0]<<1)^xor[5];
b=(xor[1]<<3)^(xor[2]<<2)^(xor[3]<<1)^xor[4];
c=(xor[6]<<1)^xor[11];
d=(xor[7]<<3)^(xor[8]<<2)^(xor[9]<<1)^xor[10];
e=(xor[12]<<1)^xor[17];
f=(xor[11]<<3)^(xor[12]<<2)^(xor[13]<<1)^xor[14];
g=(xor[18]<<1)^xor[23];
h=(xor[19]<<3)^(xor[20]<<2)^(xor[21]<<1)^xor[22];
i=(xor[24]<<1)^xor[29];
j=(xor[25]<<3)^(xor[26]<<2)^(xor[27]<<1)^xor[28];
k=(xor[30]<<1)^xor[35];
l=(xor[31]<<3)^(xor[32]<<2)^(xor[33]<<1)^xor[34];
m=(xor[36]<<1)^xor[41];
n=(xor[37]<<3)^(xor[38]<<2)^(xor[39]<<1)^xor[40];
o=(xor[42]<<1)^xor[47];
p=(xor[43]<<3)^(xor[44]<<2)^(xor[45]<<1)^xor[46];

printf(“\nA = %d”,a);
printf(“\nB = %d”,b);
printf(“\nC = %d”,c);
printf(“\nD = %d”,d);
printf(“\nE = %d”,e);
printf(“\nF = %d”,f);
printf(“\nG = %d”,g);
printf(“\nH = %d”,h);
printf(“\nI = %d”,i);
printf(“\nJ = %d”,j);
printf(“\nK = %d”,k);
printf(“\nL = %d”,l);
printf(“\nM = %d”,m);
printf(“\nN = %d”,n);
printf(“\nO = %d”,o);
printf(“\nP = %d”,p);
sleep(1);
clrscr();

sementara[0]=sbox1[a][b];
sementara[1]=sbox2[c][d];
sementara[2]=sbox3[e][f];
sementara[3]=sbox4[g][h];
sementara[4]=sbox5[i][j];
sementara[5]=sbox6[k][l];
sementara[6]=sbox7[m][n];
sementara[7]=sbox8[o][p];

printf(“NILAI OUTPUT DARI SBOX\n”);
printf(“sbox1 OUTPUT : %d\n”,sementara[0]);
printf(“sbox2 OUTPUT : %d\n”,sementara[1]);
printf(“sbox3 OUTPUT : %d\n”,sementara[2]);
printf(“sbox4 OUTPUT : %d\n”,sementara[3]);
printf(“sbox5 OUTPUT : %d\n”,sementara[4]);
printf(“sbox6 OUTPUT : %d\n”,sementara[5]);
printf(“sbox7 OUTPUT : %d\n”,sementara[6]);
printf(“sbox8 OUTPUT : %d\n”,sementara[7]);
sleep(1);
clrscr();

binsbox[0] =(sementara[1]>>3)&1;
binsbox[1] =(sementara[1]>>2)&1;
binsbox[2] =(sementara[1]>>1)&1;
binsbox[3] =sementara [1]&1;
binsbox[4] =(sementara[2]>>3)&1;
binsbox[5] =(sementara[2]>>2)&1;
binsbox[6] =(sementara[2]>>1)&1;
binsbox[7] =sementara [2]&1;
binsbox[8] =(sementara[3]>>3)&1;
binsbox[9] =(sementara[3]>>2)&1;
binsbox[10]=(sementara[3]>>1)&1;
binsbox[11]=sementara [3]&1;
binsbox[12]=(sementara[4]>>3)&1;
binsbox[13]=(sementara[4]>>2)&1;
binsbox[14]=(sementara[4]>>1)&1;
binsbox[15]=sementara [4]&1;
binsbox[16]=(sementara[5]>>3)&1;
binsbox[17]=(sementara[5]>>2)&1;
binsbox[18]=(sementara[5]>>1)&1;
binsbox[19]=sementara [5]&1;
binsbox[20]=(sementara[6]>>3)&1;
binsbox[21]=(sementara[6]>>2)&1;
binsbox[22]=(sementara[6]>>1)&1;
binsbox[23]=sementara [6]&1;
binsbox[24]=(sementara[7]>>3)&1;
binsbox[25]=(sementara[7]>>2)&1;
binsbox[26]=(sementara[7]>>1)&1;
binsbox[27]=sementara [7]&1;
binsbox[28]=(sementara[8]>>3)&1;
binsbox[29]=(sementara[8]>>2)&1;
binsbox[30]=(sementara[8]>>1)&1;
binsbox[31]=sementara [8]&1;

printf(“BINARI KELUARAN DARI SBOX:\n”);
for(x=0;x<=31;x++)
printf(“%d”,binsbox[x]);
sleep(1);
clrscr();

pbox[0] =binsbox[15];    pbox[16]=binsbox[1];
pbox[1] =binsbox[6];    pbox[17]=binsbox[7];
pbox[2] =binsbox[19];    pbox[18]=binsbox[23];
pbox[3] =binsbox[20];    pbox[19]=binsbox[13];
pbox[4] =binsbox[28];    pbox[20]=binsbox[31];
pbox[5] =binsbox[11];    pbox[21]=binsbox[26];
pbox[6] =binsbox[27];    pbox[22]=binsbox[2];
pbox[7] =binsbox[16];    pbox[23]=binsbox[8];
pbox[8] =binsbox[0];    pbox[24]=binsbox[18];
pbox[9] =binsbox[14];    pbox[25]=binsbox[12];
pbox[10]=binsbox[22];    pbox[26]=binsbox[29];
pbox[11]=binsbox[25];    pbox[27]=binsbox[5];
pbox[12]=binsbox[4];    pbox[28]=binsbox[21];
pbox[13]=binsbox[17];    pbox[29]=binsbox[10];
pbox[14]=binsbox[30];    pbox[30]=binsbox[3];
pbox[15]=binsbox[9];    pbox[31]=binsbox[24];

printf(“PBOX :\n”);
for(x=0;x<=31;x++)
printf(“%d”,pbox[x]);
sleep(1);
clrscr();

for(x=0;x<=31;x++){
rikson[x]=kiri[x];
gultom[x]=kanan[x];
kiri[x]=gultom[x];
kanan[x]=rikson[x]^pbox[x];
}
printf(“XOR LALU TUKAR KIRI DENGAN KANAN\n”);
printf(“KIRI SEKARANG :\n”);
for(x=0;x<=31;x++)
printf(“%d”,kiri[x]);
printf(“\nKANAN SEKARANG :\n”);
for(x=0;x<=31;x++)
printf(“%d”,kanan[x]);
sleep(1);
clrscr();

counter++;
if(counter==17) goto lanjut;
else
goto back;

lanjut:
for(x=0;x<=31;x++){
ga[x]=kiri[x];
ga[x+32]=kanan[x];
}

printf(“GABUNG SEMUA\n”);
for(x=0;x<=63;x++)
printf(“%d”,ga[x]);
sleep(1);
clrscr();

fp[0] =ga[39];    fp[16]=ga[37];    fp[32]=ga[35];    fp[48]=ga[33];
fp[1] =ga[7];    fp[17]=ga[5];    fp[33]=ga[3];    fp[49]=ga[1];
fp[2] =ga[47];    fp[18]=ga[45];    fp[34]=ga[43];    fp[50]=ga[41];
fp[3] =ga[15];    fp[19]=ga[13];    fp[35]=ga[11];    fp[51]=ga[9];
fp[4] =ga[55];    fp[20]=ga[53];    fp[36]=ga[51];    fp[52]=ga[49];
fp[5] =ga[23];    fp[21]=ga[21];    fp[37]=ga[19];    fp[53]=ga[17];
fp[6] =ga[63];    fp[22]=ga[61];    fp[38]=ga[59];    fp[54]=ga[57];
fp[7] =ga[31];    fp[23]=ga[29];    fp[39]=ga[27];    fp[55]=ga[25];
fp[8] =ga[38];    fp[24]=ga[36];    fp[40]=ga[34];    fp[56]=ga[32];
fp[9] =ga[6];    fp[25]=ga[4];    fp[41]=ga[2];    fp[57]=ga[0];
fp[10]=ga[46];    fp[26]=ga[44];    fp[42]=ga[42];    fp[58]=ga[40];
fp[11]=ga[14];    fp[27]=ga[12];    fp[43]=ga[10];    fp[59]=ga[8];
fp[12]=ga[54];    fp[28]=ga[52];    fp[44]=ga[50];    fp[60]=ga[48];
fp[13]=ga[22];    fp[29]=ga[20];    fp[45]=ga[18];    fp[61]=ga[16];
fp[14]=ga[62];    fp[30]=ga[60];    fp[46]=ga[58];    fp[62]=ga[56];
fp[15]=ga[30];    fp[31]=ga[28];    fp[47]=ga[26];    fp[63]=ga[24];

printf(“FP:\n”);
for(x=0;x<=63;x++)
printf(“%d”,fp[x]);
sleep(1);
clrscr();

cipher[0]=(fp[0 ]<<7)^(fp[1 ]<<6)^(fp[2 ]<<5)^(fp[3 ]<<4)^(fp[4 ]<<3)^(fp[5 ]<<2)^(fp[6 ]<<1)^fp[7 ];
cipher[1]=(fp[8 ]<<7)^(fp[9 ]<<6)^(fp[10]<<5)^(fp[11]<<4)^(fp[12]<<3)^(fp[13]<<2)^(fp[14]<<1)^fp[15];
cipher[2]=(fp[16]<<7)^(fp[17]<<6)^(fp[18]<<5)^(fp[19]<<4)^(fp[20]<<3)^(fp[21]<<2)^(fp[22]<<1)^fp[23];
cipher[3]=(fp[24]<<7)^(fp[25]<<6)^(fp[26]<<5)^(fp[27]<<4)^(fp[28]<<3)^(fp[29]<<2)^(fp[30]<<1)^fp[31];
cipher[4]=(fp[32]<<7)^(fp[33]<<6)^(fp[34]<<5)^(fp[35]<<4)^(fp[36]<<3)^(fp[37]<<2)^(fp[38]<<1)^fp[39];
cipher[5]=(fp[40]<<7)^(fp[41]<<6)^(fp[42]<<5)^(fp[43]<<4)^(fp[44]<<3)^(fp[45]<<2)^(fp[46]<<1)^fp[47];
cipher[6]=(fp[48]<<7)^(fp[49]<<6)^(fp[50]<<5)^(fp[51]<<4)^(fp[52]<<3)^(fp[53]<<2)^(fp[54]<<1)^fp[55];
cipher[7]=(fp[56]<<7)^(fp[57]<<6)^(fp[58]<<5)^(fp[59]<<4)^(fp[60]<<3)^(fp[61]<<2)^(fp[62]<<1)^fp[63];

printf(“TEKS SANDI :”);
for(x=0;x<=7;x++)
printf(“%d “,cipher[x]);
getch();
}

Tabel neh,.,.

Tabel (Matriks) DES :

1. Initial Permutation

		1	2	3	4	5	6	7	8
	1	58	50	42	34	26	18	10	2
	2	60	52	44	36	28	20	12	4
	3	62	54	46	38	30	22	14	6
IP=	4	64	56	48	40	32	24	16	8
	5	57	49	41	33	25	17	9	1
	6	59	51	43	35	27	19	11	3
	7	61	53	45	37	29	21	13	5
	8	63	55	47	39	31	23	15	7

2. Final Permutation (IP^-1)

		1	2	3	4	5	6	7	8
	1	40	8	48	16	56	24	64	32
	2	39	7	47	15	55	23	63	31
	3	38	6	46	14	54	22	62	30
IP-1=	4	37	5	45	13	53	21	61	29
	5	36	4	44	12	52	20	60	28
	6	35	3	43	11	51	19	59	27
	7	34	2	42	10	50	18	58	26
	8	33	1	41	9	49	17	57	25

 

3. Expansion Function (E)

		1	2	3	4	5	6
	1	32	1	2	3	4	5
	2	4	5	6	7	8	9
	3	8	9	10	11	12	13
E=	4	12	13	14	15	16	17
	5	16	17	18	19	20	21
	6	20	21	22	23	24	25
	7	24	25	26	27	28	29
	8	28	29	30	31	32	1

4. Permutation P

		1	2	3	4
	1	16	17	20	21
	2	29	12	28	17
	3	1	15	23	26
P=	4	5	18	31	10
	5	2	8	24	14
	6	32	27	3	9
	7	19	13	30	6
	8	22	11	4	25

5. S-Boxes (S1-S8)

S1: Column

Row	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
0	14	4	13	1	2	15	11	8	3	10	6	12	5	9	0	7
1	0	15	7	4	14	2	13	1	10	6	12	11	9	5	3	8
2	4	1	14	8	13	6	2	11	15	12	9	7	3	10	5	0
3	15	12	8	2	4	9	1	7	5	11	3	14	10	0	6	13

S2: Column

Row	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
0	15	1	8	14	6	11	3	4	9	7	2	13	12	0	5	10
1	3	13	4	7	15	2	8	14	12	0	1	10	6	9	11	5
2	0	14	7	11	10	4	13	1	5	8	12	6	9	3	2	15
3	13	8	10	1	3	15	4	2	11	6	7	12	0	5	14	9

 

S3: Column

Row	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
0	10	0	9	14	6	3	15	5	1	13	12	7	11	4	2	8
1	13	7	0	9	3	4	6	10	2	8	5	14	12	11	15	1
2	3	6	4	9	8	15	3	0	11	1	2	12	5	10	14	7
3	1	10	13	0	6	9	8	7	4	15	14	3	11	5	2	12

S4: Column

Row	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
0	7	13	14	3	0	6	9	10	1	2	8	5	11	12	4	15
1	13	8	11	5	6	15	0	3	4	7	2	12	1	10	14	9
2	10	6	9	0	12	11	7	13	15	1	3	14	5	2	8	4
3	3	15	0	6	10	1	13	8	9	4	5	11	12	7	2	4

S5: Column

Row	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
0	2	12	4	1	7	10	11	6	8	5	3	15	13	0	14	9
1	14	11	2	12	4	7	13	1	5	0	15	10	3	9	8	6
2	4	2	1	11	10	13	7	8	15	9	12	5	6	3	0	14
3	11	8	12	7	1	14	2	13	6	15	0	9	10	4	5	3

S6: Column

Row	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
0	12	1	10	15	9	2	6	8	0	13	3	4	14	7	5	11
1	10	15	4	2	7	12	9	5	6	1	13	14	0	11	3	8
2	9	14	15	5	2	8	12	3	7	0	4	10	1	13	11	6
3	4	3	2	12	9	5	15	10	11	14	1	7	6	0	8	13

S7: Column

Row	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
0	4	11	2	14	15	0	8	13	3	12	9	7	5	10	6	1
1	13	0	11	7	4	9	1	10	14	3	5	12	2	15	8	6
2	1	4	11	13	12	3	7	14	10	15	6	8	0	5	9	2
3	6	11	13	8	1	4	10	7	9	5	0	15	14	2	3	12

S8: Column

Row	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
0	13	2	8	4	6	15	11	1	10	9	3	14	5	0	12	7
1	1	15	13	8	10	3	7	4	12	5	6	11	0	14	9	2
2	7	11	4	1	9	12	14	2	0	6	10	13	15	3	5	8
3	2	1	14	7	4	10	8	13	15	12	9	0	3	5	6	11

6. Key Permutation (PC-1)

		1	2	3	4	5	6	7
	1	57	49	41	33	25	17	9
	2	1	58	50	42	34	26	18
	3	10	2	59	51	43	35	27
PC-1=	4	19	11	3	60	52	44	36
	5	63	55	47	39	31	23	15
	6	7	62	54	46	38	30	22
	7	14	6	61	53	45	37	29
	8	21	13	5	28	20	12	4

7. Compression Key (PC-2)

		1	2	3	4	5	6
	1	14	17	11	24	1	5
	2	3	28	15	6	21	10
	3	23	19	12	4	26	8
PC-2=	4	16	7	27	20	13	2
	5	41	52	31	37	47	55
	6	30	40	51	45	33	48
	7	44	49	39	56	34	53
	8	46	42	50	36	29	32

Proses Enkripsi dan Dekripsi DES dilakukan 16 tahap

    Pada awal enkripsi terlebih dahulu dilakukan Initial Permutation (IP) terhadap plaintext dan pada akhir enkripsi dilakukan IP kembali. Pada saat dekripsi prosesnya sama dengan enkripsi, tetapi kunci yang digunakan untuk awal dekripsi dimulai dari K₁₆ …K₁. Matriks P, E, S-Boxes, IP, PC-1 dan PC-2 yang digunakan juga sama dengan pada saat enkripsi.

 

 

    Proses enkripsi dimulai dengan mengubah pesan m menjadi biner dengan ukuran blok 64 bit. Kemudian terhadap pesan dalam biner diacak dengan menggunakan IP, kemudian pesan dibagi 2 @ 32 bit Left dan Right. Untuk setiap putaran (round); terhadap Li dan Ri dilakukan pertukaran dari kanan ke kiri. Sementara untuk mendapatkan Ri digunakan f dan dilakukan operasi XOR dengan Li; kecuali putaran terakhir (round 16) dilakukan sebaliknya. Jadi L_i = R_i-1 dan R_i = L_i-1  f(R_i-1, K_i) i = 1,2,…15. Sementara untuk i=16 dilakukan dengan cara sebaliknya yaitu L₁₆ = L₁₅  f(R₁₅, K₁₆) dan R₁₆= L₁₅. f adalah sebuah fungsi yang memetakan (map) string 32-bit ke string 32-bit yang dihitung dari kunci dan R_i-1

    Pertama, bagian kanan R_i-1 di-expand menjadi 48 bit dengan menggunakan bit-selection table (matrix) E. Kemudian, lakukan operasi XOR string 48-bit yang baru dengan K_i. Lalu string hasil 48-bit dikompress menjadi 32 bit dengan menggunakan S-Boxes. Kedelapan S-Boxes dirancang untuk memetakan string 6-bit menjadi string 4-bit. Misalkan satu string 6-bit adalah matriks 4 x 16 [0..3, 0..15]. Bit pertama dan ke 6 diinterpretasikan sebagai string 2-bit untuk menghasilkan baris [0..3]; bit ke-2 sampai ke-5 diinterpretasikan sebagai string 4-bit untuk menghasilkan kolom [0..15]. Contoh, sebuah string 6-bit 101011 akan diinterpretasikan sebagai posisi array [3,5]. Elemen pada posisi tersebut adalah string 4-bit dalam bentuk biner. Jadi string 48-bit dianggap sebagai 8 blok masing-masing 6-bit; dengan transformasi menggunakan salah satu dari 8 S-Boxes akan menghasilkan 8 blok dengan panjang 4; sehingga diperoleh string 32-bit. Dengan menggunakan string 6-bit 101011 di atas sebagai input terhadap S2-Box yaitu baris ke-3 kolom ke-5 menghasilkan output = 15 (1111). Akhirnya, blok 32-bit ini dipermutasikan dengan P dan di-XOR-kan dengan L_i-1 untuk menghasilkan R_i. Secara singkat fungsi f dapat dituliskan sebagai:

F(R_i-1, K_i) = P(S(E(R_i-1) K_i)); yang diuraikan menjadi :

1. Expansikan R_i-1

2. XOR-kan R_i-1 yang telah di-expand dengan K_i

3. Gunakan S-Box terhadap hasil langkah 2 untuk mengubah string 48 bit jadi 32-bit

4. Gunakan permutasi P dan XOR-kan dengan L_i-1 untuk menghasilkan R_i

 

    Yang menjadi pertanyaan, adalah bagaimana kunci 48 bit pada setiap round dari 16 diperoleh? Untuk itu kita perlu memperhatikan / menggunakan PC-1, PC-2 dan The Key Schedule of Left Shift LS berikut :

Iterasi Ke	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16
#LeftShift	1	1	2	2	2	2	2	2	1	2	2	2	2	2	2	1

 

    Pada setiap tahap, kunci 56-bit mula-mula digunakan untuk menghasilkan kunci 48-bit K_i (i=1,2..16). Pada round pertama, keseluruhan kunci (56-bit) di-injeksikan ke string 64-bit, dengan bit ke 8, 16, 24 dan seterusnya dianggap parity check; kemudian hasil tersebut diberikan kepada permutasi 64-bit PC-1, yang juga membuang parity bit. Kemudian pada setiap tahap, kunci 56-bit dipecah menjadi 2 bagian kiri dan kanan masing-masing 28-bit (C_i-1 dan D_i-1). Potongan 28 bit ini akan dilakukan shift left 1 kali atau 2 kali sehubungan dengan iterasi dan key schedule di atas. Penggabungan C_i-1 dan D_i-1 kemudian mempunyai 48 bit yang dipilih dari PC-2.

 

 

<!– @page { size: 8.5in 11in; margin: 0.79in } H2 { margin-top: 0in; margin-bottom: 0in; line-height: 200%; text-align: justify } H2.western { font-family: “Nimbus Roman No9 L”, serif; font-size: 12pt } H2.cjk { font-family: “DejaVuSans”; font-size: 12pt } H2.ctl { font-family: “Lucidasans”; font-size: 12pt } P { margin-bottom: 0.08in } –

 

 

 

 

 

Bentuk Kriptosistem DES

 

χ_DES = << K₅₆, M₆₄, M₆₄, T_DES >>

K56 merupakan kunci 56 bit

M64 merupakan plaintext 64 bit

M64 merupakan ciphertext 64 bit

TDES merupakan transformasi DES

Ada beberapa matriks yang digunakan yi :

1. IP (Initial Permutation), matriks 8 x 8 yang digunakan pada awal dan akhir enkripsi dan dekripsi.

2. E (Expansion), matriks 8 x 6.

3. P (Permutation), matriks 8 x 4.

4. S-Boxes, terdiri dari 8 buah matriks berukuran 4 x 16.

5. PC-1 (Key Permutation 1), matriks 8 x 7.

6. PC-2 (Key Permutation 2), matriks 8 x 6

diganti

d tulisan pertama

awalnya mw mbuat RSA

tapi ga jadi

di ganti ma DES

tp teman2 ttp ngasi komentar ya,,,

Latar Belakang DES

<!– @page { size: 8.5in 11in; margin: 0.79in } P { margin-bottom: 0.08in } -

Mendiskusikan masalah keamanan merupakan hal yang menarik bagi siapapun. Selain karena menyangkut kepentingan banyak orang, topik keamanan juga mempunyai implikasi dan selalu kait-mengait dengan permasalahan publik lainnya seperti masalah sosial, politik, hukum, ekonomi dan lain-lain. Setiap hari masalah keamanan dikomunikasikan dalam porsi yang cukup signifikan melalui media cetak maupun elektronik.

Daya tariknya justru menjadi agak berkurang, ketika topik keamanan dipersempit menjadi keamanan informasi. Meski tidak sedikit para pakar di bidang TIK telah meyakinkan bahwa pengamanan informasi merupakan hal penting untuk melindungi kegiatan bisnis dan ekonomi misalnya, diskusi dengan topik keamanan informasi hampir selalu diminati oleh kalangan yang sangat terbatas.

Kemajuan teknologi informasi dan komunikasi telah membuat profesi kriptografi dan keamanan informasi di Indonesia menjadi profesi yang sangat dibutuhkan untuk melindungi data dan informasi penting di perusahaan / organisasi / institusi. Sehingga seperti halnya profesi lain, profesi kriptografi dan keamanan informasi membutuhkan organisasi sebagai tempat bagi berkembangnya profesi tersebut, baik untuk ilmu pengetahuan, regulasi, aplikasi maupun pemasyarakatannya. Pengamanan informasi merupakan rangkaian metode, dimana setiap metode adalah mata rantai dari seluruh rangkaian pengamanan agar tidak diketahui kerahasiaannya oleh pihak luar. Adanya kejahatan yang mengancam informasi mmbuat pentingnya pengamana informasi secara komprehensif. Oleh karena itu penulis merasa tertarik untuk menulis ”Sistem Pengamanan Data Encryption Standard sebagai Standar untuk Melindungi Data dan Informasi serta Pentingnya Organisasi Provesi Kriptografi dan Keamanan Informasi”

Cryptografi

Nesya ngerjai tugas dari dosen nih…
Ngebuat aLgoRitMa ma SouRcE cOde daRi saLah saTu sANdi mOdErN,,
bIngUNg Mw piLIh aP,,
tRaKhirNya RSA

buaT yanG baCa tuLIsaN iNi..
neSya moHoN nGAsi saRan ma kRiTik,,
tRz.,.
biSa Jg nGasi soLusi,,

maKasiH yA,,,,