--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/asymmetric/rsakeys.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,271 @@
+/*
+* 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)
+	{
+	}
+