diff -r f18401adf8e1 -r 641f389e9157 crypto/weakcrypto/test/tasymmetric/trsaencryptfb.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/crypto/weakcrypto/test/tasymmetric/trsaencryptfb.cpp Tue Aug 31 17:00:08 2010 +0300 @@ -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 +#include +#include +#include "performancetest.h" +#include + +_LIT8(KInputStart, ""); +_LIT8(KInputEnd, ""); +_LIT8(KKeyBitsStart, ""); +_LIT8(KKeyBitsEnd, ""); + +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'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(&rsaPair->PublicKey()), static_cast(&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(&rsaPair->PublicKey()), static_cast(&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); + +}