/*

* Copyright (c) 2006 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 DevCertOpenedKey

*

*/

#include <e32base.h>

#include <ct.h>

#include <mctkeystore.h>

#include <mctkeystoreuids.h>

#include <hash.h>

#include "DevCertOpenedKeys.h"

#include "DevCertKeyStore.h"

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

//CDevCertOpenedKey

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

// CDevCertOpenedKey::~CDevCertOpenedKey()

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

//

CDevCertOpenedKey::~CDevCertOpenedKey()

    {

    if ( iClient )

        {

        iClient->ReleaseObject(iHandle);

    	  }	

    delete iLabel;

    }

// CDevCertRSARepudiableSigner

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

// CDevCertRSARepudiableSigner::New()

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

//

CDevCertRSARepudiableSigner* CDevCertRSARepudiableSigner::New(CDevCertKeyStore* aClient)

    {

    return new CDevCertRSARepudiableSigner(aClient);

    }

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

// CDevCertRSARepudiableSigner::CDevCertRSARepudiableSigner()

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

//

CDevCertRSARepudiableSigner::CDevCertRSARepudiableSigner(CDevCertKeyStore* aClient)

    : MCTSigner<CRSASignature*>(aClient->Token())

    {

    iClient = aClient;

    iHandle.iTokenHandle = aClient->Token().Handle();

    iHandle.iObjectId = 0;

    }

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

// CDevCertRSARepudiableSigner::~CDevCertRSARepudiableSigner()

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

//

CDevCertRSARepudiableSigner::~CDevCertRSARepudiableSigner()

    {

    delete iDigest;

    }

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

// CDevCertRSARepudiableSigner::Release()

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

//

void CDevCertRSARepudiableSigner::Release()

    {

    MCTTokenObject::Release();

    }

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

// CDevCertRSARepudiableSigner::Label()

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

//

const TDesC& CDevCertRSARepudiableSigner::Label() const

    {

    return iLabel ? static_cast<const TDesC&>(*iLabel) : static_cast<const TDesC&>(KNullDesC);

    }

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

// CDevCertRSARepudiableSigner::Token()

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

//

MCTToken& CDevCertRSARepudiableSigner::Token() const

    {

    return iClient->Token();

    }

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

// CDevCertRSARepudiableSigner::Type()

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

//

TUid CDevCertRSARepudiableSigner::Type() const

    {

    return KRSARepudiableSignerUID;

    }

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

// CDevCertRSARepudiableSigner::Handle()

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

//

TCTTokenObjectHandle CDevCertRSARepudiableSigner::Handle() const

    {

    return iHandle;

    }

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

// CDevCertRSARepudiableSigner::SignMessage()

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

//

void CDevCertRSARepudiableSigner::SignMessage(const TDesC8& aPlaintext, 

          CRSASignature*& aSignature, 

          TRequestStatus& aStatus)

    {

    // Hash the data on the client side

    TRAPD(err, iDigest = CSHA1::NewL());

    if (err != KErrNone)

        {

        TRequestStatus* status = &aStatus;

        User::RequestComplete(status, err);

        }

    else

        {

        iDigest->Update(aPlaintext);  

        Sign(iDigest->Final(), aSignature, aStatus);

        }

    }

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

// CDevCertRSARepudiableSigner::Sign()

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

//

void CDevCertRSARepudiableSigner::Sign(const TDesC8& aPlaintext, 

          CRSASignature*& aSignature, 

          TRequestStatus& aStatus)

    {

    iClient->RepudiableRSASign(Handle(),aPlaintext, aSignature, aStatus);

    }

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

// CDevCertRSARepudiableSigner::CancelSign()

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

//

void CDevCertRSARepudiableSigner::CancelSign()

    {

    // Synchronous, no need to cancel

    }

// CDevCertDSARepudiableSigner 

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

// CDevCertDSARepudiableSigner::New()

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

//

CDevCertDSARepudiableSigner* CDevCertDSARepudiableSigner::New(CDevCertKeyStore* aClient)

    {

    return new CDevCertDSARepudiableSigner(aClient);

    }

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

// CDevCertDSARepudiableSigner::CDevCertDSARepudiableSigner()

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

//

CDevCertDSARepudiableSigner::CDevCertDSARepudiableSigner(CDevCertKeyStore* aClient)

    : MCTSigner<CDSASignature*>(aClient->Token())

    {

    iClient = aClient;

    iHandle.iTokenHandle = aClient->Token().Handle();

    iHandle.iObjectId = 0;

    }

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

// CDevCertDSARepudiableSigner::~CDevCertDSARepudiableSigner()

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

//

CDevCertDSARepudiableSigner::~CDevCertDSARepudiableSigner()

    {

    delete iDigest;

    }

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

// CDevCertDSARepudiableSigner::Release()

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

//

void CDevCertDSARepudiableSigner::Release()

    {

    MCTTokenObject::Release();

    }

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

// CDevCertDSARepudiableSigner::Label()

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

//

const TDesC& CDevCertDSARepudiableSigner::Label() const

    {

    return iLabel ? static_cast<const TDesC&>(*iLabel) : static_cast<const TDesC&>(KNullDesC);

    }

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

// CDevCertDSARepudiableSigner::Token()

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

//

MCTToken& CDevCertDSARepudiableSigner::Token() const

    {

    return iClient->Token();

    }

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

// CDevCertDSARepudiableSigner::Type()

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

//

TUid CDevCertDSARepudiableSigner::Type() const

    {

    return KDSARepudiableSignerUID;

    }

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

// CDevCertDSARepudiableSigner::Handle()

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

//

TCTTokenObjectHandle CDevCertDSARepudiableSigner::Handle() const

    {

    return iHandle;

    }

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

// CDevCertDSARepudiableSigner::SignMessage()

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

//

void CDevCertDSARepudiableSigner::SignMessage(const TDesC8& aPlaintext, 

          CDSASignature*& aSignature, 

        TRequestStatus& aStatus)

    {

    // Hash the data on the client side

    TRAPD(err, iDigest = CSHA1::NewL());

    if (err != KErrNone)

        {

        TRequestStatus* status = &aStatus;

        User::RequestComplete(status, err);

        }

    else

        {

        iDigest->Update(aPlaintext);

        Sign(iDigest->Final(), aSignature, aStatus);

        }

    }

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

// CDevCertDSARepudiableSigner::Sign()

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

//

void CDevCertDSARepudiableSigner::Sign(const TDesC8& aPlaintext, 

          CDSASignature*& aSignature, 

        TRequestStatus& aStatus)

    {

    iClient->RepudiableDSASign(Handle(),aPlaintext, aSignature, aStatus);

    }

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

// CDevCertDSARepudiableSigner::CancelSign()

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

//

void CDevCertDSARepudiableSigner::CancelSign()

    {

    // Synchronous, no need to cancel

    }

// CDevCertRSADecryptor

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

// CDevCertRSADecryptor::New()

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

//

CDevCertRSADecryptor* CDevCertRSADecryptor::New(CDevCertKeyStore* aClient)

    {

    return new CDevCertRSADecryptor(aClient);

    }

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

// CDevCertRSADecryptor::CDevCertRSADecryptor()

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

//

CDevCertRSADecryptor::CDevCertRSADecryptor(CDevCertKeyStore* aClient)

    : MCTDecryptor(aClient->Token())

    {

    iClient = aClient;

    iHandle.iTokenHandle = aClient->Token().Handle();

    iHandle.iObjectId = 0;

    }

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

// CDevCertRSADecryptor::~CDevCertRSADecryptor()

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

//

CDevCertRSADecryptor::~CDevCertRSADecryptor()

    {

    }

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

// CDevCertRSADecryptor::Release()

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

//

void CDevCertRSADecryptor::Release()

    {

    MCTTokenObject::Release();

    }

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

// CDevCertRSADecryptor::Label()

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

//

const TDesC& CDevCertRSADecryptor::Label() const

    {

    return iLabel ? static_cast<const TDesC&>(*iLabel) : static_cast<const TDesC&>(KNullDesC);

    }

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

// CDevCertRSADecryptor::Token()

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

//

MCTToken& CDevCertRSADecryptor::Token() const

    {

    return iClient->Token();

    }

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

// CDevCertRSADecryptor::Type()

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

//

TUid CDevCertRSADecryptor::Type() const

    {

    return KPrivateDecryptorUID;

    }

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

// CDevCertRSADecryptor::Handle()

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

//

TCTTokenObjectHandle CDevCertRSADecryptor::Handle() const

    {

    return iHandle;

    }

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

// CDevCertRSADecryptor::Decrypt()

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

//

void CDevCertRSADecryptor::Decrypt(const TDesC8& aCiphertext,

      TDes8& aPlaintext, 

      TRequestStatus& aStatus)

    {

    iClient->Decrypt(Handle(),aCiphertext,aPlaintext, aStatus);

    }

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

// CDevCertRSADecryptor::CancelDecrypt()

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

//

void CDevCertRSADecryptor::CancelDecrypt()

    {

    // Synchronous, no need to cancel

    }

// CDevCertDHAgreement

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

// CDevCertDHAgreement::New()

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

//

CDevCertDHAgreement* CDevCertDHAgreement::New(CDevCertKeyStore* aClient)

    {

    return new CDevCertDHAgreement(aClient);

    }

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

// CDevCertDHAgreement::CDevCertDHAgreement()

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

//

CDevCertDHAgreement::CDevCertDHAgreement(CDevCertKeyStore* aClient)

  : MCTDH(aClient->Token())

    {

    iClient = aClient;

    iHandle.iTokenHandle = aClient->Token().Handle();

    iHandle.iObjectId = 0;

    }

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

// CDevCertDHAgreement::~CDevCertDHAgreement()

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

//

CDevCertDHAgreement::~CDevCertDHAgreement()

    {

    }

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

// CDevCertDHAgreement::Release()

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

//

void CDevCertDHAgreement::Release()

    {

    MCTTokenObject::Release();

    }

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

// CDevCertDHAgreement::Label()

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

//

const TDesC& CDevCertDHAgreement::Label() const

    {

    return iLabel ? static_cast<const TDesC&>(*iLabel) : static_cast<const TDesC&>(KNullDesC);

    }

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

// CDevCertDHAgreement::Token()

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

//

MCTToken& CDevCertDHAgreement::Token() const

    {

    return iClient->Token();

    }

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

// CDevCertDHAgreement::Type()

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

//

TUid CDevCertDHAgreement::Type() const

    {

    return KKeyAgreementUID;

    }

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

// CDevCertDHAgreement::Handle()

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

//

TCTTokenObjectHandle CDevCertDHAgreement::Handle() const

    {

    return iHandle;

    }

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

// CDevCertDHAgreement::PublicKey()

// Returns the public key ('Big X') for the supplied set of parameters

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

//

void CDevCertDHAgreement::PublicKey(const TInteger& aN, const TInteger& aG, 

               CDHPublicKey*& aX, TRequestStatus& aStatus)

    {

    iClient->DHPublicKey(Handle(), aN, aG, aX, aStatus);

    }

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

// CDevCertDHAgreement::Agree()

// Agrees a session key given the public key of the other party

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

//

void CDevCertDHAgreement::Agree(const CDHPublicKey& iY, HBufC8*& aAgreedKey,

             TRequestStatus& aStatus)

    {

    iClient->DHAgree(Handle(), iY, aAgreedKey, aStatus);

    }

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

// CDevCertDHAgreement::CancelAgreement()

// Cancels either a PublicKey or Agree operation

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

//

void CDevCertDHAgreement::CancelAgreement()

    {

    // Synchronous, no need to cancel

    }