cryptoservices/filebasedcertificateandkeystores/source/keystore/Client/ClientOpenedKeys.cpp
Move the Security package to EPL, and add the implementations of the cryptographic algorithms
/*
* 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();
}