--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcrypto/test/tasymmetric/trsaencryptfb.cpp	Wed Jul 08 11:25:26 2009 +0100
@@ -0,0 +1,391 @@
+/*
+* 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 "trsaencryptfb.h"
+#include "t_input.h"
+#include <asymmetric.h>
+#include <padding.h>
+#include <bigint.h>
+#include "performancetest.h"
+#include <securityerr.h>
+
+_LIT8(KInputStart, "<input>");
+_LIT8(KInputEnd, "</input>");
+_LIT8(KKeyBitsStart, "<keybits>");
+_LIT8(KKeyBitsEnd, "</keybits>");
+
+CRSAEncryptFB::~CRSAEncryptFB()
+	{
+	delete iBody;
+	}
+
+CRSAEncryptFB::CRSAEncryptFB(RFs& aFs, CConsoleBase& aConsole, Output& aOut)
+	: CTestAction(aConsole, aOut), iFs(aFs), iKeyBits(512)	//	Default key size = 512
+	{
+	}
+
+CTestAction* CRSAEncryptFB::NewL(RFs& aFs, CConsoleBase& aConsole, Output& aOut, 
+	const TTestActionSpec& aTestActionSpec)
+	{
+	CTestAction* self = CRSAEncryptFB::NewLC(aFs, aConsole,
+		aOut, aTestActionSpec);
+	CleanupStack::Pop();
+	return self;
+	}
+
+CTestAction* CRSAEncryptFB::NewLC(RFs& aFs, CConsoleBase& aConsole,Output& aOut,
+	const TTestActionSpec& aTestActionSpec)
+	{
+	CRSAEncryptFB* self = new(ELeave) CRSAEncryptFB(aFs, aConsole, aOut);
+	CleanupStack::PushL(self);
+	self->ConstructL(aTestActionSpec);
+	return self;
+	}
+
+void CRSAEncryptFB::ConstructL(const TTestActionSpec& aTestActionSpec)
+{
+	CTestAction::ConstructL(aTestActionSpec);
+	iBody = HBufC8::NewL(aTestActionSpec.iActionBody.Length());
+	iBody->Des().Copy(aTestActionSpec.iActionBody);	
+
+	if (CPerformance::PerformanceTester()->IsTestingPerformance())
+	{//	Number of test iterations
+		TPtrC8 itsPtr = Input::ParseElement(aTestActionSpec.iActionBody, KIterationsStart, KIterationsEnd);
+		if (itsPtr!=KNullDesC8)
+		{
+			TLex8 lex;
+			lex.Assign(itsPtr);
+			User::LeaveIfError(lex.Val(iPerfTestIterations));
+			if (iPerfTestIterations > KMaxIterations)
+				User::Panic(_L("AsymmetricPerformance.exe"), KErrArgument);
+		}
+		TPtrC8 cryptoPtr = Input::ParseElement(aTestActionSpec.iActionBody, KTypeOfCryptoStart, KTypeOfCryptoEnd);
+		if (cryptoPtr.CompareF(KRSAStandard) == 0)
+			{
+			iCryptoType = EStandard;
+			}
+		else if (cryptoPtr.CompareF(KRSAStandardCRT) == 0)
+			{
+			iCryptoType = EStandardCRT;
+			}
+		else
+			{
+			User::Panic(_L("AsymmetricPerformance.exe"), KErrArgument);
+			}
+	}
+
+	TPtrC8 keyBitsPtr = Input::ParseElement(*iBody, KKeyBitsStart, KKeyBitsEnd); 
+	if (keyBitsPtr!=KNullDesC8)
+	{
+		TLex8 lex;
+		lex.Assign(keyBitsPtr);
+		User::LeaveIfError(lex.Val(iKeyBits));
+	}
+}
+
+void CRSAEncryptFB::DoPerformPrerequisite(TRequestStatus& aStatus)
+	{
+	TRequestStatus* status = &aStatus;
+
+	TPtrC8 inputTemp = Input::ParseElement(*iBody, KInputStart, KInputEnd);
+	iInput = HBufC8::NewL(inputTemp.Length());
+	*iInput = inputTemp;
+	Hex(*iInput);
+
+	User::RequestComplete(status, KErrNone);
+	iActionState = CTestAction::EAction;
+	}
+
+void CRSAEncryptFB::DoPerformPostrequisite(TRequestStatus& aStatus)
+	{
+	TRequestStatus* status = &aStatus;
+	delete iInput;
+
+	iFinished = ETrue;
+	User::RequestComplete(status, iActionResult);
+	}
+
+void CRSAEncryptFB::DoReportAction(void)
+	{
+	}
+
+void CRSAEncryptFB::DoCheckResult(TInt)
+	{
+	if (iResult)
+		iConsole.Printf(_L("."));
+	else
+		iConsole.Printf(_L("X"));
+	}
+
+void CRSAEncryptFB::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);
+    }
+
+
+void CRSAEncryptFB::PerformAction(TRequestStatus& aStatus)
+{
+	TRequestStatus* status = &aStatus;
+	
+	if (CPerformance::PerformanceTester()->IsTestingPerformance())
+	{
+		iConsole.Printf(_L(">"));	//	Indicates start of test
+		TRAP(iActionResult, DoPerformanceTestActionL());
+	}
+	else
+	{
+		TRAP(iActionResult, DoPerformActionL());
+	}
+	
+	if (iActionResult==KErrNoMemory)
+		{
+		User::Leave(iActionResult);	//	For OOM testing
+		}
+	if (iActionResult==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"));
+		}
+
+	User::RequestComplete(status, iActionResult);
+
+	iActionState = CTestAction::EPostrequisite;
+}
+
+void CRSAEncryptFB::DoPerformanceTestActionL()
+{
+	__UHEAP_MARK;
+	iResult = EFalse;
+
+	TTimeIntervalMicroSeconds keyCreateTime(0);
+	TTimeIntervalMicroSeconds encryptTime(0);
+	TTimeIntervalMicroSeconds decryptTime(0);
+	TTime start, end;
+	TTimeIntervalSeconds diff(0);
+	const TTimeIntervalSeconds KIterationTime(iPerfTestIterations);
+
+//	Time key pair creation
+	CRSAKeyPair *rsaPair = NULL;
+	TInt noKeyPairCreations = 0;
+	
+	start.UniversalTime();
+	while (diff < KIterationTime)
+		{
+		rsaPair = CRSAKeyPair::NewLC(iKeyBits, TypeOfCrypto());
+		CleanupStack::PopAndDestroy();
+		noKeyPairCreations++;
+		end.UniversalTime();
+		end.SecondsFrom(start, diff);
+		}
+	end.UniversalTime();
+	keyCreateTime = end.MicroSecondsFrom(start);
+	TReal keycreatetime = I64REAL(keyCreateTime.Int64());
+	
+	rsaPair = CRSAKeyPair::NewLC(iKeyBits, TypeOfCrypto()); // Create one keypair for operations
+	
+	CRSAPKCS1v15Encryptor* encryptor = CRSAPKCS1v15Encryptor::NewL(rsaPair->PublicKey());
+	CleanupStack::PushL(encryptor);
+
+	CRSAPKCS1v15Decryptor* decryptor = CRSAPKCS1v15Decryptor::NewL(rsaPair->PrivateKey());
+	CleanupStack::PushL(decryptor);
+	
+	HBufC8 *eResult = HBufC8::NewLC(encryptor->MaxOutputLength());
+	TPtr8 ePtr = eResult->Des();
+	TPtr8* eResultPtr = &ePtr;
+
+	
+//	Time encryption	
+	diff = 0;
+	TInt noEncryptions = 0;
+	start.UniversalTime();
+	while (diff < KIterationTime)
+		{
+		eResultPtr->Zero();
+		encryptor->EncryptL(*iInput, *eResultPtr);
+		noEncryptions++;
+		end.UniversalTime();
+		end.SecondsFrom(start, diff);
+		}
+	end.UniversalTime();
+	encryptTime = end.MicroSecondsFrom(start);
+	TReal encrypttime = I64REAL(encryptTime.Int64());
+		
+//	Time decryption
+	diff = 0;
+	HBufC8 *dResult = HBufC8::NewLC(decryptor->MaxOutputLength());
+	ePtr = eResult->Des();
+	eResultPtr = &ePtr;
+	TPtr8 dPtr = dResult->Des();
+	TPtr8* dResultPtr = &dPtr;
+	TInt noDecryptions = 0;
+	start.UniversalTime();
+	while (diff < KIterationTime)
+		{
+		decryptor->DecryptL(*eResultPtr, *dResultPtr);
+		noDecryptions++;
+		end.UniversalTime();
+		end.SecondsFrom(start, diff);
+		}
+	end.UniversalTime();
+	decryptTime = end.MicroSecondsFrom(start);
+    TReal decrypttime = I64REAL(decryptTime.Int64());
+	
+	iResult = ETrue;
+	if (*iInput != *dResult)
+	{
+		iResult = EFalse;		
+	}
+	
+	CleanupStack::PopAndDestroy(5);	//	dResult,eResult,decryptor,encryptor,rsaPair
+	__UHEAP_MARKEND;
+
+	if (iResult)
+	{
+		TReal rate = I64REAL(keyCreateTime.Int64()) / noKeyPairCreations;
+		TBuf<256> buf;
+		_LIT(KKeyCreateTime, "\n\tKeyCreate: %f us/key pair (%i key pairs in %f us)\r\n");
+  		buf.Format(KKeyCreateTime, rate, noKeyPairCreations, keycreatetime);
+		iOut.writeString(buf);
+		
+		rate = I64REAL(encryptTime.Int64()) / noEncryptions;
+		_LIT(KEncryptTime, "\tEncrypt: %f us/encryption (%i encryptions in %f us)\r\n");
+  		buf.Format(KEncryptTime, rate, noEncryptions, encrypttime);
+		iOut.writeString(buf);
+
+		rate = I64REAL(decryptTime.Int64()) / noDecryptions;
+		_LIT(KDecryptTime, "\tDecrypt: %f us/decryption (%i decryptions in %f us)\r\n");
+  		buf.Format(KDecryptTime, rate, noDecryptions, decrypttime);
+		iOut.writeString(buf);
+	}
+	else
+	{
+		_LIT(KNoTimingInfo, "\tTest Failed! No benchmark data\n");
+		iOut.writeString(KNoTimingInfo);
+	}
+}
+
+void CRSAEncryptFB::DoPerformActionL()
+	{
+	__UHEAP_MARK;
+	
+	iResult = EFalse;
+
+	CRSAKeyPair* rsaPair = CRSAKeyPair::NewLC(iKeyBits, TypeOfCrypto());
+	//LogKeyData(static_cast<const CRSAPublicKey*>(&rsaPair->PublicKey()), static_cast<const CRSAPrivateKeyCRT*>(&rsaPair->PrivateKey()), KNullDesC8);
+	
+	CRSAPKCS1v15Encryptor* encryptor = CRSAPKCS1v15Encryptor::NewL(rsaPair->PublicKey());
+	CleanupStack::PushL(encryptor);
+
+	CRSAPKCS1v15Decryptor* decryptor = CRSAPKCS1v15Decryptor::NewL(rsaPair->PrivateKey());
+	CleanupStack::PushL(decryptor);
+
+	HBufC8* eResult = HBufC8::NewLC(encryptor->MaxOutputLength());
+	HBufC8* dResult = HBufC8::NewLC(decryptor->MaxOutputLength());
+
+	TPtr8 eResultPtr = eResult->Des();
+	encryptor->EncryptL(*iInput, eResultPtr);
+
+	TPtr8 dResultPtr = dResult->Des();
+	if (TypeOfCrypto() == EStandardCRT)
+		{
+		TRAPD(res, decryptor->DecryptL(eResultPtr, dResultPtr));
+		if (res==KErrCorrupt)	//	Log all the key data for this failure
+			LogKeyData(static_cast<const CRSAPublicKey*>(&rsaPair->PublicKey()), static_cast<const CRSAPrivateKeyCRT*>(&rsaPair->PrivateKey()), *eResult);
+
+		User::LeaveIfError(res);
+		}
+	else
+		{
+		decryptor->DecryptL(eResultPtr, dResultPtr);
+		}
+		
+	if(*iInput == *dResult)
+		{
+		iResult = ETrue;
+		}
+	
+	CleanupStack::PopAndDestroy(dResult);
+	CleanupStack::PopAndDestroy(eResult);
+	CleanupStack::PopAndDestroy(decryptor);
+	CleanupStack::PopAndDestroy(encryptor);
+	CleanupStack::PopAndDestroy(rsaPair);
+
+	__UHEAP_MARKEND;
+	}
+
+void CRSAEncryptFB::LogKeyData(const CRSAPublicKey* aPublicKey, const CRSAPrivateKeyCRT* aPrivateKeyCRT, const TDesC8& aCipherText)
+{
+	iOut.writeString(_L("\n\t ----------- e -----------\n\r"));
+	const TInteger& keyE = aPublicKey->E();
+	HBufC8* theE = keyE.BufferLC();	
+	iOut.writeOctetString(*theE);
+
+	iOut.writeString(_L("\n\t ----------- P -----------\n\r"));
+	const TInteger& keyP = aPrivateKeyCRT->P();
+	HBufC8* theP = keyP.BufferLC();	
+	iOut.writeOctetString(*theP);
+
+	iOut.writeString(_L("\n\t ----------- Q -----------\n\r"));
+	const TInteger& keyQ = aPrivateKeyCRT->Q();
+	HBufC8* theQ = keyQ.BufferLC();	
+	iOut.writeOctetString(*theQ);
+
+	iOut.writeString(_L("\n\t ----------- DP -----------\n\r"));
+	const TInteger& keyDP = aPrivateKeyCRT->DP();
+	HBufC8* theDP = keyDP.BufferLC();	
+	iOut.writeOctetString(*theDP);
+
+	iOut.writeString(_L("\n\t ----------- DQ -----------\n\r"));
+	const TInteger& keyDQ = aPrivateKeyCRT->DQ();
+	HBufC8* theDQ = keyDQ.BufferLC();	
+	iOut.writeOctetString(*theDQ);
+
+	iOut.writeString(_L("\n\t ----------- QInv -----------\n\r"));
+	const TInteger& keyQInv = aPrivateKeyCRT->QInv();
+	HBufC8* theQInv = keyQInv.BufferLC();	
+	iOut.writeOctetString(*theQInv);
+
+	iOut.writeString(_L("\n\t ----------- N -----------\n\r"));
+	const TInteger& keyN = aPrivateKeyCRT->N();
+	HBufC8* theN = keyN.BufferLC();	
+	iOut.writeOctetString(*theN);
+
+	iOut.writeString(_L("\n\t ----------- ciphertext -----------\n\r"));	
+	iOut.writeOctetString(aCipherText);
+	
+	iOut.writeString(_L("\n\t -------------------------\n\r"));
+	
+	CleanupStack::PopAndDestroy(6);	
+
+}