static unsigned char *KeyExpansion(unsigned char *key, unsigned char *w, int klen)
{
unsigned char temp[4];
int i, j, i4, j4, r;
r = 4 * (klen + 7);
for (i = 0, j = 0; i < klen; i++, j += 4) {
memcpy(&w[i * 4], &key[j], 4);
}
while (i < r) {
memcpy(&temp, &w[(i - 1) * 4], 4);
if (i % klen == 0) {
SubWord(RotWord(temp));
temp[0] ^= Rcon[i/klen];
}
else if (klen > 6 && i % klen == 4) {
SubWord(temp);
}
j = i - klen;
i4 = i * 4;
j4 = j * 4;
w[i4 ] = w[j4 ] ^ temp[0];
w[i4 + 1] = w[j4 + 1] ^ temp[1];
w[i4 + 2] = w[j4 + 2] ^ temp[2];
w[i4 + 3] = w[j4 + 3] ^ temp[3];
i++;
}
return w;
}
void KeyExpansion(uint8_t* key, uint32_t* key_schedule, uint8_t Nk)
{
uint32_t temp;
uint8_t i = 0;
for (; i < Nk; i++) {
key_schedule[i] = word(key[4 * i], key[(4 * i) + 1], key[(4 * i) + 2], key[(4 * i) + 3]);
}
i = Nk;
// 4 is Nb
// 10 is Nr
// TODO figure out Nr based on Nk
for (; i < (4 * (10 + 1)); i++) {
temp = key_schedule[i-1];
if ((i % Nk) == 0) {
RotWord(temp);
SubWord(temp);
temp ^= Rcon[i/Nk];
}
else if ((Nk > 6) && ((i % Nk) == 4)) {
SubWord(temp);
}
key_schedule[i] = key_schedule[i-1] ^ temp;
}
}
void KeyExpansion(unsigned int* key, unsigned int* w, int round){
int i=4;
int temp=0;
memcpy(key,w,sizeof(unsigned int)*4);
while(i<4*(round+1)){
temp=key[i-1];
if(i%4==0){
temp=SubWord(RotWord(temp));
temp=temp ^ Rcon[i/4];
}
key[i]=temp ^ key[i-4];
i++;
}
}
static void doKeyExpand(char *key, unsigned char **word) {
int i;
int Nk = 4, Nr = 10, Nb = 4;
for (i = 0; i < Nk; i++) {
populateWord(word[i], key, i);
}
unsigned char *temp = (unsigned char *) malloc(sizeof(unsigned char) * 4);
for (i = Nk; i < (Nb * (Nr + 1)); i++) {
memcpy(temp, word[i - 1], 4);
if ((i % Nk) == 0) {
RotWord(temp);
SubWord(temp);
addRoundConstant(temp, (i / Nk));
}
calXOR(word[i], word[i - Nk], temp);
}
}
void *
AES_Init(u1 *key, int Nk)
{
AES_CTX *ctx;
char Nr;
u4 *w;
static u1 Rcon[] = { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36 };
switch(Nk) {
case 4:
Nr = 10;
break;
case 6:
Nr = 12;
break;
case 8:
Nr = 14;
break;
}
ctx = MALLOC(sizeof(AES_CTX) + sizeof(u4) * Nb * (Nr + 1) - sizeof(u4));
if(ctx) {
u4 temp;
int i;
ctx->Nr = Nr;
w = ctx->W;
for(i = 0;i < Nk;i++)
w[i] = MkWord(key[4*i], key[4*i+1], key[4*i+2], key[4*i+3]);
for(i = Nk;i < Nb * (Nr + 1);i++) {
temp = w[i-1];
if((i % Nk) == 0) {
temp = RotWord(temp);
temp = SubWord(temp);
temp = temp ^ Rcon[i/Nk - 1];
}
else if(Nk > 6 && (i % Nk) == 4)
temp = SubWord(temp);
w[i] = w[i-Nk] ^ temp;
}
}
return(ctx);
}
void KeyExpansion(ctx_aes* aes)
{
int row;
uint8_t temp[4];
uint8_t result[4],result2[4];
memset(aes->w,0,16*15);
for (row = 0; row < aes->Nk; row++)//Nk=4,6,8
{
aes->w[4*row+0] = aes->key[4*row];
aes->w[4*row+1] = aes->key[4*row+1];
aes->w[4*row+2] = aes->key[4*row+2];
aes->w[4*row+3] = aes->key[4*row+3];
}
for (row = aes->Nk; row < aes->Nb * (aes->Nr+1); row++)
{
temp[0] = aes->w[4*(row-1)+0];
temp[1] = aes->w[4*(row-1)+1];
temp[2] = aes->w[4*(row-1)+2];
temp[3] = aes->w[4*(row-1)+3];
if (row % aes->Nk == 0)
{
RotWord(temp,result);
SubWord(result,result2);
memcpy(temp,result2,4);//
temp[0] = (unsigned char)( (int)temp[0] ^ (int) Rcon[4*(row/aes->Nk)+0] );
temp[1] = (unsigned char)( (int)temp[1] ^ (int) Rcon[4*(row/aes->Nk)+1] );
temp[2] = (unsigned char)( (int)temp[2] ^ (int) Rcon[4*(row/aes->Nk)+2] );
temp[3] = (unsigned char)( (int)temp[3] ^ (int) Rcon[4*(row/aes->Nk)+3] );
}
else if ( aes->Nk > 6 && (row % aes->Nk == 4) )
{
SubWord(temp,result);
memcpy(temp,result,4);
}
// w[row] = w[row-Nk] xor temp
aes->w[4*row+0] = (unsigned char)( (int) aes->w[4*(row-aes->Nk)+0] ^ (int)temp[0] );
aes->w[4*row+1] = (unsigned char)( (int) aes->w[4*(row-aes->Nk)+1] ^ (int)temp[1] );
aes->w[4*row+2] = (unsigned char)( (int) aes->w[4*(row-aes->Nk)+2] ^ (int)temp[2] );
aes->w[4*row+3] = (unsigned char)( (int) aes->w[4*(row-aes->Nk)+3] ^ (int)temp[3] );
} // for loop
} // KeyExpansion()
void KeyExpansion()
{
unsigned char result[4],result2[4];
int row;
unsigned char temp[4];
memset(w,0,16*15);
for (row = 0; row < Nk; row++)//Nk=4,6,8
{
w[4*row+0] = key[4*row];
w[4*row+1] = key[4*row+1];
w[4*row+2] = key[4*row+2];
w[4*row+3] = key[4*row+3];
}
for (row = Nk; row < Nb * (Nr+1); row++)
{
temp[0] = w[4*(row-1)+0];
temp[1] = w[4*(row-1)+1];
temp[2] = w[4*(row-1)+2];
temp[3] = w[4*(row-1)+3];
if (row % Nk == 0)
{
RotWord(temp,result);
SubWord(result,result2);
memcpy(temp,result2,4);//
temp[0] = (byte)( (int)temp[0] ^ (int) Rcon[4*(row/Nk)+0] );
temp[1] = (byte)( (int)temp[1] ^ (int) Rcon[4*(row/Nk)+1] );
temp[2] = (byte)( (int)temp[2] ^ (int) Rcon[4*(row/Nk)+2] );
temp[3] = (byte)( (int)temp[3] ^ (int) Rcon[4*(row/Nk)+3] );
}
else if ( Nk > 6 && (row % Nk == 4) )
{
SubWord(temp,result);
memcpy(temp,result,4);
}
// w[row] = w[row-Nk] xor temp
w[4*row+0] = (byte) ( (int) w[4*(row-Nk)+0] ^ (int)temp[0] );
w[4*row+1] = (byte) ( (int) w[4*(row-Nk)+1] ^ (int)temp[1] );
w[4*row+2] = (byte) ( (int) w[4*(row-Nk)+2] ^ (int)temp[2] );
w[4*row+3] = (byte) ( (int) w[4*(row-Nk)+3] ^ (int)temp[3] );
} // for loop
} // KeyExpansion()
void ExpansionCle(char cle[], char unsigned cleEtendue[TAILLEMATRICE*(NBROUND+1)][TAILLEMATRICE]){
int caractere, round, ligne;
unsigned char wMoinsUn[TAILLEMATRICE][TAILLEMATRICE]={0};
unsigned char wMoinsQuatre[TAILLEMATRICE];
memset(cleEtendue, 0, TAILLEMATRICE*NBROUND);
for (caractere=0; caractere<strlen(cle); caractere++){
cleEtendue[(caractere/TAILLEMATRICE)%TAILLEMATRICE][caractere%TAILLEMATRICE]=cle[caractere];
}
for(round=1; round<=NBROUND*TAILLEMATRICE; round++){
for(ligne=0; ligne<TAILLEMATRICE; ligne++){
wMoinsQuatre[ligne]=cleEtendue[(round+TAILLEMATRICE-1)-4][ligne];
wMoinsUn[1][ligne]=cleEtendue[(round+TAILLEMATRICE-1)-1][ligne];
}
if((round-1)%TAILLEMATRICE==0){
RotWord(wMoinsUn);
SubBytes(wMoinsUn);
}
for(ligne=0; ligne<TAILLEMATRICE; ligne++){
cleEtendue[TAILLEMATRICE+round-1][ligne]=wMoinsQuatre[ligne]^wMoinsUn[1][ligne];
if((round-1)%TAILLEMATRICE==0){ (cleEtendue[TAILLEMATRICE+round-1][ligne])^=(Rcon[((round-1)/4)][ligne]);}
}
}
}
void KeyExpansion(void) {
uint8_t temp[4];
memcpy(w[0], &cipher_key[0], 4);
memcpy(w[1], &cipher_key[4], 4);
memcpy(w[2], &cipher_key[8], 4);
memcpy(w[3], &cipher_key[12], 4);
for (int i = 4; i < 44; ++i) {
memcpy(temp, w[i - 1], 4);
if ((i & (4 - 1)) == 0) {
RotWord(temp);
SubWord(temp);
temp[0] ^= Rcon[i >> 2];
}
w[i][0] = w[i - 4][0] ^ temp[0];
w[i][1] = w[i - 4][1] ^ temp[1];
w[i][2] = w[i - 4][2] ^ temp[2];
w[i][3] = w[i - 4][3] ^ temp[3];
}
static void InvShiftRows(unsigned char **state) {
int i, j;
for (i = 3; i >= 0; i--)
for (j = 3; j >= i; j--)
RotWord(state[i]);
}
static void ShiftRows(unsigned char **state) {
int i, j;
for (i = 0; i < 4; i++)
for (j = 0; j < i; j++)
RotWord(state[i]);
}
