/*

* 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 "cstssignatureservice.h"

#include "tstsdistinguishednameconverter.h"

#include "secdlg.h"

#include <unifiedcertstore.h>

#include <asn1enc.h>

#include <x500dn.h>

#include <charconv.h>

#include <unifiedkeystore.h>

#include <mctwritablecertstore.h>

#include <signed.h>

#include <asymmetric.h>

#include <CCMSX509Certificate.h>

#include <CCMSSignerInfo.h>

#include <CCMSEncapsulatedContentInfo.h>

#include <CCMSSignedData.h>

#include "cstsseprompt.h"

#include <hash.h>

#include "fs_methodcall.h"

#include <jutils.h>

#include "satsajnitools.h"

#include "logger.h"

#include "jstringutils.h"

const TInt KDefaultGranularity = 1;

const TInt KOptionIncludeContent = 1;

const TInt KOptionIncludeCertificate = 2;

_LIT(KIdData, "1.2.840.113549.1.7.1");

_LIT(KIdSignedData, "1.2.840.113549.1.7.2");

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

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

// CSTSSignatureService::NewL

// Two-phased constructor.

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

//

CSTSSignatureService* CSTSSignatureService::NewL()

{

    CSTSSignatureService* self = new(ELeave) CSTSSignatureService;

    CallMethodL(self, &CSTSSignatureService::AddToScheduler, self);

    CleanupStack::PushL(self);

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

    CleanupStack::Pop(self);

    return self;

}

void CSTSSignatureService::AddToScheduler()

{

    CActiveScheduler::Add(this);

}

// Destructor

CSTSSignatureService::~CSTSSignatureService()

{

    if (iDialog)

    {

        iDialog->Release(); // Release deletes the object

    }

    iCertificateArray.Close();

    iCertInfos.Close();

    delete iFilter;

    iDERNamesHBufC.ResetAndDestroy();

    iDERNames.Close();

    delete iTextToDisplay;

    if (iCertificate)

    {

        iCertificate->Release();

    }

    delete iX509Certificate;

    if (iRSASigner)

    {

        iRSASigner->Release();

    }

    if (iDSASigner)

    {

        iDSASigner->Release();

    }

    delete iCertStore;

    delete iKeyStore;

    iKeys.Close();

    delete iRSASignature;

    delete iDSASignature;

    delete iSignature;

    iFileServer.Close();

    delete iWait;

    delete iSecurityElementPrompt;

    delete iSignerInfo;

    delete iEncodedSignedAttributesHash;

    delete iCMSCertificate;

}

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

// CSTSSignatureService::AuthenticateL

// Authenticates given data

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

//

HBufC8* CSTSSignatureService::AuthenticateL(const TDesC8& abytesToAuthenticate,

        TInt aOptions, const CDesCArray& aCaNames,

        const TDesC& asecurityElementPrompt, TBool aShowData)

{

    if (iState != EReady)

    {

        ELOG(ESATSA, "CSTSSignatureService::AuthenticateL: Not Ready");

        User::Leave(KErrNotReady);

    }

    // First we need to convert the data to unicode, if we have to display it

    HBufC* textToDisplay = NULL;

    if (aShowData)

    {

        textToDisplay = ConvertUTF8ToUnicodeL(abytesToAuthenticate);

        iAuthType = EAuthWithText;

    }

    else

    {

        textToDisplay = KNullDesC().AllocL();

        iAuthType = EAuthWithoutText;

    }

    delete iTextToDisplay;

    iTextToDisplay = textToDisplay;

    iMessage.Set(abytesToAuthenticate);

    iOptions = aOptions;

    iShowNotes = EFalse;

    // get handles to applicable certificates

    HBufC8* retVal = CreateSignatureL(aCaNames, EX509UsageDigitalSignature,

                                      asecurityElementPrompt);

    return retVal;

}

TInt CSTSSignatureService::StaticAuthenticateL(JNIEnv* aJniEnv,

        CSTSSignatureService* service, jbyteArray aByteArrayToAuthenticate,

        jint aOptions, jobjectArray aCaNames, jstring aSecurityElementPrompt,

        jboolean aShowData, HBufC8** aRetVal)

{

    const TInt byteArrayLength = aJniEnv->GetArrayLength(

                                     aByteArrayToAuthenticate);

    jbyte* bytesToAuthenticate = aJniEnv->GetByteArrayElements(

                                     aByteArrayToAuthenticate, NULL);

    if (!bytesToAuthenticate)

    {

        ELOG(ESATSA, "CSTSSignatureService::StaticAuthenticateL: No memory,return");

        return NULL;

    }

    TPtrC8 desToAuthenticate(reinterpret_cast<TUint8*>(bytesToAuthenticate),

                             byteArrayLength);

    CDesCArrayFlat* nativeCaNames = STSCreateNativeStringArrayL(aJniEnv,

                                    aCaNames);

    const JStringUtils securityElementPrompt(*aJniEnv, aSecurityElementPrompt);

    TBool ShowData = static_cast<TBool>(aShowData);

    const TDesC* sec = static_cast<const TDesC*>(&securityElementPrompt);

    TRAPD(err, CallMethodL(*aRetVal, service,

                           &CSTSSignatureService::AuthenticateL, desToAuthenticate, aOptions,

                           *nativeCaNames, *sec, ShowData, service));

    return err;

}

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

// CSTSSignatureService::SignL

// Signs given data

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

HBufC8* CSTSSignatureService::SignL(const TDesC8& aBytesToSign, TInt aOptions,

                                    const CDesCArray& aCaNames, const TDesC& aSecurityElementPrompt)

{

    if (iState != EReady)

    {

        ELOG(ESATSA, "CSTSSignatureService::SignL: Not Ready");

        User::Leave(KErrNotReady);

    }

    // convert text from UTF8

    HBufC* textToDisplay = ConvertUTF8ToUnicodeL(aBytesToSign);

    delete iTextToDisplay;

    iTextToDisplay = textToDisplay;

    iAuthType = ESignWithText;

    iMessage.Set(aBytesToSign);

    iOptions = aOptions;

    iShowNotes = ETrue;

    // get handles to applicable certificates

    HBufC8* retVal = CreateSignatureL(aCaNames, EX509UsageNonRepudiation,

                                      aSecurityElementPrompt);

    return retVal;

}

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

// CSTSSignatureService::StaticSignL

// Authenticates given data

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

//

TInt CSTSSignatureService::StaticSignL(JNIEnv* aJniEnv,

                                       CSTSSignatureService* service, jbyteArray aBytesToSign, jint aOptions,

                                       jobjectArray aCaNames, jstring aSecurityElementPrompt, HBufC8** aRetVal)

{

    const TInt byteArrayLength = aJniEnv->GetArrayLength(aBytesToSign);

    jbyte* bytesToSign = aJniEnv->GetByteArrayElements(aBytesToSign, NULL);

    if (!bytesToSign)

    {

        return NULL;

    }

    TPtrC8 desToSign(reinterpret_cast<TUint8*>(bytesToSign), byteArrayLength);

    CDesCArrayFlat* nativeCaNames = STSCreateNativeStringArrayL(aJniEnv,

                                    aCaNames);

    const JStringUtils securityElementPrompt(*aJniEnv, aSecurityElementPrompt);

    const TDesC* sec = static_cast<const TDesC*>(&securityElementPrompt);

    TRAPD(err, CallMethodL(*aRetVal, service, &CSTSSignatureService::SignL,

                           desToSign, aOptions, *nativeCaNames, *sec, service));

    return err;

}

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

// CSTSSignatureService::RunL

// CActive callback

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

//

void CSTSSignatureService::RunL()

{

    if (iStatus == KErrCancel)

    {

        if (iShowNotes)

        {

            iState = EFinalNote;

            iStatus = KErrNone;

            SetActive();

        else

        {

        }

    }

    else if (iStatus != KErrNone)

    {

        // Error has occured; inform java

        Complete(iStatus.Int());

    }

    else

    {

        switch (iState)

        {

        case EInitialising:

        {

            iState = EKeyStoreInit;

            iKeyStore->Initialize(iStatus);

            SetActive();

            break;

        }

        case EKeyStoreInit:

        {

            Complete(KErrNone);

            break;

        }

        case EListing:

        {

            HandlesFromCertInfosL();

            break;

        }

        case EDialog:

        {

            iState = EGetCert;

            if (iCertificate)

            {

                iCertificate->Release();

                iCertificate = NULL;

            }

            // if there is only 1 handle, the dialog won't return it.

            if (iCertificateArray.Count() == 1)

            {

                iCertificateHandle = iCertificateArray[0];

            }

            iCertStore->GetCert(iCertificate, iCertificateHandle, iStatus);

            SetActive();

            break;

        }

        case EGetCert:

        {

            if (iX509Certificate)

            {

                delete iX509Certificate;

                iX509Certificate = NULL;

            }

            iState = ERetrieveCert;

            iCertStore->Retrieve(*iCertificate, iX509Certificate, iStatus);

            SetActive();

            break;

        }

        case ERetrieveCert:

        {

            FindKeyL();

            break;

        }

        case EFindKey:

        {

            OpenSignerL();

            break;

        }

        case EOpenSigner:

        {

            SignL();

            break;

        }

        case ESign:

        {

            CreateSignedDataL();

            break;

        }

        case EFinalNote:

        {

            Complete(KErrNone);

            break;

        }

        default:

        {

            Complete(KErrGeneral);

        }

        }

    }

}

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

// CSTSSignatureService::RunError

// CActive error callback

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

//

TInt CSTSSignatureService::RunError(TInt aError)

{

    Complete(aError);

    return KErrNone;

}

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

// CSTSSignatureService::DoCancel

// CActive cancellation callback

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

//

void CSTSSignatureService::DoCancel()

{

    switch (iState)

    {

    case EInitialising:

    {

        iCertStore->CancelInitialize();

        break;

    }

    case EKeyStoreInit:

    {

        iKeyStore->CancelInitialize();

        break;

    }

    case EListing:

    {

        iCertStore->CancelList();

        break;

    }

    case EDialog:

    {

        iDialog->Cancel();

        break;

    }

    case EGetCert:

    {

        iCertStore->CancelGetCert();

        break;

    }

    case ERetrieveCert:

    {

        iCertStore->CancelRetrieve();

        break;

    }

    case EFindKey:

    {

        iKeyStore->CancelList();

        break;

    }

    case EOpenSigner:

    {

        iKeyStore->CancelOpen();

        break;

    }

    case ESign:

    {

        if (iRSASigner)

        {

            iRSASigner->CancelSign();

        }

        if (iDSASigner)

        {

            iDSASigner->CancelSign();

        }

        break;

    }

    default:

    {

        // nothing to cancel

    }

    }

    iState = EERROR;

    iError = KErrCancel;

}

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

// CSTSSignatureService::CSTSSignatureService

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

// might leave.

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

//

CSTSSignatureService::CSTSSignatureService() :

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

        iState(EInitialising)

{

    createServerToNewThread();

}

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

// CSTSSignatureService::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CSTSSignatureService::ConstructL()

{

    User::LeaveIfError(iFileServer.Connect());

    iDialog = SecurityDialogFactory::CreateL();

    iFilter = CCertAttributeFilter::NewL();

    iWait = new(ELeave) CActiveSchedulerWait;

    iCertStore = CUnifiedCertStore::NewL(iFileServer, ETrue);

    iKeyStore = CUnifiedKeyStore::NewL(iFileServer);

    iCertStore->Initialize(iStatus);

    WaitForCompletionL();

}

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

// CSTSSignatureService::Complete

// Completes the operation

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

//

void CSTSSignatureService::Complete(TInt aError)

{

    if (KErrNone == aError)