--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/test/tsymmetric/tactionincremental.cpp	Thu Sep 10 14:01:51 2009 +0300
@@ -0,0 +1,290 @@
+/*
+* 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;
+
+}
+