/*

* Copyright (c) 2003-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 <e32base.h>

#include "t_keystore_actions.h"

#include "t_keystore_defs.h"

#include "t_input.h"

#include <asn1enc.h>

#include <asn1dec.h>

#include <x509cert.h>

#include <x509keys.h>

#include <asymmetrickeys.h>

/*static*/ CTestAction* COpenKey::NewL(RFs& aFs, CConsoleBase& aConsole, Output& aOut, const TTestActionSpec& aTestActionSpec)

{

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

	CleanupStack::Pop(self);

	return self;

}

/*static*/ CTestAction* COpenKey::NewLC(RFs& aFs, CConsoleBase& aConsole, Output& aOut, const TTestActionSpec& aTestActionSpec)

{

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

	CleanupStack::PushL(self);

	self->ConstructL(aTestActionSpec);

	return self;

}

COpenKey::~COpenKey()

{

	iKeys.Close();

}

void COpenKey::PerformAction(TRequestStatus& aStatus)

{

	switch (iState)

	{	

		case EListKeysPreOpen:

		{//	Currently uses the first store, change to check the script for a specific store

			CUnifiedKeyStore* keyStore = CSharedKeyStores::TheUnifiedKeyStores().operator[](iKeystore);

			ASSERT(keyStore);	//	Flag it up

			if (keyStore)

				keyStore->List(iKeys, iFilter, aStatus);

			iState = EOpenKey;

		}

		break;

		case EOpenKey:

			{

			CUnifiedKeyStore* keyStore = CSharedKeyStores::TheUnifiedKeyStores().operator[](iKeystore);

			ASSERT(keyStore);	//	Flag it up

			TInt keyCount = iKeys.Count();

			TInt i;

			for (i = 0; i < keyCount; i++)

				{

				CCTKeyInfo* keyInfo = iKeys[i];

				if (keyInfo->Label() == *iLabel)

					{

					switch (iType)

						{

					case ERSASign:

						keyStore->Open(*keyInfo, iRSASigner, aStatus);

						break;

					case EDSASign:

						keyStore->Open(*keyInfo, iDSASigner, aStatus);

						break;

					case EDecrypt:

						keyStore->Open(*keyInfo, iDecryptor, aStatus);

						break;

					case EDH:

						keyStore->Open(*keyInfo, iDH, aStatus);

						break;

						}

					break;

					}

				}

			iState = EFinished;

			if (i == keyCount)

				{

				TRequestStatus* status = &aStatus;

				User::RequestComplete(status, KErrNotFound);

				}

		}

		break;

		case EFinished:

			{

			HBufC* label = 0;

			iKeys.Close();

			if (aStatus.Int() == KErrNone)

				{

				switch (iType)

					{

				case ERSASign:

					if (iRSASigner)

						{

						label = iRSASigner->Label().AllocLC();

						iRSASigner->Release();

						}

					break;

				case EDSASign:

					if (iDSASigner)

						{

						label = iDSASigner->Label().AllocLC();

						iDSASigner->Release();

						}

					break;

				case EDecrypt:

					if (iDecryptor)

						{

						label = iDecryptor->Label().AllocLC();

						iDecryptor->Release();

						}

				case EDH:

					if (iDH)

						{

						label = iDH->Label().AllocLC();

						iDH->Release();

						}

					break;

					}

				if (*label != *iLabel)

					aStatus = KErrBadName;

				CleanupStack::PopAndDestroy(label);

				}

			TRequestStatus* status = &aStatus;

			User::RequestComplete(status, aStatus.Int());

			if (aStatus.Int()==iExpectedResult)

				{

				iResult = ETrue;

				}

			else

			{

				iResult = EFalse;

			}

			iActionState = EPostrequisite;

		}

		break;

		default:

			ASSERT(EFalse);	

	}

}

void COpenKey::PerformCancel()

    {

    CUnifiedKeyStore* keystore = CSharedKeyStores::TheUnifiedKeyStores().operator[](iKeystore);

    ASSERT(keystore);

    switch (iState)

        {

        case EOpenKey:

            keystore->CancelList();

            break;

        case EFinished:

            keystore->CancelOpen();

            break;

        default:

            break;

        }

    }

void COpenKey::Reset()

	{

  	iState = EListKeysPreOpen;

    iKeys.Close();

	if (iRSASigner)

		{

		iRSASigner->Release();

		iRSASigner = NULL;

		}

	if (iDSASigner)

		{

		iDSASigner->Release();

		iDSASigner = NULL;

		}

	if (iDecryptor)

		{

		iDecryptor->Release();

		iDecryptor = NULL;

		}

	if (iDH)

		{

		iDH->Release();

		iDH = NULL;

		}

	}

void COpenKey::DoReportAction()

{

	_LIT(KDeleting, "Opening...");

	iOut.writeString(KDeleting);

	iOut.writeNewLine();

}

void COpenKey::DoCheckResult(TInt aError)

{

	if (iFinished)

	{

		TBuf<256> buf;

		if (aError == KErrNone)

		{

			_LIT(KSuccessful, "Key open success\n");			

			buf.Format(KSuccessful);

			iConsole.Write(buf);

			iOut.writeString(buf);

			iOut.writeNewLine();

		}

		else

		{

			if (aError!=iExpectedResult)

			{

				_LIT(KFailed, "!!!Key open failure %d!!!\n");

				buf.Format(KFailed, aError);

				iConsole.Write(buf);

				iOut.writeString(buf);

			}

			else

			{

				_LIT(KFailed, "Key open failed, but expected\n");

				iConsole.Write(KFailed);

				iOut.writeString(KFailed);

			}

			iOut.writeNewLine();

		}

	}

}

COpenKey::COpenKey(RFs& aFs, CConsoleBase& aConsole, Output& aOut)

:	CKeyStoreTestAction(aFs, aConsole, aOut)

{}

void COpenKey::ConstructL(const TTestActionSpec& aTestActionSpec)

	{

	TInt pos = 0, err = 0;

	CKeyStoreTestAction::ConstructL(aTestActionSpec);

	SetKeyType(Input::ParseElement(aTestActionSpec.iActionBody, KOpenStart, KOpenEnd, pos, err));

	iState = EListKeysPreOpen;

	}

void COpenKey::SetKeyType(const TDesC8& aKeyType)

{

	if (aKeyType.Compare(KAlgRSA)==0)

	{

		iType = ERSASign;

	}

	else if (aKeyType.Compare(KAlgDSA)==0)

	{

		iType = EDSASign;

	}

	else if (aKeyType.Compare(KDecryptUsage)==0)

	{

		iType = EDecrypt;

	}

	else if (aKeyType.Compare(KAlgDH)==0)

	{

		iType = EDH;

	}

}

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

// CSign

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

/*static*/ CTestAction* CSign::NewL(RFs& aFs, CConsoleBase& aConsole, Output& aOut, const TTestActionSpec& aTestActionSpec)

{

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

	CleanupStack::Pop(self);

	return self;

}

/*static*/ CTestAction* CSign::NewLC(RFs& aFs, CConsoleBase& aConsole, Output& aOut, const TTestActionSpec& aTestActionSpec)

{

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

	CleanupStack::PushL(self);

	self->ConstructL(aTestActionSpec);

	return self;

}

CSign::~CSign()

{

	iKeys.Close();

	delete iReadText;

	delete iExportedPublicKey;

	delete iRSASignature;

	delete iDSASignature;

	delete iHash;

}

void CSign::PerformAction(TRequestStatus& aStatus)

{

	// Jump straight to final state if an error occured 

	if (aStatus.Int()!=KErrNone)

		{

		iState=EFinished;

		}

	switch (iState)

	{	

		case EListKeysPreOpen:

		{            

			CUnifiedKeyStore* keyStore = CSharedKeyStores::TheUnifiedKeyStores().operator[](iKeystore);

			ASSERT(keyStore);	//	Flag it up

			if (keyStore)

				keyStore->List(iKeys, iFilter, aStatus);

			iState = EOpenKey;

		}

		break;

		case EOpenKey:

		{

			CUnifiedKeyStore* keyStore = CSharedKeyStores::TheUnifiedKeyStores().operator[](iKeystore);

				ASSERT(keyStore);	//	Flag it up

				TInt keyCount = iKeys.Count();

				TInt i;

				for (i = 0; i < keyCount; i++)

					{

					CCTKeyInfo* keyInfo = iKeys[i];

					if (keyInfo->Label() == *iLabel)

						{

						switch (iType)

							{

						case ERSASign:

							keyStore->Open(*keyInfo, iRSASigner, aStatus);

							break;

						case EDSASign:

							keyStore->Open(*keyInfo, iDSASigner, aStatus);

							break;

						case EDH:

						case EDecrypt:

							break;	//	Nothing to do, for the compiler

							}

						break;

						}

					}

				iState = ESign;

				if (i == keyCount)

					{

					TRequestStatus* status = &aStatus;

					User::RequestComplete(status, KErrNotFound);

					}					

				}

		break;

		case ESign:

			{

			switch (iType)

				{

				case ERSASign:

				{

					if (iHash)

					{

					    if (iFailHashDigest)	//	Don't hash it, fail deliberately

							iRSASigner->Sign(*iReadText,iRSASignature,aStatus);

						else  // message gets signed by the keystore

							iRSASigner->SignMessage(*iReadText,iRSASignature,aStatus);

					}

					else

					{

						iRSASigner->Sign(*iReadText,iRSASignature,aStatus);

					}

				}

				break;

				case EDSASign:

				{

					if (iHash)

					{

					    if (iFailHashDigest)	//	Don't hash it, deliberately fail it

							iDSASigner->Sign(*iReadText,iDSASignature,aStatus);

						else  // message gets signed by the keystore

							iDSASigner->SignMessage(*iReadText,iDSASignature,aStatus);

					}

					else

					{

						iDSASigner->Sign(*iReadText,iDSASignature,aStatus);

					}

				}

				break;

				default:

					ASSERT(EFalse);

			}					

			iState = EExportPublic;					

		}

		break;

		case EExportPublic:

			{

			CUnifiedKeyStore* keyStore = CSharedKeyStores::TheUnifiedKeyStores().operator[](iKeystore);

			ASSERT(keyStore);	//	Flag it up				

			TInt keyCount = iKeys.Count();

			TInt i;

			for (i = 0; i < keyCount; i++)

				{

				CCTKeyInfo* keyInfo = iKeys[i];

				if (keyInfo->Label() == *iLabel)

					{

					iExportHandle = keyInfo->Handle();

					switch (iType)

						{

					case ERSASign:

						keyStore->ExportPublic(iExportHandle, iExportedPublicKey,  aStatus);

						break;

					case EDSASign:

						keyStore->ExportPublic(iExportHandle, iExportedPublicKey,  aStatus); 

						break;

					case EDH:

					case EDecrypt:

						break;	//	Nothing to do, for the compiler

						}

					break;

					}

				}

			iState = EVerify;

			if (i == keyCount)

				{

				TRequestStatus* status = &aStatus;

				User::RequestComplete(status, KErrNotFound);

				}

			}

			break;

		case EVerify:

			{

			TInt keyCount = iKeys.Count();

			TInt i;

			for (i = 0; i < keyCount; i++)

				{

				CCTKeyInfo* keyInfo = iKeys[i];

				if (keyInfo->Label() == *iLabel)

					{

					iExportHandle = keyInfo->Handle();

					CX509SubjectPublicKeyInfo* ki = 

						CX509SubjectPublicKeyInfo::NewLC(*iExportedPublicKey);

					switch (iType)

						{

					case ERSASign:

						{

						TX509KeyFactory factory; 

						CRSAPublicKey* key = factory.RSAPublicKeyL(ki->KeyData());

						CleanupStack::PushL(key);

						CRSAPKCS1v15Verifier* verifier = NULL;

						if (iHash)	//	Must compare with hash of original data

						{

							verifier = CRSAPKCS1v15Verifier::NewLC(*key);

							iHash->Reset();

							iVerifyResult = verifier->VerifyL(iHash->Final(*iReadText), *iRSASignature);

						}

						else

						{

							verifier = CRSAPKCS1v15Verifier::NewLC(*key);

							iVerifyResult = verifier->VerifyL(*iReadText, *iRSASignature);

						}

						_LIT(KReturned, "Returned... ");

						iOut.writeString(KReturned);

						iOut.writeNewLine();

						CleanupStack::PopAndDestroy(2, key);

						}

						break;

					case EDSASign:

						{