/*

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