1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:   The header file of DevCertKeyStoreConduit

    15 *

    16 */

    17 

    18 

    19 

    20 #ifndef __CDEVCERTKEYSTORECONDUIT_H__

    21 #define __CDEVCERTKEYSTORECONDUIT_H__

    22 

    23 #include <bigint.h>

    24 #include "DevTokenServer.h"

    25 

    26 class CDSASignature;

    27 class CRSASignature;

    28 class CDevCertKeyStoreServer;

    29 class CDevCertKeyStoreSession;

    30 class CDevCertRSARepudiableSigner;

    31 class CDevCertDSARepudiableSigner;

    32 class CDevCertRSADecryptor;

    33 class CDevTokenDHParams;

    34 class CDevCertOpenedKeySrv;

    35 class CDevTokenKeyInfo;

    36 class CDHPublicKey;

    37 

    38 /**

    39  * The key store server object (CDevtokenKeyStoreServer) owns one instance of this

    40  * object, which it calls for every client request.  This object unmarshalls the

    41  * client data and fulfills the request by calling back to the server object.

    42  * Any return information is then marshalled back to the client.

    43  *

    44  *  @lib

    45  *  @since S60 v3.2

    46  */

    47 class CDevCertKeyStoreConduit : public CActive

    48     {

    49     public:

    50         

    51         static CDevCertKeyStoreConduit* NewL(CDevCertKeyStoreServer& aServer);

    52         

    53         virtual ~CDevCertKeyStoreConduit();

    54     

    55     public:

    56         

    57         void ServiceRequestL(const RMessage2& aMessage, CDevCertKeyStoreSession& aSession);

    58     

    59     protected: 

    60         

    61         //  From CActive

    62         virtual void DoCancel();

    63         

    64         virtual void RunL();

    65         

    66         virtual TInt RunError(TInt aError);

    67     

    68     private:

    69         

    70         CDevCertKeyStoreConduit(CDevCertKeyStoreServer& aServer); 

    71         

    72         void ConstructL();

    73     

    74     private:

    75         

    76         CDevCertKeyStoreConduit(const CDevCertKeyStoreConduit&);        //  No copying

    77         

    78         CDevCertKeyStoreConduit& operator=(const CDevCertKeyStoreConduit&); //  No copying

    79     

    80     private:

    81         

    82         // For MKeyStore

    83         void ListL(const RMessage2& aMessage);

    84         

    85         void CancelList(const RMessage2& aMessage);

    86         

    87         void GetKeyInfoL(const RMessage2& aMessage);

    88         

    89         void CancelGetKeyInfo(const RMessage2& aMessage);

    90     

    91     private:

    92         

    93         // For MCTKeyStoreManager

    94         void CreateKeyL(const RMessage2& aMessage);

    95         

    96         void CancelCreateKey(const RMessage2& aMessage);

    97         

    98         void ImportKeyL(const RMessage2& aMessage);

    99         

   100         void CancelImportKey(const RMessage2& aMessage);

   101         

   102         void ExportKeyL(const RMessage2& aMessage); 

   103         

   104         void CancelExportKey(const RMessage2& aMessage);

   105         

   106         void ExportPublicL(const RMessage2& aMessage); 

   107         

   108         void CancelExportPublic(const RMessage2& aMessage);

   109         

   110         void DeleteKeyL(const RMessage2& aMessage);

   111         

   112         void SetUsePolicyL(const RMessage2& aMessage);

   113         

   114         void SetManagementPolicyL(const RMessage2& aMessage); 

   115         

   116         void OpenKeyL(const RMessage2& aMessage, CDevCertKeyStoreSession& aSession, TUid aType);

   117         

   118         void CloseObjectL(const RMessage2& aMessage, CDevCertKeyStoreSession& aSession);

   119     

   120     private:

   121         

   122         void GetKeyLengthL(const RMessage2& aMessage); 

   123         

   124         TUid GetClientUidL(const RMessage2& aMessage) const;

   125         

   126         void OpenKeyGetInfoL(const RMessage2& aMessage);

   127         

   128         void RepudiableDSASignL(const RMessage2& aMessage, CDevCertKeyStoreSession& aSession);

   129         

   130         void CancelDSASign(const RMessage2& aMessage);

   131         

   132         void RepudiableRSASignL(const RMessage2& aMessage, CDevCertKeyStoreSession& aSession);

   133         

   134         void CancelRSASign(const RMessage2& aMessage);

   135         

   136         void DecryptL(const RMessage2& aMessage, CDevCertKeyStoreSession& aSession);

   137         

   138         void CancelDecrypt(const RMessage2& aMessage);

   139         

   140         void DHPublicKeyL(const RMessage2& aMessage, CDevCertKeyStoreSession& aSession);

   141         

   142         void DoDHPublicKeyL(const RMessage2& aMessage, CDevCertKeyStoreSession& aSession);

   143         

   144         void FinishDHPublicKeyL();

   145         

   146         void DHAgreeL(const RMessage2& aMessage, CDevCertKeyStoreSession& aSession);

   147         

   148         void DoDHAgreeL(const RMessage2& aMessage, CDevCertKeyStoreSession& aSession);

   149         

   150         void FinishDHAgreeL();

   151         

   152         void CancelDH(const RMessage2& aMessage);

   153         

   154         CDevCertOpenedKeySrv* ProcessL(const RMessage2& aMessage, CDevCertKeyStoreSession& aSession,

   155         

   156         const TUid& aCKeyInfoID, const TDevTokenMessages& aState, TPtr8& aPtr);

   157         

   158         void FinishOpenL(const RMessage2& aMessage, CDevCertKeyStoreSession& aSession, CDevCertOpenedKeySrv& aOpenedKey);

   159         

   160         void Cleanup();

   161     

   162     private:

   163     

   164         /** 

   165          * Encapsulate data about the current request.

   166          */

   167         class TAsyncRequest

   168             {

   169             public:

   170                 

   171                 void Set(TDevTokenMessages aRequest, const RMessage2& aMessage);

   172                 

   173                 void Complete(TInt aResult);

   174                 

   175                 void Cancel();

   176             

   177             public:

   178                 

   179                 inline TDevTokenMessages OutstandingRequest() { return iRequest; }

   180                 

   181                 inline const RMessage2& Message() { return iMessage ;}

   182         

   183             public:

   184                 

   185                 TAsyncRequest(TRequestStatus& aStatus);

   186             

   187                 ~TAsyncRequest();

   188             

   189             private:

   190                 

   191                 TDevTokenMessages iRequest;

   192                 

   193                 RMessage2 iMessage;

   194                 

   195                 TRequestStatus& iOwnerStatus;

   196             };

   197              

   198     private:

   199     

   200         CDevCertKeyStoreServer& iServer;    // The server object used to execute client requests

   201 

   202         TAsyncRequest iCurrentRequest;      // The client request we are currently servicing

   203 

   204         HBufC8* iImportKey;           // Buffer for key imported key data 

   205 

   206         CDevTokenKeyInfo* iKeyInfo;       // Key info, used by create, import and export

   207 

   208         HBufC8* iText;              // Stores input data for sign and decrypt operations

   209 

   210         HBufC8* iExportBuf;           // Holds the exported key data

   211         

   212         CDevCertOpenedKeySrv* iOpenedKey;     // The key object for crypto operations

   213         

   214         CDSASignature* iDSASignature;     // Signature to return for DSA sign operation

   215         

   216         CRSASignature* iRSASignature;     // Signature to return for RSA sign operation

   217         

   218         CDevTokenDHParams* iDHParams;     // DH parameters for DU public key operation

   219         

   220         RInteger iDHPublicKeyOut;       // DH public key to return to client

   221         

   222         CDHPublicKey* iDHPublicKey;       // DH public key and params object for agree operation 

   223         

   224         HBufC8* iDHAgreedKeyOut;        // Agreed key to return to client

   225         

   226         HBufC8* iPlaintext;           // Buffer to hold decrypted data

   227     };

   228 

   229 #endif  //  __CDEVCERTKEYSTORECONDUIT_H__