/*

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

					{