/*

* 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: 

*

*/

/**

 @file

 @internalTechnology

*/

#include "symmetriccipherctrmodeoutoforderstep.h"

using namespace CryptoSpi;

CSymmetricCipherCtrModeOutOfOrderStep::CSymmetricCipherCtrModeOutOfOrderStep()

	{

	SetTestStepName(KSymmetricCipherCtrModeOutOfOrderStep);

	}

TVerdict CSymmetricCipherCtrModeOutOfOrderStep::doTestStepPreambleL()

	{

	SetTestStepResult(EPass);

	return TestStepResult();

	}

TVerdict CSymmetricCipherCtrModeOutOfOrderStep::doTestStepL()

	{

	INFO_PRINTF1(_L("*** Symmetric Cipher - Counter mode out of order operation ***"));

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

  	if (TestStepResult() != EPass)

  		{

  		return TestStepResult();

  		}

  	//Assume failure, unless all is successful

	SetTestStepResult(EFail);

	TVariantPtrC operationMode;

	CSymmetricCipher* impl = NULL;

	CKey* key = NULL;

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

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

	CleanupStack::PushL(key);

	CleanupStack::PushL(impl);

  	if (TUid(operationMode) != KOperationModeCTRUid)

  		{

  		ERR_PRINTF2(_L("*** FAIL: This test supports CTR operation mode only and not mode id: %d ***"), (TUid(operationMode)).iUid);

  		CleanupStack::PopAndDestroy(2, key);

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

  		return TestStepResult();

  		}

	HBufC8* plaintext = ReadInPlaintextL();

	CleanupStack::PushL(plaintext);

	TInt blockSize = CtrModeCalcBlockSizeL(*impl)/8;

	if (plaintext->Length() < ((blockSize * 2) + 1))

		{

		ERR_PRINTF2(_L("*** FAIL: Plaintext argument is not long enough for this test, length(B) = %d ***"), plaintext->Length());

		CleanupStack::PopAndDestroy(3, key);

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

		return TestStepResult();

		}

  	// This will store our calculated version of the ciphertext to compare with that in the .ini file

  	TUint8* calculatedCiphertext = new (ELeave) TUint8[plaintext->Length()];

  	CleanupStack::PushL(calculatedCiphertext);

  	// Ptr to the first block of the calculated ciphertext

  	TPtr8 calcCipherPtr1(calculatedCiphertext, blockSize);

  	// Ptr to the remaining blocks of the calculated ciphertext

  	TPtr8 calcCipherPtr2((calculatedCiphertext + blockSize), (plaintext->Length() - blockSize));

  	// Ptr to the first block of the .ini file's plaintext

  	TPtrC8 knownPlainPtr1(plaintext->Ptr(), blockSize);

  	// Ptr to the remaining blocks of the .ini file's plaintext

  	TPtrC8 knownPlainPtr2((plaintext->Ptr() + blockSize), (plaintext->Length() - blockSize));

	HBufC8* iv = ReadInIvL();

	CleanupStack::PushL(iv);

	// Increment IV to the value for the second block so we can encrypt blocks 2+ first

	HBufC8* incrementedIv1 = CtrModeIncrementCounterL((*iv));

	CleanupStack::PushL(incrementedIv1);

	impl->SetIvL(*incrementedIv1);

	INFO_PRINTF1(_L("Setup complete.  Encrypting blocks 2+."));

	impl->ProcessL(knownPlainPtr2, calcCipherPtr2);

	INFO_PRINTF1(_L("Blocks 2+ encrypted.  Reseting and encrypting block 1."));

	impl->SetIvL((*iv));

	impl->ProcessL(knownPlainPtr1, calcCipherPtr1);

	HBufC8* knownCiphertext = ReadInCiphertextL();

	CleanupStack::PushL(knownCiphertext);

	// Check that calculated ciphertext matches the expected value

	TPtrC8 wholeCalcCiphertext(calculatedCiphertext, (plaintext->Length()));

	if (wholeCalcCiphertext.Compare((*knownCiphertext)) != 0)

		{

		ERR_PRINTF1(_L("*** FAIL: Calculated ciphertext does not match expected value ***"));

  		CleanupStack::PopAndDestroy(7, key);

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

  		return TestStepResult();

		}

	else

		{

		INFO_PRINTF1(_L("Calculated ciphertext matches the expected value."));

		}

	// ****  SWITCH TO DECRYPTION NOW  ****

	// This will store our calculated version of the plaintext to compare with that in the .ini file

  	TUint8* calculatedPlaintext = new (ELeave) TUint8[plaintext->Length()];

  	CleanupStack::PushL(calculatedPlaintext);

  	// Ptr to the first block of the calculated plaintext

  	TPtr8 calcPlainPtr1(calculatedPlaintext, (blockSize * 2));

  	// Ptr to the remaining blocks of the calculated plaintext

  	TPtr8 calcPlainPtr2((calculatedPlaintext + (blockSize * 2)), (plaintext->Length() - (blockSize * 2)));

  	// Ptr to the first 2 blocks of the ciphertext

  	TPtrC8 knownCipherPtr1(wholeCalcCiphertext.Ptr(), (blockSize * 2));

  	// Ptr to the remaining blocks of the ciphertext

  	TPtrC8 knownCipherPtr2((wholeCalcCiphertext.Ptr() + (blockSize * 2)), (wholeCalcCiphertext.Length() - (blockSize * 2)));

	//	Increment IV to the value for the third block so we can decrypt blocks 3+ first

	HBufC8* incrementedIv2 = CtrModeIncrementCounterL(*incrementedIv1);

	CleanupStack::PushL(incrementedIv2);

	impl->SetIvL(*incrementedIv2);

	INFO_PRINTF1(_L("Setup complete.  Decrypting blocks 3+."));

	impl->ProcessL(knownCipherPtr2, calcPlainPtr2);

	INFO_PRINTF1(_L("Blocks 3+ encrypted.  Reseting and encrypting blocks 1 and 2."));

	impl->SetIvL((*iv));

	impl->ProcessL(knownCipherPtr1, calcPlainPtr1);	

	TPtrC8 wholeCalcPlaintext(calculatedPlaintext, (plaintext->Length()));

	if (wholeCalcPlaintext.Compare((*plaintext)) != 0)

		{

		ERR_PRINTF1(_L("*** FAIL: Calculated plaintext does not match expected value ***"));

		}

	else

		{

		INFO_PRINTF1(_L("*** PASS: Calculated plaintext matches the original one ***"));

		SetTestStepResult(EPass);			

		}

  	CleanupStack::PopAndDestroy(9, key);

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

	return TestStepResult();

	}

TVerdict CSymmetricCipherCtrModeOutOfOrderStep::doTestStepPostambleL()

	{

	return TestStepResult();

	}