/*

* Copyright (c) 2003-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 <asymmetrickeys.h>

#include "rsakeypairshim.h"

#include "../common/inlines.h"

/* CRSAParameters */

EXPORT_C const TInteger& CRSAParameters::N(void) const

	{

	return iN;

	}

EXPORT_C CRSAParameters::~CRSAParameters(void)

	{

	iN.Close();

	}

EXPORT_C CRSAParameters::CRSAParameters(RInteger& aN) : iN(aN)

	{

	}

EXPORT_C CRSAParameters::CRSAParameters(void)

	{

	}

/* CRSAPublicKey */

EXPORT_C CRSAPublicKey* CRSAPublicKey::NewL(RInteger& aN, RInteger& aE)

	{

	CRSAPublicKey* self = NewLC(aN, aE);

	CleanupStack::Pop();

	return self;

	}

EXPORT_C CRSAPublicKey* CRSAPublicKey::NewLC(RInteger& aN, RInteger& aE)

	{

	CRSAPublicKey* self = new(ELeave) CRSAPublicKey(aN, aE);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

void CRSAPublicKey::ConstructL()

	{

	// Check that the modulus and exponent are positive integers 

	// as specified by RSA

	if(!N().IsPositive() || !E().IsPositive() || (E() <= 1))

		{

		// If we need to leave during construction we must release ownership

		// of the RInteger parameters that were passed in.

		// These parameters should be on the cleanup stack so if we don't 

		// release ownership they will be deleted twice, causing a panic

		iN = RInteger();

		iE = RInteger();

		User::Leave(KErrArgument);

		}

	}

EXPORT_C const TInteger& CRSAPublicKey::E(void) const

	{

	return iE;

	}

EXPORT_C CRSAPublicKey::CRSAPublicKey()

	{

	}

EXPORT_C CRSAPublicKey::CRSAPublicKey(RInteger& aN, RInteger& aE)

	: CRSAParameters(aN), iE(aE)

	{

	}

EXPORT_C CRSAPublicKey::~CRSAPublicKey(void)

	{

	iE.Close();

	}

/* CRSAPrivateKeyType */

CRSAPrivateKey::CRSAPrivateKey(const TRSAPrivateKeyType aKeyType, RInteger& aN)

:	CRSAParameters(aN), iKeyType(aKeyType)

{}

/* CRSAPrivateKeyStandard */

EXPORT_C CRSAPrivateKeyStandard* CRSAPrivateKeyStandard::NewL(RInteger& aN, 

	RInteger& aD)

	{

	CRSAPrivateKeyStandard* self = NewLC(aN, aD);

	CleanupStack::Pop();

	return self;

	}

EXPORT_C CRSAPrivateKeyStandard* CRSAPrivateKeyStandard::NewLC(RInteger& aN,

	RInteger& aD)

	{

	CRSAPrivateKeyStandard* self = new(ELeave) CRSAPrivateKeyStandard(aN, aD);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

void CRSAPrivateKeyStandard::ConstructL()

	{

	// Check that the modulus and exponent are positive integers

	if(!N().IsPositive() || !D().IsPositive() || (D() <= 1))

		{

		// If we need to leave during construction we must release ownership

		// of the RInteger parameters that were passed in.

		// These parameters should be on the cleanup stack so if we don't 

		// release ownership they will be deleted twice, causing a panic

		iN = RInteger();

		iD = RInteger();

		User::Leave(KErrArgument);

		}

	}

EXPORT_C const TInteger& CRSAPrivateKeyStandard::D(void) const

	{

	return iD;

	}

EXPORT_C CRSAPrivateKeyStandard::CRSAPrivateKeyStandard(RInteger& aN, 

	RInteger& aD) : CRSAPrivateKey(EStandard, aN), iD(aD)

	{

	}

EXPORT_C CRSAPrivateKeyStandard::~CRSAPrivateKeyStandard()

	{	

	iD.Close();

	}

/* CRSAPrivateKeyCRT */

EXPORT_C CRSAPrivateKeyCRT* CRSAPrivateKeyCRT::NewL(RInteger& aN, RInteger& aP,

	RInteger& aQ, RInteger& aDP, RInteger& aDQ, RInteger& aQInv)

	{

	CRSAPrivateKeyCRT* self = NewLC(aN, aP, aQ, aDP, aDQ, aQInv);

	CleanupStack::Pop();

	return self;

	}

EXPORT_C CRSAPrivateKeyCRT* CRSAPrivateKeyCRT::NewLC(RInteger& aN, RInteger& aP, 

	RInteger& aQ, RInteger& aDP, RInteger& aDQ, RInteger& aQInv)

	{

	CRSAPrivateKeyCRT* self = new(ELeave) CRSAPrivateKeyCRT(aN, aP, aQ, 

		aDP, aDQ, aQInv);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

EXPORT_C CRSAPrivateKeyCRT::CRSAPrivateKeyCRT(RInteger& aN, RInteger& aP, 

	RInteger& aQ, RInteger& aDP, RInteger& aDQ, RInteger& aQInv) 

	: CRSAPrivateKey(EStandardCRT, aN), iP(aP), iQ(aQ), iDP(aDP), iDQ(aDQ), 

		iQInv(aQInv)

	{

	}

void CRSAPrivateKeyCRT::ConstructL()

	{

	// Check that all parameters are positive integers

	if(!P().IsPositive() || !Q().IsPositive() || !DP().IsPositive() 

		|| !DQ().IsPositive() || !QInv().IsPositive())

		{

		// If we need to leave during construction we must release ownership

		// of the RInteger parameters that were passed in.

		// These parameters should be on the cleanup stack so if we don't 

		// release ownership they will be deleted twice, causing a panic

		iN = RInteger();

		iP = RInteger();

		iQ = RInteger();

		iDP = RInteger();

		iDQ = RInteger();

		iQInv = RInteger();

		User::Leave(KErrArgument);

		}

	}

EXPORT_C CRSAPrivateKeyCRT::~CRSAPrivateKeyCRT()

	{	

	iP.Close();

	iQ.Close();

	iDP.Close();

	iDQ.Close();

	iQInv.Close();

	}

EXPORT_C const TInteger& CRSAPrivateKeyCRT::P(void) const

	{

	return iP;

	}

EXPORT_C const TInteger& CRSAPrivateKeyCRT::Q(void) const

	{

	return iQ;

	}

EXPORT_C const TInteger& CRSAPrivateKeyCRT::DP(void) const

	{

	return iDP;

	}

EXPORT_C const TInteger& CRSAPrivateKeyCRT::DQ(void) const

	{

	return iDQ;

	}

EXPORT_C const TInteger& CRSAPrivateKeyCRT::QInv(void) const

	{

	return iQInv;

	}

/* CRSAKeyPair */

EXPORT_C CRSAKeyPair* CRSAKeyPair::NewL(TUint aModulusBits, 

	TRSAPrivateKeyType aKeyType /*= EStandardCRT*/)

	{

	CRSAKeyPairShim* self = CRSAKeyPairShim::NewLC(aModulusBits, aKeyType);

	CleanupStack::Pop();

	return self;

	}

EXPORT_C CRSAKeyPair* CRSAKeyPair::NewLC(TUint aModulusBits, 

	TRSAPrivateKeyType aKeyType /*= EStandardCRT*/)

	{

	CRSAKeyPairShim* self = CRSAKeyPairShim::NewLC(aModulusBits, aKeyType);

	return self;

	}

EXPORT_C const CRSAPublicKey& CRSAKeyPair::PublicKey(void) const

	{

	return *iPublic;

	}

EXPORT_C const CRSAPrivateKey& CRSAKeyPair::PrivateKey(void) const

	{

	return *iPrivate;

	}

EXPORT_C CRSAKeyPair::~CRSAKeyPair(void)

	{

	delete iPublic;

	delete iPrivate;

	}

EXPORT_C CRSAKeyPair::CRSAKeyPair(void)

	{

	}