/*

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

* Implementation of reuse test cases

*

*/

#include "tpkcs10minortests.h"

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

// Panics

_LIT(KPanicReuseTests, "PKCS10ReuseTests");

TInt EPanicInvalidTestData = 1;

void CPKCS10ReuseAttributeStep::doTestL()

	{

	// Set it to pass initially

	SetTestStepResult(EPass);

	//////////////////////////////////////////////////////////////////////////////

	// Test for reuse case of CPKCS10Attribute class

 	TInt numAttr = iArrayGenAttrOID.Count();

 	__ASSERT_ALWAYS((numAttr > 0), User::Panic(KPanicReuseTests, EPanicInvalidTestData));

	HBufC8 *string = HBufC8::NewMaxLC(iArrayGenAttrValue[0].Length());

	string->Des().Copy(iArrayGenAttrValue[0]);

	CASN1EncOctetString* attrString1 = CASN1EncOctetString::NewLC(*string);

	CPKCS10Attribute *genericAttr = CPKCS10Attribute::NewLC(iArrayGenAttrOID[0], attrString1);

	// Get the encoding

	CASN1EncBase* attrEncoding1 = genericAttr->GetEncodingLC();

	// Reset and reuse the class

	CASN1EncOctetString* attrString2 = CASN1EncOctetString::NewLC(*string);

	genericAttr->ResetL(iArrayGenAttrOID[0], attrString2);

	CleanupStack::Pop(attrString2);

	CASN1EncBase* attrEncoding2 = genericAttr->GetEncodingLC();

	// Compare the encodings

	TBool result = IsMatchingEncodingL(attrEncoding1, attrEncoding2);

	CleanupStack::PopAndDestroy(3, genericAttr);	// attrEncoding1, attrEncoding2

	CleanupStack::Pop(attrString1);

	CleanupStack::PopAndDestroy(string);

	if (result == EFalse)

		{

		SetTestStepResult(EFail);

		}

	}

void CPKCS10ReuseChallengePasswordAttrStep::doTestL()

	{

	// Set it to pass initially

	SetTestStepResult(EPass);

	//////////////////////////////////////////////////////////////////////////////

	// Test for reuse case of CPKCS9ChallengePasswordAttr class

	HBufC8 *passwordString = HBufC8::NewMaxLC(iChallengePassword.Length());

	passwordString->Des().Copy(iChallengePassword);

	CPKCS9ChallengePasswordAttr *chPasswordAttr = CPKCS9ChallengePasswordAttr::NewLC(*passwordString);

	// Get the encoding

	CASN1EncBase* attrEncoding1 = chPasswordAttr->GetEncodingLC();

	// Reset and reuse the class

	chPasswordAttr->ResetL(*passwordString);

	CASN1EncBase* attrEncoding2 = chPasswordAttr->GetEncodingLC();

	// Compare the encodings

	TBool result = IsMatchingEncodingL(attrEncoding1, attrEncoding2);

	CleanupStack::PopAndDestroy(4, passwordString);	// chPasswordAttr, attrEncoding1, attrEncoding2

	if (result == EFalse)

		{

		SetTestStepResult(EFail);

		}

	}

void CPKCS10ReuseExtensionAttrStep::doTestL()

	{

	// Set it to pass initially

	SetTestStepResult(EPass);

	//////////////////////////////////////////////////////////////////////////////

	// Test for reuse case of CPKCS10Attribute class

	HBufC8 *extValue1 = HBufC8::NewMaxLC(iArrayV3AttrValue[0].Length());

	extValue1->Des().Copy(iArrayV3AttrValue[0]);

	CX509CertExtension *v3ExtAttr1 = CX509CertExtension::NewLC(iArrayV3AttrOID[0], 

												 iArrayV3AttrCritical[0],

												 *extValue1);

	HBufC8 *extValue2 = HBufC8::NewMaxLC(iArrayV3AttrValue[1].Length());

	extValue2->Des().Copy(iArrayV3AttrValue[1]);

	CX509CertExtension *v3ExtAttr2 = CX509CertExtension::NewLC(iArrayV3AttrOID[1], 

												 iArrayV3AttrCritical[1],

												 *extValue2);

	CPKCS9ExtensionRequestAttr *extReqAttr = CPKCS9ExtensionRequestAttr::NewLC(*v3ExtAttr1);

	extReqAttr->AddExtensionL(*v3ExtAttr2);

	// Get the encoding

	CASN1EncBase* attrEncoding1 = extReqAttr->GetEncodingLC();

	// Reset and reuse the class

	extReqAttr->ResetL(*v3ExtAttr1);

	extReqAttr->AddExtensionL(*v3ExtAttr2);

	CASN1EncBase* attrEncoding2 = extReqAttr->GetEncodingLC();

	// Compare the encodings

	TBool result = IsMatchingEncodingL(attrEncoding1, attrEncoding2);

	CleanupStack::PopAndDestroy(7, extValue1);	// v3ExtAttr1, extValue2, v3ExtAttr2, extReqAttr, attrEncoding1, attrEncoding2

	if (result == EFalse)

		{

		SetTestStepResult(EFail);

		}

	}

CPKCS10TesterActiveCancelRequestA::CPKCS10TesterActiveCancelRequestA( CTestExecuteLogger& aLogger ) : 

   CPKCS10TesterActive( aLogger )

	{

	}

void CPKCS10CancelRequestAStep::doTestL()

{

    iSched=new(ELeave) CActiveScheduler; 

    CleanupStack::PushL(iSched);  

	CActiveScheduler::Install(iSched);

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

	CleanupStack::PushL(iActiveObjTest);

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

	 {

	 	SetTestStepResult(EFail);

	 }

	 CleanupStack::PopAndDestroy(iActiveObjTest);

	 iActiveObjTest = NULL;

	 CleanupStack::PopAndDestroy(iSched);

	 iSched=NULL;

 }

TVerdict CPKCS10TesterActiveCancelRequestA::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!=KErrCancel)

     {

	     iTestSuccess= EFail;

	 }

	 else

	 {

	 	iTestSuccess= EPass;

	 }

   	CleanupStack::Pop(iKeyStore);  

    return iTestSuccess;

}

void CPKCS10TesterActiveCancelRequestA::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();

			iCertRequest->Cancel();

	  		break;	

			}

		default:

			{

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

			User::Leave(KErrCorrupt);

			}

 		} 

   	return; 

}