/*
* Copyright (c) 2007-2010 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:
*
*/
/**
@file
@internalTechnology
*/
#include "ruleselectcommonstep.h"
#include "plugincharschecker.h"
#include <cryptospi/cryptosymmetriccipherapi.h>
#include <cryptospi/cryptoasymmetriccipherapi.h>
#include <cryptospi/cryptohashapi.h>
#include <cryptospi/cryptorandomapi.h>
#include <cryptospi/cryptosignatureapi.h>
#include <cryptospi/cryptokeyagreementapi.h>
#include <cryptospi/cryptokeypairgeneratorapi.h>
#include <cryptospi/keypair.h>
#include <cryptospi/keys.h>
#ifdef SYMBIAN_SDP_IPSEC_VOIP_SUPPORT
#include <cryptospi/cryptomacapi.h>
#endif
#include <cryptospi/cryptospistateapi.h>
#include <cryptospi/ruleselector.h>
using namespace CryptoSpi;
CRuleSelectCommonStep::~CRuleSelectCommonStep()
{
}
CRuleSelectCommonStep::CRuleSelectCommonStep()
{
SetTestStepName(KRuleSelectCommonStep);
}
TVerdict CRuleSelectCommonStep::doTestStepPreambleL()
{
SetTestStepResult(EPass);
return TestStepResult();
}
TVerdict CRuleSelectCommonStep::doTestStepL()
{
INFO_PRINTF1(_L("Rule Selection - Common Characteristics Selection"));
INFO_PRINTF2(_L("HEAP CELLS: %d"), User::CountAllocCells());
if (TestStepResult()==EPass)
{
TInt err = 0;
//Create Default Selection Rules Object
CSelectionRules* rules = CSelectionRules::NewL();
CleanupStack::PushL(rules);
//*************SELECTION RULE CREATION AND ADDITION**************
//Boolean to determine whether there are more rules to apply
TBool moreRules;
moreRules = ETrue;
//Itterator representing the current rule. Appended to the end of each selection
//rule INI parameter
TInt currentRule;
currentRule = 1;
//Total number of selection rules added to the CSelectionRules object
TInt totalRules;
totalRules = 0;
TVariantPtrC interfaceScope;
TVariantPtrC algorithmScope;
TVariantPtrC charUid;
TVariantPtrC compareOperator;
TVariantPtrC charValue;
TVariantPtrC charValueType;
TBool isOptional;
//Whilst there are selection rules present in the INI file that have yet to be
//added to the CSelectionRules object
while(moreRules)
{
INFO_PRINTF2(_L("HEAP CELLS: %d"), User::CountAllocCells());
//Constructs each of the parameter names required to extract the necessary
//selection rule data from the specified INI configuration file
TBuf<KMaxConfigParamStringSize> interfaceScopeStr(KConfigInterfaceScopeBase);
interfaceScopeStr.AppendNum(currentRule);
INFO_PRINTF2(_L("interfaceScopeStr = %S"), &interfaceScopeStr);
TBuf<KMaxConfigParamStringSize> algorithmScopeStr(KConfigAlgorithmScopeBase);
algorithmScopeStr.AppendNum(currentRule);
INFO_PRINTF2(_L("algorithmScopeStr = %S"), &algorithmScopeStr);
TBuf<KMaxConfigParamStringSize> charUidStr(KConfigCharUidBase);
charUidStr.AppendNum(currentRule);
INFO_PRINTF2(_L("charUidStr = %S"), &charUidStr);
TBuf<KMaxConfigParamStringSize> compareOperatorStr(KConfigCompareOperatorBase);
compareOperatorStr.AppendNum(currentRule);
INFO_PRINTF2(_L("compareOperatorStr = %S"), &compareOperatorStr);
TBuf<KMaxConfigParamStringSize> charValueStr(KConfigCharValueBase);
charValueStr.AppendNum(currentRule);
INFO_PRINTF2(_L("charValueStr = %S"), &charValueStr);
TBuf<KMaxConfigParamStringSize> charValueTypeStr(KConfigCharValueTypeBase);
charValueTypeStr.AppendNum(currentRule);
INFO_PRINTF2(_L("charValueTypeStr = %S"), &charValueTypeStr);
TBuf<KMaxConfigParamStringSize> isOptionalStr(KConfigIsOptionalBase);
isOptionalStr.AppendNum(currentRule);
INFO_PRINTF2(_L("isOptionalStr = %S"), &isOptionalStr);
//Extracts the parameter data for a single rule from the specified INI file
if(!GetStringFromConfig(ConfigSection(),interfaceScopeStr,interfaceScope) ||
!GetStringFromConfig(ConfigSection(),algorithmScopeStr,algorithmScope) ||
!GetStringFromConfig(ConfigSection(),charUidStr,charUid) ||
!GetStringFromConfig(ConfigSection(),compareOperatorStr,compareOperator) ||
!GetStringFromConfig(ConfigSection(),charValueTypeStr,charValueType) ||
!GetBoolFromConfig(ConfigSection(),isOptionalStr,isOptional))
{
moreRules = EFalse;
}
else
{
//Creates a pointer to store the address of the newly created selection rule
CSelectionRuleContent* rule = NULL;
//Creates a pointer to store the contents of the rule value parameter, so that
//it can be passed in at construction of the selection rule.
CCryptoParam* ruleValueParam = NULL;
//Depending on the 'RuleValueType' parameter read in from the INI file, the 'RuleValue'
//parameter will either be read in as an Integer,String or a Boolean.
switch(charValueType)
{
case ERuleValueInteger:
{
TInt charValue;
if(!GetIntFromConfig(ConfigSection(),charValueStr,charValue))
{
//Should the integer value be represented by a constant..
TVariantPtrC strCharValue;
if(!GetStringFromConfig(ConfigSection(),charValueStr,strCharValue))
{
ERR_PRINTF1(_L("** .INI Error: INTEGER Rule Value Not Initialised Correctly **"));
SetTestStepResult(EFail);
}
else
{
ruleValueParam = CCryptoIntParam::NewL(TInt(strCharValue),TUid(charUid));
}
}
else
{
//The Integer Rule Value is encapsulated as a CCryptoIntParam object so that it can be passed in as
//a parameter when constructing the selection rule
ruleValueParam = CCryptoIntParam::NewL(charValue,charUid);
}
break;
}
case ERuleValueDes8:
{
TPtrC charValue;
if(!GetStringFromConfig(ConfigSection(),charValueStr,charValue))
{
ERR_PRINTF1(_L("** .INI Error: STRING Rule Value Not Initialised Correctly **"));
SetTestStepResult(EFail);
}
else
{
//Convert encryption key to an 8 Bit Descriptor
HBufC8* charStr = HBufC8::NewLC(charValue.Length());
TPtr8 charStrPtr = charStr->Des();
charStrPtr.Copy(charValue);
//The String Rule Value is encapsulated as a CCryptoDesC8Param object so that it can be passed in as
//a parameter when constructing the selection rule
ruleValueParam = CCryptoDesC8Param::NewL(charStrPtr,charUid);
CleanupStack::PopAndDestroy(charStr);
}
break;
}
case ERuleValueDes16:
{
TPtrC charValue;
if(!GetStringFromConfig(ConfigSection(),charValueStr,charValue))
{
ERR_PRINTF1(_L("** .INI Error: STRING Rule Value Not Initialised Correctly **"));
SetTestStepResult(EFail);
}
else
{
//The String Rule Value is encapsulated as a CCryptoDesC8Param object so that it can be passed in as
//a parameter when constructing the selection rule
ruleValueParam = CCryptoDesC16Param::NewL(charValue,charUid);
}
break;
}
case ERuleValueBoolean:
{
TBool charValue;
if(!GetBoolFromConfig(ConfigSection(),charValueStr,charValue))
{
ERR_PRINTF1(_L("** .INI Error: BOOLEAN Rule Value Not Initialised Correctly **"));
SetTestStepResult(EFail);
}
else
{
//The Boolean Rule Value is encapsulated as a CCryptoInt8Param object so that it can be passed in as
//a parameter when constructing the selection rule
ruleValueParam = CCryptoIntParam::NewL(charValue,charUid);
}
break;
}
default:
{
ERR_PRINTF1(_L("** .INI Error: Rule Value Type Unknown **"));
SetTestStepResult(EFail);
break;
}
}
if(TestStepResult() == EPass)
{
//Creates the CSelectionRuleContent object, passing in all the parameters read in
//from the specified INI configuration file
TRAP_LOG(err, rule = CSelectionRuleContent::NewL(interfaceScope,
algorithmScope,
ruleValueParam,
TRuleOperator((TInt)compareOperator),
isOptional));
if(err == KErrNone)
{
//Add the newly created selection rule to the CSelectionRules collection by
//calling the 'AddSelectionRule' method and passing in the address of the rule
TRAP_LOG(err,rules->AddSelectionRuleL(rule));
if(err == KErrNone)
{
INFO_PRINTF2(_L("Rule %d Created, Added and Destoryed"), currentRule);
currentRule++;
totalRules++;
}
else
{
ERR_PRINTF2(_L("RULE FAILURE: Failed to Add Selection Rule %d "), currentRule);
moreRules = EFalse;
SetTestStepResult(EFail);
}
}
else
{
ERR_PRINTF2(_L("RULE FAILURE: Failed to Create Selection Rule %d "), currentRule);
moreRules = EFalse;
SetTestStepResult(EFail);
}
}
else
{
moreRules = EFalse;
}
}
}
//If 1 or more selection rule objects were added successfully without error, the test step
//can proceed to the next phase
if((TestStepResult() == EPass) && (totalRules > 0))
{
INFO_PRINTF2(_L("Successfully Added Selection Rules: %d"), totalRules);
}
else if((TestStepResult() == EFail) && (totalRules > 0))
{
ERR_PRINTF1(_L("** .INI Error: Errornous Selection Rule Data **"));
SetTestStepResult(EFail);
}
else
{
ERR_PRINTF1(_L("** NO VALID SELECTION RULE DATA FOUND **"));
}
//**************************************************************
INFO_PRINTF2(_L("HEAP CELLS: %d"), User::CountAllocCells());
if(TestStepResult()==EPass)
{
//Assume faliure, unless all is successful
SetTestStepResult(EFail);
//Create Rule Selector Object
CRuleSelector* ruleSelector = CRuleSelector::NewL(rules);
CleanupStack::Pop(rules);
CleanupStack::PushL(ruleSelector);
//Set the Selector Passing in a pointer to the Rule Selector and SPI State
CCryptoSpiStateApi::SetSelector(ruleSelector);
//Define a pointer of type CCryptoBase to store the address ofthe instantiated encryption object
CCryptoBase* plugin = NULL;
TVariantPtrC interfaceType;
//Extract the Encryption Type parameter from the specified INI file
if(!GetStringFromConfig(ConfigSection(),KConfigInterfaceType,interfaceType))
{
ERR_PRINTF1(_L("** .INI Error: Encryption Type Data Not Located **"));
SetTestStepResult(EFail);
}
else
{
//Depending on the Interface Type retrieved, the appropriate factory object
//is created and assigned to the previously CCryptoBase plugin pointer
switch(interfaceType)
{
case KAsymmetricCipherInterface:
{
TPtrC16 encryptKey;
TVariantPtrC keyType;
TVariantPtrC algorithmUid;
TVariantPtrC cryptoMode;
TVariantPtrC paddingMode;
TVariantPtrC algorithmParams;
//Each of the individual parameters required to create the Asymmetric Cipher object
//are read in from the specified INI configuration file
if(!GetStringFromConfig(ConfigSection(),KConfigAlgorithmUid,algorithmUid) ||
!GetStringFromConfig(ConfigSection(),KConfigCryptoMode,cryptoMode) ||
!GetStringFromConfig(ConfigSection(),KConfigPaddingMode,paddingMode) ||
!GetStringFromConfig(ConfigSection(),KConfigAlgorithmParams,algorithmParams))
{
ERR_PRINTF1(_L("** .INI Error: Asymmetric Cipher Arguments Not Located **"));
SetTestStepResult(EFail);
}
else
{
//********** Rule Selector Unselcted to Create Key Pair ************
CCryptoSpiStateApi::UnsetSelector();
CCryptoParams* keyParams = CCryptoParams::NewLC();
//Create Key Pair and Key Pair Generator Objects
CKeyPair* keyPair = NULL;
CKeyPairGenerator * keypairImpl = NULL;
INFO_PRINTF1(_L("Generating RSA keys"));
// create an RSA key pair
keyParams->AddL(KKeyExponent, KRsaKeyParameterEUid);
keyParams->AddL(KRsaPrivateKeyStandard, KRsaKeyTypeUid);
// create a key pair generator implementation interface
TRAP_LOG(err,CKeyPairGeneratorFactory::CreateKeyPairGeneratorL(
keypairImpl,
KRSAKeyPairGeneratorUid,
keyParams));
CleanupStack::PushL(keypairImpl);
// Create a Key Pair
TRAP_LOG(err,keypairImpl->GenerateKeyPairL(1024, *keyParams, keyPair));
CleanupStack::PushL(keyPair);
CCryptoSpiStateApi::SetSelector(ruleSelector);
//******************************************************************
CAsymmetricCipher* asymmetricCipherImpl;
TRAP_LOG(err,CAsymmetricCipherFactory::CreateAsymmetricCipherL(asymmetricCipherImpl,
algorithmUid,
keyPair->PublicKey(),
cryptoMode,
paddingMode,
NULL));
if(asymmetricCipherImpl && (err == KErrNone))
{
plugin = static_cast<CCryptoBase*>(asymmetricCipherImpl);
INFO_PRINTF1(_L("** Successfully Loaded Asymmetric Cipher Object **"));
SetTestStepResult(EPass);
}
else
{
ERR_PRINTF2(_L("** Error: Loading Asymmetric Cipher Object - %d **"), err);
SetTestStepResult(EFail);
}
CleanupStack::PopAndDestroy(3,keyParams);
}
break;
}
case KSymmetricCipherInterface:
{
TPtrC16 encryptKey;
TVariantPtrC keyType;
TVariantPtrC algorithmUid;
TVariantPtrC cryptoMode;
TVariantPtrC operationMode;
TVariantPtrC paddingMode;
TVariantPtrC algorithmParams;
//Each of the individual parameters required to create the Symmetric Cipher object
//are read in from the specified INI configuration file
if(!GetStringFromConfig(ConfigSection(),KConfigEncryptKey,encryptKey) ||
!GetStringFromConfig(ConfigSection(),KConfigEncryptKeyType,keyType) ||
!GetStringFromConfig(ConfigSection(),KConfigAlgorithmUid,algorithmUid) ||
!GetStringFromConfig(ConfigSection(),KConfigCryptoMode,cryptoMode) ||
!GetStringFromConfig(ConfigSection(),KConfigOperationMode,operationMode) ||
!GetStringFromConfig(ConfigSection(),KConfigPaddingMode,paddingMode) ||
!GetStringFromConfig(ConfigSection(),KConfigAlgorithmParams,algorithmParams))
{
ERR_PRINTF1(_L("** .INI Error: Symmetric Cipher Arguments Not Located **"));
SetTestStepResult(EFail);
}
else
{
//Convert encryption key to an 8 Bit Descriptor
HBufC8* keyStr = HBufC8::NewLC(encryptKey.Length());
TPtr8 keyStrPtr = keyStr->Des();
keyStrPtr.Copy(encryptKey);
//Create an new CryptoParams object to encapsulate the key type and secret key string
CCryptoParams* keyParams = CCryptoParams::NewL();
CleanupStack::PushL(keyParams);
keyParams->AddL(*keyStr,keyType);
//Create Key Object
TKeyProperty keyProperty;
CKey* key=CKey::NewL(keyProperty,*keyParams);
CleanupStack::PushL(key);
CSymmetricCipher* symmetricCipherImpl = NULL;
TRAP_LOG(err,CSymmetricCipherFactory::CreateSymmetricCipherL(symmetricCipherImpl,
algorithmUid,
*key,
cryptoMode,
operationMode,
paddingMode,
NULL));
if(symmetricCipherImpl && (err == KErrNone))
{
plugin = static_cast<CCryptoBase*>(symmetricCipherImpl);
INFO_PRINTF1(_L("** Successfully Loaded Symmetric Cipher Object **"));
SetTestStepResult(EPass);
}
else
{
ERR_PRINTF2(_L("** Error: Loading Symmetric Cipher Object - %d **"), err);
SetTestStepResult(EFail);
}
CleanupStack::PopAndDestroy(3,keyStr);
}
break;
}
case KHashInterface:
{
TVariantPtrC algorithmUid;
TVariantPtrC operationMode;
TVariantPtrC algorithmParams;
//Each of the individual parameters required to create the Hash object
//are read in from the specified INI configuration file
if(!GetStringFromConfig(ConfigSection(),KConfigAlgorithmUid,algorithmUid) ||
#ifndef SYMBIAN_SDP_IPSEC_VOIP_SUPPORT
!GetStringFromConfig(ConfigSection(),KConfigOperationMode,operationMode) ||
#endif
!GetStringFromConfig(ConfigSection(),KConfigAlgorithmParams,algorithmParams))
{
ERR_PRINTF1(_L("** .INI Error: Hash Arguments Not Located **"));
SetTestStepResult(EFail);
}
else
{
CHash* hashImpl = NULL;
#ifdef SYMBIAN_SDP_IPSEC_VOIP_SUPPORT
if (GetStringFromConfig(ConfigSection(),KConfigOperationMode,operationMode))
{
TRAP_LOG(err,CHashFactory::CreateHashL(hashImpl,
algorithmUid,
operationMode,
NULL,
NULL));
}
else
{
TRAP_LOG(err,CHashFactory::CreateHashL(hashImpl,
algorithmUid,
NULL));
}
#else
TRAP_LOG(err,CHashFactory::CreateHashL(hashImpl,
algorithmUid,
operationMode,
NULL,
NULL));
#endif
if(hashImpl && (err == KErrNone))
{
plugin = static_cast<CCryptoBase*>(hashImpl);
INFO_PRINTF1(_L("** Successfully Loaded Hash Object **"));
SetTestStepResult(EPass);
}
else
{
ERR_PRINTF2(_L("** Error: Loading Hash Object - %d **"), err);
SetTestStepResult(EFail);
}
}
break;
}
#ifdef SYMBIAN_SDP_IPSEC_VOIP_SUPPORT
case KMacInterface:
{
TVariantPtrC algorithmUid;
TPtrC encryptKey;
TVariantPtrC keyType;
//Each of the individual parameters required to create the Mac object
//are read in from the specified INI configuration file
if (!GetStringFromConfig(ConfigSection(),KConfigAlgorithmUid,algorithmUid) ||
!GetStringFromConfig(ConfigSection(),KConfigEncryptKey,encryptKey) ||
!GetStringFromConfig(ConfigSection(),KConfigEncryptKeyType,keyType))
{
ERR_PRINTF1(_L("** .INI Error: Mac Arguments Not Located **"));
SetTestStepResult(EFail);
}
else
{
CMac* macImpl = NULL;
//Convert encryption key to an 8 Bit Descriptor
HBufC8* keyStr = HBufC8::NewLC(encryptKey.Length());
TPtr8 keyStrPtr = keyStr->Des();
keyStrPtr.Copy(encryptKey);
//Create an new CryptoParams object to encapsulate the key type and secret key string
CCryptoParams* keyParams = CCryptoParams::NewL();
CleanupStack::PushL(keyParams);
keyParams->AddL(*keyStr,keyType);
//Create Key Object
TKeyProperty keyProperty;
CKey* key=CKey::NewL(keyProperty,*keyParams);
CleanupStack::PushL(key);
TRAP_LOG(err,CMacFactory::CreateMacL(macImpl,
algorithmUid,
*key,
NULL));
if(macImpl && (err == KErrNone))
{
plugin = static_cast<CCryptoBase*>(macImpl);
INFO_PRINTF1(_L("** Successfully Loaded Mac Object **"));
SetTestStepResult(EPass);
}
else
{
delete macImpl;
ERR_PRINTF2(_L("** Error: Loading Mac Object - %d **"), err);
SetTestStepResult(EFail);
}
CleanupStack::PopAndDestroy(3,keyStr);
}
break;
}
#endif
case KRandomInterface:
{
TVariantPtrC algorithmUid;
TVariantPtrC algorithmParams;
//Each of the individual parameters required to create the Random object
//are read in from the specified INI configuration file
if(!GetStringFromConfig(ConfigSection(),KConfigAlgorithmUid,algorithmUid) ||
!GetStringFromConfig(ConfigSection(),KConfigAlgorithmParams,algorithmParams))
{
ERR_PRINTF1(_L("** .INI Error: Random Arguments Not Located **"));
SetTestStepResult(EFail);
}
else
{
CryptoSpi::CRandom* randomImpl = NULL;
TRAP_LOG(err,CRandomFactory::CreateRandomL(randomImpl,
algorithmUid,
NULL));
if(randomImpl && (err == KErrNone))
{
plugin = static_cast<CCryptoBase*>(randomImpl);
INFO_PRINTF1(_L("** Successfully Loaded Random Object **"));
SetTestStepResult(EPass);
}
else
{
ERR_PRINTF2(_L("** Error: Loading Random Object - %d **"), err);
SetTestStepResult(EFail);
}
}
break;
}
case KSignerInterface:
{
TVariantPtrC algorithmUid;
TVariantPtrC paddingMode;
TVariantPtrC algorithmParams;
//Each of the individual parameters required to create the Signer object
//are read in from the specified INI configuration file
if(!GetStringFromConfig(ConfigSection(),KConfigAlgorithmUid,algorithmUid) ||
!GetStringFromConfig(ConfigSection(),KConfigPaddingMode,paddingMode) ||
!GetStringFromConfig(ConfigSection(),KConfigAlgorithmParams,algorithmParams))
{
ERR_PRINTF1(_L("** .INI Error: Signer Arguments Not Located **"));
SetTestStepResult(EFail);
}
else
{
//********** Rule Selector Unselected to Create Key Pair ************
CCryptoSpiStateApi::UnsetSelector();
CCryptoParams* keyParams = CCryptoParams::NewLC();
//Create Key Pair and Key Pair Generator Objects
CKeyPair* keyPair = NULL;
CKeyPairGenerator * keypairImpl = NULL;
INFO_PRINTF1(_L("Generating RSA keys"));
// create an RSA key pair
keyParams->AddL(KKeyExponent, KRsaKeyParameterEUid);
keyParams->AddL(KRsaPrivateKeyStandard, KRsaKeyTypeUid);
// create a key pair generator implementation interface
TRAP_LOG(err,CKeyPairGeneratorFactory::CreateKeyPairGeneratorL(keypairImpl,
KRSAKeyPairGeneratorUid,
keyParams));
CleanupStack::PushL(keypairImpl);
// Create a Key Pair
TRAP_LOG(err,keypairImpl->GenerateKeyPairL(1024, *keyParams, keyPair));
CleanupStack::PushL(keyPair);
CCryptoSpiStateApi::SetSelector(ruleSelector);
//******************************************************************
CSigner* signerImpl = NULL;
TRAP_LOG(err,CSignatureFactory::CreateSignerL(signerImpl,
algorithmUid,
keyPair->PrivateKey(),
paddingMode,
NULL));
if(signerImpl && (err == KErrNone))
{
plugin = static_cast<CCryptoBase*>(signerImpl);
INFO_PRINTF1(_L("** Successfully Loaded Signer Object **"));
SetTestStepResult(EPass);
}
else
{
ERR_PRINTF2(_L("** Error: Loading Signer Object - %d **"), err);
SetTestStepResult(EFail);
}
CleanupStack::PopAndDestroy(3,keyParams);
}
break;
}
case KVerifierInterface:
{
TVariantPtrC algorithmUid;
TVariantPtrC paddingMode;
TVariantPtrC algorithmParams;
//Each of the individual parameters required to create the Verifier object
//are read in from the specified INI configuration file
if(!GetStringFromConfig(ConfigSection(),KConfigAlgorithmUid,algorithmUid) ||
!GetStringFromConfig(ConfigSection(),KConfigPaddingMode,paddingMode) ||
!GetStringFromConfig(ConfigSection(),KConfigAlgorithmParams,algorithmParams))
{
ERR_PRINTF1(_L("** .INI Error: Verifier Arguments Not Located **"));
SetTestStepResult(EFail);
}
else
{
//********** Rule Selector Unselected to Create Key Pair ************
CCryptoSpiStateApi::UnsetSelector();
CCryptoParams* keyParams = CCryptoParams::NewLC();
//Create Key Pair and Key Pair Generator Objects
CKeyPair* keyPair = NULL;
CKeyPairGenerator * keypairImpl = NULL;
INFO_PRINTF1(_L("Generating RSA keys"));
// create an RSA key pair
keyParams->AddL(KKeyExponent, KRsaKeyParameterEUid);
keyParams->AddL(KRsaPrivateKeyStandard, KRsaKeyTypeUid);
// create a key pair generator implementation interface
TRAP_LOG(err,CKeyPairGeneratorFactory::CreateKeyPairGeneratorL(keypairImpl,
KRSAKeyPairGeneratorUid,
keyParams));
CleanupStack::PushL(keypairImpl);
// Create a Key Pair
TRAP_LOG(err,keypairImpl->GenerateKeyPairL(1024, *keyParams, keyPair));
CleanupStack::PushL(keyPair);
CCryptoSpiStateApi::SetSelector(ruleSelector);
//******************************************************************
CVerifier* verifierImpl = NULL;
TRAP_LOG(err,CSignatureFactory::CreateVerifierL(verifierImpl,
algorithmUid,
keyPair->PublicKey(),
paddingMode,
NULL));
if(verifierImpl && (err == KErrNone))
{
plugin = static_cast<CCryptoBase*>(verifierImpl);
INFO_PRINTF1(_L("** Successfully Loaded Verifier Object **"));
SetTestStepResult(EPass);
}
else
{
ERR_PRINTF2(_L("** Error: Loading Verifier Object - %d **"), err);
SetTestStepResult(EFail);
}
CleanupStack::PopAndDestroy(3,keyParams);
}
break;
}
case KKeypairGeneratorInterface:
{
TVariantPtrC algorithmUid;
TVariantPtrC algorithmParams;
//Each of the individual parameters required to create the Key Pair Generator object
//are read in from the specified INI configuration file
if(!GetStringFromConfig(ConfigSection(),KConfigAlgorithmUid,algorithmUid) ||
!GetStringFromConfig(ConfigSection(),KConfigAlgorithmParams,algorithmParams))
{
ERR_PRINTF1(_L("** .INI Error: Key Pair Generator Arguments Not Located **"));
SetTestStepResult(EFail);
}
else
{
CCryptoParams* keyParams = CCryptoParams::NewLC();
//Create Key Pair and Key Pair Generator Objects
CKeyPairGenerator * keypairImpl = NULL;
INFO_PRINTF1(_L("Generating RSA keys"));
// create an RSA key pair
keyParams->AddL(KKeyExponent, KRsaKeyParameterEUid);
keyParams->AddL(KRsaPrivateKeyStandard, KRsaKeyTypeUid);
// create a key pair generator implementation interface
TRAP_LOG(err,CKeyPairGeneratorFactory::CreateKeyPairGeneratorL(keypairImpl,
algorithmUid,
keyParams));
if(keypairImpl && (err == KErrNone))
{
plugin = static_cast<CCryptoBase*>(keypairImpl);
INFO_PRINTF1(_L("** Successfully Loaded Key Pair Generator Object **"));
SetTestStepResult(EPass);
}
else
{
ERR_PRINTF2(_L("** Error: Loading Key Pair Generator Object - %d **"), err);
SetTestStepResult(EFail);
}
CleanupStack::PopAndDestroy(keyParams);
}
break;
}
case KKeyAgreementInterface:
{
TVariantPtrC algorithmUid;
TVariantPtrC algorithmParams;
//Each of the individual parameters required to create the Key Agreement object
//are read in from the specified INI configuration file
if(!GetStringFromConfig(ConfigSection(),KConfigAlgorithmUid,algorithmUid) ||
!GetStringFromConfig(ConfigSection(),KConfigAlgorithmParams,algorithmParams))
{
ERR_PRINTF1(_L("** .INI Error: Key Agreement Arguments Not Located **"));
SetTestStepResult(EFail);
}
else
{
//********** Rule Selector Unselected to Create Key Pair ************
CCryptoSpiStateApi::UnsetSelector();
RInteger DH_N = RInteger::NewPrimeL(64);
CleanupClosePushL(DH_N);
RInteger DH_N_MinusOne = RInteger::NewL(DH_N);
CleanupClosePushL(DH_N_MinusOne);
DH_N_MinusOne-=1;
RInteger DH_G = RInteger::NewRandomL(TInteger::Two(), DH_N_MinusOne);
CleanupClosePushL(DH_G);
CCryptoParams* keyParams = CCryptoParams::NewLC();
TRAP_LOG(err,keyParams->AddL(DH_N, KDhKeyParameterNUid));
TRAP_LOG(err,keyParams->AddL(DH_G, KDhKeyParameterGUid));
//Create Key Pair and Key Pair Generator Objects
CKeyPair* keyPair = NULL;
CKeyPairGenerator * keypairImpl = NULL;
INFO_PRINTF1(_L("Generating Key Pair..."));
// create a key pair generator implementation interface
TRAP_LOG(err,CKeyPairGeneratorFactory::CreateKeyPairGeneratorL(keypairImpl,
KDHKeyPairGeneratorUid,
keyParams));
CleanupStack::PushL(keypairImpl);
// Create a Key Pair
TRAP_LOG(err,keypairImpl->GenerateKeyPairL(NULL, *keyParams, keyPair));
CleanupStack::PushL(keyPair);
CCryptoSpiStateApi::SetSelector(ruleSelector);
//******************************************************************
CKeyAgreement* keyAgreementImpl = NULL;
TRAP_LOG(err,CKeyAgreementFactory::CreateKeyAgreementL(keyAgreementImpl,
algorithmUid,
keyPair->PrivateKey(),
keyParams));
if(keyAgreementImpl && (err == KErrNone))
{
plugin = static_cast<CCryptoBase*>(keyAgreementImpl);
INFO_PRINTF1(_L("** Successfully Loaded Key Agreement Object **"));
SetTestStepResult(EPass);
}
else
{
ERR_PRINTF2(_L("** Error: Loading Key Agreement Object - %d **"), err);
SetTestStepResult(EFail);
}
CleanupStack::PopAndDestroy(6,&DH_N);
}
break;
}
default:
{
ERR_PRINTF1(_L("** .INI Error: Interface Type Unknown **"));
SetTestStepResult(EFail);
break;
}
}
}
if(TestStepResult()==EPass)
{
//Push the selected implementation onto the Cleanup Stack
CleanupStack::PushL(plugin);
//Assume faliure, unless all is successful
SetTestStepResult(EFail);
//Define a pointer of type TCharacteristics in order to store the appropriate
//encryption object's characterisctics
const TCharacteristics* characteristics(NULL);
//Retrieve the characteristics for the symmetric cipher implementation object
TRAP_LOG(err, plugin->GetCharacteristicsL(characteristics));
TVariantPtrC exAlgorithmUid;
TVariantPtrC exImplementationUid;
if(!GetStringFromConfig(ConfigSection(),KConfigExAlgorithmUid,exAlgorithmUid) ||
!GetStringFromConfig(ConfigSection(),KConfigExImplementationUid,exImplementationUid))
{
ERR_PRINTF1(_L("** .INI Error: Expected Algorithm Arguments Not Located **"));
SetTestStepResult(EFail);
}
else
{
INFO_PRINTF1(_L("Checking Plug-in Selection..."));
CPluginCharsChecker* pluginCheck = CPluginCharsChecker::NewLC();
TPtrC errorMessage;
//Perform plug-in Check
if(pluginCheck->checkSelectedPlugin(characteristics,
exAlgorithmUid,
exImplementationUid,
errorMessage))
{
INFO_PRINTF1(_L("** PASS: Correct Plugin Implementation Selected **"));
SetTestStepResult(EPass);
}
else
{
ERR_PRINTF2(_L("** FAIL: Wrong Plugin Implementation Selected - %S **"),&errorMessage);
}
CleanupStack::PopAndDestroy(pluginCheck);
}
CleanupStack::PopAndDestroy(plugin);
}
//Unselect Rule Selector
CCryptoSpiStateApi::UnsetSelector();
//Pop and Destroy Rule Selector from the Cleanup Stack
CleanupStack::PopAndDestroy(ruleSelector);
}
}
INFO_PRINTF2(_L("HEAP CELLS: %d"), User::CountAllocCells());
return TestStepResult();
}
TVerdict CRuleSelectCommonStep::doTestStepPostambleL()
{
return TestStepResult();
}