/*

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

#include <ecom/ecom.h>

#include <random.h>

#include <pbedata.h>

#include <asnpkcs.h>

#include "mctcertappinterface.h"

#include <mctkeystoreuids.h>

_LIT(KUnifiedKeyStore, "UnifiedKeyStore");

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

//CUnifiedKeyStore

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

EXPORT_C CUnifiedKeyStore* CUnifiedKeyStore::NewL(RFs& aFs)

	{

	CUnifiedKeyStore* self = CUnifiedKeyStore::NewLC(aFs);

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CUnifiedKeyStore* CUnifiedKeyStore::NewLC(RFs& aFs)

	{

	CUnifiedKeyStore* self = new(ELeave) CUnifiedKeyStore(aFs);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

EXPORT_C CUnifiedKeyStore::~CUnifiedKeyStore()

	{

	Cancel();

	Cleanup();

	iKeyStoresHolder.ResetAndDestroy();

	iKeyStoresHolder.Close();

	REComSession::FinalClose();

	}

void CUnifiedKeyStore::DoInitializeL()

{//	We want the list of all token types that support a keystore interface

	RArray<TUid> uidArray;

	CleanupClosePushL(uidArray);

	User::LeaveIfError(uidArray.Append(TUid::Uid(KInterfaceKeyStore)));

	TCTFindTokenTypesByInterface filter(uidArray.Array());

	CCTTokenTypeInfo::ListL(iTokenTypes, filter);

	CleanupStack::PopAndDestroy();	// uidArray

}

EXPORT_C void CUnifiedKeyStore::Initialize(TRequestStatus& aStatus)

{// The following assertion checks that we didn't call Initialize twice

	__ASSERT_DEBUG((iKeyStoresHolder.Count()==0), User::Panic(KUnifiedKeyStore, EUnexpectedInitialise));

	TRAPD(err, DoInitializeL());

	if (err != KErrNone)

		{

		TRequestStatus* status = &aStatus;

		User::RequestComplete(status, err);

		return;

		}

	iIndexTokenTypes = -1;

	StartAsyncOperation(EInitializeGetTokenList, aStatus);

	SetActive();

	TRequestStatus* status = &iStatus;

	User::RequestComplete(status, KErrNone);

}

EXPORT_C void CUnifiedKeyStore::CancelInitialize()

	{

	if (iState == EInitializeGetTokenList ||

		iState == EInitializeGetToken ||

		iState == EInitialiseGetKeyManagerInterface ||

		iState == EInitializeGetKeyUserInterface ||

		iState == EInitializeGetKeyUserInterfaceFinished ||

		iState == EInitializeFinished)

		{

		Cancel();

		}

	}

EXPORT_C void CUnifiedKeyStore::CreateKey(TInt aKeyStoreIndex, TKeyUsagePKCS15 aUsage,TUint aSize, 

										  const TDesC& aLabel, CCTKeyInfo::EKeyAlgorithm aAlgorithm, 

										  TInt aAccessType, TTime aStartDate, TTime aEndDate, 

										  CCTKeyInfo*& aKeyInfoOut, TRequestStatus& aStatus)

	{

	StartAsyncOperation(ECreateKey, aStatus);

	TRAPD(err, PrepareToCreateKeyL(aKeyStoreIndex, aUsage, aSize, aLabel, aAlgorithm, aAccessType,

								   aStartDate, aEndDate, aStatus));

	if (KErrNone != err)

		{

		Complete(err);

		return;

		}

	iKeyInfoOut = &aKeyInfoOut;

	aKeyInfoOut = NULL;

	iKeyStoreManager->CreateKey(iKeyInfo, iStatus);

	SetActive();

	}

EXPORT_C void CUnifiedKeyStore::CancelCreateKey()

	{

	if (iState == ECreateKey)

		{			

		Cancel();

		}

	}

EXPORT_C void CUnifiedKeyStore::ImportKey(TInt aKeyStoreIndex, const TDesC8& aKeyData,

										  TKeyUsagePKCS15 aUsage, const TDesC& aLabel, 

										  TInt aAccessType, TTime aStartDate, TTime aEndDate, 

										  CCTKeyInfo*& aKeyInfoOut, TRequestStatus& aStatus)

	{

	TBool isEncrypted = TASN1DecPKCS8::IsEncryptedPKCS8Data(aKeyData);

	StartAsyncOperation(isEncrypted ? EImportKeyEncrypted : EImportKey, aStatus);

	ASSERT(!iKeyData);

	iKeyData = aKeyData.Alloc();

	if (!iKeyData)	//	OOM or some other catastrophe

		{

		Complete(KErrNoMemory);

		return;

		}

	TRAPD(err, PrepareToCreateKeyL(aKeyStoreIndex, aUsage, 0, aLabel, CCTKeyInfo::EInvalidAlgorithm, aAccessType,

								   aStartDate, aEndDate, aStatus));

	if (KErrNone != err)

		{

		Complete(err);

		return;

		}

	iKeyInfoOut = &aKeyInfoOut;

	aKeyInfoOut = NULL;

	if (isEncrypted)

		{

		iKeyStoreManager->ImportEncryptedKey(*iKeyData, iKeyInfo, iStatus);

		}

	else

		{

		iKeyStoreManager->ImportKey(*iKeyData, iKeyInfo, iStatus);

		}

	SetActive();

	}

EXPORT_C void CUnifiedKeyStore::CancelImportKey()

	{

	if (iState == EImportKey ||

		iState == EImportKeyEncrypted)

		{

		Cancel();

		}

	}

void CUnifiedKeyStore::PrepareToCreateKeyL(	TInt aKeyStoreIndex,

											TKeyUsagePKCS15 aUsage, TUint aSize, 

											const TDesC& aLabel, 

											CCTKeyInfo::EKeyAlgorithm aAlgorithm,

											TInt aAccessType, 

											TTime aStartTime, TTime aEndTime,

											TRequestStatus& aStatus)

	{

	ASSERT(!iKeyStoreManager);

	//	These values are filled in by the server when the key is created

	TKeyIdentifier keyID;

	keyID.MaxSize();

	keyID.FillZ(keyID.MaxSize());

	TInt keyHandle = 0;

	// Get the secure ID of the current process

	RProcess thisProcess;

	User::LeaveIfError(thisProcess.Open(thisProcess.Id()));

	TSecureId creatorId = thisProcess.SecureId();

	thisProcess.Close();

	// Default management policy: resict to creating process

	TSecurityPolicy managementPolicy(creatorId);

	// Default use policy: also resict to creating process

	TSecurityPolicy usePolicy(creatorId);

	HBufC* label = aLabel.AllocLC();

	// Panics if keystore manager index invalid

	MCTKeyStoreManager& keystore = KeyStoreManager(aKeyStoreIndex);

	iKeyInfo = CCTKeyInfo::NewL(keyID, aUsage, aSize, NULL, label, keystore.Token(),

								keyHandle, usePolicy, managementPolicy, aAlgorithm,

								aAccessType, ETrue, aStartTime, aEndTime);

	CleanupStack::Pop(label);

	iKeyStoreManager = &keystore;

	iOriginalRequestStatus = &aStatus;

	aStatus = KRequestPending;

	}

//	************************************************************************

//	MKeyStore

//	************************************************************************

void CUnifiedKeyStore::List(RMPointerArray<CCTKeyInfo>& aKeys, 

							const TCTKeyAttributeFilter& aFilter, 

							TRequestStatus& aStatus)

	{

	StartAsyncOperation(EList, aStatus);

	iKeyInfos = &aKeys;

	delete iFilter;

	iFilter = new TCTKeyAttributeFilter(aFilter);

	if (!iFilter)

		{

		Complete(KErrNoMemory);

		return;

		}

	iIndex = -1;

	SetActive();

	TRequestStatus* status = &iStatus;

	User::RequestComplete(status, KErrNone);

}

void CUnifiedKeyStore::CancelList()

	{

	if (iState == EList)

		{

		Cancel();

		}

	}

void CUnifiedKeyStore::GetKeyInfo(TCTTokenObjectHandle aHandle, 

										   CCTKeyInfo*& aKeyInfo,

										   TRequestStatus& aStatus)

	{

	StartAsyncOperation(EGetKeyInfo, aStatus);

	ASSERT(!iKeyStore);	

	iKeyStore = FindKeyStore(aHandle);

	if (!iKeyStore)

		{

		Complete(KErrNotFound);

		return;

		}

	iKeyStore->GetKeyInfo(aHandle, aKeyInfo, iStatus);

	SetActive();

	}

void CUnifiedKeyStore::CancelGetKeyInfo()

	{

	if (iState == EGetKeyInfo)

		{

		Cancel();

		}

	}

// Implementation for most of the Open() method

TBool CUnifiedKeyStore::DoOpen(const TCTTokenObjectHandle& aHandle, 

							   TRequestStatus& aStatus)

	{

	StartAsyncOperation(EOpen, aStatus);

	ASSERT(!iKeyStore);	

	iKeyStore = FindKeyStore(aHandle);

	if (!iKeyStore)

		{

		Complete(KErrNotFound);

		return EFalse;

		} 

	SetActive();

	return ETrue;

	}

void CUnifiedKeyStore::Open(const TCTTokenObjectHandle& aHandle, 

							MRSASigner*& aSigner,

							TRequestStatus& aStatus)

	{

	if (DoOpen(aHandle, aStatus))

		{

		iKeyStore->Open(aHandle, aSigner, iStatus);

		}

	}

void CUnifiedKeyStore::Open(const TCTTokenObjectHandle& aHandle, 

							MDSASigner*& aSigner, 

							TRequestStatus& aStatus)

	{

	if (DoOpen(aHandle, aStatus))

		{			

		iKeyStore->Open(aHandle, aSigner, iStatus);

		}

	}

void CUnifiedKeyStore::Open(const TCTTokenObjectHandle& aHandle, 

							MCTDecryptor*& aDecryptor,

							TRequestStatus& aStatus)

	{

	if (DoOpen(aHandle, aStatus))

		{

		iKeyStore->Open(aHandle, aDecryptor, iStatus);

		}

	}

void CUnifiedKeyStore::Open(const TCTTokenObjectHandle& aHandle, 

							MCTDH*& aDH, TRequestStatus& aStatus)

	{	

	if (DoOpen(aHandle, aStatus))

		{

		iKeyStore->Open(aHandle, aDH, iStatus);

		}

	}

void CUnifiedKeyStore::CancelOpen()

	{

	if (iState == EOpen)

		{

		Cancel();

		}

	}

/** Returns the public key in DER-encoded ASN-1 */

void CUnifiedKeyStore::ExportPublic(const TCTTokenObjectHandle& aHandle,

									HBufC8*& aPublicKey,

									TRequestStatus& aStatus)

	{

	StartAsyncOperation(EExportPublic, aStatus);

	iKeyStore = FindKeyStore(aHandle);

	if (!iKeyStore)

		{

		Complete(KErrNotFound);

		return;

		}

	iKeyStore->ExportPublic(aHandle, aPublicKey, iStatus);

	SetActive();

	}

void CUnifiedKeyStore::CancelExportPublic()

	{

	if (iState == EExportPublic)

		{

		Cancel();

		}

	}

//	************************************************************************

//	MKeyStoreManager

//	************************************************************************

EXPORT_C void CUnifiedKeyStore::ExportKey(TCTTokenObjectHandle aHandle, 

										  HBufC8*& aKey, TRequestStatus& aStatus)

	{

	StartAsyncOperation(EExportKey, aStatus);

	ASSERT(!iKeyStoreManager);

	iKeyStoreManager = FindKeyStoreManager(aHandle);

	if (!iKeyStoreManager)

		{

		Complete(KErrNotFound);

		return;

		} 

	iKeyStoreManager->ExportKey(aHandle, aKey, iStatus);

	SetActive();

	}

EXPORT_C void CUnifiedKeyStore::CancelExportKey()

	{

	if (iState == EExportKey)

		{

		Cancel();

		}

	} 

EXPORT_C void CUnifiedKeyStore::ExportEncryptedKey(TCTTokenObjectHandle aHandle, 

												   const CPBEncryptParms& aEncryptParams,

												   HBufC8*& aKey, TRequestStatus& aStatus)

	{

	StartAsyncOperation(EExportEncryptedKey, aStatus);

	ASSERT(!iKeyStoreManager);	

	iKeyStoreManager = FindKeyStoreManager(aHandle);

	if (!iKeyStoreManager)

		{

		Complete(KErrNotFound);

		return;

		} 

	iKeyStoreManager->ExportEncryptedKey(aHandle, aEncryptParams, aKey, iStatus);

	SetActive();

	}

EXPORT_C void CUnifiedKeyStore::CancelExportEncryptedKey()

	{

	if (iState == EExportEncryptedKey)

		{

		Cancel();

		}	

	}

EXPORT_C void CUnifiedKeyStore::DeleteKey(TCTTokenObjectHandle aHandle, 

										  TRequestStatus& aStatus)

	{

	StartAsyncOperation(EDeleteKey, aStatus);

	iKeyStoreManager = FindKeyStoreManager(aHandle);

	if (!iKeyStoreManager)

		{

		Complete(KErrNotFound);

		return;

		}

	iKeyStoreManager->DeleteKey(aHandle, iStatus);

	SetActive();

	}

EXPORT_C void CUnifiedKeyStore::CancelDeleteKey()

	{

	if (iState == EDeleteKey)

		{

		Cancel();

		}

	}

EXPORT_C void CUnifiedKeyStore::SetUsePolicy(TCTTokenObjectHandle aHandle, 

											 const TSecurityPolicy& aPolicy,

											 TRequestStatus& aStatus)

	{

	StartAsyncOperation(ESetUsePolicy, aStatus);

	iKeyStoreManager = FindKeyStoreManager(aHandle);

	if (!iKeyStoreManager)

		{

		Complete(KErrNotFound);

		return;

		}

	iKeyStoreManager->SetUsePolicy(aHandle, aPolicy, iStatus);

	SetActive();

	}

EXPORT_C void CUnifiedKeyStore::CancelSetUsePolicy()

	{

	if (iState == ESetUsePolicy)

		{

		Cancel();

		}

	}

EXPORT_C void CUnifiedKeyStore::SetManagementPolicy(TCTTokenObjectHandle aHandle, 

													const TSecurityPolicy& aPolicy,

													TRequestStatus& aStatus)

	{

	StartAsyncOperation(ESetManagementPolicy, aStatus);

	iKeyStoreManager = FindKeyStoreManager(aHandle);

	if (!iKeyStoreManager)

		{

		Complete(KErrNotFound);

		return;

		}

	iKeyStoreManager->SetManagementPolicy(aHandle, aPolicy, iStatus);

	SetActive();

	}