/*
* Copyright (c) 2007-2010 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 "keyconverter.h"
#include <cryptospi/cryptoparams.h>
#include <cryptospi/cryptospidef.h>
#include <cryptospi/keys.h>
#include <cryptospi/keypair.h>

using namespace CryptoSpi;

/* CKeyConverter */

CKey* KeyConverter::CreateKeyL(const CDHPrivateKey& aPrivateKey)
	{
	/*
	 * setup key attributes
	 */
	TKeyProperty keyProperty;
	keyProperty.iAlgorithmUid = KDHAgreementUid;

	/*
	 * extract key parameters from the compatibility dh key object
	 */
	CCryptoParams* keyParameters = CCryptoParams::NewLC();
	keyParameters->AddL(aPrivateKey.N(), KDhKeyParameterNUid);
	keyParameters->AddL(aPrivateKey.G(), KDhKeyParameterGUid);
	keyParameters->AddL(aPrivateKey.x(), KDhKeyParameterxUid);

	/*
	 * create a CKey from the parameters
	 */
	CKey* newPrivateKey = CKey::NewL(keyProperty, *keyParameters);

	CleanupStack::PopAndDestroy(1, keyParameters);
	return newPrivateKey;
	}

CKey* KeyConverter::CreateKeyL(const CDHPublicKey& aPublicKey)
	{
	/*
	 * setup key attributes
	 */
	TKeyProperty keyProperty;
	keyProperty.iAlgorithmUid = KDHAgreementUid;

	/*
	 * extract key parameters from the compatibility dh key object
	 */
	CCryptoParams* keyParameters = CCryptoParams::NewLC();
	keyParameters->AddL(aPublicKey.N(), KDhKeyParameterNUid);
	keyParameters->AddL(aPublicKey.G(), KDhKeyParameterGUid);
	keyParameters->AddL(aPublicKey.X(), KDhKeyParameterXUid);

	/*
	 * create a CKey from the parameters
	 */
	CKey* newPublicKey = CKey::NewL(keyProperty, *keyParameters);

	CleanupStack::PopAndDestroy(1, keyParameters);
	return newPublicKey;
	}

CKey* KeyConverter::CreateKeyL(const CDSAPrivateKey& aPrivateKey)
	{
	TKeyProperty keyProperty = {KDsaSignerUid, KNullUid, KDsaPrivateKeyUid, KNonEmbeddedKeyUid};

	CCryptoParams* keyParameters = CCryptoParams::NewLC();
	keyParameters->AddL(aPrivateKey.P(), KDsaKeyParameterPUid);
	keyParameters->AddL(aPrivateKey.Q(), KDsaKeyParameterQUid);
	keyParameters->AddL(aPrivateKey.G(), KDsaKeyParameterGUid);
	keyParameters->AddL(aPrivateKey.X(), KDsaKeyParameterXUid);
		
	CKey* newPrivateKey = CKey::NewL(keyProperty, *keyParameters);
	CleanupStack::PopAndDestroy(keyParameters);
	return newPrivateKey;
	}
	
CKey* KeyConverter::CreateKeyL(const CDSAPublicKey& aPublicKey)
	{
	TKeyProperty keyProperty = {KDsaSignerUid, KNullUid, KDsaPublicKeyUid, KNonEmbeddedKeyUid};

	CCryptoParams* keyParameters = CCryptoParams::NewLC();
	keyParameters->AddL(aPublicKey.P(), KDsaKeyParameterPUid);
	keyParameters->AddL(aPublicKey.Q(), KDsaKeyParameterQUid);
	keyParameters->AddL(aPublicKey.G(), KDsaKeyParameterGUid);
	keyParameters->AddL(aPublicKey.Y(), KDsaKeyParameterYUid);

	CKey* newPublicKey = CKey::NewL(keyProperty, *keyParameters);
	CleanupStack::PopAndDestroy(keyParameters);
	return newPublicKey;
	}

// RSA convertors ///////////////////////////////////////////////////////////////////////////
CKey* KeyConverter::CreateKeyL(const CRSAPrivateKeyCRT& aPrivateKey)
	{
	TKeyProperty keyProperty = {KRsaCipherUid,
		NULL,
		KRsaPrivateKeyCRTUid,
		KNonEmbeddedKeyUid };

	CCryptoParams* keyParameters = CCryptoParams::NewLC();
	keyParameters->AddL(aPrivateKey.N(), KRsaKeyParameterNUid);
	keyParameters->AddL(aPrivateKey.P(), KRsaKeyParameterPUid);
	keyParameters->AddL(aPrivateKey.Q(), KRsaKeyParameterQUid);
	keyParameters->AddL(aPrivateKey.QInv(), KRsaKeyParameterQInvUid);
	keyParameters->AddL(aPrivateKey.DP(), KRsaKeyParameterDPUid);
	keyParameters->AddL(aPrivateKey.DQ(), KRsaKeyParameterDQUid);
		
	CKey* newPrivateKey = CKey::NewL(keyProperty, *keyParameters);
	CleanupStack::PopAndDestroy(keyParameters);
	return newPrivateKey;
	}
	
CKey* KeyConverter::CreateKeyL(const CRSAPrivateKeyStandard& aPrivateKey)
	{
	TKeyProperty keyProperty = {KRsaCipherUid,
		NULL,
		KRsaPrivateKeyStandardUid,
		KNonEmbeddedKeyUid };

	CCryptoParams* keyParameters = CCryptoParams::NewLC();
	keyParameters->AddL(aPrivateKey.N(), KRsaKeyParameterNUid);
	keyParameters->AddL(aPrivateKey.D(), KRsaKeyParameterDUid);
		
	CKey* newPrivateKey = CKey::NewL(keyProperty, *keyParameters);
	CleanupStack::PopAndDestroy(keyParameters);
	return newPrivateKey;
	}
	
CKey* KeyConverter::CreateKeyL(const CRSAPublicKey& aPublicKey)
	{
	TKeyProperty keyProperty = {KRsaCipherUid,
		NULL,
		KRsaPublicKeyUid,
		KNonEmbeddedKeyUid };

	CCryptoParams* keyParameters = CCryptoParams::NewLC();	
	keyParameters->AddL(aPublicKey.N(), KRsaKeyParameterNUid);
	keyParameters->AddL(aPublicKey.E(), KRsaKeyParameterEUid);

	CKey* newPublicKey = CKey::NewL(keyProperty, *keyParameters);
	CleanupStack::PopAndDestroy(keyParameters);
	return newPublicKey;
	}

CKey* KeyConverter::CreateKeyL(const CRSAPrivateKey& aPrivateKey)
	{
	// Determine which type of private key
	if (aPrivateKey.PrivateKeyType() == EStandard)
		{
		const CRSAPrivateKeyStandard* stdKey = static_cast<const CRSAPrivateKeyStandard*>(&aPrivateKey);
		return KeyConverter::CreateKeyL(*stdKey);
		}
	else if (aPrivateKey.PrivateKeyType() == EStandardCRT)
		{
		const CRSAPrivateKeyCRT* crtKey = static_cast<const CRSAPrivateKeyCRT*>(&aPrivateKey);
		return KeyConverter::CreateKeyL(*crtKey);
		}
	return NULL;  // Keep the compiler happy
	}

// Methods which are not supported or not exposed out of library can be excluded from the coverage.
#ifdef _BullseyeCoverage
#pragma suppress_warnings on
#pragma BullseyeCoverage off
#pragma suppress_warnings off
#endif

CKeyPair* KeyConverter::CreateKeyPairL(const CDSAKeyPair& /*aKeyPair*/)
	{
	return NULL;	
	}

CKeyPair* KeyConverter::CreateKeyPairL(const CRSAKeyPair& aKeyPair)
	{
	CKey* newPrivateKey = KeyConverter::CreateKeyL(aKeyPair.PrivateKey());
	CleanupStack::PushL(newPrivateKey);
	CKey* newPublicKey = KeyConverter::CreateKeyL(aKeyPair.PublicKey());
	CleanupStack::PushL(newPublicKey);
	CKeyPair* newKeyPair = CKeyPair::NewL(newPublicKey, newPrivateKey);
	CleanupStack::Pop(2, newPrivateKey);
	return newKeyPair;
	}

CKeyPair* KeyConverter::CreateKeyPairL(const CDHKeyPair& aKeyPair)
	{
	CKey* newPrivateKey = KeyConverter::CreateKeyL(aKeyPair.PrivateKey());
	CleanupStack::PushL(newPrivateKey);
	CKey* newPublicKey = KeyConverter::CreateKeyL(aKeyPair.PublicKey());
	CleanupStack::PushL(newPublicKey);
	CKeyPair* newKeyPair = CKeyPair::NewL(newPublicKey, newPrivateKey);
	CleanupStack::Pop(2, newPrivateKey);
	return newKeyPair;
	}