/*

 * Copyright (c) 1998-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 "tactionmontecarlo.h"

 #include "bufferedtransformation.h"

 #include "rijndael.h"

 #include "cbcmode.h"

 #include "padding.h"

 const TInt KAESBlockSizeBytes = 16;	//	128 bits

 CTestAction* CActionMonteCarlo::NewL(RFs& aFs,

 									   CConsoleBase& aConsole,

 									   Output& aOut, 

 									   const TTestActionSpec& aTestActionSpec)

 	{

 	CTestAction* self = CActionMonteCarlo::NewLC(aFs, aConsole,

 		aOut, aTestActionSpec);

 	CleanupStack::Pop();

 	return self;

 	}

 CTestAction* CActionMonteCarlo::NewLC(RFs& aFs,

 										CConsoleBase& aConsole,

 										Output& aOut, 

 										const TTestActionSpec& aTestActionSpec)

 	{

 	CActionMonteCarlo* self = new(ELeave) CActionMonteCarlo(aFs, aConsole, aOut);

 	CleanupStack::PushL(self);

 	self->ConstructL(aTestActionSpec);

 	return self;

 	}

 CActionMonteCarlo::~CActionMonteCarlo()

 {

 	delete iEncrypt;

 	delete iDecrypt;

 }

 CActionMonteCarlo::CActionMonteCarlo(RFs& aFs, 

 								 CConsoleBase& aConsole,

 								 Output& aOut)

 : CCryptoTestAction(aFs, aConsole, aOut)

 {}

 void CActionMonteCarlo::DoPerformPrerequisiteL()

 {

 	TInt err = KErrNone;

 	TInt pos = 0;

 	TPtrC8 monteCarlo = Input::ParseElement(*iBody, KMonteCarloStart, KMonteCarloEnd, pos, err);

 	DoInputParseL(monteCarlo);

 	CBlockTransformation* encryptor = NULL;

 	CBlockTransformation* decryptor = NULL;

 	switch (iCipherType)

 	{

 		case (EAESMonteCarloEncryptECB):

 		{

 			encryptor = CAESEncryptor::NewLC(iKey->Des());

 		}

 		break;

 		case (EAESMonteCarloDecryptECB):

 		{

 			decryptor = CAESDecryptor::NewLC(iKey->Des());

 		}

 		break;

 		case (EAESMonteCarloEncryptCBC):

 		{

 			CBlockTransformation* aesEncryptor = NULL;		

 			aesEncryptor = CAESEncryptor::NewLC(iKey->Des());

 			encryptor = CModeCBCEncryptor::NewL(aesEncryptor, iIV->Des());

 			CleanupStack::Pop(aesEncryptor);

 			CleanupStack::PushL(encryptor);		

 		}

 		break;

 		case (EAESMonteCarloDecryptCBC):

 		{

 			CBlockTransformation* aesDecryptor = NULL;		

 			aesDecryptor = CAESDecryptor::NewLC(iKey->Des());

 			decryptor = CModeCBCDecryptor::NewL(aesDecryptor, iIV->Des());

 			CleanupStack::Pop(aesDecryptor);

 			CleanupStack::PushL(decryptor);		

 		}

 		break;

 		default:

 		{

 			ASSERT(0);

 			User::Leave(KErrNotSupported);

 		}

 	}

 	CPaddingSSLv3* padding = 0;

 	if (encryptor)

 		{

 		padding = CPaddingSSLv3::NewLC(encryptor->BlockSize());

 		iEncrypt = CBufferedEncryptor::NewL(encryptor, padding);	

 		iEResult = HBufC8::NewMaxL(iEncrypt->MaxOutputLength(iInput->Length()));

 		}

 	else if (decryptor)

 		{

 		padding = CPaddingSSLv3::NewLC(decryptor->BlockSize());

 		iDecrypt = CBufferedDecryptor::NewL(decryptor, padding);

 		iDResult = HBufC8::NewMaxL(iDecrypt->MaxOutputLength(iInput->Size()));

 		}

 	CleanupStack::Pop(2);	//	padding, encryptor/decryptor

 }

 void CActionMonteCarlo::DoPerformActionL()

 {

 	iResult = EFalse;

 	__ASSERT_DEBUG(iInput->Size()==KAESBlockSizeBytes, User::Panic(_L("tsymmetric"), KErrNotSupported));

 	if (iCipherType==EAESMonteCarloEncryptECB)

 		DoAESEncryptECB();

 	else if (iCipherType==EAESMonteCarloDecryptECB)

 		DoAESDecryptECB();	

 	else if (iCipherType==EAESMonteCarloEncryptCBC)

 		DoAESEncryptCBC();

 	else if (iCipherType==EAESMonteCarloDecryptCBC)

 		DoAESDecryptCBC();

 	else

 		User::Leave(KErrNotSupported);

 }

 void CActionMonteCarlo::DoAESEncryptECB()

 {

 	TPtr8 theEncryptResult(iEResult->Des());

 	theEncryptResult.FillZ(theEncryptResult.MaxLength());

 	theEncryptResult.SetLength(0);

 	TInt index = 0;

 	TPtr8 theInput(iInput->Des());

 	for (; index < KMonteCarloIterations; index++)

 	{

 		iEncrypt->Process(theInput, theEncryptResult);	

 		theInput.Copy(theEncryptResult);

 		theEncryptResult.FillZ(theEncryptResult.MaxLength());

 		theEncryptResult.SetLength(0);

 	}

 	if (*iOutput==*iEResult)

 	{	

 		iResult = ETrue;

 	}

 }

 void CActionMonteCarlo::DoAESDecryptECB()

 {

 	TPtr8 theDecryptResult(iDResult->Des());

 	theDecryptResult.FillZ(theDecryptResult.MaxLength());

 	theDecryptResult.SetLength(0);

 	TInt index = 0;

 	TPtr8 theInput(iInput->Des());

 	for (; index < KMonteCarloIterations; index++)

 	{

 		iDecrypt->Process(theInput, theDecryptResult);	

 		theInput.Copy(theDecryptResult);

 		theDecryptResult.FillZ(theDecryptResult.MaxLength());

 		theDecryptResult.SetLength(0);

 	}

 	if (*iOutput==*iInput)

 	{	

 		iResult = ETrue;

 	}

 }

 void CActionMonteCarlo::DoAESEncryptCBC()

     {	

 	TPtr8 theEncryptResult(iEResult->Des());

 	theEncryptResult.FillZ(theEncryptResult.MaxLength());

 	theEncryptResult.SetLength(0);

 	TInt index = 0;

 	TPtr8 theInput(iInput->Des());

 	TBuf8<KAESBlockSizeBytes> nextBuf;

 	nextBuf.FillZ(KAESBlockSizeBytes);

     for (; index < KMonteCarloIterations-1; index++)

 	    {

 	    iEncrypt->Process(theInput, theEncryptResult);	

 	    if (index==0)

 		theInput.Copy(*iIV);	//	First loop, use the original IV as next PT block

 		else	

 		theInput.Copy(nextBuf);	//	Use previous CT block as next PT block

 	    //	 Save CT block for next loop when it'll become the PT block	

 		nextBuf.Copy(theEncryptResult);

 	    //	 Reset for next encryption	

 		theEncryptResult.FillZ(theEncryptResult.MaxLength());

 		theEncryptResult.SetLength(0);

 	    }

     iEncrypt->Process(theInput, theEncryptResult);	

 	if  (theEncryptResult.Compare(*iOutput)==KErrNone)

 	    {	

 	    iResult = ETrue;

 	    }

     }

 void CActionMonteCarlo::DoAESDecryptCBC()

     {

 	TPtr8 theDecryptResult(iDResult->Des());

 	theDecryptResult.FillZ(theDecryptResult.MaxLength());

 	theDecryptResult.SetLength(0);

 	TInt index = 0;

     TPtr8 theInput(iInput->Des());

     for (; index < KMonteCarloIterations-1; index++)

 	    {

 	    iDecrypt->Process(theInput, theDecryptResult);	

 		//	Use previous PT block as next CT block

 	 	theInput.Copy(theDecryptResult);

 	    //  Reset for next decryption	

 		theDecryptResult.FillZ(theDecryptResult.MaxLength());

 		theDecryptResult.SetLength(0);

 	    }

     // Last loop	

     iDecrypt->Process(theInput, theDecryptResult);	

 	if (theDecryptResult.Compare(*iOutput)==KErrNone)

  	   {	

 	   iResult = ETrue;

 	   }

     }