/*

* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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:   Class, which provides keypair operations.

*

*/

#include <asymmetric.h>

#include "keyoperationprovider.h"

#include "pkiservicesigner.h"

#include "pkiservicedecryptor.h"

#include "pkisession.h"

#include "pkidefs.h"

#include "logonservices.h"

#include "keymanager.h"

#include "pkiserviceassert.h"

#include "keyoperationqueue.h"

static const TInt KTimeoutNever = -1;

CKeyPairOperationProvider* CKeyPairOperationProvider::NewL(CKeyOperationQueue& aKeyOperationQueue)

    {

    CKeyPairOperationProvider* self = new (ELeave)CKeyPairOperationProvider(aKeyOperationQueue);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

CKeyPairOperationProvider::CKeyPairOperationProvider(CKeyOperationQueue& aKeyOperationQueue) 

:CActive(EPriorityStandard), iKeyOperationQueue(aKeyOperationQueue), iOutputDataPtr(NULL, 0)

    {

    CActiveScheduler::Add(this);

    }

void CKeyPairOperationProvider::ConstructL()

    {    

    User::LeaveIfError(iFileServer.Connect());

    iUnifiedKeyStore = CUnifiedKeyStore::NewL(iFileServer);        

    iLogonService = CLogonServices::NewL(*iUnifiedKeyStore);

    iKeyManager = CKeyManager::NewL(*iLogonService);

    iPkiSigner = CPkiServiceSigner::NewL(*iLogonService);

    iPkiDecryptor = CPkiServiceDecryptor::NewL(*iLogonService);

    }

CKeyPairOperationProvider::~CKeyPairOperationProvider()

    {

    Cancel();

    delete iPkiDecryptor;

    delete iPkiSigner;

    delete iKeyManager;

    delete iLogonService;

    delete iUnifiedKeyStore;

    iFileServer.Close();

    }

void CKeyPairOperationProvider::Initialize()

	{	

	PKISERVICE_ASSERT(!IsActive());

	PKISERVICE_ASSERT(iKeyOperation == EKeyOperationIdle);

	iKeyOperation = EKeyOperationInitialize;

	if (!iIsInitialized)

    	{	    	    

    	iUnifiedKeyStore->Initialize(iStatus);

    	SetActive();

    	}

    else

        {

        TRequestStatus* ownStatus = &iStatus;

        *ownStatus = KRequestPending;        

        SetActive();

        User::RequestComplete(ownStatus, KErrNone);

        }

	}

void CKeyPairOperationProvider::GetKeyPairList(const TPKIKeyIdentifier& aKeyId, TInt aUsedKeyStore)

	{

	PKISERVICE_ASSERT(iIsInitialized);

    PKISERVICE_ASSERT(!IsActive());	

	PKISERVICE_ASSERT(iKeyOperation == EKeyOperationIdle);    

	iKeyOperation = EKeyOperationGetKeyList;

	iUsedKeyStore = aUsedKeyStore;

    TCTKeyAttributeFilter filter;    

    if (aKeyId.Length() > 0)

        {        

        filter.iKeyId = aKeyId;

        }

	iUnifiedKeyStore->List(iKeysList, filter, iStatus);

	SetActive();

	}

void CKeyPairOperationProvider::Decrypt(const TPKIKeyIdentifier& aKeyId,

                                        TInt aUsedKeyStore,

                                        HBufC8* aEncryptedData,

                                        TInt aOutputLength)

    {

    PKISERVICE_ASSERT(iIsInitialized);

    PKISERVICE_ASSERT(!IsActive());    

	PKISERVICE_ASSERT(iKeyOperation == EKeyOperationIdle);

    PKISERVICE_ASSERT(aKeyId.Length() > 0);

    iKeyOperation = EKeyOperationDecrypting;

    TRAPD(err, DecryptL(aKeyId, aUsedKeyStore, aEncryptedData, aOutputLength));

    if (err != KErrNone)

        {

        iStatus = KRequestPending;

        TRequestStatus* ownStatus = &iStatus;

        SetActive();

        User::RequestComplete(ownStatus, err);

        }   

    }

void CKeyPairOperationProvider::DecryptL(const TPKIKeyIdentifier& aKeyId,

                                         TInt aUsedKeyStore,

                                         HBufC8* aEncryptedData,

                                         TInt aOutputLength)

    {

    PKISERVICE_ASSERT(iKeysList.Count() == 0);

    PKISERVICE_ASSERT(iInputData == NULL);

    PKISERVICE_ASSERT(iKeyOperation == EKeyOperationDecrypting);        

    iInputData = aEncryptedData;

    iOutputData = HBufC8::NewL(aOutputLength);

    iOutputDataPtr.Set(iOutputData->Des());

    iPkiDecryptor->Decrypt(aKeyId,

                           *iInputData,

                           iOutputDataPtr,

                           *iUnifiedKeyStore,

                           aUsedKeyStore,

                           iStatus);

    SetActive();                                

    }

void CKeyPairOperationProvider::Sign(const TPKIKeyIdentifier& aKeyId,

                                     TInt aUsedKeyStore,

                                     HBufC8* aDataToBeSigned)

    {

    PKISERVICE_ASSERT(iIsInitialized);

    PKISERVICE_ASSERT(!IsActive());    

	PKISERVICE_ASSERT(iKeyOperation == EKeyOperationIdle);

    PKISERVICE_ASSERT(aKeyId.Length() > 0);    

    PKISERVICE_ASSERT(iKeysList.Count() == 0);

    PKISERVICE_ASSERT(iInputData == NULL);

    iKeyOperation = EKeyOperationSigning;

    iInputData = aDataToBeSigned;

    iPkiSigner->Sign(aKeyId,

                     *iInputData,

                     iOutputData,

                     *iUnifiedKeyStore,

                     aUsedKeyStore,

                     iStatus);

    SetActive();                  

    }

void CKeyPairOperationProvider::Logon()

    {

    PKISERVICE_ASSERT(iIsInitialized);

    PKISERVICE_ASSERT(!IsActive()); 

    PKISERVICE_ASSERT(iKeyOperation == EKeyOperationIdle);           

    iKeyOperation = EKeyOperationLogon;

    iLogonService->Logon(iStatus);

    SetActive();		

    }

void CKeyPairOperationProvider::Logoff()

    {

    PKISERVICE_ASSERT(iIsInitialized);

    PKISERVICE_ASSERT(!IsActive());    

    PKISERVICE_ASSERT(iKeyOperation == EKeyOperationIdle);    

    iKeyOperation = EKeyOperationLogoff;

    iLogonService->Logoff(iStatus);

    SetActive();		        

    }

void CKeyPairOperationProvider::ChangePassword()

    {

    PKISERVICE_ASSERT(iIsInitialized);

    PKISERVICE_ASSERT(!IsActive());    

    PKISERVICE_ASSERT(iKeyOperation == EKeyOperationIdle);    

    if (iLogonService->LogonCompleted())

        {

        iKeyOperation = EKeyOperationChangingPassword;

        iLogonService->ChangePassword(iStatus);

        }

    else

        {

        iKeyOperation = EKeyOperationLogonForChangePassword;

        iLogonService->Logon(iStatus);

        }    

    SetActive();        

    }

void CKeyPairOperationProvider::RemoveKeyPair(const TPKIKeyIdentifier& aKeyId, TInt aUsedKeyStore)

    {

    PKISERVICE_ASSERT(iIsInitialized);

    PKISERVICE_ASSERT(!IsActive());    

    PKISERVICE_ASSERT(iKeyOperation == EKeyOperationIdle);    

    iKeyOperation = EKeyOperationRemoveKeyPair;

    iKeyManager->RemoveKeyPair(aKeyId, *iUnifiedKeyStore, aUsedKeyStore, iStatus);

    SetActive();

    }

void CKeyPairOperationProvider::GenerateKeyPair(const TUint aKeySize, 

                                                TPKIKeyAlgorithm aKeyAlgorithm,

                                                TInt aUsedKeyStore)

    {

    PKISERVICE_ASSERT(iIsInitialized);

    PKISERVICE_ASSERT(!IsActive());    

    PKISERVICE_ASSERT(iKeyOperation == EKeyOperationIdle);    

    iKeyOperation = EKeyOperationGeneratingKeyPair;

    iKeyManager->GenerateKeyPair(*iUnifiedKeyStore, aUsedKeyStore, aKeySize, 

                                 aKeyAlgorithm, iKeyId, iStatus);

    SetActive();   

    }

void CKeyPairOperationProvider::ImportKeyPair(HBufC8* aKeyData, TInt aUsedKeyStore)

    {

    PKISERVICE_ASSERT(iIsInitialized);

    PKISERVICE_ASSERT(!IsActive());    

    PKISERVICE_ASSERT(iKeyOperation == EKeyOperationIdle);    

    iKeyOperation = EKeyOperationImportingKeyPair;

    iInputData = aKeyData;    

    iKeyManager->ImportKeyPair(*iUnifiedKeyStore, aUsedKeyStore, *iInputData, iKeyId, iStatus);

    SetActive();       

    }

void CKeyPairOperationProvider::GetPublicKey(const TPKIKeyIdentifier& aKeyId, TInt aUsedKeyStore)

    {	

    PKISERVICE_ASSERT(iIsInitialized);

    PKISERVICE_ASSERT(!IsActive());    

    PKISERVICE_ASSERT(iKeyOperation == EKeyOperationIdle);    

    iKeyOperation = EKeyOperationPublicKeyExport;

    iKeyManager->ExportPublicKey(*iUnifiedKeyStore, aUsedKeyStore, aKeyId, iOutputData, iStatus);

    SetActive();       	

    }

void CKeyPairOperationProvider::RunL()

	{

	switch(iKeyOperation)

		{

		case EKeyOperationInitialize:

		    {		        

			iKeyOperation = EKeyOperationIdle;	

			TInt err = iStatus.Int();		

			if (err == KErrNone)

				{

				if (!iIsInitialized)

    				{				    

    				iKeyOperation = EKeyOperationSetPassPhraseTimeout;

    			    iUnifiedKeyStore->SetPassphraseTimeout(KTimeoutNever, iStatus);	

    			    SetActive();

    				}

                else

                    {//keystore is already initialized

                    iKeyOperationQueue.KeyStoreInitComplete(err);

                    }

				}          

            else

                {                    				  				

			    iKeyOperationQueue.KeyStoreInitComplete(err);

                }

		    }

			break;

        case EKeyOperationSetPassPhraseTimeout:

            iKeyOperation = EKeyOperationIdle;

            if (iStatus.Int() == KErrNone)

                {

                iIsInitialized = ETrue;

                }

            iKeyOperationQueue.KeyStoreInitComplete(iStatus.Int());

            break;			

		case EKeyOperationGetKeyList:

		    {		        

			PKISERVICE_ASSERT(iIsInitialized);

			iKeyOperation = EKeyOperationIdle;

			CArrayFixFlat<TKeyListEntry>* list = NULL;

			TInt err = iStatus.Int();

			if (err == KErrNone)

    			{			    

    			TRAP(err, list = MakeKeyEntryListL(iKeysList, iUsedKeyStore));

    			}

            CleanupCryptoOperation();   			

			iKeyOperationQueue.KeyPairListComplete(err, list);

		    }

			break;

        case EKeyOperationDecrypting:

            {                

            PKISERVICE_ASSERT(iIsInitialized);            

            iKeyOperation = EKeyOperationIdle;                       

            HBufC8* plainTextData = NULL;

            if (iStatus.Int() == KErrNone)

                {       

                plainTextData = iOutputData;

                iOutputData = NULL;                

                }                

            CleanupCryptoOperation();

            iKeyOperationQueue.DecryptComplete(iStatus.Int(), plainTextData);

            }

            break;     

        case EKeyOperationSigning:

            {                

            PKISERVICE_ASSERT(iIsInitialized);                       

            iKeyOperation = EKeyOperationIdle;

            HBufC8* data = iOutputData;

            iOutputData = NULL;

            CleanupCryptoOperation(); 

            iKeyOperationQueue.SignComplete(iStatus.Int(), data);                             

            }

            break; 

        case EKeyOperationPublicKeyExport:

            {

            PKISERVICE_ASSERT(iIsInitialized);            

            iKeyOperation = EKeyOperationIdle;     

            PKISERVICE_ASSERT((iStatus.Int() == KErrNone && iOutputData != NULL) ||

                           (iStatus.Int() != KErrNone && iOutputData == NULL));

            HBufC8* publicKeyData = iOutputData;

            iOutputData = NULL;

            CleanupCryptoOperation();                 

            iKeyOperationQueue.GetPublicKeyCompleted(iStatus.Int(), publicKeyData);                                      

            }

            break;

		case EKeyOperationLogon:

		    iKeyOperation = EKeyOperationIdle;     

            iKeyOperationQueue.LogonCompleted(iStatus.Int());

		    break;

		case EKeyOperationLogoff:

		    iKeyOperation = EKeyOperationIdle;     

		    iKeyOperationQueue.LogoffCompleted(iStatus.Int());

            break;

		case EKeyOperationLogonForChangePassword:

		    iKeyOperation = EKeyOperationIdle;     

		    if (iStatus.Int() == KErrNone)

    		    {

    		    iKeyOperation = EKeyOperationChangingPassword;  

    		    iLogonService->ChangePassword(iStatus);

    		    SetActive();

    		    }

		    else

		        {

		        iKeyOperationQueue.PasswordChangeCompleted(iStatus.Int());

		        }

		    break;

		case EKeyOperationChangingPassword: 

		    iKeyOperation = EKeyOperationIdle;     

		    iKeyOperationQueue.PasswordChangeCompleted(iStatus.Int());

            break;

		case EKeyOperationRemoveKeyPair:

		    iKeyOperation = EKeyOperationIdle;     

		    iKeyOperationQueue.KeyPairRemoveCompleted(iStatus.Int());

		    break;

        case EKeyOperationGeneratingKeyPair:

            {                

            iKeyOperation = EKeyOperationIdle;

            TPKIKeyIdentifier keyId = iKeyId;

            iKeyId.Zero();

            iKeyOperationQueue.KeyGenerationCompleted(iStatus.Int(), keyId);        		                

            }

            break;

        case EKeyOperationImportingKeyPair:

            {

            delete iInputData;

            iInputData = NULL;

            iKeyOperation = EKeyOperationIdle;

            TPKIKeyIdentifier keyId = iKeyId;

            iKeyId.Zero();

            iKeyOperationQueue.StoreKeyPairCompleted(iStatus.Int(), keyId);        		                            

            }

            break;

		default:

			PKISERVICE_INVARIANT();

		}

	}

void CKeyPairOperationProvider::DoCancel()

	{		

	switch(iKeyOperation)

		{

		case EKeyOperationInitialize:

			PKISERVICE_ASSERT(!iIsInitialized);

			iUnifiedKeyStore->CancelInitialize();

			break;

        case EKeyOperationSetPassPhraseTimeout:

            iUnifiedKeyStore->CancelSetPassphraseTimeout();

            break;

		case EKeyOperationGetKeyList:

			PKISERVICE_ASSERT(iIsInitialized);

			iUnifiedKeyStore->CancelList();

			break;

		case EKeyOperationDecrypting:		    

		    //Deletes and cancels the decryptor also

            CleanupCryptoOperation();            		    

            break;		        

        case EKeyOperationSigning:

            //Deletes and cancels the signer also.

            CleanupCryptoOperation();

            break;

		case EKeyOperationLogon: //falls through

		case EKeyOperationLogoff: //falls through

		case EKeyOperationLogonForChangePassword: //falls through

		case EKeyOperationChangingPassword: 

		    iLogonService->Cancel();

		    break;

		case EKeyOperationRemoveKeyPair: //falls through

		case EKeyOperationGeneratingKeyPair://falls through

        case EKeyOperationImportingKeyPair://falls through

        case EKeyOperationPublicKeyExport:        

		    iKeyManager->Cancel();

		    break;

		default:

			PKISERVICE_INVARIANT();

		}

    iKeyOperation = EKeyOperationIdle;		

	}

TInt CKeyPairOperationProvider::RunError(TInt aError)

	{

	//This is not be called, because the RunL doesn't

	//leave.

	PKISERVICE_INVARIANT();

	return aError;

	}

CArrayFixFlat<TKeyListEntry>* CKeyPairOperationProvider::MakeKeyEntryListL(RMPointerArray<CCTKeyInfo> aKeysList,

                                                                           TInt aUsedKeyStore) const

    {

    CArrayFixFlat<TKeyListEntry>* list = new (ELeave) CArrayFixFlat<TKeyListEntry>(2);

    CleanupStack::PushL(list);

    for (TInt i = 0; i < aKeysList.Count(); ++i)

        {

        const CCTKeyInfo* info = aKeysList[i];

        if (aUsedKeyStore == 0 ||

            aUsedKeyStore == aKeysList[i]->Token().TokenType().Type().iUid)

            {

            TKeyListEntry keyInfo;	        

            keyInfo.iObjectName = info->Label();

            keyInfo.iSubjectKeyId = info->ID();

            keyInfo.iKeySize = info->Size();                  // Key size                            

            switch(info->Algorithm())

                {

                case CCTKeyInfo::ERSA:

                	keyInfo.iKeyAlgorithm = EPKIRSA;

                	break;

                case CCTKeyInfo::EDSA:

                	keyInfo.iKeyAlgorithm = EPKIDSA;

                	break;

                case CCTKeyInfo::EDH:

                	keyInfo.iKeyAlgorithm = EPKIDH;

                	break;

                default:	         

                	keyInfo.iKeyAlgorithm = EPKIInvalidAlgorithm;

                	break;

                }            

            list->AppendL(keyInfo);

            }        

        }    

    CleanupStack::Pop(list);    

    return list;

    }

void CKeyPairOperationProvider::CleanupCryptoOperation()

    {                

    delete iInputData;

    iInputData = NULL;

    delete iOutputData;

    iOutputData = NULL;