/*

* Copyright (c) 2007-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: 

* Example CTestStep derived implementation

*

*/

/**

 @file

 @internalTechnology

*/

#include "symmetriccipherobjectreusestep.h"

#include "filewriter.h"

#include "filecompare.h"

using namespace CryptoSpi;

CSymmetricCipherObjectReuseStep::CSymmetricCipherObjectReuseStep(TInt aOffset) : iOffset(aOffset)

	{

	}

CSymmetricCipherObjectReuseStep::~CSymmetricCipherObjectReuseStep()

	{

	}

TVerdict CSymmetricCipherObjectReuseStep::doTestStepPreambleL()

	{

	SetTestStepResult(EPass);

	return TestStepResult();

	}

TVerdict CSymmetricCipherObjectReuseStep::doTestStepL()

	{

	INFO_PRINTF1(_L("*** Symmetric Cipher - Object Reuse ***"));

	INFO_PRINTF2(_L("HEAP CELLS: %d"), User::CountAllocCells());

  	if (TestStepResult()==EPass)

		{

		//Assume failure, unless all is successful

		SetTestStepResult(EFail);

		TPtrC keyPath;

		TPtrC srcPath;

		TVariantPtrC algorithm;

		TVariantPtrC operationMode;

		TVariantPtrC paddingMode;

		if(	!GetStringFromConfig(ConfigSection(),KConfigEncryptKey, keyPath) ||

			!GetStringFromConfig(ConfigSection(),KConfigSourcePath, srcPath) || 

			!GetStringFromConfig(ConfigSection(),KConfigAlgorithmUid, algorithm) || 

			!GetStringFromConfig(ConfigSection(),KConfigOperationMode, operationMode) ||

			!GetStringFromConfig(ConfigSection(),KConfigPaddingMode, paddingMode ))

			{

			User::Leave(KErrNotFound);

			}

		else

			{

			//Create an instance of TKeyProperty

			TKeyProperty keyProperty;

			//Load the key data using the

			CFileReader* keyData = CFileReader::NewLC(keyPath);

			CCryptoParams* params = CCryptoParams::NewLC(); 

			params->AddL( *keyData, KSymmetricKeyParameterUid); 

			CKey* key=CKey::NewL(keyProperty, *params);

			CleanupStack::PushL(key);

			CCryptoParams* xparams = NULL;

			if (TUid(algorithm) == KArc4Uid)

				{

				//Set the RC4 DiscardBytes to 0

				xparams = CCryptoParams::NewL();

				xparams->AddL(NULL, KARC4DiscardBytes);

				CleanupStack::PushL(xparams);

				}

			if (TUid(algorithm) == KRc2Uid)

				{

				TInt keylen = TPtrC8(*keyData).Length() * 8;

				xparams = CCryptoParams::NewLC();

				//Set the RC2 EffectiveKeyLen according to the input key size

				xparams->AddL( keylen, KRC2EffectiveKeyLenBits);

				}

			INFO_PRINTF1(_L("Creating Symmetric Cipher Object..."));

			// Create a Symmetric Cipher with the values from the ini config file	

			CryptoSpi::CSymmetricCipher * impl = NULL;	

			TRAPD(err,CSymmetricCipherFactory::CreateSymmetricCipherL

										(

										impl,

										algorithm,

										*key,

										KCryptoModeEncryptUid,

										operationMode,

										paddingMode,

										xparams));

			if(impl && (err == KErrNone))

				{

				CleanupStack::PushL(impl);

				const TInt KObjectReuseItterations = 5; // 5 iterations should be enough to check the object reuse feature

														// the no of iteration is reduced, to reduce the time taken for execution

				//Boolean to denote the state				

				TBool testPass = ETrue;

				/*************** Encrypt/Decrypt Reuse Loop ****************/

				for(TInt index = 0; index < KObjectReuseItterations; index++)

					{

					INFO_PRINTF3(_L("i=%d : START HEAP CELLS: %d"),index, User::CountAllocCells());

					//-----RESET IMPLEMENTATION OBJECT (NORMAL LOGGING)----------

					impl->Reset();

					TRAP(err,impl->SetKeyL(*key));

					if(err != KErrNone)

						{

						ERR_PRINTF3(_L("*** ERROR:%d - SetKeyL() i=%d ***"),err,index);

						User::Leave(err);	

						}

					TRAP(err,impl->SetCryptoModeL(KCryptoModeEncryptUid));

					if(err != KErrNone)

						{

						ERR_PRINTF3(_L("*** ERROR:%d - SetCryptoModeL() i=%d ***"),err,index);

						User::Leave(err);	

						}

					if(TUid(algorithm) != KArc4Uid)

						{

						impl->SetOperationModeL(operationMode);

						if(err != KErrNone)

							{

							ERR_PRINTF3(_L("*** ERROR:%d - SetOperationModeL() i=%d ***"),err,index);

							User::Leave(err);	

							}

						TRAP(err,impl->SetPaddingModeL(paddingMode));

						if(err != KErrNone)

							{

							ERR_PRINTF3(_L("*** ERROR:%d - SetPaddingModeL() i=%d ***"),err,index);

							User::Leave(err);	

							}

						}

					//------------------------------------------------------

					//find out the block size for this algorithm

					TInt blockSize(0);

					if (TUid(operationMode) == KOperationModeCTRUid)

						{

						blockSize = CtrModeCalcBlockSizeL(*impl);

						}

					else

						{

						blockSize = impl->BlockSize();	

						}

					HBufC8* iv = NULL;

					if ((TUid(operationMode) == KOperationModeCBCUid) || (TUid(operationMode) == KOperationModeCTRUid))

						{

						// block size is in bits so to allocate the correct number of bytes divide by 8

						// iv is left on the cleanup stack for the duration of the test and deleted in a conditional at the end of the outer block.

						// If this conditional block changes, take care to update the condition for deleting this allocated IV, near the end of this function.

						iv = HBufC8::NewLC(blockSize/8);	

						// blocksize is in bits so to allocate the correct number of 8 byte chunks divide by 64

						for(TInt i = 0 ; i <blockSize/64 ; i++)

						{

							iv->Des().Append(_L8("12345678"));

						}

						TRAP_LOG(err,impl->SetIvL(iv->Des())); 

						}

					// convert to bytesize

					blockSize/=8;

					blockSize += iOffset;

					//read from src file

					CFileReader* srcData = CFileReader::NewLC(srcPath,blockSize);

					// first step is to read from the src file one block

					// at a time, encrypt that block and then write

					// the encrypted block out to a temporary file.

					CFileWriter* encryptedDataWriter = CFileWriter::NewLC(TPtrC(KTempEncryptedFilePath));

					TInt numBlocks = srcData->NumBlocks();

					INFO_PRINTF1(_L("Starting Incremental Encryption..."));

					for(TInt i = 1 ; i <= numBlocks ; i++)

						{

						TRAP_LOG(err,srcData->ReadBlockL());

						//Create buffer for encrypted data

						TInt maxOutputLength = impl->MaxFinalOutputLength(TPtrC8(*srcData).Length());

						HBufC8* encrypted =	HBufC8::NewLC(maxOutputLength);

						TPtr8 encryptedPtr = encrypted->Des();

						if(i == numBlocks)

							{

							TRAP(err,impl->ProcessFinalL(*srcData, encryptedPtr));

							if(err != KErrNone)

								{

								ERR_PRINTF3(_L("*** ERROR:%d - ProcessFinalL() Block=%d ***"),err,i);

								User::Leave(err);	

								}

							}

						else

							{

							TRAP(err,impl->ProcessL(*srcData, encryptedPtr));

							if(err != KErrNone)

								{

								ERR_PRINTF3(_L("*** ERROR:%d - ProcessL() Block=%d ***"),err,i);

								User::Leave(err);	

								}

							}	

						TRAP_LOG(err,encryptedDataWriter->WriteBlockL(encryptedPtr));

						CleanupStack::PopAndDestroy(encrypted); 

						}

					CleanupStack::PopAndDestroy(encryptedDataWriter); 

					//Switch to Decrypt Crypto Mode

					TRAP(err,impl->SetCryptoModeL(KCryptoModeDecryptUid));

					if(err != KErrNone)

						{

						ERR_PRINTF3(_L("*** ERROR:%d - SetCryptoModeL() i=%d ***"),err,index);

						User::Leave(err);	

						}

					//If in CTR mode need to reset the keystream to the start of the sequence used for encryption.

					if(TUid(operationMode) == KOperationModeCTRUid)

						{

						impl->SetIvL(iv->Des());

						}

					// the next step is to read the previously encrypted data

					// from the temporary file decrypting this one block

					// at a time and outputing this to a temporary file.

					CFileReader* encryptedDataReader = CFileReader::NewLC(TPtrC(KTempEncryptedFilePath),blockSize);

					CFileWriter* decryptedDataWriter = CFileWriter::NewLC(TPtrC(KTempDecryptedFilePath));

					numBlocks = encryptedDataReader->NumBlocks();

					INFO_PRINTF1(_L("Starting Incremental Decryption..."));

					for(TInt i = 1 ; i <= numBlocks ; i++)

						{

						encryptedDataReader->ReadBlockL();

						//Create buffer for encrypted data

						TInt maxOutputLength = impl->MaxFinalOutputLength(TPtrC8(*encryptedDataReader).Length());

						HBufC8* decrypted =	HBufC8::NewLC(maxOutputLength);

						TPtr8 decryptedPtr = decrypted->Des();

						//Perform the decryption operation

						if(i == numBlocks)

							{

							TRAP(err,impl->ProcessFinalL(*encryptedDataReader, decryptedPtr));

							if(err != KErrNone)

								{

								ERR_PRINTF3(_L("*** ERROR:%d - ProcessFinalL() Block=%d ***"),err,i);

								User::Leave(err);	

								}

							}

						else

							{

							TRAP(err,impl->ProcessL(*encryptedDataReader, decryptedPtr));

							if(err != KErrNone)

								{

								ERR_PRINTF3(_L("*** ERROR:%d - ProcessL() Block=%d ***"),err,i);

								User::Leave(err);	

								}

							}

						TRAP_LOG(err,decryptedDataWriter->WriteBlockL(decryptedPtr));

						CleanupStack::PopAndDestroy(decrypted); 

						}

					CleanupStack::PopAndDestroy(decryptedDataWriter); 

					CleanupStack::PopAndDestroy(encryptedDataReader); 

					CleanupStack::PopAndDestroy(srcData);

					if((TUid(operationMode) == KOperationModeCBCUid) || (TUid(operationMode) == KOperationModeCTRUid))

						{

						// Iv is left on the cleanupstack at creation.  

						// If it becomes possible for operationMode to be modified during

						// the test this needs to be re-engineered.

						CleanupStack::PopAndDestroy(iv);

						}

					// compare the src with the file thats been

					// encrypted then decrypted

					// Note: Returning 0 means that the files match

					if(!TFileCompare::CompareL(srcPath,TPtrC(KTempDecryptedFilePath)))

						{

						INFO_PRINTF2(_L("*** PASS = Source File and Decrypted Data Match - i=%d ***"),index);

						}

					else

						{

						testPass = EFalse;

						ERR_PRINTF2(_L("*** ERROR: Source File and Decrypted Data Mismatch - i=%d ***"),index);

						}

					RFs rFs;

					rFs.Connect();

					rFs.Delete(	KTempDecryptedFilePath );

					rFs.Delete(	KTempEncryptedFilePath );

					rFs.Close();

					INFO_PRINTF3(_L("*** i=%d : END HEAP CELLS: %d ***"),index, User::CountAllocCells());

					}

				/*************** END OF LOOP ****************/

				CleanupStack::PopAndDestroy(impl);

				if(testPass == EFalse)

					{

					ERR_PRINTF1(_L("*** TEST FAIL : Symmetric Cipher - Object Reuse ***"));

					}

				else

					{

					INFO_PRINTF1(_L("*** TEST PASS : Symmetric Cipher - Object Reuse ***"));

					SetTestStepResult(EPass);	

					}

				}

			else

				{

				ERR_PRINTF2(_L("*** FAIL: Failed to Create Symmetric Object - %d ***"), err);

				User::Leave(err);	

				}

			if (TUid(algorithm) == KArc4Uid || TUid(algorithm) == KRc2Uid)

				{

				CleanupStack::PopAndDestroy(xparams);				

				}

			CleanupStack::PopAndDestroy(key);

			CleanupStack::PopAndDestroy(params);

			CleanupStack::PopAndDestroy(keyData);

			}

		}

	INFO_PRINTF2(_L("HEAP CELLS: %d"), User::CountAllocCells());

	return TestStepResult();

	}

TVerdict CSymmetricCipherObjectReuseStep::doTestStepPostambleL()

	{

	return TestStepResult();

	}