--- /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();
+ }