diff -r 675a964f4eb5 -r 35751d3474b7 crypto/weakcryptospi/test/tcryptospi/src/KeyExchangeSyncStep.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/test/tcryptospi/src/KeyExchangeSyncStep.cpp	Thu Sep 10 14:01:51 2009 +0300
@@ -0,0 +1,260 @@
+/*
+* Copyright (c) 2007-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: 
+* Example CTestStep derived implementation
+*
+*/
+
+
+/**
+ @file
+ @internalTechnology
+*/
+#include "keyexchangesyncstep.h"
+
+#include "keypair.h"
+#include "cryptokeypairgeneratorapi.h"
+#include "cryptokeyagreementapi.h"
+#include <bigint.h>
+
+using namespace CryptoSpi;
+
+CKeyExchangeSyncStep::~CKeyExchangeSyncStep()
+	{
+	}
+
+CKeyExchangeSyncStep::CKeyExchangeSyncStep()
+	{
+	SetTestStepName(KKeyExchangeSyncStep);
+	}
+
+TVerdict CKeyExchangeSyncStep::doTestStepPreambleL()
+	{
+	SetTestStepResult(EPass);
+	return TestStepResult();
+	}
+
+TVerdict CKeyExchangeSyncStep::doTestStepL()
+	{
+	INFO_PRINTF1(_L("*** Key Exchange - DH Key Agreement ***"));
+	INFO_PRINTF2(_L("HEAP CELLS: %d"), User::CountAllocCells());
+	
+  	if (TestStepResult()==EPass)
+		{
+		//Assume faliure, unless all is successful
+		SetTestStepResult(EFail);
+
+		TVariantPtrC testVariant;
+		TVariantPtrC dhnVariant;
+		TVariantPtrC dhgVariant;
+
+		if(	!GetStringFromConfig(ConfigSection(),KConfigExchangeKey, dhnVariant) ||
+			!GetStringFromConfig(ConfigSection(),KConfigExchangeKey, dhgVariant )
+			)
+			{
+			// Leave if there's any error.
+			User::Leave(KErrNotFound);
+			}
+		else
+			{
+			/*
+	 		 * both DH keys (ie our private and their public keys) must use the same N and G parameters
+	 		 */
+	 		INFO_PRINTF1(_L("Creating Primes and Base Integers...")); 
+	 		 
+			RInteger DH_N = RInteger::NewPrimeL(1024);	// from ini file
+			CleanupClosePushL(DH_N);
+			RInteger DH_N_MinusTwo = RInteger::NewL(DH_N);
+			CleanupClosePushL(DH_N_MinusTwo);
+			DH_N_MinusTwo-=2;
+			
+			RInteger DH_G = RInteger::NewRandomL(TInteger::Two(), DH_N_MinusTwo);	
+			CleanupClosePushL(DH_G);
+			
+			INFO_PRINTF1(_L("Creating Key Pair Generator...")); 
+
+			// create a DH key pair generator interface for creating the 2 key pairs
+			CKeyPairGenerator* keyPairGeneratorImpl = NULL;
+			
+			TRAPD_LOG(err,CKeyPairGeneratorFactory::CreateKeyPairGeneratorL(keyPairGeneratorImpl, 
+														KDHKeyPairGeneratorUid, 
+														NULL));
+														
+			if(keyPairGeneratorImpl && (err==KErrNone))	
+				{
+				
+				CleanupStack::PushL(keyPairGeneratorImpl);
+
+				// package up the common parameters N and G for use through the rest of this method
+				CCryptoParams* keyParameters = CCryptoParams::NewLC();
+				keyParameters->AddL(DH_N, KDhKeyParameterNUid);
+				keyParameters->AddL(DH_G, KDhKeyParameterGUid);
+
+				/* 
+				 * call the api to create a DH key pair for alice
+				 */
+				INFO_PRINTF1(_L("Generating DH ALICE Key Pair..."));
+				CKeyPair* keyAlice = NULL;
+				
+				TRAP_LOG(err,keyPairGeneratorImpl->GenerateKeyPairL(NULL,
+																*keyParameters, 
+																keyAlice));
+				CleanupStack::PushL(keyAlice);
+
+				/* 
+				 * call the api to create a DH key pair for bob
+				 */
+				INFO_PRINTF1(_L("Generating DH BOB Key Pair..."));
+				CKeyPair* keyBob = NULL;
+				TRAP_LOG(err,keyPairGeneratorImpl->GenerateKeyPairL(NULL, 
+																*keyParameters, 
+																keyBob));
+				CleanupStack::PushL(keyBob);
+
+				/* 
+				 * get DH key agreement interfaces
+				 */
+				INFO_PRINTF1(_L("Generating ALICE & BOB Key Agreement Interfaces..."));
+				CKeyAgreement* keyAgreementAliceImpl =  NULL;
+				
+				TRAP_LOG(err,CKeyAgreementFactory::CreateKeyAgreementL(keyAgreementAliceImpl, 
+																	KDHAgreementUid, 
+																	keyAlice->PrivateKey(), 
+																	keyParameters));
+				CleanupStack::PushL(keyAgreementAliceImpl);
+				
+				CKeyAgreement* keyAgreementBobImpl =  NULL;
+				
+				TRAP_LOG(err,CKeyAgreementFactory::CreateKeyAgreementL(keyAgreementBobImpl, 
+																	KDHAgreementUid, 
+																	keyBob->PrivateKey(), 
+																	keyParameters));
+				CleanupStack::PushL(keyAgreementBobImpl);
+
+				/* 
+				 * call the api to get a DH agreed keys
+				 */
+				INFO_PRINTF1(_L("Generating Agreed Keys..."));
+				
+				CKey* agreedKeyAlice = keyAgreementAliceImpl->AgreeL(keyBob->PublicKey(), keyParameters);
+				CleanupStack::PushL(agreedKeyAlice);
+				
+				CKey* agreedKeyBob = keyAgreementBobImpl->AgreeL(keyAlice->PublicKey(), keyParameters);
+				CleanupStack::PushL(agreedKeyBob);
+
+				/*
+				 * compare the agreed keys
+				 */
+				const TInteger& agreedKeyDataAlice = agreedKeyAlice->GetBigIntL(KSymmetricKeyParameterUid);
+				const TInteger& agreedKeyDataBob = agreedKeyBob->GetBigIntL(KSymmetricKeyParameterUid);
+				
+				if (agreedKeyDataAlice == agreedKeyDataBob)
+					{
+					INFO_PRINTF1(_L("*** PASS : Key Agreement Success ***"));
+					SetTestStepResult(EPass);
+					}
+				else
+					{
+					INFO_PRINTF1(_L("*** FAIL : Agreed Keys Mismatch ***"));
+					SetTestStepResult(EFail);
+					}
+
+				// Set the private keys to check the new agreements.
+				keyAgreementAliceImpl->SetKeyL(keyAlice->PrivateKey(), keyParameters);
+				keyAgreementAliceImpl->SetKeyL(keyBob->PrivateKey(), keyParameters);
+				
+				/* 
+				* call the api to get a DH agreed keys
+				*/
+				INFO_PRINTF1(_L("Generating Agreed Keys second time..."));
+								
+				CKey* agreedKeyAlice1 = keyAgreementAliceImpl->AgreeL(keyBob->PublicKey(), keyParameters);
+				CleanupStack::PushL(agreedKeyAlice1);
+					
+				CKey* agreedKeyBob1 = keyAgreementBobImpl->AgreeL(keyAlice->PublicKey(), keyParameters);
+				CleanupStack::PushL(agreedKeyBob1);
+
+				/*
+				 * compare the agreed keys
+				 */
+				const TInteger& agreedKeyDataAlice1 = agreedKeyAlice->GetBigIntL(KSymmetricKeyParameterUid);
+				const TInteger& agreedKeyDataBob1 = agreedKeyBob->GetBigIntL(KSymmetricKeyParameterUid);
+				
+				if (agreedKeyDataAlice1 != agreedKeyDataBob1)
+					{					
+					INFO_PRINTF1(_L("*** FAIL : Second Agreed Keys Mismatch ***"));
+					SetTestStepResult(EFail);
+					}	
+							
+				const CCryptoParams& cryptoParams1 = agreedKeyAlice1->KeyParameters();
+				const CCryptoParams& cryptoParams2 = agreedKeyBob1->KeyParameters();				
+				if (cryptoParams1.Count() != cryptoParams2.GetParams().Count())					
+					{
+					INFO_PRINTF1(_L("*** FAIL : Key Parameters' Count Mismatch ***"));
+					SetTestStepResult(EFail);
+					}
+				
+				TInt paramLength = 10;
+				HBufC16* buf = HBufC16::NewLC(paramLength);
+				TPtr16 ptr = buf->Des();
+				ptr.Copy(_L("DH_N"));
+				CCryptoParams* params = CCryptoParams::NewL();
+				params->AddL(*buf, KDhKeyParameterNUid);
+				if(!params->Count())
+					{
+					INFO_PRINTF1(_L("*** FAIL : Parameter construction with descriptor failed ***"));
+					SetTestStepResult(EFail);
+					}
+
+				if (agreedKeyAlice1->IsPresent(KSymmetricKeyParameterUid))
+					{
+					TRAPD(err, agreedKeyAlice1->GetTIntL(KSymmetricKeyParameterUid));
+					if(err == KErrNone)
+						{
+						INFO_PRINTF1(_L("*** FAIL : Expected Key Parameter Int Value Mismatch ***"));
+						SetTestStepResult(EFail);
+						}
+					}
+				
+				// Clear the second key agreement elements.
+				CleanupStack::PopAndDestroy(3, agreedKeyAlice1);
+				
+				/* 
+				 * cleanup stack - it should contain privateKey, keyAgreementImpl, publicKey, keyParameters and agreedKey
+				 */
+				CleanupStack::PopAndDestroy(agreedKeyBob);
+				CleanupStack::PopAndDestroy(agreedKeyAlice);
+				CleanupStack::PopAndDestroy(keyAgreementBobImpl);
+				CleanupStack::PopAndDestroy(keyAgreementAliceImpl);
+				CleanupStack::PopAndDestroy(keyBob);
+				CleanupStack::PopAndDestroy(keyAlice);
+				CleanupStack::PopAndDestroy(keyParameters);
+				CleanupStack::PopAndDestroy(keyPairGeneratorImpl);	
+				}
+		
+			CleanupStack::PopAndDestroy(&DH_G);
+			CleanupStack::PopAndDestroy(&DH_N_MinusTwo);
+			CleanupStack::PopAndDestroy(&DH_N);
+			}
+			
+		INFO_PRINTF2(_L("HEAP CELLS: %d"), User::CountAllocCells());
+
+		}
+  	return TestStepResult();
+	}
+
+TVerdict CKeyExchangeSyncStep::doTestStepPostambleL()
+	{
+	return TestStepResult();
+	}