/*
* Copyright (c) 2006 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:   The header file of DevCertKeyStore
*
*/



#ifndef __DEVKEYSTORE_H__
#define __DEVKEYSTORE_H__

#include <mctkeystoremanager.h>
#include <ct/rmpointerarray.h>
#include "DTClient.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 CDevCertOpenedKey;
class MDevTokenKeyInfoArray;
class CDevTokenDHParams;


/**
 * Implements the MCTKeyStoreManager interface.  Inherits from CDTClient.
 *
 * 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.
 
 *  @lib DevTokenClient.dll
 *  @since S60 v3.2
 */
class CDevCertKeyStore : public CDTClient, public MCTKeyStoreManager
    {
    public:// One creator function for each token interface
        
        static MCTTokenInterface* NewKeyStoreUserInterfaceL(MCTToken& aToken, RDevTokenClientSession& aClient);
        
        static MCTTokenInterface* NewKeyStoreManagerInterfaceL(MCTToken& aToken, RDevTokenClientSession& aClient);
        
    public:
        
        virtual ~CDevCertKeyStore();
        
        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
         *
         * @param aHandle Handle to the key 
         * @param aSigner pointer to a RSA Signer
         * @param aStatus
         * @return 
         */
        virtual void Open(const TCTTokenObjectHandle& aHandle, 
                          MRSASigner*& aSigner,
                          TRequestStatus& aStatus);
        
        /**
         * Open an DSA key for signing
         *
         * @param aHandle Handle to the key 
         * @param aSigner pointer to a DSA Signer
         * @param aStatus
         * @return 
         */
        virtual void Open(const TCTTokenObjectHandle& aHandle, 
                          MDSASigner*& aSigner, 
                          TRequestStatus& aStatus);

        /**
         * Open a RSA key for private decryption
         *
         * @param aHandle Handle to the key 
         * @param aSigner pointer to a RSA Decryptor
         * @param aStatus
         * @return 
         */
        virtual void Open(const TCTTokenObjectHandle& aHandle, 
                          MCTDecryptor*& aDecryptor,
                          TRequestStatus& aStatus);
        
        /**
         * Open a DH key for key agreement
         *
         * @param aHandle Handle to the key 
         * @param aSigner pointer to a DH 
         * @param aStatus
         * @return 
         */
        virtual void Open(const TCTTokenObjectHandle& aHandle, 
                          MCTDH*& aDH, TRequestStatus& aStatus);
        
        /**
         * Cancels an ongoing open request
         *
         * @param 
         * @return 
         */
        virtual void CancelOpen();
        
        /**
         * Returns the public key in DER-encoded ASN-1
         *
         * @param aHandle handle to the public key
         * @param aPublicKey buffer for the public key
         * @param aStatus
         * @return 
         */
        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 RepudiableRSASign(const TCTTokenObjectHandle& aObject, const TDesC8& aDigest, CRSASignature*& aSignature, TRequestStatus& aStatus);
        
        void Decrypt(const TCTTokenObjectHandle& aObject, const TDesC8& aCiphertext, TDes8& aPlaintext, TRequestStatus& aStatus);
        
        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);

    protected:
        
        //  From MCTTokenInterface
        virtual void DoRelease();
        
    protected:
        
        //  From CActive
        virtual void RunL();
        
        virtual TInt RunError(TInt aError);
        
        virtual void DoCancel();
        
    protected:
        
        CDevCertKeyStore(TInt aUID, MCTToken& aToken, RDevTokenClientSession& aClient);
        
        virtual void ConstructL();
        
    private:
        
        void DoListL(const TCTKeyAttributeFilter& aFilter, MDevTokenKeyInfoArray& aOut);
        
        void DoGetKeyInfoL(TCTTokenObjectHandle aHandle, CCTKeyInfo*& aInfo);
        
        TInt DoOpenKey(TDevTokenMessages aMessage, const TCTTokenObjectHandle& aHandle, CDevCertOpenedKey* aOpenedKey);
        
        void DoImportKey(TDevTokenMessages 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,TDevTokenMessages 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
        
        CDevTokenDHParams* iDHParams;       // DH params for DH public key
        
    };

#endif  //  __DEVKEYSTORE_H__

//EOF