/*

 * Copyright (c) 2002-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: 

 *

 */

 #include "tpkcs7step.h"

 #include <test/testexecutelog.h>

 #include "pkcs7signedobject.h"

 #include <pkcs7contentinfo_v2.h>

 #include <pkcs7digestinfo.h>

 #include <pkcs7encrypteddataobject.h>

 #include <pkixcertchain.h>

 #include <pbe.h>

 #include <pbedata.h>

 #include <asn1dec.h>

 #include "validate.h"

 CTPKCS7CorruptTest::CTPKCS7CorruptTest()

 	{

 	SetTestStepName(KTPKCS7CorruptTest);

 	}

 CTPKCS7ValidTest::CTPKCS7ValidTest()

 	{

 	SetTestStepName(KTPKCS7ValidTest);

 	}

 CTPKCS7ContentTest::CTPKCS7ContentTest()

 	{

 	SetTestStepName(KTPKCS7ContentTest);

 	}

 CTPKCS7CertificateTest::CTPKCS7CertificateTest()

 	{

 	SetTestStepName(KTPKCS7CertificateTest);

 	}

 CTPKCS7SignerTest::CTPKCS7SignerTest()

 	{

 	SetTestStepName(KTPKCS7SignerTest);

 	}

 CTPKCS7EncryptedDataTest::CTPKCS7EncryptedDataTest()

 	{

 	SetTestStepName(KTPKCS7EncryptedDataTest);

 	}

 CTPKCS7DigestInfoTest::CTPKCS7DigestInfoTest()

 	{

 	SetTestStepName(KTPKCS7DigestInfoTest);

 	}

 CTPKCS7EncryptedDataCorruptTest::CTPKCS7EncryptedDataCorruptTest()

 	{

 	SetTestStepName(KTPKCS7EncryptedDataCorruptTest);

 	}

 CTPKCS7DigestInfoCorruptTest::CTPKCS7DigestInfoCorruptTest()

 	{

 	SetTestStepName(KTPKCS7DigestInfoCorruptTest);

 	}

 CTPKCS7OOMTest::CTPKCS7OOMTest()

 	{

 	SetTestStepName(KTPKCS7OOMTest);

 	}

 TVerdict CTPKCS7OOMTest::doTestStepL()

 	{

 	TVerdict verdict = EFail;

  	TInt countAfter = 0;

 	TInt countBefore = 0;

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

  		{

  		__UHEAP_RESET;

  		__UHEAP_SETFAIL(RHeap::EDeterministic, oomCount);

  		countBefore = User::CountAllocCells();

  		TRAPD(error, doTestOOML());

  		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);

  				verdict = EFail;

  				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);

  	return verdict;

 	}

 void CTPKCS7OOMTest::doTestOOML()

 	{

 	TInt OOMTest;

 	GetIntFromConfig(ConfigSection(),_L("OOMTestNo"),OOMTest);

 	__UHEAP_MARK;

 	if (OOMTest == 1)

 		{

 		CPKCS7ContentInfo* theTest = NULL;

 		theTest = CPKCS7ContentInfo::NewL(iRawData->Des());

 		delete theTest;

 		}

 	// Digest Info

 	else if (OOMTest == 2)

 		{

 		CPKCS7DigestInfo* theTest0 = NULL;

 		theTest0 = CPKCS7DigestInfo::NewL(iRawData->Des());

 		delete theTest0;

 		}

 	// Encrypted Data

 	else if (OOMTest == 3)

 		{

 		CPKCS7ContentInfo* theTest1 = NULL;

 		theTest1 = CPKCS7ContentInfo::NewL(iRawData->Des());

 		CleanupStack::PushL(theTest1);

 		CPKCS7EncryptedDataObject* theTest2 = NULL;

 		theTest2 = CPKCS7EncryptedDataObject::NewL(*theTest1);

 		CleanupStack::PopAndDestroy(theTest1);

 		delete theTest2;

 		}

 	__UHEAP_MARKEND;

 }

 //	Step 1	Corrupt

 TVerdict CTPKCS7CorruptTest::doTestStepL()

 	{

 	if (TestStepResult() != EPass)

 		{

 		return TestStepResult();

 		}

 	TInt reason;

 	if (GetIntFromConfig(ConfigSection(),_L("Reason"),reason) == EFalse)

 		{

 		reason = KErrNone;

 		}

 	TInt err;

     //Use CPKCS7ContentInfo class in order to obtain the ContentType and ContentData.

     //Depending on the ContentType the corresponding Object of that ContentType is created.

 	CPKCS7ContentInfo * contentInfo = NULL;

 	TRAP (err, contentInfo = CPKCS7ContentInfo::NewL(iRawData->Des()));

 	//Checks if the file is empty, Corrupt

 	if (err == reason)

 		{

 		delete contentInfo;

 		SetTestStepResult(EPass);

 		INFO_PRINTF3(_L("Expected result %d, got %d"), reason, err);

 		return TestStepResult();

 		}

 	if( err == KErrNone)

 		{

 		//ContentType is SignedData

 		if( contentInfo->ContentType() == KPkcs7SignedData)

 			{

 			CPKCS7SignedObject * p7 = NULL;

 			TRAP (err, p7 = CPKCS7SignedObject::NewL(*contentInfo));

 			delete p7;

 			}

 		}

 	delete contentInfo;

 	if (err != reason)

 		{

 		SetTestStepResult(EFail);

 		INFO_PRINTF3(_L("Expected result %d, got %d"), reason, err);

 		}

 	//Not corrupt , repeat files

 	return TestStepResult();

 	}

 TVerdict CTPKCS7ValidTest::doTestStepL()

 	{

 	if (TestStepResult() != EPass)

 		{

 		return TestStepResult();

 		}

 	__UHEAP_MARK;

 	TBool expectedValid;

 	if (GetBoolFromConfig(ConfigSection(),_L("IsValid"), expectedValid) == EFalse)

 		{

 		expectedValid = ETrue;

 		}

 	TInt err;

 	CPKCS7ContentInfo * contentInfo = NULL;

 	TRAP (err, contentInfo = CPKCS7ContentInfo::NewL(iRawData->Des()));

 	if(err == KErrNone)

 		{

 		CPKCS7SignedObject * p7 = NULL;

 		if( contentInfo->ContentType() == KPkcs7SignedData)

 			{

 			TRAP (err, p7 = CPKCS7SignedObject::NewL(*contentInfo));

 			//expired, and the case where certificate chain root is not on the device	

 			if (!expectedValid)

 				{

 				if (err != KErrNone)

 					{

 					SetTestStepResult(EPass);

 					INFO_PRINTF2(_L("Got %d building PKCS7 object"), err);

 					return TestStepResult();

 					}

 				}

 			if (err != KErrNone)

 				{

 				SetTestStepResult(EFail);

 				INFO_PRINTF2(_L("Got %d building PKCS7 object"), err);

 				}

 			else

 				{

 				CleanupStack::PushL (p7);

 				const RPointerArray<CPKCS7SignerInfo>& signers = p7->SignerInfo();

 				TBool isValid = EFalse;

 				HBufC8* certificateEncoding = NULL;

 				if(!p7->ValidateSignerL(*signers[0], certificateEncoding))

 					{

 					INFO_PRINTF1(_L("Couldn't validate signer"));

 					}

 				else

 					{

 					CActiveScheduler* sched = NULL;

 					if (CActiveScheduler::Current() == NULL)

 						{

 						INFO_PRINTF1(_L("Installing scheduler"));

 						sched = new (ELeave) CActiveScheduler();

 						CleanupStack::PushL (sched);

 						__UHEAP_MARK;

 						CActiveScheduler::Install (sched);

 						}

 					RPointerArray<CX509Certificate> roots (&iRootCertificate, 1);

 					CPKIXCertChain * chain = CPKIXCertChain::NewLC(iFs, *certificateEncoding, roots);

 					TTime tm;

 					_LIT(KDateCorrect1,"20040801:"); 

 					TBuf <24> theDate(KDateCorrect1); 

 					TInt err=tm.Set(theDate); 

 					if(err)

 						{

 						tm.HomeTime();

 						}

 					CPKIXValidationResult* result = CPKIXValidationResult::NewLC();

 					CTPKCS7Validator* validator = new (ELeave) CTPKCS7Validator (chain, result, &tm);

 					CleanupStack::PushL (validator);

 					validator->doValidate ();

 					sched->Start ();

 					if (result->Error().iReason == EValidatedOK)

 						{

 						isValid = ETrue;

 						INFO_PRINTF1(_L("Validation success"));

 						}

 					else

 						{

 						INFO_PRINTF2(_L("Validation failed: %d"), result->Error().iReason);

 						}

 					CleanupStack::PopAndDestroy(validator);

 					CleanupStack::PopAndDestroy(result);

 					CleanupStack::PopAndDestroy(chain);

 					if (sched)

 						{

 						CActiveScheduler::Install (NULL);

 						CleanupStack::PopAndDestroy (sched);

 						}

 					}

 				if (certificateEncoding)

 					{

 					CleanupStack::PopAndDestroy(certificateEncoding);

 					}

 				CleanupStack::PopAndDestroy (p7);

 				if (isValid != expectedValid)

 					{

 					SetTestStepResult(EFail);

 					if (expectedValid)

 						{

 						INFO_PRINTF1(_L("Expected valid, got invalid"));

 						}

 					else

 						{

 						INFO_PRINTF1(_L("Expected invalid, got valid"));

 						}

 					}

 				}

 			}

 		}

 	else

 		{

 		SetTestStepResult(EFail);

 		}

 	__UHEAP_MARKEND;

 	return TestStepResult();

 	}

 //	Step 3	Content

 TVerdict CTPKCS7ContentTest::doTestStepL()

 	{

 	if (TestStepResult() != EPass)

 		{

 		return TestStepResult();

 		}

 	TBool checkType;

 	TBool checkLength;

 	TBool checkContent;

 	TInt expectedType;

 	TInt expectedLength;

 	TPtrC expectedString;

 	HBufC8 * expectedContent = NULL;

 	checkType    = GetIntFromConfig   (ConfigSection(),_L("ContentType"),   expectedType);

 	checkLength  = GetIntFromConfig   (ConfigSection(),_L("ContentLength"), expectedLength);

 	checkContent = GetStringFromConfig(ConfigSection(),_L("ContentString"), expectedString);

 	if (checkContent)

 		{

 		if (expectedString.Length() & 1)

 			{

 			SetTestStepResult(ETestSuiteError);

 			INFO_PRINTF1(_L("ContentString is not a multiple of 2 long"));

 			checkContent = EFalse;

 			}

 		else

 			{

 			// workaround to parse the expectedstring 

 			expectedContent = HBufC8::NewLC (expectedString.Length()/2);

 			TPtr8 des = expectedContent->Des ();

 			for (TInt i = 0; i < expectedString.Length()/2; i++)

 				{

 				TInt top = expectedString[2*i];

 				TInt low = expectedString[2*i+1];

 				if (top >= 0x61) top -= (0x61-10);

 				else top -= 0x30;

 				if (low >= 0x61) low -= (0x61-10);

 				else low -= 0x30;

 				des.Append (top*16+low);

 				}

 			}

 		}

 	TInt err;

     CPKCS7ContentInfo * contentInfo = NULL;

 	TRAP (err, contentInfo = CPKCS7ContentInfo::NewL(iRawData->Des()));

     if(err == KErrNone)

 		{

 		CPKCS7SignedObject * p7 = NULL;

 		if( contentInfo->ContentType() == 2)

 			{

 			TRAPD (err, p7 = CPKCS7SignedObject::NewL(*contentInfo));

 			if (err != KErrNone)

 				{

 				SetTestStepResult(EFail);

 				INFO_PRINTF2(_L("Got %d building PKCS7 object"), err);

 				}

 			else

 				{

 				CleanupStack::PushL (p7);

 				const CPKCS7ContentInfo& p7info = p7->ContentInfo ();

 				if (checkType)

 					{

 					if (p7info.ContentType() != expectedType)

 						{

 						SetTestStepResult(EFail);

 						INFO_PRINTF3(_L("Expected ContentType %d, got %d"), expectedType, p7info.ContentType());

 						}

 					}

 				const TDesC8& content = p7info.ContentData();

 				if (checkLength)

 					{

 					if (content.Length() != expectedLength)

 						{

 						SetTestStepResult(EFail);

 						INFO_PRINTF3(_L("Expected ContentLength %d, got %d"), expectedLength, content.Length());

 						}

 					}

 				if (checkContent)

 					{

 					if (content.Length() != expectedContent->Length())

 						{

 						SetTestStepResult(EFail);

 						INFO_PRINTF3(_L("Expected ContentString length %d does not correspond to PKCS7 data length %d"),

 						expectedContent->Length(), content.Length());

 						}

 					else

 						{

 						if (expectedContent->Compare(content) != 0)

 							{

 							SetTestStepResult(EFail);

 							INFO_PRINTF1(_L("Expected ContentString does not match PKCS7 content"));

 							}

 						}

 					}

 				CleanupStack::PopAndDestroy (p7);

 				}

 			}

 		}

 	else

 		{

 		SetTestStepResult(EFail);

 		}

 		if (expectedContent)

 			{

 			CleanupStack::PopAndDestroy (expectedContent);

 			}

 		if (!checkType && !checkLength && !checkContent && (TestStepResult()==EPass))

 			{

 			SetTestStepResult(EInconclusive);

 			INFO_PRINTF1(_L("No test performed in this step"));

 			}

 	return TestStepResult();

 	}

 //	Step 4	Certificate

 TVerdict CTPKCS7CertificateTest::doTestStepL()

 	{

 	if (TestStepResult() != EPass)

 		{

 		return TestStepResult();

 		}

 	TBool checkCount;

 	TInt expectedCount;

 	checkCount = GetIntFromConfig (ConfigSection(),_L("CertificateCount"), expectedCount);

 	TInt err;

 	CPKCS7ContentInfo * contentInfo = NULL;

 	TRAP (err, contentInfo = CPKCS7ContentInfo::NewL(iRawData->Des()));

 	if(err == KErrNone)

 		{

 		CPKCS7SignedObject * p7 = NULL;

 		if( contentInfo->ContentType() == 2)

 			{

 			TRAP (err, p7 = CPKCS7SignedObject::NewL(*contentInfo));

 			if (err != KErrNone)

 				{

 				SetTestStepResult(EFail);

 				INFO_PRINTF2(_L("Got %d building PKCS7 object"), err);

 				}

 			else

 				{

 				CleanupStack::PushL (p7);

 				const RPointerArray<CPKCS7ExtendedCertificateOrCertificate>& certificates = p7->Certificates();

 				if (checkCount)

 					{

 					if (certificates.Count() != expectedCount)

 						{

 						SetTestStepResult(EFail);

 						INFO_PRINTF3(_L("Expected %d certificates, got %d"), expectedCount, certificates.Count());

 						}

 					}

 				CleanupStack::PopAndDestroy (p7);

 				}

 			}

 		}

 	else

 		{

 		SetTestStepResult(EFail);

 		}

 	if (!checkCount && (TestStepResult()==EPass))

 		{

 		SetTestStepResult(EInconclusive);

 		INFO_PRINTF1(_L("No test performed in this step"));

 		}

 	return TestStepResult();

 	}

 //	Step 5	Signer

 TVerdict CTPKCS7SignerTest::doTestStepL()

 	{

 	if (TestStepResult() != EPass)

 		{

 		return TestStepResult();

 		}

 	TBool checkCount;

 	TInt expectedCount;

 	checkCount = GetIntFromConfig (ConfigSection(),_L("SignerCount"), expectedCount);

 	TInt err;

 	CPKCS7ContentInfo * contentInfo = NULL;

 	TRAP (err, contentInfo = CPKCS7ContentInfo::NewL(iRawData->Des()));

     if(err == KErrNone)

 		{

 		CPKCS7SignedObject * p7 = NULL;

 		if( contentInfo->ContentType() == 2)

 			{

 			TRAPD (err, p7 = CPKCS7SignedObject::NewL(*contentInfo));

 			if (err != KErrNone)

 				{

 				SetTestStepResult(EFail);

 				INFO_PRINTF2(_L("Got %d building PKCS7 object"), err);

 				}

 			else

 				{

 				CleanupStack::PushL (p7);

 				const RPointerArray<CPKCS7SignerInfo>& signers = p7->SignerInfo();

 				if (checkCount)

 					{

 					if (signers.Count() != expectedCount)

 						{

 						SetTestStepResult(EFail);

 						INFO_PRINTF3(_L("Expected %d signers, got %d"), expectedCount, signers.Count());

 						}

 					}

 				CleanupStack::PopAndDestroy (p7);

 				}

 			}

 		}

 	if (!checkCount && (TestStepResult()==EPass))

 		{

 		SetTestStepResult(EInconclusive);

 		INFO_PRINTF1(_L("No test performed in this step"));

 		}

 	return TestStepResult();

 	}

 //Encrypted Data

 TVerdict CTPKCS7EncryptedDataTest::doTestStepL()

 	{

 	if (TestStepResult() != EPass)

 		{

 		return TestStepResult();

 		}

 	TInt reason;

 	// Read from INI file.

 	GetIntFromConfig(ConfigSection(),_L("Reason"),reason);

 	//Is Valid	

   	TBool expectedValid;

   	TBool checkValid;

   	checkValid = GetBoolFromConfig(ConfigSection(),_L("IsValid"), expectedValid);

 	 __UHEAP_MARK;

     CPKCS7ContentInfo *contentInfo = NULL;

 	TRAPD (err, contentInfo = CPKCS7ContentInfo::NewL(iRawData->Des()));

 	CleanupStack::PushL(contentInfo);

     if(err == KErrNone)

 		{

 		CPKCS7EncryptedDataObject* p7 = NULL;

 		TInt type = contentInfo->ContentType();

 		if( contentInfo->ContentType() == CPKCS7ContentInfo::EContentTypeEncryptedData)

 			{

 			TRAPD (err, p7 = CPKCS7EncryptedDataObject::NewL(*contentInfo));

 		    CleanupStack::PushL(p7);

 		    __UHEAP_MARK;

 			if (checkValid)

   				{

   				if(!expectedValid && err == reason)

   		 			{ 

 					CleanupStack::PopAndDestroy(2,contentInfo);//p7, contentInfo

   		 			return TestStepResult();

   		 			}

   				if(!expectedValid && contentInfo->ContentType() == 1)	

            			{

            			CleanupStack::PopAndDestroy(2,contentInfo);//p7, contentInfo

            		 	return TestStepResult();

            			}

   				}

 			if (err != KErrNone)

 				{

 				SetTestStepResult(EFail);

 				ERR_PRINTF2(_L("Got %d building PKCS7 object"), err);

 				}

 			//CONTENT TYPE

 			CPKCS7EncryptedDataObject::TContentType contentType = p7->ContentType();

 			if(contentType != CPKCS7EncryptedDataObject::EPkcs7Data)

     			{

      			SetTestStepResult(EFail);

      			ERR_PRINTF1(_L("ContentType does not match"));

      			CleanupStack::PopAndDestroy(3,contentInfo);//expectedContentType, p7, contentInfo

      			return TestStepResult();	

      			}

 			 else

      			{

      			INFO_PRINTF1(_L("ContentType matches"));	

      			}

 			//ENCRYPTEDCONTENT DATA

 			const TDesC8& contentData = p7->EncryptedContentInfoData();

 			if(contentData.Compare(*iContentData) != 0)

 				{

 	   			SetTestStepResult(EFail);

 	   			ERR_PRINTF1(_L("EncryptedContentData does not match"));

 	   			CleanupStack::PopAndDestroy(2,contentInfo);	//p7, contentInfo

 	   			return TestStepResult();

 	  			}

 			else

 	  			{

 	  			INFO_PRINTF1(_L("EncryptedContentData matches")); 	

 	  			}

 			//SALT

 			const CPBEncryptParms& encryptParams = p7->EncryptParams();

 			if((encryptParams.Salt()).Compare(*iSaltValue) != 0)

 				{

 	   			SetTestStepResult(EFail);

 	   			ERR_PRINTF1(_L("Salt Value does not match"));	

 	   			CleanupStack::PopAndDestroy(2, contentInfo);//p7,contentInfo

 	   			return TestStepResult();

 	  			}

 			else

 				{

 				INFO_PRINTF1(_L("Salt Value matches"));	

 				}  	

 			//ITERATION COUNT

 			TBool checkIteration;

 			TInt expectedIterationCount;

 			checkIteration = GetIntFromConfig(ConfigSection(),_L("Iteration"), expectedIterationCount);

 			if(checkIteration)

 				{

 	   			if(encryptParams.Iterations() != expectedIterationCount)

 	   				{

 	   				SetTestStepResult(EFail);

 	   				ERR_PRINTF1(_L("Iterations does not match"));

 	   				CleanupStack::PopAndDestroy(2, contentInfo);//p7, contentInfo

 	   				return TestStepResult();	

 	   				}

 	   			else

 	   				{

 	   				INFO_PRINTF1(_L("Iteration matches")); 

 	   				}

 	  			}		

 			//CIPHER

 			TBool checkCipher;

 			TPtrC expectedCipher;

 			TPBECipher cipherValue = (TPBECipher) -1;//assign to impossible value

 			checkCipher = GetStringFromConfig(ConfigSection(),_L("Algorithm"),  expectedCipher);

 			if(checkCipher)

 				{

 				if(expectedCipher.Compare(_L("pbeWithSHA1And40BitRC2_CBC")) == 0)

 	   	 			{

 	   	  			cipherValue = ECipherRC2_CBC_40_5;

 	     			}

 				else if(expectedCipher.Compare(_L("pbeWithSHA1And128BitRC4")) == 0)

 	   	 			{

 	   	  			cipherValue = ECipherARC4_128;

 	     			}

 	            else if(expectedCipher.Compare(_L("pbeWithSHA1AndDES-CBC")) == 0)

 	   	 			{

 	   	  			cipherValue = ECipherDES_CBC;

 	     			}

 	     		else if(expectedCipher.Compare(_L("pbeWithSHAAnd3_KeyTripleDES_CBC")) == 0)

 	   	 			{

 	   	  			cipherValue = ECipher3DES_CBC;

 	     			}

 	     		else if(expectedCipher.Compare(_L("pbeWithSHAAnd2-KeyTripleDES-CBC"))==0)

 	     			{

 	     			cipherValue = ECipher2Key3DES_CBC;	

 	     			}

 	     		else if(expectedCipher.Compare(_L("pbeWithSHA1And40BitRC4")) == 0)

 	   	 			{

 	   	  			cipherValue = ECipherARC4_40;

 	     			}

 	     		else if(expectedCipher.Compare(_L("pbewithSHAAnd128BitRC2CBC")) == 0)

 	   	 			{

 	   	  			cipherValue = ECipherRC2_CBC_128_16;

 	     			}

 	     		else if(expectedCipher.Compare(_L("pbeWithSHA1AndRC2_CBC")) == 0)

 	     			{

 	     			cipherValue = ECipherRC2_CBC_40;

 	     			}

 	   			if(encryptParams.Cipher() != cipherValue)

 	     			{

 	     			SetTestStepResult(EFail);

 	     			ERR_PRINTF1(_L("Cipher does not match"));

 	     			CleanupStack::PopAndDestroy(3, contentInfo);//expectedCipher,p7,contentInfo

 	     			return TestStepResult();	

 	     			} 

 				else 

 	    			{

 	   				INFO_PRINTF1(_L("Cipher matches")); 

 	    			}

 				}

 			if(contentData.Length() != 0)

 				{

 				//Decryption

 				TBool checkPassword;

 				TPtrC password;

 				checkPassword = GetStringFromConfig(ConfigSection(),_L("Password"), password);

 				if(checkPassword)

 					{

 			    	HBufC8* plainText = p7->DecryptDataL(password);

 			    	delete plainText;

 			    	SetTestStepResult(EPass);

 	  				} 

 				}

 	  		CleanupStack::PopAndDestroy(p7);

             }

         //If ContentType is not Encrypted Data

         else

         	{

         	if(checkValid)

           		{

           		if(!expectedValid && err == reason)

  		 			{

   		 			CleanupStack::PopAndDestroy(contentInfo);

   		 			return TestStepResult();

   		 			}

           		else

           			{

           			SetTestStepResult(EFail);	

           			}

           		}

        		}

 		}

 	else if(err != reason)

 		{

 		SetTestStepResult(EFail);

 		}

 	CleanupStack::PopAndDestroy(contentInfo);

 	__UHEAP_MARKEND;

 	return TestStepResult();

 	}

 //Digest Info

 TVerdict CTPKCS7DigestInfoTest::doTestStepL()

 	{

 	if (TestStepResult() != EPass)

 		{

 		return TestStepResult();

 		}

 	__UHEAP_MARK;

 	TInt reason;

 	// Read from INI file.

 	GetIntFromConfig(ConfigSection(),_L("Reason"),reason);

 	CPKCS7DigestInfo* p7 = NULL;

 	TRAPD (err, p7 = CPKCS7DigestInfo::NewL(iRawData->Des()));

 	CleanupStack::PushL(p7);

 	if (err != KErrNone)

 		{

 		if(err == reason)

 			{

 			CleanupStack::PopAndDestroy(p7);

 			SetTestStepResult(EPass);

 			return TestStepResult();

 			}

 		else

 			{

 			SetTestStepResult(EFail);

 			ERR_PRINTF2(_L("Got %d building PKCS7 object"), err);

 			}

 		}

 	//DIGEST	

     const TDesC8& digest = p7->Digest();

     if(digest.Compare(*iDigest) != 0)		

     	{

        	SetTestStepResult(EFail);

 	   	ERR_PRINTF1(_L("Digest does not match"));

       	}

     else

 		{

 		INFO_PRINTF1(_L("Digest matches"));		

 		}

     //ALGORITHM ID

     TBool checkAlgorithm;

     TPtrC expectedAlgorithm;

     TAlgorithmId algorithmId = (TAlgorithmId) -1;

 	checkAlgorithm = GetStringFromConfig(ConfigSection(),_L("AlgorithmId"), expectedAlgorithm);

 	if(checkAlgorithm)

 		{

 	   	if(expectedAlgorithm.Compare(_L("SHA1")) == 0)

 	   	 	{

 	   	  	algorithmId = ESHA1;

 	     	}

       	else if(expectedAlgorithm.Compare(_L("MD5")) == 0)

 	   	 	{

 	   	  	algorithmId = EMD5;

 	     	}

     	if(algorithmId != p7->Algorithm())  

         	{

        		SetTestStepResult(EFail);

 	   		ERR_PRINTF1(_L("Algorithm Id does not match"));	

       		}

       	else

       		{

       		INFO_PRINTF1(_L("Algorithm Id matches"));	

       		}	

     	}

     //ENCODED PARAMS

     const TDesC8& encodedParams= p7->EncodedParams();

     if(encodedParams.Length() != 0)

     	{

     	if(encodedParams.Compare(*iEncodedParams))  

     		{

        		SetTestStepResult(EFail);

 	   		ERR_PRINTF1(_L("EncodedParams does not match"));		

       		}

     	else

     		{

     		INFO_PRINTF1(_L("EncodedParams match"));	

     		}  	

     	}

     else if(!iEncodedParams)

         {

         INFO_PRINTF1(_L("EncodedParams not present"));	

         }

     CleanupStack::PopAndDestroy(p7);

     __UHEAP_MARKEND;	

 	return TestStepResult();

 	}

 //EncryptedDataCorrupt

 //Step8

 TVerdict CTPKCS7EncryptedDataCorruptTest::doTestStepL()

 	{

 	if (TestStepResult() != EPass)

 		{

 		return TestStepResult();

 		}

     __UHEAP_MARK;	

 	TInt reason;

 	GetIntFromConfig(ConfigSection(),_L("Reason"),reason);

 	CPKCS7ContentInfo *contentInfo = NULL;

 	TRAPD (err, contentInfo = CPKCS7ContentInfo::NewL(iRawData->Des()));

 	CleanupStack::PushL(contentInfo);

 	if(err != KErrNone)

 		{

 		if (err != reason)

 			{

 			SetTestStepResult(EFail);

 			INFO_PRINTF3(_L("Expected result %d, got %d"), reason, err);

 			}

 		}

 	if (err == reason)

 		{

 		CleanupStack::PopAndDestroy(contentInfo);

 		return TestStepResult();

 		}

     CPKCS7EncryptedDataObject* p7 = NULL;

 	TRAPD (err1, p7 = CPKCS7EncryptedDataObject::NewL(*contentInfo));

 	CleanupStack::PushL(p7);

 	if (err1 != reason)

 		{

 		SetTestStepResult(EFail);

 		INFO_PRINTF3(_L("Expected result %d, got %d"), reason, err);

 		}

 	CleanupStack::PopAndDestroy(2,contentInfo);//p7, contentInfo

 	__UHEAP_MARKEND;

 	return TestStepResult();

 	}

 //DigestInfoCorrupt

 //Step 9

 TVerdict CTPKCS7DigestInfoCorruptTest::doTestStepL()

 	{

 	if (TestStepResult() != EPass)

 		{

 		return TestStepResult();

 		}

     __UHEAP_MARK;

 	TInt reason;

 	GetIntFromConfig(ConfigSection(),_L("Reason"),reason);

 	CPKCS7DigestInfo* p7 = NULL;

 	TRAPD (err, p7 = CPKCS7DigestInfo::NewL(iRawData->Des()));

 	delete p7;

 	if (err != reason)

 		{

 		SetTestStepResult(EFail);

 		INFO_PRINTF3(_L("Expected result %d, got %d"), reason, err);

 		}

 	__UHEAP_MARKEND;

 	return TestStepResult();

 	}