/*
* 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);		
	}