--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/test/tsymmetric/cryptotestaction.cpp	Thu Sep 10 14:01:51 2009 +0300
@@ -0,0 +1,275 @@
+/*
+* 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 "cryptotestaction.h"
+#include <securityerr.h>
+#include <cryptostrength.h>
+#include "../common/inlines.h"
+#include "t_output.h"
+
+CCryptoTestAction::CCryptoTestAction(RFs& aFs, CConsoleBase& aConsole, Output& aOut)
+:	CTestAction(aConsole, aOut), iFs(aFs), iEffectiveKeyLen(128)
+{}
+
+CCryptoTestAction::~CCryptoTestAction()
+{
+	delete iBody;
+}
+
+void CCryptoTestAction::ConstructL(const TTestActionSpec& aTestActionSpec)
+{
+	CTestAction::ConstructL(aTestActionSpec);
+	iBody = HBufC8::NewL(aTestActionSpec.iActionBody.Length());
+	iBody->Des().Copy(aTestActionSpec.iActionBody);	
+}
+
+void CCryptoTestAction::DoPerformPrerequisite(TRequestStatus& aStatus)
+{
+	TRequestStatus* status = &aStatus;
+	
+	TRAPD(r, DoPerformPrerequisiteL());
+	if ((r != iExpectedWeakResult) && (TCrypto::Strength() == TCrypto::EWeak))
+		{
+		r = KErrUnknown;
+		}
+	User::RequestComplete(status, r);
+	if (KErrNone==r)
+		{
+		iActionState = CTestAction::EAction;
+		}
+	else if (r==KErrKeyNotWeakEnough)
+		{
+		iResult = ETrue;
+		iConsole.Printf(_L("Crypto libraries returned KErrKeyNotWeakEnough!  Passing test automatically.\n\r"));
+		iOut.writeString(_L("Crypto libraries returned KErrKeyNotWeakEnough!  Passing test automatically.\r\n"));
+		iActionState = CTestAction::EPostrequisite;
+		}
+	else if (r==KErrWeakKey)
+ 		{
+ 		iResult = ETrue;
+ 		iConsole.Printf(_L("Crypto libraries returned KErrWeakKey!  Passing test automatically.\n\r"));
+ 		iOut.writeString(_L("Crypto libraries returned KErrWeakKey!  Passing test automatically.\r\n"));
+ 		iActionState = CTestAction::EPostrequisite;
+ 		}
+	else
+		{
+		iActionState = CTestAction::EPostrequisite;
+		}
+}
+
+void CCryptoTestAction::DoPerformPostrequisite(TRequestStatus& aStatus)
+{
+	TRequestStatus* status = &aStatus;
+	TRAPD(r, DoPerformPostrequisiteL());
+	delete iKey;
+	delete iInput;
+	delete iOutput;
+	delete iIV;
+	delete iEResult;
+	delete iDResult;
+
+	iFinished = ETrue;
+	User::RequestComplete(status, r);
+}
+
+void CCryptoTestAction::DoReportAction(void)
+{}
+
+void CCryptoTestAction::DoCheckResult(TInt)
+{
+	if (iResult==EFalse)
+		iConsole.Printf(_L("X"));
+	else
+		iConsole.Printf(_L("."));
+}
+
+void CCryptoTestAction::PerformAction(TRequestStatus& aStatus)
+{
+	TRequestStatus* status = &aStatus;
+
+	TRAPD(res, DoPerformActionL());
+	if (res==KErrNoMemory)
+		{
+		User::Leave(res);	//	For OOM testing
+		}
+	iActionState = CTestAction::EPostrequisite;
+	User::RequestComplete(status, res);
+}
+
+
+void CCryptoTestAction::DoInputParseL(TDesC8& aScriptBuffer)
+{
+	TInt err = KErrNone;
+	TInt pos = 0;
+
+	TPtrC8 keyTemp = Input::ParseElement(aScriptBuffer, KKeyStart, KKeyEnd, pos=0, err);
+	iKey = HBufC8::NewL(keyTemp.Length());
+	*iKey = keyTemp;
+	Hex(*iKey);
+
+	TPtrC8 inputTemp = Input::ParseElement(aScriptBuffer, KInputStart, KInputEnd, pos=0, err);
+	iInput = HBufC8::NewL(inputTemp.Length());
+	*iInput = inputTemp;
+	Hex(*iInput);
+
+	TPtrC8 ivTemp = Input::ParseElement(aScriptBuffer, KIVStart, KIVEnd, pos=0, err);
+	iIV = HBufC8::NewL(ivTemp.Length());
+	*iIV = ivTemp;
+	Hex(*iIV);
+
+	TPtrC8 outputTemp = Input::ParseElement(aScriptBuffer, KOutputStart, KOutputEnd, pos=0, err);
+	iOutput = HBufC8::NewL(outputTemp.Length());
+	*iOutput = outputTemp;
+	Hex(*iOutput);
+
+	TPtrC8 cipherType = Input::ParseElement(aScriptBuffer, KCipherTypeStart, KCipherTypeEnd, pos=0, err);
+	iExpectedWeakResult = KErrNone;
+	if( cipherType == _L8("DESECB") )
+	{
+		iCipherType = EDESECB;
+	}
+	else if( cipherType == _L8("DESCBC") )
+	{
+		iCipherType = EDESCBC;
+	}
+	else if( cipherType == _L8("3DESECB") )
+	{
+		iCipherType = E3DESECB;
+		iExpectedWeakResult = KErrKeyNotWeakEnough;
+	}
+	else if( cipherType == _L8("3DESCBC") )
+	{
+		iCipherType = E3DESCBC;
+		iExpectedWeakResult = KErrKeyNotWeakEnough;
+	}
+	else if( cipherType == _L8("AESECB") )
+	{
+		iCipherType = EAESECB;
+		iExpectedWeakResult = KErrKeyNotWeakEnough;
+	}
+	else if (cipherType==_L8("AESENC_ECB") )
+	{
+		iCipherType = EAESMonteCarloEncryptECB;	
+		iExpectedWeakResult = KErrKeyNotWeakEnough;
+	}
+	else if (cipherType==_L8("AESDEC_ECB") )
+	{
+		iCipherType = EAESMonteCarloDecryptECB;	
+		iExpectedWeakResult = KErrKeyNotWeakEnough;
+	}
+	else if (cipherType==_L8("AESENC_CBC") )
+	{
+		iCipherType = EAESMonteCarloEncryptCBC;	
+		iExpectedWeakResult = KErrKeyNotWeakEnough;
+	}
+	else if (cipherType==_L8("AESDEC_CBC") )
+	{
+		iCipherType = EAESMonteCarloDecryptCBC;		
+		iExpectedWeakResult = KErrKeyNotWeakEnough;
+	}
+	else if( cipherType == _L8("RC2ECB") )
+	{
+		iCipherType = ERC2ECB;
+		// weak enough if either aKey or aEffectiveKeyLen is weak
+		TInt minKeySize = Min(iEffectiveKeyLen, BytesToBits(iKey->Size()));
+		TRAP(iExpectedWeakResult, TCrypto::IsSymmetricWeakEnoughL(minKeySize));
+	}
+	else if( cipherType == _L8("RC2CBC") )
+	{
+		iCipherType = ERC2CBC;
+		// weak enough if either aKey or aEffectiveKeyLen is weak
+		TInt minKeySize = Min(iEffectiveKeyLen, BytesToBits(iKey->Size()));
+		TRAP(iExpectedWeakResult, TCrypto::IsSymmetricWeakEnoughL(minKeySize));
+	}
+	else if( cipherType == _L8("RC4") )
+	{
+		iCipherType = ERC4;
+		TRAP(iExpectedWeakResult, TCrypto::IsSymmetricWeakEnoughL(BytesToBits(iKey->Size())));
+	}
+	else if( cipherType == _L8("NULL") )
+	{
+		iCipherType = ECipherNull;
+	}
+ 	else if( cipherType == _L8("DESECB_WKT"))
+ 	{
+ 		iCipherType = EDESECB;	
+ 		iExpectedWeakResult = KErrWeakKey;
+ 	}
+ 	else if( cipherType == _L8("DESCBC_WKT"))
+ 	{
+ 		iCipherType = EDESCBC;	
+ 		iExpectedWeakResult = KErrWeakKey;
+ 	}
+	else 
+	{
+		TBuf<64> cipherName(0);
+		cipherName.Copy(cipherType);
+		TBuf<256> formattable;
+		formattable.Format(_L("\nBad Cipher Type: %S"), &cipherName);
+		iConsole.Printf(formattable);
+
+		iActionState = CTestAction::EPostrequisite;
+		User::Leave(KErrNotSupported);
+	}
+
+	if ( (iCipherType==ERC2ECB) || (iCipherType==ERC2CBC) )
+	{
+		TPtrC8 effKeyLenTemp = Input::ParseElement(aScriptBuffer, KEffKeyLenStart, KEffKeyLenEnd, pos=0, err);
+
+		if (effKeyLenTemp.Length() != 0)
+		{
+			TLex8 lex;
+			lex.Assign(effKeyLenTemp);
+			User::LeaveIfError(lex.Val(iEffectiveKeyLen));
+		}
+	}
+
+	TPtrC8 iterationsTemp = Input::ParseElement(aScriptBuffer, KIterationsStart, KIterationsEnd, pos=0, err);	
+	TLex8 lex;
+	lex.Assign(iterationsTemp);
+	err = lex.Val(iIterationTime);
+
+	TPtrC8 randTemp = Input::ParseElement(aScriptBuffer, KRandDataSizeStart, KRandDataSizeEnd, pos=0, err);	
+	TLex8 randlex;
+	randlex.Assign(randTemp);
+	err = randlex.Val(iRandDataSize);	
+
+	delete iBody;
+	iBody = NULL;
+}
+
+void CCryptoTestAction::Hex(HBufC8& aString)
+    {
+    TPtr8 ptr=aString.Des();
+    if (aString.Length()%2)
+        {
+        ptr.SetLength(0);
+        return;
+        }
+    TInt i;
+    for (i=0;i<aString.Length();i+=2)
+        {
+        TUint8 tmp;
+        tmp=(TUint8)(aString[i]-(aString[i]>'9'?('A'-10):'0'));
+        tmp*=16;
+        tmp|=(TUint8)(aString[i+1]-(aString[i+1]>'9'?('A'-10):'0'));
+        ptr[i/2]=tmp;
+        }
+    ptr.SetLength(aString.Length()/2);
+    }
+