1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285
| // Include stdio.h for standard input/output.
// Used for giving output to the screen.
#include<stdio.h>
#include<iostream>
#include<fstream>
#include<stdlib.h>
// The number of columns comprising a state in AES. This is a constant in AES. Value=4
#define Nb 4
// The number of rounds in AES Cipher. It is simply initiated to zero. The actual value is recieved in the program.
int Nr=0;
// The number of 32 bit words in the key. It is simply initiated to zero. The actual value is recieved in the program.
int Nk=0;
// in - it is the array that holds the plain text to be encrypted.
// out - it is the array that holds the key for encryption.
// state - the array that holds the intermediate results during encryption.
unsigned char in[16], out[16], state[4][4];
// The array that stores the round keys.
unsigned char RoundKey[240];
// The Key input to the AES Program
unsigned char Key[32];
int sbox[256] = {
//0 1 2 3 4 5 6 7 8 9 A B C D E F
0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76, //0
0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, //1
0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15, //2
0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75, //3
0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, //4
0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf, //5
0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8, //6
0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, //7
0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73, //8
0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb, //9
0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, //A
0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08, //B
0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a, //C
0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, //D
0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf, //E
0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 }; //F
int xtimeTab[]={ 0x0 ,
0x2 , 0x4 , 0x6 , 0x8 , 0xa , 0xc , 0xe , 0x10 , 0x12 , 0x14 , 0x16 , 0x18 , 0x1a , 0x1c , 0x1e ,
0x20 , 0x22 , 0x24 , 0x26 , 0x28 , 0x2a , 0x2c , 0x2e , 0x30 , 0x32 , 0x34 , 0x36 , 0x38 , 0x3a , 0x3c ,
0x3e , 0x40 , 0x42 , 0x44 , 0x46 , 0x48 , 0x4a , 0x4c , 0x4e , 0x50 , 0x52 , 0x54 , 0x56 , 0x58 , 0x5a ,
0x5c , 0x5e , 0x60 , 0x62 , 0x64 , 0x66 , 0x68 , 0x6a , 0x6c , 0x6e , 0x70 , 0x72 , 0x74 , 0x76 , 0x78 ,
0x7a , 0x7c , 0x7e , 0x80 , 0x82 , 0x84 , 0x86 , 0x88 , 0x8a , 0x8c , 0x8e , 0x90 , 0x92 , 0x94 , 0x96 ,
0x98 , 0x9a , 0x9c , 0x9e , 0xa0 , 0xa2 , 0xa4 , 0xa6 , 0xa8 , 0xaa , 0xac , 0xae , 0xb0 , 0xb2 , 0xb4 ,
0xb6 , 0xb8 , 0xba , 0xbc , 0xbe , 0xc0 , 0xc2 , 0xc4 , 0xc6 , 0xc8 , 0xca , 0xcc , 0xce , 0xd0 , 0xd2 ,
0xd4 , 0xd6 , 0xd8 , 0xda , 0xdc , 0xde , 0xe0 , 0xe2 , 0xe4 , 0xe6 , 0xe8 , 0xea , 0xec , 0xee , 0xf0 ,
0xf2 , 0xf4 , 0xf6 , 0xf8 , 0xfa , 0xfc , 0xfe , 0x1b , 0x19 , 0x1f , 0x1d , 0x13 , 0x11 , 0x17 , 0x15 ,
0xb , 0x9 , 0xf , 0xd , 0x3 , 0x1 , 0x7 , 0x5 , 0x3b , 0x39 , 0x3f , 0x3d , 0x33 , 0x31 , 0x37 ,
0x35 , 0x2b , 0x29 , 0x2f , 0x2d , 0x23 , 0x21 , 0x27 , 0x25 , 0x5b , 0x59 , 0x5f , 0x5d , 0x53 , 0x51 ,
0x57 , 0x55 , 0x4b , 0x49 , 0x4f , 0x4d , 0x43 , 0x41 , 0x47 , 0x45 , 0x7b , 0x79 , 0x7f , 0x7d , 0x73 ,
0x71 , 0x77 , 0x75 , 0x6b , 0x69 , 0x6f , 0x6d , 0x63 , 0x61 , 0x67 , 0x65 , 0x9b , 0x99 , 0x9f , 0x9d ,
0x93 , 0x91 , 0x97 , 0x95 , 0x8b , 0x89 , 0x8f , 0x8d , 0x83 , 0x81 , 0x87 , 0x85 , 0xbb , 0xb9 , 0xbf ,
0xbd , 0xb3 , 0xb1 , 0xb7 , 0xb5 , 0xab , 0xa9 , 0xaf , 0xad , 0xa3 , 0xa1 , 0xa7 , 0xa5 , 0xdb , 0xd9 ,
0xdf , 0xdd , 0xd3 , 0xd1 , 0xd7 , 0xd5 , 0xcb , 0xc9 , 0xcf , 0xcd , 0xc3 , 0xc1 , 0xc7 , 0xc5 , 0xfb ,
0xf9 , 0xff , 0xfd , 0xf3 , 0xf1 , 0xf7 , 0xf5 , 0xeb , 0xe9 , 0xef , 0xed , 0xe3 , 0xe1 , 0xe7 , 0xe5 };
// The round constant word array, Rcon[i], contains the values given by
// x to th e power (i-1) being powers of x (x is denoted as {02}) in the field GF(28)
// Note that i starts at 1, not 0).
int Rcon[255] = {
0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a,
0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39,
0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a,
0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8,
0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef,
0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc,
0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b,
0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3,
0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94,
0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20,
0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35,
0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f,
0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04,
0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63,
0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd,
0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb };
// This function produces Nb(Nr+1) round keys. The round keys are used in each round to encrypt the states.
void KeyExpansion(){
int i,j;
unsigned char temp[4],k;
// The first round key is the key itself.
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];
}
// All other round keys are found from the previous round keys.
while (i < (Nb * (Nr+1))){
for(j=0;j<4;j++)
temp[j]=RoundKey[(i-1) * 4 + j];
if (i % Nk == 0){
// Function RotWord()
{
k = temp[0];
temp[0] = temp[1];
temp[1] = temp[2];
temp[2] = temp[3];
temp[3] = k;
}
// Function Subword()
{
temp[0]=sbox[temp[0]];
temp[1]=sbox[temp[1]];
temp[2]=sbox[temp[2]];
temp[3]=sbox[temp[3]];
}
temp[0] ^= Rcon[i/Nk];
}
else if (Nk > 6 && i % Nk == 4){
// Function Subword()
{
temp[0]=sbox[temp[0]];
temp[1]=sbox[temp[1]];
temp[2]=sbox[temp[2]];
temp[3]=sbox[temp[3]];
}
}
RoundKey[i*4] = RoundKey[(i-Nk)*4] ^ 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;
}
}
#define NB4 Nb * 4
void AddRoundKey(int round){
for(int i=0; i<4; ++i)
for(int j=0; j<4; ++j)
state[j][i] ^= RoundKey[round * NB4 + i * Nb + j];
}
void SubBytes(){
for(int i=0; i<4; ++i)
for(int j=0; j<4; ++j)
state[i][j] = sbox[state[i][j]];
}
void ShiftRows(){
unsigned char temp;
// Rotate first row 1 columns to left
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;
// Rotate second row 2 columns to left
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;
// Rotate third row 3 columns to left
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;
}
// xtime is a macro that finds the product of {02} and the argument to xtime modulo {1b}
#define xtime(x) ((x<<1) ^ (((x>>7) & 1) * 0x1b))
// MixColumns function mixes the columns of the state matrix
void MixColumns(){
unsigned char Tmp,Tm,t;
for(int i = 0; i < 4; ++i){
t=state[0][i];
Tmp = state[0][i] ^ state[1][i] ^ state[2][i] ^ state[3][i] ;
state[0][i] ^= xtimeTab[state[0][i] ^ state[1][i]] ^ Tmp ;
state[1][i] ^= xtimeTab[state[1][i] ^ state[2][i]] ^ Tmp ;
state[2][i] ^= xtimeTab[state[2][i] ^ state[3][i]] ^ Tmp ;
state[3][i] ^= xtimeTab[state[3][i] ^ t] ^ Tmp ;
}
}
int cmpt = 0;
// Cipher is the main function that encrypts the PlainText.
void Cipher(){
int i,j,round;
//Copy the input PlainText to state array.
for(i=0;i<4;++i)
for(j=0;j<4;++j)
state[j][i] = in[i*4 + j];
// Add the First round key to the state before starting the rounds.
AddRoundKey(0);
// There will be Nr rounds.
// The first Nr-1 rounds are identical.
// These Nr-1 rounds are executed in the loop below.
for(round = 1; round < Nr; ++round){
SubBytes();
ShiftRows();
MixColumns();
AddRoundKey(round);
}
// The last round is given below.
// The MixColumns function is not here in the last round.
SubBytes();
ShiftRows();
AddRoundKey(Nr);
// The encryption process is over.
// Copy the state array to output array.
for(i=0; i<4; ++i)
for(j=0; j<4; ++j)
out[i*4+j] = state[j][i];
++cmpt;
}
int main(){
int i;
/*unsigned char a;
printf("int xtimeTab[]={ ");
for (i = 0; i < 256; ++i){
a = xtime(i);
printf("0x%x , ",a);
if(i%15 == 0)
printf("\n");
}
exit(1);*/
Nr = 128;
// Calculate Nk and Nr from the recieved value.
Nk = Nr / 32;
Nr = Nk + 6;
// Part 1 is for demonstrative purpose. The key and plaintext are given in the program itself.
// Part 1: ********************************************************
// The array temp stores the key.
// The array temp2 stores the plaintext.
unsigned char temp[32] = {0x00 ,0x01 ,0x02 ,0x03 ,0x04 ,0x05 ,0x06 ,0x07 ,0x08 ,0x09 ,0x0a ,0x0b ,0x0c ,0x0d ,0x0e ,0x0f};
unsigned char temp2[32]= {0x00 ,0x11 ,0x22 ,0x33 ,0x44 ,0x55 ,0x66 ,0x77 ,0x88 ,0x99 ,0xaa ,0xbb ,0xcc ,0xdd ,0xee ,0xff};
// Copy the Key and PlainText
for(i=0;i<Nk*4;i++){
Key[i]=temp[i];
in[i]=temp2[i];
}
// The KeyExpansion routine must be called before encryption.
KeyExpansion();
// The next function call encrypts the PlainText with the Key using AES algorithm.
for (i = 0; i < 200000000; ++i)// 200000000*16 octet => 3051,75781 Mo
Cipher();
printf("%d\n",cmpt);
// Output the encrypted text.
printf("\nText after encryption:\n");
for(i=0;i<Nb*4;i++){
printf("%02x ",out[i]);
}
printf("\n\n");
} |
Partager