/*

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

 #include "tokenserverdebug.h"

 #include <bigint.h>

 #include <securityerr.h>

 //	Wrapper class because we differ from crypto on what a DH key is

 class CSimpleDHKey : public CBase

 	{

 	public:

 		static CSimpleDHKey* NewL(TInt aSize);

 		~CSimpleDHKey();

 	public:

 		inline RInteger& DHKey() {return (iKey);};

 	private:

 		CSimpleDHKey() {};

 		void ConstructL(TInt aSize);

 	private:

 		RInteger iKey;

 	};

 CSimpleDHKey* CSimpleDHKey::NewL(TInt aSize)

 	{

 	CSimpleDHKey* me = new (ELeave) CSimpleDHKey();

 	CleanupStack::PushL(me);

 	me->ConstructL(aSize);

 	CleanupStack::Pop(me);

 	return (me);

 	}

 void CSimpleDHKey::ConstructL(TInt aSize)

 	{

 	iKey = RInteger::NewRandomL(aSize - 1);							

 	}

 CSimpleDHKey::~CSimpleDHKey()

 	{

 	iKey.Close();

 	}

 CKeyCreator::CKeyCreator()

 	: CActive(EPriorityStandard), 

 	iAction(EIdle)

 	{

 	CActiveScheduler::Add(this);

 	}

 CKeyCreator::~CKeyCreator()

 	{

 	Cancel(); 

 	iCreatorThread.LogonCancel(iStatus);

 	iCreatorThread.Close();

 	delete iCreateData;

 	}

 //	Spin a thread to create an appropriate key, if successful, left on CleanupStack

 void CKeyCreator::DoCreateKeyAsync(CKeyInfo::EKeyAlgorithm aAlgorithm, TInt aSize, TRequestStatus& aStatus)

 	{

 	iClientStatus = &aStatus;

 	*iClientStatus = KRequestPending;

 	iStatus = KRequestPending;

 	TInt err = KErrNone;

 	if ( (aSize <= 0) ||

 		 (aAlgorithm==CKeyInfo::EInvalidAlgorithm) || 

 		 ((aAlgorithm!=CKeyInfo::ERSA) && (aAlgorithm!=CKeyInfo::EDSA) && (aAlgorithm!=CKeyInfo::EDH)) )

 		{

 		err = KErrKeyAlgorithm;

 		}

 	if(err == KErrNone)

 		{

 		iCreateData = new CKeyCreatorData(aAlgorithm, aSize);

 		if(iCreateData == NULL)

 			{

 			err = KErrNoMemory;

 			}

 		}

 	else

 		{

 		User::RequestComplete(iClientStatus, err);

 		return;

 		}

 	//	OK, ready to start the async operation...do it in RunL

 	iAction = EReadyToCreateKey;

 	SetActive();

 	TRequestStatus* stat = &iStatus;

 	User::RequestComplete(stat, err);

 	}	

 //	HERE'S THE THREAD TO CREATE THE KEY

 //	Code cannot leave in here, but not as many traps as it looks

 /*static*/ TInt CKeyCreator::CreatorThreadEntryPoint(TAny* aParameters)

 	{

 	CTrapCleanup* cleanup = CTrapCleanup::New();

 	if (!cleanup)

 		User::Exit(KErrNoMemory);

 #ifdef _DEBUG

 	TokenServerDebug::PauseOOMTest();

 #endif

 	ASSERT(aParameters);

 	TInt result = KErrNone;

 	CKeyCreatorData* createData = static_cast<CKeyCreatorData*>(aParameters);

 	switch (createData->iKeyAlgorithm)

 		{

 		case(CKeyInfo::ERSA):

 			{//	Currently, CRT signing is not supported, in case the key is to be used

 			//	for such, create a standard (private) key as part of the pair

 				TRAP(result, createData->iKey.iRSAKey = CRSAKeyPair::NewL(createData->iSize));

 			}

 			break;

 		case (CKeyInfo::EDSA):

 			{

 				TRAP(result, createData->iKey.iDSAKey = CDSAKeyPair::NewL(createData->iSize));

 			}

 			break;

 		case (CKeyInfo::EDH):

 			{//	Generate a number that's less than N. The snag is that

 			//	we don't know what N is. We do know that it'll be of a

 			//	particular size, so we can safely generate any number

 			//	with less than iSize digits

 				TRAP(result, createData->iKey.iDHKey = CSimpleDHKey::NewL(createData->iSize));				

 			}

 			break;

 		default:

 			ASSERT(EFalse);

 			result = KErrArgument;

 		}

 	#ifdef _DEBUG

 		TokenServerDebug::ResumeOOMTest();

 	#endif

 	delete cleanup;

 	User::Exit(result);

 	return (KErrNone);

 	}

 CRSAKeyPair* CKeyCreator::GetCreatedRSAKey()

 	{

 	//	Check algorithm is as expected, return NULL if no key or wrong type

 	if ( (!iCreateData) || (CKeyInfo::ERSA!=iCreateData->iKeyAlgorithm) )

 		return (NULL);

 	else

 		return (iCreateData->iKey.iRSAKey);

 	}

 CDSAKeyPair* CKeyCreator::GetCreatedDSAKey()

 	{

 	//	Check algorithm is as expected, return NULL if no key or wrong type

 	if ( (!iCreateData) || (CKeyInfo::EDSA!=iCreateData->iKeyAlgorithm) )

 		return (NULL);

 	else

 		return (iCreateData->iKey.iDSAKey);

 	}

 void CKeyCreator::GetCreatedDHKey(RInteger& aDHKey)

 	{

 	ASSERT(iCreateData);

 	ASSERT(CKeyInfo::EDH==iCreateData->iKeyAlgorithm);		

 	aDHKey = iCreateData->iKey.iDHKey->DHKey();

 	}

 void CKeyCreator::DoCancel()

 	{

 	//	Only do the cancel if in the middle of creating a key.  Kill the thread.

 	if (iAction!=EIdle)

 		{

 		TExitType exitType = iCreatorThread.ExitType();

 		if (EExitPending==exitType)	//	Still alive, so kill it

 			{

 			iCreatorThread.Kill(KErrCancel);

 			}

 		iAction = EIdle;

 		}

 	ASSERT(iClientStatus);

 	User::RequestComplete(iClientStatus, KErrCancel);

 	}

 void CKeyCreator::RunL()

 	{

 	ASSERT(iClientStatus);

 	User::LeaveIfError(iStatus.Int());

 	switch (iAction)

 		{

 		case (EReadyToCreateKey):

 			{	

 			// Spin off the thread and pass it the parameter data, then stand by

 			// INC118634

 			// To be safe, we should use anonymous threads because naming a thread means anybody could have opened a handle on the thread,

 			// most likely system applications which want to know about panicing threads. So next thread creation will fail with KErrAlreadyExist(-11).

 			User::LeaveIfError(iCreatorThread.Create(KNullDesC, CreatorThreadEntryPoint, KDefaultStackSize, NULL, (TAny*)iCreateData));

 			iStatus = KRequestPending;

 			iCreatorThread.Logon(iStatus);

 			iAction = ECreatedKey;

 			SetActive();

 			iCreatorThread.Resume();

 			}

 		break;

 		case (ECreatedKey):

 			{//	Notify the caller

 			ASSERT(iClientStatus);

 			// May be OOM creating logon, in which case we should kill thread

 			if (iStatus.Int() == KErrNoMemory)

 				{

 				TExitType exitType = iCreatorThread.ExitType();

 				if (EExitPending==exitType)	//	Still alive, so kill it

 					iCreatorThread.Kill(KErrNone);

 				}

 			User::RequestComplete(iClientStatus, iStatus.Int());

 			iAction = EIdle;

 			}

 		break;

 		default:

 			ASSERT(EFalse);

 		}

 	}

 TInt CKeyCreator::RunError(TInt anError)

 	{

 	if (iClientStatus)

 		User::RequestComplete(iClientStatus, anError);

 	return (KErrNone);

 	}

 CKeyCreator::CKeyCreatorData::CKeyCreatorData(CKeyInfo::EKeyAlgorithm aAlgorithm, TInt aSize)

 	:iSize(aSize), 

 	iKeyAlgorithm(aAlgorithm)

 	{}

 CKeyCreator::CKeyCreatorData::~CKeyCreatorData()

 	{

 	if (iKeyAlgorithm==CKeyInfo::ERSA)

 		delete iKey.iRSAKey;

 	else if (iKeyAlgorithm==CKeyInfo::EDSA)

 		delete iKey.iDSAKey;

 	else if (iKeyAlgorithm==CKeyInfo::EDH)

 		delete iKey.iDHKey;

 	}