/*******************************************************************************
* Function Name : AES_keyschedule_enc
* Description : According to key, computes the expanded key (expkey) for AES128
* encryption.
* Input : key: user key
* Output : expkey: expanded key
* Return : None
*******************************************************************************/
void AES_keyschedule_enc(u32* key, u32* expkey)
{
register u32* local_pointer = expkey;
register int i = 0;
register u32 copy0;
register u32 copy1;
register u32 copy2;
register u32 copy3;
copy0 = key[0];
copy1 = key[1];
copy2 = key[2];
copy3 = key[3];
local_pointer[0] = copy0;
local_pointer[1] = copy1;
local_pointer[2] = copy2;
local_pointer[3] = copy3;
for (;i < 10;)
{
copy0 ^= WORD8_TO_WORD32( Sbox[byte1(copy3)],
Sbox[byte2(copy3)],
Sbox[byte3(copy3)],
Sbox[byte0(copy3)]) ^ rcon[i++];
copy1 ^= copy0;
copy2 ^= copy1;
copy3 ^= copy2;
local_pointer += 4;
local_pointer[0] = copy0;
local_pointer[1] = copy1;
local_pointer[2] = copy2;
local_pointer[3] = copy3;
}
}
/*******************************************************************************
* Function Name : AES_expand_enckey
* Description : According to key computes the expanded key exp for AES128
* encryption.
* Input : key: user key (128 bits / 16 bytes)
* Output : expkey: expanded key (352 bits / 44 bytes)
* Return : None
*******************************************************************************/
void AES_expand_enckey(ot_u32* key, ot_u32* expkey) {
#if (AES_USEHW)
platform_expand_enckey(key, expkey);
#elif ((AES_USEFAST == ENABLED) || (AES_USELITE == ENABLED))
register ot_u32* local_pointer = expkey;
register int i = 0;
register ot_u32 copy0;
register ot_u32 copy1;
register ot_u32 copy2;
register ot_u32 copy3;
copy0 = key[0];
copy1 = key[1];
copy2 = key[2];
copy3 = key[3];
local_pointer[0] = copy0;
local_pointer[1] = copy1;
local_pointer[2] = copy2;
local_pointer[3] = copy3;
for (;i <10;) {
copy0 ^= WORD8_TO_WORD32( Sbox[byte1(copy3)],
Sbox[byte2(copy3)],
Sbox[byte3(copy3)],
Sbox[byte0(copy3)]) ^ rcon[i++];
copy1 ^= copy0;
copy2 ^= copy1;
copy3 ^= copy2;
local_pointer += 4;
local_pointer[0] = copy0;
local_pointer[1] = copy1;
local_pointer[2] = copy2;
local_pointer[3] = copy3;
}
#endif
}
/*******************************************************************************
* Function Name : AES_decrypt
* Description : Decrypts one block of 16 bytes
* Input : - input_pointer: input block address
* - expkey: decryption key
* Output : output_pointer: output block address
* Return : None
*******************************************************************************/
void AES_decrypt(u8* input_pointer, u32* output_pointer, u32* expkey)
{
register u32 s0;
register u32 s1;
register u32 s2;
register u32 s3;
register u32 t0;
register u32 t1;
register u32 t2;
register u32 t3;
register int r = 10 >> 1;
register u32* local_pointer = expkey + (40);
//added ***
register u32 copy0;
register u32 copy1;
register u32 copy2;
register u32 copy3;
copy0 = *input_pointer;
copy0 =copy0<<8;
copy0 |= *(input_pointer+1);
copy0 =copy0<<8;
copy0 |= *(input_pointer+2);
copy0 =copy0<<8;
copy0 |= *(input_pointer+3);
copy1 = *(input_pointer+4);
copy1 =copy1<<8;
copy1 |= *(input_pointer+5);
copy1 =copy1<<8;
copy1 |= *(input_pointer+6);
copy1 =copy1<<8;
copy1 |= *(input_pointer+7);
copy2 = *(input_pointer+8);
copy2 =copy2<<8;
copy2 |= *(input_pointer+9);
copy2 =copy2<<8;
copy2 |= *(input_pointer+10);
copy2 =copy2<<8;
copy2 |= *(input_pointer+11);
copy3 = *(input_pointer+12);
copy3 =copy3<<8;
copy3 |= *(input_pointer+13);
copy3 =copy3<<8;
copy3 |= *(input_pointer+14);
copy3 =copy3<<8;
copy3 |= *(input_pointer+15);
s0 = copy0^ local_pointer[0];
s1 = copy1 ^ local_pointer[1];
s2 = copy2 ^ local_pointer[2];
s3 = copy3 ^ local_pointer[3];
for (;;)
{
local_pointer -= 8;
t0 = dec_table[byte0(s0)] ^
rot1(dec_table[byte1(s3)]) ^
rot2(dec_table[byte2(s2)]) ^
rot3(dec_table[byte3(s1)]) ^
local_pointer[4];
t1 = dec_table[byte0(s1)] ^
rot1(dec_table[byte1(s0)]) ^
rot2(dec_table[byte2(s3)]) ^
rot3(dec_table[byte3(s2)]) ^
local_pointer[5];
t2 = dec_table[byte0(s2)] ^
rot1(dec_table[byte1(s1)]) ^
rot2(dec_table[byte2(s0)]) ^
rot3(dec_table[byte3(s3)]) ^
local_pointer[6];
t3 = dec_table[byte0(s3)] ^
rot1(dec_table[byte1(s2)]) ^
rot2(dec_table[byte2(s1)]) ^
rot3(dec_table[byte3(s0)]) ^
local_pointer[7];
if (--r == 0)
{
break;
}
s0 = dec_table[byte0(t0)] ^
rot1(dec_table[byte1(t3)]) ^
rot2(dec_table[byte2(t2)]) ^
rot3(dec_table[byte3(t1)]) ^
local_pointer[0];
s1 = dec_table[byte0(t1)] ^
rot1(dec_table[byte1(t0)]) ^
rot2(dec_table[byte2(t3)]) ^
rot3(dec_table[byte3(t2)]) ^
local_pointer[1];
s2 = dec_table[byte0(t2)] ^
rot1(dec_table[byte1(t1)]) ^
rot2(dec_table[byte2(t0)]) ^
rot3(dec_table[byte3(t3)]) ^
local_pointer[2];
s3 = dec_table[byte0(t3)] ^
rot1(dec_table[byte1(t2)]) ^
rot2(dec_table[byte2(t1)]) ^
rot3(dec_table[byte3(t0)]) ^
local_pointer[3];
}
output_pointer[0] = WORD8_TO_WORD32( InvSbox[byte0(t0)],
InvSbox[byte1(t3)],
InvSbox[byte2(t2)],
InvSbox[byte3(t1)]) ^ local_pointer[0];
output_pointer[1] = WORD8_TO_WORD32( InvSbox[byte0(t1)],
InvSbox[byte1(t0)],
InvSbox[byte2(t3)],
InvSbox[byte3(t2)]) ^ local_pointer[1];
output_pointer[2] = WORD8_TO_WORD32( InvSbox[byte0(t2)],
InvSbox[byte1(t1)],
InvSbox[byte2(t0)],
InvSbox[byte3(t3)]) ^ local_pointer[2];
output_pointer[3] = WORD8_TO_WORD32( InvSbox[byte0(t3)],
InvSbox[byte1(t2)],
InvSbox[byte2(t1)],
InvSbox[byte3(t0)]) ^ local_pointer[3];
}
/*******************************************************************************
* Function Name : AES_keyschedule_enc
* Description : According to key computes the expanded key exp for AES128
* encryption.
* Input : key: user key
* Output : expkey: expanded key
* Return : None
*******************************************************************************/
void AES_keyschedule_enc(u8* key, u32* expkey)
{
register u32* local_pointer = expkey;
register int i = 0;
register u32 copy0;
register u32 copy1;
register u32 copy2;
register u32 copy3;
copy0 = *key;
copy0 =copy0<<8;
copy0 |= *(key+1);
copy0 =copy0<<8;
copy0 |= *(key+2);
copy0 =copy0<<8;
copy0 |= *(key+3);
copy1 = *(key+4);
copy1 =copy1<<8;
copy1 |= *(key+5);
copy1 =copy1<<8;
copy1 |= *(key+6);
copy1 =copy1<<8;
copy1 |= *(key+7);
copy2 = *(key+8);
copy2 =copy2<<8;
copy2 |= *(key+9);
copy2 =copy2<<8;
copy2 |= *(key+10);
copy2 =copy2<<8;
copy2 |= *(key+11);
copy3 = *(key+12);
copy3 =copy3<<8;
copy3 |= *(key+13);
copy3 =copy3<<8;
copy3 |= *(key+14);
copy3 =copy3<<8;
copy3 |= *(key+15);
// copy0 = key[0];
// copy1 = key[1];
// copy2 = key[2];
// copy3 = key[3];
local_pointer[0] = copy0;
local_pointer[1] = copy1;
local_pointer[2] = copy2;
local_pointer[3] = copy3;
for (;i < 10;)
{
copy0 ^= WORD8_TO_WORD32( Sbox[byte1(copy3)],
Sbox[byte2(copy3)],
Sbox[byte3(copy3)],
Sbox[byte0(copy3)]) ^ rcon[i++];
copy1 ^= copy0;
copy2 ^= copy1;
copy3 ^= copy2;
local_pointer += 4;
local_pointer[0] = copy0;
local_pointer[1] = copy1;
local_pointer[2] = copy2;
local_pointer[3] = copy3;
}
}
/*******************************************************************************
* Function Name : AES_encrypt
* Description : Encrypts one block of 16 bytes
* Input : - input_pointer: input block address
* - expkey: encryption key
* Output : output_pointer
* Return : None
*******************************************************************************/
void AES_encrypt(u32* input_pointer, u32* output_pointer, u32* expkey)
{
register u32 t0;
register u32 t1;
register u32 t2;
register u32 t3;
register u32 s0;
register u32 s1;
register u32 s2;
register u32 s3;
register int r = 10;/*Round counter */
register u32* local_pointer = expkey;
s0 = input_pointer[0] ^ local_pointer[0];
s1 = input_pointer[1] ^ local_pointer[1];
s2 = input_pointer[2] ^ local_pointer[2];
s3 = input_pointer[3] ^ local_pointer[3];
local_pointer += 4;
/* ADD KEY before start round*/
for (;;)
{
t0 = WORD8_TO_WORD32( Sbox[byte0(s0)],
Sbox[byte1(s1)],
Sbox[byte2(s2)],
Sbox[byte3(s3)]);
t1 = WORD8_TO_WORD32( Sbox[byte0(s1)],
Sbox[byte1(s2)],
Sbox[byte2(s3)],
Sbox[byte3(s0)]);
t2 = WORD8_TO_WORD32( Sbox[byte0(s2)],
Sbox[byte1(s3)],
Sbox[byte2(s0)],
Sbox[byte3(s1)]);
t3 = WORD8_TO_WORD32( Sbox[byte0(s3)],
Sbox[byte1(s0)],
Sbox[byte2(s1)],
Sbox[byte3(s2)]);
/*End of SBOX + Shift ROW*/
s0 = fwd_mcol(t0)^local_pointer[0];
s1 = fwd_mcol(t1)^local_pointer[1];
s2 = fwd_mcol(t2)^local_pointer[2];
s3 = fwd_mcol(t3)^local_pointer[3];
/*End of mix colomn*/
local_pointer += 4;
if ( --r == 1)
{
break;
}
}/*End for(;;)*/
/*Start Last round*/
t0 = WORD8_TO_WORD32( Sbox[byte0(s0)],
Sbox[byte1(s1)],
Sbox[byte2(s2)],
Sbox[byte3(s3)]);
t1 = WORD8_TO_WORD32( Sbox[byte0(s1)],
Sbox[byte1(s2)],
Sbox[byte2(s3)],
Sbox[byte3(s0)]);
t2 = WORD8_TO_WORD32( Sbox[byte0(s2)],
Sbox[byte1(s3)],
Sbox[byte2(s0)],
Sbox[byte3(s1)]);
t3 = WORD8_TO_WORD32( Sbox[byte0(s3)],
Sbox[byte1(s0)],
Sbox[byte2(s1)],
Sbox[byte3(s2)]);
t0 ^= local_pointer[0];
t1 ^= local_pointer[1];
t2 ^= local_pointer[2];
t3 ^= local_pointer[3];
/*Store of the result of encryption*/
output_pointer[0] = t0;
output_pointer[1] = t1;
output_pointer[2] = t2;
output_pointer[3] = t3;
}
/*******************************************************************************
* Function Name : AES_decrypt
* Description : Decrypts one block of 16 bytes
* Input : - input_pointer: input block address
* - expkey: decryption key
* Output : output_pointer: output block address
* Return : None
*******************************************************************************/
void AES_decrypt(u32* input_pointer, u32* output_pointer, u32* expkey)
{
/* Register: ask to the compiler to maintain this variable in the
processor's registers and don't store it in RAM */
register u32 t0;
register u32 t1;
register u32 t2;
register u32 t3;
register u32 s0;
register u32 s1;
register u32 s2;
register u32 s3;
register int r = 10; /* Count the round */
register u32* local_pointer = expkey;
u32 f2,f4,f8;
s0 = input_pointer[0] ^ local_pointer[0];
s1 = input_pointer[1] ^ local_pointer[1];
s2 = input_pointer[2] ^ local_pointer[2];
s3 = input_pointer[3] ^ local_pointer[3];
/* First add key: before start the rounds */
local_pointer += 4;
for (;;) /* Start round */
{
t0 = WORD8_TO_WORD32( InvSbox[byte0(s0)],
InvSbox[byte1(s3)],
InvSbox[byte2(s2)],
InvSbox[byte3(s1)]) ^ local_pointer[4];
t1 = WORD8_TO_WORD32( InvSbox[byte0(s1)],
InvSbox[byte1(s0)],
InvSbox[byte2(s3)],
InvSbox[byte3(s2)]) ^ local_pointer[5];
t2 = WORD8_TO_WORD32( InvSbox[byte0(s2)],
InvSbox[byte1(s1)],
InvSbox[byte2(s0)],
InvSbox[byte3(s3)]) ^ local_pointer[6];
t3 = WORD8_TO_WORD32( InvSbox[byte0(s3)],
InvSbox[byte1(s2)],
InvSbox[byte2(s1)],
InvSbox[byte3(s0)]) ^ local_pointer[7];
/*End of InvSbox, INVshiftRow, add key*/
s0=inv_mcol(t0);
s1=inv_mcol(t1);
s2=inv_mcol(t2);
s3=inv_mcol(t3);
/*End of INVMix column */
local_pointer += 4; /*Follow the key sheduler to choose the right round key*/
if (--r == 1)
{
break;
}
}/*End of round*/
/*Start last round :is the only one different from the other*/
t0 = WORD8_TO_WORD32( InvSbox[byte0(s0)],
InvSbox[byte1(s3)],
InvSbox[byte2(s2)],
InvSbox[byte3(s1)]) ^ local_pointer[4];
t1 = WORD8_TO_WORD32( InvSbox[byte0(s1)],
InvSbox[byte1(s0)],
InvSbox[byte2(s3)],
InvSbox[byte3(s2)]) ^ local_pointer[5];
t2 = WORD8_TO_WORD32( InvSbox[byte0(s2)],
InvSbox[byte1(s1)],
InvSbox[byte2(s0)],
InvSbox[byte3(s3)]) ^ local_pointer[6];
t3 = WORD8_TO_WORD32( InvSbox[byte0(s3)],
InvSbox[byte1(s2)],
InvSbox[byte2(s1)],
InvSbox[byte3(s0)]) ^ local_pointer[7];
output_pointer[0] = t0;
output_pointer[1] = t1;
output_pointer[2] = t2;
output_pointer[3] = t3;
}
/*******************************************************************************
* Function Name : AES_decrypt
* Description : Decrypts one block of 16 bytes
* Input : - input_pointer: input block address
* - expkey: decryption key
* Output : output_pointer: output block address
* Return : None
*******************************************************************************/
void AES_decrypt(ot_u32* input_pointer, ot_u32* output_pointer, ot_u32* expkey) {
#if (AES_USEHW == ENABLED)
#elif (AES_USEFAST == ENABLED)
register ot_u32 s0;
register ot_u32 s1;
register ot_u32 s2;
register ot_u32 s3;
register ot_u32 t0;
register ot_u32 t1;
register ot_u32 t2;
register ot_u32 t3;
register int r = 10 >> 1;
register ot_u32* local_pointer = expkey + (40);
s0 = input_pointer[0] ^ local_pointer[0];
s1 = input_pointer[1] ^ local_pointer[1];
s2 = input_pointer[2] ^ local_pointer[2];
s3 = input_pointer[3] ^ local_pointer[3];
for (;;)
{
local_pointer -= 8;
t0 = dec_table[byte0(s0)] ^
rot1(dec_table[byte1(s3)]) ^
rot2(dec_table[byte2(s2)]) ^
rot3(dec_table[byte3(s1)]) ^
local_pointer[4];
t1 = dec_table[byte0(s1)] ^
rot1(dec_table[byte1(s0)]) ^
rot2(dec_table[byte2(s3)]) ^
rot3(dec_table[byte3(s2)]) ^
local_pointer[5];
t2 = dec_table[byte0(s2)] ^
rot1(dec_table[byte1(s1)]) ^
rot2(dec_table[byte2(s0)]) ^
rot3(dec_table[byte3(s3)]) ^
local_pointer[6];
t3 = dec_table[byte0(s3)] ^
rot1(dec_table[byte1(s2)]) ^
rot2(dec_table[byte2(s1)]) ^
rot3(dec_table[byte3(s0)]) ^
local_pointer[7];
if (--r == 0)
{
break;
}
s0 = dec_table[byte0(t0)] ^
rot1(dec_table[byte1(t3)]) ^
rot2(dec_table[byte2(t2)]) ^
rot3(dec_table[byte3(t1)]) ^
local_pointer[0];
s1 = dec_table[byte0(t1)] ^
rot1(dec_table[byte1(t0)]) ^
rot2(dec_table[byte2(t3)]) ^
rot3(dec_table[byte3(t2)]) ^
local_pointer[1];
s2 = dec_table[byte0(t2)] ^
rot1(dec_table[byte1(t1)]) ^
rot2(dec_table[byte2(t0)]) ^
rot3(dec_table[byte3(t3)]) ^
local_pointer[2];
s3 = dec_table[byte0(t3)] ^
rot1(dec_table[byte1(t2)]) ^
rot2(dec_table[byte2(t1)]) ^
rot3(dec_table[byte3(t0)]) ^
local_pointer[3];
}
output_pointer[0] = WORD8_TO_WORD32( InvSbox[byte0(t0)],
InvSbox[byte1(t3)],
InvSbox[byte2(t2)],
InvSbox[byte3(t1)]) ^ local_pointer[0];
output_pointer[1] = WORD8_TO_WORD32( InvSbox[byte0(t1)],
InvSbox[byte1(t0)],
InvSbox[byte2(t3)],
InvSbox[byte3(t2)]) ^ local_pointer[1];
output_pointer[2] = WORD8_TO_WORD32( InvSbox[byte0(t2)],
InvSbox[byte1(t1)],
InvSbox[byte2(t0)],
InvSbox[byte3(t3)]) ^ local_pointer[2];
output_pointer[3] = WORD8_TO_WORD32( InvSbox[byte0(t3)],
InvSbox[byte1(t2)],
InvSbox[byte2(t1)],
InvSbox[byte3(t0)]) ^ local_pointer[3];
#elif (AES_USELITE == ENABLED)
/* Register: ask to the compiler to maintain this variable in the
processor's registers and don't store it in RAM */
register ot_u32 t0;
register ot_u32 t1;
register ot_u32 t2;
register ot_u32 t3;
register ot_u32 s0;
register ot_u32 s1;
register ot_u32 s2;
register ot_u32 s3;
register int r = 10; /* Count the round */
register ot_u32* local_pointer = expkey + 40;
ot_u32 f2,f4,f8;
s0 = input_pointer[0] ^ local_pointer[0];
s1 = input_pointer[1] ^ local_pointer[1];
s2 = input_pointer[2] ^ local_pointer[2];
s3 = input_pointer[3] ^ local_pointer[3];
/* First add key: before start the rounds */
local_pointer -= 8;
for (;;) /* Start round */
{
t0 = WORD8_TO_WORD32( InvSbox[byte0(s0)],
InvSbox[byte1(s3)],
InvSbox[byte2(s2)],
InvSbox[byte3(s1)]) ^ local_pointer[4];
t1 = WORD8_TO_WORD32( InvSbox[byte0(s1)],
InvSbox[byte1(s0)],
InvSbox[byte2(s3)],
InvSbox[byte3(s2)]) ^ local_pointer[5];
t2 = WORD8_TO_WORD32( InvSbox[byte0(s2)],
InvSbox[byte1(s1)],
InvSbox[byte2(s0)],
InvSbox[byte3(s3)]) ^ local_pointer[6];
t3 = WORD8_TO_WORD32( InvSbox[byte0(s3)],
InvSbox[byte1(s2)],
InvSbox[byte2(s1)],
InvSbox[byte3(s0)]) ^ local_pointer[7];
/*End of InvSbox, INVshiftRow, add key*/
s0=inv_mcol(t0);
s1=inv_mcol(t1);
s2=inv_mcol(t2);
s3=inv_mcol(t3);
/*End of INVMix column */
local_pointer -= 4; /*Follow the key sheduler to choose the right round key*/
if (--r == 1)
{
break;
}
}/*End of round*/
/*Start last round :is the only one different from the other*/
t0 = WORD8_TO_WORD32( InvSbox[byte0(s0)],
InvSbox[byte1(s3)],
InvSbox[byte2(s2)],
InvSbox[byte3(s1)]) ^ local_pointer[4];
t1 = WORD8_TO_WORD32( InvSbox[byte0(s1)],
InvSbox[byte1(s0)],
InvSbox[byte2(s3)],
InvSbox[byte3(s2)]) ^ local_pointer[5];
t2 = WORD8_TO_WORD32( InvSbox[byte0(s2)],
InvSbox[byte1(s1)],
InvSbox[byte2(s0)],
InvSbox[byte3(s3)]) ^ local_pointer[6];
t3 = WORD8_TO_WORD32( InvSbox[byte0(s3)],
InvSbox[byte1(s2)],
InvSbox[byte2(s1)],
InvSbox[byte3(s0)]) ^ local_pointer[7];
output_pointer[0] = t0;
output_pointer[1] = t1;
output_pointer[2] = t2;
output_pointer[3] = t3;
#endif
}
/*******************************************************************************
* Function Name : AES_encrypt
* Description : Encrypts one block of 16 bytes
* Input : - input_pointer: input block address
* - expkey: encryption key
* Output : output_pointer
* Return : None
*******************************************************************************/
void AES_encrypt(ot_u32* input_pointer, ot_u32* output_pointer, ot_u32* expkey) {
#if (AES_USEHW == ENABLED)
#elif (AES_USEFAST == ENABLED)
register ot_u32 s0;
register ot_u32 s1;
register ot_u32 s2;
register ot_u32 s3;
register ot_u32 t0;
register ot_u32 t1;
register ot_u32 t2;
register ot_u32 t3;
register int r = 10 >> 1;
register ot_u32* local_pointer = expkey;
s0 = input_pointer[0] ^ local_pointer[0];
s1 = input_pointer[1] ^ local_pointer[1];
s2 = input_pointer[2] ^ local_pointer[2];
s3 = input_pointer[3] ^ local_pointer[3];
for (;;) {
t0 = enc_table[byte0(s0)] ^
rot1(enc_table[byte1(s1)]) ^
rot2(enc_table[byte2(s2)]) ^
rot3(enc_table[byte3(s3)]) ^
local_pointer[4];
t1 = enc_table[byte0(s1)] ^
rot1(enc_table[byte1(s2)]) ^
rot2(enc_table[byte2(s3)]) ^
rot3(enc_table[byte3(s0)]) ^
local_pointer[5];
t2 = enc_table[byte0(s2)] ^
rot1(enc_table[byte1(s3)]) ^
rot2(enc_table[byte2(s0)]) ^
rot3(enc_table[byte3(s1)]) ^
local_pointer[6];
t3 = enc_table[byte0(s3)] ^
rot1(enc_table[byte1(s0)]) ^
rot2(enc_table[byte2(s1)]) ^
rot3(enc_table[byte3(s2)]) ^
local_pointer[7];
local_pointer += 8;
if (--r == 0) {
break;
}
s0 = enc_table[byte0(t0)] ^
rot1(enc_table[byte1(t1)]) ^
rot2(enc_table[byte2(t2)]) ^
rot3(enc_table[byte3(t3)]) ^
local_pointer[0];
s1 = enc_table[byte0(t1)] ^
rot1(enc_table[byte1(t2)]) ^
rot2(enc_table[byte2(t3)]) ^
rot3(enc_table[byte3(t0)]) ^
local_pointer[1];
s2 = enc_table[byte0(t2)] ^
rot1(enc_table[byte1(t3)]) ^
rot2(enc_table[byte2(t0)]) ^
rot3(enc_table[byte3(t1)]) ^
local_pointer[2];
s3 = enc_table[byte0(t3)] ^
rot1(enc_table[byte1(t0)]) ^
rot2(enc_table[byte2(t1)]) ^
rot3(enc_table[byte3(t2)]) ^
local_pointer[3];
}
output_pointer[0] = WORD8_TO_WORD32( Sbox[byte0(t0)],
Sbox[byte1(t1)],
Sbox[byte2(t2)],
Sbox[byte3(t3)]) ^ local_pointer[0];
output_pointer[1] = WORD8_TO_WORD32( Sbox[byte0(t1)],
Sbox[byte1(t2)],
Sbox[byte2(t3)],
Sbox[byte3(t0)]) ^ local_pointer[1];
output_pointer[2] = WORD8_TO_WORD32( Sbox[byte0(t2)],
Sbox[byte1(t3)],
Sbox[byte2(t0)],
Sbox[byte3(t1)]) ^ local_pointer[2];
output_pointer[3] = WORD8_TO_WORD32( Sbox[byte0(t3)],
Sbox[byte1(t0)],
Sbox[byte2(t1)],
Sbox[byte3(t2)]) ^ local_pointer[3];
#elif (AES_USELITE == ENABLED)
register ot_u32 t0;
register ot_u32 t1;
register ot_u32 t2;
register ot_u32 t3;
register ot_u32 s0;
register ot_u32 s1;
register ot_u32 s2;
register ot_u32 s3;
register int r = 10; // Round counter
register ot_u32* local_pointer = expkey;
s0 = input_pointer[0] ^ local_pointer[0];
s1 = input_pointer[1] ^ local_pointer[1];
s2 = input_pointer[2] ^ local_pointer[2];
s3 = input_pointer[3] ^ local_pointer[3];
local_pointer += 4;
// ADD KEY before start round
for (;;)
{
t0 = WORD8_TO_WORD32( Sbox[byte0(s0)],
Sbox[byte1(s1)],
Sbox[byte2(s2)],
Sbox[byte3(s3)]);
t1 = WORD8_TO_WORD32( Sbox[byte0(s1)],
Sbox[byte1(s2)],
Sbox[byte2(s3)],
Sbox[byte3(s0)]);
t2 = WORD8_TO_WORD32( Sbox[byte0(s2)],
Sbox[byte1(s3)],
Sbox[byte2(s0)],
Sbox[byte3(s1)]);
t3 = WORD8_TO_WORD32( Sbox[byte0(s3)],
Sbox[byte1(s0)],
Sbox[byte2(s1)],
Sbox[byte3(s2)]);
/*End of SBOX + Shift ROW*/
s0 = fwd_mcol(t0)^local_pointer[0];
s1 = fwd_mcol(t1)^local_pointer[1];
s2 = fwd_mcol(t2)^local_pointer[2];
s3 = fwd_mcol(t3)^local_pointer[3];
/*End of mix colomn*/
local_pointer += 4;
if ( --r == 1)
{
break;
}
}/*End for(;;)*/
/*Start Last round*/
t0 = WORD8_TO_WORD32( Sbox[byte0(s0)],
Sbox[byte1(s1)],
Sbox[byte2(s2)],
Sbox[byte3(s3)]);
t1 = WORD8_TO_WORD32( Sbox[byte0(s1)],
Sbox[byte1(s2)],
Sbox[byte2(s3)],
Sbox[byte3(s0)]);
t2 = WORD8_TO_WORD32( Sbox[byte0(s2)],
Sbox[byte1(s3)],
Sbox[byte2(s0)],
Sbox[byte3(s1)]);
t3 = WORD8_TO_WORD32( Sbox[byte0(s3)],
Sbox[byte1(s0)],
Sbox[byte2(s1)],
Sbox[byte3(s2)]);
t0 ^= local_pointer[0];
t1 ^= local_pointer[1];
t2 ^= local_pointer[2];
t3 ^= local_pointer[3];
/*Store of the result of encryption*/
output_pointer[0] = t0;
output_pointer[1] = t1;
output_pointer[2] = t2;
output_pointer[3] = t3;
#endif
}
