/*
* 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 "tactionincremental.h"
#include "symmetric.h"
#include "des.h"
#include "securityerr.h"

CTestAction* CActionIncremental::NewL(RFs& aFs,
									   CConsoleBase& aConsole,
									   Output& aOut, 
									   const TTestActionSpec& aTestActionSpec)
	{
	CTestAction* self = CActionIncremental::NewLC(aFs, aConsole,
		aOut, aTestActionSpec);
	CleanupStack::Pop();
	return self;
	}

CTestAction* CActionIncremental::NewLC(RFs& aFs,
										CConsoleBase& aConsole,
										Output& aOut, 
										const TTestActionSpec& aTestActionSpec)
	{
	CActionIncremental* self = new(ELeave) CActionIncremental(aFs, aConsole, aOut);
	CleanupStack::PushL(self);
	self->ConstructL(aTestActionSpec);
	return self;
	}

CActionIncremental::~CActionIncremental()
{
}

CActionIncremental::CActionIncremental(RFs& aFs, 
								 CConsoleBase& aConsole,
								 Output& aOut)						 
: CCryptoTestAction(aFs, aConsole, aOut)
{}

void CActionIncremental::DoPerformPostrequisiteL()
{
	if (iEncryptor)
		{
		iEncryptor->Reset();
		delete iEncryptor;
		}
	
	if (iDecryptor)
		{
		iDecryptor->Reset();
		delete iDecryptor;
		}
}

void CActionIncremental::DoPerformPrerequisiteL()
{
	iResult = ETrue;
	TInt err = KErrNone;
	TInt pos = 0;
	TPtrC8 incremental = Input::ParseElement(*iBody, KIncrementalStart, KIncrementalEnd, pos, err);

	DoInputParseL(incremental);

	CBlockTransformation* encryptor = NULL;
	CBlockTransformation* decryptor = NULL;

	iEncryptor =0;
	iDecryptor =0;

	switch (iCipherType)
	{
		case (EDESECB):
		{
		//If the test is weak key test
		if(iExpectedWeakResult == KErrWeakKey)
			{
			//we expect to leave with KErrWeakKey reason
			if(CDES::IsWeakKey(iKey->Des()))
				{
				User::Leave(KErrWeakKey);
				}
			else //test is unsuccessful, leave with a different reason
				{
				User::Leave(KErrGeneral);
				}	
			}		
			encryptor = CDESEncryptor::NewLC(iKey->Des());
			decryptor = CDESDecryptor::NewL(iKey->Des());
			CleanupStack::Pop(encryptor);
		}
		break;
		case (EDESCBC):
		{
			CBlockTransformation* desEncryptor = NULL;
			CBlockTransformation* desDecryptor = NULL;
 			
 			if(iExpectedWeakResult == KErrWeakKey)
 				{
 				if(CDES::IsWeakKey(iKey->Des()))
 					{
 					User::Leave(KErrWeakKey);
 					}
 				else
 					{
 					User::Leave(KErrGeneral);
 					}	
 				}

			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);
		}
		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);
		}
		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):
		{
			encryptor = CRC2Encryptor::NewLC(iKey->Des(), iEffectiveKeyLen);
			decryptor = CRC2Decryptor::NewL(iKey->Des(), iEffectiveKeyLen);
			CleanupStack::Pop(encryptor);
		}
		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);
		
		TInt desEBlockSize = encryptor->BlockSize();
		TInt desDBlockSize = decryptor->BlockSize();
		TInt bufEBlockSize = iEncryptor->BlockSize();
		TInt bufDBlockSize = iDecryptor->BlockSize();
		if ((desEBlockSize/desDBlockSize) != (bufEBlockSize/bufDBlockSize))
			{
			iResult = EFalse;
			}

		TInt desEKeySize = encryptor->KeySize();
		TInt desDKeySize = decryptor->KeySize();
		if (desEKeySize != desDKeySize)
			{
			iResult = EFalse;
			}
		
		encryptor->Reset();
		decryptor->Reset();		
		}
	
	TInt encryptorKeySize = iEncryptor->KeySize();
	TInt decryptorKeySize = iDecryptor->KeySize();
	if (encryptorKeySize != decryptorKeySize)
		{
		iResult = EFalse;
		}

	CleanupStack::Pop(2, encryptor);

	iEResult = HBufC8::NewMaxL(iEncryptor->MaxFinalOutputLength(iInput->Length()));
	iDResult = HBufC8::NewMaxL(iDecryptor->MaxFinalOutputLength(iEResult->Size()));
}

void CActionIncremental::DoPerformActionL()
	{
	TRAPD(res, DoDoPerformActionL())
	if(res == KErrNoMemory)
		{
		iEncryptor->Reset();
		iDecryptor->Reset();
		}
	}

void CActionIncremental::DoDoPerformActionL()
{
	__UHEAP_MARK;	
	TPtr8 eResultActual = iEResult->Des();
	eResultActual.FillZ(eResultActual.MaxLength());
	eResultActual.SetLength(0);

	TPtr8 dResultActual = iDResult->Des();
	dResultActual.FillZ(dResultActual.MaxLength());
	dResultActual.SetLength(0);

	TInt len = iInput->Length();
	for(TInt i=1; i<len; i++)
	{
		TInt j = 0;
		for(; j+i<len; j+=i)
		{//	encryption in blocks of size i
			iEncryptor->Process(iInput->Mid(j,i), eResultActual);
		}
	
		iEncryptor->ProcessFinalL(iInput->Mid(j), eResultActual);
		
		j=0;
		for(; (j+(len-i))<len; j+=(len-i))
		{//	Decryption in blocks of size (len - i)
			iDecryptor->Process(eResultActual.Mid(j, len-i), dResultActual);
		}
		
		iDecryptor->ProcessFinalL(eResultActual.Mid(j), dResultActual);
		
		if(dResultActual != *iInput)
		{
			iResult = EFalse;
		}
		
		eResultActual.FillZ(eResultActual.MaxLength());
		dResultActual.FillZ(dResultActual.MaxLength());
		eResultActual.SetLength(0);
		dResultActual.SetLength(0);
	}
	__UHEAP_MARKEND;

}