/*

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

#include "symmetric.h"

CTestAction* CActionVector::NewL(RFs& aFs,

									   CConsoleBase& aConsole,

									   Output& aOut, 

									   const TTestActionSpec& aTestActionSpec)

{

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

		aOut, aTestActionSpec);

	CleanupStack::Pop();

	return self;

}

CTestAction* CActionVector::NewLC(RFs& aFs,

										CConsoleBase& aConsole,

										Output& aOut, 

										const TTestActionSpec& aTestActionSpec)

{

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

	CleanupStack::PushL(self);

	self->ConstructL(aTestActionSpec);

	return self;

	}

CActionVector::~CActionVector()

{

	delete iEncryptor;

	delete iDecryptor;

}

CActionVector::CActionVector(RFs& aFs, 

								 CConsoleBase& aConsole,

								 Output& aOut)

:	CCryptoTestAction(aFs, aConsole, aOut)

{}

void CActionVector::DoPerformPrerequisiteL()

{

	TInt err = KErrNone;

	TInt pos = 0;

	TPtrC8 vector = Input::ParseElement(*iBody, KVectorStart, KVectorEnd, pos, err);

	DoInputParseL(vector);

	CBlockTransformation* encryptor = NULL;

	CBlockTransformation* decryptor = NULL;

	iEncryptor = 0;

	iDecryptor = 0;

	switch (iCipherType)

	{

		case (EDESECB):

		{

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

			decryptor = CDESDecryptor::NewL(iKey->Des());

			CleanupStack::Pop(encryptor);

		}

		break;

		case(EDESCBC):

		{

			CBlockTransformation* desEncryptor = NULL;

			CBlockTransformation* desDecryptor = NULL;

			desEncryptor = CDESEncryptor::NewLC(iKey->Des());

			desDecryptor = CDESDecryptor::NewLC(iKey->Des());

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

			CleanupStack::PushL(encryptor);

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

			CleanupStack::Pop(3, desEncryptor);

		}

		break;

		case (E3DESECB):

		{

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

			decryptor = C3DESDecryptor::NewL(iKey->Des());

			CleanupStack::Pop(encryptor);

		}

		break;

		case (E3DESCBC):

		{

			CBlockTransformation* the3DESencryptor = NULL;

			CBlockTransformation* the3DESdecryptor = NULL;

			the3DESencryptor = C3DESEncryptor::NewLC(iKey->Des());

			the3DESdecryptor = C3DESDecryptor::NewLC(iKey->Des());

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

			CleanupStack::PushL(encryptor);

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

			CleanupStack::Pop(3, the3DESencryptor);

		}

		break;

		case (EAESECB):

		{

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

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

			CleanupStack::Pop(encryptor);

		}

		break;

		case (ERC2ECB):

		{

			encryptor = CRC2Encryptor::NewLC(iKey->Des(), iEffectiveKeyLen);

			decryptor = CRC2Decryptor::NewL(iKey->Des(), iEffectiveKeyLen);

			CleanupStack::Pop(encryptor);

		}

		break;

		case (ERC2CBC):

		{

			CBlockTransformation* theRC2encryptor = NULL;

			CBlockTransformation* theRC2decryptor = NULL;

			theRC2encryptor = CRC2Encryptor::NewLC(iKey->Des(), iEffectiveKeyLen);

			theRC2decryptor = CRC2Decryptor::NewLC(iKey->Des(), iEffectiveKeyLen);

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

			CleanupStack::PushL(encryptor);

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

			CleanupStack::Pop(3, theRC2encryptor);

		}

		break;

		case (ERC4):

		{

			iEncryptor = CARC4::NewL(*iKey,0);

			iDecryptor = CARC4::NewL(*iKey,0);

		}

		break;

		case (ECipherNull):

		{

			iEncryptor = CNullCipher::NewL();

			iDecryptor = CNullCipher::NewL();

		}

		break;

		default:

		{

			ASSERT(0);

			User::Leave(KErrNotSupported);

		}

	}

	CleanupStack::PushL(encryptor);

	CleanupStack::PushL(decryptor);

	if(!iEncryptor && !iDecryptor)

		{

		CPaddingSSLv3* dPadding = CPaddingSSLv3::NewLC(decryptor->BlockSize());

		CPaddingSSLv3* ePadding = CPaddingSSLv3::NewLC(encryptor->BlockSize());

		iEncryptor = CBufferedEncryptor::NewL(encryptor, ePadding);	

		CleanupStack::Pop(ePadding);

		iDecryptor = CBufferedDecryptor::NewL(decryptor, dPadding);

		CleanupStack::Pop(dPadding);

		}

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

	iDResult = HBufC8::NewMaxL(iDecryptor->MaxOutputLength(iEResult->Size()));

	CleanupStack::Pop(2, encryptor);

}

void CActionVector::DoPerformActionL()

{

//	First perform the test blockwise (ie passing in one block at a time)	

	TUint blockSize = iEncryptor->BlockSize();

	if((iInput->Size() % blockSize) != 0)

		{

		// input was not a multiple of the blocksize

		iResult = EFalse;

		return;

		}

	TUint index = 0;

	while (index <= (iInput->Size() - blockSize)) 

	{

		TPtr8 theEncryptResult((TUint8*)&(iEResult->operator[](index)), blockSize, blockSize);

		theEncryptResult.FillZ(theEncryptResult.MaxLength());

		theEncryptResult.SetLength(0);

		TPtrC8 theEncryptInput(iInput->Mid(index, blockSize));	

		iEncryptor->Process(theEncryptInput, theEncryptResult);

		if (iOutput->Mid(index, blockSize) == theEncryptResult)

			iResult = ETrue;

		else

			break;	//	No point doing any more

		index+=blockSize;

	}

	if (*iOutput==*iEResult)

	{

		iResult = ETrue;

		index = 0;

		while (index <= (iEResult->Size()- blockSize))

		{

			TPtr8 theDecryptResult((TUint8*)&(iDResult->operator[](index)), blockSize, blockSize);

			theDecryptResult.FillZ(theDecryptResult.MaxLength());

			theDecryptResult.SetLength(0);

			TPtrC8 theDecryptInput(iEResult->Mid(index, blockSize));

			iDecryptor->Process(theDecryptInput, theDecryptResult);

			if(iInput->Mid(index, blockSize) != theDecryptResult)

			{

				iResult = EFalse;

				break;	//	No point doing any more

			}

			index+=blockSize;

		}

		if (*iInput!=*iDResult)

		iResult = EFalse;	

	}

	iEncryptor->Reset();

	iDecryptor->Reset();

//	Now, if input is longer than a single block, repeat passing all the data

	if ((TUint)iInput->Size() > blockSize)

	{

		TPtr8 theEncryptResult(iEResult->Des());

		theEncryptResult.FillZ(theEncryptResult.MaxLength());

		theEncryptResult.SetLength(0);

		TPtrC8 theInput(*iInput);

		iEncryptor->Process(theInput, theEncryptResult);

		if (*iOutput!=*iEResult)

		{

			iResult = EFalse;

		}

		else

		{

			TPtr8 theDecryptResult(iDResult->Des());

			theDecryptResult.FillZ(theDecryptResult.MaxLength());

			theDecryptResult.SetLength(0);

			iDecryptor->Process(*iEResult, theDecryptResult);

			if (*iInput!=*iDResult)

				iResult = EFalse;

		}

	}

}