diff -r 000000000000 -r 2c201484c85f cryptoservices/certificateandkeymgmt/tpkcs7/tpkcs7step.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoservices/certificateandkeymgmt/tpkcs7/tpkcs7step.cpp	Wed Jul 08 11:25:26 2009 +0100
@@ -0,0 +1,969 @@
+/*
+* 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 <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();
+	}