/*

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

#include <bigint.h>

#include <cryptospi/cryptokeypairgeneratorapi.h>

#include <cryptospi/keypair.h>

#include <cryptospi/cryptoparams.h>

#include <cryptospi/cryptospidef.h>

using namespace CryptoSpi;

/* CDHKeyPair */

CDHKeyPairShim* CDHKeyPairShim::NewLC(RInteger& aN, RInteger& aG)

	{

	CDHKeyPairShim* self = new(ELeave) CDHKeyPairShim();

	CleanupStack::PushL(self);

	self->ConstructL(aN, aG);

	return self;

	}

CDHKeyPairShim* CDHKeyPairShim::NewLC(RInteger& aN, RInteger& aG, RInteger& ax)

	{

	CDHKeyPairShim* self = new(ELeave) CDHKeyPairShim();

	CleanupStack::PushL(self);

	self->ConstructL(aN, aG, ax);

	return self;

	}

CDHKeyPairShim::~CDHKeyPairShim(void)

	{

	}

CDHKeyPairShim::CDHKeyPairShim(void)

	{

	}	

void CDHKeyPairShim::ConstructL(RInteger& aN, RInteger& aG)

	{

	RInteger x = RInteger::NewL();

	CleanupClosePushL(x);

	KeyConstructorL(aN, aG, x, EFalse);

	CleanupStack::PopAndDestroy(1, &x);

	}

void CDHKeyPairShim::ConstructL(RInteger& aN, RInteger& aG, RInteger& ax)

	{

	KeyConstructorL(aN, aG, ax, ETrue);

	}

void CDHKeyPairShim::KeyConstructorL(RInteger& aN, RInteger& aG, RInteger& ax, TBool xIncluded)

	{

	RInteger& nminus2 = aN;

	/*

	 * do some sanity checks

	 */

	--nminus2;

	--nminus2;

	if( aG < TInteger::Two() || aG > nminus2 )

		{

		User::Leave(KErrArgument);

		}

	if (xIncluded)

		{

		if( ax < TInteger::One() || ax > nminus2 )

			{

			User::Leave(KErrArgument);

			}

		}

	/*

	 *find out how big the key should be - the key must be in the range x | 1 <= x <= n-2

	 * nminus2 is the largest the key can be so get the number of bits required to represent that number

	 */

	const TInt keySize = nminus2.BitCount();

	// increment aN back to its original value

	++nminus2;

	++nminus2;

	// obtain an RSA key pair generator interface

	CKeyPairGenerator* keyPairGeneratorImpl=NULL;

	CKeyPairGeneratorFactory::CreateKeyPairGeneratorL(

											keyPairGeneratorImpl,

											KDHKeyPairGeneratorUid,

											NULL);

	CleanupStack::PushL(keyPairGeneratorImpl);

	/* 

	 * put the DH parameters into an array

	 */

	CCryptoParams* keyParameters = CCryptoParams::NewLC();

	keyParameters->AddL(aN, KDhKeyParameterNUid);

	keyParameters->AddL(aG, KDhKeyParameterGUid);

	if (xIncluded)

		{

		// the private key x has been supplied so add it to the params array so the key generator algo can use it

		keyParameters->AddL(ax, KDhKeyParameterxUid);

		ax.Close();

		}

	/* 

	 * call the api to create a DH key pair

	 */

	CKeyPair* keyPair = 0;

	keyPairGeneratorImpl->GenerateKeyPairL(keySize, *keyParameters, keyPair);

	CleanupStack::PushL(keyPair);

	/* 

	 * for compatibility convert the CKeyPair to CDHPrivateKey and CDHPublicKey

	 */

	// create new RInteger copies of aN, aG and x so the private key can own them

	RInteger NCopy = RInteger::NewL(aN);

	CleanupClosePushL(NCopy);

	RInteger GCopy = RInteger::NewL(aG);

	CleanupClosePushL(GCopy);

	RInteger x = RInteger::NewL(keyPair->PrivateKey().GetBigIntL(KDhKeyParameterxUid));

	CleanupClosePushL(x);

	iPrivate = CDHPrivateKey::NewL(NCopy, GCopy, x);

	CleanupStack::Pop(3, &NCopy);

	// the public key becomes the owner of aN, aG and X

	RInteger X = RInteger::NewL(keyPair->PublicKey().GetBigIntL(KDhKeyParameterXUid));

	CleanupClosePushL(X);

	iPublic = CDHPublicKey::NewL(aN, aG, X);

	CleanupStack::Pop(&X);	

	/* 

	 * cleanup stack - it should contain keyPairGeneratorImpl, keyParameters, keyPair, X, NCopy, GCopy and x

	 */	

	CleanupStack::PopAndDestroy(3, keyPairGeneratorImpl);

	}