/*

* 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: 

*

*/

/**

 @file  

 @internalTechnology

*/

#include "tcertrequeststep.h"

#include <f32file.h> 

#include <e32std.h>

_LIT(KKeyLabel, "new pkcs10 test key"); 

// CertRequest tester active.

CPKCS10TesterActive::CPKCS10TesterActive( CTestExecuteLogger& aLogger ) : 

   CActive( EPriorityStandard ),

   iLogger( aLogger )

	{

	CActiveScheduler::Add( this );

	User::LeaveIfError(iFs.Connect());

	}

CPKCS10TesterActive::~CPKCS10TesterActive()

	{

   	delete iDN;

	iDN=NULL;	 

	delete iCertRequest;

	iCertRequest=NULL;			

 	delete iOutputASN1Encoding;	

 	iOutputASN1Encoding=NULL; 			

 	delete iSecondOutputASN1Encoding;

 	iSecondOutputASN1Encoding=NULL;

 	if (iKeyInfo)

 	{

		iKeyInfo->Release();

		iKeyInfo=NULL;	 			

 	}

	delete iKeyData;

	iKeyData=NULL;

	if(iKeyStore) // debug.

	{

	    iKeyStore->Cancel();

		delete iKeyStore;

		iKeyStore=NULL;	

	}

	iFs.Close ();

	}

void CPKCS10TesterActive::DeleteAllKeysL()

	{

	// Delete Key store.

	INFO_PRINTF1(_L("deleting store keys"));

  	iKeyStore = CUnifiedKeyStore::NewL(iFs);

  	CleanupStack::PushL(iKeyStore); 

  	iKeyStore->Initialize(iStatus);  

	iState = EDeleteAllInit;

	SetActive();

   	CActiveScheduler::Start();

   	iKeys.Close();

   	CleanupStack::Pop(iKeyStore);

   	delete iKeyStore;

	iKeyStore = NULL;	

	}

TVerdict CPKCS10TesterActive::doActiveCertRequestL(CCertificateRequestStep* aStep)

	{

	iTestSuccess= EFail;

	INFO_PRINTF1(_L("Active tester for Cert Request started. "));

	iStepPointer = aStep;

    DeleteAllKeysL();

    INFO_PRINTF1(_L("initialising keystore"));

	// Initialise Key store.

  	iKeyStore = CUnifiedKeyStore::NewL(iFs);

  	CleanupStack::PushL(iKeyStore); 

  	iKeyStore->Initialize(iStatus);  

	iState = EInitKeyStore; 

	SetActive();

   	CActiveScheduler::Start();

   	// After encoding was produced it checks correctness

    if(iRunError==KErrNone)

     {

	     if( !(iStepPointer->iOOMCondition) &&verifyCertReqEncodingL()!=EPass  )

		 {

			  iTestSuccess= EFail;

		 }

		 else    

		 {

		 	  iTestSuccess= EPass;

		 }

		 if( iTestSuccess && iStepPointer->iGenerateSecondRequest) // if cert was reused.

		 {

			// compare encoding of first and second request.

			if((iOutputASN1Encoding->Compare(iSecondOutputASN1Encoding->Des())) == 0)

			{

		 		INFO_PRINTF1(_L("Reuse verified"));

		 	}

			else

		 	{

		 		iTestSuccess= EFail;

		 		//iStepPointerSetTestStepResult(EFail);

		 		INFO_PRINTF1(_L("New output encoding is not what is expected"));		

		 	} 

		 }

     }

   	CleanupStack::Pop(iKeyStore);  

    return iTestSuccess;

}

TInt CPKCS10TesterActive::RunError(TInt aError)

	{

	iRunError =aError;

	iKeyStore->Cancel();

	if(iCertRequest)

	{

		iCertRequest->Cancel();	

	}

	CActiveScheduler::Stop();

	return KErrNone;

	}

void CPKCS10TesterActive::RunL()

	{

	iRunError =KErrNone;

 	User::LeaveIfError(iStatus.Int());

	switch(iState)

		{

		case EDeleteAllInit:

			INFO_PRINTF1(_L("  listing existing keys\n"));

			iKeyStore->List(iKeys, iKeyFilter, iStatus);

			iState = EDeleteAllDelete;

			SetActive();

			break;

		case EDeleteAllDelete:

			if (iKeys.Count() == 0)

				{

				// key log is empty

				iKeys.Close();

				CActiveScheduler::Stop();

				break;

				}

			INFO_PRINTF1(_L("  deleting key\n"));

			iKeyStore->DeleteKey(*iKeys[0], iStatus);

			iState = EDeleteAllDelete;

			SetActive();

			iKeys[0]->Release();

			iKeys.Remove(0);

			break;

		case EInitKeyStore:

			{

	  		INFO_PRINTF1(_L("Importing keys"));

 			TFileName filename;

 			filename = iStepPointer->iPrivateKey;

			RFile file;

			User::LeaveIfError(file.Open(iFs,filename,EFileRead));

			CleanupClosePushL(file);

			TInt size;

			User::LeaveIfError(file.Size(size));

			iKeyData = HBufC8::NewMaxL(size);

			TPtr8 keyPtr = iKeyData->Des();

			User::LeaveIfError(file.Read(keyPtr));			

			CleanupStack::PopAndDestroy(); // file

			TTime start(0.0); 

			TTime end(0.0); 

			// Assumes only one keystore

			// Check parameters!

		 	ASSERT(iKeyInfo == NULL);      

			iKeyStore->ImportKey(0, *(iKeyData), EPKCS15UsageSign, KKeyLabel,0, start, end,iKeyInfo, iStatus);

	  		iState = EImportKey;

	  		SetActive();

			break;

			}

	  	case EImportKey:

			{

			INFO_PRINTF1(_L("Setting security policy for new stored key"));

			TSecureId secureId(0x101f7784); // Application secure ID 

			TSecurityPolicy securePolicy(secureId,ECapabilityReadUserData);

			iKeyStore->SetUsePolicy(iKeyInfo->Handle(),securePolicy,iStatus);

			iState = EKeyPolicy;

 			SetActive();

 			break;

		   	}

		case EKeyPolicy:

			{

			iAttrCollection=CPKCS10Attributes::NewL();

 			CleanupStack::PushL(iAttrCollection); 

			INFO_PRINTF1(_L("Adding generic attributes"));		

 			AddGenericAttributesL();

 			INFO_PRINTF1(_L("Adding Challenge password"));

 			AddChallengePasswordL();

 			INFO_PRINTF1(_L("Adding V3 extensions"));

 			AddV3ExtensionsL();

 			INFO_PRINTF1(_L("Generating distinguished name"));

 			iDN=MakeDistinguishedNameL();

 			CleanupStack::PushL(iDN);

   	 		INFO_PRINTF1(_L("Generating cert request"));

   	 		iCertRequest=CPKCS10Request::NewL(*iDN,*iKeyInfo,iAttrCollection);

     		CleanupStack::PushL(iCertRequest);

     		INFO_PRINTF1(_L("Setting digest algorithm"));

			TAlgorithmId digestAlgo=iStepPointer->ConvertNameToDigestId(iStepPointer->iDigestAlg);

			iCertRequest->SetDigestAlgL(digestAlgo);

 			INFO_PRINTF1(_L("Requesting cert request encoding"));

 	  		// Clean up

 	  		CleanupStack::Pop(iCertRequest);

 			CleanupStack::Pop(iDN);

    	 	CleanupStack::Pop(iAttrCollection);

    	  	iAttrCollection=NULL;  

			iOutputASN1Encoding=NULL;

			iCertRequest->CreateEncoding(iOutputASN1Encoding,iStatus);

			iState=EGenerateCertRequest; 

	 		SetActive();     

	  		break;	

			}

		case EGenerateCertRequest:

			{ 

			// Use to debug encoding 			

  			// iStepPointer->OutputEncodingToFileL(iOutputASN1Encoding->Des()); //debug

			// Used for cert request reuse cases  

			if(iStepPointer->iGenerateSecondRequest)

				{       

						INFO_PRINTF1(_L("Reusing instance of CPKCS10Request"));

				        if(iStepPointer->iRepopulateDataRequest)

				        {

				         	iAttrCollection=CPKCS10Attributes::NewL();

				            CleanupStack::PushL(iAttrCollection); 

				        	AddGenericAttributesL();

				 			AddChallengePasswordL();

				 			AddV3ExtensionsL();

				 			// deletes previous value of iDN.

				 			delete iDN;

				 			iDN=MakeDistinguishedNameL();

				 			CleanupStack::PushL(iDN);

				   	 		TAlgorithmId digestAlgo2=iStepPointer->ConvertNameToDigestId(iStepPointer->iDigestAlg);

							// Repopulates data.

							CleanupStack::PushL(iCertRequest);

							iCertRequest->SetDigestAlgL(digestAlgo2);

							iCertRequest->SetDistinguishedNameL(*iDN);

							iCertRequest->SetAttributes(iAttrCollection);

							iCertRequest->SetKeyInfoL(*iKeyInfo);

							// Clean up

							CleanupStack::Pop(iCertRequest);

							CleanupStack::Pop(iDN);

    						CleanupStack::Pop(iAttrCollection);

    						iAttrCollection=NULL;		

				        }

				        INFO_PRINTF1(_L("Launches second cert request"));

				        iSecondOutputASN1Encoding=NULL;

				        iCertRequest->CreateEncoding(iSecondOutputASN1Encoding,iStatus);

				        iState=EGenerateSecondCertRequest;

				}

				else

				{

					 // if no reuse case delete keys and prepare for final state

						INFO_PRINTF1(_L("Deleting key"));

 		 				iKeyStore->DeleteKey(*iKeyInfo, iStatus);

 		 				iState=EDeleteKey;

				}

 		  	SetActive();  

 		 	break;	

			}

		case EGenerateSecondCertRequest:

			{

			INFO_PRINTF1(_L("Deleting key"));

 		 	iKeyStore->DeleteKey(*iKeyInfo,iStatus);

 		 	iState=EDeleteKey;

 		 	SetActive();

 		 	break;

			}

		case EDeleteKey:

			{

		    iKeyInfo->Release();  

			iKeyInfo = NULL;

		 	CActiveScheduler::Stop();

 		    break;	

			}

 		default:

			{

		  	INFO_PRINTF1(_L("Cert Request Active tester: State corrupted."));

			User::Leave(KErrCorrupt);

			}

 		} 

   	return; 

}

CCertificateRequestStep::~CCertificateRequestStep()

/**

 * Destructor

 */

	{   

 		delete iActiveObjTest;

 		delete iSched;

	}

CCertificateRequestStep::CCertificateRequestStep()

{

	SetTestStepName(KCertificateRequestStep);

}

TVerdict CCertificateRequestStep::doTestStepPreambleL()

{

	__UHEAP_MARK;	

	User::LeaveIfError (iFs.Connect());

	// initializes data.

	// Read values form config file 

	GetIntFromConfig(ConfigSection(), _L("Expected_error"), iExpectedError);	

    GetStringFromConfig(ConfigSection(), _L("DN_country"), iDN_country);

    GetStringFromConfig(ConfigSection(), _L("DN_state"), iDN_state);

    GetStringFromConfig(ConfigSection(), _L("DN_locality"), iDN_locality);

    GetStringFromConfig(ConfigSection(), _L("DN_organization"), iDN_organization);

    GetStringFromConfig(ConfigSection(), _L("DN_unit"), iDN_unit);

    GetStringFromConfig(ConfigSection(), _L("DN_common"), iDN_common);

    GetStringFromConfig(ConfigSection(), _L("DN_email"), iDN_email);

    GetStringFromConfig(ConfigSection(), _L("PrivateKey"),iPrivateKey);

    GetStringFromConfig(ConfigSection(), _L("OPENSSL_certreq"),iOPENSSLCertReq);

    GetStringFromConfig(ConfigSection(), _L("KeyAlg"),iKeyAlg);

    GetStringFromConfig(ConfigSection(), _L("ChallengePassword"),iChallengePassword);

    GetStringFromConfig(ConfigSection(), _L("DigestAlg"),iDigestAlg);

    GetBoolFromConfig(ConfigSection(), _L("OOMCondition"),iOOMCondition);

    GetBoolFromConfig(ConfigSection(), _L("GenerateSecondRequest"),iGenerateSecondRequest);

    GetBoolFromConfig(ConfigSection(), _L("RepopulateDataRequest"),iRepopulateDataRequest);

    GetIntFromConfig(ConfigSection(), _L("ElemCertReqCount"),iElemCertReqCount);

    GetIntFromConfig(ConfigSection(), _L("ElemCertInfoCount"),iElemCertInfoCount);

    GetIntFromConfig(ConfigSection(), _L("CertReqVer"),iCertReqVer);

    GetIntFromConfig(ConfigSection(), _L("ElemSubPubKeytInfoCount"),iElemSubPubKeytInfoCount);

    GetIntFromConfig(ConfigSection(), _L("ElemKeyAlgIdenCount"),iElemKeyAlgIdenCount);

    GetIntFromConfig(ConfigSection(), _L("ElemSigAlgIdenCount"),iElemSigAlgIdenCount);

    GetIntFromConfig(ConfigSection(), _L("Attribute_count"),iAttribute_count );

    // Read generic Attributes (ARRAY).

    TInt index(0);

	TName fGenericAttrOID;

	fGenericAttrOID.Format(_L("Attribute_OID_%d"), index);

	TName fGenericAttrValue;

	fGenericAttrValue.Format(_L("Attribute_value_%d"), index); 

	TPtrC genericAttrOIDName;

	TPtrC genericAttrValueName;

   	while (GetStringFromConfig(ConfigSection(), fGenericAttrOID, genericAttrOIDName)

			&& GetStringFromConfig(ConfigSection(), fGenericAttrValue, genericAttrValueName))

	{

	    iArrayGenAttrOID.AppendL(genericAttrOIDName);

	    iArrayGenAttrValue.AppendL(genericAttrValueName);

		index++;

		fGenericAttrOID.Format(_L("Attribute_OID_%d"), index);

		fGenericAttrValue.Format(_L("Attribute_value_%d"), index);

	}	

	// Read the v3 extension attributes (Array)

	index=0;

    TName fV3AttrOID;

	fV3AttrOID.Format(_L("V3_Extension_OID_%d"), index);

	TName fV3AttrCritical;

	fV3AttrCritical.Format(_L("V3_Extension_Critical_%d"), index); 

	TName fV3AttrValue;

	fV3AttrValue.Format(_L("V3_Extension_Value_%d"), index); 

	TPtrC v3AttrOID;

	TBool v3AttrCritical;

	TPtrC v3AttrValue;

   	while (GetStringFromConfig(ConfigSection(), fV3AttrOID, v3AttrOID)

			&& GetBoolFromConfig(ConfigSection(), fV3AttrCritical, v3AttrCritical)

			&& GetStringFromConfig(ConfigSection(), fV3AttrValue, v3AttrValue))

		{

	    iArrayV3AttrOID.AppendL(v3AttrOID);

	    iArrayV3AttrCritical.AppendL(v3AttrCritical);

	    iArrayV3AttrValue.AppendL(v3AttrValue);

		index++;

		fV3AttrOID.Format(_L("V3_Extension_OID_%d"), index);

		fV3AttrCritical.Format(_L("V3_Extension_Critical_%d"), index); 

		fV3AttrValue.Format(_L("V3_Extension_Value_%d"), index); 

		}	

	SetTestStepResult(EPass);

	return TestStepResult();

}

TVerdict CCertificateRequestStep::doTestStepL()

{

	if (!iOOMCondition)

		{

		 doTestL(); 

		}

	else

		{

 		return doOOMTestL();

	    }	

   	 return TestStepResult();

}

TVerdict CCertificateRequestStep::doOOMTestL()

{

	TVerdict verdict = EFail;

 	TInt countAfter = 0;

	TInt countBefore = 0;

 	for (TInt oomCount = 0; ; oomCount++)

 		{

 		INFO_PRINTF2(_L("\n ==== Number of memory allocations %d ===="), oomCount);

 		verdict = EFail;

 		__UHEAP_RESET;

 		__UHEAP_SETFAIL(RHeap::EDeterministic, oomCount);

 		countBefore = User::CountAllocCells();

 		TRAPD(error, doTestL());// ----> This is the actual test that runs under OOM conditions.

 		countAfter = User::CountAllocCells();

 		__UHEAP_RESET;

 		if (error != KErrNoMemory)  

 			{

 			verdict = EPass;

 			INFO_PRINTF2(_L("OOM Status %d"),error);

			INFO_PRINTF1(_L("Test outcome : Passed"));

 			break;

 			}

 		else

 			{

 			if (countBefore != countAfter)

 				{

 				INFO_PRINTF2(_L("OOM Status %d"),error);

 				INFO_PRINTF2(_L("OOM Failed at %d"), oomCount);

 				SetTestStepResult(verdict);  

 				break;

 				}

 			}

 		INFO_PRINTF2(_L("OOM Failed Point status %d"), error);

		}

	INFO_PRINTF3(_L("Heap alloc count ok: %d final vs %d initial"), countAfter,countBefore);

 	SetTestStepResult(verdict);

 	if (verdict==EFail)

	 	{

 		User::Leave(KErrGeneral);	 		

	 	}	 	

 	return verdict;

	}	

void CCertificateRequestStep::doTestL()

{

    iSched=new(ELeave) CActiveScheduler; 

    CleanupStack::PushL(iSched);  

	CActiveScheduler::Install(iSched);

	iActiveObjTest = new (ELeave) CPKCS10TesterActive(Logger());

	CleanupStack::PushL(iActiveObjTest);

	if (iActiveObjTest->doActiveCertRequestL(this) != EPass)

	 {

	 	SetTestStepResult(EFail);

	 	INFO_PRINTF1(_L("Verification FAIL."));

	 	// To keep happy out of memory test.

	 	User::Leave(KErrNoMemory);

	 }

	 else

	 {

	 	INFO_PRINTF1(_L("Verification PASS."));	

	 }

	 CleanupStack::PopAndDestroy(iActiveObjTest);

	 iActiveObjTest = NULL;

	 CleanupStack::PopAndDestroy(iSched);

	 iSched=NULL;

 }

TVerdict CPKCS10TesterActive::verifyCertReqEncodingL()

{   

    TVerdict certReqCheck= EPass;

	INFO_PRINTF1(_L("Verifiying cert request encoding"));

	TInt pos(0);

	CArrayPtrFlat<TASN1DecGeneric>* certReq= TASN1DecSequence().DecodeDERLC(*iOutputASN1Encoding,pos);

	// Verifies Number of elements in cert request.

	if(certReq->Count() != iStepPointer->iElemCertReqCount)

	{

		INFO_PRINTF1(_L("VERIFICATION FAILED: Incorrect number of elements in cert request"));

		certReqCheck= EFail;