/*

 * Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved.

 * This component and the accompanying materials are made available

 * under the terms of the License "Eclipse Public License v1.0"

 * which accompanies this distribution, and is available

 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

 *

 * Initial Contributors:

 * Nokia Corporation - initial contribution.

 *

 * Contributors:

 *

 * Description: 

 *

 */

 #include "rijndael.h"

 #include "rijndaelshim.h"

 #include "rijndaeltables.h"

 #include "../common/inlines.h"

 #include <cryptostrength.h>

 const TUint KAESKeyBytes128 = 16;

 const TUint KAESKeyBytes192 = 24;

 const TUint KAESKeyBytes256 = 32;

 const TUint KAESBlockBytes = 16;

 /* CRijndael */

 EXPORT_C CRijndael::CRijndael(void)

 	{

 	}

 void CRijndael::Reset()

 	{

 	// CRijndael is externally derivable. Don't delete this code

 	SetKey(*iKey);

 	}

 TInt CRijndael::KeySize() const

 	{

 	// CRijndael is externally derivable. Don't delete this code

 	return (4*(iRounds+1));

 	}

 EXPORT_C CRijndael::~CRijndael()

 	{

 	// CRijndael is externally derivable. Don't delete this code

 	delete iKey;

 	}

 void CRijndael::ConstructL(const TDesC8& aKey)

 	{

 	// CRijndael is externally derivable. Don't delete this code

 	TUint keySize = aKey.Size();

 	assert((keySize==KAESKeyBytes128)||(keySize==KAESKeyBytes192)||(keySize==KAESKeyBytes256));

 	iKey = aKey.AllocL();

 	iRounds = keySize/4 + 6;

 	SetKey(aKey);

 	}

 void CRijndael::SetKey(const TDesC8& aKey)

 	{

 	// CRijndael is externally derivable. Don't delete this code

 	TUint keySize = aKey.Size();

 	TUint32 temp; 

 	TUint32* rk = &iK[0];

 	TUint i = 0;

 	GetUserKeyBigEndian(rk, keySize/4, &aKey[0], keySize);

 	switch(keySize)

 		{

 		case (KAESKeyBytes128):

 			{

 			FOREVER

 				{

 				temp  = rk[3];

 				rk[4] = rk[0] ^

 					(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 2)] & 0xff000000) ^

 					(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 1)] & 0x00ff0000) ^

 					(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 0)] & 0x0000ff00) ^

 					(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 3)] & 0x000000ff) ^

 					RIJNDAEL_TABLE::rcon[i];

 				rk[5] = rk[1] ^ rk[4];

 				rk[6] = rk[2] ^ rk[5];

 				rk[7] = rk[3] ^ rk[6];

 				if (++i == 10)

 					break;

 				rk += 4;

 				}

 			}

 		break;

 		case (KAESKeyBytes192):

 			{

 			FOREVER

 				{

 				temp = rk[ 5];

 				rk[ 6] = rk[ 0] ^

 					(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 2)] & 0xff000000) ^

 					(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 1)] & 0x00ff0000) ^

 					(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 0)] & 0x0000ff00) ^

 					(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 3)] & 0x000000ff) ^

 					RIJNDAEL_TABLE::rcon[i];

 				rk[ 7] = rk[ 1] ^ rk[ 6];

 				rk[ 8] = rk[ 2] ^ rk[ 7];

 				rk[ 9] = rk[ 3] ^ rk[ 8];

 				if (++i == 8)

 					break;

 				rk[10] = rk[ 4] ^ rk[ 9];

 				rk[11] = rk[ 5] ^ rk[10];

 				rk += 6;

 				}

 			}

 		break;

 		case (KAESKeyBytes256):

 			{

 			FOREVER

 				{

         		temp = rk[ 7];

         		rk[ 8] = rk[ 0] ^

         			(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 2)] & 0xff000000) ^

         			(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 1)] & 0x00ff0000) ^

         			(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 0)] & 0x0000ff00) ^

         			(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 3)] & 0x000000ff) ^

         			RIJNDAEL_TABLE::rcon[i];

         		rk[ 9] = rk[ 1] ^ rk[ 8];

         		rk[10] = rk[ 2] ^ rk[ 9];

         		rk[11] = rk[ 3] ^ rk[10];

 				if (++i == 7)

 					break;

         		temp = rk[11];

         		rk[12] = rk[ 4] ^

         			(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 3)] & 0xff000000) ^

         			(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 2)] & 0x00ff0000) ^

         			(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 1)] & 0x0000ff00) ^

         			(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 0)] & 0x000000ff);

         		rk[13] = rk[ 5] ^ rk[12];

         		rk[14] = rk[ 6] ^ rk[13];

         		rk[15] = rk[ 7] ^ rk[14];

 				rk += 8;

 				}

 			}

 		break;

 		default:

 			assert(0);	//	Shouldn't get here, keeps compiler happy

 		}

 	}

 /* CAESEncryptor */

 EXPORT_C CAESEncryptor* CAESEncryptor::NewL(const TDesC8& aKey)

 	{

 	return CAESEncryptorShim::NewL(aKey);

 	}

 EXPORT_C CAESEncryptor* CAESEncryptor::NewLC(const TDesC8& aKey)

 	{

 	return CAESEncryptorShim::NewLC(aKey);

 	}

 CAESEncryptor::CAESEncryptor()

 	{

 	}

 /* CAESDecryptor */

 EXPORT_C CAESDecryptor* CAESDecryptor::NewL(const TDesC8& aKey)

 	{

 	return CAESDecryptorShim::NewL(aKey);

 	}

 EXPORT_C CAESDecryptor* CAESDecryptor::NewLC(const TDesC8& aKey)

 	{

 	return CAESDecryptorShim::NewLC(aKey);

 	}

 CAESDecryptor::CAESDecryptor()

 	{	

 	}

 // All these methods have been replaced by the shim

 #ifdef _BullseyeCoverage

 #pragma suppress_warnings on

 #pragma BullseyeCoverage off

 #pragma suppress_warnings off

 #endif

 TInt CAESDecryptor::BlockSize() const

 	{

 	// Method replaced by shim

 	ASSERT(EFalse);

 	return 0;

 	}

 void CAESDecryptor::Transform(TDes8& /*aBlock*/)

 	{

 	// Method replaced by shim

 	ASSERT(EFalse);	

 	}

 void CAESDecryptor::SetKey(const TDesC8& /*aKey*/)

 	{

 	// Method replaced by shim

 	ASSERT(EFalse);

 	}

 TInt CAESEncryptor::BlockSize() const

 	{

 	// Method replaced by shim

 	ASSERT(EFalse);

 	return KAESBlockBytes;

 	}

 void CAESEncryptor::Transform(TDes8& /*aBlock*/)

 	{

 	// Method replaced by shim

 	ASSERT(EFalse);		

 	}