/*

* Copyright (c) 2008 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:

 *

*/

// INCLUDE FILES

#include "cstscredentialmanager.h"

#include "tstsdistinguishednameconverter.h"

#include "CCMSIssuerAndSerialNumber.h"

#include "cstsseprompt.h"

#include "stspkiconstants.h"

#include "fs_methodcall.h"

#include <asn1dec.h>

#include <x509cert.h>

#include <unifiedcertstore.h>

#include <unifiedkeystore.h>

#include <mctwritablecertstore.h>

#include <charconv.h>

#include <pkcs10.h>

#include <secdlg.h>

#include <PKIDlg.h>

#include <securityerr.h>

// CONSTANTS

_LIT(KSTSSymbianKeyStoreLabel, "Software key store");

_LIT(KSTSSymbianCertificateStoreLabel, "Software certificate store");

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

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

// CSTSCredentialManager::NewLC

// Two-phased constructor.

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

//

CSTSCredentialManager* CSTSCredentialManager::NewLC()

{

    CSTSCredentialManager* self = new(ELeave) CSTSCredentialManager;

    CallMethod(self,&CSTSCredentialManager::AddToScheduler,self);

    CleanupStack::PushL(self);

    CallMethodL(self,&CSTSCredentialManager::ConstructL,self);

    return self;

}

void CSTSCredentialManager::AddToScheduler()

{

    CActiveScheduler::Add(this);

}

// Destructor

CSTSCredentialManager::~CSTSCredentialManager()

{

    delete iEncodedCert;

    delete iIssuerAndSerialNumber;

    if (iPKIDialog)

    {

        iPKIDialog->Release();

    }

    delete iDistinguishedName;

    delete iDisplayName;

    delete iRequestEncoded;

    delete iRequest;

    if (iCertInfoArray)

    {

        iCertInfoArray->Close();

        delete iCertInfoArray;

    }

    if (iKeyInfoArray)

    {

        iKeyInfoArray->Close();

        delete iKeyInfoArray;

    }

    if (iKeyInfo)

    {

        iKeyInfo->Release();

    }

    delete iKeyStore;

    delete iStore;

    delete iWait;

    iFileServer.Close();

}

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

// CSTSCredentialManager::AddCredentialL

// Adds a certificate or certificate URI to certificate store

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

//

TBool CSTSCredentialManager::AddCredentialL(

    TInt/*const TDesC&*/ aCertDisplayName,

    TInt/*const TDesC&*/ aPkiPath)

{

    if (iState != EReady)

    {

        User::Leave(KErrNotReady);

    }

    iWritableCertStoreIndex = CheckWriteCertStoreSEIDL(NULL, NULL);

    const TDesC8* path = reinterpret_cast< const TDesC8* >(aPkiPath);

    TASN1DecGeneric genericDecoder(*path);

    genericDecoder.InitL();

    TPtrC8 certificates = genericDecoder.GetContentDER();

    TInt certificatesLength = certificates.Length();

    TInt pos = 0;

    iSubject.Set(certificates.Right(certificatesLength));

    TPtrC8 issuer(iSubject);

    // go through the certificate chain, leaving the last certificate as subject

    // and second last as issuer

    while (pos < certificatesLength)

    {

        issuer.Set(iSubject);

        TASN1DecGeneric

        certDecoder(certificates.Right(certificatesLength - pos));

        certDecoder.InitL();

        TInt certLength = certDecoder.LengthDER();

        TPtrC8 singleCert(certificates.Mid(pos, certLength));

        iSubject.Set(singleCert);

        pos+=certLength;

    }

    CX509Certificate* cert =

        CX509Certificate::NewLC(iSubject);

    CX509Certificate* issuerCert =

        CX509Certificate::NewLC(issuer);

    iSubjectKeyId = cert->KeyIdentifierL();

    iIssuerKeyId = issuerCert->KeyIdentifierL();

    iCertDisplayName = reinterpret_cast<TDesC*>(aCertDisplayName);

    // now we have to check that this certificate does not exist in the

    // database yet

    CCertAttributeFilter* filter = CCertAttributeFilter::NewLC();

    filter->SetFormat(EX509Certificate);

    filter->SetSubjectKeyId(iSubjectKeyId);

    filter->SetIssuerKeyId(iIssuerKeyId);

    RMPointerArray< CCTCertInfo >* certInfoArray =

        new(ELeave) RMPointerArray< CCTCertInfo >();

    if (iCertInfoArray)

    {

        iCertInfoArray->Close();

        delete iCertInfoArray;

    }

    iCertInfoArray = certInfoArray;

    iState = EAddListing;

    iStore->WritableCertStore(iWritableCertStoreIndex)

    .List(*iCertInfoArray, *filter,

          iStatus);

    WaitForCompletionL();

    CleanupStack::PopAndDestroy(3); // filter, cert, issuerCert

    iCertInfoArray->Close();

    delete iCertInfoArray;

    iCertInfoArray = NULL;

    return ETrue;

}

void CSTSCredentialManager::StaticAddCredentialL(

    TInt /*aManager*/,

    TInt /*aCertDisplayName*/,

    TInt /*aPkiPath*/,

    TInt /*aRetVal*/)

{

}

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

// CSTSCredentialManager::GenerateCSRL

// Creates a DER encoded PKCS#10 certificate enrollment request.

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

//

TDesC8& CSTSCredentialManager::GenerateCSRL(

    const TDesC& aNameInfo,

    const TDesC& aAlgorithm,

    TInt aKeyLen,

    TInt aKeyUsage,

    const TDesC* aSecurityElementID,

    const TDesC* aSecurityElementPrompt)

{

    TInt storeIndex = CheckKeyStoreSEIDL(aSecurityElementID,

                                         aSecurityElementPrompt);

    CKeyInfoBase::EKeyAlgorithm algorithm(CKeyInfoBase::EInvalidAlgorithm);

    if (aAlgorithm.Compare(KSTSAlgorithmRsa()) == 0)

    {

        algorithm = CKeyInfoBase::ERSA;

    }

    else

    {

        CheckOIDL(aAlgorithm);

        User::Leave(KSTSErrSeNoKeys);

    }

    TSTSDistinguishedNameConverter dnConverter;

    CX500DistinguishedName* dName = dnConverter.CreateDNL(aNameInfo);

    delete iDistinguishedName;

    iDistinguishedName = dName;

    HBufC* dispName = dName->DisplayNameL();

    delete iDisplayName;

    iDisplayName = dispName;

    TKeyUsagePKCS15 keyUsage(EPKCS15UsageNone);

    switch (aKeyUsage)

    {

    case KSTSKeyUsageAuthentication:

    {

        keyUsage = EPKCS15UsageSign;

        break;

    }

    case KSTSKeyUsageNonRepudiation:

    {

        keyUsage = EPKCS15UsageNonRepudiation;

        break;

    }

    default:

    {

        User::Leave(KErrKeyUsage);

    }

    }

    // have to search for the key

    TCTKeyAttributeFilter filter;

    filter.iKeyAlgorithm = algorithm;

    filter.iUsage = keyUsage;

    RMPointerArray< CCTKeyInfo >* keyInfoArray =

        new(ELeave) RMPointerArray< CCTKeyInfo >();

    if (iKeyInfoArray)

    {

        iKeyInfoArray->Close();

        delete iKeyInfoArray;

    }

    iKeyInfoArray = keyInfoArray;

    iKeyLen = aKeyLen;

    iState = ESearchingKey;

    iKeyStore->KeyStore(storeIndex).List(

        *iKeyInfoArray, filter, iStatus);

    WaitForCompletionL();

    return *iRequestEncoded;

}

void CSTSCredentialManager::StaticGenerateCSRL(

    TInt aParams,

    TInt aRetVal)

{

    TGenerateCSRParams* params = reinterpret_cast<TGenerateCSRParams*>(aParams);

    TDesC8** ret = reinterpret_cast<TDesC8**>(aRetVal);

    TDesC8& retVal = GenerateCSRL(

                         *(params->iNameInfo), *(params->iAlgorithm),

                         params->iKeyLen, params->iKeyUsage,

                         params->iSecurityElementID,

                         params->iSecurityElementPrompt);

    *ret = &retVal;

}

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

// CSTSCredentialManager::RemoveCredentialL

// Removes a certificate or certificate URI from a certificate store.

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

//

TBool CSTSCredentialManager::RemoveCredentialL(

    const TDesC& aCertDisplayName,

    const TDesC8& aIssuerAndSerialNumber,

    const TDesC* aSecurityElementID,

    const TDesC* aSecurityElementPrompt)

{

    TInt storeIndex = CheckWriteCertStoreSEIDL(aSecurityElementID,

                      aSecurityElementPrompt);

    // currently the certificates are stored in the symbian store, always

    storeIndex = CheckWriteCertStoreSEIDL(NULL, NULL);

    if (iState != EReady)

    {

        User::Leave(KErrNotReady);

    }

    // Create filter

    CCertAttributeFilter* filter = CCertAttributeFilter::NewLC();

    TCertLabel label(aCertDisplayName);

    filter->SetLabel(label);

    RMPointerArray< CCTCertInfo >* certInfoArray =

        new(ELeave) RMPointerArray< CCTCertInfo >();

    if (iCertInfoArray)

    {

        iCertInfoArray->Close();

        delete iCertInfoArray;

    }

    iCertInfoArray = certInfoArray;

    // Decode Issuer and SerialNumber

    CCMSIssuerAndSerialNumber* issuerAndSerialNumber =

        CCMSIssuerAndSerialNumber::NewL();

    delete iIssuerAndSerialNumber;

    iIssuerAndSerialNumber = issuerAndSerialNumber;

    iIssuerAndSerialNumber->DecodeL(aIssuerAndSerialNumber);

    iState = ERemoveListing;

    iStore->WritableCertStore(storeIndex).

    List(*iCertInfoArray, *filter, iStatus);

    WaitForCompletionL();

    CleanupStack::PopAndDestroy();  // filter

    iCertInfoArray->Close();

    delete iCertInfoArray;

    iCertInfoArray = NULL;

    delete iIssuerAndSerialNumber;

    iIssuerAndSerialNumber = NULL;

    delete iEncodedCert;

    iEncodedCert = NULL;

    return ETrue;

}

void CSTSCredentialManager::StaticRemoveCredentialL(

    TInt aCertDisplayName,

    TInt aIssuerAndSerialNumber,

    TInt aSecurityElementID,

    TInt aSecurityElementPrompt,

    TInt aRetVal)

{

    *(reinterpret_cast<TBool*>(aRetVal)) = RemoveCredentialL(*(reinterpret_cast<TDesC*>(aCertDisplayName)),

                                           *(reinterpret_cast<TDesC8*>(aIssuerAndSerialNumber)),

                                           reinterpret_cast<TDesC*>(aSecurityElementID),

                                           reinterpret_cast<TDesC*>(aSecurityElementPrompt));

}

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

// CSTSCredentialManager::RunL

// CActive callback

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

//

void CSTSCredentialManager::RunL()

{

    if (iStatus != KErrNone)

    {

        // Error has occured; inform java

        Complete(iStatus.Int());

    }

    else

    {

        switch (iState)

        {

        case EInitialising:

        {

            iState = EKeyStoreInit;

            iKeyStore->Initialize(iStatus);

            SetActive();

            break;

        }

        case ERemoveListing:

        {

            RemoveRetrieveL();

            break;

        }

        case ERemoveRetrieve:

        {

            RemoveVerifyL();

            break;

        }

        case ERemoveDialog:

        {

            Remove();

            break;

        }

        case EAddListing:

        {

            AddRetrieveL();

            break;

        }

        case EAddRetrieve:

        {

            AddVerifyL();

            break;

        }

        case EAddDialog:

        {

            AddL();

            break;

        }

        case EAdding:

        case EDeleting:

        case ECreatingCSR:

        case EKeyStoreInit:

        {

            Complete(KErrNone);

            break;

        }

        case ECSRDialog:

        {

            CreateCSRL();

            break;

        }

        case ESearchingKey:

        {

            CheckSearchResultsL();

            break;

        }

        default:

        {

            Complete(KErrGeneral);

        }

        }

    }

}

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

// CSTSCredentialManager::RunError

// CActive error callback

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

//

TInt CSTSCredentialManager::RunError(TInt aError)

{

    Complete(aError);

    return KErrNone;

}

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

// CSTSCredentialManager::DoCancel

// CActive cancellation callback - cancel whatever doing

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

//

void CSTSCredentialManager::DoCancel()

{

    switch (iState)

    {

    case EInitialising:

    {

        iStore->CancelInitialize();

        break;

    }

    case EKeyStoreInit:

    {

        iKeyStore->CancelInitialize();

        break;

    }

    case EAdding:

    {

        MCTWritableCertStore& writableStore =

            iStore->WritableCertStore(iWritableCertStoreIndex);

        writableStore.CancelAdd();

        break;

    }

    case EAddListing:

    case ERemoveListing:

    {

        iStore->CancelList();

        break;

    }

    case EAddRetrieve:

    case ERemoveRetrieve:

    {

        iStore->CancelRetrieve();

        break;

    }

    case EDeleting:

    {

        iStore->CancelRemove();

        break;

    }

    case EAddDialog: // AddDialog has nothing to cancel

    case ERemoveDialog: // RemoveDialog has nothing to cancel

    default:

    {

        // nothing to cancel

    }

    }

    iState = EError;

}

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

// CSTSCredentialManager::CSTSCredentialManager

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

// might leave.

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

//

CSTSCredentialManager::CSTSCredentialManager()

        : CActive(EPriorityStandard),java::util::FunctionServer("MyPKIServer"),

        iState(EInitialising),

        iEncodedCertDes(NULL, 0)

{

    createServerToNewThread();

}