DEKRIPSI AES

#include<stdio.h>
#define Nb 4

int Nr=0;
int Nk=0;

unsigned char in[16], out[16], state[4][4];
unsigned char RoundKey[240];
unsigned char Key[32];

int getSBoxInvert(int num)
{
int rsbox[256] =
{ 0×52, 0×09, 0×6a, 0xd5, 0×30, 0×36, 0xa5, 0×38, 0xbf, 0×40, 0xa3, 0×9e, 0×81, 0xf3, 0xd7, 0xfb
, 0×7c, 0xe3, 0×39, 0×82, 0×9b, 0×2f, 0xff, 0×87, 0×34, 0×8e, 0×43, 0×44, 0xc4, 0xde, 0xe9, 0xcb
, 0×54, 0×7b, 0×94, 0×32, 0xa6, 0xc2, 0×23, 0×3d, 0xee, 0×4c, 0×95, 0×0b, 0×42, 0xfa, 0xc3, 0×4e
, 0×08, 0×2e, 0xa1, 0×66, 0×28, 0xd9, 0×24, 0xb2, 0×76, 0×5b, 0xa2, 0×49, 0×6d, 0×8b, 0xd1, 0×25
, 0×72, 0xf8, 0xf6, 0×64, 0×86, 0×68, 0×98, 0×16, 0xd4, 0xa4, 0×5c, 0xcc, 0×5d, 0×65, 0xb6, 0×92
, 0×6c, 0×70, 0×48, 0×50, 0xfd, 0xed, 0xb9, 0xda, 0×5e, 0×15, 0×46, 0×57, 0xa7, 0×8d, 0×9d, 0×84
, 0×90, 0xd8, 0xab, 0×00, 0×8c, 0xbc, 0xd3, 0×0a, 0xf7, 0xe4, 0×58, 0×05, 0xb8, 0xb3, 0×45, 0×06
, 0xd0, 0×2c, 0×1e, 0×8f, 0xca, 0×3f, 0×0f, 0×02, 0xc1, 0xaf, 0xbd, 0×03, 0×01, 0×13, 0×8a, 0×6b
, 0×3a, 0×91, 0×11, 0×41, 0×4f, 0×67, 0xdc, 0xea, 0×97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0×73
, 0×96, 0xac, 0×74, 0×22, 0xe7, 0xad, 0×35, 0×85, 0xe2, 0xf9, 0×37, 0xe8, 0×1c, 0×75, 0xdf, 0×6e
, 0×47, 0xf1, 0×1a, 0×71, 0×1d, 0×29, 0xc5, 0×89, 0×6f, 0xb7, 0×62, 0×0e, 0xaa, 0×18, 0xbe, 0×1b
, 0xfc, 0×56, 0×3e, 0×4b, 0xc6, 0xd2, 0×79, 0×20, 0×9a, 0xdb, 0xc0, 0xfe, 0×78, 0xcd, 0×5a, 0xf4
, 0×1f, 0xdd, 0xa8, 0×33, 0×88, 0×07, 0xc7, 0×31, 0xb1, 0×12, 0×10, 0×59, 0×27, 0×80, 0xec, 0×5f
, 0×60, 0×51, 0×7f, 0xa9, 0×19, 0xb5, 0×4a, 0×0d, 0×2d, 0xe5, 0×7a, 0×9f, 0×93, 0xc9, 0×9c, 0xef
, 0xa0, 0xe0, 0×3b, 0×4d, 0xae, 0×2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0×3c, 0×83, 0×53, 0×99, 0×61
, 0×17, 0×2b, 0×04, 0×7e, 0xba, 0×77, 0xd6, 0×26, 0xe1, 0×69, 0×14, 0×63, 0×55, 0×21, 0×0c, 0×7d };

return rsbox[num];
}

int getSBoxValue(int num)
{
int sbox[256] = {

0×63, 0×7c, 0×77, 0×7b, 0xf2, 0×6b, 0×6f, 0xc5, 0×30, 0×01, 0×67, 0×2b, 0xfe, 0xd7, 0xab, 0×76,
0xca, 0×82, 0xc9, 0×7d, 0xfa, 0×59, 0×47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0×9c, 0xa4, 0×72, 0xc0,
0xb7, 0xfd, 0×93, 0×26, 0×36, 0×3f, 0xf7, 0xcc, 0×34, 0xa5, 0xe5, 0xf1, 0×71, 0xd8, 0×31, 0×15,
0×04, 0xc7, 0×23, 0xc3, 0×18, 0×96, 0×05, 0×9a, 0×07, 0×12, 0×80, 0xe2, 0xeb, 0×27, 0xb2, 0×75,
0×09, 0×83, 0×2c, 0×1a, 0×1b, 0×6e, 0×5a, 0xa0, 0×52, 0×3b, 0xd6, 0xb3, 0×29, 0xe3, 0×2f, 0×84,
0×53, 0xd1, 0×00, 0xed, 0×20, 0xfc, 0xb1, 0×5b, 0×6a, 0xcb, 0xbe, 0×39, 0×4a, 0×4c, 0×58, 0xcf,
0xd0, 0xef, 0xaa, 0xfb, 0×43, 0×4d, 0×33, 0×85, 0×45, 0xf9, 0×02, 0×7f, 0×50, 0×3c, 0×9f, 0xa8,
0×51, 0xa3, 0×40, 0×8f, 0×92, 0×9d, 0×38, 0xf5, 0xbc, 0xb6, 0xda, 0×21, 0×10, 0xff, 0xf3, 0xd2,
0xcd, 0×0c, 0×13, 0xec, 0×5f, 0×97, 0×44, 0×17, 0xc4, 0xa7, 0×7e, 0×3d, 0×64, 0×5d, 0×19, 0×73,
0×60, 0×81, 0×4f, 0xdc, 0×22, 0×2a, 0×90, 0×88, 0×46, 0xee, 0xb8, 0×14, 0xde, 0×5e, 0×0b, 0xdb,
0xe0, 0×32, 0×3a, 0×0a, 0×49, 0×06, 0×24, 0×5c, 0xc2, 0xd3, 0xac, 0×62, 0×91, 0×95, 0xe4, 0×79,
0xe7, 0xc8, 0×37, 0×6d, 0×8d, 0xd5, 0×4e, 0xa9, 0×6c, 0×56, 0xf4, 0xea, 0×65, 0×7a, 0xae, 0×08,
0xba, 0×78, 0×25, 0×2e, 0×1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0×74, 0×1f, 0×4b, 0xbd, 0×8b, 0×8a,
0×70, 0×3e, 0xb5, 0×66, 0×48, 0×03, 0xf6, 0×0e, 0×61, 0×35, 0×57, 0xb9, 0×86, 0xc1, 0×1d, 0×9e,
0xe1, 0xf8, 0×98, 0×11, 0×69, 0xd9, 0×8e, 0×94, 0×9b, 0×1e, 0×87, 0xe9, 0xce, 0×55, 0×28, 0xdf,
0×8c, 0xa1, 0×89, 0×0d, 0xbf, 0xe6, 0×42, 0×68, 0×41, 0×99, 0×2d, 0×0f, 0xb0, 0×54, 0xbb, 0×16 };
return sbox[num];
}

int Rcon[255] = {
0×8d, 0×01, 0×02, 0×04, 0×08, 0×10, 0×20, 0×40, 0×80, 0×1b, 0×36, 0×6c, 0xd8, 0xab, 0×4d, 0×9a,
0×2f, 0×5e, 0xbc, 0×63, 0xc6, 0×97, 0×35, 0×6a, 0xd4, 0xb3, 0×7d, 0xfa, 0xef, 0xc5, 0×91, 0×39,
0×72, 0xe4, 0xd3, 0xbd, 0×61, 0xc2, 0×9f, 0×25, 0×4a, 0×94, 0×33, 0×66, 0xcc, 0×83, 0×1d, 0×3a,
0×74, 0xe8, 0xcb, 0×8d, 0×01, 0×02, 0×04, 0×08, 0×10, 0×20, 0×40, 0×80, 0×1b, 0×36, 0×6c, 0xd8,
0xab, 0×4d, 0×9a, 0×2f, 0×5e, 0xbc, 0×63, 0xc6, 0×97, 0×35, 0×6a, 0xd4, 0xb3, 0×7d, 0xfa, 0xef,
0xc5, 0×91, 0×39, 0×72, 0xe4, 0xd3, 0xbd, 0×61, 0xc2, 0×9f, 0×25, 0×4a, 0×94, 0×33, 0×66, 0xcc,
0×83, 0×1d, 0×3a, 0×74, 0xe8, 0xcb, 0×8d, 0×01, 0×02, 0×04, 0×08, 0×10, 0×20, 0×40, 0×80, 0×1b,
0×36, 0×6c, 0xd8, 0xab, 0×4d, 0×9a, 0×2f, 0×5e, 0xbc, 0×63, 0xc6, 0×97, 0×35, 0×6a, 0xd4, 0xb3,
0×7d, 0xfa, 0xef, 0xc5, 0×91, 0×39, 0×72, 0xe4, 0xd3, 0xbd, 0×61, 0xc2, 0×9f, 0×25, 0×4a, 0×94,
0×33, 0×66, 0xcc, 0×83, 0×1d, 0×3a, 0×74, 0xe8, 0xcb, 0×8d, 0×01, 0×02, 0×04, 0×08, 0×10, 0×20,
0×40, 0×80, 0×1b, 0×36, 0×6c, 0xd8, 0xab, 0×4d, 0×9a, 0×2f, 0×5e, 0xbc, 0×63, 0xc6, 0×97, 0×35,
0×6a, 0xd4, 0xb3, 0×7d, 0xfa, 0xef, 0xc5, 0×91, 0×39, 0×72, 0xe4, 0xd3, 0xbd, 0×61, 0xc2, 0×9f,
0×25, 0×4a, 0×94, 0×33, 0×66, 0xcc, 0×83, 0×1d, 0×3a, 0×74, 0xe8, 0xcb, 0×8d, 0×01, 0×02, 0×04,
0×08, 0×10, 0×20, 0×40, 0×80, 0×1b, 0×36, 0×6c, 0xd8, 0xab, 0×4d, 0×9a, 0×2f, 0×5e, 0xbc, 0×63,
0xc6, 0×97, 0×35, 0×6a, 0xd4, 0xb3, 0×7d, 0xfa, 0xef, 0xc5, 0×91, 0×39, 0×72, 0xe4, 0xd3, 0xbd,
0×61, 0xc2, 0×9f, 0×25, 0×4a, 0×94, 0×33, 0×66, 0xcc, 0×83, 0×1d, 0×3a, 0×74, 0xe8, 0xcb };

void KeyExpansion()
{
int i,j;
unsigned char temp[4],k;

for(i=0;i<Nk;i++)
{
RoundKey[i*4]=Key[i*4];
RoundKey[i*4+1]=Key[i*4+1];
RoundKey[i*4+2]=Key[i*4+2];
RoundKey[i*4+3]=Key[i*4+3];
}

while (i < (Nb * (Nr+1)))
{
for(j=0;j<4;j++)
{
temp[j]=RoundKey[(i-1) * 4 + j];
}
if (i % Nk == 0)
{

{
k = temp[0];
temp[0] = temp[1];
temp[1] = temp[2];
temp[2] = temp[3];
temp[3] = k;
}

{
temp[0]=getSBoxValue(temp[0]);
temp[1]=getSBoxValue(temp[1]);
temp[2]=getSBoxValue(temp[2]);
temp[3]=getSBoxValue(temp[3]);
}

temp[0] = temp[0] ^ Rcon[i/Nk];
}
else if (Nk > 6 && i % Nk == 4)
{

{
temp[0]=getSBoxValue(temp[0]);
temp[1]=getSBoxValue(temp[1]);
temp[2]=getSBoxValue(temp[2]);
temp[3]=getSBoxValue(temp[3]);
}
}
RoundKey[i*4+0] = RoundKey[(i-Nk)*4+0] ^ temp[0];
RoundKey[i*4+1] = RoundKey[(i-Nk)*4+1] ^ temp[1];
RoundKey[i*4+2] = RoundKey[(i-Nk)*4+2] ^ temp[2];
RoundKey[i*4+3] = RoundKey[(i-Nk)*4+3] ^ temp[3];
i++;
}
}

void AddRoundKey(int round)
{
int i,j;
for(i=0;i<4;i++)
{
for(j=0;j<4;j++)
{
state[j][i] ^= RoundKey[round * Nb * 4 + i * Nb + j];
}
}
}

void InvSubBytes()
{
int i,j;
for(i=0;i<4;i++)
{
for(j=0;j<4;j++)
{
state[i][j] = getSBoxInvert(state[i][j]);

}
}
}

void InvShiftRows()
{
unsigned char temp;

temp=state[1][3];
state[1][3]=state[1][2];
state[1][2]=state[1][1];
state[1][1]=state[1][0];
state[1][0]=temp;

temp=state[2][0];
state[2][0]=state[2][2];
state[2][2]=temp;

temp=state[2][1];
state[2][1]=state[2][3];
state[2][3]=temp;

temp=state[3][0];
state[3][0]=state[3][1];
state[3][1]=state[3][2];
state[3][2]=state[3][3];
state[3][3]=temp;
}

#define xtime(x) ((x<<1) ^ (((x>>7) & 1) * 0×1b))
#define Multiply(x,y) (((y & 1) * x) ^ ((y>>1 & 1) * xtime(x)) ^ ((y>>2 & 1) * xtime(xtime(x))) ^ ((y>>3 & 1) * xtime(xtime(xtime(x)))) ^ ((y>>4 & 1) * xtime(xtime(xtime(xtime(x))))))

void InvMixColumns()
{
int i;
unsigned char a,b,c,d;
for(i=0;i<4;i++)
{

a = state[0][i];
b = state[1][i];
c = state[2][i];
d = state[3][i];

state[0][i] = Multiply(a, 0×0e) ^ Multiply(b, 0×0b) ^ Multiply(c, 0×0d) ^ Multiply(d, 0×09);
state[1][i] = Multiply(a, 0×09) ^ Multiply(b, 0×0e) ^ Multiply(c, 0×0b) ^ Multiply(d, 0×0d);
state[2][i] = Multiply(a, 0×0d) ^ Multiply(b, 0×09) ^ Multiply(c, 0×0e) ^ Multiply(d, 0×0b);
state[3][i] = Multiply(a, 0×0b) ^ Multiply(b, 0×0d) ^ Multiply(c, 0×09) ^ Multiply(d, 0×0e);
}
}

void InvCipher()
{
int i,j,round=0;

for(i=0;i<4;i++)
{
for(j=0;j<4;j++)
{
state[j][i] = in[i*4 + j];
}
}

AddRoundKey(Nr);

for(round=Nr-1;round>0;round–)
{
InvShiftRows();
InvSubBytes();
AddRoundKey(round);
InvMixColumns();
}

InvShiftRows();
InvSubBytes();
AddRoundKey(0);

for(i=0;i<4;i++)
{
for(j=0;j<4;j++)
{
out[i*4+j]=state[j][i];
}
}
}
void main()
{
int i;
unsigned char temp[32] = {0×00 ,0×01 ,0×02 ,0×03 ,0×04 ,0×05 ,0×06 ,0×07 ,0×08 ,0×09 ,0×0a ,0×0b ,0×0c ,0×0d ,0×0e ,0×0f};
unsigned char temp2[16]= {0×69 ,0xc4 ,0xe0 ,0xd8 ,0×6a ,0×7b ,0×04 ,0×30 ,0xd8 ,0xcd ,0xb7 ,0×80 ,0×70 ,0xb4 ,0xc5 ,0×5a};
printf(“********************************************************************************\n\n”);
printf(” WELCOME\n”);
printf(” ANDA TELAH MEMASUKI PROGRAM ADVANCE ENCRYPTION STANDARD\n”);
printf(” PROGRAM DEKRIPSI\n”);
printf(” KARYA : NEO FAJAR BAWANA KONTA DEWA DANU\n\n”);
printf(“********************************************************************************\n\n”);

while(Nr!=128 && Nr!=192 && Nr!=256)
{
printf(“Masukan Panjang Kunci (128, 192 or 256 only): “);
scanf(“%d”,&Nr);
}
Nk = Nr / 32;
Nr = Nk + 6;

for(i=0;i<Nk*4;i++)
{
Key[i]=temp[i];
in[i]=temp2[i];
}

flushall();

printf(“Masukan Kunci dalam Heksadesimal: “);
for(i=0;i<Nk*4;i++)
{
scanf(“%x”,&Key[i]);
}

printf(“Masukan Ciphertext dalam Heksadesimal: “);
for(i=0;i<Nb*4;i++)
{
scanf(“%x”,&in[i]);
}

KeyExpansion();
InvCipher();
printf(“\nTeks Dekripsi:\n”);
for(i=0;i<Nb*4;i++)
{
printf(“%02x “,out[i]);
}
printf(“\n\n”);
getch();
}

NOTE :

Program ini masih memiliki banyak kekurangan,,

Mohon jika memasuki Blog ini untuk memberikan komentar dan mengoreksi program ini…thx!!