Commit 9ae240cf authored by kokke's avatar kokke
Browse files

Update aes.c

parent 698375cf
...@@ -3,31 +3,31 @@ ...@@ -3,31 +3,31 @@
This is the implementation of the AES128 algorithm, specifically ECB mode. This is the implementation of the AES128 algorithm, specifically ECB mode.
The implementation is verified against the test vectors in: The implementation is verified against the test vectors in:
National Institute of Standards and Technology Special Publication 800-38A 2001 ED National Institute of Standards and Technology Special Publication 800-38A 2001 ED
ECB-AES128 ECB-AES128
---------- ----------
plain-text: plain-text:
6bc1bee22e409f96e93d7e117393172a 6bc1bee22e409f96e93d7e117393172a
ae2d8a571e03ac9c9eb76fac45af8e51 ae2d8a571e03ac9c9eb76fac45af8e51
30c81c46a35ce411e5fbc1191a0a52ef 30c81c46a35ce411e5fbc1191a0a52ef
f69f2445df4f9b17ad2b417be66c3710 f69f2445df4f9b17ad2b417be66c3710
key: key:
2b7e151628aed2a6abf7158809cf4f3c 2b7e151628aed2a6abf7158809cf4f3c
resulting cipher resulting cipher
50fe67cc996d32b6da0937e99bafec60 50fe67cc996d32b6da0937e99bafec60
d9a4dada0892239f6b8b3d7680e15674 d9a4dada0892239f6b8b3d7680e15674
a78819583f0308e7a6bf36b1386abf23 a78819583f0308e7a6bf36b1386abf23
c6d3416d29165c6fcb8e51a227ba994e c6d3416d29165c6fcb8e51a227ba994e
Use aes_encrypt_string() to encrypt or decrypt a string Use aes_encrypt_string() to encrypt or decrypt a string
NOTE: String length must be evenly divisible by 16byte (str_len % 16 == 0) NOTE: String length must be evenly divisible by 16byte (str_len % 16 == 0)
You should pad the end of the string with zeros if this is not the case. You should pad the end of the string with zeros if this is not the case.
*/ */
...@@ -75,44 +75,44 @@ static uint8_t* Key; ...@@ -75,44 +75,44 @@ static uint8_t* Key;
// This can be useful in (embedded) bootloader applications, where ROM is often limited. // This can be useful in (embedded) bootloader applications, where ROM is often limited.
static const uint8_t sbox[256] = { static const uint8_t sbox[256] = {
//0 1 2 3 4 5 6 7 8 9 A B C D E F //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, 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15, 0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75, 0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf, 0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8, 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73, 0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb, 0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08, 0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a, 0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf, 0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 }; 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 };
// The round constant word array, Rcon[i], contains the values given by // 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(2^8) // x to th e power (i-1) being powers of x (x is denoted as {02}) in the field GF(2^8)
// Note that i starts at 1, not 0). // Note that i starts at 1, not 0).
static const uint8_t Rcon[255] = { static const uint8_t Rcon[255] = {
0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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 }; 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb };
/*****************************************************************************/ /*****************************************************************************/
...@@ -120,101 +120,101 @@ static const uint8_t Rcon[255] = { ...@@ -120,101 +120,101 @@ static const uint8_t Rcon[255] = {
/*****************************************************************************/ /*****************************************************************************/
static uint8_t getSBoxValue(uint8_t num) static uint8_t getSBoxValue(uint8_t num)
{ {
return sbox[num]; return sbox[num];
} }
// This function produces Nb(Nr+1) round keys. The round keys are used in each round to decrypt the states. // This function produces Nb(Nr+1) round keys. The round keys are used in each round to decrypt the states.
static void KeyExpansion() static void KeyExpansion()
{ {
uint8_t i, j, k; uint8_t i, j, k;
uint8_t tempa[4]; // used for the column/row operations uint8_t tempa[4]; // used for the column/row operations
// The first round key is the key itself. // The first round key is the key itself.
for(i = 0; i < Nk; ++i) for(i = 0; i < Nk; ++i)
{ {
RoundKey[ i * 4 ] = Key[ i * 4 ]; RoundKey[ i * 4 ] = Key[ i * 4 ];
RoundKey[(i * 4) + 1] = Key[(i * 4) + 1]; RoundKey[(i * 4) + 1] = Key[(i * 4) + 1];
RoundKey[(i * 4) + 2] = Key[(i * 4) + 2]; RoundKey[(i * 4) + 2] = Key[(i * 4) + 2];
RoundKey[(i * 4) + 3] = Key[(i * 4) + 3]; RoundKey[(i * 4) + 3] = Key[(i * 4) + 3];
} }
// All other round keys are found from the previous round keys. // All other round keys are found from the previous round keys.
for(; (i < (Nb * Nr) + 1); ++i) for(; (i < (Nb * Nr) + 1); ++i)
{ {
for(j = 0; j < 4; ++j) for(j = 0; j < 4; ++j)
{ {
tempa[j]=RoundKey[(i-1) * 4 + j]; tempa[j]=RoundKey[(i-1) * 4 + j];
} }
if (i % Nk == 0) if (i % Nk == 0)
{ {
// This function rotates the 4 bytes in a word to the left once. // This function rotates the 4 bytes in a word to the left once.
// [a0,a1,a2,a3] becomes [a1,a2,a3,a0] // [a0,a1,a2,a3] becomes [a1,a2,a3,a0]
// Function RotWord() // Function RotWord()
{ {
k = tempa[0]; k = tempa[0];
tempa[0] = tempa[1]; tempa[0] = tempa[1];
tempa[1] = tempa[2]; tempa[1] = tempa[2];
tempa[2] = tempa[3]; tempa[2] = tempa[3];
tempa[3] = k; tempa[3] = k;
} }
// SubWord() is a function that takes a four-byte input word and // SubWord() is a function that takes a four-byte input word and
// applies the S-box to each of the four bytes to produce an output word. // applies the S-box to each of the four bytes to produce an output word.
// Function Subword() // Function Subword()
{ {
tempa[0] = getSBoxValue(tempa[0]); tempa[0] = getSBoxValue(tempa[0]);
tempa[1] = getSBoxValue(tempa[1]); tempa[1] = getSBoxValue(tempa[1]);
tempa[2] = getSBoxValue(tempa[2]); tempa[2] = getSBoxValue(tempa[2]);
tempa[3] = getSBoxValue(tempa[3]); tempa[3] = getSBoxValue(tempa[3]);
} }
tempa[0] = tempa[0] ^ Rcon[i/Nk]; tempa[0] = tempa[0] ^ Rcon[i/Nk];
} }
else if (Nk > 6 && i % Nk == 4) else if (Nk > 6 && i % Nk == 4)
{ {
// Function Subword() // Function Subword()
{ {
tempa[0] = getSBoxValue(tempa[0]); tempa[0] = getSBoxValue(tempa[0]);
tempa[1] = getSBoxValue(tempa[1]); tempa[1] = getSBoxValue(tempa[1]);
tempa[2] = getSBoxValue(tempa[2]); tempa[2] = getSBoxValue(tempa[2]);
tempa[3] = getSBoxValue(tempa[3]); tempa[3] = getSBoxValue(tempa[3]);
} }
} }
RoundKey[ i * 4 ] = RoundKey[ i - Nk * 4 ] ^ tempa[0]; RoundKey[ i * 4 ] = RoundKey[ i - Nk * 4 ] ^ tempa[0];
RoundKey[(i * 4) + 1] = RoundKey[(i - Nk) * (4 + 1)] ^ tempa[1]; RoundKey[(i * 4) + 1] = RoundKey[(i - Nk) * (4 + 1)] ^ tempa[1];
RoundKey[(i * 4) + 2] = RoundKey[(i - Nk) * (4 + 2)] ^ tempa[2]; RoundKey[(i * 4) + 2] = RoundKey[(i - Nk) * (4 + 2)] ^ tempa[2];
RoundKey[(i * 4) + 3] = RoundKey[(i - Nk) * (4 + 3)] ^ tempa[3]; RoundKey[(i * 4) + 3] = RoundKey[(i - Nk) * (4 + 3)] ^ tempa[3];
} }
} }
// This function adds the round key to state. // This function adds the round key to state.
// The round key is added to the state by an XOR function. // The round key is added to the state by an XOR function.
static void AddRoundKey(uint8_t round) static void AddRoundKey(uint8_t round)
{ {
uint8_t i,j; uint8_t i,j;
for(i=0;i<4;i++) for(i=0;i<4;i++)
{ {
for(j = 0; j < 4; ++j) for(j = 0; j < 4; ++j)
{ {
state[j][i] ^= RoundKey[round * Nb * 4 + i * Nb + j]; state[j][i] ^= RoundKey[round * Nb * 4 + i * Nb + j];
} }
} }
} }
// The SubBytes Function Substitutes the values in the // The SubBytes Function Substitutes the values in the
// state matrix with values in an S-box. // state matrix with values in an S-box.
static void SubBytes() static void SubBytes()
{ {
uint8_t i, j; uint8_t i, j;
for(i = 0; i < 4; ++i) for(i = 0; i < 4; ++i)
{ {
for(j = 0; j < 4; ++j) for(j = 0; j < 4; ++j)
{ {
state[i][j] = getSBoxValue(state[i][j]); state[i][j] = getSBoxValue(state[i][j]);
} }
} }
} }
// The ShiftRows() function shifts the rows in the state to the left. // The ShiftRows() function shifts the rows in the state to the left.
...@@ -222,97 +222,97 @@ static void SubBytes() ...@@ -222,97 +222,97 @@ static void SubBytes()
// Offset = Row number. So the first row is not shifted. // Offset = Row number. So the first row is not shifted.
static void ShiftRows() static void ShiftRows()
{ {
uint8_t temp; uint8_t temp;
// Rotate first row 1 columns to left // Rotate first row 1 columns to left
temp = state[1][0]; temp = state[1][0];
state[1][0] = state[1][1]; state[1][0] = state[1][1];
state[1][1] = state[1][2]; state[1][1] = state[1][2];
state[1][2] = state[1][3]; state[1][2] = state[1][3];
state[1][3] = temp; state[1][3] = temp;
// Rotate second row 2 columns to left // Rotate second row 2 columns to left
temp = state[2][0]; temp = state[2][0];
state[2][0] = state[2][2]; state[2][0] = state[2][2];
state[2][2] = temp; state[2][2] = temp;
temp = state[2][1]; temp = state[2][1];
state[2][1] = state[2][3]; state[2][1] = state[2][3];
state[2][3] = temp; state[2][3] = temp;
// Rotate third row 3 columns to left // Rotate third row 3 columns to left
temp = state[3][0]; temp = state[3][0];
state[3][0] = state[3][3]; state[3][0] = state[3][3];
state[3][3] = state[3][2]; state[3][3] = state[3][2];
state[3][2] = state[3][1]; state[3][2] = state[3][1];
state[3][1] = temp; state[3][1] = temp;
} }
static uint8_t xtime(uint8_t x) static uint8_t xtime(uint8_t x)
{ {
return ((x<<1) ^ (((x>>7) & 1) * 0x1b)); return ((x<<1) ^ (((x>>7) & 1) * 0x1b));
} }
// MixColumns function mixes the columns of the state matrix // MixColumns function mixes the columns of the state matrix
static void MixColumns() static void MixColumns()
{ {
uint8_t i; uint8_t i;
uint8_t Tmp,Tm,t; uint8_t Tmp,Tm,t;
for(i = 0; i < 4; ++i) for(i = 0; i < 4; ++i)
{ {
t = state[0][i]; t = state[0][i];
Tmp = state[0][i] ^ state[1][i] ^ state[2][i] ^ state[3][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[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[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[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 ; Tm = state[3][i] ^ t ; Tm = xtime(Tm); state[3][i] ^= Tm ^ Tmp ;
} }
} }
// Cipher is the main function that encrypts the PlainText. // Cipher is the main function that encrypts the PlainText.
static void Cipher() static void Cipher()
{ {
uint8_t i, j, round = 0; uint8_t i, j, round = 0;
//Copy the input PlainText to state array. //Copy the input PlainText to state array.
for(i = 0; i < 4; ++i) for(i = 0; i < 4; ++i)
{ {
for(j = 0; j < 4 ; ++j) for(j = 0; j < 4 ; ++j)
{ {
state[j][i] = in[(i * 4) + j]; state[j][i] = in[(i * 4) + j];
} }
} }
// Add the First round key to the state before starting the rounds. // Add the First round key to the state before starting the rounds.
AddRoundKey(0); AddRoundKey(0);
// There will be Nr rounds. // There will be Nr rounds.
// The first Nr-1 rounds are identical. // The first Nr-1 rounds are identical.
// These Nr-1 rounds are executed in the loop below. // These Nr-1 rounds are executed in the loop below.
for(round = 1; round < Nr; ++round) for(round = 1; round < Nr; ++round)
{ {
SubBytes(); SubBytes();
ShiftRows(); ShiftRows();
MixColumns(); MixColumns();
AddRoundKey(round); AddRoundKey(round);
} }
// The last round is given below. // The last round is given below.
// The MixColumns function is not here in the last round. // The MixColumns function is not here in the last round.
SubBytes(); SubBytes();
ShiftRows(); ShiftRows();
AddRoundKey(Nr); AddRoundKey(Nr);
// The encryption process is over. // The encryption process is over.
// Copy the state array to output array. // Copy the state array to output array.
for(i = 0; i < 4; ++i) for(i = 0; i < 4; ++i)
{ {
for(j = 0; j < 4; ++j) for(j = 0; j < 4; ++j)
{ {
out[(i * 4) + j] = state[j][i]; out[(i * 4) + j] = state[j][i];
} }
} }
} }
...@@ -322,16 +322,16 @@ static void Cipher() ...@@ -322,16 +322,16 @@ static void Cipher()
void AES128_ECB(uint8_t* input, uint8_t* key, uint8_t *output) void AES128_ECB(uint8_t* input, uint8_t* key, uint8_t *output)
{ {
// Copy the Key and CipherText // Copy the Key and CipherText
Key = key; Key = key;
in = input; in = input;
out = output; out = output;
// The KeyExpansion routine must be called before encryption. // The KeyExpansion routine must be called before encryption.
KeyExpansion(); KeyExpansion();
// The next function call encrypts the PlainText with the Key using AES algorithm. // The next function call encrypts the PlainText with the Key using AES algorithm.
Cipher(); Cipher();
} }
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment