/*
* Copyright (c) 2006-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 "tcmsstep.h"
#include <testexecutelog.h>
#include <asnpkcs.h>
#include <pkcs7signedobject.h>
#include <asn1enc.h>
#include <cmssignedobject.h>
#include <cmsdefs.h>
#include <hash.h>
#include <asymmetric.h>
#include <cmssigneridentifier.h>
#include <x509certext.h>
#include <pkixcertchain.h>
#include <cmscontentinfo.h>
#include "validate.h"


CTCmsBaseStep::CTCmsBaseStep()
	{
	}

CTCmsBaseStep::~CTCmsBaseStep()
	{
	iFs.Close ();
	delete iDataContent;
	delete iExpectedEncoding;
	__UHEAP_MARKEND;
	}

TVerdict CTCmsBaseStep::doTestStepPreambleL()
	{
	__UHEAP_MARK;	
	User::LeaveIfError (iFs.Connect());	
	
	//Read the data to be signed
	iDataContent = readFileL(_L("Data"));
	
	if (iDataContent == NULL)
		{
		iDataContent=KNullDesC8().AllocL();
		}
	
	//Read the expected data type
	TPtrC contentDataType;
	if (GetStringFromConfig(ConfigSection(), _L("ExpectedDataType"), contentDataType))
		{
		iExpectedDataType=CovertContentDataTypeNameToDataType(contentDataType);			
		}

	//Read the expected result
	iExpectedEncoding = readFileL(_L("Result"));
	if (!iExpectedEncoding)
		{
		INFO_PRINTF1(_L("Failed to read 'Result' section of script"));
		SetTestStepResult(ETestSuiteError);			
		}

	GetIntFromConfig(ConfigSection(), _L("ExpectedResult"), iExpectedResult);	
	GetBoolFromConfig(ConfigSection(), _L("IsOOMTest"), iIsOOMTest);
	return TestStepResult();	
	}

TInt CTCmsBaseStep::CovertContentDataTypeNameToDataType(const TDesC& aDataTypeName)
	{
	if (aDataTypeName.Compare(_L("DATA"))==0)
		{
		return EContentTypeData;	
		}
	else	if (aDataTypeName.Compare(_L("SIGNEDDATA"))==0)
				{
				return EContentTypeSignedData;
				}
		 else	if (aDataTypeName.Compare(_L("ENVELOPEDDATA"))==0)
					 {
					 return EContentTypeEnvelopedData;	
					 }
			  else	if (aDataTypeName.Compare(_L("DIGESTEDDATA"))==0)
						{
						return EContentTypeDigestedData;
						}
					else 	if (aDataTypeName.Compare(_L("ENCRYPTEDDATA"))==0)
								{
								return EContentTypeEncryptedData;
								}
							else 	if (aDataTypeName.Compare(_L("SIGNEDANDENVELOPEDDATA"))==0)
										{
										return CPKCS7ContentInfo::EContentTypeSignedAndEnvelopedData;	
										}
									else	if (aDataTypeName.Compare(_L("AUTHDATA"))==0)
												{
												return EContentTypeAuthenticatedData;	
												}
											else
												{
												User::Leave(KErrArgument);
												return EContentTypeData;
												}
	}

HBufC8* CTCmsBaseStep::readFileL (TPtrC tag)
	{
	TPtrC fileName;
	if (GetStringFromConfig(ConfigSection(), tag, fileName) == EFalse)
		{
		return NULL;
		}

	RFile file;
	if (file.Open(iFs, fileName, EFileRead) != KErrNone)
		{
		INFO_PRINTF2(_L("Cannot open file %S for reading"), &fileName);
		return NULL;
		}
	CleanupClosePushL(file);
	TInt fileSize = 0;
	User::LeaveIfError(file.Size(fileSize));
	HBufC8* result = HBufC8::NewMaxL(fileSize);
	TPtr8 rawDataPtr(result->Des());
	file.Read (rawDataPtr);
	CleanupStack::PopAndDestroy (&file);
	INFO_PRINTF3(_L("Read %d octets from %S"), result->Size(), &fileName);
	return result;
	}

void CTCmsBaseStep::OutputResultToFileL(const TDesC8& aSignature)
	{
	TDriveUnit sysDrive (RFs::GetSystemDrive());
	TBuf<128> rName (sysDrive.Name());;
	rName.Append(_L("\\tpkcs7\\myresults\\"));
			
	TInt err=iFs.MkDir(rName);
	if (err!=KErrNone && err!=KErrAlreadyExists)
		{
		User::Leave(err);	
		}
				
	RFile file;
	CleanupClosePushL(file);
	
	_LIT(KExtension, ".der");
	rName.Append(ConfigSection());
	rName.Append(KExtension);
	rName.LowerCase();
	User::LeaveIfError(file.Replace(iFs, rName, EFileWrite | EFileStream));
	User::LeaveIfError(file.Write(aSignature));
	CleanupStack::PopAndDestroy(&file);
	}


HBufC8* CTCmsBaseStep::CreateDEREncodingLC(const CASN1EncBase& aEncoding)
	{	
	TUint len = aEncoding.LengthDER();
	HBufC8* buf = HBufC8::NewMaxLC(len);
	TUint pos = 0;
	TPtr8 bufptr(buf->Des());
	aEncoding.WriteDERL(bufptr, pos);
	return buf;
	}

TVerdict CTCmsBaseStep::doTestStepL()
	{
	if (!iIsOOMTest)
		{
		TRAPD(err, doTestL();)
		if (err!=iExpectedResult)
			{
			SetTestStepResult(EFail);
			User::Leave(err);
			}
		return TestStepResult();
		}
	else
		{
		return doOOMTestL();	
		}	
	}

TVerdict CTCmsBaseStep::doOOMTestL()
	{
	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, doTestL());
 		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(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);
 	if (verdict==EFail)
	 	{
 		User::Leave(KErrGeneral);	 		
	 	}	 	
 	return verdict;
	}


//
// Implementation of CMS Data Test Step
//
CTCmsDataStep::CTCmsDataStep()
	{
	}

CTCmsDataStep::~CTCmsDataStep()
	{
	}

	
void CTCmsDataStep::doTestL()
	{
	__UHEAP_MARK;
	CCmsContentInfo* content=CCmsContentInfo::NewL(EContentTypeData, *iDataContent);
	CleanupStack::PushL(content);
	CASN1EncSequence* contentSeq=content->EncodeASN1DERLC();
	HBufC8* signature=CreateDEREncodingLC(*contentSeq);
	CleanupStack::Pop(signature);
	CleanupStack::PopAndDestroy(2, content);
	CleanupStack::PushL(signature);
	//OutputResultToFileL(signature->Des());

	TBool r=signature->Compare(*iExpectedEncoding);
	if (r!=0 && !iIsOOMTest)
		{
		INFO_PRINTF1(_L("CMS Data Type Encoding Error"));
		User::Leave(KErrGeneral);
		}
	else
		{
		DecodingAndCheckL(*iExpectedEncoding);
		}

	CleanupStack::PopAndDestroy(signature);	
	}
void CTCmsDataStep::DecodingAndCheckL(TDesC8& aRawData)
	{
	INFO_PRINTF1(_L("Start CMS Data Type Decoding"));
	CCmsContentInfo* content=CCmsContentInfo::NewL(aRawData);
	CleanupStack::PushL(content);
	if (content->ContentType()!=EContentTypeData)
		{
		INFO_PRINTF1(_L("CMS Data Type is not as expected"));
		User::Leave(KErrGeneral);
		}
	else
		{
		if (content->ContentData()!=iDataContent->Des())
			{
			INFO_PRINTF1(_L("CMS Data Content is not as expected"));
			User::Leave(KErrGeneral);					
			}
		}
	CleanupStack::PopAndDestroy(content);		
	}
//
// Implementation of CMS Data Test Step
//
CTCmsDataDecodingStep::CTCmsDataDecodingStep()
	{
	}

CTCmsDataDecodingStep::~CTCmsDataDecodingStep()
	{
	}

void CTCmsDataDecodingStep::doTestL()
	{
	DecodingAndCheckL(*iExpectedEncoding);	
	}


//
// Implementation of Signed Data Test Base Step
//
CTSignedDataBaseStep::CTSignedDataBaseStep() : iContentType(EContentTypeData), iRsaAlgorithm(ETrue) 
	{
	}

CTSignedDataBaseStep::~CTSignedDataBaseStep()
	{
	iDecPKCS8Data.ResetAndDestroy();
	iCertificates.ResetAndDestroy();
	iSignerInfoVersion.Close();
	iHashName.Close();
	iValidateResults.Close();
	iSignedAttributePresent.Close();
	iUnSignedAttributePresent.Close();
	delete iRootCertificate;
	delete iAdditionalCertificate;
	delete iAdditionalEncodedCertificate;
	}


TInt CTSignedDataBaseStep::CovertHashNameToAlgorithmId(const TDesC& aHashName)
	{
	if (aHashName.Compare(_L("SHA1"))==0)
		{
		return ESHA1;	
		}
	else if (aHashName.Compare(_L("MD5"))==0)
			{
			return EMD5;
			}
		 else
			 {
			 return EMD2;	
			 }
	}

TInt CTSignedDataBaseStep::CovertCertificateNameToCertificateType(const TDesC& aCertificateName)
	{
	if (aCertificateName.Compare(_L("X509"))==0)
		{
		return CCmsCertificateChoice::ECertificateX509;	
		}
	else if (aCertificateName.Compare(_L("Attribute"))==0)
			{
			return CCmsCertificateChoice::ECertificateAttribute;
			}
		 else
			 {
			 return CCmsCertificateChoice::ECertificateExtendedCerificate;	
			 }
	}


TVerdict CTSignedDataBaseStep::doTestStepPreambleL()
	{
	if (CTCmsBaseStep::doTestStepPreambleL()==EFail)
		{
		SetTestStepResult(EFail);
		}
	else
		{
		//Read the configurations
		GetBoolFromConfig(ConfigSection(), _L("HashAvailable"), iIsHashAvailable);
		GetBoolFromConfig(ConfigSection(), _L("DataDetached"), iIsDetached);
		GetBoolFromConfig(ConfigSection(), _L("CertificateSetPresent"), iCertificateSetPresent);
		GetBoolFromConfig(ConfigSection(), _L("CRLsSetPresent"), iCRLsSetPresent);
		GetIntFromConfig(ConfigSection(), _L("SignedDataVersion"), iSignedDataVersion);
		GetIntFromConfig(ConfigSection(), _L("AlgorithmCount"), iAlgorithmCount);
		GetIntFromConfig(ConfigSection(), _L("CertsCount"), iCertsCount);
		GetIntFromConfig(ConfigSection(), _L("SignerCount"), iSignerCount);
		GetBoolFromConfig(ConfigSection(), _L("NoCertSet"), iNoCertSet);
		GetBoolFromConfig(ConfigSection(), _L("ValidateUsingUserCerts"), iValidateUsingUserCerts);
		GetBoolFromConfig(ConfigSection(), _L("NoSigning"), iNoSigning);
		GetBoolFromConfig(ConfigSection(), _L("NoValidationTest"), iNoValidationTest);
		GetBoolFromConfig(ConfigSection(), _L("TwoStepCreation"), iTwoStepCreation);
		GetBoolFromConfig(ConfigSection(), _L("ValidationDetachedWithoutInput"), iValidationDetachedWithoutInput);
		

		HBufC8* certificate = readFileL(_L("RootCertificate"));
		if (certificate)
			{
			CleanupStack::PushL(certificate);
			iRootCertificate = CX509Certificate::NewL(*certificate);
			CleanupStack::PopAndDestroy (certificate);
			}

		certificate = readFileL(_L("AddtionalCertificate"));
		if (certificate)
			{
			CleanupStack::PushL(certificate);
			iAdditionalCertificate = CX509Certificate::NewL(*certificate);
			CleanupStack::PopAndDestroy (certificate);			
			}
		TPtrC certTypeName;
		if (GetStringFromConfig(ConfigSection(), _L("AdditionalEncodedCertificateType"), certTypeName))
			{
			iAdditionalEncodedCertificateType=CovertCertificateNameToCertificateType(certTypeName);
			iAdditionalEncodedCertificate=readFileL (_L("AdditionalEncodedCertificate"));				
			}
					
		//Read the certificates, private keys and hash algorithm
		TInt index(0);
		
		TName fKeyName;
		fKeyName.Format(_L("PrivateKey_%d"), index);
		
		TName fCertName;
		fCertName.Format(_L("Certificate_%d"), index);
		
		TName fHashAlgorithmName;
		fHashAlgorithmName.Format(_L("HashAlgorithm_%d"), index);

		TName fValidationResult;
		fValidationResult.Format(_L("ValidationResult_%d"), index);
		
		TName fSignedAttributePresent;
		fSignedAttributePresent.Format(_L("SignedAttributePresent_%d"), index);
		
		TName fUnSignedAttributePresent;
		fUnSignedAttributePresent.Format(_L("UnSignedAttributePresent_%d"), index);

		TName fSignerInfoVersion;
		fSignerInfoVersion.Format(_L("SignerInfoVersion_%d"), index);

		TPtrC hashName;
		TBool vResult(EFalse);
		TBool sAP(EFalse);
		TBool uSAP(EFalse);
		TInt signerInfoVersion;
		TPtrC keyName;
		TPtrC certName;
		
		while ( GetStringFromConfig(ConfigSection(), fKeyName, keyName)
				&& GetStringFromConfig(ConfigSection(), fCertName, certName)
				&& GetStringFromConfig(ConfigSection(), fHashAlgorithmName, hashName)
				&& GetBoolFromConfig(ConfigSection(), fValidationResult, vResult)
				&& GetBoolFromConfig(ConfigSection(), fSignedAttributePresent, sAP)
				&& GetBoolFromConfig(ConfigSection(), fUnSignedAttributePresent, uSAP)
				&& GetIntFromConfig(ConfigSection(), fSignerInfoVersion, signerInfoVersion) )
			{
			//Construct private keys
			HBufC8* privateKey(NULL);
			if ((privateKey=readFileL(fKeyName))!=NULL)
				{
				CleanupStack::PushL (privateKey);
				CDecPKCS8Data* pkcs8Data=TASN1DecPKCS8::DecodeDERL(privateKey->Des());
				CleanupStack::PushL (pkcs8Data);
				iDecPKCS8Data.AppendL(pkcs8Data);
				CleanupStack::Pop(pkcs8Data);
				CleanupStack::PopAndDestroy(privateKey);	
				}
			
			//Construct X509 certificate
			HBufC8* cert(NULL);
			if ((cert=readFileL(fCertName))!=NULL)
				{
				CleanupStack::PushL (cert);
				CX509Certificate* x509cert=CX509Certificate::NewLC(cert->Des());		
				iCertificates.AppendL(x509cert);
				CleanupStack::Pop(x509cert);
				CleanupStack::PopAndDestroy(cert);				
				}
				
			TInt hashId=CovertHashNameToAlgorithmId(hashName);		
			iHashName.AppendL(hashId);
					
			iValidateResults.AppendL(vResult);
			iSignedAttributePresent.AppendL(sAP);
			iUnSignedAttributePresent.AppendL(uSAP);
			iSignerInfoVersion.AppendL(signerInfoVersion);
			
			//for next pair
			index++;
			fKeyName.Format(_L("PrivateKey_%d"), index);
			fCertName.Format(_L("Certificate_%d"), index);
			fHashAlgorithmName.Format(_L("HashAlgorithm_%d"), index);
			fValidationResult.Format(_L("ValidationResult_%d"), index);
			fSignedAttributePresent.Format(_L("SignedAttributePresent_%d"), index);
			fUnSignedAttributePresent.Format(_L("UnSignedAttributePresent_%d"), index);
			fSignerInfoVersion.Format(_L("SignerInfoVersion_%d"), index);
			}			
		}
	return TestStepResult();
	}

CMessageDigest* CTSignedDataBaseStep::CreateHashLC(TAlgorithmId aAlgorithmId)
	{
	CMessageDigest* hash(NULL);
	switch (aAlgorithmId)
		{
	case EMD2:
		hash=CMD2::NewL();
		break;
		
	case EMD5:
		hash=CMD5::NewL();
		break;
		
	case ESHA1:
		hash=CSHA1::NewL();
		break;
		
	default:
		User::Leave(KErrNotSupported);
		}
	CleanupStack::PushL(hash);
	return hash;		
	}


//
// Implementation of CMS Signed Data Test Step
//
CTCmsSignedDataStep::CTCmsSignedDataStep()
	{
	}

CTCmsSignedDataStep::~CTCmsSignedDataStep()
	{
	}


void CTCmsSignedDataStep::CheckAndValidateSignedDataL(TDesC8& aRawData)
	{
	//Decode the content info encoding read from predefined file	
	CCmsContentInfo* content=CCmsContentInfo::NewL(aRawData);
	CleanupStack::PushL(content);
	if (content->ContentType()!=EContentTypeSignedData)
		{
		INFO_PRINTF1(_L("Content Type is not Signed Data"));
		User::Leave(KErrGeneral);
		}
	else
		{
		//Decode the signed data and check the fields
		CCmsSignedObject* signedData=CCmsSignedObject::NewL(*content);
		CleanupStack::PushL(signedData);	
		CheckSignedDataFieldsL(*signedData);
		
		//Validate the signatures
		const RPointerArray<CCmsSignerInfo>& signerInfos=signedData->SignerInfo();
		CheckSignerInfoFieldsL(signerInfos);
		
		if (!iNoValidationTest)
			{
			TInt count=signerInfos.Count();
			for (TInt i=0;i<count;i++)
				{
				HBufC8* certificateEncoding = NULL;
				
				CMessageDigest* hash(NULL);
				if (iIsHashAvailable)
					{
					hash=CreateHashLC((TAlgorithmId)iHashName[i]);
					}
					
				TBool isValid(EFalse);
				if (iValidateUsingUserCerts)
					{
					INFO_PRINTF1(_L("Test validation by using given certificates"));
					if (iIsHashAvailable)
						{
						isValid = signedData->ValidateSignerLC(*signerInfos[i], iCertificates, certificateEncoding, ETrue, hash->Hash(iDataContent->Des()));
						}
					else 
						{
						if (iIsDetached)
							{
							if (!iValidationDetachedWithoutInput)
								{
								isValid = signedData->ValidateSignerLC(*signerInfos[i], iCertificates, certificateEncoding, EFalse, iDataContent->Des());
								}
							else
								{
								isValid = signedData->ValidateSignerLC(*signerInfos[i], iCertificates, certificateEncoding);	
								}							
							}
						else
							{
							isValid = signedData->ValidateSignerLC(*signerInfos[i], iCertificates, certificateEncoding);	
							}
						}					
					}
				else
					{
					INFO_PRINTF1(_L("Test validation by using the embedded certificates"));
					
					if (iIsHashAvailable)
						{
						isValid = signedData->ValidateSignerLC(*signerInfos[i], certificateEncoding, ETrue, hash->Hash(iDataContent->Des()));
						}
					else 
						{
						if (iIsDetached)
							{
							if (!iValidationDetachedWithoutInput)
								{
								isValid = signedData->ValidateSignerLC(*signerInfos[i], certificateEncoding, EFalse, iDataContent->Des());	
								}
							else
								{
								isValid = signedData->ValidateSignerLC(*signerInfos[i], certificateEncoding);	
								}
							}
						else
							{
							isValid = signedData->ValidateSignerLC(*signerInfos[i], certificateEncoding);	
							}
						}					
					}
									
				if (!isValid)
					{
					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);
						CActiveScheduler::Install (sched);
						}
					RPointerArray<CX509Certificate> roots (&iRootCertificate, 1);
					CPKIXCertChain * chain = CPKIXCertChain::NewLC(iFs, *certificateEncoding, roots);
					
					TTime tm;
					_LIT(KDateCorrect1,"20061128:"); 
					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);
					validator->doValidate ();
					sched->Start ();
					if (result->Error().iReason == EValidatedOK)
						{
						isValid = ETrue;
						INFO_PRINTF1(_L("Validation success"));
						}
					else
						{
						isValid = EFalse;
						INFO_PRINTF2(_L("Validation failed: %d"), result->Error().iReason);
						}
	        		delete validator;
					CleanupStack::PopAndDestroy(result);
					CleanupStack::PopAndDestroy(chain);
					if (sched)
						{
						CActiveScheduler::Install (NULL);
						CleanupStack::PopAndDestroy (sched);
						}
					}
				
				CleanupStack::PopAndDestroy(certificateEncoding);				
				if (hash)
					{
					CleanupStack::PopAndDestroy(hash);	
					}				
				
				if (isValid!=iValidateResults[i])
					{
					INFO_PRINTF1(_L("validate result not as expected"));
					User::Leave(KErrGeneral);
					}
				}			
			}
		CleanupStack::PopAndDestroy(signedData);
		}
	CleanupStack::PopAndDestroy(content);						
	}

void CTCmsSignedDataStep::CheckEncapsulatedContentFieldsL(const CEncapsulatedContentInfo& aEncapContentInfo)
	{
	if (aEncapContentInfo.ContentType()!=EContentTypeData)
		{
		INFO_PRINTF1(_L("Encapsulated data Content is not data content type"));
		User::Leave(KErrGeneral);
		}
	else
		{
		if (aEncapContentInfo.IsContentDataPresent() == iIsDetached)
			{
			INFO_PRINTF1(_L("Encapsulated data Content attachment not as expected"));
			User::Leave(KErrGeneral);
			}
		else
			{
			if (aEncapContentInfo.IsContentDataPresent() && aEncapContentInfo.ContentData()!=*iDataContent)
				{
				INFO_PRINTF1(_L("Encapsulated data Content not as expected"));
				User::Leave(KErrGeneral);
				}
			}
		}		
	}

void CTCmsSignedDataStep::CheckAlgorithmSetFieldsL(const RPointerArray<CX509AlgorithmIdentifier>& aAlgorithms)
	{
	if (iAlgorithmCount!=aAlgorithms.Count())
		{
		INFO_PRINTF1(_L("Number of Algorithm ID is not as expected"));
		User::Leave(KErrGeneral);
		}
	}

void CTCmsSignedDataStep::CheckCertificateSetFieldsL(const CCmsSignedObject& aSignedData)
	{
	if (aSignedData.IsCertificateSetPresent())
		{
		const RPointerArray<CCmsCertificateChoice>& certSet=aSignedData.Certificates();
		if (iCertsCount!=certSet.Count())
			{
			INFO_PRINTF1(_L("Number of Certificates is not as expected"));
			User::Leave(KErrGeneral);
			}
		else
			{
			//Signer Certificate is in the Signed data
			if (!iNoCertSet)
				{
				TInt count = iCertificates.Count();
				for (TInt i=0;i<count;i++)
					{
					if (certSet[i]->CertificateType()==CCmsCertificateChoice::ECertificateX509 && !iCertificates[i]->IsEqualL(certSet[i]->Certificate()))
						{
						INFO_PRINTF2(_L("X509 Certificates %d is not as expected"), i);
						User::Leave(KErrGeneral);						
						}
					}
				}
			
			if (iAdditionalCertificate || iAdditionalEncodedCertificate)
				{
				if (certSet[iCertsCount-1]->CertificateType()==CCmsCertificateChoice::ECertificateAttribute && 
						certSet[iCertsCount-1]->AttributeCertificate()->Compare(*iAdditionalEncodedCertificate)!=0)
					{
					INFO_PRINTF1(_L("Additional Attribute Certificates is not as expected"));
					User::Leave(KErrGeneral);						
					}
				else if (certSet[iCertsCount-1]->CertificateType()==CCmsCertificateChoice::ECertificateX509)
						{
						if (iAdditionalCertificate && !certSet[iCertsCount-1]->Certificate().IsEqualL(*iAdditionalCertificate))
							{
							INFO_PRINTF1(_L("Additional X509 Certificates is not as expected"));
							User::Leave(KErrGeneral);																					
							}
						else
							{
							if (iAdditionalEncodedCertificate)
								{
								CX509Certificate* addX509Cert=CX509Certificate::NewLC(*iAdditionalEncodedCertificate);
								if (!certSet[iCertsCount-1]->Certificate().IsEqualL(*addX509Cert))
									{
									INFO_PRINTF1(_L("Additional X509 Certificates is not as expected"));
									User::Leave(KErrGeneral);										
									}
								CleanupStack::PopAndDestroy(addX509Cert);
								}
							}
						}
				}
			}
		}
	}

void CTCmsSignedDataStep::CheckSignerInfoFieldsL(const RPointerArray<CCmsSignerInfo>& signerInfos)
	{
	TInt count=signerInfos.Count();
	if (iDecPKCS8Data.Count()!=count && iSignerCount!=count)
		{
		INFO_PRINTF1(_L("Number of Signer Info is not as expected"));
		User::Leave(KErrGeneral);
		}
	for (TInt i=0;i<count;i++)
		{
		if (signerInfos[i]->IsSignedAttributesPresent()!=iSignedAttributePresent[i]
			|| signerInfos[i]->IsUnsignedAttributesPresent()!=iUnSignedAttributePresent[i]
			|| signerInfos[i]->Version()!=iSignerInfoVersion[i])
			{
			INFO_PRINTF1(_L("Signed or Unsigned Attribute presence or Signer Version is not as expected"));
			User::Leave(KErrGeneral);
			}
			
		const CX509AlgorithmIdentifier& digestId=signerInfos[i]->DigestAlgorithm();
		if (digestId.Algorithm()!=(TAlgorithmId)iHashName[i])
			{
			INFO_PRINTF1(_L("Digest Algorithm ID is not as expected"));
			User::Leave(KErrGeneral);
			}
			
		const CX509AlgorithmIdentifier& sigId=signerInfos[i]->SignatureAlgorithm();
		if (iDecPKCS8Data[i]->Algorithm()!=sigId.Algorithm())
			{
			INFO_PRINTF1(_L("Signature Algorithm ID is not as expected"));
			User::Leave(KErrGeneral);
			}
			
		const CCmsSignerIdentifier& signerId=signerInfos[i]->SignerIdentifier();
		if (signerId.SignerIdentifierType()==CCmsSignerIdentifier::EIssuerAndSerialNumber)
			{
			if (!iCertificates[i]->IssuerName().ExactMatchL(signerId.IssuerAndSerialNumber()->IssuerName()))
				{
				INFO_PRINTF1(_L("Issuer name is not as expected"));
				User::Leave(KErrGeneral);
				}
			else
				{
				RInteger sn1=RInteger::NewL(iCertificates[i]->SerialNumber());
				CleanupClosePushL(sn1);
				RInteger sn2=RInteger::NewL(signerId.IssuerAndSerialNumber()->SerialNumber());
				CleanupClosePushL(sn2);
				if (sn1!=sn2)
					{
					INFO_PRINTF1(_L("Serial number is not as expected"));
					User::Leave(KErrGeneral);					
					}
				CleanupStack::PopAndDestroy(2, &sn1);//sn2, sn1
					
				}
			}
		else if (signerId.SignerIdentifierType()==CCmsSignerIdentifier::ESubjectKeyIdentifier)
				{
				const CX509CertExtension* certExt = iCertificates[i]->Extension(KSubjectKeyId);
				if (certExt)
					{
					CX509SubjectKeyIdExt* ext=CX509SubjectKeyIdExt::NewLC(certExt->Data());
					if (signerId.SubjectKeyIdentifier().Compare(ext->KeyId())!=0)
						{
						INFO_PRINTF1(_L("Subject Key Id is not as expected"));
						User::Leave(KErrGeneral);
						}
					CleanupStack::PopAndDestroy(ext);
					}
				}
		}
	}

void CTCmsSignedDataStep::CheckSignedDataFieldsL(const CCmsSignedObject& aSignedData)
	{		
	if (aSignedData.IsCertificateSetPresent()!=iCertificateSetPresent ||
		aSignedData.IsCertificateRevocationListsPresent()!=iCRLsSetPresent ||
		aSignedData.Version()!=iSignedDataVersion)
		{
		INFO_PRINTF1(_L("cert present or CRL present or version not as expected"));
		User::Leave(KErrGeneral);
		}
	else
		{
		const CEncapsulatedContentInfo& encapContentInfo=aSignedData.ContentInfo();
		CheckEncapsulatedContentFieldsL(encapContentInfo);
		const RPointerArray<CX509AlgorithmIdentifier>& algorithms=aSignedData.DigestAlgorithms();
		CheckAlgorithmSetFieldsL(algorithms);
		CheckCertificateSetFieldsL(aSignedData);
		}
	}

void CTCmsSignedDataStep::doTestL()
	{
	__UHEAP_MARK;
	
	CCmsSignedObject* signedData(NULL);
	TInt count=iDecPKCS8Data.Count();
	
	//Create Signed Object
	for (TInt i=0;i<count;i++)
		{
		//Get the key pair
		CDecPKCS8Data* decPKCS8Data=iDecPKCS8Data[i];
		MPKCS8DecodedKeyPairData* keyPair = decPKCS8Data->KeyPairData();
		
		CMessageDigest* hash(NULL);
		TPtrC8 hashValue;
		if (iIsHashAvailable)
			{
			hash=CreateHashLC((TAlgorithmId)iHashName[i]);
			hashValue.Set(hash->Hash(iDataContent->Des()));
			}
		
		//If it is the first time, a signed object needs to be created
		if (i==0)
			{
			if (iIsHashAvailable)
				{
				if (decPKCS8Data->Algorithm()==ERSA)
					{
					const CRSAPrivateKey& RSAPrivateKey=static_cast<CPKCS8KeyPairRSA*>(keyPair)->PrivateKey();
					if (!iTwoStepCreation)
						{
						signedData=CCmsSignedObject::NewL((TCmsContentInfoType)iContentType,
															hashValue,
															(TAlgorithmId)iHashName[i],
															RSAPrivateKey,
															*iCertificates[i],
															!iNoCertSet);
						CleanupStack::PushL(signedData);																
						}
					else
						{
						signedData=CCmsSignedObject::NewL((TCmsContentInfoType)iContentType, iIsDetached, iDataContent->Des());
						CleanupStack::PushL(signedData);
						signedData->SignL(hashValue, (TAlgorithmId)iHashName[i], RSAPrivateKey, *iCertificates[i], !iNoCertSet);
						}
					}
				else
					{
					const CDSAPrivateKey& DSAPrivateKey=static_cast<CPKCS8KeyPairDSA*>(keyPair)->PrivateKey();
					if (!iTwoStepCreation)
						{
						signedData=CCmsSignedObject::NewL((TCmsContentInfoType)iContentType,
															hashValue,
															(TAlgorithmId)iHashName[i],
															DSAPrivateKey,
															*iCertificates[i],
															!iNoCertSet);
						CleanupStack::PushL(signedData);																	
						}
					else
						{
						signedData=CCmsSignedObject::NewL((TCmsContentInfoType)iContentType, iIsDetached, iDataContent->Des());
						CleanupStack::PushL(signedData);
						signedData->SignL(hashValue, (TAlgorithmId)iHashName[i], DSAPrivateKey, *iCertificates[i], !iNoCertSet);
						}
					iRsaAlgorithm=EFalse;			
					}
				CleanupStack::Pop(signedData);	
				CleanupStack::PopAndDestroy(hash);
				CleanupStack::PushL(signedData);
				}		
			else
				{
				signedData=CCmsSignedObject::NewL((TCmsContentInfoType)iContentType, iIsDetached, iDataContent->Des());
				CleanupStack::PushL(signedData);
				if (!iNoSigning)
					{
					if (decPKCS8Data->Algorithm()==ERSA)
						{
						const CRSAPrivateKey& RSAPrivateKey=static_cast<CPKCS8KeyPairRSA*>(keyPair)->PrivateKey();
						signedData->SignL(KNullDesC8, (TAlgorithmId)iHashName[i], RSAPrivateKey, *iCertificates[i], !iNoCertSet);
						}
					else
						{
						const CDSAPrivateKey& DSAPrivateKey=static_cast<CPKCS8KeyPairDSA*>(keyPair)->PrivateKey();
						signedData->SignL(KNullDesC8, (TAlgorithmId)iHashName[i], DSAPrivateKey, *iCertificates[i], !iNoCertSet);
						iRsaAlgorithm=EFalse;
						}												
					}
				}
			}
		else
			{
			//multiple signatures
			if (iIsHashAvailable)
				{
				if (decPKCS8Data->Algorithm()==ERSA)
					{
					const CRSAPrivateKey& RSAPrivateKey=static_cast<CPKCS8KeyPairRSA*>(keyPair)->PrivateKey();
					signedData->SignL(hashValue, (TAlgorithmId)iHashName[i], RSAPrivateKey, *iCertificates[i], !iNoCertSet);
					}
				else
					{
					const CDSAPrivateKey& DSAPrivateKey=static_cast<CPKCS8KeyPairDSA*>(keyPair)->PrivateKey();
					signedData->SignL(hashValue, (TAlgorithmId)iHashName[i], DSAPrivateKey, *iCertificates[i], !iNoCertSet);
					iRsaAlgorithm=EFalse;
					}
				CleanupStack::PopAndDestroy(hash);	
				}
			else
				{
				if (decPKCS8Data->Algorithm()==ERSA)
					{
					const CRSAPrivateKey& RSAPrivateKey=static_cast<CPKCS8KeyPairRSA*>(keyPair)->PrivateKey();
					signedData->SignL(KNullDesC8, (TAlgorithmId)iHashName[i], RSAPrivateKey, *iCertificates[i], !iNoCertSet);
					}
				else
					{
					const CDSAPrivateKey& DSAPrivateKey=static_cast<CPKCS8KeyPairDSA*>(keyPair)->PrivateKey();
					signedData->SignL(KNullDesC8, (TAlgorithmId)iHashName[i], DSAPrivateKey, *iCertificates[i], !iNoCertSet);
					iRsaAlgorithm=EFalse;
					}						
				}
			}	
		}
	
	if (iAdditionalCertificate)
		{
		signedData->AddCertificateL(*iAdditionalCertificate);	
		}

 	if (iAdditionalEncodedCertificate)
 		{
 		signedData->AddCertificateL(*iAdditionalEncodedCertificate, (CCmsCertificateChoice::TCertificateType)iAdditionalEncodedCertificateType);
 		}
		
	//Encoding the Signed object
	CASN1EncSequence* signedObjectSeq=signedData->EncodeASN1DERLC();
	HBufC8* buf=CreateDEREncodingLC(*signedObjectSeq);

	//Encoding the wrapper Content Info
	CCmsContentInfo* content=CCmsContentInfo::NewL(EContentTypeSignedData, *buf);
	CleanupStack::PushL(content);
	CASN1EncSequence* contentSeq=content->EncodeASN1DERLC();
	HBufC8* signature=CreateDEREncodingLC(*contentSeq);
	CleanupStack::Pop(signature);
	CleanupStack::PopAndDestroy(5, signedData);	//contentSeq,content,buf,signedObjectSeq,signedData
	CleanupStack::PushL(signature);


	//write the result to a file, for initial debuging
	//OutputResultToFileL(signature->Des());
	
	//Compare the result with the expected result, if the signature algorithms are RSA
		
	if (iRsaAlgorithm)
		{
		
		//Check if the signature is the same as expected
		TBool r=signature->Compare(*iExpectedEncoding);
		if (r!=0 && !iIsOOMTest)
			{
			INFO_PRINTF1(_L("RSA Signature Encoding Error"));
			User::Leave(KErrGeneral);
			}
		else
			{
			CheckAndValidateSignedDataL(*iExpectedEncoding);
			}
		}
	else	
		{
		CheckAndValidateSignedDataL(*iExpectedEncoding);
		CheckAndValidateSignedDataL(*signature);		
		}	
			
	CleanupStack::PopAndDestroy(signature);
	__UHEAP_MARKEND;
	}

//
// Implementation of CMS Signed Data Decoding Test Step
//

CTCmsSignedDataDecodingStep::CTCmsSignedDataDecodingStep()
	{
	}

CTCmsSignedDataDecodingStep::~CTCmsSignedDataDecodingStep()
	{
	}

void CTCmsSignedDataDecodingStep::doTestL()
	{
	__UHEAP_MARK;
	CheckAndValidateSignedDataL(*iExpectedEncoding);
	__UHEAP_MARKEND;
	}

//
// Implementation of CMS Content Info Test step
//
CTCmsContentInfoDecodingStep::CTCmsContentInfoDecodingStep()
	{	
	}

CTCmsContentInfoDecodingStep::~CTCmsContentInfoDecodingStep()
	{	
	}
	
void CTCmsContentInfoDecodingStep::doTestL()
	{
	INFO_PRINTF1(_L("Start CMS Data Type Decoding"));
	CCmsContentInfo* content=CCmsContentInfo::NewL(*iExpectedEncoding);
	CleanupStack::PushL(content);
	if (content->ContentType()!=iExpectedDataType)
		{
		INFO_PRINTF1(_L("CMS Data Type is not as expected"));
		User::Leave(KErrGeneral);
		}
	CleanupStack::PopAndDestroy(content);		
	}
