/*
* Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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 <e32base.h>
#include <ct.h>
#include <mctkeystore.h>
#include "ClientOpenedKeys.h"
#include "cfskeystoreclient.h"
#include "hash.h"

// COpenedKey //////////////////////////////////////////////////////////////////
	
COpenedKey::~COpenedKey()
	{
	iClient->ReleaseObject(iHandle);
	delete iLabel;
	}

// CRSARepudiableSigner ////////////////////////////////////////////////////////

CRSARepudiableSigner* CRSARepudiableSigner::New(CFSKeyStoreClient* aClient)
	{
	return new CRSARepudiableSigner(aClient);
	}

CRSARepudiableSigner::CRSARepudiableSigner(CFSKeyStoreClient* aClient)
		: MCTSigner<CRSASignature*>(aClient->Token())
	{
	iClient = aClient;
	iHandle.iTokenHandle = aClient->Token().Handle();
	iHandle.iObjectId = 0;
	}

CRSARepudiableSigner::~CRSARepudiableSigner()
	{
	delete iDigest;
	}

void CRSARepudiableSigner::Release()
	{
	MCTTokenObject::Release();
	}

const TDesC& CRSARepudiableSigner::Label() const
	{
	return iLabel ? static_cast<const TDesC&>(*iLabel) : static_cast<const TDesC&>(KNullDesC);
	}

MCTToken& CRSARepudiableSigner::Token() const
	{
	return iClient->Token();
	}

TUid CRSARepudiableSigner::Type() const
	{
	return KRSARepudiableSignerUID;
	}

TCTTokenObjectHandle CRSARepudiableSigner::Handle() const
	{
	return iHandle;
	}

void CRSARepudiableSigner::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);
        }
	}

void CRSARepudiableSigner::Sign(const TDesC8& aPlaintext, 
  				CRSASignature*& aSignature, 
  				TRequestStatus& aStatus)
	{
	iClient->RepudiableRSASign(Handle(),aPlaintext, aSignature, aStatus);
	}

void CRSARepudiableSigner::CancelSign()
	{
	iClient->CancelRepudiableRSASign();
	}

// CDSARepudiableSigner ////////////////////////////////////////////////////////

CDSARepudiableSigner* CDSARepudiableSigner::New(CFSKeyStoreClient* aClient)
	{
	return new CDSARepudiableSigner(aClient);
	}

CDSARepudiableSigner::CDSARepudiableSigner(CFSKeyStoreClient* aClient)
		: MCTSigner<CDSASignature*>(aClient->Token())
	{
	iClient = aClient;
	iHandle.iTokenHandle = aClient->Token().Handle();
	iHandle.iObjectId = 0;
	}


CDSARepudiableSigner::~CDSARepudiableSigner()
	{
	delete iDigest;
	}

void CDSARepudiableSigner::Release()
	{
	MCTTokenObject::Release();
	}

const TDesC& CDSARepudiableSigner::Label() const
	{
	return iLabel ? static_cast<const TDesC&>(*iLabel) : static_cast<const TDesC&>(KNullDesC);
	}

MCTToken& CDSARepudiableSigner::Token() const
	{
	return iClient->Token();
	}

TUid CDSARepudiableSigner::Type() const
	{
	return KDSARepudiableSignerUID;
	}

TCTTokenObjectHandle CDSARepudiableSigner::Handle() const
	{
	return iHandle;
	}

void CDSARepudiableSigner::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);
        }
	}

void CDSARepudiableSigner::Sign(const TDesC8& aPlaintext, 
  				CDSASignature*& aSignature, 
 				TRequestStatus& aStatus)
	{
	iClient->RepudiableDSASign(Handle(),aPlaintext, aSignature, aStatus);
	}

void CDSARepudiableSigner::CancelSign()
	{
	iClient->CancelRepudiableDSASign();
	}

// CFSRSADecryptor /////////////////////////////////////////////////////////////

CFSRSADecryptor* CFSRSADecryptor::New(CFSKeyStoreClient* aClient)
	{
	return new CFSRSADecryptor(aClient);
	}

CFSRSADecryptor::CFSRSADecryptor(CFSKeyStoreClient* aClient)
		: MCTDecryptor(aClient->Token())
	{
	iClient = aClient;
	iHandle.iTokenHandle = aClient->Token().Handle();
	iHandle.iObjectId = 0;
	}

CFSRSADecryptor::~CFSRSADecryptor()
	{
	}

void CFSRSADecryptor::Release()
	{
	MCTTokenObject::Release();
	}

const TDesC& CFSRSADecryptor::Label() const
	{
	return iLabel ? static_cast<const TDesC&>(*iLabel) : static_cast<const TDesC&>(KNullDesC);
	}

MCTToken& CFSRSADecryptor::Token() const
	{
	return iClient->Token();
	}

TUid CFSRSADecryptor::Type() const
	{
	return KPrivateDecryptorUID;
	}

TCTTokenObjectHandle CFSRSADecryptor::Handle() const
	{
	return iHandle;
	}

void CFSRSADecryptor::Decrypt(const TDesC8& aCiphertext,
			TDes8& aPlaintext, 
			TRequestStatus& aStatus
	)
	{
	iClient->Decrypt(Handle(),aCiphertext,aPlaintext, aStatus);
	}

void CFSRSADecryptor::CancelDecrypt()
	{
	iClient->CancelDecrypt();
	}

// CDHAgreement ////////////////////////////////////////////////////////////////

CDHAgreement* CDHAgreement::New(CFSKeyStoreClient* aClient)
	{
	return new CDHAgreement(aClient);
	}

CDHAgreement::CDHAgreement(CFSKeyStoreClient* aClient)
	: MCTDH(aClient->Token())
	{
	iClient = aClient;
	iHandle.iTokenHandle = aClient->Token().Handle();
	iHandle.iObjectId = 0;
	}

CDHAgreement::~CDHAgreement()
	{
	}

void CDHAgreement::Release()
	{
	MCTTokenObject::Release();
	}

const TDesC& CDHAgreement::Label() const
	{
	return iLabel ? static_cast<const TDesC&>(*iLabel) : static_cast<const TDesC&>(KNullDesC);
	}

MCTToken& CDHAgreement::Token() const
	{
	return iClient->Token();
	}

TUid CDHAgreement::Type() const
	{
	return KKeyAgreementUID;
	}

TCTTokenObjectHandle CDHAgreement::Handle() const
	{
	return iHandle;
	}

/** Returns the public key ('Big X') for the supplied set of parameters */
void CDHAgreement::PublicKey(const TInteger& aN, const TInteger& aG, 
							 CDHPublicKey*& aX, TRequestStatus& aStatus)
	{
	iClient->DHPublicKey(Handle(), aN, aG, aX, aStatus);
	}

/** Agrees a session key given the public key of the other party */
void CDHAgreement::Agree(const CDHPublicKey& iY, HBufC8*& aAgreedKey,
						 TRequestStatus& aStatus)
	{
	iClient->DHAgree(Handle(), iY, aAgreedKey, aStatus);
	}

/** Cancels either a PublicKey or Agree operation */
void CDHAgreement::CancelAgreement()
	{
	iClient->CancelDH();
	}
