os/security/crypto/weakcrypto/test/tasymmetric/trsasignfb.cpp
author sl
Tue, 10 Jun 2014 14:32:02 +0200
changeset 1 260cb5ec6c19
permissions -rw-r--r--
Update contrib.
     1 /*
     2 * Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).
     3 * All rights reserved.
     4 * This component and the accompanying materials are made available
     5 * under the terms of the License "Eclipse Public License v1.0"
     6 * which accompanies this distribution, and is available
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
     8 *
     9 * Initial Contributors:
    10 * Nokia Corporation - initial contribution.
    11 *
    12 * Contributors:
    13 *
    14 * Description: 
    15 *
    16 */
    17 
    18 
    19 #include "trsasignfb.h"
    20 #include "t_input.h"
    21 #include <asymmetric.h>
    22 #include <padding.h>
    23 #include <bigint.h>
    24 #include "performancetest.h"
    25 
    26 _LIT8(KInputStart, "<input>");
    27 _LIT8(KKeyBitsStart, "<keybits>");
    28 _LIT8(KKeyBitsEnd, "</keybits>");
    29 
    30 CRSASignFB::~CRSASignFB()
    31 	{
    32 	delete iBody;
    33 	}
    34 
    35 CRSASignFB::CRSASignFB(RFs& aFs, CConsoleBase& aConsole, Output& aOut)
    36 	: CTestAction(aConsole, aOut), iFs(aFs), iPerfTestIterations(100)
    37 	{
    38 	}
    39 
    40 CTestAction* CRSASignFB::NewL(RFs& aFs, CConsoleBase& aConsole, Output& aOut, 
    41 	const TTestActionSpec& aTestActionSpec)
    42 	{
    43 	CTestAction* self = CRSASignFB::NewLC(aFs, aConsole,
    44 		aOut, aTestActionSpec);
    45 	CleanupStack::Pop();
    46 	return self;
    47 	}
    48 
    49 CTestAction* CRSASignFB::NewLC(RFs& aFs, CConsoleBase& aConsole, Output& aOut, 
    50 	const TTestActionSpec& aTestActionSpec)
    51 	{
    52 	CRSASignFB* self = new(ELeave) CRSASignFB(aFs, aConsole, aOut);
    53 	CleanupStack::PushL(self);
    54 	self->ConstructL(aTestActionSpec);
    55 	return self;
    56 	}
    57 
    58 
    59 TRSAPrivateKeyType CRSASignFB::TypeOfCrypto()
    60 	{
    61 	return iCryptoType;
    62 	}
    63 	
    64 void CRSASignFB::ConstructL(const TTestActionSpec& aTestActionSpec)
    65 {
    66 	CTestAction::ConstructL(aTestActionSpec);
    67 	iBody = HBufC8::NewL(aTestActionSpec.iActionBody.Length());
    68 	iBody->Des().Copy(aTestActionSpec.iActionBody);
    69 
    70 	if (CPerformance::PerformanceTester()->IsTestingPerformance())
    71 	{//	Number of test iterations
    72 		TPtrC8 itsPtr = Input::ParseElement(aTestActionSpec.iActionBody, KIterationsStart, KIterationsEnd);
    73 		if (itsPtr!=KNullDesC8)
    74 		{
    75 			TLex8 lex;
    76 			lex.Assign(itsPtr);
    77 			User::LeaveIfError(lex.Val(iPerfTestIterations));
    78 			if (iPerfTestIterations > KMaxIterations)
    79 				User::Panic(_L("AsymmetricPerformance.exe"), KErrArgument);
    80 			
    81 		}
    82 		TPtrC8 cryptoPtr = Input::ParseElement(aTestActionSpec.iActionBody, KTypeOfCryptoStart, KTypeOfCryptoEnd);
    83 		if (cryptoPtr.CompareF(KRSAStandard) == 0)
    84 			{
    85 			iCryptoType = EStandard;
    86 			}
    87 		else if (cryptoPtr.CompareF(KRSAStandardCRT) == 0)
    88 			{
    89 			iCryptoType = EStandardCRT;
    90 			}
    91 		else
    92 			{
    93 			User::Panic(_L("AsymmetricPerformance.exe"), KErrArgument);
    94 			}
    95 	}
    96 
    97 	TPtrC8 keyBitsPtr = Input::ParseElement(*iBody, KKeyBitsStart, KKeyBitsEnd); 
    98 	if (keyBitsPtr!=KNullDesC8)
    99 	{
   100 		TLex8 lex;
   101 		lex.Assign(keyBitsPtr);
   102 		User::LeaveIfError(lex.Val(iKeyBits));
   103 	}
   104 }
   105 
   106 void CRSASignFB::DoPerformPrerequisite(TRequestStatus& aStatus)
   107 	{
   108 	TRequestStatus* status = &aStatus;
   109 
   110 	HBufC8* input = Input::ParseElementHexL(*iBody, KInputStart);
   111 	CleanupStack::PushL(input);
   112 	iSigInput = CHashingSignatureInput::NewL(CMessageDigest::ESHA1);
   113 	iSigInput->Update(*input);
   114 	iInput = iSigInput->Final().AllocL();
   115 	CleanupStack::PopAndDestroy(input);
   116 
   117 	User::RequestComplete(status, KErrNone);
   118 	iActionState = CTestAction::EAction;
   119 	}
   120 
   121 void CRSASignFB::DoPerformPostrequisite(TRequestStatus& aStatus)
   122 	{
   123 	TRequestStatus* status = &aStatus;
   124 	delete iInput;
   125 	delete iSigInput;
   126 
   127 	iFinished = ETrue;
   128 	User::RequestComplete(status, iActionResult);
   129 	}
   130 
   131 void CRSASignFB::DoReportAction(void)
   132 	{
   133 	}
   134 
   135 void CRSASignFB::DoCheckResult(TInt)
   136 	{
   137 	if (iResult)
   138 		iConsole.Printf(_L("."));
   139 	else
   140 		iConsole.Printf(_L("X"));
   141 	}
   142 
   143 void CRSASignFB::Hex(HBufC8& aString)
   144     {
   145     TPtr8 ptr=aString.Des();
   146     if (aString.Length()%2)
   147         {
   148         ptr.SetLength(0);
   149         return;
   150         }
   151     TInt i;
   152     for (i=0;i<aString.Length();i+=2)
   153         {
   154         TUint8 tmp;
   155         tmp=(TUint8)(aString[i]-(aString[i]>'9'?('A'-10):'0'));
   156         tmp*=16;
   157         tmp|=(TUint8)(aString[i+1]-(aString[i+1]>'9'?('A'-10):'0'));
   158         ptr[i/2]=tmp;
   159         }
   160     ptr.SetLength(aString.Length()/2);
   161     }
   162 
   163 void CRSASignFB::PerformAction(TRequestStatus& aStatus)
   164 	{
   165 	TRequestStatus* status = &aStatus;
   166 
   167 	if (CPerformance::PerformanceTester()->IsTestingPerformance())
   168 	{
   169 		iConsole.Printf(_L(">"));	//	Indicates start of test
   170 		TRAP(iActionResult, DoPerformanceTestActionL());
   171 	}
   172 	else
   173 	{
   174 		TRAP(iActionResult, DoPerformActionL());
   175 	}
   176 
   177 	if (iActionResult==KErrNoMemory)
   178 		User::Leave(iActionResult);	//	For OOM testing
   179 	
   180 	User::RequestComplete(status, iActionResult);
   181 	iActionState = CTestAction::EPostrequisite;
   182 	}
   183 
   184 
   185 void CRSASignFB::DoPerformanceTestActionL()
   186 {
   187 	__UHEAP_MARK;
   188 	iResult = EFalse;
   189 
   190 	TTimeIntervalMicroSeconds keyCreateTime(0);
   191 	TTimeIntervalMicroSeconds signTime(0);
   192 	TTimeIntervalMicroSeconds verifyTime(0);
   193 	TTime start, end;
   194 	TTimeIntervalSeconds diff(0);
   195 	const TTimeIntervalSeconds KIterationTime(iPerfTestIterations);
   196 
   197 	//	Time key pair creation
   198 	CRSAKeyPair *rsaPair = NULL;
   199 	TUint noRSAPairs = 0;
   200 	start.UniversalTime();
   201 	while (diff < KIterationTime)
   202 	{
   203        rsaPair = CRSAKeyPair::NewLC(iKeyBits, TypeOfCrypto());
   204        CleanupStack::PopAndDestroy();
   205        noRSAPairs++;
   206 	   end.UniversalTime();
   207 	   end.SecondsFrom(start, diff);
   208 	}
   209 	end.UniversalTime();
   210 	keyCreateTime = end.MicroSecondsFrom(start);
   211 	TReal keycreatetime = I64REAL(keyCreateTime.Int64());
   212 	
   213 	rsaPair=CRSAKeyPair::NewLC(iKeyBits, TypeOfCrypto()); // Create one keypair for operations
   214 
   215 	CRSAPKCS1v15Signer* signer = CRSAPKCS1v15Signer::NewL(rsaPair->PrivateKey());
   216 	CleanupStack::PushL(signer);
   217 	CRSAPKCS1v15Verifier* verifier = CRSAPKCS1v15Verifier::NewL(rsaPair->PublicKey());
   218 	CleanupStack::PushL(verifier);
   219 
   220 	const CRSASignature  *testSig;
   221 
   222 	//	Time signing
   223 	diff = 0;
   224 	TInt noSignings = 0;
   225 	start.UniversalTime();
   226 	while (diff < KIterationTime)
   227 	{
   228 		testSig = signer->SignL(*iInput);
   229 		delete testSig;
   230 		noSignings++;
   231 		end.UniversalTime();
   232 		end.SecondsFrom(start, diff);
   233 	}
   234 	end.UniversalTime();
   235 	signTime = end.MicroSecondsFrom(start);
   236 	TReal signtime = I64REAL(signTime.Int64());	
   237 	//	Time verification
   238 	TInt noVerifies = 0;
   239 	diff = 0;
   240 	testSig = signer->SignL(*iInput);
   241 	CleanupStack::PushL(const_cast<CRSASignature*>(testSig));
   242 	start.UniversalTime();
   243 	while (diff < KIterationTime)
   244 	{
   245 		iResult = verifier->VerifyL(*iInput, *testSig);
   246 
   247 		// do as many verfies as possible 
   248 		if (!iResult)
   249 		{
   250 		   break;
   251 		}
   252 		noVerifies++;
   253 		end.UniversalTime();
   254 		end.SecondsFrom(start, diff);
   255 	}	
   256 	end.UniversalTime();
   257 	verifyTime = end.MicroSecondsFrom(start);
   258     TReal verifytime = I64REAL(verifyTime.Int64());
   259 	CleanupStack::PopAndDestroy(4);	//	verifier,signer,testSig,rsaPairs
   260 	__UHEAP_MARKEND;
   261 		 
   262 	if (iResult)
   263 	{
   264 		TBuf<256> buf;
   265 		TReal rate = I64REAL(keyCreateTime.Int64()) / noRSAPairs;
   266 		
   267 		_LIT(KKeyCreateTime, "\n\tKeyCreate: %f us/key creation (no creations: %i in %f us)\r\n");
   268  		buf.Format(KKeyCreateTime, rate, noRSAPairs, keycreatetime);
   269 		iOut.writeString(buf);
   270 
   271 		rate = I64REAL(signTime.Int64()) / noSignings;
   272 		_LIT(KSignTime, "\tSigning: %f us/signing (no signings: %i in %f us)\r\n");
   273   		buf.Format(KSignTime, rate, noSignings, signtime);
   274 		iOut.writeString(buf);
   275 		
   276 		rate = I64REAL(verifyTime.Int64()) / noVerifies;
   277 		_LIT(KVerifyTime, "\tVerifying: %f us/verify (no verfies: %i in %f us)\r\n");
   278  		buf.Format(KVerifyTime, rate, noVerifies, verifytime);
   279 		iOut.writeString(buf);
   280 	}
   281 	else
   282 	{
   283 		_LIT(KNoTimingInfo, "\tTest Failed! No benchmark data\n");
   284 		iOut.writeString(KNoTimingInfo);
   285 	}
   286 }
   287 
   288 void CRSASignFB::DoPerformActionL()
   289 	{
   290 	__UHEAP_MARK;
   291 	
   292 	iResult = EFalse;
   293 
   294 	CRSAKeyPair* rsaPair = CRSAKeyPair::NewLC(512, TypeOfCrypto());
   295 
   296 	CRSAPKCS1v15Signer* signer = CRSAPKCS1v15Signer::NewL(rsaPair->PrivateKey());
   297 	CleanupStack::PushL(signer);
   298 
   299 	CRSAPKCS1v15Verifier* verifier = CRSAPKCS1v15Verifier::NewL(rsaPair->PublicKey());
   300 	CleanupStack::PushL(verifier);
   301 
   302 	const CRSASignature* signature = signer->SignL(*iInput);
   303 	CleanupStack::PushL(const_cast<CRSASignature*>(signature));
   304 
   305 	if(verifier->VerifyL(*iInput, *signature))
   306 		{
   307 		iResult = ETrue;
   308 		}
   309 	
   310 	CleanupStack::PopAndDestroy(4, rsaPair); //signature, verifier, signer, rsaPair
   311 	
   312 	__UHEAP_MARKEND;
   313 	}
   314