/*

* Copyright (c) 2002-2009 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:  Certificate management methods

*

*/

// INCLUDE FILES

#include    "Wimi.h"            // wimi definitions

#include    "WimCertHandler.h"

#include    "WimMemMgmt.h"

#include    "WimSession.h"

#include    "WimResponse.h"

#include    "WimUtilityFuncs.h"

#include    <asn1enc.h>         // asn.1 encoding

#include    <asn1dec.h>         // asn.1 decoding

#include    <x509cert.h>        // cx509certificate

#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS

#include    <x509keys.h>        // cx509rsapublickey

#else

#include    <x509keys.h>        // cx509rsapublickey

#include    <x509keyencoder.h>        // cx509rsapublickey

#endif

#include    <wtlscert.h>        // cwtlscertificate

#include    <wtlskeys.h>        // cwtlsrsapublickey

#include    "WimTrace.h"

#include    "WimCallbackImpl.h"

#include    "WimCleanup.h"

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CWimCertHandler::CWimCertHandler

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

//

CWimCertHandler::CWimCertHandler()

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimCertHandler::CWimCertHandler | Begin"));

    }

// -----------------------------------------------------------------------------

// CWimCertHandler::ConstructL

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

void CWimCertHandler::ConstructL()

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimCertHandler::ConstructL | Begin"));

    iWimUtilFuncs = CWimUtilityFuncs::NewL();

    }

// -----------------------------------------------------------------------------

// CWimCertHandler::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CWimCertHandler* CWimCertHandler::NewL() 

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimCertHandler::NewL | Begin"));

    CWimCertHandler* self = new( ELeave ) CWimCertHandler;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

CWimCertHandler::~CWimCertHandler()

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimCertHandler::~CWimCertHandler | Begin"));

    delete iWimUtilFuncs;

    for( TInt index = 0; index < iCertRefLst.Count(); ++index )

        {

        WIMI_Ref_t* ref = reinterpret_cast< WIMI_Ref_t* >( iCertRefLst[ index ] );

        _WIMTRACE2(_L("WIM | WIMServer | CWimCertHandler::~CWimCertHandler, -ref 0x%08x"), ref);

        free_WIMI_Ref_t( ref );

        iCertRefLst[ index ] = 0;

        }

    iCertRefLst.Reset();

    }

// -----------------------------------------------------------------------------

// CWimCertHandler::GetCertificatesFromWimL

// Fetches certificates from WIM card.

// -----------------------------------------------------------------------------

//

void CWimCertHandler::GetCertificatesFromWimL(

    const RMessage2& aMessage, 

    CWimMemMgmt* aWimMgmt )

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimCertHandler::GetCertificatesFromWimL | Begin"));

    WIMI_STAT callStatus = WIMI_Ok;

    TUint8 certNum = 0;

    WIMI_Ref_t* temp = NULL;

    HBufC8* certRefLst = iWimUtilFuncs->DesLC( 0, aMessage );

    HBufC8* certInfoLst = iWimUtilFuncs->DesLC( 1, aMessage );

    TWimEntryType certEntryType = ( TWimEntryType ) aMessage.Int2();

    TUint32* pCertRefLst = ( TUint32* )( certRefLst->Des().Ptr() );

    TWimCertInfo* pCertInfoLst = ( TWimCertInfo* )( certInfoLst->Des().Ptr() );

    temp = aWimMgmt->WimRef();

    if ( !temp )

        { 

        temp = WIMI_GetWIMRef( 0 );

        aWimMgmt->SetWIMRef( temp );    // takes ownership

        }

    if ( temp )

        {

        if ( EWimEntryTypeAll == certEntryType || 

             EWimEntryTypeCA == certEntryType )

            {

            callStatus = GetCertificateFromWimRefL( temp, WIMI_CU_CA,

                                                    certNum, pCertRefLst,

                                                    pCertInfoLst, aMessage );

            }

        if ( callStatus == WIMI_Ok && ( EWimEntryTypeAll == certEntryType || 

                                   EWimEntryTypePersonal == certEntryType ) )

            {

            callStatus = GetCertificateFromWimRefL( temp, WIMI_CU_Client,

                                                    certNum, pCertRefLst,

                                                    pCertInfoLst, aMessage );

            }

        //record the ref for sanity checking, deallocate old refs first

        for( TInt index = 0; index < iCertRefLst.Count(); ++index )

            {

            WIMI_Ref_t* ref = reinterpret_cast< WIMI_Ref_t* >( iCertRefLst[ index ] );

            _WIMTRACE2(_L("WIM | WIMServer | CWimCertHandler::GetCertificatesFromWimL, -ref 0x%08x"), ref);

            free_WIMI_Ref_t( ref );

            iCertRefLst[ index ] = 0;

            }

        iCertRefLst.Reset();

        for( TInt index = 0; index < certNum; ++index )

            {

            _WIMTRACE2(_L("WIM | WIMServer | CWimCertHandler::GetCertificatesFromWimL, +ref 0x%08x"), pCertRefLst[ index ]);

            iCertRefLst.AppendL( pCertRefLst[ index ] );

            }

        aMessage.WriteL( 0, certRefLst->Des() );

        aMessage.WriteL( 1, certInfoLst->Des() );

        }

    else

        {

        callStatus = WIMI_ERR_OutOfMemory;

        }

    CleanupStack::PopAndDestroy( 2, certRefLst );   // certInfoLst, certRefLst

    aMessage.Complete( CWimUtilityFuncs::MapWIMError( callStatus ) );

    }

// -----------------------------------------------------------------------------

// CWimCertHandler::GetCertificateFromWimRefL

// Fetches certificate from the WIM card.

// -----------------------------------------------------------------------------

//

WIMI_STAT CWimCertHandler::GetCertificateFromWimRefL(

    WIMI_Ref_t* aTmpWimRef,

    TInt8 aUsage,

    TUint8& aCertNum,

    TUint32* aCertRefLst,

    TWimCertInfo* aCertInfoLst,

    const RMessage2& aMessage )

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimCertHandler::GetCertificateFromWimRefL | Begin"));

    TUint8 tempCrtCount;

    WIMI_RefList_t refList = NULL;

    WIMI_STAT callStatus = WIMI_Ok;

    if ( aTmpWimRef )

        {

        callStatus = WIMI_GetCertificateListByWIM( aTmpWimRef, 

                                                   aUsage, 

                                                   &tempCrtCount, 

                                                   &refList );

        if ( callStatus == WIMI_Ok )

            {

            // If the certifcate length is 0,

            // the step increases by 1.

            TInt step = 0;

            TInt err = KErrNone;

            for ( TUint8 certIndex = 0; certIndex < tempCrtCount; certIndex++ )

                {

                TInt current = aCertNum + certIndex - step;

                err = CopyCertificateInfo( aCertInfoLst[current], refList[certIndex], aMessage );

                if ( err == KErrNone )

                    {

                    // transfers ownership of refList item to aCertRefLst

                    aCertRefLst[current] = reinterpret_cast< TUint32 >( refList[certIndex] );

                    refList[certIndex] = NULL;

                    }

                else // KErrArgument

                    {

                    // ingore certificate info and continue with the next

                	step++;

                    free_WIMI_Ref_t( refList[certIndex] );

                    }

                }

            //variable step is equal to the number of certificate in CDF whose 

            //length is set as 0.     

            aCertNum = static_cast< TUint8 >( aCertNum + tempCrtCount - step );

            // Because list items are moved to aCertRefLst, only refList array

            // needs to be freed. Cannot use free_WIMI_RefList_t() as it would

            // delete also items contained in refList.

            WSL_OS_Free( refList );

            }

        }

    return callStatus;

    }

// -----------------------------------------------------------------------------

// CWimCertHandler::CopyCertificateInfo

// Copies certificate information to client's allocated memory area.

// This function MAY NOT leave.

// -----------------------------------------------------------------------------

//

TInt CWimCertHandler::CopyCertificateInfo(

    TWimCertInfo& aCertInfo,

    WIMI_Ref_t* aCert,

    const RMessage2& /*aMessage*/ )

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimCertHandler::CopyCertificateInfo | Begin"));

    WIMI_Ref_t* tempRef = NULL;

    WIMI_BinData_t ptLabel;

    WIMI_BinData_t ptKeyID;

    WIMI_BinData_t ptCAID;

    WIMI_BinData_t ptIssuerHash;

    WIMI_BinData_t ptTrustedUsage;

    TUint8 uiCDFRefs;

    TUint8 usage;

    TUint8 type;

    TUint16 certLen;

    TUint8 modifiable = 0;

    WIMI_STAT callStatus = WIMI_GetCertificateInfo( 

                                aCert,

                                &tempRef,

                                &ptLabel,

                                &ptKeyID, /* Key Id (hash)*/

                                &ptCAID,

                                &ptIssuerHash,

                                &ptTrustedUsage,

                                &uiCDFRefs,

                                &usage,  /* 0 = client, 1 = CA */

                                &type,   /* WTLSCert(1), 

                                            X509Cert(2), 

                                            X968Cert(3), 

                                            CertURL(4) */ 

                                &certLen,   /* cert. content or URL length */

                                &modifiable );

    if ( callStatus == WIMI_Ok )

        {

        free_WIMI_Ref_t( tempRef );

        // To make sure the length of the certificate is not zero

        _WIMTRACE2(_L("WIM | WIMServer | CWimCertHandler::CopyCertificateInfoL | certLen %d"), certLen);

        if ( certLen == 0 )

            {

            WSL_OS_Free( ptLabel.pb_buf );

            WSL_OS_Free( ptKeyID.pb_buf );

            WSL_OS_Free( ptCAID.pb_buf );

            WSL_OS_Free( ptIssuerHash.pb_buf );

            WSL_OS_Free( ptTrustedUsage.pb_buf );

        	return KErrArgument;

            }

        // it is x509cert

        if ( type == 2 && certLen != 0 )

            {

            //use this rough sanity checking for temp

            if ( certLen < 10 )

                {

                _WIMTRACE(_L("WIM | WIMServer | CWimCertHandler::CopyCertificateInfoL | cert is malformated, return KErrArgument"));

                WSL_OS_Free( ptLabel.pb_buf );

                WSL_OS_Free( ptKeyID.pb_buf );

                WSL_OS_Free( ptCAID.pb_buf );

                WSL_OS_Free( ptIssuerHash.pb_buf );

                WSL_OS_Free( ptTrustedUsage.pb_buf );

                return KErrArgument;

                }

            }

        _WIMTRACE(_L("WIM | WIMServer | CWimCertHandler::CopyCertificateInfoL | X509 check ok"));

        aCertInfo.iLabel.Copy(

            TPtr8(

                ptLabel.pb_buf, 

                ptLabel.ui_buf_length, 

                ptLabel.ui_buf_length ) );

        aCertInfo.iKeyId.Copy(

            TPtr8(

                ptKeyID.pb_buf, 

                ptKeyID.ui_buf_length, 

                ptKeyID.ui_buf_length ) );

        aCertInfo.iCAId.Copy(

            TPtr8(

                ptCAID.pb_buf, 

                ptCAID.ui_buf_length, 

                ptCAID.ui_buf_length ) );

        aCertInfo.iIssuerHash.Copy(

            TPtr8(

                ptIssuerHash.pb_buf, 

                ptIssuerHash.ui_buf_length, 

                ptIssuerHash.ui_buf_length ) );

        aCertInfo.iUsage = usage;

        aCertInfo.iType = type;

        aCertInfo.iCertlen = certLen;

        aCertInfo.iModifiable = modifiable;

        // Certificate location

        aCertInfo.iCDFRefs = iWimUtilFuncs->MapCertLocation( uiCDFRefs );

        //Allocate enough memory for OID

        aCertInfo.iTrustedUsageLength = ptTrustedUsage.ui_buf_length * 16;

        WSL_OS_Free( ptLabel.pb_buf );

        WSL_OS_Free( ptKeyID.pb_buf );

        WSL_OS_Free( ptCAID.pb_buf );

        WSL_OS_Free( ptIssuerHash.pb_buf );

        WSL_OS_Free( ptTrustedUsage.pb_buf );

        }

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CWimCertHandler::GetExtrasFromWimL

// Fetches certificate's extra info from WIM card. In this case it is

// trusted usage info.

// -----------------------------------------------------------------------------

//

void CWimCertHandler::GetExtrasFromWimL(

    const RMessage2& aMessage, 

    CWimMemMgmt* aWimMgmt )

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimCertHandler::GetExtrasFromWimL | Begin"));

    WIMI_STAT callStatus = WIMI_Ok;

    TInt8 certUsage = 0;

    HBufC8* keyIdBuf = iWimUtilFuncs->DesLC( 0, aMessage );

    TPtrC8 keyIdHash = keyIdBuf->Des();

    WIMI_Ref_t* wimTempRef = aWimMgmt->WimRef();

    if ( !wimTempRef )

        { 

        wimTempRef = WIMI_GetWIMRef( 0 );

        aWimMgmt->SetWIMRef( wimTempRef );  // takes ownership

        }

    if ( wimTempRef )

        {

        TWimEntryType certEntryType = static_cast< TWimEntryType >( aMessage.Int2() );

        switch ( certEntryType )

            {

            case EWimEntryTypeCA:

                {

                certUsage = WIMI_CU_CA;

                break;

                }

            case EWimEntryTypeAll: //Flow through

            case EWimEntryTypePersonal:

                {

                certUsage = WIMI_CU_Client;

                break;

                }

            default:

                {

                callStatus = WIMI_ERR_BadParameters;

                break;

                }

            }

        if ( callStatus == WIMI_Ok )

            {

            callStatus = GetExtrasFromWimRefL( wimTempRef,

                                               certUsage,

                                               keyIdHash,

                                               aMessage );

            }

        }

    else

        {

        callStatus = WIMI_ERR_BadReference;

        }

    CleanupStack::PopAndDestroy( keyIdBuf );

    aMessage.Complete( CWimUtilityFuncs::MapWIMError( callStatus ) );

    }

// -----------------------------------------------------------------------------

// CWimCertHandler::GetExtrasFromWimRefL

// Fetches extra information (e.g. certs trusted usage) from the WIM card.

// -----------------------------------------------------------------------------

//

WIMI_STAT CWimCertHandler::GetExtrasFromWimRefL(

    WIMI_Ref_t* aTmpWimRef,

    TInt8 aUsage,

    TDesC8& aKeyHash,

    const RMessage2& aMessage )

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimCertHandler::GetExtrasFromWimRefL | Begin"));

    TUint8 tempCertCount = 0;

    WIMI_RefList_t certRefList = NULL;

    WIMI_STAT callStatus = WIMI_Ok;

    TInt certIndex = 0;

    TPtrC8 keyHash;

    if ( aTmpWimRef )

        {

        // List all certificates (by WIM and usage)

        callStatus = WIMI_GetCertificateListByWIM( aTmpWimRef, 

                                                   aUsage, 

                                                   &tempCertCount, 

                                                   &certRefList );

        }

    else

        {

        callStatus = WIMI_ERR_BadReference;

        }

    CleanupPushWimRefListL( certRefList );

    if ( callStatus == WIMI_Ok )

        {

        WIMI_Ref_t* tempRef = NULL;

        WIMI_BinData_t ptLabel;

        WIMI_BinData_t ptKeyID;

        WIMI_BinData_t ptCAID;

        WIMI_BinData_t ptIssuerHash;

        WIMI_BinData_t ptTrustedUsage;

        TUint8 uiCDFRefs;

        TUint8 usage;

        TUint8 certType;

        TUint16 certLen;

        TUint8 modifiable = 0;

        for ( TInt i = 0; i < tempCertCount; i++ )

            {

            // Get info for each certificate until we find valid cert

            callStatus = WIMI_GetCertificateInfo( certRefList[i],

                                                  &tempRef,

                                                  &ptLabel,

                                                  &ptKeyID,

                                                  &ptCAID,

                                                  &ptIssuerHash,

                                                  &ptTrustedUsage,

                                                  &uiCDFRefs,

                                                  &usage,

                                                  &certType,   

                                                  &certLen,

                                                  &modifiable );

            if ( callStatus == WIMI_Ok )

                {

                free_WIMI_Ref_t( tempRef );

                // Code MAY NOT leave before ptLabel.pb_buf, ptKeyID.pb_buf,

                // ptCAID.pb_buf, ptIssuerHash.pt_buf, and ptTrustedUsage.pb_buf

                // are deallocated.

                keyHash.Set( ptKeyID.pb_buf, ptKeyID.ui_buf_length );

                // Compare given and fetched key hash

                if ( keyHash.Compare( aKeyHash ) == 0 &&

                     certType == WIMI_CT_X509 ) //Match

                    {

                    certIndex = i; // Found one

                    i = tempCertCount; // Stop looping

                    callStatus = WIMI_Ok;

                    }

                else // Cert not supported

                    {

                    callStatus = WIMI_ERR_UnsupportedCertificate;

                    }

                WSL_OS_Free( ptLabel.pb_buf );

                WSL_OS_Free( ptKeyID.pb_buf );

                WSL_OS_Free( ptCAID.pb_buf );

                WSL_OS_Free( ptIssuerHash.pb_buf );

                WSL_OS_Free( ptTrustedUsage.pb_buf );

                // Code can leave after this point.

                }

            }

        if ( callStatus == WIMI_Ok )

            {

            CopyCertExtrasInfoL( certRefList[certIndex], aMessage );

            }

        CleanupStack::PopAndDestroy( certRefList );

        }

    return callStatus;

    }

// -----------------------------------------------------------------------------

// CWimCertHandler::CopyCertExtrasInfoL

// Copies certs extra information to client's allocated memory area.

// -----------------------------------------------------------------------------

//

void CWimCertHandler::CopyCertExtrasInfoL(