/* crypto/rijndael/rijndael.c */

#include <openssl/evp.h>
#include "rijndael.h"
#include <openssl/opensslv.h>
#include "boxes-fst.dat"
#include <stdio.h>
#include <memory.h>

/*------------------------------------------------------------------------*/
const char *RIJNDAEL_version="Rijndael" OPENSSL_VERSION_PTEXT;
/*------------------------------------------------------------------------*/

/*------------------------------------------------------------------------*/
int rijndaelKeySched(word8 k[RIJNDAEL_MAXKC][4], word8 W[RIJNDAEL_MAXROUNDS+1][4][4], int ROUNDS) 
{
/* Calculate the necessary round keys
 * The number of calculations depends on keyBits and blockBits
 */ 
 int j, r, t, rconpointer = 0;
 word8 tk[RIJNDAEL_MAXKC][4];
 int KC = ROUNDS - 6;

 for (j = KC-1; j >= 0; j--) 
   {
    *((word32*)tk[j]) = *((word32*)k[j]);
   }
 r = 0;
 t = 0;
/* copy values into round key array */
 for (j = 0; (j < KC) && (r < ROUNDS + 1); ) 
   {
    for (; (j < KC) && (t < 4); j++, t++) 
      {
	*((word32*)W[r][t]) = *((word32*)tk[j]);
      }
    if (t == 4) 
      {
	r++;
	t = 0;
      }
   }
		
 while (r < ROUNDS + 1) 
   { /* while not enough round key material calculated */
     /* calculate new values */
     tk[0][0] ^= S[tk[KC-1][1]];
     tk[0][1] ^= S[tk[KC-1][2]];
     tk[0][2] ^= S[tk[KC-1][3]];
     tk[0][3] ^= S[tk[KC-1][0]];
     tk[0][0] ^= rcon[rconpointer++];
     if (KC != 8) 
	{
	 for (j = 1; j < KC; j++) 
 	  {
	    *((word32*)tk[j]) ^= *((word32*)tk[j-1]);
	  }
	} 
       else 
        {
	  for (j = 1; j < KC/2; j++) 
           {
	    *((word32*)tk[j]) ^= *((word32*)tk[j-1]);
	   }
	  tk[KC/2][0] ^= S[tk[KC/2 - 1][0]];
	  tk[KC/2][1] ^= S[tk[KC/2 - 1][1]];
	  tk[KC/2][2] ^= S[tk[KC/2 - 1][2]];
	  tk[KC/2][3] ^= S[tk[KC/2 - 1][3]];
	  for (j = KC/2 + 1; j < KC; j++) 
  	    {
	     *((word32*)tk[j]) ^= *((word32*)tk[j-1]);
	    }
	}
/* copy values into round key array */
     for (j = 0; (j < KC) && (r < ROUNDS + 1); ) 
        {
	 for (; (j < KC) && (t < 4); j++, t++) 
  	   {
	    *((word32*)W[r][t]) = *((word32*)tk[j]);
	   }
	 if (t == 4) 
	   {
	    r++;
	    t = 0;
	   }
	}
   }		
 return 0;
}
/*------------------------------------------------------------------------*/

/*------------------------------------------------------------------------*/
int rijndaelKeyEncToDec(word8 W[RIJNDAEL_MAXROUNDS+1][4][4], int ROUNDS) 
{
 int r;
 word8 *w;

 for (r = 1; r < ROUNDS; r++) 
   {
    w = W[r][0];
    *((word32*)w) = *((word32*)U1[w[0]]) ^ *((word32*)U2[w[1]])	^ *((word32*)U3[w[2]]) ^ *((word32*)U4[w[3]]);
    w = W[r][1];
    *((word32*)w) = *((word32*)U1[w[0]]) ^ *((word32*)U2[w[1]]) ^ *((word32*)U3[w[2]]) ^ *((word32*)U4[w[3]]);
    w = W[r][2];
    *((word32*)w) = *((word32*)U1[w[0]]) ^ *((word32*)U2[w[1]])	^ *((word32*)U3[w[2]]) ^ *((word32*)U4[w[3]]);
    w = W[r][3];
    *((word32*)w) = *((word32*)U1[w[0]]) ^ *((word32*)U2[w[1]])	^ *((word32*)U3[w[2]]) ^ *((word32*)U4[w[3]]);
   }
 return 0;
}	
/*------------------------------------------------------------------------*/

/*------------------------------------------------------------------------*/
/**
 * Encrypt a single block. 
 */
/*------------------------------------------------------------------------*/
int rijndaelEncrypt(word8 a[RIJNDAEL_BYTESPERBLOCK], word8 b[RIJNDAEL_BYTESPERBLOCK], word8 rk[RIJNDAEL_MAXROUNDS+1][4][4], int ROUNDS) 
{
 int r;
 word8 temp[4][4];

 *((word32*)temp[0]) = *((word32*)(a   )) ^ *((word32*)rk[0][0]);
 *((word32*)temp[1]) = *((word32*)(a+ 4)) ^ *((word32*)rk[0][1]);
 *((word32*)temp[2]) = *((word32*)(a+ 8)) ^ *((word32*)rk[0][2]);
 *((word32*)temp[3]) = *((word32*)(a+12)) ^ *((word32*)rk[0][3]);
 *((word32*)(b    )) = *((word32*)T1[temp[0][0]]) ^ *((word32*)T2[temp[1][1]]) ^ *((word32*)T3[temp[2][2]]) ^ *((word32*)T4[temp[3][3]]);
 *((word32*)(b + 4)) = *((word32*)T1[temp[1][0]]) ^ *((word32*)T2[temp[2][1]]) ^ *((word32*)T3[temp[3][2]]) ^ *((word32*)T4[temp[0][3]]);
 *((word32*)(b + 8)) = *((word32*)T1[temp[2][0]]) ^ *((word32*)T2[temp[3][1]]) ^ *((word32*)T3[temp[0][2]]) ^ *((word32*)T4[temp[1][3]]);
 *((word32*)(b +12)) = *((word32*)T1[temp[3][0]]) ^ *((word32*)T2[temp[0][1]]) ^ *((word32*)T3[temp[1][2]]) ^ *((word32*)T4[temp[2][3]]);
 for (r = 1; r < ROUNDS-1; r++) 
   {
    *((word32*)temp[0]) = *((word32*)(b   )) ^ *((word32*)rk[r][0]);
    *((word32*)temp[1]) = *((word32*)(b+ 4)) ^ *((word32*)rk[r][1]);
    *((word32*)temp[2]) = *((word32*)(b+ 8)) ^ *((word32*)rk[r][2]);
    *((word32*)temp[3]) = *((word32*)(b+12)) ^ *((word32*)rk[r][3]);
    *((word32*)(b    )) = *((word32*)T1[temp[0][0]]) ^ *((word32*)T2[temp[1][1]]) ^ *((word32*)T3[temp[2][2]]) ^ *((word32*)T4[temp[3][3]]);
    *((word32*)(b + 4)) = *((word32*)T1[temp[1][0]]) ^ *((word32*)T2[temp[2][1]]) ^ *((word32*)T3[temp[3][2]]) ^ *((word32*)T4[temp[0][3]]);
    *((word32*)(b + 8)) = *((word32*)T1[temp[2][0]]) ^ *((word32*)T2[temp[3][1]]) ^ *((word32*)T3[temp[0][2]]) ^ *((word32*)T4[temp[1][3]]);
    *((word32*)(b +12)) = *((word32*)T1[temp[3][0]]) ^ *((word32*)T2[temp[0][1]]) ^ *((word32*)T3[temp[1][2]]) ^ *((word32*)T4[temp[2][3]]);
   }
/* last round is special */   
 *((word32*)temp[0]) = *((word32*)(b   )) ^ *((word32*)rk[ROUNDS-1][0]);
 *((word32*)temp[1]) = *((word32*)(b+ 4)) ^ *((word32*)rk[ROUNDS-1][1]);
 *((word32*)temp[2]) = *((word32*)(b+ 8)) ^ *((word32*)rk[ROUNDS-1][2]);
 *((word32*)temp[3]) = *((word32*)(b+12)) ^ *((word32*)rk[ROUNDS-1][3]);
 b[ 0] = T1[temp[0][0]][1];
 b[ 1] = T1[temp[1][1]][1];
 b[ 2] = T1[temp[2][2]][1];
 b[ 3] = T1[temp[3][3]][1];
 b[ 4] = T1[temp[1][0]][1];
 b[ 5] = T1[temp[2][1]][1];
 b[ 6] = T1[temp[3][2]][1];
 b[ 7] = T1[temp[0][3]][1];
 b[ 8] = T1[temp[2][0]][1];
 b[ 9] = T1[temp[3][1]][1];
 b[10] = T1[temp[0][2]][1];
 b[11] = T1[temp[1][3]][1];
 b[12] = T1[temp[3][0]][1];
 b[13] = T1[temp[0][1]][1];
 b[14] = T1[temp[1][2]][1];
 b[15] = T1[temp[2][3]][1];
 *((word32*)(b   )) ^= *((word32*)rk[ROUNDS][0]);
 *((word32*)(b+ 4)) ^= *((word32*)rk[ROUNDS][1]);
 *((word32*)(b+ 8)) ^= *((word32*)rk[ROUNDS][2]);
 *((word32*)(b+12)) ^= *((word32*)rk[ROUNDS][3]);

 return 0;
}
/*------------------------------------------------------------------------*/


/*------------------------------------------------------------------------*/
/**
 * Decrypt a single block.
 */
/*------------------------------------------------------------------------*/
int rijndaelDecrypt(word8 a[RIJNDAEL_BYTESPERBLOCK], word8 b[RIJNDAEL_BYTESPERBLOCK], word8 rk[RIJNDAEL_MAXROUNDS+1][4][4], int ROUNDS) 
{
 int r;
 word8 temp[4][4];
	
 *((word32*)temp[0]) = *((word32*)(a   )) ^ *((word32*)rk[ROUNDS][0]);
 *((word32*)temp[1]) = *((word32*)(a+ 4)) ^ *((word32*)rk[ROUNDS][1]);
 *((word32*)temp[2]) = *((word32*)(a+ 8)) ^ *((word32*)rk[ROUNDS][2]);
 *((word32*)temp[3]) = *((word32*)(a+12)) ^ *((word32*)rk[ROUNDS][3]);

 *((word32*)(b   )) = *((word32*)T5[temp[0][0]]) ^ *((word32*)T6[temp[3][1]]) ^ *((word32*)T7[temp[2][2]]) ^ *((word32*)T8[temp[1][3]]);
 *((word32*)(b+ 4)) = *((word32*)T5[temp[1][0]]) ^ *((word32*)T6[temp[0][1]]) ^ *((word32*)T7[temp[3][2]]) ^ *((word32*)T8[temp[2][3]]);
 *((word32*)(b+ 8)) = *((word32*)T5[temp[2][0]]) ^ *((word32*)T6[temp[1][1]]) ^ *((word32*)T7[temp[0][2]]) ^ *((word32*)T8[temp[3][3]]);
 *((word32*)(b+12)) = *((word32*)T5[temp[3][0]]) ^ *((word32*)T6[temp[2][1]]) ^ *((word32*)T7[temp[1][2]]) ^ *((word32*)T8[temp[0][3]]);
 for (r = ROUNDS-1; r > 1; r--) 
   {
    *((word32*)temp[0]) = *((word32*)(b   )) ^ *((word32*)rk[r][0]);
    *((word32*)temp[1]) = *((word32*)(b+ 4)) ^ *((word32*)rk[r][1]);
    *((word32*)temp[2]) = *((word32*)(b+ 8)) ^ *((word32*)rk[r][2]);
    *((word32*)temp[3]) = *((word32*)(b+12)) ^ *((word32*)rk[r][3]);
    *((word32*)(b   )) = *((word32*)T5[temp[0][0]]) ^ *((word32*)T6[temp[3][1]]) ^ *((word32*)T7[temp[2][2]]) ^ *((word32*)T8[temp[1][3]]);
    *((word32*)(b+ 4)) = *((word32*)T5[temp[1][0]]) ^ *((word32*)T6[temp[0][1]]) ^ *((word32*)T7[temp[3][2]]) ^ *((word32*)T8[temp[2][3]]);
    *((word32*)(b+ 8)) = *((word32*)T5[temp[2][0]]) ^ *((word32*)T6[temp[1][1]]) ^ *((word32*)T7[temp[0][2]]) ^ *((word32*)T8[temp[3][3]]);
    *((word32*)(b+12)) = *((word32*)T5[temp[3][0]]) ^ *((word32*)T6[temp[2][1]]) ^ *((word32*)T7[temp[1][2]]) ^ *((word32*)T8[temp[0][3]]);
   }
/* last round is special */   
 *((word32*)temp[0]) = *((word32*)(b   )) ^ *((word32*)rk[1][0]);
 *((word32*)temp[1]) = *((word32*)(b+ 4)) ^ *((word32*)rk[1][1]);
 *((word32*)temp[2]) = *((word32*)(b+ 8)) ^ *((word32*)rk[1][2]);
 *((word32*)temp[3]) = *((word32*)(b+12)) ^ *((word32*)rk[1][3]);
 b[ 0] = S5[temp[0][0]];
 b[ 1] = S5[temp[3][1]];
 b[ 2] = S5[temp[2][2]];
 b[ 3] = S5[temp[1][3]];
 b[ 4] = S5[temp[1][0]];
 b[ 5] = S5[temp[0][1]];
 b[ 6] = S5[temp[3][2]];
 b[ 7] = S5[temp[2][3]];
 b[ 8] = S5[temp[2][0]];
 b[ 9] = S5[temp[1][1]];
 b[10] = S5[temp[0][2]];
 b[11] = S5[temp[3][3]];
 b[12] = S5[temp[3][0]];
 b[13] = S5[temp[2][1]];
 b[14] = S5[temp[1][2]];
 b[15] = S5[temp[0][3]];
 *((word32*)(b   )) ^= *((word32*)rk[0][0]);
 *((word32*)(b+ 4)) ^= *((word32*)rk[0][1]);
 *((word32*)(b+ 8)) ^= *((word32*)rk[0][2]);
 *((word32*)(b+12)) ^= *((word32*)rk[0][3]);
 return 0;
}
/*------------------------------------------------------------------------*/

/*------------------------------------------------------------------------*/
/* Fills key structure */
/*------------------------------------------------------------------------*/
int Rijndael_makeKey(Rijndael_key *key, BYTE direction, int keyLen, char *keyMaterial)
{
 word8 k[RIJNDAEL_MAXKC][4];
 int i;
 char *keyMat;
	
 if (key == NULL) 
   {
    return -1;
   }

 memset( key, 0, sizeof(Rijndael_key) );

 if ((direction == RIJNDAEL_ENCRYPT) || (direction == RIJNDAEL_DECRYPT)) 
   {
    key->direction = direction;
   } 
  else 
   {
    return -1;
   }

  if ((keyLen == 128) || (keyLen == 192) || (keyLen == 256)) 
   { 
    key->keyLen = keyLen;
   } 
  else 
   {
    return -1;
   }

  if (keyMaterial != NULL) 
   {
/*		strncpy(key->keyMaterial, keyMaterial, keyLen/4);
 Changed by RJS - What if there is a 0 in keyMaterial? */
     memcpy( key->keyMaterial, keyMaterial, keyLen/8 );
   }

 key->ROUNDS = keyLen/32 + 6;

/* initialize key schedule: */
 keyMat = key->keyMaterial;
 for (i = 0; i < key->keyLen/8; i++) 
   {
    k[i >> 2][i & 3] = (word8)keyMat[i]; 
   }
 rijndaelKeySched(k, key->keySched, key->ROUNDS);
 if (direction == RIJNDAEL_DECRYPT) 
  {
   rijndaelKeyEncToDec(key->keySched, key->ROUNDS);
  }
 return TRUE;
}
/*------------------------------------------------------------------------*/

/*------------------------------------------------------------------------*/
/* Initializes cipherInstance before encryption */
/*------------------------------------------------------------------------*/
/*
int Rijndael_Init(Rijndael_cipherInstance *cipher, char *IV)
{
 if (!cipher) return( -1 );
 memset( cipher, 0, sizeof(Rijndael_cipherInstance) );
 if (IV != NULL) 
   {
    memcpy(cipher->IV, IV, RIJNDAEL_MAX_IV_SIZE);
   } 
  else 
   {
    memset(cipher->IV, 0, RIJNDAEL_MAX_IV_SIZE);
   }
 cipher->blockLen=RIJNDAEL_BITSPERBLOCK;
 return TRUE;
}
*/
/*------------------------------------------------------------------------*/
/* Do Rijndael CBC type encryption - inputLen and outputLen in bits */
/*------------------------------------------------------------------------*/
int Rijndael_Encrypt_CBC( void *_ctx, BYTE *input, int inputLen, BYTE *outBuffer, int outputLen)
{
 int i, numBlocks;
 EVP_CIPHER_CTX *ctx=_ctx;
 Rijndael_key *key;
 word8 block[RIJNDAEL_BYTESPERBLOCK];

 if (ctx == NULL)
   {
    return -1;
   }

 key=&(ctx->c.rijndael_key);
 if (key->direction == RIJNDAEL_DECRYPT) 
   {
    return -1;
   }

 if (input == NULL || inputLen <= 0) 
   {
    return 0; /* nothing to do */
   }

 if (outputLen<inputLen) return( -1 );

 numBlocks = inputLen/RIJNDAEL_BITSPERBLOCK;
	
 ((word32*)block)[0] = ((word32*)ctx->iv)[0] ^ ((word32*)input)[0];
 ((word32*)block)[1] = ((word32*)ctx->iv)[1] ^ ((word32*)input)[1];
 ((word32*)block)[2] = ((word32*)ctx->iv)[2] ^ ((word32*)input)[2];
 ((word32*)block)[3] = ((word32*)ctx->iv)[3] ^ ((word32*)input)[3];
 rijndaelEncrypt(block, outBuffer, key->keySched, key->ROUNDS);
 input += RIJNDAEL_BYTESPERBLOCK;
 for (i = numBlocks - 1; i > 0; i--) 
   {
    ((word32*)block)[0] = ((word32*)outBuffer)[0] ^ ((word32*)input)[0];
    ((word32*)block)[1] = ((word32*)outBuffer)[1] ^ ((word32*)input)[1];
    ((word32*)block)[2] = ((word32*)outBuffer)[2] ^ ((word32*)input)[2];
    ((word32*)block)[3] = ((word32*)outBuffer)[3] ^ ((word32*)input)[3];
    outBuffer += RIJNDAEL_BYTESPERBLOCK;
    rijndaelEncrypt(block, outBuffer, key->keySched, key->ROUNDS);
    input += RIJNDAEL_BYTESPERBLOCK;
   }
 return RIJNDAEL_BITSPERBLOCK*numBlocks;
}
/*------------------------------------------------------------------------*/

/*------------------------------------------------------------------------*/
/* Do Rijndael ECB type encryption - inputLen and outputLen in bits */
/*------------------------------------------------------------------------*/
int Rijndael_Encrypt_ECB( void *_ctx, BYTE *input, int inputLen, BYTE *outBuffer, int outputLen)
{
 EVP_CIPHER_CTX *ctx=_ctx;
 int i, numBlocks;
 Rijndael_key *key;

 if (ctx == NULL) 
   {
    return -1;
   }
 key=&(ctx->c.rijndael_key);
 if (key->direction == RIJNDAEL_DECRYPT)
   {
    return -1;
   }
 if (input == NULL || inputLen <= 0)
   {
    return 0; /* nothing to do */
   }
 if (outputLen<inputLen) return( -1 );

 numBlocks = inputLen/RIJNDAEL_BITSPERBLOCK;
 for (i = numBlocks; i > 0; i--) 
   {
    rijndaelEncrypt(input, outBuffer, key->keySched, key->ROUNDS);
    input += RIJNDAEL_BYTESPERBLOCK;
    outBuffer += RIJNDAEL_BYTESPERBLOCK;
   }
 return RIJNDAEL_BITSPERBLOCK*numBlocks;
}
/*------------------------------------------------------------------------*/

/*------------------------------------------------------------------------*/
/* Do Rijndael CBC type decryption - inputLen and outputLen in bits */
/*------------------------------------------------------------------------*/
int Rijndael_Decrypt_CBC( void *_ctx, BYTE *input, int inputLen, BYTE *outBuffer, int outputLen)
{
 EVP_CIPHER_CTX *ctx=_ctx;
 int i, numBlocks;
 Rijndael_key *key;
 word8 block[RIJNDAEL_BYTESPERBLOCK], iv[4][4];

 if (ctx == NULL)
   {
    return -1;
   }
 key=&(ctx->c.rijndael_key);
 if (key->direction == RIJNDAEL_ENCRYPT)
   {
    return -1;
   }
 if (input == NULL || inputLen <= 0) 
   {
    return 0; /* nothing to do */
   }
 if (outputLen<inputLen) return( -1 );

 numBlocks = inputLen/RIJNDAEL_BITSPERBLOCK;
 *((word32*)iv[0]) = *((word32*)(ctx->iv   ));
 *((word32*)iv[1]) = *((word32*)(ctx->iv+ 4));
 *((word32*)iv[2]) = *((word32*)(ctx->iv+ 8));
 *((word32*)iv[3]) = *((word32*)(ctx->iv+12));
 for (i = numBlocks; i > 0; i--) 
   {
    rijndaelDecrypt(input, block, key->keySched, key->ROUNDS);
    ((word32*)block)[0] ^= *((word32*)iv[0]);
    ((word32*)block)[1] ^= *((word32*)iv[1]);
    ((word32*)block)[2] ^= *((word32*)iv[2]);
    ((word32*)block)[3] ^= *((word32*)iv[3]);
    *((word32*)iv[0]) = ((word32*)input)[0]; ((word32*)outBuffer)[0] = ((word32*)block)[0];
    *((word32*)iv[1]) = ((word32*)input)[1]; ((word32*)outBuffer)[1] = ((word32*)block)[1];
    *((word32*)iv[2]) = ((word32*)input)[2]; ((word32*)outBuffer)[2] = ((word32*)block)[2];
    *((word32*)iv[3]) = ((word32*)input)[3]; ((word32*)outBuffer)[3] = ((word32*)block)[3];
    input += RIJNDAEL_BYTESPERBLOCK;
    outBuffer += RIJNDAEL_BYTESPERBLOCK;
   }
 return RIJNDAEL_BITSPERBLOCK*numBlocks;
}
/*------------------------------------------------------------------------*/

/*------------------------------------------------------------------------*/
/* Do Rijndael CBC type decryption - inputLen and outputLen in bits */
/*------------------------------------------------------------------------*/
int Rijndael_Decrypt_ECB(void *_ctx, BYTE *input, int inputLen, BYTE *outBuffer, int outputLen)
{
 EVP_CIPHER_CTX *ctx=_ctx;
 int i, numBlocks;
 Rijndael_key *key;

 if (ctx == NULL)
   {
    return -1;
   }
 key=&(ctx->c.rijndael_key);
 if (key->direction == RIJNDAEL_ENCRYPT) 
   {
    return -1;
   }
 if (input == NULL || inputLen <= 0) 
   {
    return 0; /* nothing to do */
   }
 if (outputLen<inputLen) return( -1 );

 numBlocks = inputLen/RIJNDAEL_BITSPERBLOCK;

 for (i = numBlocks; i > 0; i--)
   { 
    rijndaelDecrypt(input, outBuffer, key->keySched, key->ROUNDS);
    input += RIJNDAEL_BYTESPERBLOCK;
    outBuffer += RIJNDAEL_BYTESPERBLOCK;
   }
 return RIJNDAEL_BITSPERBLOCK*numBlocks;
}
/*------------------------------------------------------------------------*/