diff -r 000000000000 -r 164170e6151a wim/WimPlugin/src/WimKeyStore.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/wim/WimPlugin/src/WimKeyStore.cpp	Tue Jan 26 15:20:08 2010 +0200
@@ -0,0 +1,946 @@
+/*
+* Copyright (c) 2002 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:  Implementation of Wim key store interface
+*
+*/
+
+
+// INCLUDE FILES
+
+#include "WimKeyStore.h"
+#include "WimKeyDetails.h"
+#include "WimToken.h"
+#include "WimPin.h"
+#include "WimAuthenticationObject.h"
+#include "WimTrace.h"
+#include "WimTokenListener.h"
+#include "WimImplementationUID.hrh"
+#include "WimRSASigner.h"
+#include "WimConsts.h"
+#include <mctauthobject.h>
+#include <ct.h>
+#include <asymmetric.h>
+
+
+// ============================ MEMBER FUNCTIONS ===============================
+
+// -----------------------------------------------------------------------------
+// CWimKeyStore::CWimKeyStore()
+// Default constructor
+// -----------------------------------------------------------------------------
+//
+CWimKeyStore::CWimKeyStore( CWimToken& aToken ) :
+                            CActive( EPriorityNormal ),
+                            iToken( aToken )
+
+    {
+    CActiveScheduler::Add( this );
+    }
+
+// -----------------------------------------------------------------------------
+// CWimKeyStore::NewL()
+// Two-phased constructor
+// -----------------------------------------------------------------------------
+//
+CWimKeyStore* CWimKeyStore::NewL( CWimToken& aToken )
+    {
+    _WIMTRACE ( _L( "CWimKeyStore::NewL()" ) );
+    CWimKeyStore* self = new( ELeave ) CWimKeyStore( aToken );
+    CleanupStack::PushL( self );
+    self->ConstructL();
+    CleanupStack::Pop( self );
+    return self;
+    }
+
+// -----------------------------------------------------------------------------
+// CWimKeyStore::ConstructL()
+// Second phase constructor
+// -----------------------------------------------------------------------------
+//
+void CWimKeyStore::ConstructL()
+    {
+    _WIMTRACE ( _L( "CWimKeyStore::ConstructL()" ) );
+    iCWimKeyDetails = CWimKeyDetails::NewL( Token() );
+    iKeyNumbers = new( ELeave )CArrayFixFlat<TUint8>(1);
+    iPhase = EIdle;
+    iPhaseOriginal = EIdle;
+    }
+
+// -----------------------------------------------------------------------------
+// CWimKeyStore::~CWimKeyStore()
+// Destructor
+// -----------------------------------------------------------------------------
+//
+CWimKeyStore::~CWimKeyStore()
+    {
+    _WIMTRACE ( _L( "CWimKeyStore::~CWimKeyStore()" ) );
+    Cancel();
+    TInt count = iKeyInfos.Count();
+    for ( TInt i = 0; i < count; i++ )
+        {
+        iKeyInfos[i]->Release();
+        }
+    iKeyInfos.Close();
+
+    if ( iKeyNumbers )
+        {
+        iKeyNumbers->Reset();
+        delete iKeyNumbers;
+        }
+
+    delete iSignature;
+
+    if ( iCWimKeyDetails )
+        {
+        delete iCWimKeyDetails;
+        iCWimKeyDetails = NULL;
+        }
+
+    delete iKeyId;
+    }
+// -----------------------------------------------------------------------------
+// CWimKeyStore::DoRelease()
+// Deletes this interface when Release() for this instance is called.
+// -----------------------------------------------------------------------------
+//
+void CWimKeyStore::DoRelease()
+    {
+    _WIMTRACE ( _L( "CWimKeyStore::DoRelease()" ) );
+    delete this;
+    }
+
+// -----------------------------------------------------------------------------
+// CWimKeyStore::Token()
+// Returns a reference to current token of this key store interface.
+// -----------------------------------------------------------------------------
+//
+MCTToken& CWimKeyStore::Token()
+    {
+    _WIMTRACE ( _L( "CWimKeyStore::Token()" ) );
+    return iToken;
+    }
+
+// -----------------------------------------------------------------------------
+// CWimKeyStore::List()
+// Lists all the keys in the store that match the filter.
+// -----------------------------------------------------------------------------
+//
+void CWimKeyStore::List( RMPointerArray<CCTKeyInfo>& aKeys,
+                         const TCTKeyAttributeFilter& aFilter,
+                         TRequestStatus& aStatus )
+    {
+    _WIMTRACE ( _L( "CWimKeyStore::List()" ) );
+
+    if ( !EnteringAllowed( aStatus ) )
+        {
+        return;
+        }
+
+    iKeyList = &aKeys;
+    iKeyFilter = aFilter;
+    iPhase = EGetKeyList;
+    iPhaseOriginal = EGetKeyList;
+    TRequestStatus* status = &iStatus;
+    User::RequestComplete( status, KErrNone );
+    SetActive();
+    }
+
+
+// -----------------------------------------------------------------------------
+// CWimKeyStore::Open()
+// Open an RSA key for signing
+// -----------------------------------------------------------------------------
+//
+void CWimKeyStore::Open( const TCTTokenObjectHandle& aHandle,
+                        MRSASigner*& aSigner,
+                        TRequestStatus& aStatus )
+    {
+    _WIMTRACE ( _L( "CWimKeyStore::Open()" ) );
+
+    if ( !EnteringAllowed( aStatus ) )
+        {
+        return;
+        }
+
+    //Check whether handle matches.
+    if ( aHandle.iTokenHandle == Token().Handle() )
+        {
+        TRAPD( err, iSigner = CWimRSASigner::NewL( *this ) );
+        if ( err ) //OOM
+            {
+            iPhase = EIdle;
+            User::RequestComplete( iOriginalRequestStatus, err );
+            }
+        else
+           {
+            aSigner = iSigner;
+            iOpenSigninKeyHandle = aHandle;
+            iPhase = ECreateRSASignerObject;
+            TRequestStatus* status = &iStatus;
+            User::RequestComplete( status, KErrNone );
+            SetActive();
+           }
+        }
+
+    else
+        {
+        User::RequestComplete( iOriginalRequestStatus, KErrArgument );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CWimKeyStore::CancelOpen()
+// Cancels an ongoing Open operation
+// -----------------------------------------------------------------------------
+//
+void CWimKeyStore::CancelOpen()
+    {
+    _WIMTRACE ( _L( "CWimKeyStore::CancelOpen()" ) );
+    Cancel();
+    }
+
+// -----------------------------------------------------------------------------
+// CWimKeyStore::ExportPublic()
+// Returns the public key in DER-encoded ASN-1.
+// -----------------------------------------------------------------------------
+//
+void CWimKeyStore::ExportPublic( const TCTTokenObjectHandle& aHandle,
+                                 HBufC8*& aPublicKey,
+                                 TRequestStatus& aStatus )
+    {
+    _WIMTRACE ( _L( "CWimKeyStore::ExportPublic()" ) );
+
+    if ( !EnteringAllowed( aStatus ) )
+        {
+        return;
+        }
+
+    if ( aHandle.iTokenHandle == Token().Handle() )
+        {
+    
+            TRAPD( err, iPublicKey = HBufC8::NewL( KPublicKeyLength ) );
+
+            if ( err )
+                {
+                User::RequestComplete( iOriginalRequestStatus, err );
+                }
+            else
+                {
+                iExportKeyIdIndex = aHandle.iObjectId;
+                aPublicKey = iPublicKey;
+                iPhase = EStartExportPublicKey;
+                TRequestStatus* status = &iStatus;
+                User::RequestComplete( status, KErrNone );
+                SetActive();
+                }
+         
+           
+        }
+    else
+        {
+        User::RequestComplete( iOriginalRequestStatus, KErrBadHandle );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CWimKeyStore::CancelExportPublic()
+// Cancels an ongoing Export operation.
+// -----------------------------------------------------------------------------
+//
+void CWimKeyStore::CancelExportPublic()
+    {
+    _WIMTRACE ( _L( "CWimKeyStore::CancelExportPublic()" ) );
+    Cancel();
+    }
+
+// -----------------------------------------------------------------------------
+// CWimKeyStore::Open()
+//Open an DSA key for signing. Not Supported.
+// -----------------------------------------------------------------------------
+//
+void CWimKeyStore::Open( const TCTTokenObjectHandle& /*aHandle*/,
+                         MDSASigner*& /*aSigner*/,
+                         TRequestStatus& aStatus )
+    {
+    _WIMTRACE ( _L( "CWimKeyStore::Open()" ) );
+    TRequestStatus* stat = &aStatus;
+    User::RequestComplete(stat, KErrNotSupported );
+    }
+
+// -----------------------------------------------------------------------------
+// CWimKeyStore::Open()
+// Open a RSA key for private decryption. Not Supported.
+// -----------------------------------------------------------------------------
+//
+void CWimKeyStore::Open( const TCTTokenObjectHandle& /*aHandle*/,
+                         MCTDecryptor*& /*aDecryptor*/,
+                         TRequestStatus& aStatus )
+    {
+    _WIMTRACE ( _L( "CWimKeyStore::Open()" ) );
+    TRequestStatus* stat = &aStatus;
+    User::RequestComplete( stat, KErrNotSupported );
+    }
+
+// -----------------------------------------------------------------------------
+// CWimKeyStore::Open()
+// Open a DH key for key agreement. Not Supported.
+// -----------------------------------------------------------------------------
+//
+void CWimKeyStore::Open( const TCTTokenObjectHandle& /*aHandle*/,
+                         MCTDH*& /*aDH*/,
+                         TRequestStatus& aStatus )
+    {
+    _WIMTRACE ( _L( "CWimKeyStore::Open()" ) );
+    TRequestStatus* stat = &aStatus;
+    User::RequestComplete( stat, KErrNotSupported );
+    }
+
+// -----------------------------------------------------------------------------
+// void CWimKeyStore::RunL()
+// Core operations are done here.
+// -----------------------------------------------------------------------------
+//
+void CWimKeyStore::RunL()
+    {
+    _WIMTRACE ( _L( "CWimKeyStore::RunL()" ) );
+
+    if ( !iListDone &&
+         iPhase != EGetKeyList &&
+         iPhase != ECheckGetKeyList )
+        {
+        iPhaseOriginal = iPhase;
+        iPhase = EGetKeyList;
+        TRequestStatus* status = &iStatus;
+        User::RequestComplete( status, KErrNone );
+        SetActive();
+        }
+    else
+        {
+        switch ( iPhase )
+            {
+        case EGetKeyList:
+            {
+            TInt count = iKeyInfos.Count();
+
+            for ( TInt i = 0; i < count; i++ )
+                {
+                iKeyInfos[i]->Release();
+                }
+
+            iKeyInfos.Reset();
+            delete iCWimKeyDetails;
+            iCWimKeyDetails = NULL;
+            iKeyNumbers->Reset();
+            iCWimKeyDetails = CWimKeyDetails::NewL( Token() );
+            iStatus = KRequestPending;
+            iPhase = ECheckGetKeyList;
+            iCWimKeyDetails->GetKeyList( iKeyInfos, *iKeyNumbers, iStatus );
+            SetActive();
+            break;
+            }
+        case ECheckGetKeyList:
+            {
+            if ( iStatus.Int() == KErrNone )
+                {
+                iListDone = ETrue;
+                iKeyIndex = 0;
+                iPhase = EFilterKeys;
+                TRequestStatus* status = &iStatus;
+                User::RequestComplete( status, KErrNone );
+                SetActive();
+                }
+            else // No keys found or iWimKeyDetails->Restore call has
+                 // been cancelled or failed
+                {
+                iPhase = EIdle;
+                iPhaseOriginal = EIdle;
+                User::RequestComplete( iOriginalRequestStatus, iStatus.Int() );
+                }
+            break;
+            }
+        case EFilterKeys:
+            {
+            DoFilterKeysL();
+            break;
+            }
+        case EGetKey:
+            {
+            TInt count = iKeyInfos.Count();
+            TInt i;
+
+            for ( i = 0; i < count; i++ )
+                {
+                if ( iKeyInfos[i]->Handle().iObjectId == iHandle )
+                    {
+                    // Make a copy of key info
+                    *iInfo = CreateKeyInfoL( i );
+                    i = count + 1;
+                    }
+                }
+            if ( i == count )
+                {
+                User::RequestComplete( iOriginalRequestStatus, KErrNotFound );
+                }
+            else
+                {
+                User::RequestComplete( iOriginalRequestStatus, KErrNone );
+                }
+            iPhase = EIdle;
+            iPhaseOriginal = EIdle;
+            break;  
+            }
+            
+        case ECreateRSASignerObject:
+            {
+            TBool found = EFalse;
+            TInt i;
+
+            for ( i = 0; i<iKeyInfos.Count() && !found; i++ )
+                {
+                //Check if the handle matches.
+                if ( iKeyInfos[i]->Handle().iObjectId ==
+                    iOpenSigninKeyHandle.iObjectId )
+                    {
+                    found = ETrue;
+                    }
+                if ( found )
+                    {
+                    //Check whether found key can do RSA sign.
+                    if ( iKeyInfos[i]->Algorithm() != CKeyInfoBase::ERSA )
+                        {
+                        //Set flag to false, the key does not do RSA sign.
+                        found = EFalse;
+                        }
+                    else
+                        {
+                        //Set label for new signing key
+                        iSigner->SetLabelL( iKeyInfos[i]->Label() );
+                        //Set objectId
+                        iSigner->SetObjectId( iKeyInfos[i]->Handle().iObjectId );
+                        }
+                    }
+                }
+            if ( found )
+                {
+                User::RequestComplete( iOriginalRequestStatus, KErrNone );
+                }
+            else
+                {
+                delete iSigner;
+                iSigner = NULL;
+                User::RequestComplete( iOriginalRequestStatus, KErrBadHandle );
+                }
+            iPhase = EIdle;
+            iPhaseOriginal = EIdle;
+            break;
+            }
+        case EStartNonRepudiableRSASign:
+            {
+            TBool found = EFalse;
+            TInt i = 0;
+
+            for ( ; i < iKeyInfos.Count() && !found; i++ )
+                {
+                 if ( iKeyInfos.operator[]( i )->Handle().iObjectId ==
+                 iRSAKeyIdIndex )
+                     {
+                     found = ETrue;
+                     TRAPD( err, iKeyId = iKeyInfos[i]->ID().AllocL() )
+
+                     if ( err )
+                         {
+                         User::RequestComplete( iOriginalRequestStatus, err );
+                         }
+                     else
+                         {
+                         iCWimKeyDetails->Sign( *iDigest,
+                                        *iKeyId,
+                                        iSignature,
+                                        iStatus );
+                         iPhase = ESignCompleted;
+                         SetActive();
+                         }
+                     }
+                }
+            //Key was not found, no need for signature
+           if ( !found )
+              {
+              iPhase = EIdle;
+              iPhaseOriginal = EIdle;
+              delete iSignature;
+              iSignature = NULL;
+              User::RequestComplete( iOriginalRequestStatus, KErrBadHandle );
+              }
+        	break;
+            }
+        case ESignCompleted:
+            {
+            //No need for KeyId anymore
+            delete iKeyId;
+            iKeyId = NULL;
+
+            //Check whether signing failed
+            if ( iStatus.Int() != KErrNone )
+                {
+                delete iSignature;
+                iSignature = NULL;
+                User::RequestComplete( iOriginalRequestStatus, iStatus.Int() );
+                }
+            else //Sign was succesful.
+                {
+                 //Create signature and complete operation
+                RInteger signature = RInteger::NewL( *iSignature );
+                CleanupStack::PushL( signature );
+                *iRSASignature = CRSASignature::NewL( signature );
+                CleanupStack::Pop();
+                delete iSignature;
+                iSignature = NULL;
+                User::RequestComplete( iOriginalRequestStatus, iStatus.Int() );
+                }
+            iPhase = EIdle;
+            iPhaseOriginal = EIdle;
+            break;
+            }
+        case EStartExportPublicKey:
+            {
+            TInt i = 0;
+            TBool found = EFalse;
+            
+            for( i = 0; i < iKeyInfos.Count() && !found; i++ )
+                {
+            	//Check if the objectIds matches
+            	if( iKeyInfos[i]->Handle().iObjectId == iExportKeyIdIndex )
+            	    {
+            		found = ETrue;
+            	    }	
+                }
+               
+            if( !found )
+                {
+            	iPhase = EIdle;
+            	iPhaseOriginal = EIdle;
+            	delete iPublicKey;
+            	iPublicKey = NULL;
+            	User::RequestComplete( iOriginalRequestStatus, KErrNotFound );
+                }
+            else
+                {
+            	iKeyId = iKeyInfos[iExportKeyIdIndex]->ID().AllocL();
+                iCWimKeyDetails->ExportPublicKeyL( *iKeyId,
+                                               iPublicKey,
+                                               iStatus );
+
+                iPhase = EExportPublicKeyDone;
+                SetActive();
+                }
+            
+            break;
+            }
+        case EExportPublicKeyDone:
+            {
+            delete iKeyId;
+            iKeyId = NULL;
+            iPhase = EIdle;
+            iPhaseOriginal = EIdle;
+            User::RequestComplete( iOriginalRequestStatus, iStatus.Int() );
+            break;
+            }
+        default:
+            {
+            // Here we should not be
+            iPhase = EIdle;
+            iPhaseOriginal = EIdle;
+            User::RequestComplete( iOriginalRequestStatus, KErrCorrupt );
+            break;
+            }
+        }
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CWimKeyStore::NonRepudiableRSASign()
+// Perform signing operation
+// -----------------------------------------------------------------------------
+//
+void CWimKeyStore::NonRepudiableRSASign( const TCTTokenObjectHandle& aHandle,
+                                         const TDesC8& aDigest,
+                                         CRSASignature*& aSignature,
+                                         TRequestStatus& aStatus )
+    {
+    _WIMTRACE ( _L( "CWimKeyStore::NonRepudiableRSASign()" ) );
+
+    if ( !EnteringAllowed( aStatus ) )
+        {
+        return;
+        }
+
+    TRAPD( err, iSignature = HBufC8::NewL( KMaxSignatureLength ) );
+
+    if ( err ) //OOM
+        {
+        User::RequestComplete( iOriginalRequestStatus, err );
+        return;
+        }
+
+    iRSASignature = &aSignature;
+    iRSAKeyIdIndex = aHandle.iObjectId;
+    iDigest = &aDigest;
+
+    iPhase = EStartNonRepudiableRSASign;
+    TRequestStatus* status = &iStatus;
+    User::RequestComplete( status, KErrNone );
+    SetActive();
+    }
+
+// -----------------------------------------------------------------------------
+// void CWimKeyStore::DoFilterKeysL()
+// Core operations are done here.
+// -----------------------------------------------------------------------------
+//
+void CWimKeyStore::DoFilterKeysL()
+    {
+    _WIMTRACE ( _L( "CWimKeyStore::DoFilterKeysL()" ) );
+    if ( iPhaseOriginal == EGetKeyList )
+        {
+        if ( iKeyIndex < iKeyInfos.Count() )
+            {
+            // If usage is given in filter and handled key (in iKeyIndex) has
+            // also same usage, take with
+            //
+            // OR, (if filter usage is 0 or EAllKeyUsages) AND handled key
+            // usage is also 0 AND (key id length in filter is 0 OR handled
+            // key id is equal to key id in filter), take with
+            //
+            if ( ( ( iKeyFilter.iUsage & iKeyInfos[iKeyIndex]->Usage() ) ||
+               ( ( ( iKeyFilter.iUsage == 0 ) || ( iKeyFilter.iUsage ==
+               EPKCS15UsageAll ) ) &&
+               ( iKeyInfos[iKeyIndex]->Usage() == 0 ) ) ) &&
+               ( iKeyFilter.iKeyId.Length() == 0 ||
+                !iKeyInfos[iKeyIndex]->ID().Compare( iKeyFilter.iKeyId ) ) )
+                {
+                // Make a copy of key info
+                CCTKeyInfo* copy = CreateKeyInfoL( iKeyIndex );
+                // Call Release() for copy, if leave occurs
+                CleanupReleasePushL( *copy );
+                User::LeaveIfError( iKeyList->Append ( copy ) );
+                CleanupStack::Pop( copy );
+                }
+            iKeyIndex++;
+            TRequestStatus* status = &iStatus;
+            User::RequestComplete( status, KErrNone );
+            SetActive();
+            }
+        else
+            {
+            // All keys are listed or there are not any
+            iPhase = EIdle;
+            iPhaseOriginal = EIdle;
+            User::RequestComplete( iOriginalRequestStatus, KErrNone );
+            }
+        }
+    else
+        {
+        iPhase = iPhaseOriginal;
+        iPhaseOriginal = EIdle;
+        TRequestStatus* status = &iStatus;
+        User::RequestComplete( status, KErrNone );
+        SetActive();
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// void CWimKeyStore::CreateKeyInfoL()
+// Creates a new key info from internal array.
+// -----------------------------------------------------------------------------
+//
+CCTKeyInfo* CWimKeyStore::CreateKeyInfoL( TInt aIndex )
+    {
+    _WIMTRACE ( _L( "CWimKeyStore::CreateKeyInfoL()" ) );
+    // Create protector
+    MCTAuthenticationObject* protector = NULL;
+    TUint thishandle = iKeyNumbers->At ( aIndex );
+    protector = MakeAuthObjectL( thishandle );
+    
+    if ( protector )
+        {
+        CleanupStack::PushL( protector );
+        }
+
+    HBufC* wlabel = HBufC::NewLC( ( iKeyInfos )[aIndex]->Label().Length() );
+    wlabel->Des().Copy( ( iKeyInfos )[aIndex]->Label() );
+
+#ifdef __SECURITY_PLATSEC_ARCH__
+    CCTKeyInfo* copy = CCTKeyInfo::NewL( ( iKeyInfos ) [aIndex]->ID(),
+                                         ( iKeyInfos ) [aIndex]->Usage(),
+                                         ( iKeyInfos ) [aIndex]->Size(),
+                                         protector,
+                                         wlabel,
+                                         ( iKeyInfos ) [aIndex]->Token(),
+                                         ( iKeyInfos ) [aIndex]->Handle().iObjectId,
+                                         ( iKeyInfos ) [aIndex]->UsePolicy(),
+                                         ( iKeyInfos ) [aIndex]->ManagementPolicy(),
+                                         ( iKeyInfos ) [aIndex]->Algorithm(),
+                                         ( iKeyInfos ) [aIndex]->AccessType(),
+                                         ( iKeyInfos ) [aIndex]->Native(),
+                                         ( iKeyInfos ) [aIndex]->StartDate(),
+                                         ( iKeyInfos ) [aIndex]->EndDate() );
+#else
+   CCTKeyInfo* copy = CCTKeyInfo::NewL( ( iKeyInfos ) [aIndex]->ID(),
+                                         ( iKeyInfos ) [aIndex]->Usage(),
+                                         ( iKeyInfos ) [aIndex]->Size(),
+                                         protector,
+                                         wlabel,
+                                         ( iKeyInfos ) [aIndex]->Token(),
+                                         ( iKeyInfos ) [aIndex]->Handle().iObjectId,
+                                         ( iKeyInfos ) [aIndex]->Owner(),
+                                         ( iKeyInfos ) [aIndex]->Users(),
+                                         ( iKeyInfos ) [aIndex]->Algorithm(),
+                                         ( iKeyInfos ) [aIndex]->AccessType(),
+                                         ( iKeyInfos ) [aIndex]->Native(),
+                                         ( iKeyInfos ) [aIndex]->StartDate(),
+                                         ( iKeyInfos ) [aIndex]->EndDate() );
+#endif
+
+    CleanupStack::Pop( wlabel );
+    if ( protector )
+        {
+        CleanupStack::Pop( protector );
+        }
+    return copy;
+    }
+
+// -----------------------------------------------------------------------------
+// void CWimKeyStore::MakeAuthObjectL()
+// Lists authentication objects and matches each on given handle.
+// When match is found, one instance is created and returned.
+// -----------------------------------------------------------------------------
+//
+MCTAuthenticationObject* CWimKeyStore::MakeAuthObjectL( TInt aHandle )
+    {
+    
+    if( !iPinNRs )
+	    {
+	    TInt ret = iToken.WimSecModule()->PinNrEntriesL( iPinNRs );
+	   
+	    if ( ret != KErrNone )
+	        {
+	        User::Leave( ret );
+	        }	
+	    }
+    
+        
+    if ( iPinNRs ) // If PINs were found
+        {
+        TUid pintype = {WIM_PIN_G_UID}; // The first one is always PIN-G
+        TInt count = iPinNRs->Count();
+        TUint32 status = 0;
+
+        for ( TInt i = 0; i < count; i++ )
+            {
+            if ( aHandle == (*iPinNRs)[i]->PinNumber() )
+                {
+                CWimAuthenticationObject* me =
+                        CWimAuthenticationObject::NewLC(
+                                            iToken,
+                                         *( *iPinNRs )[i],
+                                          ( *iPinNRs )[i]->Label(),
+                                             pintype,
+                                          ( *iPinNRs )[i]->PinNumber(),
+                                             status );
+                 CleanupStack::Pop( me );
+                 return me;
+                }
+            pintype.iUid = WIM_PIN_NR_UID; // The others are always PIN-NRs
+            }
+        }
+    return NULL;    
+    }
+// -----------------------------------------------------------------------------
+// void CWimKeyStore::RunError()
+// Unexpected error in RunL (e.g. Leave) leads us here.
+// -----------------------------------------------------------------------------
+//
+TInt CWimKeyStore::RunError( TInt aError )
+    {
+    _WIMTRACE ( _L( "CWimKeyStore::RunError()" ) );
+
+    iPhase = EIdle;
+    iPhaseOriginal = EIdle;
+    User::RequestComplete( iOriginalRequestStatus, aError );
+    return KErrNone;
+    }
+
+// -----------------------------------------------------------------------------
+// void CWimKeyStore::DoCancel()
+// Cancels outgoing async. calls.
+// -----------------------------------------------------------------------------
+//
+void CWimKeyStore::DoCancel()
+    {
+    _WIMTRACE ( _L( "CWimKeyStore::DoCancel()" ) );
+
+    if ( iCWimKeyDetails && iPhase == ECheckGetKeyList )
+        {
+        if ( iCWimKeyDetails->IsActive() )
+            {
+            iCWimKeyDetails->CancelList();
+            }
+        }
+    else if ( iCWimKeyDetails && iPhase == ESignCompleted )
+        {
+        if ( iCWimKeyDetails->IsActive() )
+            {
+            iCWimKeyDetails->CancelSign();
+            delete iSignature;
+            iSignature = NULL;
+            }
+        }
+    else if ( iCWimKeyDetails && iPhase == EExportPublicKeyDone )
+        {
+        if ( iCWimKeyDetails->IsActive() )
+            {
+            iCWimKeyDetails->CancelExport();
+            }
+        }
+    iPhase = EIdle;
+    iPhaseOriginal = EIdle;
+    delete iKeyId;
+    iKeyId = NULL;
+    User::RequestComplete( iOriginalRequestStatus, KErrCancel );
+    }
+
+// -----------------------------------------------------------------------------
+// CWimKeyStore::CancelList()
+// Cancels an ongoing List operation. Sets an internal flag to true.
+// -----------------------------------------------------------------------------
+//
+void CWimKeyStore::CancelList()
+    {
+    _WIMTRACE ( _L( "CWimKeyStore::CancelList()" ) );
+
+    if ( TokenRemoved() )
+        {
+        return;
+        }
+
+    Cancel();
+    }
+
+// -----------------------------------------------------------------------------
+// CWimKeyStore::GetKeyInfo()
+// Retrieves a key according to given handle.
+// -----------------------------------------------------------------------------
+//
+void CWimKeyStore::GetKeyInfo( TCTTokenObjectHandle aHandle,
+                               CCTKeyInfo*& aInfo,
+                               TRequestStatus& aStatus )
+    {
+    _WIMTRACE ( _L( "CWimKeyStore::GetKeyInfo()" ) );
+
+    if ( !EnteringAllowed( aStatus ) )
+        {
+        return;
+        }
+
+    if ( aHandle.iTokenHandle == Token().Handle() )
+        {
+        iInfo = &aInfo;
+        iHandle = aHandle.iObjectId;
+        iPhase = EGetKey;
+        TRequestStatus* status = &iStatus;
+        User::RequestComplete( status, KErrNone );
+        SetActive();
+        }
+    else
+        {
+        User::RequestComplete( iOriginalRequestStatus, KErrArgument );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CWimKeyStore::CancelGetKeyInfo()
+// Cancels an ongoing GetKeyInfo operation.
+// -----------------------------------------------------------------------------
+//
+void CWimKeyStore::CancelGetKeyInfo()
+    {
+    _WIMTRACE ( _L( "CWimKeyStore::CancelGetKeyInfo()" ) );
+
+    if ( TokenRemoved() )
+        {
+        return;
+        }
+
+    Cancel();
+    }
+
+// -----------------------------------------------------------------------------
+// CWimKeyStore::EnteringAllowed()
+//
+// -----------------------------------------------------------------------------
+//
+TBool CWimKeyStore::EnteringAllowed( TRequestStatus& aStatus )
+    {
+    _WIMTRACE ( _L( "CWimKeyStore::EnteringAllowed()" ) );
+    if ( TokenRemoved() )
+        {
+        TRequestStatus* status = &aStatus;
+        User::RequestComplete( status, KErrHardwareNotAvailable );
+        return EFalse;
+        }
+
+    // If this active object is in running, don't accept entering
+    if ( IsActive() )
+        {
+        // If the caller status is the same as the status, that activated
+        // this object, just return
+        if ( &aStatus == iOriginalRequestStatus )
+            {
+            return EFalse;
+            }
+        else
+            {
+            // Otherwise complete it with error
+            TRequestStatus* status = &aStatus;
+            User::RequestComplete( status, KErrInUse );
+            return EFalse;
+            }
+        }
+    else
+        {
+        iOriginalRequestStatus = &aStatus;
+        aStatus = KRequestPending;
+        return ETrue;
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CWimKeyStore::TokenRemoved()
+// Returns true or false indicating if token is removed
+// -----------------------------------------------------------------------------
+//
+TBool CWimKeyStore::TokenRemoved()
+    {
+    _WIMTRACE ( _L( "CWimKeyStore::TokenRemoved()" ) );
+    // If token listener is not alive, then token is removed
+    if ( iToken.TokenListener()->TokenStatus() != KRequestPending )
+        {
+        return ETrue;
+        }
+    else
+        {
+        return EFalse;
+        }
+    }
+