/*

* Copyright (c) 1998-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 "CorruptionTest.h"

#include "SyntaxTest.h"

#include "wtlscert.h"

#include "t_output.h"

#include "t_input.h"

#include <random.h>

#include <asymmetric.h>

#include <bigint.h>

TInt CCorruptionTest::nInstances = 0;

_LIT(KCorruptLogFile, "X509CorruptLog.txt");

_LIT(KPathStart, "<path>");

_LIT(KIterationsStart, "<iterations>");

//////////////////////////////////////////////////////////////////////

// Construction/Destruction

//////////////////////////////////////////////////////////////////////

CTestAction* CCorruptionTest::NewL(RFs& aFs, CConsoleBase& aConsole, 

		Output& aOut, const TTestActionSpec& aTestActionSpec)

	{

	CTestAction* self = CCorruptionTest::NewLC(aFs, aConsole, aOut, aTestActionSpec);

	CleanupStack::Pop(self);

	return self;

	}

CTestAction* CCorruptionTest::NewLC(RFs& aFs, CConsoleBase& aConsole, 

		Output& aOut, const TTestActionSpec& aTestActionSpec)

	{

	CCorruptionTest* self = new(ELeave) CCorruptionTest(aFs, aConsole, aOut);

	CleanupStack::PushL(self);

	self->ConstructL(aTestActionSpec);

	return self;

	}

CCorruptionTest::CCorruptionTest(RFs& aFs, 

								 CConsoleBase& aConsole,

								 Output& aOut)

: CTestAction(aConsole, aOut), iFs(aFs)

	{

	nFileNumber = 0;

	}

CCorruptionTest::~CCorruptionTest(void)

	{

	delete iDirList;

	delete iWriter;

	iLogFile.Close();

	delete iNullOut;

	delete iCorruptOut;

	};

void CCorruptionTest::ConstructL(const TTestActionSpec& aTestActionSpec)

	{

	CTestAction::ConstructL(aTestActionSpec);

	if(nInstances==0)

		{

		HBufC* body = HBufC::NewLC(aTestActionSpec.iActionBody.Length());

		TInt pos=0;

		nInstances++;

		iNullOut = new(ELeave) NullOutput;

		body->Des().Copy(aTestActionSpec.iActionBody);

		TPtrC chainBuf = Input::ParseElement(*body, KPathStart, pos);

		iPath.Copy(chainBuf);

		TPtrC itertaionBuf = Input::ParseElement(*body, KIterationsStart, pos);

		TLex itLex(itertaionBuf);

		itLex.Val(iIterations);

		CleanupStack::PopAndDestroy(); // body

		User::LeaveIfError(iLogFile.Replace(iFs,KCorruptLogFile,EFileWrite));

		iCorruptOut = new(ELeave) FileOutput(iLogFile);

		iWriter = new(ELeave) CertWriter(iCorruptOut);

		}

	else

		{

		SetScriptError(ESyntax, _L("Only one corruption test can be run in each script"));

		iFinished = ETrue;

		}

	}

void CCorruptionTest::DoPerformPrerequisite(TRequestStatus& aStatus)

	{

	HBufC *searchPath = HBufC::NewLC(iPath.Size() + 1);

	TPtr searchPathPtr(searchPath->Des());

	searchPathPtr.Copy(iPath);

	searchPathPtr.Append(_L("*"));

    TInt err = iFs.GetDir(searchPathPtr, KEntryAttMaskSupported, ESortByName, iDirList);

	if (err != KErrNone)

		{

		iConsole.Printf(_L("Error getting directory "));

		iConsole.Printf(searchPathPtr);

		iConsole.Printf(_L("\n"));

		iOut.writeString(_L("Error getting directory "));

		iOut.writeString(searchPathPtr);

		iOut.writeNewLine();

		iFinished = ETrue;

		TRequestStatus* status = &aStatus;

		User::RequestComplete(status, KErrNone);

		SetScriptError(EFileNotFound, searchPathPtr);

		}

	else

		{

		iConsole.Printf(_L("Please view "));

		iConsole.Printf(KCorruptLogFile);

		iConsole.Printf(_L(" for results\n"));

		iOut.writeString(_L("Please view "));

		iOut.writeString(KCorruptLogFile);

		iOut.writeString(_L(" for results"));

		iOut.writeNewLine();

		iActionState = EAction;

		TRequestStatus* status = &aStatus;

		User::RequestComplete(status, KErrNone);

		iResult = ETrue;

		}

	CleanupStack::PopAndDestroy();

	}

void CCorruptionTest::DoPerformPostrequisite(TRequestStatus& aStatus)

	{

	TRequestStatus* status = &aStatus;

	iFinished = ETrue;

	User::RequestComplete(status, KErrNone);

	}

void CCorruptionTest::RunCorruptionTestL(const TDesC &aFilename)

	{

	__UHEAP_MARK;

	for (TInt i = 0; i < iIterations; i++)

		{

		HBufC8* buf = Input::ReadFileLC(aFilename, iPath, iFs);

		TPtr8 pBuf = buf->Des();

		TInt len = pBuf.Size();

		TInt pos = 0;

				//list of positions altered

		HBufC* posOctsBuf = HBufC::NewLC(70);

		TPtr pPosOctsBuf = posOctsBuf->Des();

		pPosOctsBuf.SetLength(0);

		pPosOctsBuf.Append(_L("p:"));

				//list of octets altered

		HBufC8* octsBuf = HBufC8::NewLC(40);

		TPtr8 pOctsBuf = octsBuf->Des();

		pOctsBuf.SetLength(0);

		for (TInt j = 0; j < 10; j++)

			{

				//randomness

			HBufC8* rand = HBufC8::NewLC(5);

			TPtr8 pRand = rand->Des();

			pRand.SetLength(5);

			TRandom::RandomL(pRand);

			TUint num = 0;

			for (TInt k = 0; k < 4 ; k++)

				{

				num<<=8;

				num+=pRand[k];

				}

			pos = num % len;

			TUint8 newOctet = pRand[4];

				//update output lines

			pPosOctsBuf.AppendNum(pos);

			pPosOctsBuf.Append(_L(" "));

			pOctsBuf.Append(pBuf.Mid(pos, 1));

			TPtrC8 pNewOct = pRand.Right(1);

			pOctsBuf.Append(pNewOct);

				//switch the selected octet

			pBuf[pos] = newOctet;

				//file out

			iCorruptOut->writeString(pPosOctsBuf);

			iCorruptOut->writeNewLine();

			iCorruptOut->writeString(_L("o:"));

			iCorruptOut->writeOctetString(pOctsBuf);

			iCorruptOut->writeNewLine();

				//try to make corrupt cert

			CX509Certificate* cert = NULL;

			TRAPD(err, cert = CX509Certificate::NewL(pBuf));

			CleanupStack::PushL(cert);

			if (err == KErrNone)

				{

				TBool res = EFalse;;

			//	Don't bother attempting to verify if public key modulus is even

			//	since CMontgomery methods will fail...	

				TKeyFactory* theKeyFactory = new (ELeave) TX509KeyFactory();

				CleanupStack::PushL(theKeyFactory);

				CRSAPublicKey* key = theKeyFactory->RSAPublicKeyL(cert->PublicKey().KeyData());

				CleanupStack::Pop(theKeyFactory);

				delete theKeyFactory;

				const TInteger& theN = key->N();

				if (theN.IsOdd())

					{

					RInteger input = RInteger::NewL(cert->Signature());

					CleanupStack::PushL(input);

				//	Check that the signature is not out of bounds for the key

				//	Otherwise the crypto library will panic (descriptor out of bounds)

					if ( (input < theN) && (input > 0) )

						{

						TRAP_IGNORE(res = cert->VerifySignatureL(cert->PublicKey().KeyData()));

						if (res)

							{

							iCorruptOut->writeString(_L("!!!"));

							iCorruptOut->writeNewLine();

							}

						}

						CleanupStack::PopAndDestroy(&input);

					}

					delete key;

				}

			iCorruptOut->writeString(_L("r:"));

			iCorruptOut->writeNum(err);

			iCorruptOut->writeNewLine();

			CleanupStack::PopAndDestroy(2);// rand, cert

			}

		CleanupStack::PopAndDestroy(3);//

		}

	__UHEAP_MARKEND;

	}

//	These tests are very slow and do not need to be performed on every

//	certificate in the x509 test directory.  Corrupt every 10th certificate.

void CCorruptionTest::PerformAction(TRequestStatus& aStatus)

	{

	TBuf<256> filename = (*iDirList)[nFileNumber].iName;

	TInt error;

	if( (filename.CompareF(KResultsFile)!=0) && (nFileNumber%10==0) )

		{

		iCorruptOut->writeString(_L("file:"));

		iCorruptOut->writeString(filename);

		iCorruptOut->writeNewLine();

		iConsole.Printf(_L("file:%S\n"), &filename);

		TRAP(error, RunCorruptionTestL(filename));

		if(error == KErrNoMemory)

			User::Leave(error);

		};

	if(++nFileNumber == iDirList->Count())

		{

		iActionState = EPostrequisite;

		};

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, KErrNone);

	}

void CCorruptionTest::DoReportAction()

	{

	}

void CCorruptionTest::DoCheckResult(TInt /*aError*/)

	{

	}

HBufC8* CCorruptionTest::readCertLC(const TDesC& aFilename)

	{

	TFileName fullname;

	fullname.Append(iPath);

	fullname.Append(aFilename);

	RFile file;

	User::LeaveIfError( file.Open(iFs, fullname, EFileRead) );

	TInt size;

	file.Size(size);

	file.Close();

	HBufC8* res = HBufC8::NewLC(size);

	TPtr8 p(res->Des());

	p.SetLength(size);

	RFileReadStream stream;

	User::LeaveIfError(stream.Open(iFs, fullname, EFileStream));

	stream.ReadL(p, size);

	stream.Close();

	return res;

	}