/*

* 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 <test/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);

			}			

		}