ENKRIPSI 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 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 SubBytes()
{
int i,j;
for(i=0;i<4;i++)
{
for(j=0;j<4;j++)
{
state[i][j] = getSBoxValue(state[i][j]);

}
}
}

void ShiftRows()
{
unsigned char temp;
temp=state[1][0];
state[1][0]=state[1][1];
state[1][1]=state[1][2];
state[1][2]=state[1][3];
state[1][3]=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][3];
state[3][3]=state[3][2];
state[3][2]=state[3][1];
state[3][1]=temp;
}

#define xtime(x) ((x<<1) ^ (((x>>7) & 1) * 0×1b))

void MixColumns()
{
int i;
unsigned char Tmp,Tm,t;
for(i=0;i<4;i++)
{
t=state[0][i];
Tmp = state[0][i] ^ state[1][i] ^ state[2][i] ^ state[3][i] ;
Tm = state[0][i] ^ state[1][i] ; Tm = xtime(Tm); state[0][i] ^= Tm ^ Tmp ;
Tm = state[1][i] ^ state[2][i] ; Tm = xtime(Tm); state[1][i] ^= Tm ^ Tmp ;
Tm = state[2][i] ^ state[3][i] ; Tm = xtime(Tm); state[2][i] ^= Tm ^ Tmp ;
Tm = state[3][i] ^ t ; Tm = xtime(Tm); state[3][i] ^= Tm ^ Tmp ;
}
}

void Cipher()
{
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(0);
for(round=1;round<Nr;round++)
{
SubBytes();
ShiftRows();
MixColumns();
AddRoundKey(round);
}

SubBytes();
ShiftRows();
AddRoundKey(Nr);

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[16] = {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×00 ,0×11 ,0×22 ,0×33 ,0×44 ,0×55 ,0×66 ,0×77 ,0×88 ,0×99 ,0xaa ,0xbb ,0xcc ,0xdd ,0xee ,0xff};

printf(“********************************************************************************\n\n”);
printf(” WELCOME\n”);
printf(” ANDA TELAH MEMASUKI PROGRAM ADVANCE ENCRYPTION STANDARD\n”);
printf(” PROGRAM ENKRIPSI\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];
}

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

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

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

NOTE :

program ini masih banyak kekurangan,,

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