/*

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

#if (defined(SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT) && defined(SYMBIAN_ENABLE_SDP_ECC))

#include <cryptospidef.h>

#include "cryptoasymmetriccipherapi.h"

#include "cryptosignatureapi.h"

#include <cryptospi/cryptoparams.h>

#endif // SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT && SYMBIAN_ENABLE_SDP_ECC && SYMBIAN_ENABLE_SDP_ECC

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

{

#if (defined(SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT) && defined(SYMBIAN_ENABLE_SDP_ECC))

    delete iSigner;

    delete iDecrypt;

#endif

	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;

					#if (defined(SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT) && defined(SYMBIAN_ENABLE_SDP_ECC))

					case EECC:

						{

						ASSERT(iHardwareType);

						if(iOperationType == ESigning)

							{

							keyStore->Open(keyInfo->Handle(),iSigner,aStatus);

							}

						if(iOperationType == EDecryption)

							{

							keyStore->Open(keyInfo->Handle(),iDecrypt,aStatus);

							}

						break;

						}

					#endif // SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT && SYMBIAN_ENABLE_SDP_ECC

						}

					break;

					}

				}

			if (i == keyCount)

				{

				TRequestStatus* status = &aStatus;

				User::RequestComplete(status, KErrNotFound);

				}

			iState = EFinished;

		}

		break;

		case EFinished:

			{

			TInt completionCode = aStatus.Int();

			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 (defined(SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT) && defined(SYMBIAN_ENABLE_SDP_ECC))

					case EECC:

						{

						ASSERT(iHardwareType);

						if(iOperationType == ESigning && iSigner == NULL

								|| iOperationType == EDecryption && iDecrypt == NULL)

							{

							completionCode = KErrGeneral;

							}

						break;

						}

#endif // SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT && SYMBIAN_ENABLE_SDP_ECC

				} // switch

#if (defined(SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT) && defined(SYMBIAN_ENABLE_SDP_ECC))

				if(iHardwareType == 0)

#endif // SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT && SYMBIAN_ENABLE_SDP_ECC

					{

					if (*label != *iLabel)

						aStatus = KErrBadName;

					CleanupStack::PopAndDestroy(label);

					}

				}

			TRequestStatus* status = &aStatus;

			User::RequestComplete(status, completionCode);

			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;

		}

#if (defined(SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT) && defined(SYMBIAN_ENABLE_SDP_ECC))

    delete iSigner;

    iSigner = NULL;

    delete iDecrypt;

    iDecrypt = NULL;

#endif // SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT && SYMBIAN_ENABLE_SDP_ECC

	}

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)

	{

	CKeyStoreTestAction::ConstructL(aTestActionSpec);

#if (defined(SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT) && defined(SYMBIAN_ENABLE_SDP_ECC))

	TPtrC8 operationType = Input::ParseElement(aTestActionSpec.iActionBody, KOperationTypeStart, KOperationTypeEnd, pos, err);

	if(operationType.Compare(_L8("sign")) == 0)

		{

		iOperationType = ESigning;

		}

	else if (operationType.Compare(_L8("decrypt")) == 0)

		{

		iOperationType = EDecryption;

		}

#endif // SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT && SYMBIAN_ENABLE_SDP_ECC

	iState = EListKeysPreOpen;

	}

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

// 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;

#if (defined(SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT) && defined(SYMBIAN_ENABLE_SDP_ECC))

    delete iSigner;

    delete iSpiSignature;

#endif // SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT && SYMBIAN_ENABLE_SDP_ECC

}

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

						#if (defined(SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT) && defined(SYMBIAN_ENABLE_SDP_ECC))

						case EECC:

							{

							iTokenHandle = keyInfo->Handle();

							if(iHardwareType == 0)

								{

								keyStore->Open(iTokenHandle, iSigner, aStatus);

								}

							else

								{

								TRequestStatus* status = &aStatus;

								User::RequestComplete(status, KErrNone);

								}

							}

							break;

						#endif // SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT && SYMBIAN_ENABLE_SDP_ECC

                        }

                    } // if

                if (i == keyCount)

					{

					TRequestStatus* status = &aStatus;

					User::RequestComplete(status, KErrNotFound);

					}		

                }// for

			iState = ESign;

		}

		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;

#if (defined(SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT) && defined(SYMBIAN_ENABLE_SDP_ECC))

                case EECC:

                    {

                    TRAPD(err, iSpiSignature = CryptoSpi::CCryptoParams::NewL());

                    if(err == KErrNone)

                        {

                        if(iHardwareType)

                            {

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

                            ASSERT(keyStore);   //  Flag it up

                            keyStore->Sign(iTokenHandle, *iReadText, iSpiSignature, aStatus);

                            }

                        else

                            {

                            if(iSigner)

                                {

                                TRAP(err, iSigner->SignL(*iReadText, *iSpiSignature));

                                aStatus = err;

                                }

                            TRequestStatus* status = &aStatus;

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

                            }