/*

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

* Implements CFSKeyStoreClient

*

*/

/**

 @file 

 @internalTechnology

*/

#ifndef __CFSKEYSTORECLIENT_H__

#define __CFSKEYSTORECLIENT_H__

#include <CFSClient.h>

#include <mctkeystoremanager.h>

#include <rmpointerarray.h>

#include "CKeyStoreAuthObject.h"

/** Maximum allowed size of digest to RSA sign (implied by max 2048 bit key length). */

const TInt KMaxRSADigestSize = 2048 / 8;

/** Maximum allowed size of digest to DSA sign (implied by 160 bit output of SHA1). */

const TInt KMaxDSADigestSize = 160 / 8;

class COpenedKey;

class MKeyInfoArray;

class CDHParams;

/**

 * Implements the MCTKeyStoreManager interface.  Inherits from CFSClient.

 *

 * The class implements the keystore manager token interface for the software

 * keystore.  It will be created and owned by the unified keystore.  Its main

 * function is to marshall user requests to the filetokens server and unmarshall

 * the results back again.

 */

NONSHARABLE_CLASS(CFSKeyStoreClient) : public CFSClient, public MCTKeyStoreManager

{

public://	One creator function for each token interface

	static MCTTokenInterface* NewKeyStoreUserInterfaceL(MCTToken& aToken, RFileStoreClientSession& aClient);

	static MCTTokenInterface* NewKeyStoreManagerInterfaceL(MCTToken& aToken, RFileStoreClientSession& aClient);

public:

	virtual ~CFSKeyStoreClient();

	void AddRef();

public:

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

//	MKeyStore

	virtual void List(RMPointerArray<CCTKeyInfo>& aKeys, const TCTKeyAttributeFilter& aFilter, TRequestStatus& aStatus);

	virtual void CancelList();

	virtual void GetKeyInfo(TCTTokenObjectHandle aHandle, CCTKeyInfo*& aInfo, TRequestStatus& aStatus);

	virtual void CancelGetKeyInfo();

	/** Open an RSA key for signing	*/

	virtual void Open(const TCTTokenObjectHandle& aHandle, 

					  MRSASigner*& aSigner,

					  TRequestStatus& aStatus);

	/** Open a DSA key for signing */

	virtual void Open(const TCTTokenObjectHandle& aHandle, 

					  MDSASigner*& aSigner, 

					  TRequestStatus& aStatus);

	/** Open a RSA key for private decryption */

	virtual void Open(const TCTTokenObjectHandle& aHandle, 

					  MCTDecryptor*& aDecryptor,

					  TRequestStatus& aStatus);

	/** Open a DH key for key agreement */

	virtual void Open(const TCTTokenObjectHandle& aHandle, 

					  MCTDH*& aDH, TRequestStatus& aStatus);

	/// Cancels an ongoing open request

	virtual void CancelOpen();

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

	virtual void ExportPublic(const TCTTokenObjectHandle& aHandle,

							  HBufC8*& aPublicKey,

							  TRequestStatus& aStatus);

	virtual void CancelExportPublic();

public:

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

//	MCTKeyStoreManager

	virtual void CreateKey(CCTKeyInfo*& aReturnedKey, TRequestStatus& aStatus);

	virtual void CancelCreateKey();

	virtual void ImportKey(const TDesC8& aKey, CCTKeyInfo*& aReturnedKey, TRequestStatus& aStatus);

	virtual void CancelImportKey();

	virtual void ImportEncryptedKey(const TDesC8& aKey, CCTKeyInfo*& aReturnedKey, TRequestStatus& aStatus);

	virtual void CancelImportEncryptedKey();

	virtual void ExportKey(TCTTokenObjectHandle aHandle, HBufC8*& aKey, TRequestStatus& aStatus); 

	virtual void CancelExportKey();

	virtual void ExportEncryptedKey(TCTTokenObjectHandle aHandle, const CPBEncryptParms& aParams, HBufC8*& aKey, TRequestStatus& aStatus);

	virtual void CancelExportEncryptedKey();

	virtual void DeleteKey(TCTTokenObjectHandle aHandle, TRequestStatus& aStatus);

	virtual void CancelDeleteKey();	

	virtual void SetUsePolicy(TCTTokenObjectHandle aHandle, const TSecurityPolicy& aPolicy, TRequestStatus& aStatus);

	virtual void CancelSetUsePolicy();

	virtual void SetManagementPolicy(TCTTokenObjectHandle aHandle, const TSecurityPolicy& aPolicy, TRequestStatus& aStatus);

	virtual void CancelSetManagementPolicy();

	virtual void SetPassphraseTimeout(TInt aTimeout, TRequestStatus& aStatus);

	virtual void CancelSetPassphraseTimeout();	

	virtual void Relock(TRequestStatus& aStatus);

	virtual void CancelRelock();	

	void ReleaseObject(const TCTTokenObjectHandle& aObject);

public:	

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

//	From MCTTokenInterface

	virtual MCTToken& Token();

public:

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

	void RepudiableDSASign(const TCTTokenObjectHandle& aObject, const TDesC8& aDigest, CDSASignature*& aSignature, TRequestStatus& aStatus);

	void CancelRepudiableDSASign();

	void RepudiableRSASign(const TCTTokenObjectHandle& aObject, const TDesC8& aDigest, CRSASignature*& aSignature, TRequestStatus& aStatus);

	void CancelRepudiableRSASign();

	void Decrypt(const TCTTokenObjectHandle& aObject, const TDesC8& aCiphertext, TDes8& aPlaintext, TRequestStatus& aStatus);

	void CancelDecrypt();

	void DHPublicKey(const TCTTokenObjectHandle& aHandle, const TInteger& aN, const TInteger& aG, CDHPublicKey*& aX, TRequestStatus& aStatus);

	void DHAgree(const TCTTokenObjectHandle& aHandle, const CDHPublicKey& iY, HBufC8*& aAgreedKey, TRequestStatus& aStatus);

	void CancelDH();

public:

	// Called by CKeyStoreAuthObject

	void ListProtectedObjects(RMPointerArray<MCTTokenObject>& aObjects, TRequestStatus& aStatus);

	void ChangeReferenceData(TRequestStatus &aStatus);

	void CancelChangeReferenceData();

	TUint32 AuthStatus() const;

	void AuthOpen(TRequestStatus& aStatus);

	void CancelAuthOpen();

	void AuthClose(TRequestStatus& aStatus);

	void TimeRemaining(TInt& aStime, TRequestStatus& aStatus);

	void SetTimeout(TInt aTime, TRequestStatus& aStatus);

	void Timeout(TInt& aTime, TRequestStatus& aStatus);

protected:

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

//	From MCTTokenInterface

	virtual void DoRelease();

protected:

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

//	From CActive

protected:	

	virtual void RunL();

	virtual TInt RunError(TInt aError);

	virtual void DoCancel();

protected:

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

	CFSKeyStoreClient(TInt aUID, MCTToken& aToken, RFileStoreClientSession& aClient);

	virtual void ConstructL();

private:

	void DoListL(const TCTKeyAttributeFilter& aFilter, MKeyInfoArray& aOut);

	void DoGetKeyInfoL(TCTTokenObjectHandle aHandle, CCTKeyInfo*& aInfo);

	TInt DoOpenKey(TFSTokenMessages aMessage, const TCTTokenObjectHandle& aHandle, COpenedKey* aOpenedKey);

	void DoImportKey(TFSTokenMessages aMessage, const TDesC8& aKey, CCTKeyInfo*& aReturnedKey, TRequestStatus& aStatus);

	void DoExportPublicL(const TCTTokenObjectHandle& aHandle, HBufC8*& aPublicKey);

	TInt MarshalKeyInfo(CCTKeyInfo& aKey);

	void Process(const TCTTokenObjectHandle& aHandle,const TDesC8& aText,TFSTokenMessages aMessage,TRequestStatus& aStatus,TInt aBufSize);

	void DoDHPublicKeyL(const TCTTokenObjectHandle& aHandle, const TInteger& aN, const TInteger& aG, CDHPublicKey*& aX, TRequestStatus& aStatus);

private:

	TInt AllocKeyBuffer(TInt aReqdSize);

	void FreeKeyBuffer();

	void UpdateKey();

	TUint GetKeySizeL(TInt aObjectId);

	void Cleanup();

private:

	TInt iRefCount;

	//	Data holders for server to write into

	TPckgBuf<TInt> iIntOut;

	TInt iObjectId; 		// Id of object passed to server

private:

	/**

	 * Pointers to client pointers, which we set to return created objects.

	 * Only one of these is ever in use at any one time, determined by the

	 * state.

	 */

	union 

		{

		TAny* iAny;						///< generic pointer, used to zero the contents of the union

		CCTKeyInfo** iKeyInfo;			///< key info object, used for create and import

		HBufC8** iBuffer;				///< generic buffer, used for export key and DH agree

		TDes8* iDecryptedText;			///< decypled plaintext, used for RSA decrypt

		CDSASignature** iDSASignature;  ///< DSA signature

		CRSASignature** iRSASignature;	///< RSA signature

		CDHPublicKey** iDHPublicKey;	///< DH public key

		} iClientPtr;

private:

	HBufC8* iKey;						///< Key data buffer for import/export

	HBufC8* iText;						///< Buffer used to hold text for decrypt and sign

	CKeyStoreAuthObject* iAuthObject;   ///< The single auth object that serves as protector for all keys

	CDHParams* iDHParams;				///< DH params for DH public key

	HBufC8* iPbeParamsBuf;				///< Buffer holding PBE parameters for encrypted key export

};

#endif	//	__CFSKEYSTORECLIENT_H__