/*

 * 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 "symmetriccipherincrementalencryptdecryptstep.h"

 #include "filewriter.h"

 #include "filecompare.h"

 using namespace CryptoSpi;

 CSymmetricCipherIncrementalEncryptDecryptStep::~CSymmetricCipherIncrementalEncryptDecryptStep()

 	{

 	}

 CSymmetricCipherIncrementalEncryptDecryptStep::CSymmetricCipherIncrementalEncryptDecryptStep(TInt aOffset) : iOffset(aOffset)

 	{

 	SetTestStepName(KSymmetricCipherIncrementalEncryptDecryptStep);

 	}

 TVerdict CSymmetricCipherIncrementalEncryptDecryptStep::doTestStepPreambleL()

 	{

 	SetTestStepResult(EPass);

 	return TestStepResult();

 	}

 TVerdict CSymmetricCipherIncrementalEncryptDecryptStep::doTestStepL()

 	{

 	INFO_PRINTF1(_L("*** Symmetric Cipher - Incremental Encrypt/Decrypt ***"));

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

   	if (TestStepResult()==EPass)

 		{

 		//Assume faliure, unless all is successful

 		SetTestStepResult(EFail);

 		TPtrC srcPath;

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

 			{

 			User::Leave(KErrNotFound);

 			}

 		TVariantPtrC operationMode;

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

 		CryptoSpi::CSymmetricCipher * impl = NULL;	

 		CKey* key = NULL;

 		SetupCipherL(ETrue, EFalse, operationMode, impl, key);

 		INFO_PRINTF1(_L("Plugin loaded."));

 		CleanupStack::PushL(key);

 		CleanupStack::PushL(impl);

 		HBufC8* iv = NULL;

 		TInt err(0);

 		TInt blockSize(0);

 		if (TUid(operationMode) == KOperationModeCTRUid)

 			{

 			blockSize = CtrModeCalcBlockSizeL(*impl);

 			}

 		else

 			{

 			blockSize = impl->BlockSize();

 			}

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

 			{

 			// blocksize 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(KEncryptedFilePath));

 		TInt numBlocks = srcData->NumBlocks();

 		INFO_PRINTF1(_L("Encrypting Source Data..."));

 		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_LOG(err,impl->ProcessFinalL(*srcData, encryptedPtr));

 				}

 			else

 				{

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

 				}

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

 			CleanupStack::PopAndDestroy(encrypted); 

 			}

 		CleanupStack::PopAndDestroy(encryptedDataWriter); 

 		if(err == KErrNone)

 			{

 			//Switch to decrypt

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

 			//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(KEncryptedFilePath),blockSize);

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

 			numBlocks = encryptedDataReader->NumBlocks();

 			INFO_PRINTF1(_L("Decrypting Data..."));

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

 				{

 				TRAP_LOG(err,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_LOG(err,impl->ProcessFinalL(*encryptedDataReader, decryptedPtr));

 					}

 				else

 					{

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

 					}

 				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);

 			}

 		CleanupStack::PopAndDestroy(impl);							

 		CleanupStack::PopAndDestroy(key);

 		// compare the src with the file thats been

 		// encrypted then decrypted

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

 			{

 			INFO_PRINTF1(_L("PASS : Source File and Decrypted Data Match"));

 			SetTestStepResult(EPass);

 			}

 		else

 			{

 			INFO_PRINTF1(_L("FAIL : Source File and Decrypted Data Mismatch"));	

 			SetTestStepResult(EFail);

 			}

 		RFs rFs;

 		rFs.Connect();

 		rFs.Delete(	KDecryptedFilePath );

 		rFs.Delete(	KEncryptedFilePath );

 		rFs.Close();

 		}

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

 	return TestStepResult();

 	}

 TVerdict CSymmetricCipherIncrementalEncryptDecryptStep::doTestStepPostambleL()

 	{

 	return TestStepResult();

 	}